Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 3438 → Rev 3219

/branches/dynload/uspace/lib/libc/generic/getopt.c
File deleted
/branches/dynload/uspace/lib/libc/generic/vfs/vfs.c
59,10 → 59,9
char *cwd_path = NULL;
size_t cwd_len = 0;
 
char *absolutize(const char *path, size_t *retlen)
static char *absolutize(const char *path, size_t *retlen)
{
char *ncwd_path;
char *ncwd_path_nc;
 
futex_down(&cwd_futex);
size_t len = strlen(path);
71,40 → 70,28
futex_up(&cwd_futex);
return NULL;
}
ncwd_path_nc = malloc(cwd_len + 1 + len + 1);
if (!ncwd_path_nc) {
ncwd_path = malloc(len + cwd_len + 1);
if (!ncwd_path) {
futex_up(&cwd_futex);
return NULL;
}
strcpy(ncwd_path_nc, cwd_path);
ncwd_path_nc[cwd_len] = '/';
ncwd_path_nc[cwd_len + 1] = '\0';
strcpy(ncwd_path, cwd_path);
ncwd_path[cwd_len] = '/';
ncwd_path[cwd_len + 1] = '\0';
} else {
ncwd_path_nc = malloc(len + 1);
if (!ncwd_path_nc) {
ncwd_path = malloc(len + 1);
if (!ncwd_path) {
futex_up(&cwd_futex);
return NULL;
}
ncwd_path_nc[0] = '\0';
ncwd_path[0] = '\0';
}
strcat(ncwd_path_nc, path);
ncwd_path = canonify(ncwd_path_nc, retlen);
if (!ncwd_path) {
strcat(ncwd_path, path);
if (!canonify(ncwd_path, retlen)) {
futex_up(&cwd_futex);
free(ncwd_path_nc);
free(ncwd_path);
return NULL;
}
/*
* We need to clone ncwd_path because canonify() works in-place and thus
* the address in ncwd_path need not be the same as ncwd_path_nc, even
* though they both point into the same dynamically allocated buffer.
*/
ncwd_path = strdup(ncwd_path);
free(ncwd_path_nc);
if (!ncwd_path) {
futex_up(&cwd_futex);
return NULL;
}
futex_up(&cwd_futex);
return ncwd_path;
}
118,8 → 105,7
 
static int device_get_handle(char *name, dev_handle_t *handle)
{
int phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP, DEVMAP_CLIENT,
0);
int phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP, DEVMAP_CLIENT, 0);
if (phone < 0)
return phone;
185,15 → 171,6
free(mpa);
return (int) rc;
}
/* Ask VFS whether it likes fs_name. */
rc = async_req_0_0(vfs_phone, IPC_M_PING);
if (rc != EOK) {
async_wait_for(req, NULL);
async_serialize_end();
futex_up(&vfs_phone_futex);
free(mpa);
return (int) rc;
}
rc = ipc_data_write_start(vfs_phone, (void *)mpa, mpa_len);
if (rc != EOK) {
async_wait_for(req, NULL);
246,8 → 223,7
futex_up(&vfs_phone_futex);
free(pa);
 
if (rc != EOK)
return (int) rc;
if (rc != EOK) return (int) rc;
return (int) IPC_GET_ARG1(answer);
}
 
311,7 → 287,7
if (rc == EOK)
return (ssize_t) IPC_GET_ARG1(answer);
else
return rc;
return -1;
}
 
