Затем, кажется, войти в эту функцию, которая просто огромный! и комплекс! и некрасиво! и безумие! это как о мой бог?! Как кто-нибудь может запрограммировать эту shhhhiiittt?!?
Теперь это поистине заставляет меня задаться вопросом, если "юникода" был только изобретен, чтобы ввести эксплуатационные системные ошибки для китайских хакеров! YIKES!
ИНТ __cdecl _output_s_l (
#endif / * _SAFECRT_IMPL * /
FILE * поток,
#endif / * POSITIONAL_PARAMETERS * /
#endif / * FORMAT_VALIDATIONS * /
#endif / * _UNICODE * /
#endif / * CPRFLAG * /
Формат Const _TCHAR *,
#ifndef _SAFECRT_IMPL
_locale_t plocinfo,
#endif / * _SAFECRT_IMPL * /
va_list argptr
)
{
INT hexadd = 0; / * Смещение, чтобы добавить номер, чтобы получить «а» .. «е» * /
TCHAR ч; / * Символ просто читать * /
ИНТ флаги = 0; / * Флаг слово - см #defines выше значений флагов * /
перечисление состояния STATE; /* Текущее состояние */
перечисление CHARTYPE chclass; / * Класс текущего символа * /
INT радикс; / * Текущее радикс преобразование * /
INT charsout; / * Символов в настоящее время написано до сих пор, -1 = ошибка ввода-вывода * /
INT fldwidth = 0; / * Ширина выбранного поля - 0 означает, что по умолчанию * /
ИНТ точность = 0; / * Выбрана точность - -1 означает по умолчанию * /
TCHAR префикс [2]; / * Числовой префикс - до двух символов * /
INT = 0 длинного префикс; / * Длина префикса - 0 означает, что без префикса * /
INT capexp; / * Ненулевой = 'E' показатель signifient, ноль = 'е' * /
INT no_output = 0; / * Ненулевой = не prodcue никакого вывода для этого спецификатора * /
объединение {
символ * зг; / * Указатель текст, который будет напечатан, а не ноль прекращено * /
wchar_t * WZ;
} Текст;
INT textlen; / * Длина текста в байтах / WCHARs для печати.
textlen в мультибайтных или широких символов, если _UNICODE * /
объединение {
обугливается SZ [BufferSize];
#ifdef _UNICODE
wchar_t WZ [BufferSize];
#endif / * _UNICODE * /
} Буфер;
wchar_t WCHAR; / * Температура wchar_t * /
INT BufferSize; / * Размер text.sz (используется только для вызова _cfltcvt) * /
INT bufferiswide = 0; / * Ненулевой = буфер содержит широкие символы уже * /
#ifndef _SAFECRT_IMPL
_LocaleUpdate _loc_update (plocinfo);
#endif / * _SAFECRT_IMPL * /
#ifdef POSITIONAL_PARAMETERS
/ * Используется для разбора формат * /
Const _TCHAR * saved_format = NULL;
_TCHAR * end_pos = NULL;
/ * Это структура, которая хранит значения, соответствующие
каждые позиционные пары * /
структура positional_param pos_value [_ARGMAX];
ИНТ передача = 0; / * Ctr для сканирования строки формата в Diff проходит * /
INT noofpasses = 0; / * Установить 2 для позиционных форматов, в противном случае 1 * /
INT max_pos = -1; / * Отслеживание текущего максимального позиционный агд * /
INT type_pos = -1; / * Положение из Arg, обозначающий типа * /
INT width_pos = -1; / * Положение в обозначающей ширине агда * /
INT precis_pos = -1; / * Положение в арг обозначая точность * /
INT format_type = FMT_TYPE_NOTSET; / * Тип строки формата * /
#endif / * POSITIONAL_PARAMETERS * /
символ * heapbuf = NULL; / * Ненулевой = test.sz использования буфера кучи, чтобы освободиться * /
#ifndef CPRFLAG
_VALIDATE_RETURN ((поток = NULL), EINVAL, -1!);
#ifndef _UNICODE
_VALIDATE_STREAM_ANSI_RETURN (поток, EINVAL, EOF);
#endif / * _UNICODE * /
#endif / * CPRFLAG * /
_VALIDATE_RETURN ((формат = NULL), EINVAL, -1!);
charsout = 0; / * Нет символов написанных * /
#ifdef POSITIONAL_PARAMETERS
saved_format = формат;
(для прохода = 0; проход < 2; ++ проход)
{
если ((передача == FORMAT_OUTPUT_PASS) && (Format_type == FMT_TYPE_NONPOSITIONAL))
{
/ * Если в pass2, мы до сих пор format_type не позиционная, это означает,
что нам не нужен 2-ой проход * /
ломать;
}
#endif / * POSITIONAL_PARAMETERS * /
textlen = 0; / * Нет текста еще * /
состояние = ST_NORMAL; / * Начальное состояние * /
heapbuf = NULL; / * Не используется куча выделенного буфера * /
BufferSize = 0;
#ifdef POSITIONAL_PARAMETERS
max_pos = -1;
fldwidth = 0;
Точность = 0;
Формат = saved_format;
type_pos = -1;
width_pos = -1;
precis_pos = -1;
/ * Все символы до первого спецификатора формата получить выход в первом
выдать себя. Следовательно, мы должны сбросить format_type к FMT_TYPE_NOTSET для обеспечения
что они не получают выход снова на 2-й проход * /
format_type = FMT_TYPE_NOTSET;
#endif / * POSITIONAL_PARAMETERS * /
/ * Главный цикл - цикл в то время как формат символы существовать и без ошибок ввода / вывода * /
в то время как ((ч = * формат ++)! = _T ( '\ 0') && charsout >= 0) {
#ifndef FORMAT_VALIDATIONS
chclass = FIND_CHAR_CLASS (__ LookupTable, ч); / * Находка класс символов * /
состояние = FIND_NEXT_STATE (__ LookupTable, chclass, состояние); / * Найти следующее состояние * /
#else / * FORMAT_VALIDATIONS * /
chclass = FIND_CHAR_CLASS (__ lookuptable_s, ч); / * Находка класс символов * /
состояние = FIND_NEXT_STATE (__ lookuptable_s, chclass, состояние); / * Найти следующее состояние * /
#ifdef POSITIONAL_PARAMETERS
если ((состояние == ST_PERCENT) && (Формат *! = _T ( '%')))
{
если (format_type == FMT_TYPE_NOTSET)
{
/ * Мы устанавливаем значение format_type, когда мы попали в первый спецификатор типа * /
если (_tcstol (формат, &end_pos, 10) > 0 && (* End_pos == POSITION_CHAR))
{
если (== пройти FORMAT_POSSCAN_PASS)
{
MemSet (pos_value, 0, SizeOf (pos_value));
}
format_type = FMT_TYPE_POSITIONAL;
}
еще
{
format_type = FMT_TYPE_NONPOSITIONAL;
}
}
если (format_type == FMT_TYPE_POSITIONAL)
{
type_pos = _tcstol (формат, &end_pos, 10) - 1;
Формат = end_pos + 1;
если (== пройти FORMAT_POSSCAN_PASS)
{
/ * Мы не переделывать валидации во 2-е прохода * /
_VALIDATE_RETURN (((type_pos >= 0) && (* End_pos == POSITION_CHAR) && (type_pos < _ARGMAX)), EINVAL, -1);
/ * Обновление max_pos с текущим максимальными позами аргументом * /
max_pos = type_pos > max_pos? type_pos: max_pos;
}
}
}
еще
{
/ * Если состояние ST_INVALID, что означает недопустимый спецификатор формата * /
если (состояние == ST_INVALID)
_VALIDATE_RETURN (("Неверный формат спецификатор", 0), EINVAL, -1);
}
#else / * POSITIONAL_PARAMETERS * /
если (состояние == ST_INVALID)
_VALIDATE_RETURN (("Неверный формат спецификатор", 0), EINVAL, -1);
#endif / * POSITIONAL_PARAMETERS * /
#endif / * FORMAT_VALIDATIONS * /
/ * Выполнение кода для каждого состояния * /
переключатель (состояние) {
случай ST_NORMAL:
#ifdef POSITIONAL_PARAMETERS
если (((передвигайте == FORMAT_POSSCAN_PASS) && (Format_type == FMT_TYPE_POSITIONAL))
|| ((Пропуск == FORMAT_OUTPUT_PASS) && (Format_type == FMT_TYPE_NOTSET)))
{
/ * Не выход в 1-м проходе, если мы уже сталкивались
позиционное спецификатор формата. Все символы до первого формата
Спецификатор получить выход в самом первом проходе. Следовательно, мы должны
проверить format_type, чтобы убедиться, что они не получают выход
снова во 2-й проход * /
ломать;
}
#endif / * POSITIONAL_PARAMETERS * /
NORMAL_STATE:
/ * Нормальное состояние - просто написать символ * /
#ifdef _UNICODE
bufferiswide = 1;
#else / * _UNICODE * /
bufferiswide = 0;
#ifdef _SAFECRT_IMPL
если (isleadbyte ((символ без знака) CH)) {
#else / * _SAFECRT_IMPL * /
если (_isleadbyte_l ((символ без знака) ч, _loc_update.GetLocaleT ())) {
#endif / * _SAFECRT_IMPL * /
WRITE_CHAR (ч, &charsout);
ч = * формат ++;
/ * Не отвалится формат строки * /
_VALIDATE_RETURN ((ч = _T ( '\ 0')), EINVAL, -1!);
}
#endif / * _UNICODE * /
WRITE_CHAR (ч, &charsout);
ломать;
случай ST_PERCENT:
/ * Значение по умолчанию набора параметров преобразования * /
= fldwidth длинной префикса = no_output = capexp = 0;
флаги = 0;
Точность = -1;
bufferiswide = 0; /* по умолчанию */
ломать;
случай ST_FLAG:
/ * Флаг установлен, на основании которого символ флага * /
переключатель (ч)
случай _T ( '-'):
флаги
ломать;
случай ST_WIDTH:
/ * Обновление значения ширины * /
если (ч == _T ( '*')) {
/ * Получить ширину из списка агда * /
#ifdef POSITIONAL_PARAMETERS
если (format_type == FMT_TYPE_NONPOSITIONAL)
{
#endif / * POSITIONAL_PARAMETERS * /
fldwidth = get_int_arg (&argptr);
#ifdef POSITIONAL_PARAMETERS
}
еще
{
width_pos = _tcstol (формат, &end_pos, 10) - 1;
Формат = end_pos + 1;
если (== пройти FORMAT_POSSCAN_PASS)
{
_VALIDATE_RETURN (((width_pos >= 0) && (* End_pos == POSITION_CHAR) && (type_pos < _ARGMAX)), EINVAL, -1);
/ * Обновление max_pos с текущим максимальными позами аргументом * /
max_pos = width_pos > max_pos? width_pos: max_pos;
STORE_ARGPTR (pos_value, e_int_arg, width_pos, ч, флаги)
ломать;
}
еще
{
/ * Получить ширину из списка агда * /
GET_ARG (get_int_arg, pos_value [width_pos] .arg_ptr, fldwidth,)
}
}
#endif / * POSITIONAL_PARAMETERS * /
если (fldwidth < 0) = FL_LEFT;
fldwidth = -fldwidth;
}
еще {
/ * Добавить цифру к текущей ширине поля * /
fldwidth = fldwidth * 10 + (ч - _T ( '0'));
}
ломать;
случай ST_DOT:
/ * Обнулить точность, так как точка без номера означает 0
не по умолчанию, в соответствии с ANSI * /
Точность = 0;
ломать;
случай ST_PRECIS:
/ * Обновление значения * по точности /
если (ч == _T ( '*')) {
/ * Получить точность из списка агда * /
#ifdef POSITIONAL_PARAMETERS
если (format_type == FMT_TYPE_NONPOSITIONAL)
{
#endif / * POSITIONAL_PARAMETERS * /
Точность = get_int_arg (&argptr);
#ifdef POSITIONAL_PARAMETERS
}
еще
{
precis_pos = _tcstol (формат, &end_pos, 10) - 1;
Формат = end_pos + 1;
если (== пройти FORMAT_POSSCAN_PASS)
{
_VALIDATE_RETURN (((precis_pos >= 0) && (* End_pos == POSITION_CHAR) && (type_pos < _ARGMAX)), EINVAL, -1);
/ * Обновление max_pos с текущим максимальными позами аргументом * /
max_pos = precis_pos > max_pos? precis_pos: max_pos;
STORE_ARGPTR (pos_value, e_int_arg, precis_pos, ч, флаги)
ломать;
}
еще
{
/ * Получить ширину из списка агда * /
GET_ARG (get_int_arg, pos_value [precis_pos] .arg_ptr, точность)
}
}
#endif / * POSITIONAL_PARAMETERS * /
если (точность < 0)
Точность = -1; / * Отр точности означает, по умолчанию * /
}
еще {
/ * Добавить цифру к текущей точности * /
Точность = точность * 10 + (ч - _T ( '0'));
}
ломать;
случай st_size:
/ * Только что прочитал спецификатор размера, установите флаги на его основе * /
переключатель (ч) {
Случай _T ( 'л'):
/ *
* Для того, чтобы обработать случай Л.Л., мы уходим от
* Простой детерминированный конечный автомат.
* /
если (* Формат == _T ( 'L'))
= FL_LONGLONG; / * 'LL' => долго долго */
еще
флаги
ломать;
случай _T ( 'I'):
/ *
* Для того, чтобы справиться с I, I32 и I64 модификаторов размера, мы
* Отойти от простой детерминированной государственной машины.
* Код ниже сканирования для символов после «I»,
* И по умолчанию 64 бит на WIN64 и 32 бит на WIN32
* /
#if PTR_IS_INT64
флаги | = FL_I64; / * 'I' => __int64 на системах Win64 * /
#endif / * PTR_IS_INT64 * /
если ((формат * == _T ( '6')) && (* (Формат + 1) == _T ( '4')))
Формат + = 2;
флаги
иначе если ((формат * == _T ( '3')) && (* (Формат + 1) == _T ( '2')))
{
Формат + = 2;
флаги &= ~ FL_I64; / * I32 => __int32 * /
}
иначе если ((формат * == _T ( 'd')) ||
(Формат * == _T ( 'я')) ||
(Формат * == _T ( 'о')) ||
(Формат * == _T ( 'и')) ||
(Формат * == _T ( 'х')) ||
(Формат * == _T ( 'X')))
#ifdef POSITIONAL_PARAMETERS
/ *% Я не 32/64 зависит от платформы. Положим FL_PTRSIZE указать
это - используется при проверке повторного использования параметра позиционной * /
флаги
еще {
состояние = ST_NORMAL;
Гото NORMAL_STATE;
}
ломать;
Случай _T ( 'ч'):
флаги | = FL_SHORT; / * 'Ч' => короткий INT или символ * /
ломать;
Случай _T ( 'W'):
флаги | = FL_WIDECHAR; / * 'Ш' => широкий символ * /
ломать;
}
ломать;
случай ST_TYPE:
/ * Мы, наконец, читать фактический тип характера, поэтому мы * /
/ * Теперь форматировать и "Распечатать" выход. Мы используем большой переключатель * /
/ * Оператор, который устанавливает «текст», чтобы указать текст, который должен * /
/ * Печататься, и «textlen» к длине этого текста. * /
/ * Общий код позже берет на себя оправдывает его и * /
/ * Другие различные хозяйственные работы. Следует отметить, что случаи, доля кода * /
/ * В частности, все целое форматирование делается в одном месте. * /
/ * Посмотрите на эти фанк GOTO заявления! * /
переключатель (ч) {
случай _T ( 'C'): / * ISO широкий символ * /
если (! (флаги & (FL_SHORT | FL_LONG | FL_WIDECHAR)))
#ifdef _UNICODE
флаги | = FL_SHORT;
#else / * _UNICODE * /
флаги | = FL_WIDECHAR; / * ISO станд. * /
#endif / * _UNICODE * /
/ * Попадают в «с» случай * /
Случай _T ( 'с'): {
/ * Напечатать один символ, заданный Int аргумент * /
#ifdef _UNICODE
bufferiswide = 1;
#ifdef POSITIONAL_PARAMETERS
если (format_type == FMT_TYPE_NONPOSITIONAL)
{
#endif / * POSITIONAL_PARAMETERS * /
WCHAR = (wchar_t) get_int_arg (&argptr);
#ifdef POSITIONAL_PARAMETERS
}
еще
{
_VALIDATE_RETURN (((type_pos>= 0) && (type_pos<_ARGMAX)), EINVAL, -1);
если (== пройти FORMAT_POSSCAN_PASS)
{
STORE_ARGPTR (pos_value, e_int_arg, type_pos, ч, флаги)
ломать;
}
еще
{
GET_ARG (get_int_arg, pos_value [type_pos] .arg_ptr, WCHAR, (wchar_t))
}
}
#endif / * POSITIONAL_PARAMETERS * /
если (флаги & FL_SHORT) {
/ * Формат многобайтовый * /
/ * Это расширение ANSI * /
символ tempchar [2];
{
tempchar [0] = (символ) (WCHAR & 0x00FF);
tempchar [1] = '\ 0';
}
#ifdef _SAFECRT_IMPL
если (_MBTOWC (buffer.wz, tempchar, MB_CUR_MAX) < 0)
#else / * _SAFECRT_IMPL * /
если (_mbtowc_l (buffer.wz,
tempchar,
_loc_update.GetLocaleT () ->locinfo->MB_CUR_MAX,
_loc_update.GetLocaleT ()) < 0)
#endif / * _SAFECRT_IMPL * /
{
/ * Игнорировать, если преобразование было неудачным * /
no_output = 1;
}
} Еще {
buffer.wz [0] = WCHAR;
}
text.wz = buffer.wz;
textlen = 1; / * Печать только один символ * /
#else / * _UNICODE * /
если (флаги & (FL_LONG | FL_WIDECHAR)) {
errno_t е = 0;
#ifdef POSITIONAL_PARAMETERS
если (format_type == FMT_TYPE_NONPOSITIONAL)
{
#endif / * POSITIONAL_PARAMETERS * /
WCHAR = (wchar_t) get_short_arg (&argptr);
#ifdef POSITIONAL_PARAMETERS
}
еще
{
_VALIDATE_RETURN (((type_pos>= 0) && (type_pos<_ARGMAX)), EINVAL, -1);
если (== пройти FORMAT_POSSCAN_PASS)
{
STORE_ARGPTR (pos_value, e_short_arg, type_pos, ч, флаги)
ломать;
}
еще
{
GET_ARG (get_short_arg, pos_value [type_pos] .arg_ptr, WCHAR, (wchar_t))
}
}
#endif / * POSITIONAL_PARAMETERS * /
/ * Преобразовать символ * /
е = _WCTOMB_S (&textlen, buffer.sz, _countof (buffer.sz), WCHAR);
/ * Проверить, что преобразование прошло успешно * /
если (е! = 0)
no_output = 1;
} Еще {
/ * Формат многобайтовый * /
/ * Это расширение ANSI * /
беззнаковая короткая температура;
#ifdef POSITIONAL_PARAMETERS
если (format_type == FMT_TYPE_NONPOSITIONAL)
{
#endif / * POSITIONAL_PARAMETERS * /
Темп = (беззнаковое короткое замыкание) get_int_arg (&argptr);
#ifdef POSITIONAL_PARAMETERS
}
еще
{
_VALIDATE_RETURN (((type_pos>= 0) && (type_pos<_ARGMAX)), EINVAL, -1);
если (== пройти FORMAT_POSSCAN_PASS)
{
STORE_ARGPTR (pos_value, e_int_arg, type_pos, ч, флаги)
ломать;
}
еще
{
GET_ARG (get_int_arg, pos_value [type_pos] .arg_ptr, темп, (беззнаковое короткое))
}
}
#endif / * POSITIONAL_PARAMETERS * /
{
buffer.sz [0] = (символ) температура;
textlen = 1;
}
}
text.sz = buffer.sz;
#endif / * _UNICODE * /
}
ломать;
Случай _T ( 'Z'): {
/ * Печать подсчитывали Строка
Int я;
символ * р; / * * Временные секретари /
структура _count_string {
короткая длина;
короткие MaximumLength;
символ * Buffer;
} * Pstr;
#ifdef POSITIONAL_PARAMETERS
если (format_type == FMT_TYPE_NONPOSITIONAL)
{
#endif / * POSITIONAL_PARAMETERS * /
pstr = (структура _count_string *) get_ptr_arg (&argptr);
#ifdef POSITIONAL_PARAMETERS
}
еще
{
_VALIDATE_RETURN (((type_pos>= 0) && (type_pos<_ARGMAX)), EINVAL, -1);
если (== пройти FORMAT_POSSCAN_PASS)
{
STORE_ARGPTR (pos_value, e_ptr_arg, type_pos, ч, флаги)
ломать;
}
еще
{
GET_ARG (get_ptr_arg, pos_value [type_pos] .arg_ptr, pstr, (структура _count_string *))
}
}
#endif / * POSITIONAL_PARAMETERS * /
если (pstr == NULL || pstr->Буфер == NULL) {
/ * Нулевой PTR прошло, используйте специальную строку * /
text.sz = __nullstring;
textlen = (целое) StrLen (text.sz);
} Еще {
если (флаги & FL_WIDECHAR) {
text.wz = (wchar_t *) pstr->Буфер;
textlen = pstr->Длина / (INT) SizeOf (wchar_t);
bufferiswide = 1;
} Еще {
bufferiswide = 0;
text.sz = pstr->Буфер;
textlen = pstr->Длина;
}
}
}
ломать;
случай _T ( 'S'): / * строка широких символов ISO * /
#ifndef _UNICODE
если (! (флаги & (FL_SHORT | FL_LONG | FL_WIDECHAR)))
флаги | = FL_WIDECHAR;
#else / * _UNICODE * /
если (! (флаги & (FL_SHORT | FL_LONG | FL_WIDECHAR)))
флаги | = FL_SHORT;
#endif / * _UNICODE * /
Случай _T ( 'S'): {
/ * Напечатать строку - * /
/ * ANSI правила о том, сколько строки для печати: * /
/ * Все, если точность по умолчанию, * /
/ * Мин (точность, длина), если точность дается. * /
/ * Печатает «(нуль)», если пустая строка передается * /
Int я;
символ * р; / * * Временные секретари /
wchar_t * pwch;
/ * На данный момент заманчиво использовать STRLEN (), но * /
/ * Если точность определена, мы не позволили * /
/ * Скан прошлое там, потому что не может быть не нулевым * /
/* вообще. Таким образом, мы должны сделать нашу собственную проверку. * /
я = (точность == -1)? INT_MAX: точность;
#ifdef POSITIONAL_PARAMETERS
если (format_type == FMT_TYPE_NONPOSITIONAL)
{
#endif / * POSITIONAL_PARAMETERS * /
text.sz = (символ *) get_ptr_arg (&argptr);
#ifdef POSITIONAL_PARAMETERS
}
еще
{
_VALIDATE_RETURN (((type_pos>= 0) && (type_pos<_ARGMAX)), EINVAL, -1);
если (== пройти FORMAT_POSSCAN_PASS)
{
STORE_ARGPTR (pos_value, e_ptr_arg, type_pos, ч, флаги)
ломать;
}
еще
{
GET_ARG (get_ptr_arg, pos_value [type_pos] .arg_ptr, text.sz, (символ *))
}
}
#endif / * POSITIONAL_PARAMETERS * /
/ * Сканировать нуль Шифрование до я символов * /
#ifdef _UNICODE
если (флаги & FL_SHORT) {
если (text.sz == NULL) / * NULL передается, используйте специальную строку * /
text.sz = __nullstring;
р = text.sz;
для (textlen = 0; textlen<я && *п; textlen ++) {
#ifdef _SAFECRT_IMPL
если (isleadbyte ((неподписанные символ) (* р)))
#else / * _SAFECRT_IMPL * /
если (_isleadbyte_l ((символ без знака) (* р), _loc_update.GetLocaleT ()))
#endif / * _SAFECRT_IMPL * /
++п;
++п;
}
/ * Textlen теперь содержит длину в мультибайтных символов * /
} Еще {
если (text.wz == NULL) / * NULL передается, используйте специальную строку * /
text.wz = __wnullstring;
bufferiswide = 1;
pwch = text.wz;
в то время как я-- && * Pwch)
++pwch;
textlen = (INT) (pwch - text.wz); / * В wchar_ts * /
/ * Textlen теперь содержит длину в широких символов * /
}
#else / * _UNICODE * /
если (флаги & (FL_LONG | FL_WIDECHAR)) {
если (text.wz == NULL) / * NULL передается, используйте специальную строку * /
text.wz = __wnullstring;
bufferiswide = 1;
pwch = text.wz;
в то время как я-- && * Pwch)
++pwch;
textlen = (INT) (pwch - text.wz);
/ * Textlen теперь содержит длину в широких символов * /
} Еще {
если (text.sz == NULL) / * NULL передается, используйте специальную строку * /
text.sz = __nullstring;
р = text.sz;
в то время как я-- && *п)
++п;
textlen = (целое) (р - text.sz); / * Длина строки * /
}
#endif / * _UNICODE * /
}
ломать;
Случай _T ( 'п'): {
/ * Количество записи символов видели до сих пор в * /
/ * Короткий / INT / длинный через PTR чтения из арг * /
пустота * р; / * Темп * /
#ifdef POSITIONAL_PARAMETERS
если (format_type == FMT_TYPE_NONPOSITIONAL)
{
#endif / * POSITIONAL_PARAMETERS * /
р = get_ptr_arg (&argptr);
#ifdef POSITIONAL_PARAMETERS
}
еще
{
_VALIDATE_RETURN (((type_pos>= 0) && (type_pos<_ARGMAX)), EINVAL, -1);
если (== пройти FORMAT_POSSCAN_PASS)
{
STORE_ARGPTR (pos_value, e_ptr_arg, type_pos, ч, флаги)
ломать;
}
еще
{
GET_ARG (get_ptr_arg, pos_value [type_pos] .arg_ptr, р,)
}
}
#endif / * POSITIONAL_PARAMETERS * /
/ * Если% п отключена, мы пропустить ARG и печать «п» * /
если (! _get_printf_count_output ())
{
_VALIDATE_RETURN (("«П» спецификатор формата отключена", 0), EINVAL, -1);
ломать;
}
/ * Магазин обугливает вне в короткий / длинный / междунар в зависимости от флагов * /
#if! LONG_IS_INT
если (флаги & FL_LONG)
* (Длинный *) р = charsout;
еще
#endif / *! LONG_IS_INT * /
#if! SHORT_IS_INT
если (флаги & FL_SHORT)
* (Короткий *) р = (короткое замыкание) charsout;
еще
#endif / *! SHORT_IS_INT * /
* (Интермедиат *) р = charsout;
no_output = 1; / * Не заставляет никакого вывода * /
}
ломать;
Случай _T ( 'E'):
Случай _T ( 'G'):
Случай _T ( 'А'):
capexp = 1; / * Капитализировать показатель * /
CH + = _T ( 'а') - _T ( 'А'); / * Формат конвертировать символ в нижний * /
/ * DROP ЧЕРЕЗ * /
случай _T ( 'е'):
Случай _T ( 'е'):
Случай _T ( 'г'):
Случай _T ( 'а'): {
/ * С плавающей точкой преобразования - мы называем cfltcvt процедуры * /
/ *, Чтобы сделать работу для нас. * /
флаги | = FL_SIGNED; / * С плавающей точкой подписывается преобразование * /
#ifdef POSITIONAL_PARAMETERS
если ((format_type == FMT_TYPE_POSITIONAL) && (Передать == FORMAT_POSSCAN_PASS))
{
_VALIDATE_RETURN (((type_pos>= 0) && (type_pos<_ARGMAX)), EINVAL, -1);
#if! LONGDOUBLE_IS_DOUBLE
если (флаги & FL_LONGDOUBLE)
{
STORE_ARGPTR (pos_value, e_longdouble_arg, type_pos, ч, флаги)
}
еще
#endif / *! LONGDOUBLE_IS_DOUBLE * /
{
STORE_ARGPTR (pos_value, e_double_arg, type_pos, ч, флаги)
}
ломать;
}
#endif / * POSITIONAL_PARAMETERS * /
text.sz = buffer.sz; / * Поместить результат в буфер * /
BufferSize = BufferSize;
/ * Вычислить значение точности * /
если (точность < 0)
Точность = 6; / * По умолчанию точность: 6 * /
иначе если (точность == 0 && ч == _T ( 'г'))
Точность = 1; / * ANSI указано * /
иначе если (точность > MAXPRECISION)
Точность = MAXPRECISION;
если (точность > BufferSize - _CVTBUFSIZE) {
/ * Преобразование потенциально переполнить локальный буфер * /
/ * Так что мы должны использовать кучу распределённой буфер. * /
heapbuf = (символ *) _ malloc_crt (_CVTBUFSIZE + точность);
если (heapbuf! = NULL)
{
text.sz = heapbuf;
BufferSize = _CVTBUFSIZE + точность;
}
еще
/ * ТаНос не удалось, крышка точности далее * /
Точность = BufferSize - _CVTBUFSIZE;
}
#ifdef _SAFECRT_IMPL
/ * Для safecrt, проходим вдоль флага FL_ALTERNATE в _safecrt_cfltcvt * /
если (флаги & FL_ALTERNATE)
capexp
#endif / * _SAFECRT_IMPL * /
#if! LONGDOUBLE_IS_DOUBLE
/ * Сделать преобразование * /
если (флаги & FL_LONGDOUBLE) {
_LONGDOUBLE TMP;
#ifdef POSITIONAL_PARAMETERS
если (format_type == FMT_TYPE_NONPOSITIONAL)
{
#endif / * POSITIONAL_PARAMETERS * /
TMP = va_arg (argptr, _LONGDOUBLE);
#ifdef POSITIONAL_PARAMETERS
}
еще
{
/ * Будет ли сюда только для прохода == FORMAT_OUTPUT_PASS потому что
пройти == FORMAT_POSSCAN_PASS имеет разрыв выше * /
va_list tmp_arg;
_ASSERTE (передача == FORMAT_OUTPUT_PASS);
Н.Б.