mirror of
https://github.com/cookiengineer/audacity
synced 2025-11-04 08:04:06 +01:00
384 lines
8.2 KiB
C
384 lines
8.2 KiB
C
/*
|
|
* Copyright 2008 Digital Bazaar, Inc.
|
|
*
|
|
* This file is part of librdfa.
|
|
*
|
|
* librdfa is Free Software, and can be licensed under any of the
|
|
* following three licenses:
|
|
*
|
|
* 1. GNU Lesser General Public License (LGPL) V2.1 or any
|
|
* newer version
|
|
* 2. GNU General Public License (GPL) V2 or any newer version
|
|
* 3. Apache License, V2.0 or any newer version
|
|
*
|
|
* You may not use this file except in compliance with at least one of
|
|
* the above three licenses.
|
|
*
|
|
* See LICENSE-* at the top of this software distribution for more
|
|
* information regarding the details of each license.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with librdfa. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
#include "stdlib.h"
|
|
#include "string.h"
|
|
#include "stdio.h"
|
|
#include "rdfa_utils.h"
|
|
#include "rdfa.h"
|
|
|
|
#define RDFA_WHITESPACE_CHARACTERS " \a\b\t\n\v\f\r"
|
|
|
|
char* rdfa_join_string(const char* prefix, const char* suffix)
|
|
{
|
|
char* rval = NULL;
|
|
size_t prefix_size = strlen(prefix);
|
|
size_t suffix_size = strlen(suffix);
|
|
rval = (char*)malloc(prefix_size + suffix_size + 1);
|
|
|
|
memcpy(rval, prefix, prefix_size);
|
|
memcpy(rval+prefix_size, suffix, suffix_size + 1);
|
|
|
|
|
|
return rval;
|
|
}
|
|
|
|
char* rdfa_n_append_string(
|
|
char* old_string, size_t* string_size,
|
|
const char* suffix, size_t suffix_size)
|
|
{
|
|
char* rval = NULL;
|
|
rval = (char*)realloc(old_string, *string_size + suffix_size + 1);
|
|
memcpy(rval + *string_size, suffix, suffix_size + 1);
|
|
*string_size = *string_size + suffix_size;
|
|
return rval;
|
|
}
|
|
|
|
char* rdfa_replace_string(char* old_string, const char* new_string)
|
|
{
|
|
char* rval = NULL;
|
|
|
|
if(new_string != NULL)
|
|
{
|
|
// free the memory associated with the old string if it exists.
|
|
if(old_string != NULL)
|
|
{
|
|
free(old_string);
|
|
}
|
|
|
|
// copy the new string
|
|
rval = strdup(new_string);
|
|
}
|
|
|
|
return rval;
|
|
}
|
|
|
|
char* rdfa_canonicalize_string(const char* str)
|
|
{
|
|
char* rval = (char*)malloc(sizeof(char) * (strlen(str) + 2));
|
|
char* working_string = NULL;
|
|
char* token = NULL;
|
|
char* wptr = NULL;
|
|
char* offset = rval;
|
|
|
|
working_string = rdfa_replace_string(working_string, str);
|
|
|
|
// split on any whitespace character that we may find
|
|
token = strtok_r(working_string, RDFA_WHITESPACE_CHARACTERS, &wptr);
|
|
while(token != NULL)
|
|
{
|
|
size_t token_length = strlen(token);
|
|
memcpy(offset, token, token_length);
|
|
offset += token_length;
|
|
*offset++ = ' ';
|
|
*offset = '\0';
|
|
|
|
token = strtok_r(NULL, RDFA_WHITESPACE_CHARACTERS, &wptr);
|
|
}
|
|
|
|
if(offset != rval)
|
|
{
|
|
offset--;
|
|
*offset = '\0';
|
|
}
|
|
|
|
free(working_string);
|
|
|
|
return rval;
|
|
}
|
|
|
|
rdfalist* rdfa_create_list(size_t size)
|
|
{
|
|
rdfalist* rval = (rdfalist*)malloc(sizeof(rdfalist));
|
|
|
|
rval->max_items = size;
|
|
rval->num_items = 0;
|
|
rval->items = (rdfalistitem**)malloc(sizeof(rdfalistitem) * rval->max_items);
|
|
|
|
return rval;
|
|
}
|
|
|
|
rdfalist* rdfa_copy_list(rdfalist* list)
|
|
{
|
|
rdfalist* rval = (rdfalist*)malloc(sizeof(rdfalist));
|
|
unsigned int i;
|
|
|
|
// copy the base list variables over
|
|
rval->max_items = list->max_items;
|
|
rval->num_items = list->num_items;
|
|
rval->items = NULL;
|
|
rval->items = (rdfalistitem**)realloc(rval->items, sizeof(void*) * rval->max_items);
|
|
|
|
// copy the data of every list member along with all of the flags
|
|
// for each list member.
|
|
//
|
|
// TODO: Implement the copy for context, if it is needed.
|
|
for(i = 0; i < list->max_items; i++)
|
|
{
|
|
if(i < rval->num_items)
|
|
{
|
|
if(list->items[i]->flags & RDFALIST_FLAG_TEXT)
|
|
{
|
|
rval->items[i] = (rdfalistitem*)malloc(sizeof(rdfalistitem));
|
|
rval->items[i]->data = NULL;
|
|
rval->items[i]->data = (char*)
|
|
rdfa_replace_string((char*)rval->items[i]->data, (const char*)list->items[i]->data);
|
|
rval->items[i]->flags = list->items[i]->flags;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rval->items[i] = NULL;
|
|
}
|
|
}
|
|
|
|
return rval;
|
|
}
|
|
|
|
void rdfa_print_list(rdfalist* list)
|
|
{
|
|
unsigned int i;
|
|
|
|
printf("[ ");
|
|
|
|
for(i = 0; i < list->num_items; i++)
|
|
{
|
|
if(i != 0)
|
|
{
|
|
printf(", ");
|
|
}
|
|
|
|
puts((const char*)list->items[i]->data);
|
|
}
|
|
|
|
printf(" ]\n");
|
|
}
|
|
|
|
void rdfa_free_list(rdfalist* list)
|
|
{
|
|
if(list != NULL)
|
|
{
|
|
unsigned int i;
|
|
for(i = 0; i < list->num_items; i++)
|
|
{
|
|
free(list->items[i]->data);
|
|
free(list->items[i]);
|
|
}
|
|
|
|
free(list->items);
|
|
free(list);
|
|
}
|
|
}
|
|
|
|
void rdfa_push_item(rdfalist* stack, void* data, liflag_t flags)
|
|
{
|
|
rdfa_add_item(stack, data, flags);
|
|
}
|
|
|
|
void* rdfa_pop_item(rdfalist* stack)
|
|
{
|
|
void* rval = NULL;
|
|
|
|
if(stack->num_items > 0)
|
|
{
|
|
rval = stack->items[stack->num_items - 1]->data;
|
|
free(stack->items[stack->num_items - 1]);
|
|
stack->items[stack->num_items - 1] = NULL;
|
|
stack->num_items--;
|
|
}
|
|
|
|
return rval;
|
|
}
|
|
|
|
void rdfa_add_item(rdfalist* list, void* data, liflag_t flags)
|
|
{
|
|
rdfalistitem* item = (rdfalistitem*)malloc(sizeof(rdfalistitem));
|
|
|
|
item->data = NULL;
|
|
|
|
if(flags & RDFALIST_FLAG_CONTEXT)
|
|
{
|
|
item->data = data;
|
|
}
|
|
else
|
|
{
|
|
item->data = (char*)rdfa_replace_string((char*)item->data, (const char*)data);
|
|
}
|
|
|
|
item->flags = flags;
|
|
|
|
if(list->num_items == list->max_items)
|
|
{
|
|
list->max_items = 1 + (list->max_items * 2);
|
|
list->items = (rdfalistitem**)
|
|
realloc(list->items, sizeof(rdfalistitem) * list->max_items);
|
|
}
|
|
|
|
list->items[list->num_items] = item;
|
|
list->num_items++;
|
|
}
|
|
|
|
#ifndef LIBRDFA_IN_RAPTOR
|
|
char** rdfa_create_mapping(size_t elements)
|
|
{
|
|
size_t mapping_size = sizeof(char*) * MAX_URI_MAPPINGS * 2;
|
|
char** mapping = malloc(mapping_size);
|
|
|
|
// only initialize the mapping if it is null.
|
|
if(mapping != NULL)
|
|
{
|
|
memset(mapping, 0, mapping_size);
|
|
}
|
|
|
|
return mapping;
|
|
}
|
|
|
|
char** rdfa_copy_mapping(char** mapping)
|
|
{
|
|
size_t mapping_size = sizeof(char*) * MAX_URI_MAPPINGS * 2;
|
|
char** rval = malloc(mapping_size);
|
|
char** mptr = mapping;
|
|
char** rptr = rval;
|
|
|
|
// initialize the mapping
|
|
memset(rval, 0, mapping_size);
|
|
|
|
// copy each element of the old mapping to the new mapping.
|
|
while(*mptr != NULL)
|
|
{
|
|
*rptr = rdfa_replace_string(*rptr, *mptr);
|
|
rptr++;
|
|
mptr++;
|
|
}
|
|
|
|
return rval;
|
|
}
|
|
|
|
void rdfa_update_mapping(char** mapping, const char* key, const char* value)
|
|
{
|
|
int found = 0;
|
|
char** mptr = mapping;
|
|
|
|
// search the current mapping to see if the namespace
|
|
// prefix exists in the mapping
|
|
while(*mptr != NULL)
|
|
{
|
|
if(strcmp(*mptr, key) == 0)
|
|
{
|
|
mptr++;
|
|
*mptr = rdfa_replace_string(*mptr, value);
|
|
found = 1;
|
|
}
|
|
else
|
|
{
|
|
mptr++;
|
|
}
|
|
mptr++;
|
|
}
|
|
|
|
// if we made it through the entire URI mapping and the key was not
|
|
// found, create a new key-value pair.
|
|
if(!found)
|
|
{
|
|
*mptr = rdfa_replace_string(*mptr, key);
|
|
mptr++;
|
|
*mptr = rdfa_replace_string(*mptr, value);
|
|
}
|
|
}
|
|
|
|
const char* rdfa_get_mapping(char** mapping, const char* key)
|
|
{
|
|
const char* rval = NULL;
|
|
char** mptr = mapping;
|
|
|
|
// search the current mapping to see if the key exists in the mapping.
|
|
while(*mptr != NULL)
|
|
{
|
|
if(strcmp(*mptr, key) == 0)
|
|
{
|
|
mptr++;
|
|
rval = *mptr;
|
|
}
|
|
else
|
|
{
|
|
mptr++;
|
|
}
|
|
mptr++;
|
|
}
|
|
|
|
return rval;
|
|
}
|
|
|
|
void rdfa_next_mapping(char** mapping, char** key, char** value)
|
|
{
|
|
*key = NULL;
|
|
*value = NULL;
|
|
|
|
if(*mapping != NULL)
|
|
{
|
|
*key = *mapping++;
|
|
*value = *mapping++;
|
|
}
|
|
}
|
|
|
|
void rdfa_print_mapping(char** mapping)
|
|
{
|
|
char** mptr = mapping;
|
|
printf("{\n");
|
|
while(*mptr != NULL)
|
|
{
|
|
char* key;
|
|
char* value;
|
|
key = *mptr++;
|
|
value = *mptr++;
|
|
|
|
printf(" %s : %s", key, value);
|
|
if(*mptr != NULL)
|
|
{
|
|
printf(",\n");
|
|
}
|
|
else
|
|
{
|
|
printf("\n");
|
|
}
|
|
}
|
|
printf("}\n");
|
|
}
|
|
|
|
void rdfa_free_mapping(char** mapping)
|
|
{
|
|
char** mptr = mapping;
|
|
|
|
if(mapping != NULL)
|
|
{
|
|
// free all of the memory in the mapping
|
|
while(*mptr != NULL)
|
|
{
|
|
free(*mptr);
|
|
mptr++;
|
|
}
|
|
|
|
free(mapping);
|
|
}
|
|
}
|
|
#endif
|