X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Frrd_graph.c;h=1e1488e54cf61d5f99675cd89d70b259385a1146;hb=c2add7c35c88043958aebc64851b7b953adf305f;hp=313c518369aa1c4fc63c98f6a2ecba86695a52f1;hpb=89b4e542ae2e10695233c8a4664ba8e0924bf231;p=rrdtool.git

diff --git a/src/rrd_graph.c b/src/rrd_graph.c
index 313c518..1e1488e 100644
--- a/src/rrd_graph.c
+++ b/src/rrd_graph.c
@@ -4,7 +4,10 @@
  * rrd__graph.c  make creates ne rrds
  ****************************************************************************/
 
+#if 0
 #include "rrd_tool.h"
+#endif
+
 #include <gd.h>
 #include <gdlucidan10.h>
 #include <gdlucidab12.h>
@@ -13,7 +16,9 @@
 #include <io.h>
 #include <fcntl.h>
 #endif
-#include "rrd_rpncalc.h"
+
+#include "rrd_graph.h"
+#include "rrd_graph_helper.h"
 
 #define SmallFont gdLucidaNormal10
 #define LargeFont gdLucidaBold12
@@ -26,56 +31,6 @@
 # define DPRINT(x)
 #endif
 
-#define DEF_NAM_FMT "%29[_A-Za-z0-9]"
-
-enum tmt_en {TMT_SECOND=0,TMT_MINUTE,TMT_HOUR,TMT_DAY,
-	     TMT_WEEK,TMT_MONTH,TMT_YEAR};
-
-enum grc_en {GRC_CANVAS=0,GRC_BACK,GRC_SHADEA,GRC_SHADEB,
-	     GRC_GRID,GRC_MGRID,GRC_FONT,GRC_FRAME,GRC_ARROW,__GRC_END__};
-
-
-enum gf_en {GF_PRINT=0,GF_GPRINT,GF_COMMENT,GF_HRULE,GF_VRULE,GF_LINE1,
-	    GF_LINE2,GF_LINE3,GF_AREA,GF_STACK,GF_TICK,
-	    GF_DEF, GF_CDEF, GF_VDEF};
-
-enum if_en {IF_GIF=0,IF_PNG=1};
-
-enum vdef_op_en {
-		 VDEF_MAXIMUM	/* like the MAX in (G)PRINT */
-		,VDEF_MINIMUM	/* like the MIN in (G)PRINT */
-		,VDEF_AVERAGE	/* like the AVERAGE in (G)PRINT */
-		,VDEF_PERCENT	/* Nth percentile */
-		,VDEF_FIRST	/* first non-unknown value and time */
-		,VDEF_LAST	/* last  non-unknown value and time */
-		};
-typedef struct vdef_t {
-    enum vdef_op_en	op;
-    double		param;	/* parameter for function, if applicable */
-    double		val;	/* resulting value */
-    time_t		when;	/* timestamp, if applicable */
-} vdef_t;
-
-typedef struct col_trip_t {
-    int red; /* red = -1 is no color */
-    int green;
-    int blue;
-    int i; /* color index assigned in gif image i=-1 is unasigned*/
-} col_trip_t;
-
-
-typedef struct xlab_t {
-    long         minsec;       /* minimum sec per pix */
-    enum tmt_en  gridtm;       /* grid interval in what ?*/
-    long         gridst;       /* how many whats per grid*/
-    enum tmt_en  mgridtm;      /* label interval in what ?*/
-    long         mgridst;      /* how many whats per label*/
-    enum tmt_en  labtm;        /* label interval in what ?*/
-    long         labst;        /* how many whats per label*/
-    long         precis;       /* label precision -> label placement*/
-    char         *stst;        /* strftime string*/
-} xlab_t;
-
 xlab_t xlab[] = {
     {0,        TMT_SECOND,30, TMT_MINUTE,5,  TMT_MINUTE,5,         0,"%H:%M"},
     {2,        TMT_MINUTE,1,  TMT_MINUTE,5,  TMT_MINUTE,5,         0,"%H:%M"},
@@ -110,11 +65,6 @@ double yloglab[][12]= {{ 1e9, 1,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0 },
 
 /* sensible y label intervals ...*/
 
-typedef struct ylab_t {
-    double   grid;    /* grid spacing */
-    int      lfac[4]; /* associated label spacing*/
-} ylab_t;
-
 ylab_t ylab[]= {
     {0.1, {1,2, 5,10}},
     {0.2, {1,5,10,20}},
@@ -144,133 +94,6 @@ col_trip_t graph_col[] = { /* default colors */
     {255,0,0,-1}	/*arrow*/
 };
 
-/* this structure describes the elements which can make up a graph.
-   because they are quite diverse, not all elements will use all the
-   possible parts of the structure. */
-#ifdef HAVE_SNPRINTF
-#define FMT_LEG_LEN 200
-#else
-#define FMT_LEG_LEN 2000
-#endif
-
-typedef  struct graph_desc_t {
-    enum gf_en     gf;         /* graphing function */
-    char           vname[30];  /* name of the variable */
-    long           vidx;       /* gdes reference */
-    char           rrd[255];   /* name of the rrd_file containing data */
-    char           ds_nam[DS_NAM_SIZE]; /* data source name */
-    long           ds;         /* data source number */
-    enum cf_en     cf;         /* consolidation function */
-    col_trip_t     col;        /* graph color */
-    char           format[FMT_LEG_LEN+5]; /* format for PRINT AND GPRINT */
-    char           legend[FMT_LEG_LEN+5]; /* legend*/
-    gdPoint        legloc;     /* location of legend */   
-    double         yrule;      /* value for y rule line and for VDEF */
-    time_t         xrule;      /* time for x rule line and for VDEF */
-    vdef_t         vf;         /* instruction for VDEF function */
-    rpnp_t         *rpnp;     /* instructions for CDEF function */
-
-    /* description of data fetched for the graph element */
-    time_t         start,end; /* timestaps for first and last data element */
-    unsigned long  step;      /* time between samples */
-    unsigned long  ds_cnt; /* how many data sources are there in the fetch */
-    long           data_first; /* first pointer to this data */
-    char           **ds_namv; /* name of datasources  in the fetch. */
-    rrd_value_t    *data; /* the raw data drawn from the rrd */
-    rrd_value_t    *p_data; /* processed data, xsize elments */
-
-} graph_desc_t;
-
-#define ALTYGRID          0x01  /* use alternative y grid algorithm */
-#define ALTAUTOSCALE      0x02  /* use alternative algorithm to find lower and upper bounds */
-#define ALTAUTOSCALE_MAX  0x04  /* use alternative algorithm to find upper bounds */
-#define NOLEGEND          0x08  /* use no legend */
-
-typedef struct image_desc_t {
-
-    /* configuration of graph */
-
-    char           graphfile[MAXPATH]; /* filename for graphic */
-    long           xsize,ysize;    /* graph area size in pixels */
-    col_trip_t     graph_col[__GRC_END__]; /* real colors for the graph */   
-    char           ylegend[200];   /* legend along the yaxis */
-    char           title[200];     /* title for graph */
-    int            draw_x_grid;      /* no x-grid at all */
-    int            draw_y_grid;      /* no x-grid at all */
-    xlab_t         xlab_user;      /* user defined labeling for xaxis */
-    char           xlab_form[200]; /* format for the label on the xaxis */
-
-    double         ygridstep;      /* user defined step for y grid */
-    int            ylabfact;       /* every how many y grid shall a label be written ? */
-
-    time_t         start,end;      /* what time does the graph cover */
-    unsigned long           step;           /* any preference for the default step ? */
-    rrd_value_t    minval,maxval;  /* extreme values in the data */
-    int            rigid;          /* do not expand range even with 
-				      values outside */
-    char*          imginfo;         /* construct an <IMG ... tag and return 
-				      as first retval */
-    int            lazy;           /* only update the gif if there is reasonable
-				      probablility that the existing one is out of date */
-    int            logarithmic;    /* scale the yaxis logarithmic */
-    enum if_en     imgformat;         /* image format */
-    
-    /* status information */
-    	    
-    long           xorigin,yorigin;/* where is (0,0) of the graph */
-    long           xgif,ygif;      /* total size of the gif */
-    int            interlaced;     /* will the graph be interlaced? */
-    double         magfact;        /* numerical magnitude*/
-    long         base;            /* 1000 or 1024 depending on what we graph */
-    char           symbol;         /* magnitude symbol for y-axis */
-    int            unitsexponent;    /* 10*exponent for units on y-asis */
-    int            extra_flags;    /* flags for boolean options */
-    /* data elements */
-
-    long  prt_c;                  /* number of print elements */
-    long  gdes_c;                  /* number of graphics elements */
-    graph_desc_t   *gdes;          /* points to an array of graph elements */
-
-} image_desc_t;
-
-/* Prototypes */
-int xtr(image_desc_t *,time_t);
-int ytr(image_desc_t *, double);
-enum gf_en gf_conv(char *);
-enum if_en if_conv(char *);
-enum tmt_en tmt_conv(char *);
-enum grc_en grc_conv(char *);
-int im_free(image_desc_t *);
-void auto_scale( image_desc_t *,  double *, char **, double *);
-void si_unit( image_desc_t *);
-void expand_range(image_desc_t *);
-void reduce_data( enum cf_en,  unsigned long,  time_t *, time_t *,  unsigned long *,  unsigned long *,  rrd_value_t **);
-int data_fetch( image_desc_t *);
-long find_var(image_desc_t *, char *);
-long find_var_wrapper(void *arg1, char *key);
-long lcd(long *);
-int data_calc( image_desc_t *);
-int data_proc( image_desc_t *);
-time_t find_first_time( time_t,  enum tmt_en,  long);
-time_t find_next_time( time_t,  enum tmt_en,  long);
-void gator( gdImagePtr, int, int);
-int print_calc(image_desc_t *, char ***);
-int leg_place(image_desc_t *);
-int horizontal_grid(gdImagePtr, image_desc_t *);
-int horizontal_log_grid(gdImagePtr, image_desc_t *);
-void vertical_grid( gdImagePtr, image_desc_t *);
-void axis_paint( image_desc_t *, gdImagePtr);
-void grid_paint( image_desc_t *, gdImagePtr);
-gdImagePtr MkLineBrush(image_desc_t *,long, enum gf_en);
-int lazy_check(image_desc_t *);
-int graph_paint(image_desc_t *, char ***);
-int gdes_alloc(image_desc_t *);
-int scan_for_col(char *, int, char *);
-int rrd_graph(int, char **, char ***, int *, int *);
-int bad_format(char *);
-int vdef_parse(struct graph_desc_t *,char *);
-int vdef_calc(image_desc_t *, int);
-int vdef_percent_compar(const void *,const void *);
 
 /* translate time values into x coordinates */   
 /*#define xtr(x) (int)((double)im->xorigin \
@@ -326,8 +149,6 @@ ytr(image_desc_t *im, double value){
     } 
 }
 
-   
-    
 
 
 /* conversion function for symbolic entry names */
@@ -427,7 +248,7 @@ auto_scale(
 	   )
 {
 	
-    char *symbol[] = {"a", /* 10e-18 Ato */
+    char *symbol[] = {"a", /* 10e-18 Atto */
 		      "f", /* 10e-15 Femto */
 		      "p", /* 10e-12 Pico */
 		      "n", /* 10e-9  Nano */
@@ -437,7 +258,7 @@ auto_scale(
 		      "k", /* 10e3   Kilo */
 		      "M", /* 10e6   Mega */
 		      "G", /* 10e9   Giga */
-		      "T", /* 10e12  Terra */
+		      "T", /* 10e12  Tera */
 		      "P", /* 10e15  Peta */
 		      "E"};/* 10e18  Exa */
 
@@ -468,7 +289,7 @@ si_unit(
 )
 {
 
-    char symbol[] = {'a', /* 10e-18 Ato */ 
+    char symbol[] = {'a', /* 10e-18 Atto */ 
 		     'f', /* 10e-15 Femto */
 		     'p', /* 10e-12 Pico */
 		     'n', /* 10e-9  Nano */
@@ -478,7 +299,7 @@ si_unit(
 		     'k', /* 10e3   Kilo */
 		     'M', /* 10e6   Mega */
 		     'G', /* 10e9   Giga */
-		     'T', /* 10e12  Terra */
+		     'T', /* 10e12  Tera */
 		     'P', /* 10e15  Peta */
 		     'E'};/* 10e18  Exa */
 
@@ -612,60 +433,68 @@ reduce_data(
     (*step) = cur_step*reduce_factor; /* set new step size for reduced data */
     dstptr = *data;
     srcptr = *data;
+    row_cnt = ((*end)-(*start))/cur_step;
 
-    /* We were given one extra row at the beginning of the interval.
-    ** We also need to return one extra row.  The extra interval is
-    ** the one defined by the start time in both cases.  It is not
-    ** used when graphing but maybe we can use it while reducing the
-    ** data.
-    */
-    row_cnt = ((*end)-(*start))/cur_step +1;
+#ifdef DEBUG
+#define DEBUG_REDUCE
+#endif
+#ifdef DEBUG_REDUCE
+printf("Reducing %lu rows with factor %i time %lu to %lu, step %lu\n",
+			row_cnt,reduce_factor,*start,*end,cur_step);
+for (col=0;col<row_cnt;col++) {
+    printf("time %10lu: ",*start+(col+1)*cur_step);
+    for (i=0;i<*ds_cnt;i++)
+	printf(" %8.2e",srcptr[*ds_cnt*col+i]);
+    printf("\n");
+}
+#endif
 
-    /* alter start and end so that they are multiples of the new steptime.
-    ** End will be shifted towards the future and start will be shifted
-    ** towards the past in order to include the requested interval
-    */ 
+    /* We have to combine [reduce_factor] rows of the source
+    ** into one row for the destination.  Doing this we also
+    ** need to take care to combine the correct rows.  First
+    ** alter the start and end time so that they are multiples
+    ** of the new step time.  We cannot reduce the amount of
+    ** time so we have to move the end towards the future and
+    ** the start towards the past.
+    */
     end_offset = (*end) % (*step);
-    if (end_offset) end_offset = (*step)-end_offset;
     start_offset = (*start) % (*step);
-    (*end) = (*end)+end_offset;
-    (*start) = (*start)-start_offset;
 
-    /* The first destination row is unknown yet it still needs
-    ** to be present in the returned data.  Skip it.
-    ** Don't make it NaN or we might overwrite the source.
-    */
-    dstptr += (*ds_cnt);
-
-    /* Depending on the amount of extra data needed at the
-    ** start of the destination, three things can happen:
-    ** -1- start_offset == 0:  skip the extra source row
-    ** -2- start_offset == cur_step: do nothing
-    ** -3- start_offset > cur_step: skip some source rows and 
-    **                      fill one destination row with NaN
+    /* If there is a start offset (which cannot be more than
+    ** one destination row), skip the appropriate number of
+    ** source rows and one destination row.  The appropriate
+    ** number is what we do know (start_offset/cur_step) of
+    ** the new interval (*step/cur_step aka reduce_factor).
     */
-    if (start_offset==0) {
-	srcptr+=(*ds_cnt);
-	row_cnt--;
-    } else if (start_offset!=cur_step) {
-	skiprows=((*step)-start_offset)/cur_step+1;
-	srcptr += ((*ds_cnt)*skiprows);
+#ifdef DEBUG_REDUCE
+printf("start_offset: %lu  end_offset: %lu\n",start_offset,end_offset);
+printf("row_cnt before:  %lu\n",row_cnt);
+#endif
+    if (start_offset) {
+	(*start) = (*start)-start_offset;
+	skiprows=reduce_factor-start_offset/cur_step;
+	srcptr+=skiprows* *ds_cnt;
+        for (col=0;col<(*ds_cnt);col++) *dstptr++ = DNAN;
 	row_cnt-=skiprows;
-	for (col=0;col<(*ds_cnt);col++) *dstptr++=DNAN;
     }
+#ifdef DEBUG_REDUCE
+printf("row_cnt between: %lu\n",row_cnt);
+#endif
 
-    /* If we had to alter the endtime, there won't be
-    ** enough data to fill the last row.  This means
-    ** we have to skip some rows at the end
+    /* At the end we have some rows that are not going to be
+    ** used, the amount is end_offset/cur_step
     */
     if (end_offset) {
-	skiprows = ((*step)-end_offset)/cur_step;
+	(*end) = (*end)-end_offset+(*step);
+	skiprows = end_offset/cur_step;
 	row_cnt-=skiprows;
     }
-
+#ifdef DEBUG_REDUCE
+printf("row_cnt after:   %lu\n",row_cnt);
+#endif
 
 /* Sanity check: row_cnt should be multiple of reduce_factor */
-/* if this gets triggered, something is REALY WRONG ... we die immediately */
+/* if this gets triggered, something is REALLY WRONG ... we die immediately */
 
     if (row_cnt%reduce_factor) {
 	printf("SANITY CHECK: %lu rows cannot be reduced by %i \n",
@@ -733,11 +562,22 @@ reduce_data(
 	srcptr+=(*ds_cnt)*reduce_factor;
 	row_cnt-=reduce_factor;
     }
-
     /* If we had to alter the endtime, we didn't have enough
     ** source rows to fill the last row. Fill it with NaN.
     */
-    if (end_offset!=0) for (col=0;col<(*ds_cnt);col++) *dstptr++ = DNAN;
+    if (end_offset) for (col=0;col<(*ds_cnt);col++) *dstptr++ = DNAN;
+#ifdef DEBUG_REDUCE
+    row_cnt = ((*end)-(*start))/ *step;
+    srcptr = *data;
+    printf("Done reducing. Currently %lu rows, time %lu to %lu, step %lu\n",
+				row_cnt,*start,*end,*step);
+for (col=0;col<row_cnt;col++) {
+    printf("time %10lu: ",*start+(col+1)*(*step));
+    for (i=0;i<*ds_cnt;i++)
+	printf(" %8.2e",srcptr[*ds_cnt*col+i]);
+    printf("\n");
+}
+#endif
 }
 
 
@@ -907,11 +747,6 @@ data_calc( image_desc_t *im){
 		/* Find the variables in the expression.
 		 * - VDEF variables are substituted by their values
 		 *   and the opcode is changed into OP_NUMBER.
-******************
-* Note to Jake: I cannot oversee the implications for your
-* COMPUTE DS stuff.  Please check if VDEF and COMPUTE are
-* compatible (or can be made so).
-******************
 		 * - CDEF variables are analized for their step size,
 		 *   the lowest common denominator of all the step
 		 *   sizes of the data sources involved is calculated
@@ -956,8 +791,7 @@ printf("DEBUG: value from vdef is %f\n",im->gdes[ptr].vf.val);
 			     * further save step size and data source
 			     * count of this rra
 			     */ 
-			    im->gdes[gdi].rpnp[rpi].data = 
-					im->gdes[ptr].data + im->gdes[ptr].ds; 
+			    im->gdes[gdi].rpnp[rpi].data = im->gdes[ptr].data; 
 			    im->gdes[gdi].rpnp[rpi].step = im->gdes[ptr].step;
 			    im->gdes[gdi].rpnp[rpi].ds_cnt = im->gdes[ptr].ds_cnt;
 
@@ -965,7 +799,6 @@ printf("DEBUG: value from vdef is %f\n",im->gdes[ptr].vf.val);
 			     * rpncalc() function doesn't have to treat
 			     * the first case differently
 			     */
-			    im->gdes[gdi].rpnp[rpi].data-=im->gdes[ptr].ds_cnt;
 			} /* if ds_cnt != 0 */
 		    } /* if OP_VARIABLE */
 		} /* loop through all rpi */
@@ -984,7 +817,7 @@ printf("DEBUG: value from vdef is %f\n",im->gdes[ptr].vf.val);
 		free(steparray);
 		if((im->gdes[gdi].data = malloc((
 				(im->gdes[gdi].end-im->gdes[gdi].start) 
-				    / im->gdes[gdi].step +1)
+				    / im->gdes[gdi].step)
 				    * sizeof(double)))==NULL){
 		    rrd_set_error("malloc im->gdes[gdi].data");
 		    rpnstack_free(&rpnstack);
@@ -994,7 +827,7 @@ printf("DEBUG: value from vdef is %f\n",im->gdes[ptr].vf.val);
 		/* Step through the new cdef results array and
 		 * calculate the values
 		 */
-		for (now = im->gdes[gdi].start;
+		for (now = im->gdes[gdi].start + im->gdes[gdi].step;
 				now<=im->gdes[gdi].end;
 				now += im->gdes[gdi].step)
 		{
@@ -1068,15 +901,11 @@ data_proc( image_desc_t *im ){
 
 		value =
 		    im->gdes[vidx].data[
-					((unsigned long)floor((double)
-							     (gr_time - im->gdes[vidx].start ) 
-							     / im->gdes[vidx].step)+1)			
-
-					/* added one because data was not being aligned properly
-					   this fixes it. We may also be having a problem in fetch ... */
-
-					*im->gdes[vidx].ds_cnt
-					+im->gdes[vidx].ds];
+			((unsigned long)floor(
+	(double)(gr_time-im->gdes[vidx].start) / im->gdes[vidx].step
+					     )
+                        )	*im->gdes[vidx].ds_cnt
+				+im->gdes[vidx].ds];
 
 		if (! isnan(value)) {
 		  paintval += value;
@@ -1286,6 +1115,7 @@ print_calc(image_desc_t *im, char ***prdata)
 {
     long i,ii,validsteps;
     double printval;
+    time_t printtime;
     int graphelement = 0;
     long vidx;
     int max_ii;	
@@ -1309,7 +1139,8 @@ print_calc(image_desc_t *im, char ***prdata)
 	     */
 	    vidx = im->gdes[i].vidx;
 	    if (im->gdes[vidx].gf==GF_VDEF) { /* simply use vals */
-		printval = im->gdes[vidx].yrule;
+		printval = im->gdes[vidx].vf.val;
+		printtime = im->gdes[vidx].vf.when;
 	    } else { /* need to calculate max,min,avg etcetera */
 		max_ii =((im->gdes[vidx].end 
 			- im->gdes[vidx].start)
@@ -1317,8 +1148,8 @@ print_calc(image_desc_t *im, char ***prdata)
 			* im->gdes[vidx].ds_cnt);
 		printval = DNAN;
 		validsteps = 0;
-		for(ii=im->gdes[vidx].ds+im->gdes[vidx].ds_cnt;
-			ii < max_ii+im->gdes[vidx].ds_cnt;
+		for(	ii=im->gdes[vidx].ds;
+			ii < max_ii;
 			ii+=im->gdes[vidx].ds_cnt){
 		    if (! finite(im->gdes[vidx].data[ii]))
 			continue;
@@ -1355,7 +1186,18 @@ print_calc(image_desc_t *im, char ***prdata)
 		}
 	    } /* prepare printval */
 
-
+	    if (!strcmp(im->gdes[i].format,"%c")) { /* VDEF time print */
+		if (im->gdes[i].gf == GF_PRINT){
+		    (*prdata)[prlines-2] = malloc((FMT_LEG_LEN+2)*sizeof(char));
+		    sprintf((*prdata)[prlines-2],"%s (%lu)",
+					ctime(&printtime),printtime);
+		    (*prdata)[prlines-1] = NULL;
+		} else {
+		    sprintf(im->gdes[i].legend,"%s (%lu)",
+					ctime(&printtime),printtime);
+		    graphelement = 1;
+		}
+	    } else {
 	    if ((percent_s = strstr(im->gdes[i].format,"%S")) != NULL) {
 		/* Magfact is set to -1 upon entry to print_calc.  If it
 		 * is still less than 0, then we need to run auto_scale.
@@ -1400,6 +1242,7 @@ print_calc(image_desc_t *im, char ***prdata)
 #endif
 		graphelement = 1;
 	    }
+	    }
 	    break;
         case GF_COMMENT:
 	case GF_LINE1:
@@ -2356,7 +2199,6 @@ graph_paint(image_desc_t *im, char ***calcpr)
         
 	switch(im->gdes[i].gf){
 	case GF_HRULE:
-printf("DEBUG: HRULE at %f\n",im->gdes[i].yrule);
 	    if(isnan(im->gdes[i].yrule)) { /* fetch variable */
 		im->gdes[i].yrule = im->gdes[im->gdes[i].vidx].vf.val;
 	    };
@@ -2475,58 +2317,121 @@ scan_for_col(char *input, int len, char *output)
     return inp;
 }
 
+/* Some surgery done on this function, it became ridiculously big.
+** Things moved:
+** - initializing     now in rrd_graph_init()
+** - options parsing  now in rrd_graph_options()
+** - script parsing   now in rrd_graph_script()
+*/
 int 
 rrd_graph(int argc, char **argv, char ***prdata, int *xsize, int *ysize)
 {
-    
     image_desc_t   im;
-    int            i;
-    long           long_tmp;
-    time_t	   start_tmp=0,end_tmp=0;
-    char           scan_gtm[12],scan_mtm[12],scan_ltm[12],col_nam[12];
-    char           symname[100];
-    unsigned int            col_red,col_green,col_blue;
-    long           scancount;
-    int linepass = 0; /* stack can only follow directly after LINE* AREA or STACK */    
-    struct time_value start_tv, end_tv;
-    char *parsetime_error = NULL;
-    int stroff;    
+
+    rrd_graph_init(&im);
+
+    rrd_graph_options(argc,argv,&im);
+    if (rrd_test_error()) return -1;
+    
+    if (strlen(argv[optind])>=MAXPATH) {
+	rrd_set_error("filename (including path) too long");
+	return -1;
+    }
+    strncpy(im.graphfile,argv[optind],MAXPATH-1);
+    im.graphfile[MAXPATH-1]='\0';
+
+    rrd_graph_script(argc,argv,&im);
+    if (rrd_test_error()) return -1;
+
+    /* Everything is now read and the actual work can start */
 
     (*prdata)=NULL;
+    if (graph_paint(&im,prdata)==-1){
+	im_free(&im);
+	return -1;
+    }
 
-    parsetime("end-24h", &start_tv);
-    parsetime("now", &end_tv);
+    /* The image is generated and needs to be output.
+    ** Also, if needed, print a line with information about the image.
+    */
+
+    *xsize=im.xgif;
+    *ysize=im.ygif;
+    if (im.imginfo) {
+	char *filename;
+	if (!(*prdata)) {
+	    /* maybe prdata is not allocated yet ... lets do it now */
+	    if ((*prdata = calloc(2,sizeof(char *)))==NULL) {
+		rrd_set_error("malloc imginfo");
+		return -1; 
+	    };
+	}
+	if(((*prdata)[0] = malloc((strlen(im.imginfo)+200+strlen(im.graphfile))*sizeof(char)))
+	 ==NULL){
+	    rrd_set_error("malloc imginfo");
+	    return -1;
+	}
+	filename=im.graphfile+strlen(im.graphfile);
+	while(filename > im.graphfile) {
+	    if (*(filename-1)=='/' || *(filename-1)=='\\' ) break;
+	    filename--;
+	}
 
-    im.xlab_user.minsec = -1;
-    im.xgif=0;
-    im.ygif=0;
-    im.xsize = 400;
-    im.ysize = 100;
-    im.step = 0;
-    im.ylegend[0] = '\0';
-    im.title[0] = '\0';
-    im.minval = DNAN;
-    im.maxval = DNAN;    
-    im.interlaced = 0;
-    im.unitsexponent= 9999;
-    im.extra_flags= 0;
-    im.rigid = 0;
-    im.imginfo = NULL;
-    im.lazy = 0;
-    im.logarithmic = 0;
-    im.ygridstep = DNAN;
-    im.draw_x_grid = 1;
-    im.draw_y_grid = 1;
-    im.base = 1000;
-    im.prt_c = 0;
-    im.gdes_c = 0;
-    im.gdes = NULL;
-    im.imgformat = IF_GIF; /* we default to GIF output */
+	sprintf((*prdata)[0],im.imginfo,filename,im.xgif,im.ygif);
+    }
+    im_free(&im);
+    return 0;
+}
+
+void
+rrd_graph_init(image_desc_t *im)
+{
+    int i;
+
+    im->xlab_user.minsec = -1;
+    im->xgif=0;
+    im->ygif=0;
+    im->xsize = 400;
+    im->ysize = 100;
+    im->step = 0;
+    im->ylegend[0] = '\0';
+    im->title[0] = '\0';
+    im->minval = DNAN;
+    im->maxval = DNAN;    
+    im->interlaced = 0;
+    im->unitsexponent= 9999;
+    im->extra_flags= 0;
+    im->rigid = 0;
+    im->imginfo = NULL;
+    im->lazy = 0;
+    im->logarithmic = 0;
+    im->ygridstep = DNAN;
+    im->draw_x_grid = 1;
+    im->draw_y_grid = 1;
+    im->base = 1000;
+    im->prt_c = 0;
+    im->gdes_c = 0;
+    im->gdes = NULL;
+    im->imgformat = IF_GIF; /* we default to GIF output */
 
     for(i=0;i<DIM(graph_col);i++)
-	im.graph_col[i].red=-1;
-    
-    
+	im->graph_col[i].red=-1;
+}
+
+void
+rrd_graph_options(int argc, char *argv[],image_desc_t *im)
+{
+    int			stroff;    
+    char		*parsetime_error = NULL;
+    char		scan_gtm[12],scan_mtm[12],scan_ltm[12],col_nam[12];
+    time_t		start_tmp=0,end_tmp=0;
+    long		long_tmp;
+    struct time_value	start_tv, end_tv;
+    unsigned int	col_red,col_green,col_blue;
+
+    parsetime("end-24h", &start_tv);
+    parsetime("now", &end_tv);
+
     while (1){
 	static struct option long_options[] =
 	{
@@ -2558,7 +2463,7 @@ rrd_graph(int argc, char **argv, char ***prdata, int *xsize, int *ysize)
 	int option_index = 0;
 	int opt;
 
-	
+
 	opt = getopt_long(argc, argv, 
 			  "s:e:x:y:v:w:h:iu:l:rb:oc:t:f:a:z:g",
 			  long_options, &option_index);
@@ -2568,147 +2473,147 @@ rrd_graph(int argc, char **argv, char ***prdata, int *xsize, int *ysize)
 	
 	switch(opt) {
 	case 257:
-	    im.extra_flags |= ALTYGRID;
+	    im->extra_flags |= ALTYGRID;
 	    break;
 	case 258:
-	    im.extra_flags |= ALTAUTOSCALE;
+	    im->extra_flags |= ALTAUTOSCALE;
 	    break;
 	case 259:
-	    im.extra_flags |= ALTAUTOSCALE_MAX;
+	    im->extra_flags |= ALTAUTOSCALE_MAX;
 	    break;
 	case 'g':
-	    im.extra_flags |= NOLEGEND;
+	    im->extra_flags |= NOLEGEND;
 	    break;
 	case 260:
-	    im.unitsexponent = atoi(optarg);
+	    im->unitsexponent = atoi(optarg);
 	    break;
 	case 261:
-	    im.step =  atoi(optarg);
+	    im->step =  atoi(optarg);
 	    break;
 	case 's':
 	    if ((parsetime_error = parsetime(optarg, &start_tv))) {
 	        rrd_set_error( "start time: %s", parsetime_error );
-		return -1;
+		return;
 	    }
 	    break;
 	case 'e':
 	    if ((parsetime_error = parsetime(optarg, &end_tv))) {
 	        rrd_set_error( "end time: %s", parsetime_error );
-		return -1;
+		return;
 	    }
 	    break;
 	case 'x':
 	    if(strcmp(optarg,"none") == 0){
-	      im.draw_x_grid=0;
+	      im->draw_x_grid=0;
 	      break;
 	    };
 	        
 	    if(sscanf(optarg,
 		      "%10[A-Z]:%ld:%10[A-Z]:%ld:%10[A-Z]:%ld:%ld:%n",
 		      scan_gtm,
-		      &im.xlab_user.gridst,
+		      &im->xlab_user.gridst,
 		      scan_mtm,
-		      &im.xlab_user.mgridst,
+		      &im->xlab_user.mgridst,
 		      scan_ltm,
-		      &im.xlab_user.labst,
-		      &im.xlab_user.precis,
+		      &im->xlab_user.labst,
+		      &im->xlab_user.precis,
 		      &stroff) == 7 && stroff != 0){
-                strncpy(im.xlab_form, optarg+stroff, sizeof(im.xlab_form) - 1);
-		if((im.xlab_user.gridtm = tmt_conv(scan_gtm)) == -1){
+                strncpy(im->xlab_form, optarg+stroff, sizeof(im->xlab_form) - 1);
+		if((im->xlab_user.gridtm = tmt_conv(scan_gtm)) == -1){
 		    rrd_set_error("unknown keyword %s",scan_gtm);
-		    return -1;
-		} else if ((im.xlab_user.mgridtm = tmt_conv(scan_mtm)) == -1){
+		    return;
+		} else if ((im->xlab_user.mgridtm = tmt_conv(scan_mtm)) == -1){
 		    rrd_set_error("unknown keyword %s",scan_mtm);
-		    return -1;
-		} else if ((im.xlab_user.labtm = tmt_conv(scan_ltm)) == -1){
+		    return;
+		} else if ((im->xlab_user.labtm = tmt_conv(scan_ltm)) == -1){
 		    rrd_set_error("unknown keyword %s",scan_ltm);
-		    return -1;
+		    return;
 		} 
-		im.xlab_user.minsec = 1;
-		im.xlab_user.stst = im.xlab_form;
+		im->xlab_user.minsec = 1;
+		im->xlab_user.stst = im->xlab_form;
 	    } else {
 		rrd_set_error("invalid x-grid format");
-		return -1;
+		return;
 	    }
 	    break;
 	case 'y':
 
 	    if(strcmp(optarg,"none") == 0){
-	      im.draw_y_grid=0;
+	      im->draw_y_grid=0;
 	      break;
 	    };
 
 	    if(sscanf(optarg,
 		      "%lf:%d",
-		      &im.ygridstep,
-		      &im.ylabfact) == 2) {
-		if(im.ygridstep<=0){
+		      &im->ygridstep,
+		      &im->ylabfact) == 2) {
+		if(im->ygridstep<=0){
 		    rrd_set_error("grid step must be > 0");
-		    return -1;
-		} else if (im.ylabfact < 1){
+		    return;
+		} else if (im->ylabfact < 1){
 		    rrd_set_error("label factor must be > 0");
-		    return -1;
+		    return;
 		} 
 	    } else {
 		rrd_set_error("invalid y-grid format");
-		return -1;
+		return;
 	    }
 	    break;
 	case 'v':
-	    strncpy(im.ylegend,optarg,150);
-	    im.ylegend[150]='\0';
+	    strncpy(im->ylegend,optarg,150);
+	    im->ylegend[150]='\0';
 	    break;
 	case 'u':
-	    im.maxval = atof(optarg);
+	    im->maxval = atof(optarg);
 	    break;
 	case 'l':
-	    im.minval = atof(optarg);
+	    im->minval = atof(optarg);
 	    break;
 	case 'b':
-	    im.base = atol(optarg);
-	    if(im.base != 1024 && im.base != 1000 ){
+	    im->base = atol(optarg);
+	    if(im->base != 1024 && im->base != 1000 ){
 		rrd_set_error("the only sensible value for base apart from 1000 is 1024");
-		return -1;
+		return;
 	    }
 	    break;
 	case 'w':
 	    long_tmp = atol(optarg);
 	    if (long_tmp < 10) {
 		rrd_set_error("width below 10 pixels");
-		return -1;
+		return;
 	    }
-	    im.xsize = long_tmp;
+	    im->xsize = long_tmp;
 	    break;
 	case 'h':
 	    long_tmp = atol(optarg);
 	    if (long_tmp < 10) {
 		rrd_set_error("height below 10 pixels");
-		return -1;
+		return;
 	    }
-	    im.ysize = long_tmp;
+	    im->ysize = long_tmp;
 	    break;
 	case 'i':
-	    im.interlaced = 1;
+	    im->interlaced = 1;
 	    break;
 	case 'r':
-	    im.rigid = 1;
+	    im->rigid = 1;
 	    break;
 	case 'f':
-	    im.imginfo = optarg;
+	    im->imginfo = optarg;
 	    break;
     	case 'a':
-	    if((im.imgformat = if_conv(optarg)) == -1) {
+	    if((im->imgformat = if_conv(optarg)) == -1) {
 		rrd_set_error("unsupported graphics format '%s'",optarg);
-		return -1;
+		return;
 	    }
 	    break;
 	case 'z':
-	    im.lazy = 1;
+	    im->lazy = 1;
 	    break;
 	case 'o':
-	    im.logarithmic = 1;
-	    if (isnan(im.minval))
-		im.minval=1;
+	    im->logarithmic = 1;
+	    if (isnan(im->minval))
+		im->minval=1;
 	    break;
 	case 'c':
 	    if(sscanf(optarg,
@@ -2716,20 +2621,20 @@ rrd_graph(int argc, char **argv, char ***prdata, int *xsize, int *ysize)
 		      col_nam,&col_red,&col_green,&col_blue) == 4){
 		int ci;
 		if((ci=grc_conv(col_nam)) != -1){
-		    im.graph_col[ci].red=col_red;
-		    im.graph_col[ci].green=col_green;
-		    im.graph_col[ci].blue=col_blue;
+		    im->graph_col[ci].red=col_red;
+		    im->graph_col[ci].green=col_green;
+		    im->graph_col[ci].blue=col_blue;
 		}  else {
 		  rrd_set_error("invalid color name '%s'",col_nam);
 		}
 	    } else {
 		rrd_set_error("invalid color def format");
-		return -1;
+		return;
 	    }
 	    break;	  
 	case 't':
-	    strncpy(im.title,optarg,150);
-	    im.title[150]='\0';
+	    strncpy(im->title,optarg,150);
+	    im->title[150]='\0';
 	    break;
 
 	case '?':
@@ -2737,128 +2642,147 @@ rrd_graph(int argc, char **argv, char ***prdata, int *xsize, int *ysize)
                 rrd_set_error("unknown option '%c'", optopt);
             else
                 rrd_set_error("unknown option '%s'",argv[optind-1]);
-            return -1;
+            return;
 	}
     }
     
     if (optind >= argc) {
        rrd_set_error("missing filename");
-       return -1;
+       return;
     }
 
-    if (im.logarithmic == 1 && (im.minval <= 0 || isnan(im.minval))){
+    if (im->logarithmic == 1 && (im->minval <= 0 || isnan(im->minval))){
 	rrd_set_error("for a logarithmic yaxis you must specify a lower-limit > 0");	
-	return -1;
+	return;
     }
 
-    strncpy(im.graphfile,argv[optind],MAXPATH-1);
-    im.graphfile[MAXPATH-1]='\0';
-
     if (proc_start_end(&start_tv,&end_tv,&start_tmp,&end_tmp) == -1){
-	return -1;
+	/* error string is set in parsetime.c */
+	return;
     }  
     
     if (start_tmp < 3600*24*365*10){
 	rrd_set_error("the first entry to fetch should be after 1980 (%ld)",start_tmp);
-	return -1;
+	return;
     }
     
     if (end_tmp < start_tmp) {
 	rrd_set_error("start (%ld) should be less than end (%ld)", 
 	       start_tmp, end_tmp);
-	return -1;
+	return;
     }
     
-    im.start = start_tmp;
-    im.end = end_tmp;
+    im->start = start_tmp;
+    im->end = end_tmp;
+}
+
+int
+rrd_graph_check_vname(image_desc_t *im, char *varname, char *err)
+{
+    if ((im->gdes[im->gdes_c-1].vidx=find_var(im,varname))==-1) {
+	im_free(im);
+	rrd_set_error("Unknown variable '%s' in %s",varname,err);
+	return -1;
+    }
+    return 0;
+}
+int
+rrd_graph_check_CF(image_desc_t *im, char *symname, char *err)
+{
+    if ((im->gdes[im->gdes_c-1].cf=cf_conv(symname))==-1) {
+	im_free(im);
+	rrd_set_error("Unknown CF '%s' in %s",symname,err);
+	return -1;
+    }
+    return 0;
+}
+
+void
+rrd_graph_script(int argc, char *myarg[], image_desc_t *im)
+{
+    int			i;
+    char		symname[100];
+    unsigned int	col_red,col_green,col_blue;
+    long		scancount;
+    int			linepass = 0; /* stack can only follow directly after LINE* AREA or STACK */    
+
+/* All code worked on "argv[i]", it made sense to formalize this
+** and use "arg" instead.
+**
+** The same can be said for "im->gdes[im->gdes_c-1]" which
+** has been changed into a simple "gdp".
+*/
 
-    
     for(i=optind+1;i<argc;i++){
-	int   argstart=0;
-	int   strstart=0;
-	char  varname[30],*rpnex;
-	gdes_alloc(&im);
-	if(sscanf(argv[i],"%10[A-Z0-9]:%n",symname,&argstart)==1){
-	    if((im.gdes[im.gdes_c-1].gf=gf_conv(symname))==-1){
-		im_free(&im);
+	char		*arg=myarg[i];
+	int		argstart=0;
+	int		strstart=0;
+	char		varname[MAX_VNAME_LEN+1],*rpnex;
+	graph_desc_t	*gdp;
+
+	gdes_alloc(im);
+	gdp=&im->gdes[im->gdes_c-1];
+
+	if(sscanf(arg,"%10[A-Z0-9]:%n",symname,&argstart)==1){
+	    if((gdp->gf=gf_conv(symname))==-1){
+		im_free(im);
 		rrd_set_error("unknown function '%s'",symname);
-		return -1;
+		return;
 	    }
 	} else {
-	    rrd_set_error("can't parse '%s'",argv[i]);
-	    im_free(&im);
-	    return -1;
+	    rrd_set_error("can't parse '%s'",arg);
+	    im_free(im);
+	    return;
 	}
 
-	/* reset linepass if a non LINE/STACK/AREA operator gets parsed 
-	
-	   if (im.gdes[im.gdes_c-1].gf != GF_LINE1 &&
-	   im.gdes[im.gdes_c-1].gf != GF_LINE2 &&
-	   im.gdes[im.gdes_c-1].gf != GF_LINE3 &&
-	   im.gdes[im.gdes_c-1].gf != GF_AREA &&
-	   im.gdes[im.gdes_c-1].gf != GF_STACK) {
-	   linepass = 0;
-	   } 
-	*/
-	
-	switch(im.gdes[im.gdes_c-1].gf){
+	switch(gdp->gf){
 	case GF_PRINT:
-	    im.prt_c++;
+	    im->prt_c++;
 	case GF_GPRINT:
 	    strstart=0;
-	    sscanf(&argv[i][argstart], DEF_NAM_FMT ":%n"
+	    sscanf(&arg[argstart], DEF_NAM_FMT ":%n"
 		    ,varname
 		    ,&strstart
 	    );
 
 	    if (strstart==0) {
-		im_free(&im);
-		rrd_set_error("can't parse vname in '%s'",&argv[i][argstart]);
-		return -1;
+		im_free(im);
+		rrd_set_error("can't parse vname in '%s'",&arg[argstart]);
+		return;
 	    };
 
-	    if ((im.gdes[im.gdes_c-1].vidx=find_var(&im,varname))==-1){
-		im_free(&im);
-		rrd_set_error("Unknown variable '%s' in (G)PRINT",varname);
-		return -1;
-	    } else {
+	    if (rrd_graph_check_vname(im,varname,arg)) return;
+	    else {
 		int n=0;
 
-		sscanf(&argv[i][argstart+strstart],CF_NAM_FMT ":%n"
+		sscanf(&arg[argstart+strstart],CF_NAM_FMT ":%n"
 		    ,symname
 		    ,&n
 		);
-		if (im.gdes[im.gdes[im.gdes_c-1].vidx].gf==GF_VDEF) {
+		if (im->gdes[gdp->vidx].gf==GF_VDEF) {
 		    /* No consolidation function should be present */
 		    if (n != 0) {
 			rrd_set_error("(G)PRINT of VDEF needs no CF");
-			im_free(&im);
-			return -1;
+			im_free(im);
+			return;
 		    }
 		} else {
 		    /* A consolidation function should follow */
 		    if (n==0) {
-			im_free(&im);
-			rrd_set_error("Missing or incorrect CF in (G)PRINTing '%s' (%s)",varname,&argv[i][argstart]);
-			return -1;
-		    };
-		    if((im.gdes[im.gdes_c-1].cf=cf_conv(symname))==-1){
-			im_free(&im);
-			return -1;
+			im_free(im);
+			rrd_set_error("Missing or incorrect CF in (G)PRINTing '%s' (%s)",varname,&arg[argstart]);
+			return;
 		    };
+		    if (rrd_graph_check_CF(im,symname,arg)) return;
 		    strstart+=n;
 		};
 	    };
 
-	    scan_for_col(
-			&argv[i][argstart+strstart]
-			,FMT_LEG_LEN
-			,im.gdes[im.gdes_c-1].format
-			);
+	    scan_for_col(&arg[argstart+strstart],FMT_LEG_LEN,gdp->format);
 	    break;
 	case GF_COMMENT:
-	    if(strlen(&argv[i][argstart])>FMT_LEG_LEN) argv[i][argstart+FMT_LEG_LEN-3]='\0' ;
-	    strcpy(im.gdes[im.gdes_c-1].legend, &argv[i][argstart]);
+	    if(strlen(&arg[argstart])>FMT_LEG_LEN) arg[argstart+FMT_LEG_LEN-3]='\0' ;
+	    strcpy(gdp->legend, &arg[argstart]);
 	    break;
 	case GF_HRULE:
 	    /* scan for either "HRULE:vname#..." or "HRULE:num#..."
@@ -2868,57 +2792,50 @@ rrd_graph(int argc, char **argv, char ***prdata, int *xsize, int *ysize)
 	     * permitted
 	     */
 	    strstart=0;
-	    sscanf(&argv[i][argstart], "%lf#%n"
-		,&im.gdes[im.gdes_c-1].yrule
+	    sscanf(&arg[argstart], "%lf#%n"
+		,&im->gdes[im->gdes_c-1].yrule
 		,&strstart
 	    );
 	    if (strstart==0) { /* no number, should be vname */
-		sscanf(&argv[i][argstart], DEF_NAM_FMT "#%n"
+		sscanf(&arg[argstart], DEF_NAM_FMT "#%n"
 		    ,varname
 		    ,&strstart
 		);
 		if (strstart) {
-		    im.gdes[im.gdes_c-1].yrule = DNAN;/* signal use of vname */
-		    if((im.gdes[im.gdes_c-1].vidx=find_var(&im,varname))==-1){
-			im_free(&im);
-			rrd_set_error("unknown variable '%s' in HRULE",varname);
-			return -1;
-		    }		
-		    if(im.gdes[im.gdes[im.gdes_c-1].vidx].gf != GF_VDEF) {
-			im_free(&im);
+		    gdp->yrule = DNAN;/* signal use of vname */
+		    if (rrd_graph_check_vname(im,varname,arg)) return;
+		    if(im->gdes[gdp->vidx].gf != GF_VDEF) {
+			im_free(im);
 			rrd_set_error("Only VDEF is allowed in HRULE",varname);
-			return -1;
+			return;
 		    }
 		}
-	    } else {
-printf("DEBUG: matched HRULE:num\n");
-printf("DEBUG: strstart==%i\n",strstart);
 	    };
 	    if (strstart==0) {
-		im_free(&im);
-		rrd_set_error("can't parse '%s'",&argv[i][argstart]);
-		return -1;
+		im_free(im);
+		rrd_set_error("can't parse '%s'",&arg[argstart]);
+		return;
 	    } else {
 		int n=0;
 		if(sscanf(
-			&argv[i][argstart+strstart],
+			&arg[argstart+strstart],
 			"%2x%2x%2x:%n",
 			&col_red,
 			&col_green,
 			&col_blue,
 			&n)>=3) {
-		    im.gdes[im.gdes_c-1].col.red = col_red;
-		    im.gdes[im.gdes_c-1].col.green = col_green;
-		    im.gdes[im.gdes_c-1].col.blue = col_blue;
+		    gdp->col.red = col_red;
+		    gdp->col.green = col_green;
+		    gdp->col.blue = col_blue;
 		    if (n==0) {
-			im.gdes[im.gdes_c-1].legend[0] = '\0';
+			gdp->legend[0] = '\0';
 		    } else {
-			scan_for_col(&argv[i][argstart+strstart+n],FMT_LEG_LEN,im.gdes[im.gdes_c-1].legend);
+			scan_for_col(&arg[argstart+strstart+n],FMT_LEG_LEN,gdp->legend);
 		    }
 		} else {
-		    im_free(&im);
-		    rrd_set_error("can't parse '%s'",&argv[i][argstart]);
-		    return -1;
+		    im_free(im);
+		    rrd_set_error("can't parse '%s'",&arg[argstart]);
+		    return;
 		}
 	    }
 	    
@@ -2931,108 +2848,98 @@ printf("DEBUG: strstart==%i\n",strstart);
 	     * permitted
 	     */
 	    strstart=0;
-	    sscanf(&argv[i][argstart], "%lu#%n"
-		,(long unsigned int *)&im.gdes[im.gdes_c-1].xrule
-		,&strstart
-	    );
+	    sscanf(&arg[argstart], "%lu#%n"
+		,(long unsigned int *)&gdp->xrule,&strstart);
 	    if (strstart==0) { /* no number, should be vname */
-		sscanf(&argv[i][argstart], DEF_NAM_FMT "#%n"
+		sscanf(&arg[argstart], DEF_NAM_FMT "#%n"
 		    ,varname
 		    ,&strstart
 		);
 		if (strstart!=0) { /* vname matched */
-		    im.gdes[im.gdes_c-1].xrule = 0;/* signal use of vname */
-		    if((im.gdes[im.gdes_c-1].vidx=find_var(&im,varname))==-1){
-			im_free(&im);
-			rrd_set_error("unknown variable '%s' in VRULE",varname);
-			return -1;
-		    }		
-		    if(im.gdes[im.gdes[im.gdes_c-1].vidx].gf != GF_VDEF) {
-			im_free(&im);
+		    gdp->xrule = 0;/* signal use of vname */
+		    if (rrd_graph_check_vname(im,varname,arg)) return;
+		    if(im->gdes[gdp->vidx].gf != GF_VDEF) {
+			im_free(im);
 			rrd_set_error("Only VDEF is allowed in VRULE",varname);
-			return -1;
+			return;
 		    }
 		}
 	    } else {
-		if (im.gdes[im.gdes_c-1].xrule==0)
+		if (gdp->xrule==0)
 		    strstart=0;
 	    }
 
 	    if (strstart==0) {
-		im_free(&im);
-		rrd_set_error("can't parse '%s'",&argv[i][argstart]);
-		return -1;
+		im_free(im);
+		rrd_set_error("can't parse '%s'",&arg[argstart]);
+		return;
 	    } else {
 		int n=0;
 		if(sscanf(
-			&argv[i][argstart+strstart],
+			&arg[argstart+strstart],
 			"%2x%2x%2x:%n",
 			&col_red,
 			&col_green,
 			&col_blue,
 			&n)>=3) {
-		    im.gdes[im.gdes_c-1].col.red = col_red;
-		    im.gdes[im.gdes_c-1].col.green = col_green;
-		    im.gdes[im.gdes_c-1].col.blue = col_blue;
+		    gdp->col.red = col_red;
+		    gdp->col.green = col_green;
+		    gdp->col.blue = col_blue;
 		    if (n==0) {
-			im.gdes[im.gdes_c-1].legend[0] = '\0';
+			gdp->legend[0] = '\0';
 		    } else {
-			scan_for_col(&argv[i][argstart+strstart+n],FMT_LEG_LEN,im.gdes[im.gdes_c-1].legend);
+			scan_for_col(&arg[argstart+strstart+n],FMT_LEG_LEN,gdp->legend);
 		    }
 		} else {
-		    im_free(&im);
-		    rrd_set_error("can't parse '%s'",&argv[i][argstart]);
-		    return -1;
+		    im_free(im);
+		    rrd_set_error("can't parse '%s'",&arg[argstart]);
+		    return;
 		}
 	    }
 	    break;
 	case GF_TICK:
 	    if((scancount=sscanf(
-		&argv[i][argstart],
+		&arg[argstart],
 		"%29[^:#]#%2x%2x%2x:%lf:%n",
 		varname,
 		&col_red,
 		&col_green,
 		&col_blue,
-		&(im.gdes[im.gdes_c-1].yrule),
+		&(gdp->yrule),
 		&strstart))>=1)
 		{
-		im.gdes[im.gdes_c-1].col.red = col_red;
-		im.gdes[im.gdes_c-1].col.green = col_green;
-		im.gdes[im.gdes_c-1].col.blue = col_blue;
+		gdp->col.red = col_red;
+		gdp->col.green = col_green;
+		gdp->col.blue = col_blue;
 		if(strstart <= 0){
-		    im.gdes[im.gdes_c-1].legend[0] = '\0';
+		    gdp->legend[0] = '\0';
 		} else { 
-		    scan_for_col(&argv[i][argstart+strstart],FMT_LEG_LEN,im.gdes[im.gdes_c-1].legend);
-		}
-		if((im.gdes[im.gdes_c-1].vidx=find_var(&im,varname))==-1){
-		    im_free(&im);
-		    rrd_set_error("unknown variable '%s'",varname);
-		    return -1;
+		    scan_for_col(&arg[argstart+strstart],FMT_LEG_LEN,gdp->legend);
 		}
-		if (im.gdes[im.gdes_c-1].yrule <= 0.0 || im.gdes[im.gdes_c-1].yrule > 1.0)
+		if (rrd_graph_check_vname(im,varname,arg)) return;
+		if (gdp->yrule <= 0.0 || gdp->yrule > 1.0)
 		{
-		    im_free(&im);
+		    im_free(im);
 		    rrd_set_error("Tick mark scaling factor out of range");
-		    return -1;
+		    return;
 		}
 		if (scancount < 4)
-		   im.gdes[im.gdes_c-1].col.red = -1;		
+		   gdp->col.red = -1;		
 	    if (scancount < 5) 
 		   /* default tick marks: 10% of the y-axis */
-		   im.gdes[im.gdes_c-1].yrule = 0.1;
+		   gdp->yrule = 0.1;
 
 		} else {
-		   im_free(&im);
-		   rrd_set_error("can't parse '%s'",&argv[i][argstart]);
-		   return -1;
+		   im_free(im);
+		   rrd_set_error("can't parse '%s'",&arg[argstart]);
+		   return;
 		} /* endif sscanf */
 		break;
 	case GF_STACK:
 	    if(linepass == 0){
-		im_free(&im);
+		im_free(im);
 		rrd_set_error("STACK must follow AREA, LINE or STACK");
-		return -1; 
+		return; 
 	    }		
 	case GF_LINE1:
 	case GF_LINE2:
@@ -3040,203 +2947,118 @@ printf("DEBUG: strstart==%i\n",strstart);
 	case GF_AREA:
 	    linepass = 1;
 	    if((scancount=sscanf(
-		&argv[i][argstart],
+		&arg[argstart],
 		"%29[^:#]#%2x%2x%2x:%n",
 		varname,
 		&col_red,
 		&col_green,
 		    &col_blue,
 		&strstart))>=1){
-		im.gdes[im.gdes_c-1].col.red = col_red;
-		im.gdes[im.gdes_c-1].col.green = col_green;
-		im.gdes[im.gdes_c-1].col.blue = col_blue;
+		gdp->col.red = col_red;
+		gdp->col.green = col_green;
+		gdp->col.blue = col_blue;
 		if(strstart <= 0){
-		    im.gdes[im.gdes_c-1].legend[0] = '\0';
+		    gdp->legend[0] = '\0';
 		} else { 
-		    scan_for_col(&argv[i][argstart+strstart],FMT_LEG_LEN,im.gdes[im.gdes_c-1].legend);
+		    scan_for_col(&arg[argstart+strstart],FMT_LEG_LEN,gdp->legend);
 		}
-		if((im.gdes[im.gdes_c-1].vidx=find_var(&im,varname))==-1){
-		    im_free(&im);
-		    rrd_set_error("unknown variable '%s'",varname);
-		    return -1;
-		}		
+		if (rrd_graph_check_vname(im,varname,arg)) return;
 		if (scancount < 4)
-		    im.gdes[im.gdes_c-1].col.red = -1;		
-		
+		    gdp->col.red = -1;		
 	    } else {
-		im_free(&im);
-		rrd_set_error("can't parse '%s'",&argv[i][argstart]);
-		return -1;
+		im_free(im);
+		rrd_set_error("can't parse '%s'",&arg[argstart]);
+		return;
 	    }
 	    break;
 	case GF_CDEF:
-	    if((rpnex = malloc(strlen(&argv[i][argstart])*sizeof(char)))==NULL){
+	    if((rpnex = malloc(strlen(&arg[argstart])*sizeof(char)))==NULL){
+		free(im);
 		rrd_set_error("malloc for CDEF");
-		return -1;
+		return;
 	    }
-	    if(sscanf(
-		    &argv[i][argstart],
-		    DEF_NAM_FMT "=%[^: ]",
-		    im.gdes[im.gdes_c-1].vname,
-		    rpnex) != 2){
-		im_free(&im);
-		free(rpnex);
-		rrd_set_error("can't parse CDEF '%s'",&argv[i][argstart]);
-		return -1;
+	    strstart=parse_vname1(&arg[argstart],im,"CDEF");
+	    argstart+=strstart;
+	    /* parse_vname1() did free(im) and rrd_set_error() */
+	    if (strstart==0) return;
+
+	    strstart=0;
+	    sscanf(&arg[argstart],"%[^: ]%n",rpnex,&strstart);
+	    if (strstart==0) {
+		rrd_set_error("can't parse RPN in CDEF:%s=%s",
+					gdp->vname,
+					&arg[argstart]);
+		free(im);
+		return;
 	    }
-	    /* checking for duplicate variable names */
-	    if(find_var(&im,im.gdes[im.gdes_c-1].vname) != -1){
-		im_free(&im);
-		rrd_set_error("duplicate variable '%s'",
-			      im.gdes[im.gdes_c-1].vname);
-		return -1; 
-	    }	   
-	    if((im.gdes[im.gdes_c-1].rpnp = 
-		   rpn_parse((void*)&im,rpnex,&find_var_wrapper))== NULL){
+	    if((gdp->rpnp = 
+		   rpn_parse((void*)im,rpnex,&find_var_wrapper))== NULL){
 		rrd_set_error("invalid rpn expression '%s'", rpnex);
-		im_free(&im);		
-		return -1;
+		im_free(im);		
+		return;
 	    }
 	    free(rpnex);
 	    break;
 	case GF_VDEF:
-	    /*
-	     * strstart is set to zero and will NOT be changed
-	     * if the comma is not matched.  This means that it
-	     * remains zero. Although strstart is initialized to
-	     * zero at the beginning of this loop, we do it again
-	     * here just in case someone changes the code...
-	     *
-	     * According to the docs we cannot rely on the
-	     * returned value from sscanf; it can be 2 or 3,
-	     * depending on %n incrementing it or not.
-	     */
+	    strstart=parse_vname1(&arg[argstart],im,"VDEF");
+	    argstart+=strstart;
+	    /* parse_vname1() did free(im) and rrd_set_error() */
+	    if (strstart==0) return;
+
 	    strstart=0;
-	    sscanf(
-		    &argv[i][argstart],
-		    DEF_NAM_FMT "=" DEF_NAM_FMT ",%n",
-		    im.gdes[im.gdes_c-1].vname,
-		    varname,
-		    &strstart);
-	    if (strstart){
-		/* checking both variable names */
-		if (find_var(&im,im.gdes[im.gdes_c-1].vname) != -1){
-		    im_free(&im);
-		    rrd_set_error("duplicate variable '%s'",
-				im.gdes[im.gdes_c-1].vname);
-		    return -1; 
-		} else {
-		    if ((im.gdes[im.gdes_c-1].vidx=find_var(&im,varname)) == -1){
-			im_free(&im);
-			rrd_set_error("variable '%s' not known in VDEF '%s'",
-				varname,
-				im.gdes[im.gdes_c-1].vname);
-			return -1; 
-		    } else {
-			if(im.gdes[im.gdes[im.gdes_c-1].vidx].gf != GF_DEF
-			&& im.gdes[im.gdes[im.gdes_c-1].vidx].gf != GF_CDEF){
-			    rrd_set_error("variable '%s' not DEF nor CDEF in VDEF '%s'",
-				varname,
-				im.gdes[im.gdes_c-1].vname);
-			    im_free(&im);
-			    return -1; 
-			}
-		    }
-		    /* parsed upto and including the first comma. Now
-		     * see what function is requested.  This function
-		     * sets the error string.
-		     */
-		    if (vdef_parse(&im.gdes[im.gdes_c-1],&argv[i][argstart+strstart])<0) {
-			im_free(&im);
-			return -1;
-		    };
-		}
-	    } else {
-		im_free(&im);
-		rrd_set_error("can't parse VDEF '%s'",&argv[i][argstart]);
-		return -1;
+	    sscanf(&arg[argstart],DEF_NAM_FMT ",%n",varname,&strstart);
+	    if (strstart==0) {
+		im_free(im);
+		rrd_set_error("Cannot parse '%s' in VDEF '%s'",
+				&arg[argstart],
+				gdp->vname);
+		return;
 	    }
+	    if (rrd_graph_check_vname(im,varname,arg)) return;
+	    if (   im->gdes[gdp->vidx].gf != GF_DEF
+		&& im->gdes[gdp->vidx].gf != GF_CDEF) {
+		rrd_set_error("variable '%s' not DEF nor CDEF in VDEF '%s'",
+			varname,gdp->vname);
+		im_free(im);
+		return;
+	    };
+
+	    /* parsed upto and including the first comma. Now
+	     * see what function is requested.  This function
+	     * sets the error string.
+	     */
+	    if (vdef_parse(gdp,&arg[argstart+strstart])<0) {
+		im_free(im);
+		return;
+	    };
 	    break;
 	case GF_DEF:
-	    if (sscanf(
-		&argv[i][argstart],
-		DEF_NAM_FMT "=%n",
-		im.gdes[im.gdes_c-1].vname,
-		&strstart)== 1 && strstart){ /* is the = did not match %n returns 0 */ 
-		if(sscanf(&argv[i][argstart
-				  +strstart
-				  +scan_for_col(&argv[i][argstart+strstart],
-						MAXPATH,im.gdes[im.gdes_c-1].rrd)],
-			  ":" DS_NAM_FMT ":" CF_NAM_FMT,
-			  im.gdes[im.gdes_c-1].ds_nam,
-			  symname) != 2){
-		    im_free(&im);
-		    rrd_set_error("can't parse DEF '%s' -2",&argv[i][argstart]);
-		    return -1;
-		}
-	    } else {
-		im_free(&im);
-		rrd_set_error("can't parse DEF '%s'",&argv[i][argstart]);
-		return -1;
+	    strstart=parse_vname1(&arg[argstart],im,"DEF");
+	    argstart+=strstart;
+	    /* parse_vname1() did free(im) and rrd_set_error() */
+	    if (strstart==0) return;
+
+	    argstart+=scan_for_col(&arg[argstart],MAXPATH,gdp->rrd);
+	    if(sscanf(&arg[argstart], ":" DS_NAM_FMT ":" CF_NAM_FMT,
+			  gdp->ds_nam, symname) != 2){
+		im_free(im);
+		rrd_set_error("can't parse DEF '%s' -2",&arg[argstart]);
+		return;
 	    }
 	    
-	    /* checking for duplicate DEF CDEFS */
-	    if (find_var(&im,im.gdes[im.gdes_c-1].vname) != -1){
-		im_free(&im);
-		rrd_set_error("duplicate variable '%s'",
-			  im.gdes[im.gdes_c-1].vname);
-		return -1; 
-	    }	   
-	    if((im.gdes[im.gdes_c-1].cf=cf_conv(symname))==-1){
-		im_free(&im);
-		rrd_set_error("unknown cf '%s'",symname);
-		return -1;
-	    }
+	    if (rrd_graph_check_CF(im,symname,arg)) return;
 	    break;
 	}
-	
     }
 
-    if (im.gdes_c==0){
+    if (im->gdes_c==0){
 	rrd_set_error("can't make a graph without contents");
-	im_free(&im);
-	return(-1); 
-    }
-    
-	/* parse rest of arguments containing information on what to draw*/
-    if (graph_paint(&im,prdata)==-1){
-	im_free(&im);
-	return -1;
-    }
-    
-    *xsize=im.xgif;
-    *ysize=im.ygif;
-    if (im.imginfo){
-      char *filename;
-      if (! (*prdata)) {	
-	/* maybe prdata is not allocated yet ... lets do it now */
-	if((*prdata = calloc(2,sizeof(char *)))==NULL){
-	  rrd_set_error("malloc imginfo");
-	  return -1; 
-	};
-      }
-      if(((*prdata)[0] = malloc((strlen(im.imginfo)+200+strlen(im.graphfile))*sizeof(char)))
-	 ==NULL){
-	rrd_set_error("malloc imginfo");
-	return -1;
-      }
-      filename=im.graphfile+strlen(im.graphfile);      
-      while(filename > im.graphfile){
-	if (*(filename-1)=='/' || *(filename-1)=='\\' ) break;
-	filename--;
-      }
-      
-      sprintf((*prdata)[0],im.imginfo,filename,im.xgif,im.ygif);
+	im_free(im);
+	return; 
     }
-    im_free(&im);
-    return 0;
 }
 
+
 int bad_format(char *fmt) {
 	char *ptr;
 
@@ -3296,6 +3118,7 @@ char *str;
     else if	(!strcmp("MAXIMUM",func)) gdes->vf.op = VDEF_MAXIMUM;
     else if	(!strcmp("AVERAGE",func)) gdes->vf.op = VDEF_AVERAGE;
     else if	(!strcmp("MINIMUM",func)) gdes->vf.op = VDEF_MINIMUM;
+    else if	(!strcmp("TOTAL",  func)) gdes->vf.op = VDEF_TOTAL;
     else if	(!strcmp("FIRST",  func)) gdes->vf.op = VDEF_FIRST;
     else if	(!strcmp("LAST",   func)) gdes->vf.op = VDEF_LAST;
     else {
@@ -3330,6 +3153,7 @@ char *str;
 	case VDEF_MAXIMUM:
 	case VDEF_AVERAGE:
 	case VDEF_MINIMUM:
+	case VDEF_TOTAL:
 	case VDEF_FIRST:
 	case VDEF_LAST:
 	    if (isnan(param)) {
@@ -3358,7 +3182,7 @@ int gdi;
 
     dst = &im->gdes[gdi];
     src = &im->gdes[dst->vidx];
-    data = src->data + src->ds + src->ds_cnt; /* skip first value! */
+    data = src->data + src->ds;
     steps = (src->end - src->start) / src->step;
 
 #if 0
@@ -3369,7 +3193,7 @@ printf("DEBUG: start == %lu, end == %lu, %lu steps\n"
     );
 #endif
 
-    switch (im->gdes[gdi].vf.op) {
+    switch (dst->vf.op) {
 	case VDEF_PERCENT: {
 		rrd_value_t *	array;
 		int		field;
@@ -3387,7 +3211,7 @@ printf("DEBUG: start == %lu, end == %lu, %lu steps\n"
 		field = (steps-1)*dst->vf.param/100;
 		dst->vf.val  = array[field];
 		dst->vf.when = 0;	/* no time component */
-#if 1
+#if 0
 for(step=0;step<steps;step++)
 printf("DEBUG: %3li:%10.2f %c\n",step,array[step],step==field?'*':' ');
 #endif
@@ -3400,19 +3224,20 @@ printf("DEBUG: %3li:%10.2f %c\n",step,array[step],step==field?'*':' ');
 		dst->vf.val  = DNAN;
 		dst->vf.when = 0;
 	    } else {
-		dst->vf.val  = data[steps*src->ds_cnt];
+		dst->vf.val  = data[step*src->ds_cnt];
 		dst->vf.when = src->start + (step+1)*src->step;
 	    }
 	    while (step != steps) {
 		if (finite(data[step*src->ds_cnt])) {
 		    if (data[step*src->ds_cnt] > dst->vf.val) {
-			dst->vf.val  = data[steps*src->ds_cnt];
+			dst->vf.val  = data[step*src->ds_cnt];
 			dst->vf.when = src->start + (step+1)*src->step;
 		    }
 		}
 		step++;
 	    }
 	    break;
+	case VDEF_TOTAL:
 	case VDEF_AVERAGE: {
 	    int cnt=0;
 	    double sum=0.0;
@@ -3420,12 +3245,16 @@ printf("DEBUG: %3li:%10.2f %c\n",step,array[step],step==field?'*':' ');
 		if (finite(data[step*src->ds_cnt])) {
 		    sum += data[step*src->ds_cnt];
 		    cnt ++;
-		}
-		step++;
+		};
 	    }
 	    if (cnt) {
-		dst->vf.val  = sum/cnt;
-		dst->vf.when = 0;	/* no time component */
+		if (dst->vf.op == VDEF_TOTAL) {
+		    dst->vf.val  = sum*src->step;
+		    dst->vf.when = cnt*src->step;	/* not really "when" */
+		} else {
+		    dst->vf.val = sum/cnt;
+		    dst->vf.when = 0;	/* no time component */
+		};
 	    } else {
 		dst->vf.val  = DNAN;
 		dst->vf.when = 0;
@@ -3439,13 +3268,13 @@ printf("DEBUG: %3li:%10.2f %c\n",step,array[step],step==field?'*':' ');
 		dst->vf.val  = DNAN;
 		dst->vf.when = 0;
 	    } else {
-		dst->vf.val  = data[steps*src->ds_cnt];
+		dst->vf.val  = data[step*src->ds_cnt];
 		dst->vf.when = src->start + (step+1)*src->step;
 	    }
 	    while (step != steps) {
 		if (finite(data[step*src->ds_cnt])) {
 		    if (data[step*src->ds_cnt] < dst->vf.val) {
-			dst->vf.val  = data[steps*src->ds_cnt];
+			dst->vf.val  = data[step*src->ds_cnt];
 			dst->vf.when = src->start + (step+1)*src->step;
 		    }
 		}
@@ -3486,7 +3315,7 @@ printf("DEBUG: %3li:%10.2f %c\n",step,array[step],step==field?'*':' ');
     return 0;
 }
 
-/* NaN <= -INF <= finite_values <= INF */
+/* NaN < -INF < finite_values < INF */
 int
 vdef_percent_compar(a,b)
 const void *a,*b;
@@ -3499,7 +3328,7 @@ const void *a,*b;
     if (isnan( *(double *)a )) return -1;
     if (isnan( *(double *)b )) return  1;
 
-    /* NaN doestn't reach this part so INF and -INF are extremes.
+    /* NaN doesn't reach this part so INF and -INF are extremes.
      * The sign from isinf() is compatible with the sign we return
      */
     if (isinf( *(double *)a )) return isinf( *(double *)a );