plibc/lib/stdio.c

#include "stdio.h"
#include "malloc.h"
#include "string.h"
#include "unistd.h"
#include <stdbool.h>

enum printf_size
{
    PS_DEFAULT,
    PS_LONG,
    PS_LONG_LONG,
    PS_SIZE_T,
};

int
printf_internal (const char *fmt, long long int *argp,
                 long long int *stack_argp)
{
    size_t argc = 0;

    while (*fmt)
        {
            char c = *fmt++;

            if (c != '%')
                {
                    putchar (c);
                    continue;
                }

            long long int *p;

            if (argc < 5)
                p = argp + argc;
            else
                p = stack_argp + argc - 5;

            int length = -1;
            enum printf_size size_modifier = PS_DEFAULT;
            bool zero_pad = false;

            if (*fmt == '0')
                {
                    zero_pad = true;
                    fmt++;
                }

            while (*fmt >= '0' && *fmt <= '9')
                {
                    if (length == -1)
                        length = 0;

                    length = length * 10 + *fmt++ - '0';
                }

            if (*fmt == 'L')
                {
                    size_modifier = PS_LONG_LONG;
                    fmt++;
                }
            else if (*fmt == 'l')
                {
                    size_modifier = PS_LONG;
                    fmt++;
                }
            else if (*fmt == 'z')
                {
                    size_modifier = PS_SIZE_T;
                    fmt++;
                }

            if (*fmt == 'l' && size_modifier == PS_LONG)
                {
                    size_modifier = PS_LONG_LONG;
                    fmt++;
                }

            switch (*fmt)
                {
                case '%':
                    putchar ('%');
                    break;

                case 'c':
                    putchar (*(int *) p);
                    argc++;
                    break;

                case 's':
                    putsnl (*(char **) p);
                    argc++;
                    break;

                case 'd':
                case 'i':
                    {
                        long long int num;
                        char buf[32] = { 0 };
                        int j = 0;

                        switch (size_modifier)
                            {
                            case PS_DEFAULT:
                                num = *(int *) p;
                                break;

                            case PS_LONG:
                                num = *(long *) p;
                                break;

                            case PS_LONG_LONG:
                            case PS_SIZE_T:
                                num = *(long long *) p;
                                break;
                            }

                        argc++;

                        if (num < 0)
                            {
                                putchar ('-');
                                num = -num;
                            }

                        do
                            {
                                if (j >= 32)
                                    return -1;

                                buf[j++] = num % 10 + '0';
                                num /= 10;
                            }
                        while (num);

                        if (j > length && length >= 0)
                            j = length;

                        while (length != -1 && length > j && zero_pad)
                            {
                                putchar ('0');
                                length--;
                            }

                        while (j--)
                            putchar (buf[j]);
                    }
                    break;

                case 'u':
                    {
                        unsigned long long int num;
                        char buf[32] = { 0 };
                        int j = 0;

                        switch (size_modifier)
                            {
                            case PS_DEFAULT:
                                num = *(unsigned int *) p;
                                break;

                            case PS_LONG:
                                num = *(unsigned long *) p;
                                break;

                            case PS_LONG_LONG:
                                num = *(unsigned long long *) p;
                                break;

                            case PS_SIZE_T:
                                num = *(size_t *) p;
                                break;
                            }

                        argc++;

                        do
                            {
                                if (j >= 32)
                                    return -1;

                                buf[j++] = num % 10 + '0';
                                num /= 10;
                            }
                        while (num);

                        if (j > length && length >= 0)
                            j = length;

                        while (length != -1 && length > j && zero_pad)
                            {
                                putchar ('0');
                                length--;
                            }

                        while (j--)
                            putchar (buf[j]);
                    }
                    break;

                case 'x':
                case 'X':
                case 'p':
                    {
                        unsigned long long int num;
                        char buf[32] = { 0 };
                        int j = 0;

                        if (*fmt == 'p')
                            num = *(unsigned long long int *) p;
                        else
                            {
                                switch (size_modifier)
                                    {
                                    case PS_DEFAULT:
                                        num = *(unsigned int *) p;
                                        break;

                                    case PS_LONG:
                                        num = *(unsigned long *) p;
                                        break;

                                    case PS_LONG_LONG:
                                    case PS_SIZE_T:
                                        num = *(unsigned long long *) p;
                                        break;
                                    }
                            }

                        argc++;

                        do
                            {
                                if (j >= 32)
                                    return -1;

                                long long int rem = num % 16;
                                buf[j++] = rem < 10 ? rem % 16 + '0'
                                                    : rem % 16 - 10
                                                          + (*fmt == 'X' ? 'A'
                                                                         : 'a');
                                num /= 16;
                            }
                        while (num);

                        if (*fmt == 'p')
                            {
                                putchar ('0');
                                putchar ('x');
                            }

                        if (j > length && length >= 0)
                            j = length;

                        while (length != -1 && length > j && zero_pad)
                            {
                                putchar ('0');
                                length--;
                            }

                        while (j--)
                            putchar (buf[j]);
                    }
                    break;

                default:
                    return -1;
                }

            fmt++;
        }

    return 0;
}

