Esempio n. 1
0
void help(int* tt)
     /*******************************/
     /* Function: helps player      */
     /*                             */
     /* Parameters:                 */
     /*      tt: IN a guess         */
     /*******************************/
{
    int z, w ;
    
    skipline(1);

    z = 0;
    
    /* Enter the guess you need the hint for */
    while (z < 1 || z > cur)
      {
	z = 0;
	format_output("Enter the guess you need the hint for -> ",1);
	while((*tt = getchar()) != '\n')
	  z = z * 10 + *tt - '0';
      }
    
    w = 0;
    /*choose the peg you need the hint for */
    while (w < 1 || w > 4)
      {
	w = 0;
	format_output("Which peg of guess",1);
	printf(" #%d -> ",z);
	while((*tt = getchar()) != '\n')
	  w = w * 10 + *tt - '0';
      }
    
    format_output("In guess",1);
    printf(" #%d,",z);
    printf("peg #%d received ",w);
    
    if (guesses[z - 1].pegs[w - 1].used == BLACK)
      format_output("a black peg.\n",0);
    
    if (guesses[z - 1].pegs[w - 1].used == WHITE)
      format_output("a white peg.\n",0);
    
    if (guesses[z - 1].pegs[w - 1].used == NONE)
	format_output("no peg.\n",0);
    
    skipline(1);
}
Esempio n. 2
0
wmo_message *
get_wmo_message(xbuf *buf, wmo_message *mess)
{
	init_wmo_message(buf, mess);

#if 0
	if(mess->msg == NULL || mess->msg[0] != SOH)
		return NULL;

	if(mess->len < MIN_WMO_MSG_LEN)
		return NULL;
#endif

	/* skip SOH CR CR NL */
	if(skipline(buf, 4) < 0) return NULL;

	if( get_wmo_start(buf, mess->start) == NULL )
		return NULL;
	if( get_wmo_header(buf, mess->hdr) == NULL )
		return NULL;

#if 0
	if(mess->msg[mess->len-1] != ETX )
		return NULL;
#endif

#if 0 /* DEBUG */
	fprint_wmo_header(stderr, mess->hdr);
	fputc(' ', stderr);
	fprint_wmo_start(stderr, mess->start);
	fprintf(stderr," \tplen %-7d ok\n", len);
#endif

	return mess;
}
Esempio n. 3
0
int
SimpleMixer::parse_output_scaler(const char *buf, unsigned &buflen, mixer_scaler_s &scaler)
{
	int ret;
	int s[5];
	int n = -1;

	buf = findtag(buf, buflen, 'O');

	if ((buf == nullptr) || (buflen < 12)) {
		debug("output parser failed finding tag, ret: '%s'", buf);
		return -1;
	}

	if ((ret = sscanf(buf, "O: %d %d %d %d %d %n",
			  &s[0], &s[1], &s[2], &s[3], &s[4], &n)) != 5) {
		debug("out scaler parse failed on '%s' (got %d, consumed %d)", buf, ret, n);
		return -1;
	}

	buf = skipline(buf, buflen);

	if (buf == nullptr) {
		debug("no line ending, line is incomplete");
		return -1;
	}

	scaler.negative_scale	= s[0] / 10000.0f;
	scaler.positive_scale	= s[1] / 10000.0f;
	scaler.offset		= s[2] / 10000.0f;
	scaler.min_output	= s[3] / 10000.0f;
	scaler.max_output	= s[4] / 10000.0f;

	return 0;
}
Esempio n. 4
0
void
outrumor(void)
{
	int             rn, i;
	FILE           *rumf;
	if (n_rumors <= n_used_rumors ||
	    (rumf = fopen(RUMORFILE, "r")) == (FILE *) 0)
		return;
	if (n_used_rumors < 0)
		init_rumors(rumf);
	if (!n_rumors)
		goto none;
	rn = rn2(n_rumors - n_used_rumors);
	i = 0;
	while (rn || used(i)) {
		(void) skipline(rumf);
		if (!used(i))
			rn--;
		i++;
	}
	usedbits[i / CHARSZ] |= (1 << (i % CHARSZ));
	n_used_rumors++;
	outline(rumf);
none:
	(void) fclose(rumf);
}
Esempio n. 5
0
static fill_stack_t* xyread4f(FILE* stream, char* buf)
{
  fill_stack_t* f;
  double r, g, b;
  double z;

  do
    if (fgets(buf, BUFSIZE, stream) == NULL)
      return NULL;
  while (skipline(buf));

  if (sscanf(buf, "%lf %lf %lf %lf", &z, &r, &g, &b) != 4)
    {
      btrace("bad line:  %s", buf);
      return NULL;
    }

  if ((f = malloc(sizeof(fill_stack_t))) == NULL)
    return NULL;

  f->fill.type = fill_colour;
  f->val       = z;

  f->fill.u.colour.rgb.red   = colour8(r);
  f->fill.u.colour.rgb.green = colour8(g);
  f->fill.u.colour.rgb.blue  = colour8(b);

  f->next = xyread4f(stream, buf);

  return f;
}
Esempio n. 6
0
static fill_stack_t* xyread3i(FILE* stream, char* buf, int n)
{
  fill_stack_t* f;
  int r, g, b;

  do
    if (fgets(buf, BUFSIZE, stream) == NULL)
      return NULL;
  while (skipline(buf));

  if (sscanf(buf, "%d %d %d", &r, &g, &b) != 3)
    {
      btrace("bad line: %s", buf);
      return NULL;
    }

  if ((f = malloc(sizeof(fill_stack_t))) == NULL)
    return NULL;

  f->fill.type = fill_colour;
  f->val       = n;

  f->fill.u.colour.rgb.red   = r;
  f->fill.u.colour.rgb.green = g;
  f->fill.u.colour.rgb.blue  = b;

  f->next = xyread3i(stream, buf, n+1);

  return f;
}
Esempio n. 7
0
static fill_stack_t* xyread2f(FILE* stream, char* buf)
{
  fill_stack_t* f;
  double v, d;

  do
    if (fgets(buf, BUFSIZE, stream) == NULL)
      return NULL;
  while (skipline(buf));

  if (sscanf(buf, "%lf %lf", &v, &d) != 2)
    {
      btrace("bad line: %s", buf);
      return NULL;
    }

  if ((f = malloc(sizeof(fill_stack_t))) == NULL)
    return NULL;

  f->fill.type   = fill_grey;
  f->fill.u.grey = colour8(d);
  f->val         = v;
  f->next        = xyread2f(stream, buf);

  return f;
}
Esempio n. 8
0
static fill_stack_t* xyread1i(FILE* stream, char* buf, int n)
{
  fill_stack_t* f;
  int i;

  do
    if (fgets(buf, BUFSIZE, stream) == NULL)
      return NULL;
  while (skipline(buf));

  if (sscanf(buf, "%d", &i) != 1)
    {
      btrace("bad line: %s", buf);
      return NULL;
    }

  if ((f = malloc(sizeof(fill_stack_t))) == NULL)
    return NULL;

  f->fill.type   = fill_grey;
  f->fill.u.grey = i;
  f->val         = n;
  f->next        = xyread1i(stream, buf, n+1);

  return f;
}
Esempio n. 9
0
/**
* The constructor needs to scan the whole PTX file to find out the bounding box. Unluckily.
* TODO: during the scan all the points are read and transformed. Afterwards, during loading
* the points are read again and transformed again. It should be nice to save the
* transformed points in a temporary file. That would mean a LAS file or something similar.
* Unuseful. It's better to convert the PTX to LAS files.
* TODO: it seems theat the PTXPointReader is asked to produce the bounding box more than once.
* Maybe it should be saved somewhere. Chez moi, scanning 14m points needs 90 secs. The
* process speed of the PTX file is about 1m points every 50 secs.
*/
PTXPointReader::PTXPointReader(string path) {
    this->path = path;

    if (fs::is_directory(path)) {
        // if directory is specified, find all ptx files inside directory

        for (fs::directory_iterator it(path); it != fs::directory_iterator(); it++) {
            fs::path filepath = it->path();
            if (fs::is_regular_file(filepath)) {
                if (icompare(fs::path(filepath).extension().string(), ".ptx")) {
                    files.push_back(filepath.string());
                }
            }
        }
    } else {
        files.push_back(path);
    }

    // open first file
    this->currentFile = files.begin();
    this->stream = new fstream(*(this->currentFile), ios::in);
    this->currentChunk = 0;
    skipline(*this->stream);
    loadChunk(this->stream, this->currentChunk, this->tr);
}
Esempio n. 10
0
EXPORT BOOL WINAPI xnoteadd( HSPEXINFO *hei, int p1, int p2, int p3 )
{
	//
	//		xnoteadd "strings" (type$202)
	//
	char *buf, *p, *str_to_add;
	int size;
	int line;

	str_to_add = hei->HspFunc_prm_gets();
	if (xn_pval->flag!=HSPVAR_FLAG_STR) return -1;
	buf = (char *)Hsp3GetBlockSize( hei, xn_pval, xn_aptr, &size );
	p = buf;
	line=0;
	while (*p != '\0') {
		if (lineeq(p, str_to_add) ) {
			DataInc(line);
			return -line;
		}
		p = skipline(p);
		line ++;
	}

	addline( hei, xn_pval, xn_aptr, p - buf, str_to_add );
	DataInc(line);
	return -line;
}
Esempio n. 11
0
	void error(bsparse_error_s id, ...) {
		if(!error_callback)
			return;
		int line, column;
		getpos(p, line, column);
		error_callback(id, geturl(), line, column, (const char**)xva_start(id));
		skipline();
	}
