frmrd.c

德州仪器(TI) 的超低功耗16 位RISC 混合信号处理器的MSP430 平台为电池供电的测量应用提供了最终解决方案。应用包括便携式医疗设备、低功耗工业操作、无线、实用计量等

          factor = fvalue;
          if (i > DBL_MAX_10_EXP)
          {
            goto BAD_CONVERSION;
          }

          fvalue /= pow10(i);
          if (factor && !fvalue)
          {
            goto BAD_CONVERSION;
          }

          if (   sizeof(float) != sizeof(double)
              && !(flags & LONG_FLAG)
              && fvalue < FLT_MIN)
          {
            goto BAD_CONVERSION;
          }
        }
        else
        {
          if (sizeof(float) == sizeof(double))
          {
            factor = FLT_MAX;
            num_base = FLT_MAX_10_EXP;
          }
          if (sizeof(float) != sizeof(double))
          {
            factor = (flags & LONG_FLAG) ? DBL_MAX : FLT_MAX;
            num_base = (flags & LONG_FLAG) ?
              DBL_MAX_10_EXP : FLT_MAX_10_EXP;
          }
          if ((main_digs + i) > num_base)
          {
            goto BAD_CONVERSION;
          }
          if ((main_digs + i) == num_base)
          {
            if (fvalue > (factor / pow10(num_base - main_digs)))
            {
              goto BAD_CONVERSION;
            }
          }
          fvalue *= pow10(i);
        }
      }

      if (flags & ASSIGN_FLAG)
      {
        if (sizeof (float) != sizeof (double))
        {
          if (flags & LONG_FLAG)
          {
            *VAPTR(double) = sign_flag ? - fvalue : fvalue;
          }
          else
          {
            *VAPTR(float) = sign_flag ? - fvalue : fvalue;
          }
        }
        else
        {
          *VAPTR(double) = sign_flag ? - fvalue : fvalue;
        }
        ++assigned_items;
      }
      continue;
#endif

/*======================================================================*/
/*      Convert an octal integer                                        */
/*======================================================================*/
    case 'o':
      num_base = 8;
      goto ANY_CONVERT;

/*======================================================================*/
/*       Convert a hexadecimal integer                                  */
/*======================================================================*/
    case 'x':
    case 'X':
      num_base = 16;

#ifdef REDUCED_SUPPORT
      goto ANY_CONVERT;
#else
      goto HEX_TEST;

/*======================================================================*/
/*       Convert any base integer                                       */
/*======================================================================*/
    case 'i':
      num_base = 10;
HEX_TEST:
      c = get_sign_etc(line, &sign_flag, &field_width);
      if (c == '0' && field_width)
      {
        if (tolower((*line)[1]) == 'x' && field_width > 1)
        {
          c = *((*line) += 2);
          num_base = 16;
          field_width -= 2;
        }
        else if (num_base == 10)
        {
          num_base = 8;
        }
      }
      goto SPECIAL_CONVERT;

/*======================================================================*/
/*      Convert a * (pointer) value                                     */
/*======================================================================*/
    case 'p':
      num_base = 16;
      if (sizeof(int) != sizeof(void *))
      {
        flags |= LONG_FLAG;
      }
      goto ANY_CONVERT;
#endif

/*======================================================================*/
/*      Convert an 'unsigned int'                                       */
/*======================================================================*/
    case 'u':

/*======================================================================*/
/*      Convert a decimal 'int'                                         */
/*======================================================================*/
    case 'd':
    case 'h':
      num_base = 10;

/*======================================================================*/
/*      Major conversion loop                                           */
/*======================================================================*/
ANY_CONVERT:
      c = get_sign_etc(line, &sign_flag, &field_width);