ssize_t write(int fildes, const void *buf, size_t nbyte)
/branches/dynload/uspace/lib/libc/generic/vfs/canonify.c
125,7 → 125,6
static void set_first_slash(token_t *t, token_t *tfsl, token_t *tlcomp)
{
*tfsl = *t;
*tlcomp = *t;
}
static void save_component(token_t *t, token_t *tfsl, token_t *tlcomp)
{
/branches/dynload/uspace/lib/libc/generic/task.c
41,7 → 41,6
#include <stdlib.h>
#include <async.h>
#include <errno.h>
#include <vfs/vfs.h>
 
task_id_t task_get_id(void)
{
131,17 → 130,9
int rc;
ipcarg_t retval;
 
char *pa;
size_t pa_len;
 
pa = absolutize(path, &pa_len);
if (!pa)
return 0;
 
/* Spawn a program loader */
phone_id = task_spawn_loader();
if (phone_id < 0)
return 0;
if (phone_id < 0) return 0;
 
/*
* Say hello so that the loader knows the incoming connection's
148,12 → 139,11
* phone hash.
*/
rc = async_req_0_0(phone_id, LOADER_HELLO);
if (rc != EOK)
return 0;
if (rc != EOK) return 0;
 
/* Send program pathname */
req = async_send_0(phone_id, LOADER_SET_PATHNAME, &answer);
rc = ipc_data_write_start(phone_id, (void *)pa, pa_len);
rc = ipc_data_write_start(phone_id, (void *)path, strlen(path));
if (rc != EOK) {
async_wait_for(req, NULL);
return 1;
160,18 → 150,15
}
 
async_wait_for(req, &retval);
if (retval != EOK)
goto error;
if (retval != EOK) goto error;
 
/* Send arguments */
rc = loader_set_args(phone_id, argv);
if (rc != EOK)
goto error;
if (rc != EOK) goto error;
 
/* Request loader to start the program */
rc = async_req_0_0(phone_id, LOADER_RUN);
if (rc != EOK)
goto error;
if (rc != EOK) goto error;
 
/* Success */
ipc_hangup(phone_id);
/branches/dynload/uspace/lib/libc/generic/io/asprintf.c
File deleted
/branches/dynload/uspace/lib/libc/generic/io/printf_core.c
94,9 → 94,12
if (str == NULL)
return printf_putnchars("(NULL)", 6, ps);
 
count = strlen(str);
for (count = 0; str[count] != 0; count++);
 
return ps->write((void *) str, count, ps->data);
if (ps->write((void *) str, count, ps->data) == count)
return 0;
return EOF;
}
 
/** Print one character to output
/branches/dynload/uspace/lib/libc/generic/io/vsnprintf.c
38,27 → 38,22
#include <io/printf_core.h>
 
struct vsnprintf_data {
size_t size; /* total space for string */
size_t len; /* count of currently used characters */
char *string; /* destination string */
size_t size; /* total space for string */
size_t len; /* count of currently used characters */
char *string; /* destination string */
};
 
/** Write string to given buffer.
* Write at most data->size characters including trailing zero. According to C99
* has snprintf to return number of characters that would have been written if
* enough space had been available. Hence the return value is not number of
* really printed characters but size of input string. Number of really used
* characters is stored in data->len.
*
* @param str Source string to print.
* @param count Size of the source string.
* @param data Structure with destination string, counter of used space
* and total string size.
* @return Number of characters to print (not characters really
* printed!)
* Write at most data->size characters including trailing zero. According to C99 has snprintf to return number
* of characters that would have been written if enough space had been available. Hence the return value is not
* number of really printed characters but size of input string. Number of really used characters
* is stored in data->len.
* @param str source string to print
* @param count size of source string
* @param data structure with destination string, counter of used space and total string size.
* @return number of characters to print (not characters really printed!)
*/
static int
vsnprintf_write(const char *str, size_t count, struct vsnprintf_data *data)
static int vsnprintf_write(const char *str, size_t count, struct vsnprintf_data *data)
{
size_t i;
i = data->size - data->len;
68,10 → 63,7
}
if (i == 1) {
/*
* We have only one free byte left in buffer => write there
* trailing zero.
*/
/* We have only one free byte left in buffer => write there trailing zero */
data->string[data->size - 1] = 0;
data->len = data->size;
return count;
78,23 → 70,17
}
if (i <= count) {
/*
* We have not enought space for whole string with the trailing
* zero => print only a part of string.
*/
memcpy((void *)(data->string + data->len), (void *)str, i - 1);
data->string[data->size - 1] = 0;
data->len = data->size;
return count;
/* We have not enought space for whole string with the trailing zero => print only a part of string */
memcpy((void *)(data->string + data->len), (void *)str, i - 1);
data->string[data->size - 1] = 0;
data->len = data->size;
return count;
}
/* Buffer is big enought to print whole string */
memcpy((void *)(data->string + data->len), (void *)str, count);
data->len += count;
/*
* Put trailing zero at end, but not count it into data->len so it could
* be rewritten next time.
*/
/* Put trailing zero at end, but not count it into data->len so it could be rewritten next time */
data->string[data->len] = 0;
 