Esempio n. 12
0
void toNextValid(unsigned char* buf, unsigned int* index, unsigned int size) {
	nextnonwhitespace(buf,index,size);
	while(*index < size && buf[*index]=='/' && buf[(*index) + 1]=='/') { //comment
		//printf("Found comment at %i\n",*index);
		skipline(buf,index,size);
		nextnonwhitespace(buf,index,size);
	}
}
Esempio n. 13
0
/// gettok - Return the next token from standard input.
int lexer::gettok()
{
	// Skip any whitespace.
	c = skipspace(input, c, line_num);

	// identifier: [a-zA-Z][a-zA-Z0-9_]*
	if (isalpha(c)) { 
		str = c;
		do {
			c = input->get();
			if ( isalnum(c) || c=='_' )
				str += c;
			else
				break;
		} while (true);
		if (unlikely(literal_p(str)))
			return token_type::literal;
		else
			return token_type::identifier;
	}

	// Number: [0-9]+([.][0-9]*(eE[+-][0-9]+)*)*
	if (isdigit(c) || c == '.') {
		str = "";
		do {
			str += c;
			c = input->get();
		} while (isdigit(c) || c == '.');
		if (c == 'E' || c == 'e') {
			str += 'E';
			c = input->get();
			if (isdigit(c))
				str += '+';
			do {
				str += c;
				c = input->get();
			} while (isdigit(c));
		}
		return token_type::number;
	}

	// Comment until end of line.
	if (c == '#') {
		c = skipline(input);
		++line_num;
		if (c != EOF)
			return gettok();
	}

	// Check for end of file.  Don't eat the EOF.
	if (c == EOF)
		return token_type::eof;

	// Otherwise, just return the character as its ascii value.
	int current = c;
	c = input->get();
	return current;
}
Esempio n. 14
0
Gains_t* get_gold(const char* fname, Date_t* adate)
{
 Gains_t *this;
 FILE *iFile;

 char  /*                  char                        */
      line[1024]
    , msgbuf[1024]
   ;

 double  /*                double                      */
        gain1
      , gain2
      , gain3
      , gain4
      , gain5
      , gain7
      , ysl
   ;

 int   /*                  int                        */
      dsl
    , doy
    , year
   ;

 this = (Gains_t*)malloc(sizeof(Gains_t));
 iFile= fopen(fname,"r");
 if ( !iFile ) 
   { 
   sprintf(msgbuf,"unable to open file %s",fname); 
   ERROR(msgbuf, "get_gold");
   }

  skipline(iFile,2);
  this->valid_flag= false;

  while ( mygetline(line,1024,iFile)>=0 )
   {
   sscanf(line,"%d %d %d %lg %lg %lg %lg %lg %lg %lg",
          &year,&doy,&dsl,&ysl,&gain1,&gain2,&gain3,&gain4,&gain5,&gain7);

    if ( year == adate->year && doy == adate->doy )
      {
      this->gains[0]= (float)gain1;
      this->gains[1]= (float)gain2;
      this->gains[2]= (float)gain3;
      this->gains[3]= (float)gain4;
      this->gains[4]= (float)gain5;
      this->gains[6]= (float)gain7;
      this->valid_flag= true; 
      break;
      }
   }
 return this;
}
Esempio n. 15
0
static void
init_rumors(FILE *rumf)
{
	int             i;
	n_used_rumors = 0;
	while (skipline(rumf))
		n_rumors++;
	rewind(rumf);
	i = n_rumors / CHARSZ;
	usedbits = alloc(i + 1);
	for (; i >= 0; i--)
		usedbits[i] = 0;
}
Esempio n. 16
0
	void getpos(const char* p, int& line, int& column) {
		line = 0;
		column = 0;
		auto ps = getstart();
		while(*ps) {
			line++;
			auto pe = skipline(ps);
			if(p >= ps && p < pe) {
				column = p - ps + 1;
				return;
			}
			ps = pe;
		}
	}
