Закінчуємо збирати власний printf

25 травня 4 хв читати

В заключній частині напишемо обробку останніх чотирьох прапорців. Почнемо з найпростішого - %u. В минулій частині ми описали обробку типу int, тепер наше завдання трохи спрощене, тому що нам не потрібно обробляти негативні значення. %u використовується для форматування змінних типу unsigned int, але використовувати конвертер для типу int ми не можемо, оскільки ми можемо отримати неочікувані результати. Спочатку створимо просту програму, котра виведе діапазони значень з котрими нам доведеться працювати:

#include <stdio.h>
// бібліолтека котра містить в собі діапазони для всіх стандартних типів
#include <limits.h>

int main(void){

    printf("Maximum Integer Value: %d\n", INT_MAX);
    printf("Minimum Integer Value: %d\n", INT_MIN);
    printf("Maximum Unsigned Integer Value: %u\n", UINT_MAX);

	return 0;
}

Після компіляції отримаємо:

Maximum Integer Value: 2147483647
Minimum Integer Value: -2147483648
Maximum Unsigned Integer Value: 4294967295

Unsigned int зберігає лише позитивні значення, тому мінімальне значення для цього типу - це 0. Тому, якщо ми будемо оперувати позитивними значеннями в межах від 0 до 2147483647, то все буде працювати нормально. Однак, коли ми вийдемо за ці межі, відбудеться дещо цікаве. Спробуємо обробити різні значення змінних типу unsigned int за допомогою нашої програми:

...
int main() {
		unsigned int a = 0;
		unsigned int b = 2147483647;
		unsigned int c = 2147483648;
		unsigned int d = 4294967295;


		myprintf("0 == %d\n", a);
		myprintf("2147483647 == %d\n", b);
		myprintf("2147483648 == %d\n", c);
		myprintf("4294967295 == %d\n", d);	


		return 0;
}

Отримаємо:

0 == 0
2147483647 == 2147483647
2147483648 == -2147483648
4294967295 == -1

Зовсім не те на що ми очікували. Для охочих дізнатися, чому так відбувається варто познайомитись з тим в якому виді представляються значення типу int (посилання).

Напишемо функції для обробки прапорця %u використовуючи аналогічні функції, що ми написали раніше для прапорця %d:

int uint_len(unsigned int n){

	int	count = 1;

	while (n > 9) {
		count++;
		n /= 10;
	}

	return count;
}


char *uint_toa(unsigned int n){
	int n_len;
	char *result;

	n_len = uint_len(n);
	result = malloc((n_len + 1) * sizeof(char));
	if (!result)
		return (NULL);
	result[n_len] = '\0';
	while (--n_len >= 0)
	{
		result[n_len] = (n % 10) + '0';
		n /= 10;
	}
	return (result);
}


int printu(unsigned int n){
	char *number;
	int result = 0;
	
	number = uint_toa(n);
	printstring(number);
	result = str_len(number);
	free(number);
	return (result);
}

// не забуваєсо додати новий прапорець 'u'
int	handle_flag(va_list args, char flag)
{
    if (flag == 'u')
	return (printu(va_arg(args, unsigned int)));
    if (flag == 'd' || flag == 'i')
        return (printdecimal(va_arg(args, int)));
    if (flag == 'c')
	return (printchar((char)va_arg(args, int)));
    if (flag == 's')
	return (printstring(va_arg(args, char *)));
    if (flag == '%')
	return (printchar('%'));
    return (0);
}

Скомпілюємо попередній приклад використовуючи %u:

int main() {
		unsigned int a = 0;
		unsigned int b = 2147483647;
		unsigned int c = 2147483648;
		unsigned int d = 4294967295;


		myprintf("0 == %u\n", a);
		myprintf("2147483647 == %u\n", b);
		myprintf("2147483648 == %u\n", c);
		myprintf("4294967295 == %u\n", d);	

    
    return 0;
}

Отримаємо:

0 == 0
2147483647 == 2147483647
2147483648 == 2147483648
4294967295 == 4294967295

Принаймні для тестових значень змінних отримали вірний результат.

Перейдемо до наступного прапорця - %x (%X). Цей прапорець відрізняється від %u тим, що нам потрібно представити число у шістнадцятковому форматі і в залежності від регістру виводити великі (%X) або малі (%x) літери в результаті. Ми також будемо працювати з цілими позитивними числами, але розширимо діапазон до unsigned long, щоб мати підтримку значень від 0 до 2^64-1 (це нам знадобиться пізніше). Використовуючи функції обробки %u як основу, напишемо аналогічні функції для %x:

int uhex_len(unsigned long n)
{
	int count = 1;
	
	while (n > 15) {
		count++;
		n /= 16;
	}
	return count;
}

// base використовуєтьс для форматування регістру літер
char *uhex_toa(unsigned long n, char base)
{
	int tmp;
	int n_len;
	char *result;

	n_len = uhex_len(n);
	result = (char *)malloc((n_len + 1) * sizeof(char));
	result[n_len] = '\0';
	while (--n_len >= 0)
	{
		tmp = (n % 16);
		if (tmp > 9)
			result[n_len] = base + tmp - 10;
		else
			result[n_len] = tmp + '0';
		n /= 16;
	}
	return result;
}

int printhex(unsigned long n, char base)
{
	char *number;
	int	 result;

	result = 0;
	number = uhex_toa(n, base);
	printstring(number);
	result = str_len(number);
	free(number);

	return result;
}

Додамо дві нові умови до обробника прапорців:

...
  if (flag == 'x')
    return (printhex(va_arg(args, unsigned long), 'a'));
  if (flag == 'X')
    return (printhex(va_arg(args, unsigned long), 'A'));