return count;
101,22 → 87,17
}
 
/** Print formatted to the given buffer with limited size.
* @param str Buffer.
* @param size Bffer size.
* @param fmt Format string.
* @param str buffer
* @param size buffer size
* @param fmt format string
* \see For more details about format string see printf_core.
*/
int vsnprintf(char *str, size_t size, const char *fmt, va_list ap)
{
struct vsnprintf_data data = {size, 0, str};
struct printf_spec ps = {
(int(*)(void *, size_t, void *)) vsnprintf_write,
&data
};
struct printf_spec ps = {(int(*)(void *, size_t, void *)) vsnprintf_write, &data};
 
/*
* Print 0 at end of string - fix the case that nothing will be printed.
*/
/* Print 0 at end of string - fix the case that nothing will be printed */
if (size > 0)
str[0] = 0;
/branches/dynload/uspace/lib/libc/generic/io/sprintf.c
48,6 → 48,7
va_start(args, fmt);
ret = vsprintf(str, fmt, args);
 
va_end(args);
 
return ret;
/branches/dynload/uspace/lib/libc/generic/ipc.c
682,7 → 682,7
{
int res;
sysarg_t tmp_flags;
res = async_req_3_2(phoneid, IPC_M_SHARE_IN, (ipcarg_t) dst,
res = ipc_call_sync_3_2(phoneid, IPC_M_SHARE_IN, (ipcarg_t) dst,
(ipcarg_t) size, arg, NULL, &tmp_flags);
if (flags)
*flags = tmp_flags;
742,7 → 742,7
*/
int ipc_share_out_start(int phoneid, void *src, int flags)
{
return async_req_3_0(phoneid, IPC_M_SHARE_OUT, (ipcarg_t) src, 0,
return ipc_call_sync_3_0(phoneid, IPC_M_SHARE_OUT, (ipcarg_t) src, 0,
(ipcarg_t) flags);
}
 
803,7 → 803,7
*/
int ipc_data_read_start(int phoneid, void *dst, size_t size)
{
return async_req_2_0(phoneid, IPC_M_DATA_READ, (ipcarg_t) dst,
return ipc_call_sync_2_0(phoneid, IPC_M_DATA_READ, (ipcarg_t) dst,
(ipcarg_t) size);
}
 
862,7 → 862,7
*/
int ipc_data_write_start(int phoneid, void *src, size_t size)
{
return async_req_2_0(phoneid, IPC_M_DATA_WRITE, (ipcarg_t) src,
return ipc_call_sync_2_0(phoneid, IPC_M_DATA_WRITE, (ipcarg_t) src,
(ipcarg_t) size);
}
 
/branches/dynload/uspace/lib/libc/generic/string.c
38,8 → 38,8
#include <limits.h>
#include <align.h>
#include <sys/types.h>
#include <malloc.h>
 
 
/* Dummy implementation of mem/ functions */
 
void *memset(void *s, int c, size_t n)
66,10 → 66,9
adst[i].n = asrc[i].n;
for (j = 0; j < n % sizeof(unsigned long); j++)
((unsigned char *) (((unsigned long *) dst) + i))[j] =
((unsigned char *) (((unsigned long *) src) + i))[j];
((unsigned char *) (((unsigned long *) dst) + i))[j] = ((unsigned char *) (((unsigned long *) src) + i))[j];
return (char *) dst;
return (char *) src;
}
 
void *memcpy(void *dst, const void *src, size_t n)
76,8 → 75,7
{
int i, j;
 
if (((long) dst & (sizeof(long) - 1)) ||
((long) src & (sizeof(long) - 1)))
if (((long) dst & (sizeof(long) - 1)) || ((long) src & (sizeof(long) - 1)))
return unaligned_memcpy(dst, src, n);
 
for (i = 0; i < n / sizeof(unsigned long); i++)
84,10 → 82,9
((unsigned long *) dst)[i] = ((unsigned long *) src)[i];
for (j = 0; j < n % sizeof(unsigned long); j++)
((unsigned char *) (((unsigned long *) dst) + i))[j] =
((unsigned char *) (((unsigned long *) src) + i))[j];
((unsigned char *) (((unsigned long *) dst) + i))[j] = ((unsigned char *) (((unsigned long *) src) + i))[j];
return (char *) dst;
return (char *) src;
}
 
void *memmove(void *dst, const void *src, size_t n)
98,23 → 95,22
return memcpy(dst, src, n);
 
for (j = (n % sizeof(unsigned long)) - 1; j >= 0; j--)
((unsigned char *) ((unsigned long *) dst))[j] =
((unsigned char *) ((unsigned long *) src))[j];
((unsigned char *) ((unsigned long *) dst))[j] = ((unsigned char *) ((unsigned long *) src))[j];
 
for (i = n / sizeof(unsigned long) - 1; i >=0 ; i--)
((unsigned long *) dst)[i] = ((unsigned long *) src)[i];
return (char *) dst;
return (char *) src;
}
 
/** Compare two memory areas.
*
* @param s1 Pointer to the first area to compare.
* @param s2 Pointer to the second area to compare.
* @param len Size of the first area in bytes. Both areas must have
* the same length.
* @return If len is 0, return zero. If the areas match, return
* zero. Otherwise return non-zero.
* @param s1 Pointer to the first area to compare.
* @param s2 Pointer to the second area to compare.
* @param len Size of the first area in bytes. Both areas must have the same
* length.
* @return If len is 0, return zero. If the areas match, return zero.
* Otherwise return non-zero.
*/
int bcmp(const char *s1, const char *s2, size_t len)
{
124,9 → 120,8
}
 
/** Count the number of characters in the string, not including terminating 0.
*
* @param str String.
* @return Number of characters in string.
* @param str string
* @return number of characters in string.
*/
size_t strlen(const char *str)
{
146,6 → 141,7
c++;
return (a[c] - b[c]);
}
 
int strncmp(const char *a, const char *b, size_t n)
159,22 → 155,10
}
 
int stricmp(const char *a, const char *b)
{
int c = 0;
while (a[c] && b[c] && (!(tolower(a[c]) - tolower(b[c]))))
c++;
return (tolower(a[c]) - tolower(b[c]));
}
 
/** Return pointer to the first occurence of character c in string.
*
* @param str Scanned string.
* @param c Searched character (taken as one byte).
* @return Pointer to the matched character or NULL if it is not
* found in given string.
/** Return pointer to the first occurence of character c in string
* @param str scanned string
* @param c searched character (taken as one byte)
* @return pointer to the matched character or NULL if it is not found in given string.
*/
char *strchr(const char *str, int c)
{
187,12 → 171,10
return NULL;
}
 
/** Return pointer to the last occurence of character c in string.
*
* @param str Scanned string.
* @param c Searched character (taken as one byte).
* @return Pointer to the matched character or NULL if it is not
* found in given string.
/** Return pointer to the last occurence of character c in string
* @param str scanned string
* @param c searched character (taken as one byte)
* @return pointer to the matched character or NULL if it is not found in given string.
*/
char *strrchr(const char *str, int c)
{
209,16 → 191,13
 
/** Convert string to a number.
* Core of strtol and strtoul functions.
*
* @param nptr Pointer to string.
* @param endptr If not NULL, function stores here pointer to the first
* invalid character.
* @param base Zero or number between 2 and 36 inclusive.
* @param sgn It's set to 1 if minus found.
* @return Result of conversion.
* @param nptr pointer to string
* @param endptr if not NULL, function stores here pointer to the first invalid character
* @param base zero or number between 2 and 36 inclusive
* @param sgn its set to 1 if minus found
* @return result of conversion.
*/
static unsigned long
_strtoul(const char *nptr, char **endptr, int base, char *sgn)
static unsigned long _strtoul(const char *nptr, char **endptr, int base, char *sgn)
{
unsigned char c;
unsigned long result = 0;
240,8 → 219,7
/* FIXME: set errno to EINVAL */
return 0;
}
if ((base == 16) && (*str == '0') && ((str[1] == 'x') ||
(str[1] == 'X'))) {
if ((base == 16) && (*str == '0') && ((str[1] == 'x') || (str[1] == 'X'))) {
str += 2;
}
} else {
260,8 → 238,7
 
while (*str) {
c = *str;
c = (c >= 'a' ? c - 'a' + 10 : (c >= 'A' ? c - 'A' + 10 :
(c <= '9' ? c - '0' : 0xff)));
c = (c >= 'a' ? c - 'a' + 10 : (c >= 'A' ? c - 'A' + 10 : (c <= '9' ? c - '0' : 0xff)));
if (c > base) {
break;
}
280,10 → 257,7
}
if (str == tmpptr) {
/*
* No number was found => first invalid character is the first
* character of the string.
*/
/* no number was found => first invalid character is the first character of the string */
/* FIXME: set errno to EINVAL */
str = nptr;
result = 0;
301,17 → 275,14
}
 
/** Convert initial part of string to long int according to given base.
* The number may begin with an arbitrary number of whitespaces followed by
* optional sign (`+' or `-'). If the base is 0 or 16, the prefix `0x' may be
* inserted and the number will be taken as hexadecimal one. If the base is 0
* and the number begin with a zero, number will be taken as octal one (as with
* base 8). Otherwise the base 0 is taken as decimal.
*
* @param nptr Pointer to string.
* @param endptr If not NULL, function stores here pointer to the first
* invalid character.
* @param base Zero or number between 2 and 36 inclusive.
* @return Result of conversion.
* The number may begin with an arbitrary number of whitespaces followed by optional sign (`+' or `-').
* If the base is 0 or 16, the prefix `0x' may be inserted and the number will be taken as hexadecimal one.
* If the base is 0 and the number begin with a zero, number will be taken as octal one (as with base 8).
* Otherwise the base 0 is taken as decimal.
* @param nptr pointer to string
* @param endptr if not NULL, function stores here pointer to the first invalid character
* @param base zero or number between 2 and 36 inclusive
* @return result of conversion.
*/
long int strtol(const char *nptr, char **endptr, int base)
{
334,17 → 305,14
 
 
/** Convert initial part of string to unsigned long according to given base.
* The number may begin with an arbitrary number of whitespaces followed by
* optional sign (`+' or `-'). If the base is 0 or 16, the prefix `0x' may be
* inserted and the number will be taken as hexadecimal one. If the base is 0
* and the number begin with a zero, number will be taken as octal one (as with
* base 8). Otherwise the base 0 is taken as decimal.
*
* @param nptr Pointer to string.
* @param endptr If not NULL, function stores here pointer to the first
* invalid character
* @param base Zero or number between 2 and 36 inclusive.
* @return Result of conversion.
* The number may begin with an arbitrary number of whitespaces followed by optional sign (`+' or `-').
* If the base is 0 or 16, the prefix `0x' may be inserted and the number will be taken as hexadecimal one.
* If the base is 0 and the number begin with a zero, number will be taken as octal one (as with base 8).
* Otherwise the base 0 is taken as decimal.
* @param nptr pointer to string
* @param endptr if not NULL, function stores here pointer to the first invalid character
* @param base zero or number between 2 and 36 inclusive
* @return result of conversion.
*/
unsigned long strtoul(const char *nptr, char **endptr, int base)
{
385,16 → 353,5
return orig;
}
 
char * strdup(const char *s1)
{
size_t len = strlen(s1) + 1;
void *ret = malloc(len);
 
if (ret == NULL)
return (char *) NULL;
 
return (char *) memcpy(ret, s1, len);
}
 
/** @}
*/