Esempio n. 17
0
void skipline(FILE *fp)
{
  int ch; 
  while( (ch = fgetc(fp)) != '\n')
    if(ch == EOF)
      return;
  ch = fgetc(fp);
  if(ch == '#') {
    skipline (fp);
  } else {
    ungetc(ch, fp);
  }

}
Esempio n. 18
0
const char *
wmo_err_ident(xbuf *buf)
{
	static char identbuf[128];
	char *cp = identbuf;
	xbuf clone[1];
	int conv;

	(void) memset(identbuf, 0, sizeof(identbuf));

	clone_xbuf(buf, clone, 0);
	
#if 0
	conv = sprintf(cp, "%8u ******************",
			 (unsigned) clone->cnt);
#else
	conv = sprintf(cp, "%8u",
			 (unsigned) clone->cnt);
#endif
	cp += conv;

	/* skip SOH CR CR NL */
	if(skipline(clone, 4) < 0)
		return identbuf;

	{
		wmo_start_t start;
		if( get_wmo_start(clone, &start) == NULL )
			return identbuf;
		conv = sprintf(cp, "         %03d", start.seqno);
		cp += conv;
	}

	{
		wmo_header_t hdr;
		dtime time;
		hdr.time = &time;
		if( get_wmo_header(clone, &hdr) == NULL )
			return identbuf;
		conv = sprintf(cp, "  %s", s_wmo_header(&hdr));
		cp += conv;
		log_assert(cp < &identbuf[sizeof(identbuf)]);
	}
	
	return identbuf;
}
Esempio n. 19
0
void outrumor()
{
    int rn;
    int i;
    FILE *rumf;

    if(n_rumors <= n_used_rumors) {
        return;
    }
    else {
        rumf = fopen(RUMORFILE, "r");

        if(rumf == NULL) {
            return;
        }
    }

    if(n_used_rumors < 0) {
        init_rumors(rumf);
    }

    if(n_rumors == 0) {
        fclose(rumf);
        
        return;
    }

    rn = rn2(n_rumors - n_used_rumors);
    i = 0;

    while((rn != 0) || (used(i) != 0)) {
        skipline(rumf);
        
        if(used(i) == 0) {
            --rn;
        }

        ++i;
    }

    usedbits[i / CHARSZ] |= (1 << (i % CHARSZ));
    ++n_used_rumors;
    outline(rumf);
    fclose(rumf);
}
Esempio n. 20
0
void init_rumors(FILE *rumf)
{
    int i;
    n_used_rumors = 0;
    
    while(skipline(rumf) != 0) {
        ++n_rumors;
    }

    rewind(rumf);
    i = n_rumors / CHARSZ;
    usedbits = (char *)alloc((unsigned)(i + 1));

    while(i >= 0) {
        usedbits[i] = 0;
        --i;
    }
}
Esempio n. 21
0
void score_player()
     /**************************************/
     /* Function: defines score for        */
     /*           current guess            */
     /**************************************/ 
{
  int x, y;
    /* checks black pegs*/
  for (x = 0; x < 4; x++)
    guesses[cur].pegs[x].used = code.pegs[x].used = NONE;
  
  for (x = 0; x < 4; x++)
    if (guesses[cur].pegs[x].color == code.pegs[x].color)
      {
	/* guess color = code color */
	code.pegs[x].used = guesses[cur].pegs[x].used = BLACK;
	guesses[cur].blacks++;
        PDEBUG(0,guesses[cur].blacks);
	printf("b");
      }
  
  if (guesses[cur].blacks != 4)
    /* if not game_won, checks white pegs*/
    {
      for (x = 0; x < 4; x++)
	for (y = 0; y < 4; y++)
	  if (guesses[cur].pegs[x].color == code.pegs[y].color &&
	      !code.pegs[y].used && !guesses[cur].pegs[x].used)
	    {
	      code.pegs[y].used = guesses[cur].pegs[x].used = WHITE;
	      guesses[cur].whites++;
	      printf("w");
	    }
    }
  else
    game_won = TRUE;
  
  if (guesses[cur].blacks != 0 || guesses[cur].whites != 0)
    skipline(2);
  else
    /*bad guess,no score */
    format_output("No score.\n\n",1);
}
Esempio n. 22
0
char read_char(parser_t *p)
{
  char c;

  if (feof(p->f)) {
    c = '0';
  } else {
    c = fgetc(p->f);
    while (c == '#' || c == '!') {
      skipline(p);
      if (feof(p->f)) {
	c = '0';
      } else {
	c = fgetc(p->f);
      };
    }
  }

  return c;
}
Esempio n. 23
0
	static const char* skipws(const char* p) {
		while(*p) {
			if(p[0] == 9 || p[0] == 0x20) {
				p++;
				continue;
			} else if(p[0] == '\\') {
				p++;
				if(p[0] == 10 || p[0] == 13)
					p = szskipcr(p);
				else
					p++;
				continue;
			} else if(p[0] == '/' && p[1] == '/') {
				// Comments
				p = skipline(p + 2);
				continue;
			}
			break;
		}
		return p;
	}
