int parseline( char* c1, char* c2, char* def)
{
size_t i = 1000;
int j, k, l, m;
int end = 0;
char c;
j = k = l = m = 0;
if(j = fscanf(stdin, " %s", c1))
{
while(isspace(c = getchar()))
{
if(c == '\n')
{
end = 1;
break;
}
}
m = ungetc(c, stdin);
if(!end && (k = fscanf(stdin, " %s", c2)))
{
while(isspace(c = getchar()))
{
if(c == '\n')
{
end = 1;
break;
}
}
if(!end)
{
m = ungetc(c, stdin);
l = getline(&def, &i, stdin);
def[l-1] = '\0';
}
}
}
if(!strcmp(c1, "add"))
{
if(k&&l)
{
return 1;
}
else return -1;
}
else if(!strcmp(c1, "find"))
{
if(k)
{
if(l)
return 7;
else
return 3;
}
else return -3;
}
else if(!strcmp(c1, "delete"))
{
if(k)
{
return 2;
}
else return -2;
}
else if(!strcmp(c1, "print"))
{
return 4;
}
else if(!strcmp(c1, "read"))
{
if(k)
{
return 6;
}
else return -5;
}
else if(!strcmp(c1, "exit"))
{
return 5;
}
else if(!strcmp(c1, "test"))
{
if(k)
return 8;
}
return -4;
}
/* The function f_collect() reads a string that has the format of a
* floating-point number. The function returns as soon as a format-error
* is encountered, leaving the offending character in the input. This means
* that 1.el leaves the 'l' in the input queue. Since all detection of
* format errors is done here, _doscan() doesn't call strtod() when it's
* not necessary, although the use of the width field can cause incomplete
* numbers to be passed to strtod(). (e.g. 1.3e+)
*/
static char *
f_collect(register int c, register FILE *stream, register unsigned int width)
{
register char *bufp = inp_buf;
int digit_seen = 0;
if (c == '-' || c == '+') {
*bufp++ = c;
if (--width)
c = getc(stream);
}
while (width && isdigit(c)) {
digit_seen++;
*bufp++ = c;
if (--width)
c = getc(stream);
}
if (width && c == '.') {
*bufp++ = c;
if(--width)
c = getc(stream);
while (width && isdigit(c)) {
digit_seen++;
*bufp++ = c;
if (--width)
c = getc(stream);
}
}
if (!digit_seen) {
if (width && c != EOF) ungetc(c, stream);
return inp_buf - 1;
}
else digit_seen = 0;
if (width && (c == 'e' || c == 'E')) {
*bufp++ = c;
if (--width)
c = getc(stream);
if (width && (c == '+' || c == '-')) {
*bufp++ = c;
if (--width)
c = getc(stream);
}
while (width && isdigit(c)) {
digit_seen++;
*bufp++ = c;
if (--width)
c = getc(stream);
}
if (!digit_seen) {
if (width && c != EOF) ungetc(c,stream);
return inp_buf - 1;
}
}
if (width && c != EOF) ungetc(c, stream);
*bufp = '\0';
return bufp - 1;
}
static int test_eof (lua_State *L, FILE *f) {
int c = getc(f);
ungetc(c, f);
lua_pushlstring(L, NULL, 0);
return (c != EOF);
}
/**
Process the AIFF file. This method will call processCOMM to handle the COMM section.
It will mark the position of the sound file so processSSND and getSamplesAIFF can perform correctly.
**/
File_Data processAIFF(FILE *outfile, FILE* infile){
int foundComm = 0;
int foundSSND = 0;
File_Data data;
CommonChunk comm;
SoundDataChunk sdc;
data.samples = -1;
data.channels = -1;
data.sampleRate = -1;
data.bitDepth = -1;
data.success = 0;
char buff[4];
int i, j;
for(i = 0; i < 4; i++){
buff[i] = fgetc(infile);
}
flipBytes(buff, 4);
int y = *((int*)buff);
for(i = 0; i < 4; i++){
buff[i] = fgetc(infile);
}
if(strncmp(buff, "AIFF", 4) != 0){
data.success = 0;
return data;
}else {
strncpy(data.format, "AIFF\0", 5);
}
while(!foundComm || !foundSSND){
buff[0] = fgetc(infile);
if(EOF == buff[0]){
data.success = 0;
return data;
}else if(buff[0] != 'C' && buff[0] != 'S' && buff[0] != 'A'){
continue;
}
for(i = 1; i < 4; i++){
buff[i] = fgetc(infile);
if(buff[i] == 'C'){
ungetc(buff[i], infile);
continue;
}
}
if(strncmp(buff, "COMM", 4) == 0){
comm = processComm(infile);
data.samples = comm.numSampleFrames;
data.channels = comm.numChannels;
data.sampleRate = comm.sampleRate;
data.bitDepth = comm.sampleSize;
strcpy(data.duration, findDuration(data.sampleRate, data.channels, data.samples, data.duration));
foundComm = 1;
}
if(strncmp(buff, "SSND", 4) == 0){
/*Marks the position of the SSND chunk so it can be processed later*/
foundSoundData = fgetpos(infile, &SSNDLocation);
foundSSND = 1;
}
if(strncmp(buff, "COMT", 4) == 0 || strncmp(buff, "ANNO", 4) == 0 ){
/* Runs through comment chunks */
int chunkSize;
char sizeBuff[4];
for(j = 0; j < 4; j++){
sizeBuff[j] = fgetc(infile);
}
flipBytes(sizeBuff, 4);
chunkSize = *((int *)sizeBuff);
int count = 0;
while(count < chunkSize){
count++;
fgetc(infile);
}
}
}
if(foundSSND && foundComm)
data.success = 1;
return data;
}
static void FILE_from_erlangv(ErlDrvData drv_data, ErlIOVec* ev)
{
Desc *desc = (Desc*) drv_data;
SysIOVec *iov = ev->iov;
ErlDrvBinary* bin;
switch ((&iov[1])->iov_base[0]) {
case XX_OPEN: {
char buf[BUFSIZ];
char file[BUFSIZ]; /* should be FILENAME_MAX */
char flags[4]; /* at most someething like rb+ */
char* src;
char* dst;
char* src_end;
char* dst_end;
int n;
if (desc->fp != NULL) {
driver_error(desc->port, XX_EINVAL);
return;
}
/* play it safe ? */
n = vec_to_buf(ev, buf, BUFSIZ);
src = buf + 1;
src_end = buf + n;
/* get file name */
dst = file;
dst_end = dst + BUFSIZ; /* make room for a '\0' */
while((src < src_end) && (dst < dst_end) && (*src != '\0'))
*dst++ = *src++;
if ((src == src_end) || (dst == dst_end)) {
driver_error(desc->port, XX_EINVAL);
}
*dst = *src++;
/* get flags */
dst = flags;
dst_end = dst + 4;
while((src < src_end) && (dst < dst_end) && (*src != '\0'))
*dst++ = *src++;
if (dst == dst_end) {
driver_error(desc->port, XX_EINVAL);
return;
}
*dst = '\0';
if ((desc->fp = fopen(file, flags))==NULL) {
driver_error(desc->port, errno);
return;
}
driver_ok(desc->port);
break;
}
case XX_WRITE: {
int i;
iov[1].iov_base++;
iov[1].iov_len--;
for(i=1; i<ev->vsize; i++) {
if (fwrite(iov[i].iov_base, 1, iov[i].iov_len, desc->fp) !=
iov[i].iov_len) {
driver_error(desc->port, errno);
return;
}
}
driver_ok(desc->port);
break;
}
case XX_READ: {
char ch = XX_VALUE;
int rval;
int sz = get_int32((&iov[1])->iov_base+1);
if ((bin = driver_alloc_binary(sz)) == NULL) {
driver_error(desc->port, -1);
return;
}
if ((rval = fread(bin->orig_bytes, 1, sz, desc->fp)) != sz) {
if (feof(desc->fp)) {
if (rval == 0) {
driver_free_binary(bin);
driver_eof(desc->port);
return;
}
driver_output_binary(desc->port, &ch, 1,bin, 0, rval);
driver_free_binary(bin);
return;
}
driver_free_binary(bin);
driver_error(desc->port, errno);
return;
}
driver_output_binary(desc->port, &ch, 1,bin, 0, sz);
driver_free_binary(bin);
break;
}
case XX_SEEK: {
int offs = get_int32((&iov[1])->iov_base+1);
int w = (int) (&iov[1])->iov_base[5];
int whence;
switch (w) {
case 1: whence = SEEK_SET; break;
case 2: whence = SEEK_CUR; break;
case 3: whence = SEEK_END; break;
}
if ((w = fseek(desc->fp, offs, whence)) != 0) {
driver_error(desc->port, errno);
return;
}
driver_ok(desc->port);
return;
}
case XX_TELL: {
int offs;
if ((offs = ftell(desc->fp)) == -1) {
driver_error(desc->port, errno);
return;
}
driver_ret32(desc->port, offs);
break;
}
case XX_TRUNCATE: {
int fno;
int offs;
/* is this really safe? */
if (fflush(desc->fp) != 0) {
driver_error(desc->port, errno);
return;
}
if ((offs = ftell(desc->fp)) == -1) {
driver_error(desc->port, errno);
return;
}
fno = fileno(desc->fp);
#ifdef WIN32
if (SetEndOfFile((HANDLE)fno) != 0) {
driver_error(desc->port, GetLastError());
return;
}
#else
if (ftruncate(fno, offs) == -1) {
driver_error(desc->port, errno);
return;
}
#endif
driver_ok(desc->port);
return;
}
case XX_FLUSH:
if (fflush(desc->fp) != 0)
driver_error(desc->port, errno);
else
driver_ok(desc->port);
break;
case XX_OEOF:
if (feof(desc->fp))
driver_ret32(desc->port, 1);
else
driver_ret32(desc->port,0);
break;
case XX_ERROR:
if (ferror(desc->fp))
driver_ret32(desc->port, 1);
else
driver_ret32(desc->port,0);
break;
case XX_GETC: {
int ch;
if ((ch = getc(desc->fp)) == EOF) {
if (feof(desc->fp)) {
driver_eof(desc->port);
return;
}
driver_error(desc->port, errno);
return;
}
driver_ret32(desc->port, ch);
break;
}
case XX_SET_LINEBUF_SIZE: {
int sz = get_int32((&iov[1])->iov_base+1);
desc->linebuf_size = sz;
driver_ok(desc->port);
break;
}
case XX_GETS:
case XX_GETS2: {
int rval;
long cpos1, cpos2;
char header;
if ((bin = driver_alloc_binary(desc->linebuf_size)) == NULL) {
driver_error(desc->port, -1);
return;
}
if ((cpos1 = ftell(desc->fp)) == -1) {
driver_free_binary(bin);
driver_error(desc->port, errno);
return;
}
if ((fgets(bin->orig_bytes, desc->linebuf_size,
desc->fp)) == NULL) {
driver_free_binary(bin);
if (feof(desc->fp)) {
driver_eof(desc->port);
return;
}
driver_error(desc->port, errno);
return;
}
if ((cpos2 = ftell(desc->fp)) == -1) {
driver_free_binary(bin);
driver_error(desc->port, errno);
return;
}
rval = cpos2 - cpos1;
if (bin->orig_bytes[rval-1] == '\n' &&
bin->orig_bytes[rval] == 0) {
header = XX_FLINE;
/* GETS keep newline, GETS2 remove newline */
rval = rval - ((&iov[1])->iov_base[0] == XX_GETS ? 0 : 1);
}
else
header = XX_NOLINE;
driver_output_binary(desc->port, &header, 1,bin, 0, rval);
driver_free_binary(bin);
break;
}
case XX_UNGETC: {
int ch = (&iov[1])->iov_base[1];
if (ungetc(ch, desc->fp) == EOF)
driver_error(desc->port, errno);
else
driver_ok(desc->port);
break;
}
default:
#ifdef DEBUG
fprintf(stderr, "Unknown opcode %c\n\r", ((&iov[1])->iov_base[0]));
#endif
driver_error(desc->port, XX_EINVAL);
break;
}
}
csdbparser::enResult csdbparser::symbolread(sym_data *data, symdata_pack* pack)
{
if (m_debug) printf("=====> symbolread\n");
int ch, ch2;
data->clear();
data->valid = true;
data->sym_type = sym_data::symNone;
ch = fgetc(m_fp);
if (m_debug) printf("check3! %c\n", (char)ch);
if (ch == 9) // TAB
{
ch = fgetc(m_fp);
if (m_debug) printf("check4! %c\n", (char)ch);
switch (ch)
{
case '}': // end of func
if (m_calling_func.size() > 0)
m_calling_func.clear();
else if (m_debug) printf("no func to clear!\n");
data->valid = false;
if (m_debug) printf("End of func found\n");
break;
case ')': // end of macro
if (m_calling_macro.size() > 0)
m_calling_macro.clear();
else if (m_debug) printf("no macro to clear!\n");
data->valid = false;
if (m_debug) printf("End of macro found\n");
break;
case '~': // include
ch2 = fgetc(m_fp);
if ((ch2 == '"')||(ch2 == '<'))
{
pack->line_text += (char) ch2;
}
else
{
ungetc(ch2, m_fp);
}
data->sym_type = sym_data::symIncl;
if (m_debug) printf("Incl found\n");
break;
default:
for (int i=0; i<symbtypetbl_SIZE; i++)
{
if (symbtypetbl[i].chr == ch)
{
data->sym_type =
symbtypetbl[i].type;
break;
}
}
if (data->sym_type == sym_data::symNone)
return resUNKNOWN_ERR;
break;
};
}
else ungetc(ch, m_fp);
if (fgets(m_buf, m_bufsize, m_fp) == NULL)
{
return resFILE_ACCESS_ERR;
}
data->symbname = chomp(m_buf);
if (data->valid) data->valid = (strlen(data->symbname.c_str()) > 0);
if (m_debug) printf("sym name=%s, type = %s, valid=%d, ch=%c\n",
data->symbname.c_str(), data->getTypeDesc(), data->valid, ch);
if (ch == '$')
{
m_calling_func.assign(data->symbname);
}
else if (ch == '#')
{
m_calling_macro.assign(data->symbname);
}
else if (ch == '`')
{
data->calling_func = m_calling_func;
data->calling_macro = m_calling_macro;
}
return resOK;
}
static inline int rc_ungetc (char c, FILE *rc) {
pos--;
return ungetc (c, rc);
}
/* Extract from the stream the longest string of characters which are neither
whitespace nor brackets (except for an optional bracketed n-char_sequence
directly following nan or @nan@ independently of case).
The user must free the returned string. */
static char *
extract_string (FILE *stream)
{
int c;
size_t nread = 0;
size_t strsize = 100;
char *str = mpc_alloc_str (strsize);
size_t lenstr;
c = getc (stream);
while (c != EOF && c != '\n'
&& !isspace ((unsigned char) c)
&& c != '(' && c != ')') {
str [nread] = (char) c;
nread++;
if (nread == strsize) {
str = mpc_realloc_str (str, strsize, 2 * strsize);
strsize *= 2;
}
c = getc (stream);
}
str = mpc_realloc_str (str, strsize, nread + 1);
strsize = nread + 1;
str [nread] = '\0';
if (nread == 0)
return str;
lenstr = nread;
if (c == '(') {
size_t n;
char *suffix;
int ret;
/* (n-char-sequence) only after a NaN */
if ((nread != 3
|| tolower ((unsigned char) (str[0])) != 'n'
|| tolower ((unsigned char) (str[1])) != 'a'
|| tolower ((unsigned char) (str[2])) != 'n')
&& (nread != 5
|| str[0] != '@'
|| tolower ((unsigned char) (str[1])) != 'n'
|| tolower ((unsigned char) (str[2])) != 'a'
|| tolower ((unsigned char) (str[3])) != 'n'
|| str[4] != '@')) {
ungetc (c, stream);
return str;
}
suffix = extract_suffix (stream);
nread += strlen (suffix) + 1;
if (nread >= strsize) {
str = mpc_realloc_str (str, strsize, nread + 1);
strsize = nread + 1;
}
/* Warning: the sprintf does not allow overlap between arguments. */
ret = sprintf (str + lenstr, "(%s", suffix);
MPC_ASSERT (ret >= 0);
n = lenstr + (size_t) ret;
MPC_ASSERT (n == nread);
c = getc (stream);
if (c == ')') {
str = mpc_realloc_str (str, strsize, nread + 2);
strsize = nread + 2;
str [nread] = (char) c;
str [nread+1] = '\0';
nread++;
}
else if (c != EOF)
ungetc (c, stream);
mpc_free_str (suffix);
}
else if (c != EOF)
ungetc (c, stream);
return str;
}
void StdioUngetc(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs)
{
UNUSED(Parser); UNUSED(NumArgs);
ReturnValue->Val->Integer = ungetc(Param[0]->Val->Integer, (FILE *) Param[1]->Val->Pointer);
}
MFModifiedPolytope MFReadPolytopeFromPlotfile(FILE *fid, int k, int dimV, MFErrorHandler e)
{
static char RoutineName[]={"MFReadPolytopeFromPlotfile"};
MFModifiedPolytope P;
int mV,iV,iV0;
double *v;
int *vt;
int mE,iE;
int *ev;
int *et;
int mF,iF;
int *nfv;
int **fv;
int *ft;
int i,j,l,n;
int ipoly,nv,ne,nf;
int verbose=0;
int iv,ie,iE0,je,np,v0,v1;
int trip;
int sing,bnd;
char c;
double R;
if(verbose){printf(" Read Polytope\n");fflush(stdout);}
P=(MFModifiedPolytope)malloc(sizeof(struct MFModifiedPolytopeSt));
P->k=k;
P->dimV=dimV;
fscanf(fid,"Polyhedron %d, ",&ipoly);
if(verbose){printf(" Polytope %d\n",ipoly);fflush(stdout);}
c=fgetc(fid);
ungetc(c,fid);
if(c=='R')
{
fscanf(fid,"R=%lf, %d vertices, %d edges, %d faces, boundary %d, singular %d\n",&R,&nv,&ne,&nf,&bnd,&sing);
}else{
fscanf(fid,"%d vertices, %d edges, %d faces, boundary %d, singular %d\n",&nv,&ne,&nf,&bnd,&sing);
R=0;
}
fscanf(fid," %d vertices, %d edges, %d faces, boundary %d, singular %d\n",nv,ne,nf,bnd,sing);
P->n=nv;
P->m=nv;
P->v=(double*)malloc(P->n*dimV*sizeof(double));
P->nIndices=(int*)malloc(P->n*sizeof(int));
P->mIndices=(int*)malloc(P->n*sizeof(int));
P->indices=(int**)malloc(P->n*sizeof(int*));
P->mark=(int*)malloc(P->n*sizeof(int));
for(i=0;i<P->n;i++)
{
P->nIndices[i]=0;
P->mIndices[i]=0;
P->indices[i]=(int*)NULL;
P->mark[i]=0;
}
if(verbose){printf("Polyhedron %d, %d vertices, %d edges, %d faces\n",ipoly,nv,ne,nf);fflush(stdout);}
for(iv=0;iv<nv;iv++)
{
fscanf(fid,"Vertex %d (%lf",&iV,&(P->v[0+P->dimV*iv]));
if(verbose){printf("Vertex %d (%lf",iV,(P->v[0+P->dimV*iv]));fflush(stdout);}
for(i=1;i<dimV;i++){fscanf(fid,",%lf",&(P->v[i+P->dimV*iv]));if(verbose){printf(",%lf",(P->v[i+P->dimV*iv]));fflush(stdout);}}
fscanf(fid,"), %d ",&(P->nIndices[iv]));
if(verbose){printf("), %d ",(P->nIndices[iv]));fflush(stdout);}
P->mIndices[iv]=P->nIndices[iv];
if(P->nIndices[iv]!=0)
{
P->indices[iv]=(int*)malloc((P->nIndices[i])*sizeof(int));
fscanf(fid,"[%d",&(P->indices[iv][0]));
if(verbose){printf( "[%d", (P->indices[iv][0]));fflush(stdout);}
for(i=1;i<P->nIndices[iv];i++)
{
fscanf(fid,",%d",&(P->indices[iv][i]));
if(verbose){printf( ",%d", (P->indices[iv][i]));fflush(stdout);}
}
fscanf(fid,"]\n");
if(verbose){printf( "]\n");fflush(stdout);}
}else{
fscanf(fid," [ ]\n");
if(verbose){printf( "\n");fflush(stdout);}
}
if(verbose)
{
printf(" Vertex %d (%lf",iv,P->v[0+P->dimV*iV]);
for(i=1;i<P->dimV;i++)printf(",%lf",P->v[i+P->dimV*iV]);
printf(")\n");fflush(stdout);
}
}
for(ie=0;ie<ne;ie++)
{
if(k>1)
{
fscanf(fid,"Edge %d (%d,%d), %*d [%*[ 0-9+-.,]]\n",&iE,&v0,&v1);
if(verbose){printf( "Edge %d (%d,%d)\n",iE,v0,v1);fflush(stdout);}
}else if(k==1)
{
fscanf(fid,"Edge %d (%d,%d), %*d []\n",&iE,&v0,&v1);
if(verbose){printf( "Edge %d (%d,%d)\n",iE,v0,v1);fflush(stdout);}
}else{
fscanf(fid,"Edge %d (%d,%d), %*d [%*[ 0-9+-.,]]\n",&iE,&v0,&v1);
if(verbose){printf( "Edge %d (%d,%d)\n",iE,v0,v1);fflush(stdout);}
}
if(verbose){printf(" Edge %d (%d,%d)\n",ie,v0,v1);fflush(stdout);}
}
P->nFaces=nf;
P->mFaces=nf;
P->face =(int*)malloc(P->mFaces*sizeof(int));
P->nFaceV=(int*)malloc(P->mFaces*sizeof(int));
P->faceN =(MFNVector*)malloc(P->mFaces*sizeof(MFNVector));
P->faceO =(double*)malloc(P->mFaces*sizeof(double));
for(i=0;i<nf;i++)
{
fscanf(fid,"Face %d neighbor %*d\n",&(P->face[i]));
if(verbose){printf( "Face %d neighbor\n",(P->face[i]));fflush(stdout);}
P->nFaceV[i]=0;
P->faceN [i]=(MFNVector)NULL;
P->faceO [i]=0.;
}
if(verbose){printf("done\n");fflush(stdout);}
return P;
}
int
mpc_inp_str (mpc_ptr rop, FILE *stream, size_t *read, int base,
mpc_rnd_t rnd_mode)
{
size_t white, nread = 0;
int inex = -1;
int c;
char *str;
if (stream == NULL)
stream = stdin;
white = skip_whitespace (stream);
c = getc (stream);
if (c != EOF) {
if (c == '(') {
char *real_str;
char *imag_str;
size_t n;
int ret;
nread++; /* the opening parenthesis */
white = skip_whitespace (stream);
real_str = extract_string (stream);
nread += strlen(real_str);
c = getc (stream);
if (!isspace ((unsigned int) c)) {
if (c != EOF)
ungetc (c, stream);
mpc_free_str (real_str);
goto error;
}
else
ungetc (c, stream);
white += skip_whitespace (stream);
imag_str = extract_string (stream);
nread += strlen (imag_str);
str = mpc_alloc_str (nread + 2);
ret = sprintf (str, "(%s %s", real_str, imag_str);
MPC_ASSERT (ret >= 0);
n = (size_t) ret;
MPC_ASSERT (n == nread + 1);
mpc_free_str (real_str);
mpc_free_str (imag_str);
white += skip_whitespace (stream);
c = getc (stream);
if (c == ')') {
str = mpc_realloc_str (str, nread +2, nread + 3);
str [nread+1] = (char) c;
str [nread+2] = '\0';
nread++;
}
else if (c != EOF)
ungetc (c, stream);
}
else {
if (c != EOF)
ungetc (c, stream);
str = extract_string (stream);
nread += strlen (str);
}
inex = mpc_set_str (rop, str, base, rnd_mode);
mpc_free_str (str);
}
error:
if (inex == -1) {
mpfr_set_nan (mpc_realref(rop));
mpfr_set_nan (mpc_imagref(rop));
}
if (read != NULL)
*read = white + nread;
return inex;
}
/**
* Reads strings from a file and computes the frequencies of the characters.
* @param in File to read from
* @param freq Where to store computed frequencies
* @param total_length If not NULL, the total number of characters is stored here
* @return The resulting list of strings
*/
string_list_t *read_strings(FILE *in, int ignore_case, int *freq,
int *total_length, int *string_count)
{
unsigned char *buf;
string_list_t *head;
string_list_t **nextp;
int max_len;
int i;
if (string_count)
*string_count = 0;
/* Zap frequency counts. */
for (i = 0; i < 256; i++)
freq[i] = 0;
/* Read strings and count character frequencies as we go. */
head = NULL;
nextp = &head;
max_len = 64;
buf = (unsigned char *)malloc(max_len);
if (total_length)
*total_length = 0;
while (!feof(in)) {
/* Read one string (all chars until STRING_SEPARATOR) into temp buffer */
int c;
int in_comment = 0;
i = 0;
while (((c = fgetc(in)) != -1) && (c != STRING_SEPARATOR)) {
if (c == '\\') {
/* Check for line escape */
int d;
d = fgetc(in);
if (d == STRING_SEPARATOR) {
continue;
} else if (d == '#') {
c = '#';
} else {
ungetc(d, in);
}
} else if ((i == 0) && (c == '#')) {
in_comment = 1;
}
if (in_comment)
continue;
if (i == max_len) {
/* Allocate larger buffer */
max_len += 64;
buf = (unsigned char *)realloc(buf, max_len);
}
if (ignore_case && (c >= 'A') && (c <= 'Z'))
c += 0x20;
buf[i++] = (unsigned char)c;
freq[c]++;
}
if (i > 0) {
/* Add string to list */
string_list_t *lst = (string_list_t *)malloc(sizeof(string_list_t));
lst->text = (unsigned char *)malloc(i+1);
lst->huff_data = 0;
lst->huff_size = 0;
memcpy(lst->text, buf, i);
lst->text[i] = 0;
lst->next = NULL;
*nextp = lst;
nextp = &(lst->next);
if (total_length)
*total_length = *total_length + i;
if (string_count)
*string_count = *string_count + 1;
}
}
free(buf);
return head;
}
BOOL LLWearable::importFile( LLFILE* file )
{
// *NOTE: changing the type or size of this buffer will require
// changes in the fscanf() code below. You would be better off
// rewriting this to use streams and not require an open FILE.
char text_buffer[2048]; /* Flawfinder: ignore */
S32 fields_read = 0;
// read header and version
fields_read = fscanf( file, "LLWearable version %d\n", &mDefinitionVersion );
if( fields_read != 1 )
{
// Shouldn't really log the asset id for security reasons, but
// we need it in this case.
llwarns << "Bad Wearable asset header: " << mAssetID << llendl;
//gVFS->dumpMap();
return FALSE;
}
if( mDefinitionVersion > LLWearable::sCurrentDefinitionVersion )
{
llwarns << "Wearable asset has newer version (" << mDefinitionVersion << ") than XML (" << LLWearable::sCurrentDefinitionVersion << ")" << llendl;
return FALSE;
}
// name
char next_char = fgetc( file ); /* Flawfinder: ignore */
if( '\n' == next_char )
{
// no name
mName = "";
}
else
{
ungetc( next_char, file );
fields_read = fscanf( /* Flawfinder: ignore */
file,
"%2047[^\n]",
text_buffer);
if( (1 != fields_read) || (fgetc( file ) != '\n') ) /* Flawfinder: ignore */
{
llwarns << "Bad Wearable asset: early end of file" << llendl;
return FALSE;
}
mName = text_buffer;
LLStringUtil::truncate(mName, DB_INV_ITEM_NAME_STR_LEN );
}
// description
next_char = fgetc( file ); /* Flawfinder: ignore */
if( '\n' == next_char )
{
// no description
mDescription = "";
}
else
{
ungetc( next_char, file );
fields_read = fscanf( /* Flawfinder: ignore */
file,
"%2047[^\n]",
text_buffer );
if( (1 != fields_read) || (fgetc( file ) != '\n') ) /* Flawfinder: ignore */
{
llwarns << "Bad Wearable asset: early end of file" << llendl;
return FALSE;
}
mDescription = text_buffer;
LLStringUtil::truncate(mDescription, DB_INV_ITEM_DESC_STR_LEN );
}
// permissions
S32 perm_version;
fields_read = fscanf( file, " permissions %d\n", &perm_version );
if( (fields_read != 1) || (perm_version != 0) )
{
llwarns << "Bad Wearable asset: missing permissions" << llendl;
return FALSE;
}
if( !mPermissions.importFile( file ) )
{
return FALSE;
}
// sale info
S32 sale_info_version;
fields_read = fscanf( file, " sale_info %d\n", &sale_info_version );
if( (fields_read != 1) || (sale_info_version != 0) )
{
llwarns << "Bad Wearable asset: missing sale_info" << llendl;
return FALSE;
}
// Sale info used to contain next owner perm. It is now in the
// permissions. Thus, we read that out, and fix legacy
// objects. It's possible this op would fail, but it should pick
// up the vast majority of the tasks.
BOOL has_perm_mask = FALSE;
U32 perm_mask = 0;
if( !mSaleInfo.importFile(file, has_perm_mask, perm_mask) )
{
return FALSE;
}
if(has_perm_mask)
{
// fair use fix.
if(!(perm_mask & PERM_COPY))
{
perm_mask |= PERM_TRANSFER;
}
mPermissions.setMaskNext(perm_mask);
}
// wearable type
S32 type = -1;
fields_read = fscanf( file, "type %d\n", &type );
if( fields_read != 1 )
{
llwarns << "Bad Wearable asset: bad type" << llendl;
return FALSE;
}
if( 0 <= type && type < WT_COUNT )
{
mType = (EWearableType)type;
}
else
{
llwarns << "Bad Wearable asset: bad type #" << type << llendl;
return FALSE;
}
// parameters header
S32 num_parameters = 0;
fields_read = fscanf( file, "parameters %d\n", &num_parameters );
if( fields_read != 1 )
{
llwarns << "Bad Wearable asset: missing parameters block" << llendl;
return FALSE;
}
// parameters
S32 i;
for( i = 0; i < num_parameters; i++ )
{
S32 param_id = 0;
F32 param_weight = 0.f;
fields_read = fscanf( file, "%d %f\n", ¶m_id, ¶m_weight );
if( fields_read != 2 )
{
llwarns << "Bad Wearable asset: bad parameter, #" << i << llendl;
return FALSE;
}
mVisualParamMap[param_id] = param_weight;
}
// textures header
S32 num_textures = 0;
fields_read = fscanf( file, "textures %d\n", &num_textures);
if( fields_read != 1 )
{
llwarns << "Bad Wearable asset: missing textures block" << llendl;
return FALSE;
}
// textures
for( i = 0; i < num_textures; i++ )
{
S32 te = 0;
fields_read = fscanf( /* Flawfinder: ignore */
file,
"%d %2047s\n",
&te, text_buffer);
if( fields_read != 2 )
{
llwarns << "Bad Wearable asset: bad texture, #" << i << llendl;
return FALSE;
}
if( !LLUUID::validate( text_buffer ) )
{
llwarns << "Bad Wearable asset: bad texture uuid: " << text_buffer << llendl;
return FALSE;
}
mTEMap[te] = LLUUID(text_buffer );
}
return TRUE;
}
static void fp_ungetc(int c, struct tok_state *tok) {
ungetc(c, tok->fp);
}
void
input_file_open (char *filename, /* "" means use stdin. Must not be 0. */
int pre)
{
int c;
char buf[80];
preprocess = pre;
assert (filename != 0); /* Filename may not be NULL. */
if (filename[0])
{
f_in = fopen (filename, FOPEN_RT);
file_name = filename;
}
else
{
/* Use stdin for the input file. */
f_in = stdin;
/* For error messages. */
file_name = _("{standard input}");
}
if (f_in)
c = getc (f_in);
if (f_in == NULL || ferror (f_in))
{
#ifdef BFD_ASSEMBLER
bfd_set_error (bfd_error_system_call);
#endif
as_perror (_("Can't open %s for reading"), file_name);
if (f_in)
{
fclose (f_in);
f_in = NULL;
}
return;
}
if (c == '#')
{
/* Begins with comment, may not want to preprocess. */
c = getc (f_in);
if (c == 'N')
{
fgets (buf, 80, f_in);
if (!strncmp (buf, "O_APP", 5) && ISSPACE (buf[5]))
preprocess = 0;
if (!strchr (buf, '\n'))
ungetc ('#', f_in); /* It was longer. */
else
ungetc ('\n', f_in);
}
else if (c == 'A')
{
fgets (buf, 80, f_in);
if (!strncmp (buf, "PP", 2) && ISSPACE (buf[2]))
preprocess = 1;
if (!strchr (buf, '\n'))
ungetc ('#', f_in);
else
ungetc ('\n', f_in);
}
else if (c == '\n')
ungetc ('\n', f_in);
else
ungetc ('#', f_in);
}
else
ungetc (c, f_in);
}
int main()
{
FILE *pascal_file,*lex_file;
char file_name[40], file_name2[40];
char is_token[40];
char current_char;
char before_current_char;
int i=0,j,is_comment=0,is_assignment=0;
printf("Please enter the source file name: ");
fflush(stdin);
gets(file_name);
strcpy(file_name2,file_name);
strcat(file_name,".pas");
strcat(file_name2,".lex");
for(j=0;j<40;j++)
is_token[j]=0;
if((pascal_file = fopen(file_name,"r")) == NULL)
printf("dosya acilamadi!\n");
else
{
lex_file = fopen(file_name2,"w");
while(!feof(pascal_file))
{
current_char=getc(pascal_file);
if(isLetter(current_char)==1)//current_char harfse string e eklenir
{
is_token[i]=current_char;
i++;
}
else if(isLetter(current_char)==0 && i!=0)// current char harf degilse ondan onceki stringi(is_letter) yazdýr
{
if(strcmp("writeln",is_token)==0 || strcmp("write",is_token)==0)
{
fputs("output(",lex_file);
fputs(is_token,lex_file);
fputs("),",lex_file);
}
else if(strcmp("readln",is_token)==0 || strcmp("read",is_token)==0)
{
fputs("input(",lex_file);
fputs(is_token,lex_file);
fputs("),",lex_file);
}
else if(isReservedWord(is_token)==1)
{
fputs("reservedWord(",lex_file);
fputs(is_token,lex_file);
fputs("),",lex_file);
}
else if(isAdvMathFunc(is_token)==1)
{
fputs("advancedMathFunction(",lex_file);
fputs(is_token,lex_file);
fputs("),",lex_file);
}
else if(isOrdinalFunc(is_token)==1)
{
fputs("ordinalFunction(",lex_file);
fputs(is_token,lex_file);
fputs("),",lex_file);
}
else if(isVariableType(is_token)==1)
{
fputs("variableType(",lex_file);
fputs(is_token,lex_file);
fputs("),",lex_file);
}
else if(isBoolOperator(is_token)==1)
{
fputs("booleanOperator(",lex_file);
fputs(is_token,lex_file);
fputs("),",lex_file);
}
else if(isFileHandlingFunc(is_token)==1)
{
fputs("fileHandlingFunction(",lex_file);
fputs(is_token,lex_file);
fputs("),",lex_file);
}
else if(strcmp(is_token,"div")==0 || strcmp(is_token,"mod")==0)
{
fputs("arithmeticOperation(",lex_file);
fputs(is_token,lex_file);
fputs("),",lex_file);
}
else
{
fputs("variable(",lex_file);
fputs(is_token,lex_file);
fputs("),",lex_file);
}
i=0;
for(j=0;j<40;j++)
is_token[j]=0;
}
if(current_char==':')
{
current_char=getc(pascal_file);
if(current_char=='=')
{
fputs("assignmentOperator(:=),",lex_file);
is_assignment=1;
}
else
{
fputs("colon(:),",lex_file);
ungetc(current_char,pascal_file);
}
}
if(current_char=='{')
{
comment(pascal_file,current_char,lex_file);
}
if(current_char=='*' && is_comment==1)
{
comment(pascal_file,current_char,lex_file);
is_comment=0;
}
if(is_comment==1)
{
fputs("leftParentheses((),",lex_file);
}
if(current_char==')')
{
fputs("rightParentheses()),",lex_file);
}
if(current_char==';')
{
fputs("endOfLine(;),",lex_file);
}
if(current_char=='[')
{
fputs("openingBracket([)",lex_file);
}
if(current_char==']')
{
fputs("closingBracket(])",lex_file);
}
if(is_assignment==0 && (current_char=='<' || current_char=='>' || current_char=='='))
{
before_current_char=current_char;
current_char=getc(pascal_file);
if(before_current_char=='<' && (current_char=='=' || current_char=='>'))
{
fputs("compOperator(",lex_file);
fputc(before_current_char,lex_file);
fputc(current_char,lex_file);
fputs("),",lex_file);
}
else if(before_current_char=='>' && current_char=='=')
{
fputs("compOperator(",lex_file);
fputc(before_current_char,lex_file);
fputc(current_char,lex_file);
fputs("),",lex_file);
}
else if(before_current_char=='<' || before_current_char=='>' || before_current_char=='=')
{
fputs("compOperator(",lex_file);
fputc(before_current_char,lex_file);
fputs("),",lex_file);
ungetc(current_char,pascal_file);
}
}
is_assignment=0;
if(current_char=='+' || current_char =='-' || current_char=='*' || current_char=='/')
{
fputs("arithOperator(",lex_file);
fputc(current_char,lex_file);
fputs("),",lex_file);
}
is_comment=0;
if(current_char=='(')
{
is_comment=1;
}
if(current_char==39)
{
skip_string(pascal_file,lex_file);
}
if(current_char==9 || current_char==10 || current_char==' ')
{
fputc(current_char,lex_file);
}
/*if(current_char==';')
{
i=0;
for(j=0;j<40;j++)
is_token[j]='\0';
}*/
if(isNumeric(current_char)==1)
{
constant(pascal_file,lex_file,current_char);
}
}
fclose(lex_file);
lex_file = fopen(file_name2,"r");
current_char=getc(lex_file);
while(!feof(lex_file))
{
printf("%c",current_char);
current_char=getc(lex_file);
}
}
return 0;
}
csdbparser::enResult csdbparser::get_next_symbol(symdata_pack* pack)
{
CSDBP_GENERAL_CHK();
enResult res;
bool endOfSymbData;
bool foundSomething;
int ch;
//if (m_state != stSYMB_SETUP_DONE) return resUNKNOWN_ERR;
pack->clear();
if (m_debug) printf("=====> get_next_symbol\n");
do
{
res = single_line_symbol(endOfSymbData, foundSomething);
if (res != resOK) return res;
if (endOfSymbData)
{
pack->valid = false;
if (m_debug) printf("End of symbols data!\n");
return resOK;
}
}
while (foundSomething);
pack->valid = true;
pack->filename = m_current_srcfile;
if (m_debug) printf("=====> Back from get_next_symbol\n");
ch = fgetc(m_fp);
if (ch == 0x0A)
{
pack->line_num = -1; // empty line
return resOK; //EOL
}
else ungetc(ch, m_fp);
if (fscanf(m_fp, "%ld", &(pack->line_num)) != 1)
{
return resUNKNOWN_ERR;
}
ch = fgetc(m_fp); // the space after the line number
if (fgets(m_buf, m_bufsize, m_fp) == NULL)
{
return resFILE_ACCESS_ERR;
}
pack->line_text = chomp(m_buf);
if (m_debug)
{
printf("fn = %s, lineno=%ld, firstline=%s\n",
pack->filename.c_str(), pack->line_num, pack->line_text.c_str());
}
int loopcheck = 0; // prevent infinite loop
sym_data sd;
while (loopcheck++ < 65500)
{
// symbol line
ch = fgetc(m_fp);
if ((ch == 0x0A)&&(loopcheck > 1))
{
break; //EOL
}
else if ((ch >= 0x30)&&(ch <= 0x39)&&(loopcheck > 1))
{
ungetc(ch, m_fp);
break; // symbol shouldn't start with line numbers
}
else
{
ungetc(ch, m_fp);
res = symbolread(&sd, pack);
if (res != resOK) return res;
pack->line_text += sd.symbname;
if (sd.valid)
{
pack->symbols.push_back(sd);
}
}
// no-symbol line
ch = fgetc(m_fp);
if ((ch == 0x0A)&&(loopcheck > 1))
{
;
}
else
{
ungetc(ch, m_fp);
if (fgets(m_buf, m_bufsize, m_fp) == NULL)
{
return resFILE_ACCESS_ERR;
}
pack->line_text += chomp(m_buf);
}
}
return resOK;
}
boolean faReadMixedNext(FILE *f, boolean preserveCase, char *defaultName,
boolean mustStartWithComment, char **retCommentLine, struct dnaSeq **retSeq)
/* Read next sequence from .fa file. Return sequence in retSeq.
* If retCommentLine is non-null return the '>' line in retCommentLine.
* The whole thing returns FALSE at end of file.
* Contains parameter to preserve mixed case. */
{
char lineBuf[1024];
int lineSize;
char *words[1];
int c;
off_t offset = ftello(f);
size_t dnaSize = 0;
DNA *dna, *sequence;
char *name = defaultName;
if (name == NULL)
name = "";
dnaUtilOpen();
if (retCommentLine != NULL)
*retCommentLine = NULL;
*retSeq = NULL;
/* Skip first lines until it starts with '>' */
for (;;)
{
if(fgets(lineBuf, sizeof(lineBuf), f) == NULL)
{
if (ferror(f))
errnoAbort("read of fasta file failed");
return FALSE;
}
lineSize = strlen(lineBuf);
if (lineBuf[0] == '>')
{
if (retCommentLine != NULL)
*retCommentLine = cloneString(lineBuf);
offset = ftello(f);
chopByWhite(lineBuf, words, ArraySize(words));
name = words[0]+1;
break;
}
else if (!mustStartWithComment)
{
if (fseeko(f, offset, SEEK_SET) < 0)
errnoAbort("fseek on fasta file failed");
break;
}
else
offset += lineSize;
}
/* Count up DNA. */
for (;;)
{
c = fgetc(f);
if (c == EOF || c == '>')
break;
if (isalpha(c))
{
++dnaSize;
}
}
if (dnaSize == 0)
{
warn("Invalid fasta format: sequence size == 0 for element %s",name);
}
/* Allocate DNA and fill it up from file. */
dna = sequence = needHugeMem(dnaSize+1);
if (fseeko(f, offset, SEEK_SET) < 0)
errnoAbort("fseek on fasta file failed");
for (;;)
{
c = fgetc(f);
if (c == EOF || c == '>')
break;
if (isalpha(c))
{
/* check for non-DNA char */
if (ntChars[c] == 0)
{
*dna++ = preserveCase ? 'N' : 'n';
}
else
{
*dna++ = preserveCase ? c : ntChars[c];
}
}
}
if (c == '>')
ungetc(c, f);
*dna = 0;
*retSeq = newDnaSeq(sequence, dnaSize, name);
if (ferror(f))
errnoAbort("read of fasta file failed");
return TRUE;
}
// Get input from user in a controlled manner
char* get_input(FILE* stream)
{
int i = 0;
int size = INITIAL_BUF_SIZE;
char* buf;
if((buf = (char*)malloc(size)) == NULL)
{
perror("input.c: get_input(): initial buf malloc");
return NULL;
}
buf[0] = 0;
// Loop through input 1 char at a time
while(1)
{
int c = getc(stream);
// Increase buffer size as needed
if((i + 1) == size)
{
size += size;
// Double Size
if((buf = (char*)realloc(buf, size)) == NULL)
{
perror("input.c: get_input(): buf realloc");
return NULL;
}
}
// \n marks the end of the input
// # marks the start of a comment
// and also the end of useful input
if(c == '\n' || c == '#' || c == EOF)
{
if(c == '#')
{
// Burn the rest of the line
while(c != '\n' && c != EOF)
c = getc(stream);
}
if (buf[0] == 0)
return NULL;
else
break;
}
// Replace block of whitespace with single space
if(isspace(c))
{
// Ignore leading whitespace
if (buf[0] == 0)
continue;
while (isspace(c) && c != '\n' && c != '#')
c = getc(stream);
ungetc(c, stream);
if(c != '\n')
buf[i++] = ' ';
continue;
}
buf[i++] = c;
}
buf[i] = '\0'; // Append with null char
return buf;
}
LUALIB_API int luaL_loadfile (lua_State *L, const char *filename) {
LoadF lf;
int status, readstatus;
int c;
char fullFilename[128];
int fnameindex = lua_gettop(L) + 1; /* index of filename on the stack */
lf.extraline = 0;
if (filename == NULL) {
lua_pushliteral(L, "=stdin");
lf.f = stdin;
}
else {
// Note: Always open as the requested file, Lua should not care about
// our crazy directory remapping.
lua_pushfstring(L, "@%s", filename);
#if (PS3)
// On the PS3, check always the /app_home/Lua/ directory!
// This works both for dev-testing via remote HDD and on the game disc.
// These work probably too just for developing, but app_home is fine!
// /host_root/Lua/ or /dev_bdvd/PS3_GAME/USRDIR/Lua/
CheckForValidFilenameWithPath(fullFilename, filename, "/app_home/Lua/");
#elif XBOX
// For the Xbox we have to make sure always to load files from D:\ because
// fopen ALWAYS expects a full paths, there are no current directories on the
// Xbox 360 and therefore no relative paths! Check always "D:\Lua\<file>"
CheckForValidFilenameWithPath(fullFilename, filename, "D:\\Lua\\");
#else
// On the PC we just use the default search logic (see luaconf.h) and we
// don't care about directories since we will already be in the correct one!
// In earlier versions we had a lot of extra checks here.
strcpy(fullFilename, filename);
#endif
// Rest of this code is untouched, we just use fullFilename now!
lf.f = fopen(fullFilename, "r");
if (lf.f == NULL)
return errfile(L, "open", fnameindex);
}
c = getc(lf.f);
if (c == '#') { /* Unix exec. file? */
lf.extraline = 1;
while ((c = getc(lf.f)) != EOF && c != '\n') ; /* skip first line */
if (c == '\n') c = getc(lf.f);
}
if (c == LUA_SIGNATURE[0] && fullFilename) { /* binary file? */
lf.f = freopen(fullFilename, "rb", lf.f); /* reopen in binary mode */
if (lf.f == NULL) return errfile(L, "reopen", fnameindex);
/* skip eventual `#!...' */
while ((c = getc(lf.f)) != EOF && c != LUA_SIGNATURE[0]) ;
lf.extraline = 0;
}
ungetc(c, lf.f);
status = lua_load(L, getF, &lf, lua_tostring(L, -1));
readstatus = ferror(lf.f);
if (filename) fclose(lf.f); /* close file (even in case of errors) */
if (readstatus) {
lua_settop(L, fnameindex); /* ignore results from `lua_load' */
return errfile(L, "read", fnameindex);
}
lua_remove(L, fnameindex);
return status;
}
int
form_init(FILE *fp)
{
char var[256];
char val[10000];
char *cp, *vp;
int c;
char *ep = getenv("QUERY_STRING");
char *rm = getenv("REQUEST_METHOD");
nvar = 0;
if (ep && *ep && (rm && strcmp(rm, "POST") != 0))
{
cp = strtok(ep, "&");
while (cp)
{
vp = strchr(cp, '=');
if (vp)
{
*vp++ = '\0';
http_strip(vp);
}
http_strip(cp);
form_add(cp, vp);
cp = strtok(NULL, "&");
}
}
else if (fp != NULL)
{
while (fscanf(fp, "%255[^=]=", var) == 1)
{
val[0] = '\0';
http_strip(var);
c = getc(fp);
if (c == EOF)
{
form_add(var, "");
break;
}
ungetc(c, fp);
if (c != '&' && fscanf(fp, "%9999[^&\n\r]", val) == 1)
{
http_strip(val);
form_add(var, val);
}
else
form_add(var, "");
c = getc(fp);
if (c != '&')
ungetc(c, fp);
}
}
return nvar;
}
/*
* y_entries:
* find the yacc tags and put them in.
*/
void
y_entries(void)
{
int c;
char *sp;
bool in_rule;
char tok[MAXTOKEN];
in_rule = NO;
while (GETC(!=, EOF))
switch (c) {
case '\n':
SETLINE;
/* FALLTHROUGH */
case ' ':
case '\f':
case '\r':
case '\t':
break;
case '{':
if (skip_key('}'))
in_rule = NO;
break;
case '\'':
case '"':
if (skip_key(c))
in_rule = NO;
break;
case '%':
if (GETC(==, '%'))
return;
(void)ungetc(c, inf);
break;
case '/':
if (GETC(==, '*') || c == '/')
skip_comment(c);
else
(void)ungetc(c, inf);
break;
case '|':
case ';':
in_rule = NO;
break;
default:
if (in_rule || (!isalpha(c) && c != '.' && c != '_'))
break;
sp = tok;
*sp++ = c;
while (GETC(!=, EOF) && (intoken(c) || c == '.'))
*sp++ = c;
*sp = EOS;
getline(); /* may change before ':' */
while (iswhite(c)) {
if (c == '\n')
SETLINE;
if (GETC(==, EOF))
return;
}
if (c == ':') {
pfnote(tok, lineno);
in_rule = YES;
}
else
(void)ungetc(c, inf);
}
stackDataT evaluateExpression(FILE *infile, Stack *S) {
int next_char, read_ahead_char;
int string_position = 0;
char temp_string[MAXDIGITS];
stackDataT data;
while ((next_char = fgetc(infile)) != EOF) {
// If the character is a minus, it might be an operator or it might
// be a negative sign
if (next_char == MINUS) {
// Get the next char from the stream for testing
if ((read_ahead_char = fgetc(infile)) != EOF) {
// Push the next char back onto the stream so it is correctly
// processed on the next loop iteration
if (ungetc(read_ahead_char, infile) != read_ahead_char) {
fprintf(stderr, "Error: Unable to parse the expression.\n");
}
// If the next char in the stream is a number, this minus is a
// negative sign, add it to the number string and end this loop
// iteration
if (charIsANumber(read_ahead_char)) {
temp_string[string_position] = next_char;
string_position++;
continue;
}
}
}
// If the character is a number, add it to the temp string
if (charIsANumber(next_char)) {
temp_string[string_position] = next_char;
string_position++;
}
// Test if the next char is whitespace between chars
else if (charIsWhitespace(next_char)) {
// Test if we have a number string to convert
if (string_position > 0) {
// Terminate the string and convert it to data
temp_string[string_position] = '\0';
data = atoi(temp_string);
if (errno) {
// Handle number convert error
fprintf(
stderr,
"Error: unable to convert %s to an integer\n",
temp_string
);
exit(3);
}
// Push the data onto the stack
push(S, data);
// Finally, clear counter to reset temp string
string_position = 0;
}
}
// Test if the next char is an operator
else if (charIsOperator(next_char)) {
doSingleCalculation(S, next_char);
}
// Handle unexptected characters here
else {
fprintf(
stderr,
"Error: the character %c is not valid.\n",
next_char
);
exit(2);
}
}
// Pop the final value off the stack - that's our answer
data = pop(S);
// If there is anything left on the stack, that's an error - handle here
if (!isEmpty(S)) {
fprintf(
stderr,
"Error: Not enough operators for the number of operands\n"
);
exit(4);
}
return data;
}
/* Get next line of input from G.input_file_list, flushing append buffer and
* noting if we ran out of files without a newline on the last line we read.
*/
static char *get_next_line(char *gets_char, char *last_puts_char)
{
char *temp = NULL;
int len;
char gc;
flush_append(last_puts_char);
/* will be returned if last line in the file
* doesn't end with either '\n' or '\0' */
gc = NO_EOL_CHAR;
for (; G.current_input_file <= G.last_input_file; G.current_input_file++) {
FILE *fp = G.current_fp;
if (!fp) {
const char *path = G.input_file_list[G.current_input_file];
fp = stdin;
if (path != bb_msg_standard_input) {
fp = fopen_or_warn(path, "r");
if (!fp) {
G.exitcode = EXIT_FAILURE;
continue;
}
}
G.current_fp = fp;
}
/* Read line up to a newline or NUL byte, inclusive,
* return malloc'ed char[]. length of the chunk read
* is stored in len. NULL if EOF/error */
temp = bb_get_chunk_from_file(fp, &len);
if (temp) {
/* len > 0 here, it's ok to do temp[len-1] */
char c = temp[len-1];
if (c == '\n' || c == '\0') {
temp[len-1] = '\0';
#if ENABLE_PLATFORM_MINGW32
if (c == '\n' && len > 1 && temp[len-2] == '\r') {
temp[len-2] = '\0';
}
#endif
gc = c;
if (c == '\0') {
int ch = fgetc(fp);
if (ch != EOF)
ungetc(ch, fp);
else
gc = LAST_IS_NUL;
}
}
/* else we put NO_EOL_CHAR into *gets_char */
break;
/* NB: I had the idea of peeking next file(s) and returning
* NO_EOL_CHAR only if it is the *last* non-empty
* input file. But there is a case where this won't work:
* file1: "a woo\nb woo"
* file2: "c no\nd no"
* sed -ne 's/woo/bang/p' input1 input2 => "a bang\nb bang"
* (note: *no* newline after "b bang"!) */
}
/* Close this file and advance to next one */
fclose_if_not_stdin(fp);
G.current_fp = NULL;
}
*gets_char = gc;
return temp;
}
int
_doscan(register FILE *stream, const char *format, va_list ap)
{
int done = 0; /* number of items done */
int nrchars = 0; /* number of characters read */
int conv = 0; /* # of conversions */
int base; /* conversion base */
unsigned long val; /* an integer value */
register char *str; /* temporary pointer */
char *tmp_string; /* ditto */
unsigned width = 0; /* width of field */
int flags; /* some flags */
int reverse; /* reverse the checking in [...] */
int kind;
register int ic = EOF; /* the input character */
#ifndef NOFLOAT
long double ld_val;
#endif
if (!*format) return 0;
while (1) {
if (isspace((int)*format)) {
while (isspace((int)*format))
format++; /* skip whitespace */
ic = getc(stream);
nrchars++;
while (isspace (ic)) {
ic = getc(stream);
nrchars++;
}
if (ic != EOF) ungetc(ic,stream);
nrchars--;
}
if (!*format) break; /* end of format */
if (*format != '%') {
ic = getc(stream);
nrchars++;
if (ic != *format++) break; /* error */
continue;
}
format++;
if (*format == '%') {
ic = getc(stream);
nrchars++;
if (ic == '%') {
format++;
continue;
}
else break;
}
flags = 0;
if (*format == '*') {
format++;
flags |= FL_NOASSIGN;
}
if (isdigit (*format)) {
flags |= FL_WIDTHSPEC;
for (width = 0; isdigit (*format);)
width = width * 10 + *format++ - '0';
}
switch (*format) {
case 'h': flags |= FL_SHORT; format++; break;
case 'l': flags |= FL_LONG; format++; break;
case 'L': flags |= FL_LONGDOUBLE; format++; break;
}
kind = *format;
if ((kind != 'c') && (kind != '[') && (kind != 'n')) {
do {
ic = getc(stream);
nrchars++;
} while (isspace(ic));
if (ic == EOF) break; /* outer while */
} else if (kind != 'n') { /* %c or %[ */
ic = getc(stream);
if (ic == EOF) break; /* outer while */
nrchars++;
}
switch (kind) {
default:
/* not recognized, like %q */
return conv || (ic != EOF) ? done : EOF;
break;
case 'n':
if (!(flags & FL_NOASSIGN)) { /* silly, though */
if (flags & FL_SHORT)
*va_arg(ap, short *) = (short) nrchars;
else if (flags & FL_LONG)
*va_arg(ap, long *) = (long) nrchars;
else
*va_arg(ap, int *) = (int) nrchars;
}
break;
case 'p': /* pointer */
set_pointer(flags);
/* fallthrough */
case 'b': /* binary */
case 'd': /* decimal */
case 'i': /* general integer */
case 'o': /* octal */
case 'u': /* unsigned */
case 'x': /* hexadecimal */
case 'X': /* ditto */
if (!(flags & FL_WIDTHSPEC) || width > NUMLEN)
width = NUMLEN;
if (!width) return done;
str = o_collect(ic, stream, kind, width, &base);
if (str < inp_buf
|| (str == inp_buf
&& (*str == '-'
|| *str == '+'))) return done;
/*
* Although the length of the number is str-inp_buf+1
* we don't add the 1 since we counted it already
*/
nrchars += str - inp_buf;
if (!(flags & FL_NOASSIGN)) {
if (kind == 'd' || kind == 'i')
val = strtol(inp_buf, &tmp_string, base);
else
val = strtoul(inp_buf, &tmp_string, base);
if (flags & FL_LONG)
*va_arg(ap, unsigned long *) = (unsigned long) val;
else if (flags & FL_SHORT)
*va_arg(ap, unsigned short *) = (unsigned short) val;
else
*va_arg(ap, unsigned *) = (unsigned) val;
}
break;
case 'c':
if (!(flags & FL_WIDTHSPEC))
width = 1;
if (!(flags & FL_NOASSIGN))
str = va_arg(ap, char *);
if (!width) return done;
while (width && ic != EOF) {
if (!(flags & FL_NOASSIGN))
*str++ = (char) ic;
if (--width) {
ic = getc(stream);
nrchars++;
}
}
if (width) {
if (ic != EOF) ungetc(ic,stream);
nrchars--;
}
break;
case 's':
if (!(flags & FL_WIDTHSPEC))
width = 0xffff;
if (!(flags & FL_NOASSIGN))
str = va_arg(ap, char *);
if (!width) return done;
while (width && ic != EOF && !isspace(ic)) {
if (!(flags & FL_NOASSIGN))
*str++ = (char) ic;
if (--width) {
ic = getc(stream);
nrchars++;
}
}
/* terminate the string */
if (!(flags & FL_NOASSIGN))
*str = '\0';
if (width) {
if (ic != EOF) ungetc(ic,stream);
nrchars--;
}
break;
case '[':
if (!(flags & FL_WIDTHSPEC))
width = 0xffff;
if (!width) return done;
if ( *++format == '^' ) {
reverse = 1;
format++;
} else
reverse = 0;
for (str = Xtable; str < &Xtable[NR_CHARS]
; str++)
*str = 0;
if (*format == ']') Xtable[(int)*format++] = 1;
while (*format && *format != ']') {
Xtable[(int)*format++] = 1;
if (*format == '-') {
format++;
if (*format
&& *format != ']'
&& *(format) >= *(format -2)) {
int c;
for( c = *(format -2) + 1
; c <= *format ; c++)
Xtable[c] = 1;
format++;
}
else Xtable['-'] = 1;
}
}
if (!*format) return done;
if (!(Xtable[ic] ^ reverse)) {
/* MAT 8/9/96 no match must return character */
ungetc(ic, stream);
return done;
}
if (!(flags & FL_NOASSIGN))
str = va_arg(ap, char *);
do {
if (!(flags & FL_NOASSIGN))
*str++ = (char) ic;
if (--width) {
ic = getc(stream);
nrchars++;
}
} while (width && ic != EOF && (Xtable[ic] ^ reverse));
if (width) {
if (ic != EOF) ungetc(ic, stream);
nrchars--;
}
if (!(flags & FL_NOASSIGN)) { /* terminate string */
*str = '\0';
}
break;
} /* end switch */
conv++;
if (!(flags & FL_NOASSIGN) && kind != 'n') done++;
format++;
}
return conv || (ic != EOF) ? done : EOF;
}
static boolean addElementLen (FILE *fp, tree *tr, nodeptr p, boolean readBranchLengths, boolean readNodeLabels, int *lcount)
{
nodeptr q;
int n, ch, fres;
if ((ch = treeGetCh(fp)) == '(')
{
n = (tr->nextnode)++;
if (n > 2*(tr->mxtips) - 2)
{
if (tr->rooted || n > 2*(tr->mxtips) - 1)
{
printf("ERROR: Too many internal nodes. Is tree rooted?\n");
printf(" Deepest splitting should be a trifurcation.\n");
return FALSE;
}
else
{
assert(!readNodeLabels);
tr->rooted = TRUE;
}
}
q = tr->nodep[n];
if (! addElementLen(fp, tr, q->next, readBranchLengths, readNodeLabels, lcount)) return FALSE;
if (! treeNeedCh(fp, ',', "in")) return FALSE;
if (! addElementLen(fp, tr, q->next->next, readBranchLengths, readNodeLabels, lcount)) return FALSE;
if (! treeNeedCh(fp, ')', "in")) return FALSE;
if(readNodeLabels)
{
char label[64];
int support;
if(treeGetLabel (fp, label, 10))
{
int val = sscanf(label, "%d", &support);
assert(val == 1);
/*printf("LABEL %s Number %d\n", label, support);*/
/*p->support = q->support = support;*/
/*printf("%d %d %d %d\n", p->support, q->support, p->number, q->number);*/
assert(p->number > tr->mxtips && q->number > tr->mxtips);
*lcount = *lcount + 1;
}
}
else
(void) treeFlushLabel(fp);
}
else
{
ungetc(ch, fp);
if ((n = treeFindTipName(fp, tr)) <= 0) return FALSE;
q = tr->nodep[n];
if (tr->start->number > n) tr->start = q;
(tr->ntips)++;
}
if(readBranchLengths)
{
double branch;
if (! treeNeedCh(fp, ':', "in")) return FALSE;
if (! treeProcessLength(fp, &branch)) return FALSE;
/*printf("Branch %8.20f %d\n", branch, tr->numBranches);*/
hookup(p, q, &branch, tr->numBranches);
}
else
{
fres = treeFlushLen(fp);
if(!fres) return FALSE;
hookupDefault(p, q, tr->numBranches);
}
return TRUE;
}
static int
read_disabled_heur_dissector_list_file(const char *ff_path, FILE *ff,
GList **flp)
{
heur_protocol_def *heur;
int c;
char *heuristic_name;
int heuristic_name_len;
int name_index;
gboolean parse_enabled;
gboolean enabled;
int line = 1;
/* Allocate the protocol name buffer. */
heuristic_name_len = INIT_BUF_SIZE;
heuristic_name = (char *)g_malloc(heuristic_name_len + 1);
for (line = 1; ; line++) {
/* Lines in a disabled protocol file contain the "filter name" of
a protocol to be disabled. */
/* Skip over leading white space, if any. */
while ((c = getc(ff)) != EOF && g_ascii_isspace(c)) {
if (c == '\n') {
/* Blank line. */
continue;
}
}
if (c == EOF) {
if (ferror(ff))
goto error; /* I/O error */
else
break; /* Nothing more to read */
}
ungetc(c, ff); /* Unread the non-white-space character. */
/* Get the name of the protocol. */
name_index = 0;
enabled = FALSE;
parse_enabled = FALSE;
for (;;) {
c = getc(ff);
if (c == EOF)
break; /* End of file, or I/O error */
if (g_ascii_isspace(c))
break; /* Trailing white space, or end of line. */
if (c == ',') {/* Separator for enable/disable */
parse_enabled = TRUE;
continue;
}
if (c == '#')
break; /* Start of comment, running to end of line. */
if (parse_enabled) {
enabled = ((c == '1') ? TRUE : FALSE);
break;
}
/* Add this character to the protocol name string. */
if (name_index >= heuristic_name_len) {
/* protocol name buffer isn't long enough; double its length. */
heuristic_name_len *= 2;
heuristic_name = (char *)g_realloc(heuristic_name, heuristic_name_len + 1);
}
heuristic_name[name_index] = c;
name_index++;
}
if (g_ascii_isspace(c) && c != '\n') {
/* Skip over trailing white space. */
while ((c = getc(ff)) != EOF && c != '\n' && g_ascii_isspace(c))
;
if (c != EOF && c != '\n' && c != '#') {
/* Non-white-space after the protocol name; warn about it,
in case we come up with a reason to use it. */
g_warning("'%s' line %d has extra stuff after the protocol name.",
ff_path, line);
}
}
if (c != EOF && c != '\n') {
/* Skip to end of line. */
while ((c = getc(ff)) != EOF && c != '\n')
;
}
if (c == EOF) {
if (ferror(ff))
goto error; /* I/O error */
else {
/* EOF, not error; no newline seen before EOF */
g_warning("'%s' line %d doesn't have a newline.", ff_path,
line);
}
break; /* nothing more to read */
}
/* Null-terminate the protocol name. */
if (name_index >= heuristic_name_len) {
/* protocol name buffer isn't long enough; double its length. */
heuristic_name_len *= 2;
heuristic_name = (char *)g_realloc(heuristic_name, heuristic_name_len + 1);
}
heuristic_name[name_index] = '\0';
/* Add the new protocol to the list of disabled protocols */
heur = (heur_protocol_def *) g_malloc(sizeof(heur_protocol_def));
heur->name = g_strdup(heuristic_name);
heur->enabled = enabled;
*flp = g_list_append(*flp, heur);
}
g_free(heuristic_name);
return 0;
error:
g_free(heuristic_name);
return errno;
}
int treeReadLen (FILE *fp, tree *tr, boolean readBranches, boolean readNodeLabels, boolean topologyOnly)
{
nodeptr
p;
int
i,
ch,
lcount = 0;
for (i = 1; i <= tr->mxtips; i++)
{
tr->nodep[i]->back = (node *) NULL;
/*if(topologyOnly)
tr->nodep[i]->support = -1;*/
}
for(i = tr->mxtips + 1; i < 2 * tr->mxtips; i++)
{
tr->nodep[i]->back = (nodeptr)NULL;
tr->nodep[i]->next->back = (nodeptr)NULL;
tr->nodep[i]->next->next->back = (nodeptr)NULL;
tr->nodep[i]->number = i;
tr->nodep[i]->next->number = i;
tr->nodep[i]->next->next->number = i;
/*if(topologyOnly)
{
tr->nodep[i]->support = -2;
tr->nodep[i]->next->support = -2;
tr->nodep[i]->next->next->support = -2;
}*/
}
if(topologyOnly)
tr->start = tr->nodep[tr->mxtips];
else
tr->start = tr->nodep[1];
tr->ntips = 0;
tr->nextnode = tr->mxtips + 1;
for(i = 0; i < tr->numBranches; i++)
tr->partitionSmoothed[i] = FALSE;
tr->rooted = FALSE;
p = tr->nodep[(tr->nextnode)++];
while((ch = treeGetCh(fp)) != '(');
if(!topologyOnly)
assert(readBranches == FALSE && readNodeLabels == FALSE);
if (! addElementLen(fp, tr, p, readBranches, readNodeLabels, &lcount))
assert(0);
if (! treeNeedCh(fp, ',', "in"))
assert(0);
if (! addElementLen(fp, tr, p->next, readBranches, readNodeLabels, &lcount))
assert(0);
if (! tr->rooted)
{
if ((ch = treeGetCh(fp)) == ',')
{
if (! addElementLen(fp, tr, p->next->next, readBranches, readNodeLabels, &lcount))
assert(0);
}
else
{ /* A rooted format */
tr->rooted = TRUE;
if (ch != EOF) (void) ungetc(ch, fp);
}
}
else
{
p->next->next->back = (nodeptr) NULL;
}
if (! treeNeedCh(fp, ')', "in"))
assert(0);
if(topologyOnly)
assert(!(tr->rooted && readNodeLabels));
(void) treeFlushLabel(fp);
if (! treeFlushLen(fp))
assert(0);
if (! treeNeedCh(fp, ';', "at end of"))
assert(0);
if (tr->rooted)
{
assert(!readNodeLabels);
p->next->next->back = (nodeptr) NULL;
tr->start = uprootTree(tr, p->next->next, FALSE, FALSE);
if (! tr->start)
{
printf("FATAL ERROR UPROOTING TREE\n");
assert(0);
}
}
else
tr->start = findAnyTip(p, tr->mxtips);
assert(tr->ntips == tr->mxtips);
return lcount;
}
/*
* return end of string - WARNING: malloc!
*/
int
xpmGetString(xpmData *mdata, char **sptr, unsigned int *l)
{
unsigned int i, n = 0;
int c;
char *p, *q, buf[BUFSIZ];
if (!mdata->type || mdata->type == XPMBUFFER) {
if (mdata->cptr) {
char *start;
while (isspace(c = *mdata->cptr) && c != mdata->Eos)
mdata->cptr++;
start = mdata->cptr;
while ((c = *mdata->cptr) && c != mdata->Eos)
mdata->cptr++;
n = mdata->cptr - start + 1;
p = (char *) XpmMalloc(n);
if (!p)
return (XpmNoMemory);
strncpy(p, start, n);
if (mdata->type) /* XPMBUFFER */
p[n - 1] = '\0';
}
} else {
FILE *file = mdata->stream.file;
while ((c = getc(file)) != EOF && isspace(c) && c != mdata->Eos);
if (c == EOF)
return (XpmFileInvalid);
p = NULL;
i = 0;
q = buf;
p = (char *) XpmMalloc(1);
while (c != mdata->Eos && c != EOF) {
if (i == BUFSIZ) {
/* get to the end of the buffer */
/* malloc needed memory */
q = (char *) XpmRealloc(p, n + i);
if (!q) {
XpmFree(p);
return (XpmNoMemory);
}
p = q;
q += n;
/* and copy what we already have */
strncpy(q, buf, i);
n += i;
i = 0;
q = buf;
}
*q++ = c;
i++;
c = getc(file);
}
if (c == EOF) {
XpmFree(p);
return (XpmFileInvalid);
}
if (n + i != 0) {
/* malloc needed memory */
q = (char *) XpmRealloc(p, n + i + 1);
if (!q) {
XpmFree(p);
return (XpmNoMemory);
}
p = q;
q += n;
/* and copy the buffer */
strncpy(q, buf, i);
n += i;
p[n++] = '\0';
} else {
*p = '\0';
n = 1;
}
ungetc(c, file);
}
*sptr = p;
*l = n;
return (XpmSuccess);
}
char peek (FILE * f)
{
char c = fgetc (f);
ungetc (c, f);
return c;
}