int
puts (const char *str)
{
    int ret = putsnl (str);

    if (ret < 0)
        return ret;

    return putchar ('\n');
}

int
putsnl (const char *str)
{
    return write (STDOUT_FILENO, str, strlen (str));
}

int
putchar (int c)
{
    return write (STDOUT_FILENO, &c, 1);
}

#define FBUFSIZ 1024

static int
fmode_to_flags (const char *mode)
{
    int flags = 0;

    if (mode[0] == 'r')
        flags = O_RDONLY;
    else if (mode[0] == 'w')
        flags = O_WRONLY | O_CREAT | O_TRUNC;
    else if (mode[0] == 'a')
        flags = O_WRONLY | O_CREAT | O_APPEND;
    else
        return -1;

    if (mode[1] == '+')
        {
            flags &= ~(O_RDONLY | O_WRONLY);
            flags |= O_RDWR;
        }

    return flags;
}

FILE *
fopen (const char *pathname, const char *mode)
{
    int flags = fmode_to_flags (mode);

    if (flags == -1)
        return NULL;

    int fd = open (pathname, flags);

    if (fd < 0)
        return NULL;

    FILE *file = malloc (sizeof (FILE));

    if (file == NULL)
        {
            close (fd);
            return NULL;
        }

    file->fd = fd;
    file->buf = malloc (FBUFSIZ);
    file->buf_size = 0;
    file->mode = flags;

    return file;
}

int
fclose (FILE *file)
{
    fflush (file);

    int ret = close (file->fd);

    if (ret < 0)
        return ret;

    free (file->buf);
    free (file);

    return 0;
}

size_t
fwrite (const void *ptr, size_t size, size_t nmemb, FILE *stream)
{
    size_t total = size * nmemb;
    size_t written = 0;
    char buf[FBUFSIZ];

    while (total)
        {
            size_t to_write = total;

            if (to_write > FBUFSIZ)
                to_write = FBUFSIZ;

            memcpy (buf, ptr, to_write);

            int ret = write (stream->fd, buf, to_write);

            if (ret < 0)
                return ret;

            total -= to_write;
            written += to_write;
        }

    return written;
}

int
fputs (const char *str, FILE *stream)
{
    while (*str)
        {
            ((unsigned char *) stream->buf)[stream->buf_size++] = *str;

            if (stream->buf_size >= FBUFSIZ || *str == '\n')
                {
                    int ret = fwrite (stream->buf, 1, stream->buf_size, stream);

                    if (ret < 0)
                        return ret;

                    stream->buf_size = 0;
                }

            str++;
        }

    return 0;
}

int
fflush (FILE *stream)
{
    if (stream->buf_size == 0)
        return 0;

    return fwrite (stream->buf, 1, stream->buf_size, stream);
}

