int usart_read_char(volatile avr32_usart_t *usart, int *c)

  if (usart->csr & (AVR32_USART_CSR_OVRE_MASK |
                    AVR32_USART_CSR_FRAME_MASK |
                    AVR32_USART_CSR_PARE_MASK))
    return USART_RX_ERROR;

Bool UART_Read( const eUART_PORT uartPort, WORD* pnLen, U8* pbtData)
{
   WORD len = *pnLen;
   // NOTE: For performance optimization - no range check if the uartPort is in range   
   if(usartPorts[uartPort] == NULL)
   {
      errors[uartPort] = eUART_DRV_USART_PORT_NOT_OPENED;
      return FALSE;   
   }
   
   *pnLen = 0;
   
   while(len)
   {      
      if( !usart_test_hit(usartPorts[uartPort]) )
      {
         // no more characters
         return TRUE;      
      }
      else
      {
         int ch;
         if( usart_read_char(usartPorts[uartPort], &ch) == USART_SUCCESS )
         {
            *pbtData++ = (U8)ch;                  
            (*pnLen)++;   
            len--;
         }
         else
         {
             /* NikB N303 */
//Read only                usartPorts[uartPort]->csr &= ( ! (  AVR32_USART_CSR_OVRE_MASK | AVR32_USART_CSR_FRAME_MASK | AVR32_USART_CSR_PARE_MASK));
             errors[uartPort] = eUART_DRV_RECEIVE_ERROR;
             return FALSE;
         }
      }
   }
   errors[uartPort] = eUART_DRV_RECEIVE_ERROR;
   return FALSE;
}

Bool COM_ReceiveLine(char* psz, Bool* overflow)
{
   static int n = 0;
//N303   static char buf[MAX_VCOM_REC_BUF];
    static U8 buf[MAX_VCOM_REC_BUF];

    bool xRet = FALSE;

    U8 xbuf[MAX_VCOM_REC_BUF];
   U8 bt = 0;
    U8 i;
    WORD nLen;
   
   *overflow = FALSE;
   
   if(!bInit)
   {
      return FALSE;
   }
   
//N303   if( UART_ReadByte( serCom, &bt) )
//N303  while (usart_read_char( serCom, &bt)=USART_SUCCESS)
    nLen = MAX_VCOM_REC_BUF;
    UART_Read( serCom, &nLen, &xbuf[0]);
    if (nLen>0)
   {
        i=0;
        while (i<nLen)
        {
            bt = buf[i];
         
          if(bt == 13)  // skip CR, CR/LF sequence expected as EOL
            {
            }           
            else
            {
             if(bt == 10)  // check LF
             {
                 for(int j=0; j<i; j++)
                 {
                     *(psz+j) = buf[j];
                 }
                 memmove( &psz[0], &buf[0], i); // ??? Len = i*sizeof(buf[0])
                 *(psz+i) = 0; // NULL terminated
                 n = 0;
                    if (! overflow){
                     xRet = TRUE; // true, if not overflow detect
                    }                   
             }
                else
                {
                  // check for legal characters, ignore non-printable characters and ASCII codes above 7F hex
                  if( bt > 0x7  && bt <= 0x7F)
                  {
                    buf[n++] = bt;
                     if(n >= MAX_VCOM_REC_BUF-1)
                     {
                        *overflow = TRUE;
                        n = 0;  // buffer overflow
                     }
                    }
                }
            }
          i++;
        }       
   }
   
   return xRet;
}