char *ft_itoa(int n)
{
int i;
int neg;
char *str;
i = 0;
if (n == -2147483648)
return (ft_strdup("-2147483648"));
check_neg(&n, &neg);
if ((str = ft_alloc(ft_intlen(n), neg)) == NULL)
return (NULL);
while (n > 9)
{
str[i] = ((n % 10) + '0');
ft_fuck_norminette(&n, &i);
}
str[i] = n + '0';
i++;
if (neg == 1)
{
str[i] = '-';
i++;
}
str[i] = '\0';
ft_swap(str);
return (str);
}
void ft_sys_option(int argc, char **argv)
{
char *tmp;
char *itos;
int count;
count = argc;
count = 0;
while (argv[++count])
{
itos = ft_itoa(count);
tmp = ft_strjoin("OPTION_", itos);
ft_alloc(ft_strdup(argv[count]), ft_strlen(argv[count]), tmp, "str");
ft_strdel(&tmp);
ft_strdel(&itos);
}
}
int get_next_line(int const fd, char **line)
{
char buf[BUFF_SIZE];
int ret;
static int offset = 0;
int stop;
int y;
y = 0;
stop = 0;
*line = NULL;
lseek(fd, offset, SEEK_SET);
while ((ret = read(fd, buf, BUFF_SIZE)) && !stop)
{
ft_alloc(line, sizeof (**line) * (ret + ft_strlen(*line)));
stop = fill_til_nl(&y, ret, *line, buf);
}
if (*line)
(*line)[y] = '\0';
offset += y + 1;
return (stop);
}
FT_Stream_Open( FT_Stream stream,
const char* filepathname )
{
int file;
struct stat stat_buf;
if ( !stream )
return FT_THROW( Invalid_Stream_Handle );
/* open the file */
file = open( filepathname, O_RDONLY );
if ( file < 0 )
{
FT_ERROR(( "FT_Stream_Open:" ));
FT_ERROR(( " could not open `%s'\n", filepathname ));
return FT_THROW( Cannot_Open_Resource );
}
/* Here we ensure that a "fork" will _not_ duplicate */
/* our opened input streams on Unix. This is critical */
/* since it avoids some (possible) access control */
/* issues and cleans up the kernel file table a bit. */
/* */
#ifdef F_SETFD
#ifdef FD_CLOEXEC
(void)fcntl( file, F_SETFD, FD_CLOEXEC );
#else
(void)fcntl( file, F_SETFD, 1 );
#endif /* FD_CLOEXEC */
#endif /* F_SETFD */
if ( fstat( file, &stat_buf ) < 0 )
{
FT_ERROR(( "FT_Stream_Open:" ));
FT_ERROR(( " could not `fstat' file `%s'\n", filepathname ));
goto Fail_Map;
}
/* XXX: TODO -- real 64bit platform support */
/* */
/* `stream->size' is typedef'd to unsigned long (in `ftsystem.h'); */
/* `stat_buf.st_size', however, is usually typedef'd to off_t */
/* (in sys/stat.h). */
/* On some platforms, the former is 32bit and the latter is 64bit. */
/* To avoid overflow caused by fonts in huge files larger than */
/* 2GB, do a test. Temporary fix proposed by Sean McBride. */
/* */
if ( stat_buf.st_size > LONG_MAX )
{
FT_ERROR(( "FT_Stream_Open: file is too big\n" ));
goto Fail_Map;
}
else if ( stat_buf.st_size == 0 )
{
FT_ERROR(( "FT_Stream_Open: zero-length file\n" ));
goto Fail_Map;
}
/* This cast potentially truncates a 64bit to 32bit! */
stream->size = (unsigned long)stat_buf.st_size;
stream->pos = 0;
stream->base = (unsigned char *)mmap( NULL,
stream->size,
PROT_READ,
MAP_FILE | MAP_PRIVATE,
file,
0 );
/* on some RTOS, mmap might return 0 */
if ( (long)stream->base != -1 && stream->base != NULL )
stream->close = ft_close_stream_by_munmap;
else
{
ssize_t total_read_count;
FT_ERROR(( "FT_Stream_Open:" ));
FT_ERROR(( " could not `mmap' file `%s'\n", filepathname ));
stream->base = (unsigned char*)ft_alloc( NULL, stream->size );
if ( !stream->base )
{
FT_ERROR(( "FT_Stream_Open:" ));
FT_ERROR(( " could not `alloc' memory\n" ));
goto Fail_Map;
}
total_read_count = 0;
do
{
ssize_t read_count;
read_count = read( file,
stream->base + total_read_count,
stream->size - total_read_count );
if ( read_count <= 0 )
{
if ( read_count == -1 && errno == EINTR )
continue;
FT_ERROR(( "FT_Stream_Open:" ));
FT_ERROR(( " error while `read'ing file `%s'\n", filepathname ));
goto Fail_Read;
}
total_read_count += read_count;
} while ( (unsigned long)total_read_count != stream->size );
stream->close = ft_close_stream_by_free;
}
close( file );
stream->descriptor.pointer = stream->base;
stream->pathname.pointer = (char*)filepathname;
stream->read = 0;
FT_TRACE1(( "FT_Stream_Open:" ));
FT_TRACE1(( " opened `%s' (%d bytes) successfully\n",
filepathname, stream->size ));
return FT_Err_Ok;
Fail_Read:
ft_free( NULL, stream->base );
Fail_Map:
close( file );
stream->base = NULL;
stream->size = 0;
stream->pos = 0;
return FT_THROW( Cannot_Open_Stream );
}
FT_Stream_Open( FT_Stream stream,
const char* filepathname )
{
int file;
struct stat stat_buf;
if ( !stream )
return FT_Err_Invalid_Stream_Handle;
/* open the file */
file = open( filepathname, O_RDONLY );
if ( file < 0 )
{
FT_ERROR(( "FT_Stream_Open:" ));
FT_ERROR(( " could not open `%s'\n", filepathname ));
return FT_Err_Cannot_Open_Resource;
}
/* Here we ensure that a "fork" will _not_ duplicate */
/* our opened input streams on Unix. This is critical */
/* since it avoids some (possible) access control */
/* issues and cleans up the kernel file table a bit. */
/* */
#ifdef F_SETFD
#ifdef FD_CLOEXEC
(void)fcntl( file, F_SETFD, FD_CLOEXEC );
#else
(void)fcntl( file, F_SETFD, 1 );
#endif /* FD_CLOEXEC */
#endif /* F_SETFD */
if ( fstat( file, &stat_buf ) < 0 )
{
FT_ERROR(( "FT_Stream_Open:" ));
FT_ERROR(( " could not `fstat' file `%s'\n", filepathname ));
goto Fail_Map;
}
stream->size = stat_buf.st_size;
stream->pos = 0;
stream->base = (unsigned char *)mmap( NULL,
stream->size,
PROT_READ,
MAP_FILE | MAP_PRIVATE,
file,
0 );
if ( (long)stream->base != -1 )
stream->close = ft_close_stream_by_munmap;
else
{
ssize_t total_read_count;
FT_ERROR(( "FT_Stream_Open:" ));
FT_ERROR(( " could not `mmap' file `%s'\n", filepathname ));
stream->base = (unsigned char*)ft_alloc( NULL, stream->size );
if ( !stream->base )
{
FT_ERROR(( "FT_Stream_Open:" ));
FT_ERROR(( " could not `alloc' memory\n" ));
goto Fail_Map;
}
total_read_count = 0;
do {
ssize_t read_count;
read_count = read( file,
stream->base + total_read_count,
stream->size - total_read_count );
if ( ( read_count == -1 ) )
{
if ( errno == EINTR )
continue;
FT_ERROR(( "FT_Stream_Open:" ));
FT_ERROR(( " error while `read'ing file `%s'\n", filepathname ));
goto Fail_Read;
}
total_read_count += read_count;
} while ( (unsigned long)total_read_count != stream->size );
stream->close = ft_close_stream_by_free;
}
close( file );
stream->descriptor.pointer = stream->base;
stream->pathname.pointer = (char*)filepathname;
stream->read = 0;
FT_TRACE1(( "FT_Stream_Open:" ));
FT_TRACE1(( " opened `%s' (%d bytes) successfully\n",
filepathname, stream->size ));
return FT_Err_Ok;
Fail_Read:
ft_free( NULL, stream->base );
Fail_Map:
close( file );
stream->base = NULL;
stream->size = 0;
stream->pos = 0;
return FT_Err_Cannot_Open_Stream;
}
