PerformanceTests/JetStream2/wasm/TSF/tsf_ra_type_man.c - WebKit - Git at Google

 /*
  * Copyright (C) 2004, 2005 Filip Pizlo. All rights reserved.
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY FILIP PIZLO ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL FILIP PIZLO OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */

 #include "tsf_internal.h"

 tsf_ra_type_man_t *tsf_ra_type_man_create(void) {
     tsf_ra_type_man_t *result=malloc(sizeof(tsf_ra_type_man_t));
     result->out_map=tsf_st_init_typetable();
     if (result->out_map==NULL) {
 	return NULL;
     }
     result->in_map=tsf_st_init_numtable();
     if (result->in_map==NULL) {
 	tsf_st_free_table(result->out_map);
 	return NULL;
     }
     result->type_codes=NULL;
     return result;
 }

 void tsf_ra_type_man_destroy(tsf_ra_type_man_t *man) {
     tsf_ra_tc_node_t *n;
     tsf_st_iterator iter;

     n=man->type_codes;
     while (n!=NULL) {
 	tsf_ra_tc_node_t *victim=n;
 	n=n->next;
 	free(victim);
     }

     for (tsf_st_iterator_init(man->out_map,&iter);
 	 tsf_st_iterator_valid(&iter);
 	 tsf_st_iterator_next(&iter)) {
 	tsf_type_t *type;
 	tsf_ra_type_info_t *info;
 	tsf_st_iterator_get(&iter,(char**)&type,(void*)&info);
 	tsf_type_destroy(type);
 	free(info);
     }

     tsf_st_free_table(man->in_map);
     tsf_st_free_table(man->out_map);
 }

 tsf_bool_t tsf_ra_type_man_insert(tsf_ra_type_man_t *man,
 				  tsf_type_t *type,
 				  uint32_t type_code,
 				  uint64_t ref_count) {
     tsf_ra_type_info_t *info;

     info=malloc(sizeof(tsf_ra_type_info_t));
     if (info==NULL) {
         tsf_set_errno("Could not malloc tsf_ra_type_info_t");
         return tsf_false;
     }

     info->type_code=type_code;
     info->ref_count=ref_count;

     type=tsf_type_dup(type);

     if (tsf_st_add_direct(man->out_map,
                           (char*)type,
                           info)<0) {
         tsf_set_errno("Could not tsf_st_add_direct()");
         tsf_type_destroy(type);
         free(info);
         return tsf_false;
     }

     if (tsf_st_add_direct(man->in_map,
                           (void*)(uintptr_t)type_code,
                           type)) {
         tsf_type_t *to_delete;
         tsf_set_errno("Could not tsf_st_add_direct()");
         to_delete = type;
         tsf_st_delete(man->out_map,
                       (char**)&to_delete,
                       NULL);
         tsf_type_destroy(type);
         free(info);
         return tsf_false;
     }

     return tsf_true;
 }

 void tsf_ra_type_man_remove(tsf_ra_type_man_t *man,
 			    tsf_type_t *type) {
     tsf_ra_type_info_t *info;
     uintptr_t type_code;
     tsf_ra_tc_node_t *n;
     tsf_type_t *type_to_delete;

     type_to_delete = type;
     tsf_assert(tsf_st_delete(man->out_map,
                              (char**)&type_to_delete,
                              (void**)&info));

     type_code = info->type_code;

     tsf_assert(tsf_st_delete(man->in_map,
                              (char**)&type_code,
                              NULL));

     n=malloc(sizeof(tsf_ra_tc_node_t));
     if (n!=NULL) {
         n->next=man->type_codes;
         n->type_code=type_code;
         man->type_codes=n;
     } /* else we would signal an error but that would be bad so we instead
        * just leak this type code. */

     tsf_type_destroy(type);
     free(info);
 }

 /* maybe this shouldn't be setting the error when the type isn't
    found?  afterall, all uses of this function currently set
    their own error code. */
 tsf_type_t *tsf_ra_type_man_find(tsf_ra_type_man_t *man,
 				 uint32_t type_code) {
     tsf_type_t *type;

     if (!tsf_st_lookup(man->in_map,
                        (char*)(uintptr_t)type_code,
                        (void**)&type)) {
 	tsf_set_error(TSF_E_ELE_NOT_FOUND,
 		      "Element not found in tsf_ra_type_man_find()");
         return NULL;
     }

     return type;
 }

 tsf_bool_t tsf_ra_type_man_has_type(tsf_ra_type_man_t *man,
 				    tsf_type_t *type) {
     if (tsf_st_lookup(man->out_map,
                       (char*)type,
                       NULL)) {
         return tsf_true;
     }

     return tsf_false;
 }

 /* call this only once you know that you know about the type. */
 uint32_t tsf_ra_type_man_get_type_code(tsf_ra_type_man_t *man,
 				       tsf_type_t *type) {
     tsf_ra_type_info_t *info;

     tsf_assert(tsf_st_lookup(man->out_map,
                              (char*)type,
                              (void**)&info));

     return info->type_code;
 }

 tsf_bool_t tsf_ra_type_man_get_reference(tsf_ra_type_man_t *man,
 					 tsf_type_t *type) {
     tsf_ra_type_info_t *info;

     if (!tsf_st_lookup(man->out_map,
                        (char*)type,
                        (void**)&info)) {
         uint32_t type_code;
         tsf_ra_tc_node_t *n=man->type_codes;

         if (n==NULL) {
             /* if there are none in the free list, then that means
              * that all contiguous type codes are used up to the
              * number of live type codes.  hence we can use the
              * num_entries field on either hash table as the next
              * type code. */
             type_code=man->out_map->num_entries;
         } else {
             type_code=n->type_code;
             man->type_codes=n->next;
         }

         if (!tsf_ra_type_man_insert(man,
 				    type,
 				    type_code,
 				    1)) {
             man->type_codes=n;
             return tsf_false;
         }

         if (n!=NULL) {
             free(n);
         }

         return tsf_true;
     }

     info->ref_count++;

     return tsf_true;
 }

 void tsf_ra_type_man_remove_reference(tsf_ra_type_man_t *man,
 				      tsf_type_t *type) {
     tsf_ra_type_info_t *info;

     tsf_assert(tsf_st_lookup(man->out_map,
                              (char*)type,
                              (void**)&info));

     if (--info->ref_count==0) {
         tsf_ra_type_man_remove(man,type);
     }
 }

 uint32_t tsf_ra_type_man_num_types(tsf_ra_type_man_t *man) {
     return man->out_map->num_entries;
 }

 tsf_bool_t tsf_ra_type_man_has_buf_types(tsf_ra_type_man_t *man,
 					 tsf_buffer_t *buf) {
     uint32_t i;

     if (!tsf_ra_type_man_has_type(man,buf->type)) {
         return tsf_false;
     }

     for (i=0;
          i<tsf_type_in_map_get_num_types(buf->types);
          ++i) {
         if (!tsf_ra_type_man_has_type(man,
                  tsf_type_in_map_get_type(buf->types,i))) {
             return tsf_false;
         }
     }

     return tsf_true;
 }

 tsf_bool_t tsf_ra_type_man_get_buf_references(tsf_ra_type_man_t *man,
 					      tsf_buffer_t *buf) {
     uint32_t i;

     if (!tsf_ra_type_man_get_reference(man,buf->type)) {
         return tsf_false;
     }

     for (i=0;
          i<tsf_type_in_map_get_num_types(buf->types);
          ++i) {
         if (!tsf_ra_type_man_get_reference(man,
                  tsf_type_in_map_get_type(buf->types,i))) {
             uint32_t j;
             for (j=0;j<i;++j) {
                 tsf_ra_type_man_remove_reference(man,
                     tsf_type_in_map_get_type(buf->types,j));
             }
             tsf_ra_type_man_remove_reference(man,buf->type);
             return tsf_false;
         }
     }

     return tsf_true;
 }

 void tsf_ra_type_man_remove_buf_references(tsf_ra_type_man_t *man,
 					   tsf_buffer_t *buf) {
     uint32_t i;

     tsf_ra_type_man_remove_reference(man,buf->type);

     for (i=0;
          i<tsf_type_in_map_get_num_types(buf->types);
          ++i) {
         tsf_ra_type_man_remove_reference(man,
             tsf_type_in_map_get_type(buf->types,i));
     }
 }

 tsf_ra_type_man_t *tsf_ra_type_man_read(tsf_reader_t reader,
 					void *arg) {
     tsf_ra_type_man_t *result;
     uint32_t num_types;
     uint32_t type_code;
     uint32_t *type_codes;
     uint64_t ref_count;
     uint32_t n,i;
     tsf_bool_t tres;

     if (!reader(arg,&num_types,sizeof(num_types))) {
 	return NULL;
     }

     num_types=ntohl(num_types);

     result=tsf_ra_type_man_create();
     if (result==NULL) {
 	return NULL;
     }

     type_codes=malloc(sizeof(uint32_t)*num_types);
     if (type_codes==NULL) {
 	tsf_set_errno("Could not map type code array");
 	tsf_ra_type_man_destroy(result);
 	return NULL;
     }

     for (n=num_types;n-->0;) {
 	tsf_type_t *type;

 	if (!reader(arg,&type_code,sizeof(type_code))) {
 	    free(type_codes);
 	    tsf_ra_type_man_destroy(result);
 	    return NULL;
 	}

         type_code=ntohl(type_code);
 	type_codes[n]=type_code;

 	if (!reader(arg,&ref_count,sizeof(ref_count))) {
 	    free(type_codes);
 	    tsf_ra_type_man_destroy(result);
 	    return NULL;
 	}

 	ref_count=ntohll(ref_count);

 	type=tsf_type_read(reader,arg,NULL);
 	if (type==NULL) {
 	    free(type_codes);
 	    tsf_ra_type_man_destroy(result);
 	    return NULL;
 	}

 	tres=tsf_ra_type_man_insert(result,
 				    type,
 				    type_code,
 				    ref_count);

 	tsf_type_destroy(type);

 	if (!tres) {
 	    free(type_codes);
 	    tsf_ra_type_man_destroy(result);
 	    return NULL;
 	}
     }

     tsf_ui32_sort(type_codes,num_types);

     if (num_types>0) {
 	for (i=0;i<num_types-1;++i) {
 	    tsf_assert(type_codes[i]<type_codes[i+1]);

 	    for (type_code=type_codes[i]+1;
 		 type_code<type_codes[i+1];
 		 ++type_code) {
 		tsf_ra_tc_node_t *n=malloc(sizeof(tsf_ra_tc_node_t));
 		if (n==NULL) {
 		    free(type_codes);
 		    tsf_ra_type_man_destroy(result);
 		    return NULL;
 		}

 		n->next=result->type_codes;
 		n->type_code=type_code;
 		result->type_codes=n;
 	    }
 	}
     }

     free(type_codes);

     return result;
 }

 tsf_bool_t tsf_ra_type_man_write(tsf_ra_type_man_t *man,
 				 tsf_writer_t writer,
 				 void *arg) {
     uint32_t num_types;
     tsf_st_iterator iter;

     num_types=htonl(man->out_map->num_entries);
     if (!writer(arg,&num_types,sizeof(num_types))) {
 	return tsf_false;
     }

     for (tsf_st_iterator_init(man->out_map,&iter);
 	 tsf_st_iterator_valid(&iter);
 	 tsf_st_iterator_next(&iter)) {
 	tsf_type_t *type;
 	tsf_ra_type_info_t *info;
 	uint32_t type_code;
 	uint64_t ref_count;
 	tsf_st_iterator_get(&iter,(char**)&type,(void*)&info);
 	type_code=htonl(info->type_code);
 	ref_count=htonll(info->ref_count);
 	if (!writer(arg,&type_code,sizeof(type_code))) {
 	    return tsf_false;
 	}
 	if (!writer(arg,&ref_count,sizeof(ref_count))) {
 	    return tsf_false;
 	}
 	if (!tsf_type_write(type,writer,arg)) {
 	    return tsf_false;
 	}
     }

     return tsf_true;
 }

 uint32_t tsf_ra_type_man_get_type_code_free_list_size(tsf_ra_type_man_t *man) {
     uint32_t ret=0;
     tsf_ra_tc_node_t *cur;

     for (cur=man->type_codes;
          cur!=NULL;
          cur=cur->next) {
         ++ret;
     }

     return ret;
 }
	/*
	* Copyright (C) 2004, 2005 Filip Pizlo. All rights reserved.
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions
	* are met:
	* 1. Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	* 2. Redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in the
	* documentation and/or other materials provided with the distribution.
	*
	* THIS SOFTWARE IS PROVIDED BY FILIP PIZLO ``AS IS'' AND ANY
	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL FILIP PIZLO OR
	* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
	* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
	* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
	* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*/

	#include "tsf_internal.h"

	tsf_ra_type_man_t *tsf_ra_type_man_create(void) {
	tsf_ra_type_man_t *result=malloc(sizeof(tsf_ra_type_man_t));
	result->out_map=tsf_st_init_typetable();
	if (result->out_map==NULL) {
	return NULL;
	}
	result->in_map=tsf_st_init_numtable();
	if (result->in_map==NULL) {
	tsf_st_free_table(result->out_map);
	return NULL;
	}
	result->type_codes=NULL;
	return result;
	}

	void tsf_ra_type_man_destroy(tsf_ra_type_man_t *man) {
	tsf_ra_tc_node_t *n;
	tsf_st_iterator iter;

	n=man->type_codes;
	while (n!=NULL) {
	tsf_ra_tc_node_t *victim=n;
	n=n->next;
	free(victim);
	}

	for (tsf_st_iterator_init(man->out_map,&iter);
	tsf_st_iterator_valid(&iter);
	tsf_st_iterator_next(&iter)) {
	tsf_type_t *type;
	tsf_ra_type_info_t *info;
	tsf_st_iterator_get(&iter,(char*)&type,(void)&info);
	tsf_type_destroy(type);
	free(info);
	}

	tsf_st_free_table(man->in_map);
	tsf_st_free_table(man->out_map);
	}

	tsf_bool_t tsf_ra_type_man_insert(tsf_ra_type_man_t *man,
	tsf_type_t *type,
	uint32_t type_code,
	uint64_t ref_count) {
	tsf_ra_type_info_t *info;

	info=malloc(sizeof(tsf_ra_type_info_t));
	if (info==NULL) {
	tsf_set_errno("Could not malloc tsf_ra_type_info_t");
	return tsf_false;
	}

	info->type_code=type_code;
	info->ref_count=ref_count;

	type=tsf_type_dup(type);

	if (tsf_st_add_direct(man->out_map,
	(char*)type,
	info)<0) {
	tsf_set_errno("Could not tsf_st_add_direct()");
	tsf_type_destroy(type);
	free(info);
	return tsf_false;
	}

	if (tsf_st_add_direct(man->in_map,
	(void*)(uintptr_t)type_code,
	type)) {
	tsf_type_t *to_delete;
	tsf_set_errno("Could not tsf_st_add_direct()");
	to_delete = type;
	tsf_st_delete(man->out_map,
	(char**)&to_delete,
	NULL);
	tsf_type_destroy(type);
	free(info);
	return tsf_false;
	}

	return tsf_true;
	}

	void tsf_ra_type_man_remove(tsf_ra_type_man_t *man,
	tsf_type_t *type) {
	tsf_ra_type_info_t *info;
	uintptr_t type_code;
	tsf_ra_tc_node_t *n;
	tsf_type_t *type_to_delete;

	type_to_delete = type;
	tsf_assert(tsf_st_delete(man->out_map,
	(char**)&type_to_delete,
	(void**)&info));

	type_code = info->type_code;

	tsf_assert(tsf_st_delete(man->in_map,
	(char**)&type_code,
	NULL));

	n=malloc(sizeof(tsf_ra_tc_node_t));
	if (n!=NULL) {
	n->next=man->type_codes;
	n->type_code=type_code;
	man->type_codes=n;
	} /* else we would signal an error but that would be bad so we instead
	* just leak this type code. */

	tsf_type_destroy(type);
	free(info);
	}

	/* maybe this shouldn't be setting the error when the type isn't
	found? afterall, all uses of this function currently set
	their own error code. */
	tsf_type_t tsf_ra_type_man_find(tsf_ra_type_man_t man,
	uint32_t type_code) {
	tsf_type_t *type;

	if (!tsf_st_lookup(man->in_map,
	(char*)(uintptr_t)type_code,
	(void**)&type)) {
	tsf_set_error(TSF_E_ELE_NOT_FOUND,
	"Element not found in tsf_ra_type_man_find()");
	return NULL;
	}

	return type;
	}

	tsf_bool_t tsf_ra_type_man_has_type(tsf_ra_type_man_t *man,
	tsf_type_t *type) {
	if (tsf_st_lookup(man->out_map,
	(char*)type,
	NULL)) {
	return tsf_true;
	}

	return tsf_false;
	}

	/* call this only once you know that you know about the type. */
	uint32_t tsf_ra_type_man_get_type_code(tsf_ra_type_man_t *man,
	tsf_type_t *type) {
	tsf_ra_type_info_t *info;

	tsf_assert(tsf_st_lookup(man->out_map,
	(char*)type,
	(void**)&info));

	return info->type_code;
	}

	tsf_bool_t tsf_ra_type_man_get_reference(tsf_ra_type_man_t *man,
	tsf_type_t *type) {
	tsf_ra_type_info_t *info;

	if (!tsf_st_lookup(man->out_map,
	(char*)type,
	(void**)&info)) {
	uint32_t type_code;
	tsf_ra_tc_node_t *n=man->type_codes;

	if (n==NULL) {
	/* if there are none in the free list, then that means
	* that all contiguous type codes are used up to the
	* number of live type codes. hence we can use the
	* num_entries field on either hash table as the next
	* type code. */
	type_code=man->out_map->num_entries;
	} else {
	type_code=n->type_code;
	man->type_codes=n->next;
	}

	if (!tsf_ra_type_man_insert(man,
	type,
	type_code,
	1)) {
	man->type_codes=n;
	return tsf_false;
	}

	if (n!=NULL) {
	free(n);
	}

	return tsf_true;
	}

	info->ref_count++;

	return tsf_true;
	}

	void tsf_ra_type_man_remove_reference(tsf_ra_type_man_t *man,
	tsf_type_t *type) {
	tsf_ra_type_info_t *info;

	tsf_assert(tsf_st_lookup(man->out_map,
	(char*)type,
	(void**)&info));

	if (--info->ref_count==0) {
	tsf_ra_type_man_remove(man,type);
	}
	}

	uint32_t tsf_ra_type_man_num_types(tsf_ra_type_man_t *man) {
	return man->out_map->num_entries;
	}

	tsf_bool_t tsf_ra_type_man_has_buf_types(tsf_ra_type_man_t *man,
	tsf_buffer_t *buf) {
	uint32_t i;

	if (!tsf_ra_type_man_has_type(man,buf->type)) {
	return tsf_false;
	}

	for (i=0;
	i<tsf_type_in_map_get_num_types(buf->types);
	++i) {
	if (!tsf_ra_type_man_has_type(man,
	tsf_type_in_map_get_type(buf->types,i))) {
	return tsf_false;
	}
	}

	return tsf_true;
	}

	tsf_bool_t tsf_ra_type_man_get_buf_references(tsf_ra_type_man_t *man,
	tsf_buffer_t *buf) {
	uint32_t i;

	if (!tsf_ra_type_man_get_reference(man,buf->type)) {
	return tsf_false;
	}

	for (i=0;
	i<tsf_type_in_map_get_num_types(buf->types);
	++i) {
	if (!tsf_ra_type_man_get_reference(man,
	tsf_type_in_map_get_type(buf->types,i))) {
	uint32_t j;
	for (j=0;j<i;++j) {
	tsf_ra_type_man_remove_reference(man,
	tsf_type_in_map_get_type(buf->types,j));
	}
	tsf_ra_type_man_remove_reference(man,buf->type);
	return tsf_false;
	}
	}

	return tsf_true;
	}

	void tsf_ra_type_man_remove_buf_references(tsf_ra_type_man_t *man,
	tsf_buffer_t *buf) {
	uint32_t i;

	tsf_ra_type_man_remove_reference(man,buf->type);

	for (i=0;
	i<tsf_type_in_map_get_num_types(buf->types);
	++i) {
	tsf_ra_type_man_remove_reference(man,
	tsf_type_in_map_get_type(buf->types,i));
	}
	}

	tsf_ra_type_man_t *tsf_ra_type_man_read(tsf_reader_t reader,
	void *arg) {
	tsf_ra_type_man_t *result;
	uint32_t num_types;
	uint32_t type_code;
	uint32_t *type_codes;
	uint64_t ref_count;
	uint32_t n,i;
	tsf_bool_t tres;

	if (!reader(arg,&num_types,sizeof(num_types))) {
	return NULL;
	}

	num_types=ntohl(num_types);

	result=tsf_ra_type_man_create();
	if (result==NULL) {
	return NULL;
	}

	type_codes=malloc(sizeof(uint32_t)*num_types);
	if (type_codes==NULL) {
	tsf_set_errno("Could not map type code array");
	tsf_ra_type_man_destroy(result);
	return NULL;
	}

	for (n=num_types;n-->0;) {
	tsf_type_t *type;

	if (!reader(arg,&type_code,sizeof(type_code))) {
	free(type_codes);
	tsf_ra_type_man_destroy(result);
	return NULL;
	}

	type_code=ntohl(type_code);
	type_codes[n]=type_code;

	if (!reader(arg,&ref_count,sizeof(ref_count))) {
	free(type_codes);
	tsf_ra_type_man_destroy(result);
	return NULL;
	}

	ref_count=ntohll(ref_count);

	type=tsf_type_read(reader,arg,NULL);
	if (type==NULL) {
	free(type_codes);
	tsf_ra_type_man_destroy(result);
	return NULL;
	}

	tres=tsf_ra_type_man_insert(result,
	type,
	type_code,
	ref_count);

	tsf_type_destroy(type);

	if (!tres) {
	free(type_codes);
	tsf_ra_type_man_destroy(result);
	return NULL;
	}
	}

	tsf_ui32_sort(type_codes,num_types);

	if (num_types>0) {
	for (i=0;i<num_types-1;++i) {
	tsf_assert(type_codes[i]<type_codes[i+1]);

	for (type_code=type_codes[i]+1;
	type_code<type_codes[i+1];
	++type_code) {
	tsf_ra_tc_node_t *n=malloc(sizeof(tsf_ra_tc_node_t));
	if (n==NULL) {
	free(type_codes);
	tsf_ra_type_man_destroy(result);
	return NULL;
	}

	n->next=result->type_codes;
	n->type_code=type_code;
	result->type_codes=n;
	}
	}
	}

	free(type_codes);

	return result;
	}

	tsf_bool_t tsf_ra_type_man_write(tsf_ra_type_man_t *man,
	tsf_writer_t writer,
	void *arg) {
	uint32_t num_types;
	tsf_st_iterator iter;

	num_types=htonl(man->out_map->num_entries);
	if (!writer(arg,&num_types,sizeof(num_types))) {
	return tsf_false;
	}

	for (tsf_st_iterator_init(man->out_map,&iter);
	tsf_st_iterator_valid(&iter);
	tsf_st_iterator_next(&iter)) {
	tsf_type_t *type;
	tsf_ra_type_info_t *info;
	uint32_t type_code;
	uint64_t ref_count;
	tsf_st_iterator_get(&iter,(char*)&type,(void)&info);
	type_code=htonl(info->type_code);
	ref_count=htonll(info->ref_count);
	if (!writer(arg,&type_code,sizeof(type_code))) {
	return tsf_false;
	}
	if (!writer(arg,&ref_count,sizeof(ref_count))) {
	return tsf_false;
	}
	if (!tsf_type_write(type,writer,arg)) {
	return tsf_false;
	}
	}

	return tsf_true;
	}

	uint32_t tsf_ra_type_man_get_type_code_free_list_size(tsf_ra_type_man_t *man) {
	uint32_t ret=0;
	tsf_ra_tc_node_t *cur;

	for (cur=man->type_codes;
	cur!=NULL;
	cur=cur->next) {
	++ret;
	}

	return ret;
	}