FILE *
fdopen (int fd, const char *mode)
{
    int flags = fmode_to_flags (mode);

    if (flags == -1)
        return NULL;

    FILE *file = malloc (sizeof (FILE));

    if (file == NULL)
        return NULL;

    file->fd = fd;
    file->buf = malloc (FBUFSIZ);
    file->buf_size = 0;
    file->mode = flags;

    return file;
}
1	rakinar2	47	#include "stdio.h"
2	rakinar2	51	#include "malloc.h"
3	rakinar2	47	#include "string.h"
4	rakinar2	51	#include "unistd.h"
5	rakinar2	47	#include <stdbool.h>
6
7			enum printf_size
8			{
9			PS_DEFAULT,
10			PS_LONG,
11			PS_LONG_LONG,
12			PS_SIZE_T,
13			};
14
15			int
16			printf_internal (const char fmt, long long int argp,
17			long long int *stack_argp)
18			{
19			size_t argc = 0;
20
21			while (*fmt)
22			{
23			char c = *fmt++;
24
25			if (c != '%')
26			{
27			putchar (c);
28			continue;
29			}
30
31			long long int *p;
32
33			if (argc < 5)
34			p = argp + argc;
35			else
36			p = stack_argp + argc - 5;
37
38			int length = -1;
39			enum printf_size size_modifier = PS_DEFAULT;
40			bool zero_pad = false;
41
42			if (*fmt == '0')
43			{
44			zero_pad = true;
45			fmt++;
46			}
47
48			while (fmt >= '0' && fmt <= '9')
49			{
50			if (length == -1)
51			length = 0;
52
53			length = length * 10 + *fmt++ - '0';
54			}
55
56			if (*fmt == 'L')
57			{
58			size_modifier = PS_LONG_LONG;
59			fmt++;
60			}
61			else if (*fmt == 'l')
62			{
63			size_modifier = PS_LONG;
64			fmt++;
65			}
66			else if (*fmt == 'z')
67			{
68			size_modifier = PS_SIZE_T;
69			fmt++;
70			}
71
72			if (*fmt == 'l' && size_modifier == PS_LONG)
73			{
74			size_modifier = PS_LONG_LONG;
75			fmt++;
76			}
77
78			switch (*fmt)
79			{
80			case '%':
81			putchar ('%');
82			break;
83
84			case 'c':
85			putchar ((int ) p);
86			argc++;
87			break;
88
89			case 's':
90			putsnl ((char *) p);
91			argc++;
92			break;
93
94			case 'd':
95			case 'i':
96			{
97			long long int num;
98			char buf[32] = { 0 };
99			int j = 0;
100
101			switch (size_modifier)
102			{
103			case PS_DEFAULT:
104			num = (int ) p;
105			break;
106
107			case PS_LONG:
108			num = (long ) p;
109			break;
110
111			case PS_LONG_LONG:
112			case PS_SIZE_T:
113			num = (long long ) p;
114			break;
115			}
116
117			argc++;
118
119			if (num < 0)
120			{
121			putchar ('-');
122			num = -num;
123			}
124
125			do
126			{
127			if (j >= 32)
128			return -1;
129
130			buf[j++] = num % 10 + '0';
131			num /= 10;
132			}
133			while (num);
134
135			if (j > length && length >= 0)
136			j = length;
137
138			while (length != -1 && length > j && zero_pad)
139			{
140			putchar ('0');
141			length--;
142			}
143
144			while (j--)
145			putchar (buf[j]);
146			}
147			break;
148
149			case 'u':
150			{
151			unsigned long long int num;
152			char buf[32] = { 0 };
153			int j = 0;
154
155			switch (size_modifier)
156			{
157			case PS_DEFAULT:
158			num = (unsigned int ) p;
159			break;
160
161			case PS_LONG:
162			num = (unsigned long ) p;
163			break;
164
165			case PS_LONG_LONG:
166			num = (unsigned long long ) p;
167			break;
168
169			case PS_SIZE_T:
170			num = (size_t ) p;
171			break;
172			}
173
174			argc++;
175
176			do
177			{
178			if (j >= 32)
179			return -1;
180
181			buf[j++] = num % 10 + '0';
182			num /= 10;
183			}
184			while (num);
185
186			if (j > length && length >= 0)
187			j = length;
188
189			while (length != -1 && length > j && zero_pad)
190			{
191			putchar ('0');
192			length--;
193			}
194
195			while (j--)
196			putchar (buf[j]);
197			}
198			break;
199
200			case 'x':
201			case 'X':
202			case 'p':
203			{
204			unsigned long long int num;
205			char buf[32] = { 0 };
206			int j = 0;
207
208			if (*fmt == 'p')
209			num = (unsigned long long int ) p;
210			else
211			{
212			switch (size_modifier)
213			{
214			case PS_DEFAULT:
215			num = (unsigned int ) p;
216			break;
217
218			case PS_LONG:
219			num = (unsigned long ) p;
220			break;
221
222			case PS_LONG_LONG:
223			case PS_SIZE_T:
224			num = (unsigned long long ) p;
225			break;
226			}
227			}
228
229			argc++;
230
231			do
232			{
233			if (j >= 32)
234			return -1;
235
236			long long int rem = num % 16;
237			buf[j++] = rem < 10 ? rem % 16 + '0'
238			: rem % 16 - 10
239			+ (*fmt == 'X' ? 'A'
240			: 'a');
241			num /= 16;
242			}
243			while (num);
244
245			if (*fmt == 'p')
246			{
247			putchar ('0');
248			putchar ('x');
249			}
250
251			if (j > length && length >= 0)
252			j = length;
253
254			while (length != -1 && length > j && zero_pad)
255			{
256			putchar ('0');
257			length--;
258			}
259
260			while (j--)
261			putchar (buf[j]);
262			}
263			break;
264
265			default:
266			return -1;
267			}
268
269			fmt++;
270			}
271
272			return 0;
273			}
274
275			int
276			puts (const char *str)
277			{
278			int ret = putsnl (str);
279
280			if (ret < 0)
281			return ret;
282
283			return putchar ('\n');
284			}
285
286			int
287			putsnl (const char *str)
288			{
289			return write (STDOUT_FILENO, str, strlen (str));
290			}
291
292			int
293			putchar (int c)
294			{
295			return write (STDOUT_FILENO, &c, 1);
296	rakinar2	51	}
297
298			#define FBUFSIZ 1024
299
300			static int
301			fmode_to_flags (const char *mode)
302			{
303			int flags = 0;
304
305			if (mode[0] == 'r')
306			flags = O_RDONLY;
307			else if (mode[0] == 'w')
308			flags = O_WRONLY \| O_CREAT \| O_TRUNC;
309			else if (mode[0] == 'a')
310			flags = O_WRONLY \| O_CREAT \| O_APPEND;
311			else
312			return -1;
313
314			if (mode[1] == '+')
315			{
316			flags &= ~(O_RDONLY \| O_WRONLY);
317			flags \|= O_RDWR;
318			}
319
320			return flags;
321			}
322
323			FILE *
324			fopen (const char pathname, const char mode)
325			{
326			int flags = fmode_to_flags (mode);
327
328			if (flags == -1)
329			return NULL;
330
331			int fd = open (pathname, flags);
332
333			if (fd < 0)
334			return NULL;
335
336			FILE *file = malloc (sizeof (FILE));
337
338			if (file == NULL)
339			{
340			close (fd);
341			return NULL;
342			}
343
344			file->fd = fd;
345			file->buf = malloc (FBUFSIZ);
346			file->buf_size = 0;
347			file->mode = flags;
348
349			return file;
350			}
351
352			int
353			fclose (FILE *file)
354			{
355			fflush (file);
356
357			int ret = close (file->fd);
358
359			if (ret < 0)
360			return ret;
361
362			free (file->buf);
363			free (file);
364
365			return 0;
366			}
367
368			size_t
369			fwrite (const void ptr, size_t size, size_t nmemb, FILE stream)
370			{
371			size_t total = size * nmemb;
372			size_t written = 0;
373			char buf[FBUFSIZ];
374
375			while (total)
376			{
377			size_t to_write = total;
378
379			if (to_write > FBUFSIZ)
380			to_write = FBUFSIZ;
381
382			memcpy (buf, ptr, to_write);
383
384			int ret = write (stream->fd, buf, to_write);
385
386			if (ret < 0)
387			return ret;
388
389			total -= to_write;
390			written += to_write;
391			}
392
393			return written;
394			}
395
396			int
397			fputs (const char str, FILE stream)
398			{
399			while (*str)
400			{
401			((unsigned char ) stream->buf)[stream->buf_size++] = str;
402
403			if (stream->buf_size >= FBUFSIZ \|\| *str == '\n')
404			{
405			int ret = fwrite (stream->buf, 1, stream->buf_size, stream);
406
407			if (ret < 0)
408			return ret;
409
410			stream->buf_size = 0;
411			}
412
413			str++;
414			}
415
416			return 0;
417			}
418
419			int
420			fflush (FILE *stream)
421			{
422			if (stream->buf_size == 0)
423			return 0;
424
425			return fwrite (stream->buf, 1, stream->buf_size, stream);
426			}
427
428			FILE *
429			fdopen (int fd, const char *mode)
430			{
431			int flags = fmode_to_flags (mode);
432
433			if (flags == -1)
434			return NULL;
435
436			FILE *file = malloc (sizeof (FILE));
437
438			if (file == NULL)
439			return NULL;
440
441			file->fd = fd;
442			file->buf = malloc (FBUFSIZ);
443			file->buf_size = 0;
444			file->mode = flags;
445
446			return file;
447	rakinar2	47	}