SPECIAL_CONVERT:
      if (!field_width || get_num_base(c, num_base) == ILL_BASE)
      {
        goto BAD_CONVERSION;
      }

      value = 0;
      while (   (i = get_num_base(**line, num_base)) != ILL_BASE
             && field_width--)
      {
        value = (value * num_base) + i;
        (*line)++;
      }

      if (flags & ASSIGN_FLAG)
      {
        if (sign_flag)
        {
          value = -value;
        }

#ifdef  WANT_LONG_TYPES
        if (sizeof(int) == sizeof(short))
        {
          if (flags & LONG_FLAG)
          {
            *VAPTR(long) = value;
          }
          else
          {
            *VAPTR(int) = value;
          }
        }
        else
        {
          if (flags & SHORT_FLAG)
          {
            *VAPTR(short) = value;
          }
          else
          {
            *VAPTR(int) = value;
          }
        }
#else
        *VAPTR(int) = value;
#endif

        ++assigned_items;
      }
      continue;

#ifndef REDUCED_SUPPORT
/*======================================================================*/
/*      Scan for pattern matching string                                */
/*======================================================================*/
    case '[':
      if (flags & ASSIGN_FLAG)
      {
        temp_string_ptr = VAPTR(char);
      }

      if ((c = **format) == '^')
      {
        sign_flag = 0;
        c = *++(*format);
      }
      else
      {
        sign_flag = 1;
      }
      if (c)
      {
        flags |= ITEM_FLAG;     /* ICLM  is it a new item */
        while (field_width-- && **line)
        {
          if (get_valid_char(**line, sign_flag, *format))
          {
            if (flags & ITEM_FLAG)    /* if a new item */
            {
              if (flags & ASSIGN_FLAG)    /* ICLM 93.11.25 */
                assigned_items++;
              flags &= ~ITEM_FLAG;
            }
            if (flags & ASSIGN_FLAG)
            {
              *temp_string_ptr++ = **line;
            }
            (*line)++;
          }
          else
          {
            break;
          }
        }

        /* ICLM 93.11.25 */
        if (!(flags & ITEM_FLAG) && (flags & ASSIGN_FLAG))
        {
          *temp_string_ptr = '\0';
          flags |= ITEM_FLAG;
        }

        /* this will pass the PUT_VALUE_IN_STRING*/
        flags &= ~ASSIGN_FLAG;

        while (c = *++(*format))
        {
          if (c == ']')
          {
            (*format)++;
            break;
          }
        }
      }
      goto PUT_VALUE_IN_STRING;
#endif

/*======================================================================*/
/*      Convert a character sequence                                    */
/*======================================================================*/
    case 'c':
      if (flags & ASSIGN_FLAG)
      {
        temp_string_ptr = VAPTR(char);
      }

      if (field_width == MAX_FIELD_ALLOWED)
      {
        field_width = 1;
      }

      while (field_width-- && **line)
      {
        if (flags & ASSIGN_FLAG)
        {
          *temp_string_ptr++ = **line;
        }
        (*line)++;
      }

      assigned_items += flags & ASSIGN_FLAG;
      continue;

/*======================================================================*/
/*      Scan a string                                                   */
/*======================================================================*/
    case 's':
      if (flags & ASSIGN_FLAG)
      {
        temp_string_ptr = VAPTR(char);
      }

      get_non_space(line);

      while (field_width-- && **line && !isspace(**line))
      {
        if (flags & ASSIGN_FLAG)
        {
          *temp_string_ptr++ = **line;
        }
        (*line)++;
      }

PUT_VALUE_IN_STRING:
      if (flags & ASSIGN_FLAG)
      {
        ++assigned_items;
        *temp_string_ptr = '\0';
      }
      continue;

#ifndef REDUCED_SUPPORT
/*======================================================================*/
/*      Tell how many character we have eaten so far                    */
/*======================================================================*/
    case 'n':
      if (flags & ASSIGN_FLAG)
      {
        *VAPTR(int) = *line - save_line;
      }
      continue;

/*======================================================================*/
/*      '%' Test                                                        */
/*======================================================================*/
    case '%':
      if (*(*line)++ == '%')
      {
        continue;
      }
#endif

/*======================================================================*/
/*      Not a good conversion char, return                              */
/*======================================================================*/
BAD_CONVERSION:
      if (!**line) while (isspace(**format))
      {
        (*format)++;
      }
    default:
      return (assigned_items);
    }
  }
  return (assigned_items);
}