...

Випробуємо наші функції на попередніх прикладах:

int main() {
  unsigned long a = 0;
  unsigned long b = 2147483647;
  unsigned long c = 2147483648;
  unsigned long d = 4294967295;
  
  		
  myprintf("%x\n", a);
  myprintf("%x\n", b);
  myprintf("%x\n", c);
  myprintf("%x\n", d);
  		
  myprintf("%X\n", a);
  myprintf("%X\n", b);
  myprintf("%X\n", c);
  myprintf("%X\n", d);
    
  return 0;
}

/*
0
7fffffff
80000000
ffffffff
0
7FFFFFFF
80000000
FFFFFFFF
*/

Отже, ми підходимо до фінішу, і залишився лише один прапорець - %p, який використовується для виводу вказівників. Вказівники виводяться у форматі шістнадцяткових чисел з префіксом "0x". Ми вже створили функцію для конвертації десяткових чисел у шістнадцятковий формат, тому залишилося лише створити функцію, яка буде додавати префікс "0x". Вказівник може вказувати на практично будь-яку комірку пам'яті. З огляду на те, що більшість сучасних процесорів мають 64-бітну архітектуру, на попередньому кроці, ми розширили діапазон оброблюваних значень до unsigned long. Отримаємо:

int printpointer(unsigned long n)
{
  char *number;
  int result = 0;
  
  // використовуємо раніше створені функції
  number = uhex_toa(n, 'a');
  // виводимо префікс
  printstring("0x");
  printstring(number);
  result = str_len(number) + 2;
  free(number);
	
  return result;
}

Залишилась лише невелика деталь - обробка випадків, коли вказівник вказує на звільнену комірку пам'яті або вказівник ще не має жодного значення. Додамо обробку для NULL-вказівників і оновимо функцію printPointer:

int printpointer(unsigned long n)
{
  char *number;
  int result;

  result = 0;
  if (!n) {
    // наша функція повинна відтворювати поведінку
    // printf, саму тому для NULL вказівників ми виводмио (nil)
    write(1, "(nil)", 5);
    result = 5;
  }
  else {
    number = uhex_toa(n, 'a');
    printstring("0x");
    printstring(number);
    result = str_len(number) + 2;
    free(number);
  }
  return result;
}

В раніше створених функціях нам залишилось ще одне місце куди слід додати обробку NULL-вказівників, а саме функція printstring:

int printstring(char *str){
    int len  = 0;
    
    if (!str) {
	write(1, "(null)", 6);
	len = 6;
    }
    else {
        len = str_len(str);
        write(1, str, len);
    }
    return len;
}

Додамо нову умову для обробника прапорців:

...
    if (flag == 'p')
	return (printpointer(va_arg(args, unsigned long)));
...

Протестуємо роботу функції:

int main() {
  unsigned long a = 0;
  unsigned long b = 2147483647;
  unsigned long c = 2147483648;
  unsigned long d = 4294967295;


		
  myprintf("%p\n", a);
  myprintf("%p\n", b);
  myprintf("%p\n", c);
  myprintf("%p\n", d);
  // подивимось де в пам'яті знаходяться наші змінні
  myprintf("%p\n", &a);
  myprintf("%p\n", &b);
  myprintf("%p\n", &c);
  myprintf("%p\n", &d);
  return 0;
}
/*
(nil)
0x7fffffff
0x80000000
0xffffffff
0x7ffc3a970228
0x7ffc3a970230
0x7ffc3a970238
0x7ffc3a970240
*/

Таким чином, нам вдалося створити аналог printf, познайомитись ближче з деякими стандартними бібліотеками C і роботою операційної системи. Однак, є багато місць для подальшого покращення. Ось декілька ідей:

Розбиття функцій на окремі файли.
Створення make-файлу.
Перевірка попереджень компілятора.
Перевірка пам'яті за допомогою Valgrind.
Написання тестів.

Код можна знайти за посиланням, дякую за увагу.

Читаємо вікіпедію не покидаючи термінал.

Продовжуємо збирати велосипед або писати власний printf

Збираємо велосипед або пишемо власний printf

Закінчуємо збирати власний printf

Більше від автора

Читаємо вікіпедію не покидаючи термінал.

Продовжуємо збирати велосипед або писати власний printf

Збираємо велосипед або пишемо власний printf

Вам також сподобається

Консольний навігатор Diskonaut

HTTP проксі-сервер на декілька маршрутів

Впустіть Linux у своє життя

Коментарі (0)

Вам також сподобається

Консольний навігатор Diskonaut

HTTP проксі-сервер на декілька маршрутів

Впустіть Linux у своє життя

Читаємо вікіпедію не покидаючи термінал.

Теми цього довгочиту:

Продовжуємо збирати велосипед або писати власний printf

Теми цього довгочиту:

Збираємо велосипед або пишемо власний printf

Теми цього довгочиту:

Більше від автора

Читаємо вікіпедію не покидаючи термінал.

Теми цього довгочиту:

Продовжуємо збирати велосипед або писати власний printf

Теми цього довгочиту:

Збираємо велосипед або пишемо власний printf

Теми цього довгочиту:

Вам також сподобається

Консольний навігатор Diskonaut

Теми цього довгочиту:

HTTP проксі-сервер на декілька маршрутів

Теми цього довгочиту:

Впустіть Linux у своє життя

Теми цього довгочиту:

Коментарі (0)

Вам також сподобається

Консольний навігатор Diskonaut

Теми цього довгочиту:

HTTP проксі-сервер на декілька маршрутів

Теми цього довгочиту:

Впустіть Linux у своє життя

Теми цього довгочиту: