static void assemble (flag_t flags) { extern signed c; c = mygetc (); while (c != EOF) { if (isspace (c)) { do { c = mygetc (); } while (isspace (c)); continue; } if ((c == '#') || (c == ';')) { do { c = mygetc (); } while (nobreak (c)); continue; } phy = integer (16); reg = integer (16); data = integer (16); mask = integer (16); instr = MDIO16_INSTR (1, 1, phy, reg, 2); write (STDOUT_FILENO, &instr, sizeof (instr)); data = HTOLE16 (data & 0xFFFF); write (STDOUT_FILENO, &data, sizeof (data)); mask = HTOLE16 (mask & 0xFFFF); write (STDOUT_FILENO, &mask, sizeof (mask)); count++; if (_anyset (flags, MDIO_VERBOSE)) { fprintf (stderr, "INSTR=0x%04X DATA=0x%04X MASK=0x%04X\n", instr, data, mask); } if ((c == ';') || (c == EOF)) { c = mygetc (); continue; } if (_allclr (flags, MDIO_SILENCE)) { error (1, 0, "Illegal character or missing terminator: line %d col %d", row, col); } } return; }
void getnext( int abc, int nextstep[] ) { int a, b, c; a = mygeta(abc); b = mygetb(abc); c = mygetc(abc); if( (b < BROOM) && (a>0) ) nextstep[0] = get_abc( fromcup(a,b,BROOM), tocup(a,b,BROOM), c ); //A to B if( (c < CROOM) && (a>0) ) nextstep[1] = get_abc( fromcup(a,c,CROOM), b, tocup(a,c,CROOM) ); //A to C if( (a < AROOM) && (b>0) ) nextstep[2] = get_abc( tocup(b,a,AROOM), fromcup(b,a,AROOM), c ); //B to A if( (c < CROOM) && (b>0) ) nextstep[3] = get_abc( a, fromcup(b,c,CROOM), tocup(b,c,CROOM) ); //B to C if( (a < AROOM) && (c>0) ) nextstep[4] = get_abc( tocup(c,a,AROOM), b, fromcup(c,a,AROOM) ); //C to A if( (b < BROOM) && (c>0) ) nextstep[5] = get_abc( a, tocup(c,b,BROOM), fromcup(c,b,BROOM) ); //C to B #ifdef HSSDEBUG int i; printf("%03d = %d %d %d,", abc, a, b, c); for (i=0; i<6; i++) printf(" %03d,", nextstep[i] ); printf("\n"); #endif return; }
/* G e t b i t s * * Put curbits bits into index from stdin. Note: only copy 4 uses this. * The bits within a byte are in the correct order. But when the bits * cross a byte boundry, the lowest bits will be in the higher part of * the current byte, and the higher bits will be in the lower part of * the next byte. */ void getbits() { int have; static unsigned curbyte; /* byte having bits extracted from it */ static int left; /* how many bits are left in curbyte */ inmod = (inmod + 1) & 7; /* count input mod 8 */ iindex = curbyte; have = left; if (curbits - have > 8) { iindex |= mygetc() << have; have += 8; } iindex |= ((curbyte = mygetc()) << have) & ~((unsigned) 0xFFFF << curbits); curbyte >>= curbits - have; left = 8 - (curbits - have); }
static uint16_t integer (unsigned radix) { extern signed c; uint16_t value = 0; unsigned digit = 0; while ((digit = todigit (c)) < radix) { value *= radix; value += digit; c = mygetc (); } while (isspace (c)) { c = mygetc (); } return (value); }
void DemLex (FILE *fpin) { /* fpin est un fichier qui a été ouvert correctement */ leFichier = fpin ; nol = 1 ; noc = 0 ; ptaschar = taschar ; cc = mygetc(leFichier) ; AvLex () ; }
static INLINE int gobble(int c) { int d; d = mygetc(); if (c == d) return 1; *--outp = d; nbuf++; return 0; }
static void skip_comment2(void) { int c; while ((c = mygetc()) != '\n' && c != EOF) ; if (c == EOF) { lexerror("End of file in a // comment"); return; } nexpands=0; store_line_number_info(current_incfile, current_line); current_line++; }
static size_t myfgets(char* buf,size_t bufsize) { static int eof; int i; size_t j; if (eof) return 0; for (j=0; j<bufsize-1; ++j) { i=mygetc(); if (i==-2) { eof=1; return j; } if (i==-1) return -1; if (i=='\n') break; buf[j]=i; } buf[j]=0; return j; }
/* Greps the starting number */ int grepFirstNumber(int* ret,int c,FILE* datei,char* vname,char* str,int str_len,int* c_read){ if(ret[0]!=77) c = mygetc(str,str_len,datei,c_read); else{ ret[0]= 0; c = ret[1]; } while(isspace(c)) c = mygetc(str,str_len,datei,c_read); while(1){ if(c == '-') { *vname='\0'; return 0; } else if (isspace(c)) c = mygetc(str,str_len,datei,c_read); else{ if (isdigit(c)){ *vname=c; vname++; c = mygetc(str,str_len,datei,c_read); } else return 1; } } return 2; }
static int EatComment( myFILE *InFile ) /* ------------------------------------------------------------------------ ** * Scan to the end of a comment. * * Input: InFile - Input source. * * Output: The character that marks the end of the comment. Normally, * this will be a newline, but it *might* be an EOF. * * Notes: Because the config files use a line-oriented grammar, we * explicitly exclude the newline character from the list of * whitespace characters. * - Note that both EOF (-1) and the nul character ('\0') are * considered end-of-file markers. * * ------------------------------------------------------------------------ ** */ { int c; for( c = mygetc( InFile ); ('\n'!=c) && (EOF!=c) && (c>0); c = mygetc( InFile ) ) ; return( c ); } /* EatComment */
static int EatWhitespace( myFILE *InFile ) /* ------------------------------------------------------------------------ ** * Scan past whitespace (see ctype(3C)) and return the first non-whitespace * character, or newline, or EOF. * * Input: InFile - Input source. * * Output: The next non-whitespace character in the input stream. * * Notes: Because the config files use a line-oriented grammar, we * explicitly exclude the newline character from the list of * whitespace characters. * - Note that both EOF (-1) and the nul character ('\0') are * considered end-of-file markers. * * ------------------------------------------------------------------------ ** */ { int c; for( c = mygetc( InFile ); isspace( c ) && ('\n' != c); c = mygetc( InFile ) ) ; return( c ); } /* EatWhitespace */
static int cmygetc(void) { int c; for (;;) { c = mygetc(); if (c == '/') { if (gobble('*')) skip_comment(); else return c; } else return c; } }
// output the result in *pa, return the status static int getint(double *pa) { int c; // skip the space for (c = mygetc(); isspace(c) && c != EOF; c = mygetc()); if (c == EOF) return EOF; // not a number if (!isdigit(c) && c != '+' && c != '-') return 0; int sign; sign = 1; if (c == '+' || c == '-') { if (c == '-') sign = -1; // have '+' or '-', but not a number if (isspace(c = mygetc()) || c == EOF) { *pa = 0; if (c != EOF) myungetc(c); return c; } } // is a number *pa = 0; for (; isdigit(c) && c != EOF; c = mygetc()) { //printf("%c\n", c); //getchar(); *pa = *pa * 10 + (c - '0'); //printf("%d\n", *pa); } // the fraction if (c == '.') { double fac; for (fac = 0.1, c = mygetc(); isdigit(c) && c != EOF; c = mygetc(), fac /= 10.0) { *pa += (c - '0') * fac; } } *pa *= sign; if (c != EOF) myungetc(c); return c; }
static void parse_token(struct token *t) { int c; while (isspace(c = mygetc()) && (c != '\n')) continue; retry: if (isdigit(c)) { t->type = NUM; t->u.num.start = c - '0'; while (isdigit(c = mygetc())) t->u.num.start = t->u.num.start * 10 + c - '0'; t->u.num.end = t->u.num.start; t->u.num.step = 1; if (c == '-') { t->u.num.end = 0; while (isdigit(c = mygetc())) t->u.num.end = t->u.num.end * 10 + c - '0'; if (t->u.num.end < t->u.num.start) parse_err("bad range %u-%u", t->u.num.start, t->u.num.end); } if (c == '/') { t->u.num.step = 0; while (isdigit(c = mygetc())) t->u.num.step = t->u.num.step * 10 + c - '0'; } myungetc(c); } else if (c == '"') { char *p = t->u.str; t->type = STR; while ((c = mygetc()) != '"') { if ((c == '\n') || (c == '\r') || (c == EOF)) parse_err("unexpected newline or end-of-file in string"); *p++ = c; if ((p - t->u.str) >= (sizeof(t->u.str)-1)) parse_err("string too long"); } *p = '\0'; } else if (isalpha(c)) { char *p = t->u.str; t->type = STR; *p++ = c; while (isalnum(c = mygetc()) || (c == '_')) { *p++ = c; if ((p - t->u.str) >= (sizeof(t->u.str)-1)) parse_err("string too long"); } *p = '\0'; myungetc(c); } else if (c == '\\') { /* ignore EOL at line break */ while (isspace(c = mygetc()) && (c != '\n')) continue; if (c != '\n') parse_err("expected newline after backslash"); while (isspace(c = mygetc()) && (c != '\n')) continue; goto retry; } else if (c == '#') { /* ignore until EOL */ while (((c = mygetc()) != EOF) && (c != '\n')) continue; goto retry; } else if ((c == EOF) || (c == '\n')) { t->type = EOL; t->u.ch = c; } else { t->type = CHR; t->u.ch = c; } }
static bool Parameter( DATA_BLOB *buf, myFILE *InFile, bool (*pfunc)(const char *, const char *, void *), int c, void *userdata ) { int i = 0; /* Position within bufr. */ int end = 0; /* bufr[end] is current end-of-string. */ int vstart = 0; /* Starting position of the parameter value. */ const char *func = "params.c:Parameter() -"; /* Read the parameter name. */ while( 0 == vstart ) { /* Loop until we've found the start of the value. */ if( i > (buf->length - 2) ) { /* Ensure there's space for next char. */ uint8_t *tb = (uint8_t *)SMB_REALLOC_KEEP_OLD_ON_ERROR( buf->data, buf->length + BUFR_INC ); if (!tb) { DEBUG(0, ("%s Memory re-allocation failure.", func) ); return False; } buf->data = tb; buf->length += BUFR_INC; } switch(c) { case '=': /* Equal sign marks end of param name. */ if( 0 == end ) { /* Don't allow an empty name. */ DEBUG(0, ("%s Invalid parameter name in config. file.\n", func )); return False; } buf->data[end++] = '\0'; /* Mark end of string & advance. */ i = end; /* New string starts here. */ vstart = end; /* New string is parameter value. */ buf->data[i] = '\0'; /* New string is nul, for now. */ break; case '\n': /* Find continuation char, else error. */ i = Continuation( buf->data, i ); if( i < 0 ) { buf->data[end] = '\0'; DEBUG(1,("%s Ignoring badly formed line in configuration file: %s\n", func, buf->data )); return True; } end = ( (i > 0) && (' ' == buf->data[i - 1]) ) ? (i - 1) : (i); c = mygetc( InFile ); /* Read past eoln. */ break; case '\0': /* Shouldn't have EOF within param name. */ case EOF: buf->data[i] = '\0'; DEBUG(1,("%s Unexpected end-of-file at: %s\n", func, buf->data )); return True; default: if(isspace( c )) { /* One ' ' per whitespace region. */ buf->data[end] = ' '; i = end + 1; c = EatWhitespace( InFile ); } else { buf->data[i++] = c; end = i; c = mygetc( InFile ); } } } /* Now parse the value. */ c = EatWhitespace( InFile ); /* Again, trim leading whitespace. */ while( (EOF !=c) && (c > 0) ) { if( i > (buf->length - 2) ) { /* Make sure there's enough room. */ uint8_t *tb = (uint8_t *)SMB_REALLOC_KEEP_OLD_ON_ERROR( buf->data, buf->length + BUFR_INC ); if (!tb) { DEBUG(0, ("%s Memory re-allocation failure.", func)); return False; } buf->data = tb; buf->length += BUFR_INC; } switch(c) { case '\r': /* Explicitly remove '\r' because the older */ c = mygetc( InFile ); /* version called fgets_slash() which also */ break; /* removes them. */ case '\n': /* Marks end of value unless there's a '\'. */ i = Continuation( buf->data, i ); if( i < 0 ) { c = 0; } else { for( end = i; (end >= 0) && isspace((int)buf->data[end]); end-- ) ; c = mygetc( InFile ); } break; default: /* All others verbatim. Note that spaces do not advance <end>. This allows trimming */ buf->data[i++] = c; if( !isspace( c ) ) /* of whitespace at the end of the line. */ end = i; c = mygetc( InFile ); break; } } buf->data[end] = '\0'; /* End of value. */ return( pfunc( (char *)buf->data, (char *)&buf->data[vstart], userdata ) ); /* Pass name & value to pfunc(). */ }
static bool Section( DATA_BLOB *buf, myFILE *InFile, bool (*sfunc)(const char *, void *), void *userdata ) { int c; int i; int end; const char *func = "params.c:Section() -"; i = 0; /* <i> is the offset of the next free byte in bufr[] and */ end = 0; /* <end> is the current "end of string" offset. In most */ /* cases these will be the same, but if the last */ /* character written to bufr[] is a space, then <end> */ /* will be one less than <i>. */ /* Find the end of the section. We must use mb functions for this. */ if (!FindSectionEnd(InFile)) { DEBUG(0, ("%s No terminating ']' character in section.\n", func) ); return False; } c = EatWhitespace( InFile ); /* We've already got the '['. Scan */ /* past initial white space. */ while( (EOF != c) && (c > 0) ) { /* Check that the buffer is big enough for the next character. */ if( i > (buf->length - 2) ) { uint8_t *tb = (uint8_t *)SMB_REALLOC_KEEP_OLD_ON_ERROR(buf->data, buf->length+BUFR_INC ); if(!tb) { DEBUG(0, ("%s Memory re-allocation failure.", func) ); return False; } buf->data = tb; buf->length += BUFR_INC; } /* Handle a single character other than section end. */ switch( c ) { case '\n': /* Got newline before closing ']'. */ i = Continuation( buf->data, i ); /* Check for line continuation. */ if( i < 0 ) { buf->data[end] = '\0'; DEBUG(0, ("%s Badly formed line in configuration file: %s\n", func, buf->data )); return False; } end = ( (i > 0) && (' ' == buf->data[i - 1]) ) ? (i - 1) : (i); c = mygetc( InFile ); /* Continue with next line. */ break; default: /* All else are a valid name chars. */ if(isspace( c )) { /* One space per whitespace region. */ buf->data[end] = ' '; i = end + 1; c = EatWhitespace( InFile ); } else { buf->data[i++] = c; end = i; c = mygetc( InFile ); } } if (AtSectionEnd(InFile)) { /* Got to the closing bracket. */ buf->data[end] = '\0'; if( 0 == end ) { /* Don't allow an empty name. */ DEBUG(0, ("%s Empty section name in configuration file.\n", func )); return False; } if( !sfunc((char *)buf->data, userdata) ) /* Got a valid name. Deal with it. */ return False; EatComment( InFile ); /* Finish off the line. */ return True; } } /* We arrive here if we've met the EOF before the closing bracket. */ DEBUG(0, ("%s Unexpected EOF in the configuration file: %s\n", func, buf->data )); return False; }
/* Main function starts */ int main() { clock_t begin, end; int option, n, temp; const char *a="Writing byte by byte\n"; const char *b="Writing using buffers\n"; unsigned long i, bytes_to_write = BYTES_TO_READ_WRITE, bytes_to_read = BYTES_TO_READ_WRITE; char ch; while(1) { printf("\n 1 - Write without buffering \n 2 - Write with buffering"); printf("\n 3 - Read without buffering \n 4 - Read with buffering"); printf(("\n 5 - Exit \n Enter the option: ")); scanf("%d", &option); switch(option) { case 1: /* Write without buffer */ begin = clock(); for (i=0;i<bytes_to_write;i++) { ch = a[i%strlen(a)]; mywritec(ch); } end = clock(); printf("\n Time to write without buffering: %f secs\n",(double)(end - begin)/CLOCKS_PER_SEC); break; case 2: /* Write with buffer */ printf("\n Enter the buffer size in bytes: "); scanf("%d", &n); mywritebufsetup(n); begin = clock(); for (i=0;i<bytes_to_write;i++) { ch = b[i%strlen(b)]; myputc(ch); } mywriteflush(); end = clock(); printf("\n Time to write with buffering: %f secs\n",(double)(end - begin)/CLOCKS_PER_SEC); break; case 3: /* Read without buffer */ fd_read = open(READABLE_FILE, O_RDONLY); if(fd_read < 0) { printf("\n Error opening the readable file \n"); return 1; } begin = clock(); for (i=0;i<bytes_to_read;i++) { /* you may need to modify this slightly to print the character received and also check for end of file */ if(myreadc() == -1) { printf("\n End of file \n"); break; } } end = clock(); if(close(fd_read)) { printf("\n Error while closing the file \n "); } printf("\n Time to read without buffering: %f secs\n",(double)(end - begin)/CLOCKS_PER_SEC); break; case 4: /* Read with buffer */ printf("\n Enter the buffer size in bytes: "); scanf("%d", &n); myreadbufsetup(n); fd_read = open(READABLE_FILE, O_RDONLY); if(fd_read < 0) { printf("\n Error opening the readable file \n"); return 1; } begin = clock(); for (i=0;i<bytes_to_read;i++) { /* you may need to modify this slightly to print the character received and also check for end of file */ if(mygetc() == -1) { printf("\n End of file \n"); break; } } end = clock(); if(close(fd_read)) { printf("\n Error while closing the file \n "); } printf("\n Time to read with buffering: %f secs\n",(double)(end - begin)/CLOCKS_PER_SEC); break; default: return 0; } } }
partition_t parse_partition(FILE* datei,int all,int paras){ int i = 0; /* loop variable */ int j = 0; /* loop variable */ int c = 0; /* Read Character */ int current_pos = 0; /* Current Position for Start/End */ int temp = 0;/* loop variable */ int charset_flag = 0;/* Flag to check when charset starts */ int charpart_flag = 0;/* Flag to check when charpartition starts */ size_t current_set_len = 0; /* number of charsets currently read. */ size_t partition_counter = 0; /* number of charpartitionlines currently read */ size_t set_leng = SET_LENG; /* Maximum number of Charsets */ size_t part_leng = PART_LENG; /*Maximum number of Charpartitionlines */ int true_nexus = 0; /* Flag to check if file is a Nexusfile */ int set_start = 0; int end_counter = 0; partition_t ret; /* Returned struct */ int part_var_names_str_len[2]; int temp_summe; /* Current_pos + temp_sum = new starting point for partition */ char vname[100]; /* String for a name */ char first_number[100]; /* String for a name */ char second_number[100]; /* String for a name */ char step_number[100]; /* String for a name */ char **lookup; /*Array of Strings for Charsets */ char mod_name[100]; /* String for a name */ char mod_v_name[100];/* String for a name */ char pname[2000];/* String for a name */ char **ppart_name; /* Array of Strings for Charpartitions */ char **ppart_var_name; /* Array of Strings for Charpartitions */ char **ppart_model_name; /* Array of Strings for Charpartitions */ char **ppart_parameter_name; /* Array of Strings for Charpartitions */ int fn,sn,st; /* Calculation of length */ int name_right; int more_numbone; int more_mv_names[3]; int* ind; int doto[2]; size_t* pset_fn; size_t* pset_sn; size_t* pset_st; size_t* pset_leng; size_t* ppart_fn; size_t* ppart_sn; char * str; int str_len = STR_LEN; int c_read = -1; /* Allocate arrays */ str = (char*) malloc(sizeof(char)*str_len); str = fgets(str,str_len,datei); pset_fn = (size_t*) malloc(sizeof(size_t)*set_leng); pset_sn = (size_t*) malloc(sizeof(size_t)*set_leng); pset_st = (size_t*) malloc(sizeof(size_t)*set_leng); pset_leng = (size_t*) malloc(sizeof(size_t)*set_leng); ppart_fn = (size_t*) malloc(sizeof(size_t)*part_leng); ppart_sn = (size_t*) malloc(sizeof(size_t)*part_leng); ppart_name = (char **) malloc(sizeof(char*)*part_leng); ppart_var_name = (char **) malloc(sizeof(char*)*part_leng); ppart_model_name = (char **) malloc(sizeof(char*)*part_leng); ppart_parameter_name = (char **) malloc(sizeof(char*)*part_leng); lookup = (char **) malloc(sizeof(char*)*set_leng); /* Here the fun begins */ while( (c=mygetc(str,str_len,datei,&c_read)) != EOF && true_nexus != 6){ while(isspace(c)) c = mygetc(str,str_len,datei,&c_read); if (c<91 && c>64) c+= 32; if(true_nexus == 0 && c=='#') true_nexus++; else if(true_nexus == 1 && c=='n') true_nexus++; else if(true_nexus == 2 && c=='e') true_nexus++; else if(true_nexus == 3 && c=='x') true_nexus++; else if(true_nexus == 4 && c=='u') true_nexus++; else if(true_nexus == 5 && c=='s') { true_nexus++; break; } else true_nexus = 0; } if(true_nexus != 6) { printf("No '#nexus' was found. Is this a nexus file?\n"); exit(EXIT_FAILURE); } else { while( (c=mygetc(str,str_len,datei,&c_read)) != EOF){ if(set_start == 0 && c=='b') set_start++; else if(set_start == 1 && c=='e') set_start++; else if(set_start == 2 && c=='g') set_start++; else if(set_start == 3 && c=='i') set_start++; else if(set_start == 4 && c=='n') set_start++; else if(set_start == 5 && c==' ') set_start++; else if(set_start == 6 && c=='s') set_start++; else if(set_start == 7 && c=='e') set_start++; else if(set_start == 8 && c=='t') set_start++; else if(set_start == 9 && c=='s') set_start++; else if(set_start == 10 && c==';') { set_start++; break; } else set_start = 0; } } if(set_start != 11) { printf("No sets have been found\n"); exit(EXIT_FAILURE); } while( (c=mygetc(str,str_len,datei,&c_read)) != EOF){ if(charset_flag == 0 && c=='e' && end_counter==0) end_counter++; else if(charset_flag == 0 && c=='n' && end_counter==1) end_counter++; else if(charset_flag == 0 && c=='d' && end_counter==2) end_counter++; else if(charset_flag == 0 && c==';' && end_counter==3) end_counter++; else end_counter=0; if(end_counter==4) break; if(charset_flag == 0 && c=='c') charset_flag++; else if(charset_flag == 1 && c=='h') charset_flag++; else if(charset_flag == 2 && c=='a') charset_flag++; else if(charset_flag == 3 && c=='r') charset_flag++; else if(charset_flag == 4 && c=='s') charset_flag++; else if(charset_flag == 5 && c=='e') charset_flag++; else if(charset_flag == 6 && c=='t') charset_flag++; else if(charset_flag == 7 && c==' ') charset_flag++; else if(charset_flag == 8){ /* fseek(datei, -1L, SEEK_CUR); */ name_right = grepName(c,datei,vname,str,str_len,&c_read); if( name_right == -1) exit(EXIT_FAILURE); lookup[i]=(char *) malloc(sizeof(char)*name_right); for(temp=0;vname[temp]!='\0';temp++){ lookup[i][temp]=vname[temp]; } lookup[i][temp]='\0'; grepFirstNumber(doto,c,datei,first_number,str,str_len,&c_read); fn = charint(first_number); pset_fn[i]=charint(first_number); more_numbone = grepSecondNumber(c,datei,first_number,str,str_len,&c_read); pset_sn[i]=charint(first_number); sn = charint(first_number); grepSteps(doto,c,datei,first_number,str,str_len,&c_read); st = charint(first_number); pset_st[i]=charint(first_number); pset_leng[i]=(sn-fn)/st+1; i++; current_set_len++; /* Extend Array if needed */ if(current_set_len==set_leng){ set_leng=set_leng *2; expand_set_table( set_leng, current_set_len, &lookup, &pset_leng, &pset_fn, &pset_sn, &pset_st); } while(more_numbone == 77 || doto[0] == 77){ /* fseek(datei, -1L, SEEK_CUR); */ grepFirstNumber(doto,c,datei,first_number,str,str_len,&c_read); more_numbone = grepSecondNumber(c,datei,second_number,str,str_len,&c_read); grepSteps(doto,c,datei,step_number,str,str_len,&c_read); temp = 0; lookup[i]=(char *) malloc(sizeof(char)*name_right); for(temp=0;vname[temp]!='\0';temp++){ lookup[i][temp]=vname[temp]; } lookup[i][temp]='\0'; pset_fn[i]=charint(first_number); pset_sn[i]=charint(second_number); pset_st[i]=charint(step_number); pset_leng[i]=(pset_sn[i]-pset_fn[i])/pset_st[i]+1; i++; current_set_len++; /* Extend Array if needed */ if(current_set_len==set_leng){ set_leng=set_leng *2; expand_set_table( set_leng, current_set_len, &lookup, &pset_leng, &pset_fn, &pset_sn, &pset_st); } } charset_flag = 0; } else charset_flag = 0; /* Looking for 'charpartition' */ if(charpart_flag == 0 && c=='c') charpart_flag++; else if(charpart_flag == 1 && c=='h') charpart_flag++; else if(charpart_flag == 2 && c=='a') charpart_flag++; else if(charpart_flag == 3 && c=='r') charpart_flag++; else if(charpart_flag == 4 && c=='p') charpart_flag++; else if(charpart_flag == 5 && c=='a') charpart_flag++; else if(charpart_flag == 6 && c=='r') charpart_flag++; else if(charpart_flag == 7 && c=='t') charpart_flag++; else if(charpart_flag == 8 && c=='i') charpart_flag++; else if(charpart_flag == 9 && c=='t') charpart_flag++; else if(charpart_flag == 10 && c=='i') charpart_flag++; else if(charpart_flag == 11 && c=='o') charpart_flag++; else if(charpart_flag == 12 && c=='n') charpart_flag++; else if(charpart_flag == 13 && c==' '){ if(all!=1)current_pos =0; temp = 0; /* fseek(datei, -1L, SEEK_CUR); */ name_right = grepName(c,datei,vname,str,str_len,&c_read); /* check if 'all' is set */ if(all==1){ vname[0] = 'a'; vname[1] = 'l'; vname[2] = 'l'; vname[3] = '\0'; name_right=4; } if( name_right == -1) exit(EXIT_FAILURE); grepModName(c,datei,mod_name, pname,part_var_names_str_len,str,str_len,&c_read); grepVName(c,datei,mod_v_name,more_mv_names,str,str_len,&c_read); while (more_mv_names[0] != 0){ ppart_name[j]=(char*) malloc(sizeof(char)*name_right); for(temp=0;vname[temp]!='\0';temp++)ppart_name[j][temp] = vname[temp]; ppart_name[j][temp]='\0'; ppart_model_name[j]=(char*) malloc(sizeof(char)*part_var_names_str_len[0]); for(temp=0;mod_name[temp]!='\0';temp++)ppart_model_name[j][temp] = mod_name[temp]; ppart_model_name[j][temp]='\0'; ppart_parameter_name[j]=(char*) malloc(sizeof(char)*part_var_names_str_len[1]); for(temp=0;pname[temp]!='\0';temp++) ppart_parameter_name[j][temp]= pname[temp]; ppart_parameter_name[j][temp]='\0'; if( more_mv_names[0] == -1 ) exit(EXIT_FAILURE); else if( more_mv_names[0] == 66){ ppart_var_name[j]=(char*) malloc(sizeof(char)*more_mv_names[1]); for(temp=0;mod_v_name[temp]!='\0';temp++) ppart_var_name[j][temp]=mod_v_name[temp]; ppart_var_name[j][temp]='\0'; /* fprintf(stderr,"COMPARE:\n......%s\n......%s\n",mod_v_name,lookup[0]); */ ind = find_set(mod_v_name,lookup,current_set_len); temp_summe =0; for(temp=1;temp<ind[0]+1;temp++)temp_summe+= pset_leng[ind[temp]]; free(ind); ppart_fn[j]=current_pos+1; current_pos += temp_summe; ppart_sn[j]=current_pos; partition_counter++; j++; /* Extend Array if needed */ if(j==part_leng){ part_leng = part_leng*2; expand_part_table(&ppart_name,&ppart_var_name,&ppart_model_name,&ppart_parameter_name,partition_counter,part_leng,&ppart_fn,&ppart_sn); } grepVName(more_mv_names[2],datei,mod_v_name,more_mv_names,str,str_len,&c_read); } else if( more_mv_names[0] == 77) { ppart_var_name[j]=(char*) malloc(sizeof(char)*more_mv_names[1]); for(temp=0;mod_v_name[temp]!='\0';temp++) ppart_var_name[j][temp]=mod_v_name[temp]; ppart_var_name[j][temp]='\0'; /* fprintf(stderr,"COMPARE:\n......%s\n......%s\n",mod_v_name,lookup[0]); */ ind = find_set(mod_v_name,lookup,current_set_len); temp_summe =0; for(temp=1;temp<ind[0]+1;temp++)temp_summe+= pset_leng[ind[temp]]; free(ind); ppart_fn[j]=current_pos+1; current_pos += temp_summe; ppart_sn[j]=current_pos; j++; partition_counter++; /* Extend Array if needed */ if(j==part_leng){ part_leng = part_leng *2; /* fprintf(stderr,"(%s:%d)\n",__FILE__,__LINE__); */ expand_part_table(&ppart_name,&ppart_var_name,&ppart_model_name,&ppart_parameter_name,partition_counter,part_leng,&ppart_fn,&ppart_sn); } grepModName(c,datei,mod_name, pname,part_var_names_str_len,str,str_len,&c_read); grepVName(c,datei,mod_v_name,more_mv_names,str,str_len,&c_read); } } /* Get new Memory and save char[] */ ppart_var_name[j]=(char*) malloc(sizeof(char)*more_mv_names[1]); for(temp=0;mod_v_name[temp]!='\0';temp++) ppart_var_name[j][temp]=mod_v_name[temp]; ppart_var_name[j][temp]='\0'; ppart_name[j]=(char*) malloc(sizeof(char)*name_right); for(temp=0;vname[temp]!='\0';temp++)ppart_name[j][temp] = vname[temp]; ppart_name[j][temp]='\0'; ppart_model_name[j]=(char*) malloc(sizeof(char)*part_var_names_str_len[0]); for(temp=0;mod_name[temp]!='\0';temp++)ppart_model_name[j][temp] = mod_name[temp]; ppart_model_name[j][temp]='\0'; ppart_parameter_name[j]=(char*) malloc(sizeof(char)*part_var_names_str_len[1]); for(temp=0;pname[temp]!='\0';temp++) ppart_parameter_name[j][temp]= pname[temp]; ppart_parameter_name[j][temp]='\0'; /* fprintf(stderr,"COMPARE:\n......%s\n......%s\n",mod_v_name,lookup[0]); */ ind = find_set(mod_v_name,lookup,current_set_len); temp_summe =0; for(temp=1;temp<ind[0]+1;temp++)temp_summe+= pset_leng[ind[temp]]; free(ind); ppart_fn[j]=current_pos+1; current_pos += temp_summe; ppart_sn[j]= current_pos; j++; partition_counter++; /* Extend Array if needed */ if(j==part_leng){ part_leng = part_leng *2; /* fprintf(stderr,"(%s:%d)\n",__FILE__,__LINE__); */ expand_part_table(&ppart_name,&ppart_var_name,&ppart_model_name,&ppart_parameter_name,partition_counter,part_leng,&ppart_fn,&ppart_sn); } charpart_flag = 0; } else charpart_flag = 0; } if(end_counter != 4) { printf("No 'end;' for 'begin sets;' was found.\n"); exit(EXIT_FAILURE); } ret.start = ppart_fn; ret.end = ppart_sn; ret.model_names=ppart_model_name; if(paras) ret.parameter_names=ppart_parameter_name; else{ ret.parameter_names=NULL; for(i=0;i<partition_counter;i++) free(ppart_parameter_name[i]); free(ppart_parameter_name); /* fprintf(stderr,"ERROR %s:%d\n",__FILE__,__LINE__); */ } ret.partition_names=ppart_name; ret.gene_names=ppart_var_name; ret.part_len=partition_counter; ret.max_part_len=part_leng; for(i=0;i<current_set_len;i++){ printf("%s ",lookup[i]); printf("%lu...%lu...%lu...%lu",pset_fn[i],pset_sn[i],pset_st[i],pset_leng[i]); printf("\n"); } for(i=0;i<current_set_len;i++) free(lookup[i]); free(lookup); free(pset_fn); free(pset_sn); free(pset_st); free(pset_leng); return ret; } /* parse_partition */
void grepVName(int c,FILE* datei, char* vname, int* ret,char* str,int str_len,int* c_read){ int empt = 1; ret[0]=0; ret[1]=0; ret[2]=0; while(isspace(c)) c = mygetc(str,str_len,datei,c_read); while(1){ if(c == ';') { if(empt){ printf("No text after ':' has been found"); ret[0]=-1; exit(EXIT_FAILURE); } else { *vname = '\0'; ret[1]++; return; } } if(isspace(c)) { while(isspace(c)) c = mygetc(str,str_len,datei,c_read); if(c == ';'){ if(empt){ printf("No text after ':' has been found"); ret[0]=-1; exit(EXIT_FAILURE); } else{ *vname = '\0'; ret[1]++; return; } } else if(c == ','){ if(empt){ printf("No text after ':' has been found"); ret[0]=-1; exit(EXIT_FAILURE); } c = mygetc(str,str_len,datei,c_read); *vname = '\0'; ret[1]++; ret[0]=77; return; } else{ *vname= '\0'; ret[1]++; ret[0]=66; ret[2]=c; return; } } if(c == ','){ if(empt){ printf("No text after ':' has been found"); ret[0]=-1; exit(EXIT_FAILURE); } c = mygetc(str,str_len,datei,c_read); *vname = '\0'; ret[1]++; ret[0]=77; return; } else{ *vname=c; ret[1]++; vname++; empt = 0; c = mygetc(str,str_len,datei,c_read); } } return; }
static BOOL Section( myFILE *InFile, BOOL (*sfunc)(char *) ) /* ------------------------------------------------------------------------ ** * Scan a section name, and pass the name to function sfunc(). * * Input: InFile - Input source. * sfunc - Pointer to the function to be called if the section * name is successfully read. * * Output: True if the section name was read and True was returned from * <sfunc>. False if <sfunc> failed or if a lexical error was * encountered. * * ------------------------------------------------------------------------ ** */ { int c; int i; int end; char *func = "params.c:Section() -"; i = 0; /* <i> is the offset of the next free byte in bufr[] and */ end = 0; /* <end> is the current "end of string" offset. In most */ /* cases these will be the same, but if the last */ /* character written to bufr[] is a space, then <end> */ /* will be one less than <i>. */ c = EatWhitespace( InFile ); /* We've already got the '['. Scan */ /* past initial white space. */ while( (EOF != c) && (c > 0) ) { /* Check that the buffer is big enough for the next character. */ if( i > (bSize - 2) ) { bSize += BUFR_INC; bufr = Realloc( bufr, bSize ); if( NULL == bufr ) { DEBUG(0, ("%s Memory re-allocation failure.", func) ); return( False ); } } /* Handle a single character. */ switch( c ) { case ']': /* Found the closing bracket. */ bufr[end] = '\0'; if( 0 == end ) /* Don't allow an empty name. */ { DEBUG(0, ("%s Empty section name in configuration file.\n", func )); return( False ); } if( !sfunc( bufr ) ) /* Got a valid name. Deal with it. */ return( False ); (void)EatComment( InFile ); /* Finish off the line. */ return( True ); case '\n': /* Got newline before closing ']'. */ i = Continuation( bufr, i ); /* Check for line continuation. */ if( i < 0 ) { bufr[end] = '\0'; DEBUG(0, ("%s Badly formed line in configuration file: %s\n", func, bufr )); return( False ); } end = ( (i > 0) && (' ' == bufr[i - 1]) ) ? (i - 1) : (i); c = mygetc( InFile ); /* Continue with next line. */ break; default: /* All else are a valid name chars. */ if( isspace( c ) ) /* One space per whitespace region. */ { bufr[end] = ' '; i = end + 1; c = EatWhitespace( InFile ); } else /* All others copy verbatim. */ { bufr[i++] = c; end = i; c = mygetc( InFile ); } } } /* We arrive here if we've met the EOF before the closing bracket. */ DEBUG(0, ("%s Unexpected EOF in the configuration file: %s\n", func, bufr )); return( False ); } /* Section */
static int yylex1(void) { register char *yyp; register int c; register int c1, c2; for (;;) { if (lex_fatal) { return -1; } switch(c = mygetc()) { case EOF: if (inctop) { struct incstate *p; p = inctop; (void)fclose(yyin); /*(void)fprintf(stderr, "popping to %s\n", p->file);*/ free(current_file); nexpands = 0; current_file = p->file; current_line = p->line + 1; current_incfile = p->incfnum; pragma_strict_types = p->pragma_strict_types; yyin = p->yyin; slast = p->slast; lastchar = p->lastchar; inctop = p->next; if (p->nbuf) { nbuf = p->nbuf; outp = defbuf + DEFMAX - nbuf; memcpy(outp, p->outp, nbuf); free((char *)p->outp); } else { nbuf = 0; outp = defbuf + DEFMAX; } store_line_number_info(current_incfile, current_line); incdepth--; free((char *)p); break; } if (iftop) { struct ifstate *p = iftop; lexerror(p->state == EXPECT_ENDIF ? "Missing #endif" : "Missing #else"); while (iftop) { p = iftop; iftop = p->next; free((char *)p); } } return -1; case '\n': { nexpands=0; store_line_number_info(current_incfile, current_line); current_line++; total_lines++; } /* FALLTHROUGH */ case ' ': case '\t': case '\f': case '\v': break; case '+': TRY('+', F_INC); TRY('=', F_ADD_EQ); return c; case '-': TRY('>', F_ARROW); TRY('-', F_DEC); TRY('=', F_SUB_EQ); return c; case '&': TRY('&', F_LAND); TRY('=', F_AND_EQ); return c; case '|': TRY('|', F_LOR); TRY('=', F_OR_EQ); return c; case '^': TRY('=', F_XOR_EQ); return c; case '<': if (gobble('<')) { TRY('=', F_LSH_EQ); return F_LSH; } TRY('=', F_LE); return c; case '>': if (gobble('>')) { TRY('=', F_RSH_EQ); return F_RSH; } TRY('=', F_GE); return c; case '*': TRY('=', F_MULT_EQ); return c; case '%': TRY('=', F_MOD_EQ); return F_MOD; case '/': if (gobble('*')) { skip_comment(); break; } else if (gobble('/')) { skip_comment2(); break; } TRY('=', F_DIV_EQ); return c; case '=': TRY('=', F_EQ); return c; case ';': case '(': case ')': case ',': case '{': case '}': case '~': case '[': case ']': case '?': case '@': return c; case '!': TRY('=', F_NE); return F_NOT; case ':': TRY(':', F_COLON_COLON); return ':'; case '.': if (gobble('.')) { if (gobble('.')) return F_VARARG; else return F_RANGE; } return c; case '#': if (lastchar == '\n') { char *ssp = 0; int quote; yyp = yytext; do { c = mygetc(); } while (isspace(c)); for (quote = 0;;) { if (c == '"') quote ^= 1; /*gc - handle comments cpp-like! 1.6.91 @@@*/ while (!quote && c == '/') { if (gobble('*')) { skip_comment(); c = mygetc(); } else break; } if (!ssp && isspace(c)) ssp = yyp; if (c == '\n' || c == EOF) break; SAVEC; c = mygetc(); } if (ssp) { *ssp++ = 0; while (isspace(*ssp)) ssp++; } else { ssp = yyp; } *yyp = 0; if (strcmp("define", yytext) == 0) { handle_define(ssp); } else if (strcmp("if", yytext) == 0) { #if 0 short int nega=0; /*@@@ allow #if !VAR gc 1.6.91*/ if (*ssp=='!'){ ssp++; nega=1;} if (isdigit(*ssp)) { char *p; long l; l = strtol(ssp, &p, 10); while (isspace(*p)) p++; if (*p) lexerror("Condition too complex in #if"); else handle_cond(nega ? !(int)l : (int)l); } else if (isalunum(*ssp)) { char *p = ssp; while (isalunum(*p)) p++; if (*p) { *p++ = 0; while (isspace(*p)) p++; } if (*p) lexerror("Condition too complex in #if"); else { struct defn *d; d = lookup_define(ssp); if (d) { handle_cond(nega ? !atoi(d->exps) : atoi(d->exps));/* a hack! */ } else { handle_cond(nega?1:0); /* cpp-like gc*/ } } } else lexerror("Condition too complex in #if"); #else int cond; myungetc(0); add_input(ssp); cond = cond_get_exp(0); if (mygetc()) { lexerror("Condition too complex in #if"); while (mygetc()) ; } else handle_cond(cond); #endif } else if (strcmp("ifdef", yytext) == 0) { deltrail(ssp); handle_cond(lookup_define(ssp) != 0); } else if (strcmp("ifndef", yytext) == 0) { deltrail(ssp); handle_cond(lookup_define(ssp) == 0); } else if (strcmp("else", yytext) == 0) { if (iftop && iftop->state == EXPECT_ELSE) { struct ifstate *p = iftop; /*(void)fprintf(stderr, "found else\n");*/ iftop = p->next; free((char *)p); (void)skip_to("endif", (char *)0); store_line_number_info(current_incfile, current_line); current_line++; total_lines++; } else { lexerror("Unexpected #else"); } } else if (strcmp("endif", yytext) == 0) { if (iftop && (iftop->state == EXPECT_ENDIF || iftop->state == EXPECT_ELSE)) { struct ifstate *p = iftop; /*(void)fprintf(stderr, "found endif\n");*/ iftop = p->next; free((char *)p); } else { lexerror("Unexpected #endif"); } } else if (strcmp("undef", yytext) == 0) { struct defn *d; deltrail(ssp); if ((d = lookup_define(ssp)) != NULL ) d->undef++; } else if (strcmp("echo", yytext) == 0) { (void)fprintf(stderr, "%s\n", ssp); } else if (strcmp("include", yytext) == 0) { /*(void)fprintf(stderr, "including %s\n", ssp); */ handle_include(ssp, 0); } else if (strcmp("pragma", yytext) == 0) { deltrail(ssp); handle_pragma(ssp); } else if (strcmp("error", yytext) == 0) { handle_exception(ERROR, ssp); } else if (strcmp("warning", yytext) == 0) { handle_exception(WARNING, ssp); } else { lexerror("Unrecognised # directive"); } myungetc('\n'); break; } else goto badlex; case '\'': yylval.number = mygetc(); if (yylval.number == '\\') { int tmp = mygetc(); switch (tmp) { case 'n': yylval.number = '\n'; break; case 't': yylval.number = '\t'; break; case 'b': yylval.number = '\b'; break; case 'a': yylval.number = '\a'; break; case 'v': yylval.number = '\v'; break; case '\'': case '\\': case '"': yylval.number = tmp; break; default: lexwarning("Bad character escape sequence"); yylval.number = tmp; break; } } if (!gobble('\'')) lexerror("Illegal character constant"); return F_NUMBER; case '"': yyp = yytext; *yyp++ = c; for (;;) { c = mygetc(); if (c == EOF) { lexerror("End of file in string"); return string("\"\""); } else if (c == '\n') { lexerror("Newline in string"); return string("\"\""); } SAVEC; if (c == '"') break; if (c == '\\') { c = mygetc(); if ( c == '\n' ) { yyp--; store_line_number_info(current_incfile, current_line); current_line++; total_lines++; } else if ( c == EOF ) { /* some operating systems give EOF only once */ myungetc(c); } else *yyp++ = c; } } *yyp = 0; return string(yytext); case '0': c = mygetc(); if ( c == 'X' || c == 'x' || c == 'o') { char *endptr; long long value; int base = 16; if (c == 'o') base = 8; yyp = yytext; for (;;) { c = mygetc(); if (!isxdigit(c)) break; SAVEC; } myungetc(c); *yyp = '\0'; value = strtoll(yytext, &endptr, base); if (*endptr != '\0') { fprintf(stderr, "%s\n", yytext); lexwarning("Invalid digits in octal number number"); } return number(value); } myungetc(c); c = '0'; /* FALLTHROUGH */ case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': yyp = yytext; *yyp++ = c; for (;;) { c = mygetc(); if (!isdigit(c)) break; SAVEC; } if (c == '.') { if (isdigit(c1 = mygetc())) { SAVEC; c = c1; SAVEC; for (c = mygetc(); isdigit(c); c = mygetc()) SAVEC; if (c == 'e' || c == 'E') { c1 = mygetc(); if (c1 == '-' || c1 == '+') { c2 = mygetc(); if (isdigit(c2)) { SAVEC; c = c1; SAVEC; c = c2; SAVEC; for (c = mygetc(); isdigit(c); c = mygetc()) SAVEC; } else { myungetc(c2); myungetc(c1); } } else if (isdigit(c1)) { SAVEC; c = c1; SAVEC; for (c = mygetc(); isdigit(c); c = mygetc()) SAVEC; } else myungetc(c1); } myungetc(c); *yyp = 0; return real(strtod(yytext, NULL)); } myungetc(c1); } myungetc(c); *yyp = 0; if (*yytext == '0') { /* OCTALS */ char *endptr; long long value; value = strtoll(yytext, &endptr, 010); if (*endptr != '\0') lexwarning("Invalid digits in octal number"); if (value != 0) lexwarning("Obsolete octal format used. Use 0o111 syntax"); return number(value); } return number(atoll(yytext)); default: if (isalpha(c) || c == '_') { int r; yyp = yytext; *yyp++ = c; for (;;) { c = mygetc(); if (!isalunum(c)) break; SAVEC; } *yyp = 0; myungetc(c); if (!expand_define()) { r = lookup_resword(yytext); if (r >= 0) { return r; } else return ident(yytext); } break; } goto badlex; } } badlex: { lexerror("Illegal character (hex %02x) '%c'", c, c); return ' '; } }
static int skip_to(char *token, char *atoken) { char b[20], *p; int c; int nest; for (nest = 0;;) { c = mygetc(); if (c == '#') { do { c = mygetc(); } while (isspace(c)); for (p = b; c != '\n' && c != EOF; ) { if (p < b+sizeof b-1) *p++ = c; c = mygetc(); } *p++ = 0; for (p = b; *p && !isspace(*p); p++) ; *p = 0; /*(void)fprintf(stderr, "skip checks %s\n", b);*/ if (strcmp(b, "if") == 0 || strcmp(b, "ifdef") == 0 || strcmp(b, "ifndef") == 0) { nest++; } else if (nest > 0) { if (strcmp(b, "endif") == 0) nest--; } else { if (strcmp(b, token) == 0) return 1; else if (atoken && strcmp(b, atoken) == 0) return 0; } } else { /*(void)fprintf(stderr, "skipping (%d) %c", c, c);*/ while (c != '\n' && c != EOF) { c = mygetc(); /*(void)fprintf(stderr, "%c", c);*/ } if (c == EOF) { lexerror("Unexpected end of file while skipping"); return 1; } } store_line_number_info(current_incfile, current_line); current_line++; total_lines++; } }
static int cond_get_exp(int priority) { int c; int value, value2, x; do c = exgetc(); while (isspace(c)); if (c == '(') { value = cond_get_exp(0); do c = exgetc(); while (isspace(c)); if (c != ')') { lexerror("bracket not paired in #if"); if (!c) myungetc('\0'); } } else if (ispunct(c)) { x = (_optab-' ')[c]; if (!x) { lexerror("illegal character in #if"); return 0; } value = cond_get_exp(12); switch ( optab2[x-1] ) { case BNOT : value = ~value; break; case LNOT : value = !value; break; case UMINUS: value = -value; break; case UPLUS : value = value; break; default : lexerror("illegal unary operator in #if"); return 0; } } else { int base; if (!isdigit(c)) { if (!c) { lexerror("missing expression in #if"); myungetc('\0'); } else lexerror("illegal character in #if"); return 0; } value = 0; if (c!='0') base = 10; else { c = mygetc(); if ( c == 'x' || c == 'X' ) { base = 16; c = mygetc(); } else base=8; } for (;;) { if ( isdigit(c) ) x = -'0'; else if (isupper(c)) x = -'A' + 10; else if (islower(c)) x = -'a' + 10; else break; x += c; if (x > base) break; value = value*base + x; c = mygetc(); } myungetc(c); } for (;;) { do c = exgetc(); while (isspace(c)); if (!ispunct(c)) break; x = (_optab-' ')[c]; if (!x) break; value2 = mygetc(); for (;;x += 3) { if (!optab2[x]) { myungetc(value2); if (!optab2[x + 1]) { lexerror("illegal operator use in #if"); return 0; } break; } if (value2 == optab2[x]) break; } if (priority >= optab2[x + 2]) { if (optab2[x]) myungetc(value2); break; } value2 = cond_get_exp(optab2[x + 2]); switch ( optab2[x + 1] ) { case MULT : value *= value2; break; case DIV : value /= value2; break; case MOD : value %= value2; break; case BPLUS : value += value2; break; case BMINUS : value -= value2; break; case LSHIFT : value <<= value2; break; case RSHIFT : value = (unsigned)value >> value2; break; case LESS : value = value < value2; break; case LEQ : value = value <= value2; break; case GREAT : value = value > value2; break; case GEQ : value = value >= value2; break; case EQ : value = value == value2; break; case NEQ : value = value != value2; break; case BAND : value &= value2; break; case XOR : value ^= value2; break; case BOR : value |= value2; break; case LAND : value = value && value2; break; case LOR : value = value || value2; break; case QMARK : do c = exgetc(); while (isspace(c)); if (c != ':') { lexerror("'?' without ':' in #if"); myungetc(c); return 0; } if (value) { (void)cond_get_exp(1); value = value2; } else value = cond_get_exp(1); break; } } myungetc(c); return value; }
/* Stuff to evaluate expression. I havn't really checked it. /LA ** Written by "J\"orn Rennecke" <*****@*****.**> */ static int exgetc(void) { register char c, *yyp; c = mygetc(); while (isalpha(c) || c == '_') { yyp = yytext; do { SAVEC; c = mygetc(); } while (isalunum(c)); myungetc(c); *yyp = '\0'; if (strcmp(yytext, "defined") == 0) { /* handle the defined "function" in #if */ do c = mygetc(); while (isspace(c)); if (c != '(') { lexerror("Missing ( in defined"); continue; } do c = mygetc(); while (isspace(c)); yyp = yytext; while (isalunum(c)) { SAVEC; c = mygetc(); } *yyp = '\0'; while (isspace(c)) c = mygetc(); if (c != ')') { lexerror("Missing ) in defined"); continue; } /* Skip whitespace */ do c = mygetc(); while (isspace(c)); myungetc(c); if (lookup_define(yytext)) add_input(" 1 "); else add_input(" 0 "); } else { if (!expand_define()) add_input(" 0 "); } c = mygetc(); } return c; }
void AvLex () { Etat ee = E_INIT ; /* etat courant */ int a_consommer ; /* faut-il consommer le caractere ? */ int value ; /* valeur entiere si lexeme INTEGER */ while ((cc != EOF) && (ee != E_ERREUR) && (ee != E_TERM)) { a_consommer = 1 ; /* a priori, il faut consommer */ switch (ee) { case E_INIT : { if (cc == '@') ee = E_COMM; else if ((cc == ' ') || (cc == '\t')) { ; } else if (isdigit(cc) && (cc != '0')) { ee = E_INTEGER ; leLex.nat = INTEGER ; value = char2int (cc) ; *ptaschar = cc ; leLex.chaine = ptaschar ; leLex.nol = nol ; leLex.noc = noc ; ptaschar++; } else if (cc == '0') { ee = E_VERIF_NOTA_HEXA ; leLex.nat = INTEGER ; value = 0 ; leLex.chaine = ptaschar ; leLex.nol = nol ; leLex.noc = noc ; } else if (isalpha(cc) || (cc == '_') || (cc=='.') ) { ee = E_IDF_KEYW ; *ptaschar = cc ; /* leLex.nat encore inconnu mais on met ETIQUETTE a priori */ leLex.nat = ETIQUETTE ; leLex.chaine = ptaschar ; ptaschar++; leLex.nol = nol ; leLex.noc = noc ; } else if (cc =='"') { ee = E_CHAINE ; *ptaschar = cc ; leLex.chaine = ptaschar ; ptaschar++; leLex.nat = CHAINE ; leLex.nol = nol ; leLex.noc = noc ; } else if ((cc == ',') || (cc == '!') || (cc == '{') || (cc == '}') || (cc == '[') || (cc == ']') || (cc == '#') || (cc == '^') || (cc == '-') || (cc == '(') || (cc == ')') || (cc == '+') || (cc == '=') || (cc == ':') || (cc == '\n')) { ee = E_TERM ; *ptaschar = cc ; leLex.chaine = ptaschar ; ptaschar++; leLex.nat = char2nat (cc) ; leLex.nol = nol ; leLex.noc = noc ; } else { leLex.nat = ERRLEX ; ee = E_ERREUR ; leLex.nol = nol ; leLex.noc = noc ; *ptaschar = cc ; leLex.chaine = ptaschar ; ptaschar++; } } break ; case E_CHAINE : *ptaschar = cc ; ptaschar++; if (cc == '"') ee = E_TERM ; break ; case E_COMM : if (cc == '\n') { ee = E_TERM ; *ptaschar = cc ; leLex.chaine = ptaschar ; ptaschar++; leLex.nat = char2nat (cc) ; leLex.nol = nol ; leLex.noc = noc ; } break ; case E_INTEGER : if (isdigit (cc) ) { value = 10*value + char2int (cc) ; *ptaschar = cc ; ptaschar++ ; } else { a_consommer = 0 ; ee = E_TERM ; leLex.value = value ; } break ; case E_IDF_KEYW : if (isdigit(cc) || isalpha(cc) || (cc == '_') ) { *ptaschar = cc ; ptaschar++ ; } else { a_consommer = 0 ; ee = E_TERM ; } break ; case E_VERIF_NOTA_HEXA : if (cc == 'x') { ee = E_INTEGER_HEXA ; } else if (isdigit (cc)) { ee = E_INTEGER ; a_consommer = 0 ; } else { ee = E_TERM ; a_consommer = 0 ; leLex.value = value ; /* 0, normalement */ } break ; case E_INTEGER_HEXA : if (isdigit (cc) || (cc == 'A') || (cc == 'B') || (cc == 'C') || (cc == 'D') || (cc == 'E') || (cc == 'F') || (cc == 'a') || (cc == 'b') || (cc == 'c') || (cc == 'd') || (cc == 'e') || (cc == 'f')) { value = 16*value + char2int (cc) ; *ptaschar = cc ; ptaschar++ ; } else { a_consommer = 0 ; ee = E_TERM ; leLex.value = value ; } break ; default : printf ("Oups! Internal error in AvLex\n"); exit (1) ; } if (a_consommer) cc = mygetc (leFichier) ; } /* terminer la chaine lue */ *ptaschar = '\0' ; ptaschar++ ; /* On a atteint un état terminal, ou l'état d'erreur, ou alors la fin de fichier. Une analyse par cas est nécessaire. */ if (ee == E_ERREUR) { /* rien a faire de plus. */ } else if (ee == E_TERM) { /* on a termine un lexeme proprement. il se peut qu'on vienne de reconnaitre un mot, il faut determiner de quelle espece de lexeme il s'agit. */ if (leLex.nat == ETIQUETTE) { /* finir le travail */ ChercherMotCle(&leLex) ; } /* sinon le lexeme est entierement construit. */ } else /* cad (cc == EOF) && (ee != E_ERREUR) & (ee != E_TERM) */ { /* on n'a pas le droit de finir le fichier dans n'importe quel etat : */ if ((ee == E_COMM) || (ee == E_CHAINE)) { leLex.nat = ERRLEX ; } else { /* ici ee=E_INIT ou E_INTEGER ou E_IDF_KEYW si E_INIT, on avait des espaces avant la fin de fichier. si E_INTEGER, on a trouve EOF juste derriere un nb, finir le travail si E_IDF_KEYW, on a trouve EOF juste derriere un mot, finir le travail */ if (ee == E_INIT) leLex.nat = ENDLEX ; if (ee == E_INTEGER) leLex.value = value ; if (ee == E_IDF_KEYW) { ChercherMotCle(&leLex) ; } } } }
/* Check if yytext is a macro and expand if it is. */ static int expand_define(void) { struct defn *p; char expbuf[DEFMAX]; char *args[NARGS]; char buf[DEFMAX]; char *q, *e, *b; if (nexpands++ > EXPANDMAX) { lexerror("Too many macro expansions"); return 0; } p = lookup_define(yytext); if (!p) { return 0; } if (p->nargs == -1) { add_input(p->exps); } else { int c, parcnt = 0, dquote = 0, squote = 0; int n; SKIPW; if (c != '(') { lexerror("Missing '(' in macro call"); return 0; } SKIPW; if (c == ')') n = 0; else { q = expbuf; args[0] = q; for (n = 0; n < NARGS; ) { switch(c) { case '"': if (!squote) dquote ^= 1; break; case '\'': if (!dquote) squote ^= 1; break; case '(': if (!squote && !dquote) parcnt++; break; case ')': if (!squote && !dquote) parcnt--; break; case '\\': if (squote || dquote) { *q++ = c; c = mygetc();} break; case '\n': if (squote || dquote) { lexerror("Newline in string"); return 0; } break; } if (c == ',' && !parcnt && !dquote && !squote) { *q++ = 0; args[++n] = q; } else if (parcnt < 0) { *q++ = 0; n++; break; } else { if (c == EOF) { lexerror("Unexpected end of file"); return 0; } if (q >= expbuf + DEFMAX - 5) { lexerror("Macro argument overflow"); return 0; } else { *q++ = c; } } if (!squote && ! dquote) c = cmygetc(); else c = mygetc(); } if (n == NARGS) { lexerror("Maximum macro argument count exceeded"); return 0; } } if (n != p->nargs) { lexerror("Wrong number of macro arguments"); return 0; } /* Do expansion */ b = buf; e = p->exps; while (*e) { if (*e == MARKS) { if (*++e == MARKS) *b++ = *e++; else { for (q = args[*e++ - MARKS - 1]; *q; ) { *b++ = *q++; if (b >= buf+DEFMAX) { lexerror("Macro expansion overflow"); return 0; } } } } else { *b++ = *e++; if (b >= buf+DEFMAX) { lexerror("Macro expansion overflow"); return 0; } } } *b++ = 0; add_input(buf); } return 1; }
/* Greps the Stepnumber and tells if there are more start/end point */ void grepSteps(int* ret,int c,FILE* datei, char* vname,char* str,int str_len,int* c_read){ int nothing; int onlyone; int spaces; c = str[*c_read]; nothing = 1; onlyone = 0; ret[1]=0; spaces = 0; while(isspace(c)) c = mygetc(str,str_len,datei,c_read); if(c == '\\') c = mygetc(str,str_len,datei,c_read); else if(c == ';'){ if(nothing==1){ *vname='1'; vname++; } *vname = '\0'; ret[0]=0; return; } else if (isdigit(c)){ *vname='1'; vname++; *vname='\0'; ret[0]=77; ret[1]=c; return; } else{ ret[0]=1; return; } while(1){ if(c == ';') { if(nothing==1){ *vname='1'; vname++; } *vname = '\0'; ret[0]=0; return; } else if (isspace(c)){ if(onlyone){ spaces =1; c = mygetc(str,str_len,datei,c_read); } else c= mygetc(str,str_len,datei,c_read); } else{ if (isdigit(c)){ if(spaces){ *vname= '\0'; ret[0]=77; ret[1]=c; return; } else{ *vname=c; vname++; nothing = 0; onlyone = 1; c = mygetc(str,str_len,datei,c_read); } } else{ ret[0]=1; return; } } } ret[0]=1; return; }
/* return(VCOUNTER,PCOUNTER) */ void grepModName(int c,FILE* datei, char* vname, char* pname,int* ret,char* str,int str_len,int* c_read){ int empt = 1; ret[0]=0; ret[1]=0; c = mygetc(str,str_len,datei,c_read); while(isspace(c)) c = mygetc(str,str_len,datei,c_read); while(1){ if(isspace(c)) c = mygetc(str,str_len,datei,c_read); if(c == ';'){ printf("The character ';' is not allowed in the name of a variable\n"); exit(EXIT_FAILURE); } if(c == ':'){ if(empt){ printf("No Model has been found\n"); exit(EXIT_FAILURE); } *pname = '{'; pname++; ret[1]++; *pname = '}'; pname++; ret[1]++; *pname = '\0'; ret[1]++; *vname= '\0'; ret[0]++; return; } if(c == '+'){ *pname = '{'; ret[1]++; pname++; *pname = '}'; ret[1]++; pname++; *pname = c; ret[1]++; pname++; *vname = c; ret[0]++; vname++; c = mygetc(str,str_len,datei,c_read); } if(c == '{'){ *pname= c; ret[1]++; pname++; while((c = mygetc(str,str_len,datei,c_read)) != '}'){ if(!(isspace(c))){ *pname = c; ret[1]++; pname++; } } *pname = '}'; ret[1]++; pname++; c = mygetc(str,str_len,datei,c_read); while(isspace(c)) c = mygetc(str,str_len,datei,c_read); if(c == '+'){ *pname = '+'; ret[1]++; pname++; *vname = '+'; ret[0]++; vname++; c = mygetc(str,str_len,datei,c_read); } else { *pname = '\0'; ret[1]++; *vname= '\0'; ret[0]++; return; } } else{ *vname=c, ret[0]++; vname++; empt = 0; c = mygetc(str,str_len,datei,c_read); } } *pname = '\0'; ret[1]++; *vname = '\0'; ret[2]++; return; }
static BOOL Parameter( myFILE *InFile, BOOL (*pfunc)(char *, char *), int c ) /* ------------------------------------------------------------------------ ** * Scan a parameter name and value, and pass these two fields to pfunc(). * * Input: InFile - The input source. * pfunc - A pointer to the function that will be called to * process the parameter, once it has been scanned. * c - The first character of the parameter name, which * would have been read by Parse(). Unlike a comment * line or a section header, there is no lead-in * character that can be discarded. * * Output: True if the parameter name and value were scanned and processed * successfully, else False. * * Notes: This function is in two parts. The first loop scans the * parameter name. Internal whitespace is compressed, and an * equal sign (=) terminates the token. Leading and trailing * whitespace is discarded. The second loop scans the parameter * value. When both have been successfully identified, they are * passed to pfunc() for processing. * * ------------------------------------------------------------------------ ** */ { int i = 0; /* Position within bufr. */ int end = 0; /* bufr[end] is current end-of-string. */ int vstart = 0; /* Starting position of the parameter value. */ char *func = "params.c:Parameter() -"; /* Read the parameter name. */ while( 0 == vstart ) /* Loop until we've found the start of the value. */ { if( i > (bSize - 2) ) /* Ensure there's space for next char. */ { bSize += BUFR_INC; bufr = Realloc( bufr, bSize ); if( NULL == bufr ) { DEBUG(0, ("%s Memory re-allocation failure.", func) ); return( False ); } } switch( c ) { case '=': /* Equal sign marks end of param name. */ if( 0 == end ) /* Don't allow an empty name. */ { DEBUG(0, ("%s Invalid parameter name in config. file.\n", func )); return( False ); } bufr[end++] = '\0'; /* Mark end of string & advance. */ i = end; /* New string starts here. */ vstart = end; /* New string is parameter value. */ bufr[i] = '\0'; /* New string is nul, for now. */ break; case '\n': /* Find continuation char, else error. */ i = Continuation( bufr, i ); if( i < 0 ) { bufr[end] = '\0'; DEBUG(1,("%s Ignoring badly formed line in configuration file: %s\n", func, bufr )); return( True ); } end = ( (i > 0) && (' ' == bufr[i - 1]) ) ? (i - 1) : (i); c = mygetc( InFile ); /* Read past eoln. */ break; case '\0': /* Shouldn't have EOF within param name. */ case EOF: bufr[i] = '\0'; DEBUG(1,("%s Unexpected end-of-file at: %s\n", func, bufr )); return( True ); default: if( isspace( c ) ) /* One ' ' per whitespace region. */ { bufr[end] = ' '; i = end + 1; c = EatWhitespace( InFile ); } else /* All others verbatim. */ { bufr[i++] = c; end = i; c = mygetc( InFile ); } } } /* Now parse the value. */ c = EatWhitespace( InFile ); /* Again, trim leading whitespace. */ while( (EOF !=c) && (c > 0) ) { if( i > (bSize - 2) ) /* Make sure there's enough room. */ { bSize += BUFR_INC; bufr = Realloc( bufr, bSize ); if( NULL == bufr ) { DEBUG(0, ("%s Memory re-allocation failure.", func) ); return( False ); } } switch( c ) { case '\r': /* Explicitly remove '\r' because the older */ c = mygetc( InFile ); /* version called fgets_slash() which also */ break; /* removes them. */ case '\n': /* Marks end of value unless there's a '\'. */ i = Continuation( bufr, i ); if( i < 0 ) c = 0; else { for( end = i; (end >= 0) && isspace(bufr[end]); end-- ) ; c = mygetc( InFile ); } break; default: /* All others verbatim. Note that spaces do */ bufr[i++] = c; /* not advance <end>. This allows trimming */ if( !isspace( c ) ) /* of whitespace at the end of the line. */ end = i; c = mygetc( InFile ); break; } } bufr[end] = '\0'; /* End of value. */ return( pfunc( bufr, &bufr[vstart] ) ); /* Pass name & value to pfunc(). */ } /* Parameter */
int main(int argc, char **argv) { char c, *cp; int j, k, fdtmp; unsigned int len; /* Find the program name */ j = 0; while (argv[0][j] != '\0') j++; len = (unsigned int) j; while (j--) if (argv[0][j] == '/') break; if (argv[0][j] == '/') j++; cp = argv[0] + j; len -= j; /* Sort out the flags */ for (k = 1; k < argc; k++) { if (argv[k][0] == '-') { c = argv[k][1]; switch (c) { case '0': /* pass numbers */ case '1': case '2': case '3': case '4': pnum = c - '0'; break; case 'd': /* used by news */ break; default: (void) write(1, "Usage: ", 7); (void) write(1, cp, len); (void) write(1, " [-#] [in] [out]\n", 17); exit(0); break; } /* Once it's checked, lose it anyway */ for (j = k; j < argc; j++) argv[j] = argv[j + 1]; argc--; k--; } } /* Default i/o settings */ fdin = 0; fdout = 1; fderr = 2; /* Try to open specific files and connect them to stdin/stdout */ if (argc > 1) { if ((fdtmp = open(argv[1], 0)) == -1) die("input open failed"); (void) close(0); if ((fdin = dup(fdtmp)) == -1) die("input dup failed\n"); (void) close(fdtmp); } if (argc > 2) { (void) unlink(argv[2]); if ((fdtmp = creat(argv[2], 0666)) == -1) die("output creat failed"); (void) close(1); if ((fdout = dup(fdtmp)) == -1) die("output dup failed\n"); (void) close(fdtmp); } /* Sort out type of compression */ if (pnum == -1 || pnum == 4) {/* if this is pass 4 */ /* Check header of compressed file */ if (mygetc() != 0x1F || mygetc() != 0x9D) /* check magic number */ die("not a compressed file\n"); iindex = mygetc(); /* get compression style */ } else getpipe(); /* get compression style */ maxbits = iindex & 0x1F; clearflg = ((iindex & 0x80) != 0) ? TRUE : FALSE; if (maxbits < 9 || maxbits > 16) /* check for valid maxbits */ die("can't decompress\n"); if (pnum != -1 && pnum != 0) putpipe(iindex, 0); /* pass style to next copy */ /* Fork off an ancestor if necessary - ffork() increments pnum */ if (pnum == -1) { pnum = 0; if (pnum == 0) ffork(); if (pnum == 1) ffork(); if (pnum == 2) ffork(); if (pnum == 3) ffork(); } /* Preliminary inits. Note: end/maxend/curend are highest, not * highest + 1 */ base = DICTSZ * pnum + 256; locend = base + DICTSZ - 1; maxend = (1 << maxbits) - 1; if (maxend > locend) maxend = locend; while (TRUE) { curend = 255 + (clearflg ? 1 : 0); /* init dictionary */ dcharp = DICTSZ; /* flag for none needed */ curbits = 9; /* init curbits (for copy 0) */ while (TRUE) { /* for each index in input */ if (pnum == 4) {/* get index using getbits() */ if (curbits < maxbits && (1 << curbits) <= curend) { /* Curbits needs to be increased */ /* Due to uglyness in compress, these * indices in the compressed file are * wasted */ while (inmod) getbits(); curbits++; } getbits(); } else getpipe(); /* get next index */ if (iindex == 256 && clearflg) { if (pnum > 0) putpipe(iindex, 0); /* Due to uglyness in compress, these indices * in the compressed file are wasted */ while (inmod) getbits(); break; } tindex = iindex; /* Convert the index part, ignoring spawned chars */ while (tindex >= base) tindex = dindex[tindex - base]; /* Pass on the index */ putpipe(tindex, 0); /* Save the char of the last added entry, if any */ if (dcharp < DICTSZ) dchar[dcharp++] = tindex; if (curend < maxend && ++curend > (base - 1)) dindex[dcharp = (curend - base)] = iindex; /* Do spawned chars. They are naturally produced in * the wrong order. To get them in the right order * without using memory, a series of passes, * progressively less deep, are used */ tbase = base; while ((tindex = iindex) >= tbase) {/* for each char to spawn*/ while ((tindex2 = dindex[tindex - base]) >= tbase) tindex = tindex2; /* scan to desired char */ putpipe(dchar[tindex-base], 1); /* put it to the pipe*/ tbase = tindex + 1; if (tbase == 0) break; /* it's a wrap */ } } } }