Esempio n. 1
0
kim_error kim_string_create_from_buffer (kim_string *out_string, 
                                         const char *in_buffer, 
                                         kim_count   in_length)
{
    kim_error err = kim_library_init ();
    kim_string string = NULL;
    
    if (!err && !out_string) { err = check_error (KIM_NULL_PARAMETER_ERR); }
    if (!err && !in_buffer ) { err = check_error (KIM_NULL_PARAMETER_ERR); }
    
    if (!err) {
        string = calloc (in_length + 1, sizeof (char *));
        if (!string) { err = check_error (KIM_OUT_OF_MEMORY_ERR); }
    }
    
    if (!err) {
        memcpy ((char *) string, in_buffer, in_length * sizeof (char));
        *out_string = string;
        string = NULL;
    }
    
    kim_string_free (&string);
    
    return check_error (err);
}
Esempio n. 2
0
kim_error kim_string_copy (kim_string *out_string, 
                           kim_string  in_string)
{
    kim_error err = kim_library_init ();
    kim_string string = NULL;
    
    if (!err && !out_string) { err = check_error (KIM_NULL_PARAMETER_ERR); }
    if (!err && !in_string ) { err = check_error (KIM_NULL_PARAMETER_ERR); }
    
    if (!err) {
        if (in_string[0]) {
            string = calloc (strlen (in_string) + 1, sizeof (char *));
            if (!string) { err = check_error (KIM_OUT_OF_MEMORY_ERR); }
            
            if (!err) {
                strncpy ((char *) string, in_string, strlen (in_string) + 1);
            }
        } else {
            string = kim_empty_string;
        }
    }
    
    if (!err) {
        *out_string = string;
        string = NULL;
    }
    
    kim_string_free (&string);
    
    return check_error (err);
}
Esempio n. 3
0
kim_error kim_string_create_from_format_va (kim_string *out_string, 
                                            kim_string  in_format,
                                            va_list     in_args)
{
    kim_error err = kim_library_init ();
    kim_string string = NULL;
    
    if (!err && !out_string) { err = check_error (KIM_NULL_PARAMETER_ERR); }
    if (!err && !in_format ) { err = check_error (KIM_NULL_PARAMETER_ERR); }
    
    if (!err) {
        err = kim_string_create_from_format_va_retcode (&string, 
                                                        in_format, 
                                                        in_args);
    }
    
    if (!err) {
        *out_string = string;
        string = NULL;
    }
    
    if (string) { kim_string_free (&string); }
    
    return check_error (err);
}
Esempio n. 4
0
kim_error kim_string_create_for_last_error (kim_string *out_string,
                                            kim_error   in_error)
{
    kim_error err = kim_library_init ();

    err = kim_string_copy (out_string, kim_error_message (in_error));

    return check_error (err);
}
Esempio n. 5
0
kim_error kim_string_create_from_format_va_retcode (kim_string *out_string, 
                                                    kim_string  in_format,
                                                    va_list     in_args)
{
    kim_error err = kim_library_init ();
    
    int count = vasprintf ((char **) out_string, in_format, in_args);
    if (count < 0) { err = check_error (KIM_OUT_OF_MEMORY_ERR); }
    
    return err;
}
Esempio n. 6
0
kim_error kim_string_create_from_format (kim_string *out_string, 
                                         kim_string  in_format,
                                         ...)
{
    kim_error err = kim_library_init ();
    va_list args;
    
    va_start (args, in_format);
    err = kim_string_create_from_format_va (out_string, in_format, args);
    va_end (args);
    
    return check_error (err);    
}
Esempio n. 7
0
static inline kim_error kim_identity_allocate (kim_identity *out_identity)
{
    kim_error err = kim_library_init ();
    kim_identity identity = NULL;

    if (!err && !out_identity) { err = check_error (KIM_NULL_PARAMETER_ERR); }

    if (!err) {
        identity = malloc (sizeof (*identity));
        if (!identity) { err = KIM_OUT_OF_MEMORY_ERR; }
    }

    if (!err) {
        *identity = kim_identity_initializer;
        *out_identity = identity;
        identity = NULL;
    }

    kim_identity_free (&identity);

    return check_error (err);
}
Esempio n. 8
0
static inline kim_error kim_options_allocate (kim_options *out_options)
{
    kim_error err = kim_library_init ();
    kim_options options = NULL;
    
    if (!err && !out_options) { err = check_error (KIM_NULL_PARAMETER_ERR); }
    
    if (!err) {
        options = malloc (sizeof (*options));
        if (!options) { err = KIM_OUT_OF_MEMORY_ERR; }
    }
    
    if (!err) {
        *options = kim_options_initializer;
        *out_options = options;
        options = NULL;
    }
    
    kim_options_free (&options);
    
    return check_error (err);    
}