Esempio n. 24
0
bool PTXPointReader::doReadNextPoint() {
    if (this->stream->eof()) {
        this->stream->close();
        this->currentFile++;

        if (this->currentFile != files.end()) {
            this->stream = new fstream(*(this->currentFile), ios::in);
            this->currentChunk = 0;
            skipline(*stream);
            loadChunk(stream, currentChunk, tr);
        } else {
            return false;
        }
    }
    vector<double> split;
    getlined(*stream, split);
    if (1 == split.size()) {
        this->currentChunk++;
        loadChunk(stream, currentChunk, tr);
        getlined(*stream, split);
    }
    auto size1 = split.size();
    if (size1 > 3) {
        this->p = transform(tr, split[0], split[1], split[2]);
        double intensity = split[3];
        this->p.intensity = (unsigned short)(65535.0 * intensity);
        if (4 == size1) {
            this->p.color.x = (unsigned char)(intensity * 255.0);
			this->p.color.y = (unsigned char)(intensity * 255.0);
			this->p.color.z = (unsigned char)(intensity * 255.0);
        } else if (7 == size1) {
            this->p.color.x = (unsigned char)(split[4]);
            this->p.color.y = (unsigned char)(split[5]);
            this->p.color.z = (unsigned char)(split[6]);
        }
    } else {
        this->p.intensity = INVALID_INTENSITY;
    }
    return true;
}
Esempio n. 25
0
int
SimpleMixer::parse_control_scaler(const char *buf, unsigned &buflen, mixer_scaler_s &scaler, uint8_t &control_group,
				  uint8_t &control_index)
{
	unsigned u[2];
	int s[5];

	buf = findtag(buf, buflen, 'S');

	if ((buf == nullptr) || (buflen < 16)) {
		debug("control parser failed finding tag, ret: '%s'", buf);
		return -1;
	}

	if (sscanf(buf, "S: %u %u %d %d %d %d %d",
		   &u[0], &u[1], &s[0], &s[1], &s[2], &s[3], &s[4]) != 7) {
		debug("control parse failed on '%s'", buf);
		return -1;
	}

	buf = skipline(buf, buflen);

	if (buf == nullptr) {
		debug("no line ending, line is incomplete");
		return -1;
	}

	control_group		= u[0];
	control_index		= u[1];
	scaler.negative_scale	= s[0] / 10000.0f;
	scaler.positive_scale	= s[1] / 10000.0f;
	scaler.offset		= s[2] / 10000.0f;
	scaler.min_output	= s[3] / 10000.0f;
	scaler.max_output	= s[4] / 10000.0f;

	return 0;
}
Esempio n. 26
0
static int
getlig(struct mfile *mp, int warn)	/* pick up ligature list */
{
	int lig;
	char *temp;

	lig = 0;
	while ((temp = sget(mp)) != NULL && strcmp(temp, "0") != 0) {
		if (strcmp(temp, "fi") == 0)
			lig |= LFI;
		else if (strcmp(temp, "fl") == 0)
			lig |= LFL;
		else if (strcmp(temp, "ff") == 0)
			lig |= LFF;
		else if (strcmp(temp, "ffi") == 0)
			lig |= LFFI;
		else if (strcmp(temp, "ffl") == 0)
			lig |= LFFL;
		else if (warn)
			errprint("illegal ligature %s\n", temp);
	}
	skipline(mp);
	return lig;
}
Esempio n. 27
0
File: bwbar.c Progetto: osuosl/bwbar
int main(int argc, char *argv[])
{
  FILE *pnd;
  char *interface;
  struct ifinfo {
    char name[8];
    unsigned int r_bytes, r_pkt, r_err, r_drop, r_fifo, r_frame;
    unsigned int r_compr, r_mcast;
    unsigned int x_bytes, x_pkt, x_err, x_drop, x_fifo, x_coll;
    unsigned int x_carrier, x_compr;
  } ifc;
  unsigned long long bin, bout, lbin, lbout;
  int first;
  struct timeval t_now, t_last;
  double maxbandwidth;
  double bwin, bwout, bwmeasure, timedelta;
  int opt;
  char *t_tmp, *g_tmp;
  /* Options */
  int measure_input = 0;	/* Input instead of output */
  char *text_file = "ubar.txt";	/* Text filename */
  char *graphics_file = "ubar.png"; /* Graphics filename */
  char *unit_name = "Mbit/s";	/* Unit name */
  double unit = 1.0e+6;		/* Unit multiplier */
  int interval = 15;		/* Interval between measurements (s) */
  int width = 600;		/* Bar width */
  int height = 4;		/* Bar height */
  int border = 1;		/* Bar border */

  program = argv[0];

  while ( (opt = getopt_long(argc, argv, "iof:p:t:x:y:b:kMGh", longopts, NULL)) != -1 ) {
    switch ( opt ) {
    case 'i':
      measure_input = 1;
      break;
    case 'o':
      measure_input = 0;
      break;
    case 'f':
      text_file = optarg;
      break;
    case 'p':
      graphics_file = optarg;
      break;
    case 't':
      interval = atoi(optarg);
      break;
    case 'x':
      width = atoi(optarg);
      break;
    case 'y':
      height = atoi(optarg);
      break;
    case 'b':
      border = atoi(optarg);
      break;
    case 'k':
      unit = 1.0e+3;
      unit_name = "kbit/s";
      break;
    case 'M':
      unit = 1.0e+6;
      unit_name = "Mbit/s";
      break;
    case 'G':
      unit = 1.0e+9;
      unit_name = "Gbit/s";
      break;
    case 'h':
      usage(0);
      break;
    default:
      usage(1);
      break;
    }
  }

  if ( argc-optind != 2 )
    usage(1);

  t_tmp = malloc(strlen(text_file) + 5);
  g_tmp = malloc(strlen(graphics_file) + 5);
  if ( !t_tmp || !g_tmp ) {
    perror(program);
    exit(1);
  }
  sprintf(t_tmp, "%s.tmp", text_file);
  sprintf(g_tmp, "%s.tmp", graphics_file);

  interface = argv[optind];
  maxbandwidth = atof(argv[optind+1]) * unit;

  first = 1;
  lbin = 0; lbout = 0;

  gettimeofday(&t_last, NULL);
  
  while ( 1 ) {

    /**** Begin code that obtains bandwidth data ****/

    gettimeofday(&t_now, NULL);
    pnd = fopen("/proc/net/dev", "r");
    if ( !pnd ) {
      fprintf(stderr, "%s: /proc/net/dev: %s", argv[0], strerror(errno));
      exit(1);
    }

    /* Skip header */
    skipline(pnd);
    skipline(pnd);

    /* Get interface info */
    do {
      if ( fscanf(pnd, " %[^:]:%u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u",
		  ifc.name,
		  &ifc.r_bytes, &ifc.r_pkt, &ifc.r_err, &ifc.r_drop,
		  &ifc.r_fifo, &ifc.r_frame, &ifc.r_compr, &ifc.r_mcast,
		  &ifc.x_bytes, &ifc.x_pkt, &ifc.x_err, &ifc.x_drop,
		  &ifc.x_fifo, &ifc.x_coll, &ifc.x_carrier, &ifc.x_compr)
	   != 17 ) {
	exit(200);
      }
      skipline(pnd);
    } while ( strcmp(ifc.name, interface) );

    bin  = ifc.r_bytes + (lbin & ~0xffffffffULL);
    bout = ifc.x_bytes + (lbout & ~0xffffffffULL);

    if ( bin < lbin )
      bin += (1ULL << 32);
    if ( bout < lbout )
      bout += (1ULL << 32);

    /**** Begin code that generates output ****/

    if ( !first ) {
      FILE *ubar, *pngmaker;

      timedelta = (double)(t_now.tv_sec - t_last.tv_sec) + 
	(t_now.tv_usec - t_last.tv_usec)/1.0e+6;
      bwin = (bin-lbin)*8/timedelta;
      bwout = (bout-lbout)*8/timedelta;

      bwmeasure = measure_input ? bwin : bwout;
      
      ubar = fopen(t_tmp, "w");
      pngmaker = fopen(g_tmp, "w");
      if ( ubar ) {
	fprintf(ubar, "Current bandwidth utilization %6.2f %s\n", bwmeasure/unit, unit_name);
	fclose(ubar);
	rename(t_tmp, text_file);
      }
      if ( pngmaker ) {
	write_bar_graph(pngmaker, bwmeasure/maxbandwidth, width, height, border, 5);
	fclose(pngmaker);
	rename(g_tmp, graphics_file);
      }
    } else {
      first = 0;
    }

    lbin = bin;  lbout = bout;  t_last = t_now;

    fclose(pnd);

    sleep(interval);
  }
}
Esempio n. 28
0
int  main(int npar, char ** parch)
{
  double buff;
  int i,j,k;
  int nx, nt, NfMx;
  char c;
  char *cteq="CTEQ";
  double *q,*x,*d;
  char version[30];
  int ordr, nf,nf6,nf5,nf4,nf3;
  double ordrf, nff;
  double Mc,Mb,Mt;
  double lambda,L6,L5,L4,L3;
  int Ncteq;
  char names[4][10]={"(6 -6)", "(5 -5)", "(4 -4)", "(3 -3)"};
  char * p;
  
  do scanf("%c",&c); while(c!=':');
  scanf("%s",version);
  p=strstr(version,".tbl");
  if(p) p[0]=0; 
  for(i=0;i<4;i++) 
  if(toupper(version[i]) !=cteq[i]) {fprintf(stderr,"Non expected file format\n"); return 1;}  
  Ncteq=version[4]-'0';
  switch(Ncteq)
  { case 5: Ncteq=4; break;
    case 4:
    case 6: break;
    default:{fprintf(stderr,"Unknown version CTEQ%d \n",Ncteq); return 2;}
  }
                    
  skipline(2);
  if(6!=scanf("%lf %lf %lf %*lf %*lf %*lf %lf %lf %lf", &ordrf, &nff,&lambda,&Mc,&Mb,&Mt )) goto errExit; 
  nf=nff; ordr=ordrf;
  skipline(2);
  if(3!=scanf("%d %d %d",&nx,&nt,&NfMx))goto errExit;
  printf("#distribution \"%s(proton)\"    2212 =>    ",version);
  for(i= 6-NfMx; i<4;i++) printf(" %s",names[i]);
  printf(" -1 -2 21 2 1 \n");

  printf("#distribution \"%s(anti-proton)\" -2212 =>  ",version);
  for(i=6-NfMx; i<4;i++) printf(" %s",names[i]);
  printf(" 1 2 21 -2 -1\n");
    
  skipline(2);
  scanf("%lf",&buff);  printf("\n#q_min %.5E\n", buff); 
  scanf("%lf",&buff); /* printf("\n#q_max %.5E\n", buff); */
  skipline(1);
  q=(double *)malloc(sizeof(double)*(nt+1));
  
    
  for(i=0;i<=nt;i++) scanf("%lf",q+i);
  printf("\n#Q_grid\n"); 
  for(i=0,j=1;i<=nt;i++,j++) 
  {  printf(" %.5E",q[i]); 
     if(j==10) {printf("\n"); j=0;}
  }   
  printf("\n");  

  writeAlpha(stdout,nf,ordr,lambda,NfMx,Mc,Mb,Mt,nt+1,q);

/*
  nf6=nf; L6=lambda;
  if(nf6==6) {nf5=5; L5=findLambda(5,ordr, alpha(6, ordr,L6, 175.) ,175.);}
        else {nf5=nf;L5=lambda;}
  if(nf5==5) {nf4=4; L4=findLambda(4,ordr, alpha(5, ordr,L5, 4.5 ) ,4.5);}
        else {nf4=nf;L4=lambda;}
  if(nf4==4) {nf3=3; L3=findLambda(3,ordr, alpha(4, ordr,L4, 1.4 ) ,1.4);}
        else {nf3=nf;L3=lambda;}

  printf("\n#Alpha\n");
  for(i=0,j=1;i<=nt;i++,j++) 
  {  double al;
     double Q=q[i];
           if(Q<1.4)  al=alpha(nf3, ordr, L3, Q);
     else  if(Q<4.5)  al=alpha(nf4, ordr, L4, Q);
     else  if(Q<175.) al=alpha(nf5, ordr, L5, Q);
     else             al=alpha(nf6, ordr, L6, Q);
     printf(" %.5E",al);
     if(j==10) {printf("\n"); j=0;}
  }   
  printf("\n");  
*/

  skipline(2);
  scanf("%lf",&buff);  printf("\n#x_min %.5E\n", buff);  
  skipline(1);
  printf("\n#X_grid\n");
  for(i=0,j=1;i<=nx;i++,j++) 
  {  scanf("%lf",&buff);     
     printf(" %.5E ",buff); 
     if(j==10) {printf("\n"); j=0;}
  }     
  printf("\n");

  skipline(2);
  
  printf("\n#Interpolation CTEQ%d  %f ",Ncteq,lambda); 
  for(k=0;k<3+NfMx;k++) 
  {  printf("\n#%d-parton\n",k+1);
     for(j=0;j<nt+1;j++) 
     { for(i=0;i<nx+1;i++) {scanf("%lf",&buff); printf(" %.5E",buff);} 
       printf("\n");
     }  
  }
  return 0;
 errExit:
  fprintf(stderr,"%d", ftell(stdin));
       
}
MultirotorMixer *
MultirotorMixer::from_text(Mixer::ControlCallback control_cb, uintptr_t cb_handle, const char *buf, unsigned &buflen)
{
	MultirotorGeometry geometry;
	char geomname[8];
	int s[4];
	int used;

	/* enforce that the mixer ends with a new line */
	if (!string_well_formed(buf, buflen)) {
		return nullptr;
	}

	if (sscanf(buf, "R: %7s %d %d %d %d%n", geomname, &s[0], &s[1], &s[2], &s[3], &used) != 5) {
		debug("multirotor parse failed on '%s'", buf);
		return nullptr;
	}

	if (used > (int)buflen) {
		debug("OVERFLOW: multirotor spec used %d of %u", used, buflen);
		return nullptr;
	}

	buf = skipline(buf, buflen);

	if (buf == nullptr) {
		debug("no line ending, line is incomplete");
		return nullptr;
	}

	debug("remaining in buf: %d, first char: %c", buflen, buf[0]);

	if (!strcmp(geomname, "4+")) {
		geometry = MultirotorGeometry::QUAD_PLUS;

	} else if (!strcmp(geomname, "4x")) {
		geometry = MultirotorGeometry::QUAD_X;

	} else if (!strcmp(geomname, "4h")) {
		geometry = MultirotorGeometry::QUAD_H;

	} else if (!strcmp(geomname, "4v")) {
		geometry = MultirotorGeometry::QUAD_V;

	} else if (!strcmp(geomname, "4w")) {
		geometry = MultirotorGeometry::QUAD_WIDE;

	} else if (!strcmp(geomname, "4s")) {
		geometry = MultirotorGeometry::QUAD_S250AQ;

	} else if (!strcmp(geomname, "4dc")) {
		geometry = MultirotorGeometry::QUAD_DEADCAT;

	} else if (!strcmp(geomname, "6+")) {
		geometry = MultirotorGeometry::HEX_PLUS;

	} else if (!strcmp(geomname, "6x")) {
		geometry = MultirotorGeometry::HEX_X;

	} else if (!strcmp(geomname, "6c")) {
		geometry = MultirotorGeometry::HEX_COX;

	} else if (!strcmp(geomname, "6t")) {
		geometry = MultirotorGeometry::HEX_T;

	} else if (!strcmp(geomname, "8+")) {
		geometry = MultirotorGeometry::OCTA_PLUS;

	} else if (!strcmp(geomname, "8x")) {
		geometry = MultirotorGeometry::OCTA_X;

	} else if (!strcmp(geomname, "8c")) {
		geometry = MultirotorGeometry::OCTA_COX;

	} else if (!strcmp(geomname, "6m")) {
		geometry = MultirotorGeometry::DODECA_TOP_COX;

	} else if (!strcmp(geomname, "6a")) {
		geometry = MultirotorGeometry::DODECA_BOTTOM_COX;

	} else if (!strcmp(geomname, "2-")) {
		geometry = MultirotorGeometry::TWIN_ENGINE;

	} else if (!strcmp(geomname, "3y")) {
		geometry = MultirotorGeometry::TRI_Y;

	} else {
		debug("unrecognised geometry '%s'", geomname);
		return nullptr;
	}

	debug("adding multirotor mixer '%s'", geomname);

	return new MultirotorMixer(
		       control_cb,
		       cb_handle,
		       geometry,
		       s[0] / 10000.0f,
		       s[1] / 10000.0f,
		       s[2] / 10000.0f,
		       s[3] / 10000.0f);
}
Esempio n. 30
0
File: jq_test.c Progetto: AndrewO/jq
static void run_jq_tests(jv lib_dirs, FILE *testdata) {
  char prog[4096];
  char buf[4096];
  struct err_data err_msg;
  int tests = 0, passed = 0, invalid = 0;
  unsigned int lineno = 0;
  int must_fail = 0;
  int check_msg = 0;
  jq_state *jq = NULL;

  jq = jq_init();
  assert(jq);
  if (jv_get_kind(lib_dirs) == JV_KIND_NULL)
    lib_dirs = jv_array();
  jq_set_attr(jq, jv_string("JQ_LIBRARY_PATH"), lib_dirs);

  while (1) {
    if (!fgets(prog, sizeof(prog), testdata)) break;
    lineno++;
    if (skipline(prog)) continue;
    if (checkfail(prog)) {
      must_fail = 1;
      check_msg = checkerrormsg(prog);
      jq_set_error_cb(jq, test_err_cb, &err_msg);
      continue;
    }
    if (prog[strlen(prog)-1] == '\n') prog[strlen(prog)-1] = 0;
    printf("Testing '%s' at line number %u\n", prog, lineno);
    int pass = 1;
    tests++;
    int compiled = jq_compile(jq, prog);

    if (must_fail) {
      jq_set_error_cb(jq, NULL, NULL);
      must_fail = 0;
      check_msg = 0;
      if (!fgets(buf, sizeof(buf), testdata)) { invalid++; break; }
      lineno++;
      if (buf[strlen(buf)-1] == '\n') buf[strlen(buf)-1] = 0;
      if (compiled) {
        printf("*** Test program compiled that should not have at line %u: %s\n", lineno, prog);
        invalid++; continue;
      }
      if (check_msg && strcmp(buf, err_msg.buf) != 0) {
        printf("*** Erroneous test program failed with wrong message (%s) at line %u: %s\n", err_msg.buf, lineno, prog);
        invalid++;
      } else {
        passed++;
      }
      continue;
    }

    if (!compiled) {
      printf("*** Test program failed to compile at line %u: %s\n", lineno, prog);
      invalid++;
      // skip past test data
      while (fgets(buf, sizeof(buf), testdata)) {
        lineno++;
        if (buf[0] == '\n' || (buf[0] == '\r' && buf[1] == '\n'))
          break;
      }
      continue;
    }
    printf("Disassembly:\n");
    jq_dump_disassembly(jq, 2);
    printf("\n");
    if (!fgets(buf, sizeof(buf), testdata)) { invalid++; break; }
    lineno++;
    jv input = jv_parse(buf);
    if (!jv_is_valid(input)){ invalid++; continue; }
    jq_start(jq, input, JQ_DEBUG_TRACE);

    while (fgets(buf, sizeof(buf), testdata)) {
      lineno++;
      if (skipline(buf)) break;
      jv expected = jv_parse(buf);
      if (!jv_is_valid(expected)){ invalid++; continue; }
      jv actual = jq_next(jq);
      if (!jv_is_valid(actual)) {
        jv_free(actual);
        printf("*** Insufficient results for test at line number %u: %s\n", lineno, prog);
        pass = 0;
        break;
      } else if (!jv_equal(jv_copy(expected), jv_copy(actual))) {
        printf("*** Expected ");
        jv_dump(jv_copy(expected), 0);
        printf(", but got ");
        jv_dump(jv_copy(actual), 0);
        printf(" for test at line number %u: %s\n", lineno, prog);
        pass = 0;
      }
      jv as_string = jv_dump_string(jv_copy(expected), rand() & ~(JV_PRINT_COLOUR|JV_PRINT_REFCOUNT));
      jv reparsed = jv_parse_sized(jv_string_value(as_string), jv_string_length_bytes(jv_copy(as_string)));
      assert(jv_equal(jv_copy(expected), jv_copy(reparsed)));
      jv_free(as_string);
      jv_free(reparsed);
      jv_free(expected);
      jv_free(actual);
    }
    if (pass) {
      jv extra = jq_next(jq);
      if (jv_is_valid(extra)) {
        printf("*** Superfluous result: ");
        jv_dump(extra, 0);
        printf(" for test at line number %u, %s\n", lineno, prog);
        pass = 0;
      } else {
        jv_free(extra);
      }
    }
    passed+=pass;
  }
  jq_teardown(&jq);
  printf("%d of %d tests passed (%d malformed)\n", passed,tests,invalid);
  if (passed != tests) exit(1);
}