FreeBSD Manual Pages
amathc.h(3) Library Functions Manual amathc.h(3) NAME amathc.h - C functions for manipulating strings and memory SYNOPSIS #include "amathc.h" Data Structures struct texttag Functions void * AllocMemSafe (size_t) Allocate memory and add it to the global memory list. void FreeMemSafe (void *) Deallocate memory from the global memory list. void DetachMemSafe (void *) Detach an allocated memory from the global memory list. void FreeAllSafe () Deallocate all memory in the global memory list. void MemUsage (long *, long *, long *) Get memory usage in the global memory list. int StrLen (const char *string) Get the length of a null terminated string. bool StrIsEqual (const char *s1, const char *s2) Compare two null terminated strings to each other. void MemSet (void *destination, int c0, unsigned int length) Fill block of memory with a constant value. void MemCopy (void *destination, const void *source, unsigned int length) Copy a block of memory, handling overlap. unsigned int AllocAndCopy (char **destination, const char *source) Allocate memory and copy a string into the array. void Untag (char *destination, const char *source, texttag tags[], un- signed int tagcount) DESCRIPTION unsigned int AllocAndCopy (char ** destination, const char * source) Allocate memory and copy a string into the array. Definition at line 40 of file alloccpy.c. 41 { 42 char *i, *s, *d; 43 unsigned int n, size; 44 45 if (source == nullptr) 46 { 47 *destination = nullptr; 48 return 0; 49 } 50 51 i = (char*)source; 52 s = (char*)source; 53 while (*i) 54 i++; 55 56 n = (unsigned int)(i - s + 1); 57 size = n; 58 *destination = AllocMemSafe(size); 59 d = *destination; 60 64 while (n--) 65 *d++ = *s++; 67 68 return size; 69 } void* AllocMemSafe (size_t) Allocate memory and add it to the global memory list. Definition at line 86 of file mem.c. 87 { 88 struct MemoryBlock* newblock; 89 size_t allocsize; 90 91 if (list == nullptr) 92 { 93 list = (struct MemoryList*)ALLOC_MEM(sizeof(struct MemoryList)); 94 if (!list) 95 { 96 alloc_error("list", sizeof(struct MemoryList)); 97 return 0; 98 } 99 100 list->first = nullptr; 101 list->peak = 0; 102 list->size = 0; 103 list->count = 0; 104 } 105 106 #ifdef P64BIT 107 // Align to bytes of 8 108 allocsize = (size + 7) & ~0x07; 109 #else 110 // Align to bytes of 4 111 allocsize = (size + 3) & ~0x03; 112 #endif 113 114 newblock = (struct MemoryBlock*)ALLOC_MEM(sizeof(struct MemoryBlock)); 115 if (!newblock) 116 { 117 alloc_error("block", sizeof(struct MemoryBlock)); 118 return 0; 119 } 120 121 newblock->address = (struct MemoryBlock*)ALLOC_MEM(allocsize); 122 if (!newblock->address) 123 { 124 FREE_MEM(newblock); 125 alloc_error("memory", allocsize); 126 return 0; 127 } 128 129 newblock->size = allocsize; 130 newblock->next = list->first; 131 list->first = newblock; 132 list->size += allocsize; 133 list->count++; 134 135 if (list->size > list->peak) 136 { 137 list->peak = list->size; 138 } 139 140 // Memory allocated 141 return newblock->address; 142 } void DetachMemSafe (void * block) Detach an allocated memory from the global memory list. The memory block is only detached, not deallocated. Definition at line 209 of file mem.c. 210 { 211 RemoveMemSafe(block, false); 212 } void FreeAllSafe () Deallocate all memory in the global memory list. Definition at line 217 of file mem.c. 218 { 219 struct MemoryBlock *current, *next; 220 221 if (list == nullptr) 222 { 223 return; 224 } 225 226 current = list->first; 227 while (current != nullptr) 228 { 229 next = current->next; 230 FREE_MEM(current->address); 231 FREE_MEM(current); 232 current = next; 233 } 234 235 FREE_MEM(list); 236 list = nullptr; 237 } void FreeMemSafe (void *) Deallocate memory from the global memory list. Definition at line 200 of file mem.c. 201 { 202 RemoveMemSafe(block, true); 203 } void MemCopy (void * destination, const void * source, unsigned int length) Copy a block of memory, handling overlap. Definition at line 75 of file memcpy.c. 76 { 77 char* dst = (char*) destination; 78 const char* src = (const char*) source; 79 unsigned int t; 80 81 if (length == 0 || dst == src) // nothing to do 82 return; 83 84 if ((mem_ptr)dst < (mem_ptr)src) 85 { 86 // Copy forward 90 t = (mem_ptr)src; // only need low bits 91 if ((t | (mem_ptr)dst) & wmask) 92 { 93 // Try to align operands. This cannot be done unless the low bits match. 94 if ((t ^ (mem_ptr)dst) & wmask || length < wsize) 95 t = length; 96 else 97 t = wsize - (t & wmask); 98 length -= t; 99 100 TLOOP1(*dst++ = *src++); 101 } 102 103 // Copy whole words, then mop up any trailing bytes. 104 t = length / wsize; 105 TLOOP(*(word *)dst = *(word *)src; src += wsize; dst += wsize); 106 107 t = length & wmask; 108 TLOOP(*dst++ = *src++); 110 } 111 else 112 { 113 // Copy backwards. Otherwise essentially the same. 114 // Alignment works as before, except that it takes 115 // (t&wmask) bytes to align, not wsize-(t&wmask). 116 src += length; 117 dst += length; 118 t = (mem_ptr)src; 119 if ((t | (mem_ptr)dst) & wmask) 120 { 121 if ((t ^ (mem_ptr)dst) & wmask || length <= wsize) 122 t = length; 123 else 124 t &= wmask; 125 length -= t; 126 127 TLOOP1(*--dst = *--src); 128 } 129 130 t = length / wsize; 131 TLOOP(src -= wsize; dst -= wsize; *(word *)dst = *(word *)src); 132 133 t = length & wmask; 134 TLOOP(*--dst = *--src); 135 } 136 } void MemSet (void * destination, int c0, unsigned int length) Fill block of memory with a constant value. Definition at line 56 of file memset.c. 57 { 58 unsigned char* dst = (unsigned char*) dst0; 59 unsigned int t; 60 unsigned int c; 61 62 /* 63 * If not enough words, just fill bytes. A length >= 2 words 64 * guarantees that at least one of them is `complete' after 65 * any necessary alignment. For instance: 66 * 67 * |-----------|-----------|-----------| 68 * |00|01|02|03|04|05|06|07|08|09|0A|00| 69 * ^---------------------^ 70 * dst dst+length-1 71 * 72 * but we use a minimum of 3 here since the overhead of the code 73 * to do word writes is substantial. 74 */ 75 if (length < 3 * wsize) 76 { 77 while (length != 0) 78 { 79 *dst++ = c0; 80 --length; 81 } 82 } 83 84 if ((c = (unsigned char)c0) != 0) 85 { /* Fill the word. */ 86 c = (c << 8) | c; /* u_int is 16 bits. */ 87 #if UINT_MAX > 0xffff 88 c = (c << 16) | c; /* u_int is 32 bits. */ 89 #endif 90 #if UINT_MAX > 0xffffffff 91 c = (c << 32) | c; /* u_int is 64 bits. */ 92 #endif 93 } 94 95 /* Align destination by filling in bytes. */ 96 if ((t = (mem_ptr)dst & wmask) != 0) 97 { 98 t = wsize - t; 99 length -= t; 100 do 101 { 102 *dst++ = c0; 103 } 104 while (--t != 0); 105 } 106 107 /* Fill words. Length was >= 2*words so we know t >= 1 here. */ 108 t = length / wsize; 109 do 110 { 111 *(unsigned int*)dst = c; 112 dst += wsize; 113 } 114 while (--t != 0); 115 116 /* Mop up trailing bytes, if any. */ 117 t = length & wmask; 118 if (t != 0) 119 do 120 { 121 *dst++ = c0; 122 } 123 while (--t != 0); 124 } void MemUsage (long *, long *, long *) Get memory usage in the global memory list. Definition at line 242 of file mem.c. 243 { 244 *blocks = list->count; 245 *size = (long)list->size; 246 *peak = (long)list->peak;; 247 } bool StrIsEqual (const char * s1, const char * s2) Compare two null terminated strings to each other. Definition at line 50 of file strcmp.c. 51 { 52 int r; 53 54 while (*s1 == *s2++) 55 if (*s1++ == ' ') 56 return true; 57 58 r = (*(const unsigned char *)s1 - *(const unsigned char *)(s2 - 1)); 59 60 return r == 0; 61 } int StrLen (const char * string) Get the length of a null terminated string. Definition at line 34 of file strlen.c. 35 { 36 char* i = (char*)string; 37 char* s = i; 38 while (*i) 39 i++; 40 return (int)(i - s); 41 } void Untag (char * destination, const char * source, texttag tags[], un- signed int tagcount) Definition at line 32 of file untag.c. 33 { 34 const char *pos, *tmp, *tag; 35 char* dest; 36 int unsigned i, j, found; 37 38 pos = source; 39 dest = destination; 40 41 while (*pos != ' ') 42 { 43 if (*pos != '#') 44 { 45 (*dest++ = *pos++); 46 } 47 else 48 { 49 // Try to replace tag 50 found = 0; 51 for (i = 0; i < tagcount; i++) 52 { 53 tag = tags[i].tag; 54 tmp = pos; 55 j = 0; 56 while (*tmp != ' ' && *tag != ' ' && *tmp == *tag) 57 { 58 tmp++; 59 tag++; 60 j++; 61 } 62 63 if (j > 1 && *(--tag) == '#') 64 { 65 // Tag found. Now replace. 66 tag = tags[i].text; 67 while ((*dest++ = *tag++)); 68 dest--; 69 pos = tmp; 70 found = 1; 71 break; 72 } 73 } 74 75 if (!found) 76 { 77 (*dest++ = *pos++); 78 } 79 } 80 } 81 *dest = ' '; 82 } HOMEPAGE https://amath.innolan.net/ AUTHORS Written by Carsten Sonne Larsen <cs@innolan.net>. The code in MemSet and MemCopy is derived from software contributed to Berkeley by Mike Hibler and Chris Torek. COPYRIGHT Copyright (c) 2014-2018 Carsten Sonne Larsen <cs@innolan.net> Copyright (c) 2007 The NetBSD Foundation, Inc. Copyright (c) 1990, 1993 The Regents of the University of California SEE ALSO amath(1), amathr(3), amathi(3) August 07 2018 Version 1.8.5 amathc.h(3)
NAME | SYNOPSIS | DESCRIPTION | HOMEPAGE | AUTHORS | COPYRIGHT | SEE ALSO
Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=amathc&sektion=3&manpath=FreeBSD+Ports+15.0>