Exemple #1
0
void process_text(char *in_buffer) {
    uint8_t last_pos = *ringbuffer_pos;
    char buffer[64] = {0};

    while(1) {
        uint8_t new_pos;
        while(last_pos == (new_pos = *ringbuffer_pos)) {
            uint64_t info = wait_for_interrupt();
            if(INT_ID(info) == CLOCK_ID) {
                toggle_pos(cursor_pos, normal, inverted);
            }
        }
        while(last_pos != new_pos) {
            uint8_t c;
            c = keyboard_ringbuffer[last_pos];
            process_char(c,1);
            last_pos = ((last_pos + 1) % RINGBUFFER_SIZE);
            if(c == '\r') {
                strcpy(in_buffer, input);
                process_char('\r',0);
                input_size = 0;
                memset(input,0,sizeof(input));
                goto done;
            }
        }
    }
done:
    return;
}
Exemple #2
0
int main(int argc,char **argv)
{
  if (argc>2&&argv[2]) start_addr=strtoll(argv[2],NULL,16);
  if (argc>3&&argv[3]) end_addr=strtoll(argv[3],NULL,16);
  printf("Dumping memory from $%x to $%x\n",start_addr,end_addr);

  errno=0;
  fd=open(argv[1],O_RDWR);
  perror("A");
  if (fd==-1) perror("open");
  perror("B");
  fcntl(fd,F_SETFL,fcntl(fd, F_GETFL, NULL)|O_NONBLOCK);
  perror("C");
  struct termios t;
  if (cfsetospeed(&t, B230400)) perror("Failed to set output baud rate");
  perror("D");
  if (cfsetispeed(&t, B230400)) perror("Failed to set input baud rate");
  perror("E");
  t.c_cflag &= ~PARENB;
  t.c_cflag &= ~CSTOPB;
  t.c_cflag &= ~CSIZE;
  t.c_cflag &= ~CRTSCTS;
  t.c_cflag |= CS8 | CLOCAL;
  t.c_lflag &= ~(ICANON | ISIG | IEXTEN | ECHO | ECHOE);
  t.c_iflag &= ~(BRKINT | ICRNL | IGNBRK | IGNCR | INLCR |
                 INPCK | ISTRIP | IXON | IXOFF | IXANY | PARMRK);
  t.c_oflag &= ~OPOST;
  if (tcsetattr(fd, TCSANOW, &t)) perror("Failed to set terminal parameters");
  perror("F");

  unsigned long long last_check = gettime_ms();

  while(1)
    {
      int b;
      char read_buff[1024];
      switch(state) {
      case 0: case 99:
	errno=0;
	b=read(fd,read_buff,1024);
	if (b>0) {
	  int i;
	  for(i=0;i<b;i++) {
	    process_char(read_buff[i],1);
	  }
	} else {
	  usleep(1000);
	}
	if (gettime_ms()>last_check) {
	  if (state==99) printf("sending M command to sync.\n");
	  sprintf(filename,"M%x\r",start_addr);
	  slow_write(fd,filename,strlen(filename));
	  last_check=gettime_ms()+50;
	}
	break;
      }
    }

  return 0;
}
Exemple #3
0
void process_input (SLOT *sp)
{
  unsigned char buf[MAXBUF];
  int i, len;

  if (sp->flags.die)
    return;

  cur_slot = sp;
  len = read (cur_slot->fd, (char *)buf, MAXBUF);
  if (len > 0) {
    for (i = 0; i < len; i++)
      process_char (buf[i]);
  } else {
    transmit (cur_slot);
    if (!sp->flags.die) {
      if (cur_slot->acct.chan < NUMCHANNELS) {
        /* protect against people whose logins time our or
           something before they're fully "on" the system */
        remove_from_channel (cur_slot, cur_slot->acct.chan);
        remove_from_channel (cur_slot, MAINLIST);
      }
      if (cur_slot->acct.chan && cur_slot->flags.on) {
        paabout (cur_slot, DISCONNECTED);
        cur_slot->acct.last_logout = time(NULL);
      }
      inactivate_slot (cur_slot, 0);
    }
  }
}
Exemple #4
0
int main(int argc,char **argv)
{
  search_path=argv[2];
  fd=open(argv[1],O_RDWR);
  if (fd==-1) perror("open");
  if (fcntl(fd,F_SETFL,fcntl(fd, F_GETFL, NULL)|O_NONBLOCK))
    perror("fcntl");
  struct termios t;
  if (cfsetospeed(&t, B230400)) perror("Failed to set output baud rate");
  if (cfsetispeed(&t, B230400)) perror("Failed to set input baud rate");
  t.c_cflag &= ~PARENB;
  t.c_cflag &= ~CSTOPB;
  t.c_cflag &= ~CSIZE;
  t.c_cflag |= CS8;
  t.c_lflag &= ~(ICANON | ISIG | IEXTEN | ECHO | ECHOE);
  t.c_iflag &= ~(BRKINT | ICRNL | IGNBRK | IGNCR | INLCR |
                 INPCK | ISTRIP | IXON | IXOFF | IXANY | PARMRK);
  t.c_oflag &= ~OPOST;
  if (tcsetattr(fd, TCSANOW, &t)) perror("Failed to set terminal parameters");

  // Send ^U r <return> to print registers and get into a known state.
  usleep(20000);
  slow_write(fd,"\r",1);
  usleep(50000);
  slow_write(fd,"r\r",2);

  unsigned long long last_check = gettime_ms();

  while(1)
    {
      int b;
      char read_buff[1024];
	b=read(fd,read_buff,1024);
	if (b>0) {
	  int i;
	  for(i=0;i<b;i++) {
	    process_char(read_buff[i],1);
	  }
	} else usleep(10000);
	if (gettime_ms()>last_check) {
	  if (!toggle) {
	    char cmd[1024];
	    // set debug coordinates
	    debug_x++;
	    debug_x&=0xfff;
	    sprintf(cmd,"sffd30fc %02x %02x %02x %02x\r",
		    debug_x&0xff,debug_x>>8,debug_y&0xff,debug_y>>8);
	    slow_write(fd,cmd,strlen(cmd));
	  } else {
	    // read debug registers
	    slow_write(fd,"mffd30f0\r",9);
	  }
	  toggle^=1;
	  // Allow 2 frames before advancing debug point
	  last_check=gettime_ms()+(1000/60)*2;
	}
Exemple #5
0
void print_number(int n) {
    char buffer[10];
    int size=0,i;
    while(n > 0) {
        buffer[size++] = n%10;
        n/=10;
    }
    for(i=size-1;i>=0;i--) {
        process_char('0' + buffer[i],0);
    }
}
Exemple #6
0
int process_waiting(int fd)
{
  unsigned char  read_buff[1024];
  int b=read(fd,read_buff,1024);
  while (b>0) {
    int i;
    for(i=0;i<b;i++) {
      process_char(read_buff[i],1);
    }
    b=read(fd,read_buff,1024);    
  }
  return 0;
}
Exemple #7
0
void __attribute__((interrupt, no_auto_psv)) _U2RXInterrupt(void)
  {
  /* Read the receive receive_buffer till no more characters can be read */
  while(U2STAbits.URXDA)
    process_char(uart2, U2RXREG);

  if(U2STAbits.OERR)
    U2STAbits.OERR = 0;

  if(U2STAbits.FERR)
    U2STAbits.FERR = 0;

  IFS1bits.U2RXIF = 0;
  }
void printf_formattert::print(std::ostream &out)
{
  format_pos=0;
  next_operand=operands.begin();

  try
  {
    while(!eol()) process_char(out);
  }

  catch(eol_exceptiont)
  {
  }
}
Exemple #9
0
void process_text(char *in_buffer, int remaining) {
    uint8_t last_pos = *ringbuffer_pos;
    char buffer[64] = {0};
    if(remaining > 0) {
        //Dammit there's no standard library so I can't use sprintf :(
        strcpy(buffer,"You have    guesses remaining\r>");
        if(remaining >= 10) {
            buffer[9] = '0' + (remaining/10);
        }
        buffer[10] = '0' + (remaining%10);
        process_string(buffer);
    }
    else {
        process_string("You ran out, I picked a new number\r>");
    }

    while(1) {
        uint8_t new_pos;
        while(last_pos == (new_pos = *ringbuffer_pos)) {
            uint64_t info = wait_for_interrupt();
            if(INT_ID(info) == CLOCK_ID) {
                toggle_pos(cursor_pos, normal, inverted);
            }
        }
        while(last_pos != new_pos) {
            uint8_t c;
            c = keyboard_ringbuffer[last_pos];
            process_char(c,1);
            last_pos = ((last_pos + 1) % RINGBUFFER_SIZE);
            if(c == '\r') {
                memcpy(in_buffer, input, input_size);
                input_size = 0;
                memset(input,0,sizeof(input));
                goto done;
            }
        }
    }
done:
    return;
}
Exemple #10
0
int main(int argc, char * argv[])
{
   char input_buffer[BUFFER_SIZE];
   int i, ifd = 0, ofd = 1;

   for(i = 1; i < argc; i++)
   {
      if (   (!strcmp(argv[i], "-h"))
          || (!strcmp(argv[i], "--help"))
          )
      {
         fprintf(stderr, "Usage:\n\t%s [-h | --help] [-i | --indent] [-f[nn]]\n"
                 "\t\t[if=input] [of=output]\n",
                 argv[0]);
         fprintf(stderr, "\n");
         fprintf(stderr, "\t--help\tPrint this help message.\n");
         fprintf(stderr, "\t--indent\tIndent messages and continued lines.\n");
         fprintf(stderr,
                 "\t-f[nn]\tFold lines that are over nn (default 80) characters.\n"
                 "\t\tImplies --indent.\n"
                 );
         fprintf(stderr, "\tif=\tSpecify input file name.\n");
         fprintf(stderr, "\tof=\tSpecify output file name.\n");
         return 0;
      }
      else if (   (strcmp(argv[i], "-i") == 0)
               || (strcmp(argv[i], "--indent") == 0)
               )
      {
         indent = 1;
      }
      else if (!strncmp(argv[i], "if=", 3))
      {
         ifd = open(&argv[i][3], O_RDONLY);
         if (ifd == -1)
         {
            fprintf(stderr, "%s: %s\n", &argv[i][3], strerror(errno));
            return 1;
         }
      }
      else if (!strncmp(argv[i], "of=", 3))
      {
         ofd = open(&argv[i][3], O_WRONLY | O_CREAT, 0644);
         if (ofd == -1)
         {
            fprintf(stderr, "%s: %s\n", &argv[i][3], strerror(errno));
            return 1;
         }
      }
      else if (!strncmp(argv[i], "-f", 2))
      {
         fold = 1;
         indent = 1;
         if (strlen(argv[i]) > 2)
         {
            char* endptr;
            width = strtol(argv[i] + strlen("-f"), &endptr, 10);
            if (endptr != argv[i] + strlen(argv[i]))
            {
               fprintf(stderr, "Badly formatted width: '%s'\n",
                       argv[i]);
               return 1;
            }
            else if (width < 9)
            {
               fprintf(stderr, "Width value too small: %d\n", width);
               return 1;
            }
         }
      }
      else
      {
         fprintf(stderr, "Unknown option: %s\n", argv[i]);
         return 1;
      }
   }

   position = 0;
   line_tabbed = 0;
   i = read(ifd, input_buffer, BUFFER_SIZE);
   state = indent ? StartLine : InMessage;
   
   while(i && i != -1)
   {
      int j;
      for(j = 0; j != i; j++)
         process_char(input_buffer[j], ofd);
      i = read(ifd, input_buffer, BUFFER_SIZE);
   }

   flush_buffer(ofd);

   return 0;
}
Exemple #11
0
date_time_t to_date_time(const pstring& str)
{
    date_time_t ret;
    int dash_count = 0, t_count = 0, colon_count = 0;

    const char* p = str.get();
    const char* p_end = p + str.size();
    const char* digit = p;
    size_t digit_len = 0;

    bool valid = true;
    for (; p != p_end && valid; ++p)
    {
        switch (*p)
        {
            case '-':
            {
                if (t_count || colon_count || !digit)
                {
                    // Invalid date-time value.  All dashes must occur before
                    // any of 'T' and ':' occur.
                    valid = false;
                    break;
                }

                switch (dash_count)
                {
                    case 0:
                        // Flush year.
                        flush_int(ret.year, digit, digit_len);
                    break;
                    case 1:
                        // Flush month.
                        flush_int(ret.month, digit, digit_len);
                    break;
                    default:
                        valid = false;
                }
                ++dash_count;
            }
            break;
            case 'T':
            {
                if (t_count || dash_count != 2 || !digit)
                {
                    // Invalid date-time value.
                    valid = false;
                    break;
                }

                // Flush day.
                ret.day = strtol(digit, NULL, 10);
                digit = NULL;
                digit_len = 0;

                ++t_count;
            }
            break;
            case ':':
            {
                if (!t_count || !digit)
                {
                    // Invalid date-time value.
                    valid = false;
                    break;
                }

                switch (colon_count)
                {
                    case 0:
                        // Flush hour.
                        flush_int(ret.hour, digit, digit_len);
                    break;
                    case 1:
                        // Flush minute.
                        flush_int(ret.minute, digit, digit_len);
                    break;
                    default:
                        valid = false;
                }

                ++colon_count;
            }
            break;
            default:
            {
                if (t_count)
                {
                    // Time element.
                    switch (colon_count)
                    {
                        case 0:
                            // Hour
                            process_char(p, digit, digit_len);
                        break;
                        case 1:
                            // Minute
                            process_char(p, digit, digit_len);
                        break;
                        case 2:
                            // Second
                            process_char(p, digit, digit_len);
                        break;
                        default:
                            valid = false;
                    }
                }
                else
                {
                    // Date element.
                    switch (dash_count)
                    {
                        case 0:
                            // Year
                            process_char(p, digit, digit_len);
                        break;
                        case 1:
                            // Month
                            process_char(p, digit, digit_len);
                        break;
                        case 2:
                            // Day
                            process_char(p, digit, digit_len);
                        break;
                        default:
                            valid = false;
                    }
                }
            }
        }

    }

    if (!valid || !digit)
        return ret;

    if (t_count)
    {
        // Flush second.
        ret.second = strtod(digit, NULL);
    }
    else
    {
        // Flush day.
        ret.day = strtol(digit, NULL, 10);
    }

    return ret;
}
void Settings_ProcessBuffer(uint8 buf[], uint8 buflen){
    uint8 i = 0;
    for(i=0;i<buflen;i++){
        process_char(buf[i]);
    }
}
Exemple #13
0
void Sim900::parse(char c) {
    process_char(c);
}
Exemple #14
0
void process_string(char *s) {
    while(*s) {
        process_char(*s++,0);
    }
}
Exemple #15
0
EVENT intern process_menuevent( VSCREEN *vptr, EVENT ev )
/*******************************************************/
{
    register    int                     index;
    register    int                     oldmenu = 0;
    register    EVENT                   itemevent;
    auto        EVENT                   newevent;
    auto        DESCMENU*               desc;
    auto        int                     menu;
    auto        bool                    select;
    auto        ORD                     mouserow;
    auto        ORD                     mousecol;
    auto        int                     mouseon;

    newevent = ev;
    if( ev > EV_NO_EVENT && ev <= EV_LAST_KEYBOARD ) {
        /* this allows alt numeric keypad stuff to not activate the menus */
        Menu->altpressed = FALSE;
    }
    if( isdialogue( vptr ) == FALSE ) {
        if( NumMenus > 0 ) {
            desc = &Describe[ Menu->menu - 1 ];
            newevent = EV_NO_EVENT; /* Moved here from "else" case below */
            if( Menu->popuppending ) {
                Menu->popuppending = FALSE;
                itemevent = createpopup( desc, &ev );
            } else {
                itemevent = EV_NO_EVENT;
            }
            if( Menu->active ) {
                oldmenu = menu = Menu->menu;
            } else {
                oldmenu = menu = 0;
            }
            select = FALSE;
            if( ev == EV_ALT_PRESS && !Menu->ignorealt ) {
                Menu->altpressed = TRUE;
            } else if( ev == EV_ALT_RELEASE && Menu->altpressed ) {
                if( Menu->active ) {
                    menu = 0;
                } else {
                    desc = &Describe[ 0 ];
                    menu = 1;
                }
                Menu->altpressed = FALSE;
            } else if( ev == EV_FUNC( 10 ) && UIData->f10menus ) {
                desc = &Describe[ 0 ];
                menu = 1;
            } else if( ev == EV_MOUSE_PRESS_R  ||
                       ev == EV_MOUSE_PRESS_M  ) {
                newevent = ev;
                menu = 0;
                Menu->draginmenu = FALSE;
            } else if( ( ev == EV_MOUSE_PRESS ) ||
                       ( ev == EV_MOUSE_DRAG ) ||
                       ( ev == EV_MOUSE_REPEAT ) ||
                       ( ev == EV_MOUSE_RELEASE ) ||
                       ( ev == EV_MOUSE_DCLICK ) ) {
                uigetmouse( &mouserow, &mousecol, &mouseon );
                if( ( mouserow < uimenuheight() ) &&
                        ( Menu->active  ||
                          ev == EV_MOUSE_PRESS  || ev == EV_MOUSE_DCLICK  ||
                          ev == EV_MOUSE_DRAG || ev == EV_MOUSE_REPEAT ) ) {
                    if( ev == EV_MOUSE_DCLICK ) {
                        ev = EV_MOUSE_PRESS;
                    }
                    menu = 0;
                    for( index = 0 ; !MENUENDMARKER( Menu->titles[ index ] ); ++index ) {
                        desc = &Describe[ index ];
                        if( ( MENU_GET_ROW( desc ) == mouserow ) &&
                                ( desc->titlecol <= mousecol ) &&
                                ( mousecol < desc->titlecol + desc->titlewidth + 2 ) ) {
                            Menu->draginmenu = TRUE;
                            Menu->popuppending = TRUE;
                            menu = index + 1;
                            break;
                        }
                    }
                } else if( Menu->active || Menu->draginmenu ) {
                    if( ( desc->area.col < mousecol )
                            && ( mousecol < desc->area.col + desc->area.width - 1 )
                            && ( mouserow < desc->area.row + desc->area.height - 1 )
                            && ( desc->area.row <= mouserow ) ) {
                        Menu->movedmenu = TRUE;
                    } else if( ev == EV_MOUSE_PRESS  ) {
                        newevent = ev;
                        menu = 0;
                        Menu->draginmenu = FALSE;
                    } else if( ev == EV_MOUSE_RELEASE ) {
                        menu = 0;
                        Menu->draginmenu = FALSE;
                    }
                } else {
                    newevent = ev;
                }
                if( ev != EV_MOUSE_RELEASE && menu != oldmenu ) {
                    Menu->movedmenu = TRUE;
                }
                if( ev == EV_MOUSE_RELEASE ) {
                    if( !Menu->movedmenu ) {
                        menu = 0;
                    } else {
                        select = TRUE;
                    }
                    Menu->movedmenu = FALSE;
                }
            } else if( uialtchar( ev ) != '\0'  ) {
                process_char( uialtchar( ev ), &desc, &menu, &select );
                newevent = EV_NO_EVENT;
            } else if( Menu->active ) {
                switch( ev ) {
                case EV_ESCAPE :
                    menu = 0;
                    break;
                case EV_RETURN :
                    if( menu > 0 ) {
                        Menu->popuppending = TRUE;
                    }
                    break;
                case EV_CURSOR_LEFT :
                    menu -= 1;
                    if( menu == 0 ) {
                        menu = NumMenus;
                    }
                    Menu->popuppending = TRUE;
                    desc = &Describe[ menu - 1 ];
                    break;
                case EV_CURSOR_RIGHT :
                    menu += 1;
                    if( menu > NumMenus ) {
                        menu = 1;
                    }
                    Menu->popuppending = TRUE;
                    desc = &Describe[ menu - 1 ];
                    break;
                case EV_CURSOR_DOWN :
                    Menu->popuppending = TRUE;
                    break;
                case EV_NO_EVENT :
                    break;
                default :
                    if( ev <= EV_LAST_KEYBOARD ) {
                        if( process_char( ev, &desc, &menu, &select ) ) {
                            break;
                        }
                    }
                    if( itemevent != EV_NO_EVENT ) {
                        newevent = itemevent;
                        select = TRUE;
                    } else {
                        newevent = ev;
                    }
                }
            } else {
                newevent = ev;
            }
            if( menu != oldmenu ) {
                if( menu > 0 && !Menu->active ) {
                    newevent = EV_MENU_ACTIVE;
                }
                Menu->active = ( menu > 0 );
                if( oldmenu > 0 ) {
                    menutitle( oldmenu, FALSE );
                }
                if( menu > 0 ) {
                    Menu->menu = menu;
                    menutitle( menu, TRUE );
                }
                if( menu == 0 || oldmenu == 0 ) {
                    uimenutitlebar();
                }
            }
            if( Menu->active ) {
                if( itemevent == EV_NO_EVENT ) {
                    if( MENUGRAYED(Menu->titles[ menu-1]) )  {
                        Menu->popuppending = FALSE;
                    } else {
                        itemevent = Menu->titles[ menu-1 ].event;
                    }
                }
                Menu->event = itemevent;
                if( select ) {
                    newevent = Menu->event;
                    Menu->active = FALSE;
                    uimenutitlebar();
                }
            }
        }
    }
    if( ev == EV_MOUSE_RELEASE ) {
        Menu->draginmenu = FALSE;
    }
    if( Menu->ignorealt ) {
        Menu->ignorealt = FALSE;
    }
    if( ( !Menu->active && ( oldmenu != 0 ) ) ||
            ( Menu->active && ( oldmenu != Menu->menu ) ) ) {
        if( ( Menu->menu > 0 ) && Menu->active ) {
            uimenucurr( &Menu->titles[Menu->menu - 1 ] );
        } else {
            /* no current menu */
            uimenucurr( NULL );
        }
    }

    if ( Menu->popuppending ) {
        InitMenuPopupPending = TRUE;
    }

    return( newevent );
}
Exemple #16
0
int             hc_encode (struct or_blobrec * targblobrec,
                    UCHAR *charbuf,
                    int charcount,
                    int file_pos)
{
/********** replaced by blobrec above...
	union charint
		{
		char ch[2];
		INT	 orig_char_count;
		} un1;
	static char temp1 [MAX_NUM_CHAR+1];  ...repl by blobrec;
************/
    char           *targ, *src;
    int             i, j;
    char            temp;
    char            ret_code = TRUE;
    char            write = FALSE;
    char            last_call = FALSE;

    if (charcount == 0) {
	last_call = TRUE;
	charcount = 1;
    }
    for (i = 0; i < charcount; i++) {
	if (!last_call) {
	    ret_code = process_char (charbuf[i], (char *) blobrec.or_blob);
	}
	if ((ret_code == NO_SPACE) ||
	    (file_pos && (i == (charcount - 1)))) {
	    if (!last_call) {
		if (file_pos && (i == (charcount - 1))) {
		    num_char_coded++;
		}
	    }
	    if (bit_pos) {
		strncat (coded_bits_str, zero_str,
		    (size_t) bits_left);
		convert_str_2_char (&temp);
		blobrec.or_blob[total_num_chars - 1][0] = temp;
	    }
	    write = TRUE;
	    /**********
		un1.orig_char_count = num_char_coded;
		bitstring[0] = un1.ch[0];
		bitstring[1] = un1.ch[1];
		for (j = 0; j <= total_num_chars; j++) {
		       *(bitstring + j + 2) = *(temp1 + j);
		       };
		**************/
	    targblobrec->or_bloblen = num_char_coded;
	    targ = (char *) targblobrec->or_blob;
	    src = (char *) blobrec.or_blob;
	    for (j = 0; j < total_num_chars; j++)
		*targ++ = *src++;

	    num_char_coded = 0;
	    bit_pos = 0;
	    total_num_chars = 0;
	    if (file_pos && (i == (charcount - 1))) {
		return write;
	    }
	    i--;
	}
	else {
	    num_char_coded++;
	}
    }
    return write;
}
Exemple #17
0
void process_file (FILE **filev, int counts[], int *others, int *control)
/* procedure to read file and determine character frequency counts */
{  char ch;
   while ((ch = getc (*filev)) != EOF)
     process_char (ch, counts, others, control);
}
static int gt_sequence_buffer_fasta_advance(GtSequenceBuffer *sb, GtError *err)
{
  int currentchar, ret = 0;
  unsigned long currentoutpos = 0, currentfileadd = 0, currentfileread = 0;
  GtSequenceBufferMembers *pvt;
  GtSequenceBufferFasta *sbf;

  gt_error_check(err);

  sbf = (GtSequenceBufferFasta*) sb;
  pvt = sb->pvt;
  while (true)
  {
    if (currentoutpos >= (unsigned long) OUTBUFSIZE)
    {
      if (pvt->filelengthtab != NULL)
      {
        pvt->filelengthtab[pvt->filenum].length
          += (uint64_t) currentfileread;
        pvt->filelengthtab[pvt->filenum].effectivelength
          += (uint64_t) currentfileadd;
      }
      break;
    }
    if (sbf->nextfile)
    {
      if (pvt->filelengthtab != NULL)
      {
        pvt->filelengthtab[pvt->filenum].length = 0;
        pvt->filelengthtab[pvt->filenum].effectivelength = 0;
      }
      sbf->nextfile = false;
      sbf->indesc = false;
      sbf->firstseqinfile = true;
      currentfileadd = 0;
      currentfileread = 0;
      pvt->linenum = (uint64_t) 1;
      pvt->inputstream = gt_file_xopen(gt_str_array_get(pvt->filenametab,
                                                  (unsigned long) pvt->filenum),
                                       "rb");
      pvt->currentinpos = 0;
      pvt->currentfillpos = 0;
    } else
    {
      currentchar = inlinebuf_getchar(sb, pvt->inputstream);
      if (currentchar == EOF)
      {
        gt_file_delete(pvt->inputstream);
        pvt->inputstream = NULL;
        if (pvt->filelengthtab != NULL)
        {
          pvt->filelengthtab[pvt->filenum].length += currentfileread;
          pvt->filelengthtab[pvt->filenum].effectivelength += currentfileadd;
        }
        if ((unsigned long) pvt->filenum
                                     == gt_str_array_size(pvt->filenametab)-1)
        {
          pvt->complete = true;
          break;
        }
        pvt->filenum++;
        sbf->nextfile = true;
      } else
      {
        currentfileread++;
        if (sbf->indesc)
        {
          if (currentchar == NEWLINESYMBOL)
          {
            pvt->linenum++;
            sbf->indesc = false;
          }
          if (pvt->descptr != NULL)
          {
            if (currentchar == NEWLINESYMBOL)
            {
              gt_queue_add(pvt->descptr,
                           gt_cstr_dup(gt_str_get(sbf->headerbuffer)));
              gt_str_reset(sbf->headerbuffer);
            } else
            {
              gt_str_append_char(sbf->headerbuffer, currentchar);
            }
          }
        } else
        {
          if (!isspace((int) currentchar))
          {
            if (currentchar == FASTASEPARATOR)
            {
              if (sbf->firstoverallseq)
              {
                sbf->firstoverallseq = false;
                sbf->firstseqinfile = false;
              } else
              {
                if (sbf->firstseqinfile)
                {
                  sbf->firstseqinfile = false;
                } else
                {
                  currentfileadd++;
                }
                pvt->outbuf[currentoutpos++] = (GtUchar) SEPARATOR;
                pvt->lastspeciallength++;
              }
              sbf->indesc = true;
            } else
            {
              if ((ret = process_char(sb, currentoutpos, currentchar, err)))
                return ret;
              currentoutpos++;
              currentfileadd++;
            }
          }
        }
      }
    }
  }
  if (sbf->firstoverallseq)
  {
    gt_error_set(err,"no sequences in multiple fasta file(s) %s ...",
              gt_str_array_get(pvt->filenametab,0));
    return -2;
  }
  pvt->nextfree = currentoutpos;
  return 0;
}