Ejemplo n.º 1
0
static void convert_FrameKit_facet(FrFrame *frame,FrSymbol *slot,
				   FrList *facetspec,bool views)
{
   FrSymbol *facet = (FrSymbol *)facetspec->first() ;
   if (facet && facet->symbolp())
      {
      facetspec = facetspec->rest() ;
      if (views)
	 {
	 FrObject *first = facetspec->first() ;
	 if (first && first->consp())
	    facetspec = (FrList *)first ;
	 first = facetspec->first() ;
	 if (first && first->symbolp() &&
	     (FrSymbol *)first == symbolCOMMON)
	    facetspec = facetspec->rest() ;
	 else
	    {
	    bad_format("view other than COMMON encountered") ;
	    facetspec = nullptr ;
	    }
	 }
      if (facetspec)
	 frame->addFillers(slot,facet,facetspec) ;
      else
	 frame->createSlot(slot) ;
      }
   else
      bad_format(errmsg_facet_symbol) ;
}
Ejemplo n.º 2
0
void dimension::read(const char *s)
{
  int a, b, c;
  bool negative = false;

  // Minus sign first
  while(isspace(*s)) s++;
  if(*s == '-') { negative = true; s++; }

  // Now a number
  while(isspace(*s)) s++;
  if(!isdigit(*s)) THROW_OR_RETURN_VOID( bad_format() );
  a = *s++ - '0';
  while(isdigit(*s)) a = 10*a + (*s++ - '0');
  if(*s == '.') { // We have a number in decimal format
    s++;
    b = 1;
    while(isdigit(*s)) { a = 10*a + (*s++ - '0'); b = 10*b; }
    read_units(s);
    n = negative ? -a : a; d = b;
  } else { // Look for a fractional part
    while(isspace(*s)) s++;
    if(isdigit(*s)) { // Found a fractional part
      b = *s++ - '0';
      while(isdigit(*s)) b = 10*b + (*s++ - '0');
      while(isspace(*s)) s++;
      if(*s++ != '/') THROW_OR_RETURN_VOID( bad_format() );
      while(isspace(*s)) s++;
      if(!isdigit(*s)) THROW_OR_RETURN_VOID( bad_format() );
      c = *s++ - '0';
      while(isdigit(*s)) c = 10*c + (*s++ - '0');
      read_units(s);
      n = a * c + b; d = c;
      if(negative) n = -n;
    } else if(*s == '/') { // Just a fractional part
      s++;
      while(isspace(*s)) s++;
      if(!isdigit(*s)) THROW_OR_RETURN_VOID( bad_format() );
      c = *s++ - '0';
      while(isdigit(*s)) c = 10*c + (*s++ - '0');
      read_units(s);
      n = negative ? -a : a; d = c;     
    } else { // Just an integer
      read_units(s);
      n = negative ? -a : a; d = 1;
    }
  }
  reduce();
}
Ejemplo n.º 3
0
void dimension::read_units(const char *s)
{
  while(isspace(*s)) s++;
  const char *t = s; while(*t != '\0' && !isspace(*t)) t++;
  map<string, units>::const_iterator i = unit_names.find(string(s,t));
  if(i != unit_names.end())
    u = (*i).second;
  else
    THROW_OR_RETURN_VOID( bad_format() );
}
Ejemplo n.º 4
0
static void convert_FrameKit_slot(FrFrame *frame,const FrList *slotspec,
				  bool views)
{
   if (slotspec && slotspec->consp())
      {
      FrSymbol *slot = (FrSymbol *)slotspec->first() ;
      if (slot && slot->symbolp())
	 {
	 slotspec = slotspec->rest() ;
	 while (slotspec)
	    {
	    convert_FrameKit_facet(frame,slot,(FrList *)slotspec->first(),
				   views) ;
	    slotspec = slotspec->rest() ;
	    }
	 }
      else
	 bad_format(errmsg_slot_symbol) ;
      }
   else
      bad_format("slotspec must be a list") ;
}
Ejemplo n.º 5
0
FrFrame *FrameKit_to_FramepaC(const FrList *framespec, bool warn)
{
   FrSymbol *makefr = (FrSymbol*)framespec->first() ;
   if (makefr && makefr->symbolp() && *makefr == stringMAKEFR_OLD)
      return convert_FrameKit_frame(framespec->rest(),false) ;
   else if (makefr && makefr->symbolp() && *makefr == stringMAKEFRAME)
      return convert_FrameKit_frame(framespec->rest(),true) ;
   else
      {
      if (warn)
         bad_format("FrameKit frame not converted") ;
      return 0 ;
      }
}
Ejemplo n.º 6
0
static FrFrame *convert_FrameKit_frame(const FrList *framespec,bool views)
{
   FrFrame *frame ;
   FrSymbol *framename = (FrSymbol*)framespec->first() ;

   if (framename && framename->symbolp())
      {
      frame = read_as_VFrame
	         ? framename->createVFrame()
		 : framename->createFrame() ;
      framespec = framespec->rest() ;
      while (framespec)
	 {
	 convert_FrameKit_slot(frame,(const FrList *)framespec->first(),views) ;
	 framespec = framespec->rest() ;
	 }
      }
   else
      {
      bad_format(errmsg_frame_name) ;
      frame = nullptr ;
      }
   return frame ;
}
Ejemplo n.º 7
0
int rrd_xport_format_addprints(int flags,stringbuffer_t *buffer,image_desc_t *im) {
    /* initialize buffer */
    stringbuffer_t prints= {1024,0,NULL,NULL};
    stringbuffer_t rules= {1024,0,NULL,NULL};
    stringbuffer_t gprints= {4096,0,NULL,NULL};
    char buf[256];
    char dbuf[1024];
    char* val;
    char* timefmt=NULL;
    if (im->xlab_user.minsec!=-1) {
        timefmt=im->xlab_user.stst;
    }

    /* define some other stuff based on flags */
    int json=0;
    if (flags &1) {
        json=1;
    }
    // int showtime=0; if (flags &2) { showtime=1;} -> unused here
    // int enumds=0; if (flags &4) { enumds=1;} -> unused here

    /* define some values */
    time_t    now = time(NULL);
    struct tm tmvdef;
    localtime_r(&now, &tmvdef);
    double printval=DNAN;

    /* iterate over all fields and start the work writing to the correct buffers */
    for (long i = 0; i < im->gdes_c; i++) {
        long vidx = im->gdes[i].vidx;
        char* entry;
        switch (im->gdes[i].gf) {
        case GF_PRINT:
        case GF_GPRINT: {
            /* PRINT and GPRINT can now print VDEF generated values.
             * There's no need to do any calculations on them as these
             * calculations were already made.
             * we do not support the depreciated version here
             */
            printval=DNAN;
            /* decide to which buffer we print to*/
            stringbuffer_t *usebuffer=&gprints;
            char* usetag="gprint";
            if (im->gdes[i].gf==GF_PRINT) {
                usebuffer=&prints;
                usetag="print";
            }
            /* get the value */
            if (im->gdes[vidx].gf == GF_VDEF) { /* simply use vals */
                printval = im->gdes[vidx].vf.val;
                localtime_r(&im->gdes[vidx].vf.when, &tmvdef);
            } else {
                int max_ii = ((im->gdes[vidx].end - im->gdes[vidx].start)
                              / im->gdes[vidx].step * im->gdes[vidx].ds_cnt);
                printval = DNAN;
                long validsteps = 0;
                for (long ii = im->gdes[vidx].ds;
                        ii < max_ii; ii += im->gdes[vidx].ds_cnt) {
                    if (!finite(im->gdes[vidx].data[ii]))
                        continue;
                    if (isnan(printval)) {
                        printval = im->gdes[vidx].data[ii];
                        validsteps++;
                        continue;
                    }

                    switch (im->gdes[i].cf) {
                    case CF_HWPREDICT:
                    case CF_MHWPREDICT:
                    case CF_DEVPREDICT:
                    case CF_DEVSEASONAL:
                    case CF_SEASONAL:
                    case CF_AVERAGE:
                        validsteps++;
                        printval += im->gdes[vidx].data[ii];
                        break;
                    case CF_MINIMUM:
                        printval = min(printval, im->gdes[vidx].data[ii]);
                        break;
                    case CF_FAILURES:
                    case CF_MAXIMUM:
                        printval = max(printval, im->gdes[vidx].data[ii]);
                        break;
                    case CF_LAST:
                        printval = im->gdes[vidx].data[ii];
                    }
                }
                if (im->gdes[i].cf == CF_AVERAGE || im->gdes[i].cf > CF_LAST) {
                    if (validsteps > 1) {
                        printval = (printval / validsteps);
                    }
                }
            }
            /* we handle PRINT and GPRINT the same - format now*/
            if (im->gdes[i].strftm) {
                if (im->gdes[vidx].vf.never == 1) {
                    time_clean(buf, im->gdes[i].format);
                } else {
                    strftime(dbuf,sizeof(dbuf), im->gdes[i].format, &tmvdef);
                }
            } else if (bad_format(im->gdes[i].format)) {
                rrd_set_error
                ("bad format for PRINT in \"%s'", im->gdes[i].format);
                return -1;
            } else {
                snprintf(dbuf,sizeof(dbuf), im->gdes[i].format, printval,"");
            }
            /* print */
            if (json) {
                escapeJSON(dbuf,sizeof(dbuf));
                snprintf(buf,sizeof(buf),",\n        { \"%s\": \"%s\" }",usetag,dbuf);
            } else {
                snprintf(buf,sizeof(buf),"        <%s>%s</%s>\n",usetag,dbuf,usetag);
            }
            addToBuffer(usebuffer,buf,0);
        }
        break;
        case GF_COMMENT:
            if (json) {
                strncpy(dbuf,im->gdes[i].legend,sizeof(dbuf));
                escapeJSON(dbuf,sizeof(dbuf));
                snprintf(buf,sizeof(buf),",\n        { \"comment\": \"%s\" }",dbuf);
            } else {
                snprintf(buf,sizeof(buf),"        <comment>%s</comment>\n",im->gdes[i].legend);
            }
            addToBuffer(&gprints,buf,0);
            break;
        case GF_LINE:
            entry = im->gdes[i].legend;
            /* I do not know why the legend is "spaced", but let us skip it */
            while(isspace(*entry)) {
                entry++;
            }
            if (json) {
                snprintf(buf,sizeof(buf),",\n        { \"line\": \"%s\" }",entry);
            } else {
                snprintf(buf,sizeof(buf),"        <line>%s</line>\n",entry);
            }
            addToBuffer(&gprints,buf,0);
            break;
        case GF_AREA:
            if (json) {
                snprintf(buf,sizeof(buf),",\n        { \"area\": \"%s\" }",im->gdes[i].legend);
            } else {
                snprintf(buf,sizeof(buf),"        <area>%s</area>\n",im->gdes[i].legend);
            }
            addToBuffer(&gprints,buf,0);
            break;
        case GF_STACK:
            if (json) {
                snprintf(buf,sizeof(buf),",\n        { \"stack\": \"%s\" }",im->gdes[i].legend);
            } else {
                snprintf(buf,sizeof(buf),"        <stack>%s</stack>\n",im->gdes[i].legend);
            }
            addToBuffer(&gprints,buf,0);
            break;
        case GF_TEXTALIGN:
            val="";
            switch (im->gdes[i].txtalign) {
            case TXA_LEFT:
                val="left";
                break;
            case TXA_RIGHT:
                val="right";
                break;
            case TXA_CENTER:
                val="center";
                break;
            case TXA_JUSTIFIED:
                val="justified";
                break;
            }
            if (json) {
                snprintf(buf,sizeof(buf),",\n        { \"align\": \"%s\" }",val);
            } else {
                snprintf(buf,sizeof(buf),"        <align>%s</align>\n",val);
            }
            addToBuffer(&gprints,buf,0);
            break;
        case GF_HRULE:
            /* This does not work as expected - Tobi please help!!! */
            snprintf(dbuf,sizeof(dbuf),"%0.10e",im->gdes[i].vf.val);
            /* and output it */
            if (json) {
                snprintf(buf,sizeof(buf),",\n        { \"hrule\": \"%s\" }",dbuf);
            } else {
                snprintf(buf,sizeof(buf),"        <hrule>%s</hrule>\n",dbuf);
            }
            addToBuffer(&rules,buf,0);
            break;
        case GF_VRULE:
            if (timefmt) {
                struct tm loc;
                localtime_r(&im->gdes[i].xrule,&loc);
                strftime(dbuf,254,timefmt,&loc);
            } else {
                snprintf(dbuf,254,"%lld",(long long int)im->gdes[i].vf.when);
            }
            /* and output it */
            if (json) {
                snprintf(buf,sizeof(buf),",\n        { \"vrule\": \"%s\" }",dbuf);
            } else {
                snprintf(buf,sizeof(buf),"        <vrule>%s</vrule>\n",dbuf);
            }
            addToBuffer(&rules,buf,0);
            break;
        default:
            break;
        }
    }
    /* now add prints */
    if (prints.len) {
        if (json) {
            snprintf(buf,sizeof(buf),"    \"%s\": [\n","prints");
            addToBuffer(buffer,buf,0);
            addToBuffer(buffer,(char*)prints.data+2,prints.len-2);
            addToBuffer(buffer,"\n        ],\n",0);
        } else {
            snprintf(buf,sizeof(buf),"    <%s>\n", "prints");
            addToBuffer(buffer,buf,0);
            addToBuffer(buffer,(char*)prints.data,prints.len);
            snprintf(buf,sizeof(buf),"    </%s>\n", "prints");
            addToBuffer(buffer,buf,0);
        }
        free(prints.data);
    }
    /* now add gprints */
    if (gprints.len) {
        if (json) {
            snprintf(buf,sizeof(buf),"    \"%s\": [\n","gprints");
            addToBuffer(buffer,buf,0);
            addToBuffer(buffer,(char*)gprints.data+2,gprints.len-2);
            addToBuffer(buffer,"\n        ],\n",0);
        } else {
            snprintf(buf,sizeof(buf),"    <%s>\n", "gprints");
            addToBuffer(buffer,buf,0);
            addToBuffer(buffer,(char*)gprints.data,gprints.len);
            snprintf(buf,sizeof(buf),"    </%s>\n", "gprints");
            addToBuffer(buffer,buf,0);
        }
        free(gprints.data);
    }
    /* now add rules */
    if (rules.len) {
        if (json) {
            snprintf(buf,sizeof(buf),"    \"%s\": [\n","rules");
            addToBuffer(buffer,buf,0);
            addToBuffer(buffer,(char*)rules.data+2,rules.len-2);
            addToBuffer(buffer,"\n        ],\n",0);
        } else {
            snprintf(buf,sizeof(buf),"    <%s>\n", "rules");
            addToBuffer(buffer,buf,0);
            addToBuffer(buffer,(char*)rules.data,rules.len);
            snprintf(buf,sizeof(buf),"    </%s>\n", "rules");
            addToBuffer(buffer,buf,0);
        }
        free(rules.data);
    }
    /* and return */
    return 0;
}