コード例 #1
0
static lwres_result_t
lwres_conf_parsedomain(lwres_context_t *ctx,  FILE *fp) {
	char word[LWRES_CONFMAXLINELEN];
	int res, i;
	lwres_conf_t *confdata;

	confdata = &ctx->confdata;

	res = getword(fp, word, sizeof(word));
	if (strlen(word) == 0U)
		return (LWRES_R_FAILURE); /* Nothing else on line. */
	else if (res == ' ' || res == '\t')
		res = eatwhite(fp);

	if (res != EOF && res != '\n')
		return (LWRES_R_FAILURE); /* Extra junk on line. */

	if (confdata->domainname != NULL)
		CTXFREE(confdata->domainname,
			strlen(confdata->domainname) + 1); /*  */

	/*
	 * Search and domain are mutually exclusive.
	 */
	for (i = 0; i < LWRES_CONFMAXSEARCH; i++) {
		if (confdata->search[i] != NULL) {
			CTXFREE(confdata->search[i],
				strlen(confdata->search[i])+1);
			confdata->search[i] = NULL;
		}
	}
	confdata->searchnxt = 0;

	confdata->domainname = lwres_strdup(ctx, word);

	if (confdata->domainname == NULL)
		return (LWRES_R_FAILURE);

	return (LWRES_R_SUCCESS);
}
コード例 #2
0
ファイル: psfcheck.C プロジェクト: VictorMion/vmd-cvs-github
int parsetop(char* topin, FILE* outpsf, PsfResList* knownRes) {
	char line[101];
	//char temp[20];
	//char type[5];
	//char element[3];
	PsfRes* currRes;
	FILE* psfin;
	psfin = fopen(topin, "r");

	if (psfin == NULL) {
		fputs("Warning: Couldn't open input file ", stderr);
		fputs(topin, stderr);
		fputs("\n",stderr);
//		stderr << "Warning: Couldn't open input file " << topin << endl;
		return 1;
	}

	while(fgets(line,100,psfin)) {
  //  	        // Read the list of atomtypes
// 	        if (strncmp(line, "MASS", 4) == 0) {
// 		  int  index=0;
// 		  float mass=0;
// 		  sscanf(line, "%s %i %s %f %s", temp, &index, type, &mass, element);
// 		  PsfType* currType = new PsfType(type,mass,element);
// 		  knownType->addtype(currType);
// 		}
		//Check if we've gotten to the residue part yet
		if (strncmp(line, "RESI", 4) == 0) {
			//If so, parse and add the residue
			fprintf(outpsf,"%s",line);
//			char* comment='!';
			currRes = addTopRes(line, psfin, outpsf);
			knownRes->addres(currRes);
		} else if (strncasecmp(eatwhite(line),"END",3)) {
		       	fprintf(outpsf,"%s",line);
		}
	}
	fclose(psfin);
	return 0;
}
コード例 #3
0
ファイル: Expression.cpp プロジェクト: ajbennieston/misc
double Expression::readToken(std::map<char, double>& substitutions, std::istream& in)
{
	char ch;
	eatwhite(in); // Skip whitespace

	in.get(ch);
	if ( isalpha(ch) )
		return substitutions[ch]; // Substitute a variable
	else if ( ch == '$' )
	{
		// Evaluate a subexpression
		Expression sub = local_subs.front();
		local_subs.pop_front();
		return sub.evaluate(substitutions);
	}
	else if ( isdigit(ch) || ch == '.' )
	{
		// Read a number
		in.putback(ch);
		double num;
		in >> num;
		return num;
	}
コード例 #4
0
ファイル: gettoken.c プロジェクト: tangentforks/zpl
static int yylex2(void) {
  int ch;
  int chkcomment = FALSE;

yuk_a_goto:
	eatwhite();
	if ((ch = GETC(fname)) == EOF) {
	  if (firstsemi == 1) {
	    firstsemi = 0;
	    fclose(fname);
	    fname = fnamesave;
	    goto yuk_a_goto;
	  }
	  else {
	    return(TENDOFFILE);
	  }
	}
	do {
		if (ch == '/')
			if ((ch = GETC(fname)) == '*') {
				eatcomment();
				eatwhite();
				chkcomment = TRUE;
				if ((ch = GETC(fname)) == EOF)
					return(TENDOFFILE);
			} else {
				UNGETC(ch, fname);
				ch = '/';
				chkcomment = FALSE;
			}
		else if (ch == '-')	/* -- is a comment in our language */
		{
			if ((ch = GETC(fname)) == '-')
			{
				eatline();	 /* ignore rest of line */
				if (firstsemi != 1) yylineno++;
				eatwhite();
				chkcomment = TRUE;
				if ((ch = GETC(fname)) == EOF)
					return(TENDOFFILE);
			}
			else
			{
				UNGETC(ch, fname);
				ch = '-';
				chkcomment = FALSE;
			}
		}
		else
			chkcomment = FALSE;
	} while (chkcomment);
	if (isalpha(ch) || ch == '_')
		return(eatident(ch));
	if (isdigit(ch))
		return(eatnumber(ch));
	if (ch == '"')
		return(eatstring());
	if (ch == '\'') {
	  char ch2;
	  char ch3;
	  char chat;
	  int ate;
	  
	  ch2 = GETC(fname);
	  ch3 = GETC(fname);
	  UNGETC(ch3,fname);
	  UNGETC(ch2,fname);
	  if (ch2 != ' ' || ch3 != '\'') {
	    /* can't eat whitespace if char contains whitespace */
	    ate = eatwhite();
	    chat = GETC(fname);
	    UNGETC(chat,fname);
	    if (chat == '@') {
	      if (ate || (ch2 != '@' && ch3 != '\'')) {
		return TPRIME;
	      }
	    }
	  }
	  return eatcharacter();
	}
	if (ch == '.') {
		if (isdigit(ch = GETC(fname))) {
			UNGETC(ch, fname);
			ch = '.';
			return(eatnumber(ch));
		} else {
			UNGETC(ch, fname);
			ch = '.';
		}
	}
	if (ch == '#') {
	  char ch2;
		eatwhite();
		/* remove "line" if it exists - some vers of cpp have this */
		if ((ch2 = GETC(fname)) == '[') {
		  UNGETC(ch2, fname);
		  return eatleftovers(ch);
		}
		else {
		  UNGETC(ch2, fname);
		}
		if (!isdigit(ch = GETC(fname))) {
			UNGETC(ch, fname);
			yylex2();
			if (!strcmp(buffer,"pragma")) {
			  for (ch = GETC(fname); ch != '\n'; ch = GETC(fname)) ;
			  goto yuk_a_goto;
			}
			if (strcmp(buffer,"line")) {
			  USR_FATALX(yylineno, in_file,
				     "syntax error (appears to be a cpp directive: try -cpp)");
			}
			eatwhite();
		} else {
			UNGETC(ch, fname);
		}

		if (!isdigit(ch = GETC(fname))) {
			UNGETC(ch, fname);
			USR_FATALX(yylineno, in_file,
				   "syntax error (appears to be a cpp directive: use -cpp)");
		} else
			UNGETC(ch, fname);
		yylex2();
		yylineno = atoi(buffer);

		for (ch = GETC(fname); ch != '"' && ch != '\n'; ch = GETC(fname))
			;
		if (ch != '"') {
			goto yuk_a_goto;
		} else
			UNGETC(ch, fname);
		yylex2();

		
		in_file = (char *)PMALLOC((strlen(buffer) + 1)*sizeof(char));
		strcpy(in_file, buffer);
		base_in_file = strrchr(in_file,'/');
		if (base_in_file == NULL) {
		  base_in_file = in_file;
		} else {
		  base_in_file++;
		}
		for (ch = GETC(fname); ch != '\n'; ch = GETC(fname))
			;

		goto yuk_a_goto;
	}
	if (ispunct(ch))
		return(eatleftovers(ch));

	
	buffer[0] = ch; buffer[1] = '\0';

	  if (firstsemi == 1) {
	    firstsemi = 0;
	    fclose(fname);
	    fname = fnamesave;
	    goto yuk_a_goto;
	  }

	return(-1);
}
コード例 #5
0
ファイル: sisl_view_demo.cpp プロジェクト: BowenRaymone/SISL
static void read_curves_and_surfaces(int argc, char *argv[])
{
  xscale=yscale=zscale=1.0;
  int ref=DEFAULT_REF; // Number of new knots between old ones.
  int maxref=DEFAULT_MAX_REF; // Maximal number of coeffs in any given direction.
  // (n, n) makes sure new knots are inserted close to max limit = n...
  int i;

  //
  // This must be reset every time we change control vertices, since
  // the discretization is done in the drawing routine.
  //
  for (i=0; i<curves; i++) {
    if (discr_curve[i]!=NULL) {
      delete discr_curve[i];
      discr_curve[i]=NULL;
    }
  }

  // @HH@
  // @HH@ Use the following optional command line options:
  // @HH@
  
  surfaces=0;
  curves=0;



  for (i=1; i<argc; i++) {
    switch (argv[i][0]) {
    case 's': {
      // Next string is filename for surface. (One surface.)
	    
      puts("Reading surfaces");
      // surface[surfaces-1]=read_nurbs_sf(argv[i+1]); // old format    

      std::vector<SISLSurf*> tmp;
      std::ifstream is(argv[i+1]);
      if (!is) {
	CRIT_ERR(printf("Could not open file: '%s'.\n", argv[i+1]));
      }
      try {
	eatwhite(is);
	while (!is.eof()) {
	  //surface[surfaces-1] = readGoSurface(is);
	  tmp.push_back(readGoSurface(is));
	  eatwhite(is);
	}
      } catch (std::exception& e) {
	CRIT_ERR(printf("Error occured while reading surface: %s\n", e.what()));
      }
      is.close();
      int num_surfaces = tmp.size();
      if (surfaces + num_surfaces > MAX_SURFACES) {
	CRIT_ERR(puts("Increase MAX_SURFACES."));
      }
	    
      for (int k = 0; k < num_surfaces; ++k) {
	//
	// 010116: This should be a quick fix for periodic
	//         surfaces...
	//
	if (tmp[k] == NULL) {
	  CRIT_ERR(printf("Couldn't read SISLSurf '%s'.\n", argv[i+1]));	    
	}

	if ((tmp[k]->cuopen_1 == SISL_CRV_PERIODIC ||
	     tmp[k]->cuopen_2 == SISL_CRV_PERIODIC)) {
	  int kstat;
	  SISLSurf *tmp_surf;
	  make_sf_kreg(tmp[k], &tmp_surf, &kstat);
	  if (kstat < 0) {
	    CRIT_ERR(printf("make_sf_kreg failed!\n"));
	  }
	  freeSurf(tmp[k]);
	  tmp[k] = tmp_surf;
	}
	if (tmp[k]->idim != 3) {
	  CRIT_ERR(printf("Dimension of surface is %d and not 3!\n",
			  tmp[k]->idim));
	}
		
	if (surface[surfaces]) {
	  // deleting old surface
	  freeSurf(surface[surfaces]);
	}
	surface[surfaces] = tmp[k];
	surface_name[surfaces] = argv[i+1];
	surf_enabled[surfaces] = 1;

	// Generating an approximating polygon.
	lower_degree_and_subdivide(surface + surfaces, ref, maxref);

	// evaluating normals (normalized)
	delete normal[surfaces];
	compute_surface_normals(surface[surfaces], normal + surfaces);
		
	++surfaces;
      }
    }
      i++;
      break;
      
    case 'c': {
      // Next string is filename for file containing 1 curve.
	    
      printf("Reading a single curve into slot %d.\n", curves);

      std::vector<SISLCurve*> tmp;
	    
      //n=get_curve_set(argv[i+1], &tmp, &stat);
      //get_single_curve(argv[i+1], &tmp, &stat); // old format
      std::ifstream is(argv[i+1]);
      if (!is) {
	CRIT_ERR(printf("Could not open file: '%s'.\n", argv[i+1]));
      }
      try {
	eatwhite(is);
	while (!is.eof()) {
	  tmp.push_back(readGoCurve(is));
	  eatwhite(is);
	}
      } catch (std::exception& e) {
	CRIT_ERR(printf("Error occured while reading curve: %s\n", e.what()));
      }
      is.close();
      int num_curves = tmp.size();

      if (curves + num_curves > MAX_CURVES) {
	CRIT_ERR(puts("Increase MAX_CURVES."));
      }
	    
      for(int k = 0; k < num_curves; ++k) {
	if (curve[curves + k] != NULL) {
	  freeCurve(curve[curves + k]);
	}
	curve[curves + k] = tmp[k];
		
	//
	// 001206: If the dimension is 2, we set up a
	//         new curve, filling in zeros.
	//
	if (curve[curves + k]->idim==2) {
		    
	  double *new_coeffs=
	    new double[3*curve[curves + k]->in];
	  if (new_coeffs==NULL)
	    CRIT_ERR(puts("Couldn't allocate memory."));
	  int j;
		    
	  for (j=0; j<curve[curves + k]->in; j++) {
	    new_coeffs[3*j+0]= curve[curves + k]->ecoef[2*j+0];
	    new_coeffs[3*j+1]= curve[curves + k]->ecoef[2*j+1];
	    new_coeffs[3*j+2]=0.0;
	  }
	  SISLCurve *tmp2=curve[curves + k];
	  curve[curves + k]= newCurve(tmp2->in, tmp2->ik, tmp2->et,
				      new_coeffs, tmp2->ikind, 3, 1);
	  freeCurve(tmp2);
	}
		
	if (curve[curves + k]->idim!=3) {
	  CRIT_ERR(printf("Dimension of curve is %d and not 3?!\n",
			  curve[curves + k]->idim));
	}

	curve_name[curves + k]=argv[i+1];
	curve_enabled[curves + k]=1;
      }
      curves+=num_curves;
    }
      i++;
      break;
	    
    case 'p': {
      // Next string is filename for file containing a point cloud.
	    
      printf("Reading a point cloud.\n");

      std::ifstream is(argv[i+1]);
      if (!is) {
	CRIT_ERR(printf("Could not open file: '%s'.\n", argv[i+1]));
      }
      try {
	  vector<double> coords;
	  readGoPoints(coords, is);
	  int num_points = int(coords.size()) / 3;
	  printf("Number of vertices: %d\n", num_points);
	  for (int i = 0; i < num_points; ++i) {
	      pcloud.push_back(vector3t<float>(coords[3 * i], 
					       coords[3 * i + 1], 
					       coords[3 * i + 2]));
	  }
// 	eatwhite(is);
// 	int tmp;
// 	is >> tmp;
// 	is >> tmp;
// 	is >> tmp;
// 	is >> tmp;
// 	is >> tmp;
// 	is >> tmp;
// 	is >> tmp;
// 	is >> tmp;
// 	eatwhite(is);
// 	is >> tmp;
// 	printf("Number of vertices: %d\n", tmp);
// 	while (!is.eof()) {
// 	  double x, y, z;
// 	  is >> x;
// 	  is >> y;
// 	  is >> z;
// 	  //printf("point: %f %f %f\n", x, y, z);
// 	  pcloud.push_back(vector3t<float>(x, y, z));
// 	  eatwhite(is);
//      }
      } catch (std::exception& e) {
	  CRIT_ERR(printf("Error occured while reading curve: %s\n", e.what()));
      }
      is.close();
      printf("pcloud size is now %d\n", pcloud.size());
    }
	i++;
      break;
	    
// 	case 'r':
// 	    // Set refinement factor. Default value is ???.
	    
// 	    puts("Reading surface refinement factor");
// 	    ref=atoi(argv[i+1]);
// 	    i++;
// 	    break;
	    
//	case 'R': 
    case 'r':
      // Set max refinement factor. Default value is ???.
	    
      puts("Reading upper bound for surface refinement.");
      maxref=atoi(argv[i+1]);
      i++;
      break;
	    
    case 'e': 
      // String with keypresses to execute follows. Not
      // everything will work!
	    
      printf("Executing '%s'.\n", argv[i+1]);
      strncpy(init_key_string, argv[i+1], 1000);
      i++;
      break;
	    
    default:
      puts("Huh?! Unknown option.");
      exit(0);
	    
    }
  }
}
コード例 #6
0
ファイル: aqwin.c プロジェクト: droyo/graphics
static aqwin_param *parse_cfg(const char *cfg) {
	char *cp;
	aqwin_param *param;
	aqwin_tuple *last;

	if ((param = malloc(sizeof *param)) == NULL) {
		complain("aqwin_open: nomem param\n");
		goto e0_nomem_param;
	}
	memset(param, 0, sizeof *param);
	if ((param->buf = malloc(strlen(cfg))) == NULL) {
		complain("aqwin_open: nomem param buf\n");
		goto e1_nomem_parambuf;
	}
	strcpy(param->buf, cfg);
	if ((param->attr = malloc(sizeof *(param->attr))) == NULL) {
		complain("aqwin_open: nomem param attr\n");
		goto e2_nomem_paramattr;
	}
	memset(param->attr, 0, sizeof *(param->attr));
	
	last = param->attr;
	
	cp = param->buf;
	for(eatwhite(&cp); *cp; cp++) {
	skip_inc:
		if(*cp == '=' && last->key == NULL) {
			complain("aqwin_open: keys cannot begin with '='\n");
			goto e3_parse_error;
		} 
		else if(*cp == '=') {
			*cp = '\0';
			last->val = cp + 1;
		}
		else if(*cp == '\'') {
			*cp++ = '\0';
			if (last->val) {
				last->val = cp;
			} else {
				complain("aqwin_open: quoted key\n");
				goto e3_parse_error;
			}
			if (charff(&cp, '\'')) {
				*cp++ = '\0';
			} else {
				complain("aqwin_open: unterminated string\n");
				goto e3_parse_error;
			}
			eatwhite(&cp);
			if((last->next = malloc(sizeof *last)) == NULL) {
				complain("aqwin_open: nomem next param\n");
				goto e3_nomem_paramnext;
			}
			last = last->next;
			memset(last, 0, sizeof *last);
			goto skip_inc;
		}
		else if(isws(*cp)) {
			*cp = '\0';
			last->val = last->val ? last->val : cp;
			if (parse_attr(last)) {
				goto e3_parse_error;
			}
			cp++;
			eatwhite(&cp);
			if((last->next = malloc(sizeof *last)) == NULL) {
				complain("aqwin_open: nomem next param\n");
				goto e3_nomem_paramnext;
			}
			last = last->next;
			memset(last, 0, sizeof *last);
			goto skip_inc;
		}
		else if(last->key == NULL) {
			last->key = cp;
		}
	}
	return param;

e3_nomem_paramnext:
e3_parse_error:
	aqwin_tuple_free(param->attr);
e2_nomem_paramattr:
	free(param->buf);
e1_nomem_parambuf:
	free(param);
e0_nomem_param:
	return NULL;
}
コード例 #7
0
ファイル: utils.c プロジェクト: SKAcz/bics-current
char *nextword(char *str)
{
  return eatwhite(eatword(str));
}
コード例 #8
0
ファイル: matchproc.c プロジェクト: SKAcz/bics-current
/* board and category are initially empty strings */
static int parse_match_string(int p, int* wt,int* bt,int* winc,int* binc,
                                int* white,int* rated,char* category,
			        char* board, char* mstring)
{
  int numba;
  int confused = 0;
  char parsebuf[100];


  while (!confused && (sscanf(mstring, " %99s", parsebuf) == 1)) {
    mstring = eatword(eatwhite(mstring));

    if (isdigit(*parsebuf)) {
      if ((numba = atoi(parsebuf)) < 0) {
        pprintf(p, "You can't specify negative time controls.\n");
        return 0;
      } else if (numba > 999) {
        pprintf(p, "You can't specify time or inc above 999.\n");
        return 0;
      } else if (*wt == -1) {
        *wt = numba;
      } else if (*winc == -1) {
        *winc = numba;
      } else if (*bt == -1) {
        *bt = numba;
      } else if (*binc == -1) {
        *binc = numba;
      } else
        confused = 1;

    } else if ((!strcmp("rated", parsebuf)) || (!strcmp("r",parsebuf))) {
      if (*rated == -1)
        *rated = 1;
      else
        confused = 1;
    } else if ((!strcmp("unrated", parsebuf)) || (!strcmp("u",parsebuf))) {
      if (*rated == -1)
        *rated = 0;
      else
        confused = 1;
    } else if (!strcmp("white", parsebuf) || !strcmp ("w", parsebuf)) {
      if (*white == -1)
        *white = 1;
      else
        confused = 1;
    } else if (!strcmp("black", parsebuf) || !strcmp ("b", parsebuf)) {
      if (*white == -1)
        *white = 0;
      else
        confused = 1;

    }
	else if (!strcmp("bughouse", parsebuf) || !strcmp ("bug", parsebuf))
	{
   		strcpy(category, "bughouse");
	} else if (!strcmp("zh", parsebuf))
	{
		strcpy(category,parsebuf);
	}
	else if (category[0] && !board[0])
	{
		if (!strcmp("fr", parsebuf))
			strcpy (board, "FR");
		else if ((parsebuf[0] == 'w') && (isdigit(*(parsebuf + 1))))
			strcpy (board, parsebuf+1);
		else
			strcpy(board, parsebuf);
	}


	else
      confused = 1;
  }

  if (confused) {
    pprintf(p, "Can't interpret %s in match command.\n", parsebuf);
    return 0;
  }
  return 1;
}