Debian Codegraph @

src/fcml_env_int.c

raw
1 /*
2 * FCML - Free Code Manipulation Library.
3 * Copyright (C) 2010-2020 Slawomir Wojtasiak
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18 */
19
20 #include "fcml_env_int.h"
21
22 #include <fcml_env.h>
23 #include <ctype.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <stdarg.h>
27 #include <stdio.h>
28
29 static void* default_memory_alloc(fcml_usize size) {
30 return malloc((fcml_usize) size);
31 }
32
33 static void* default_memory_realloc(fcml_ptr ptr, fcml_usize size) {
34 return realloc(ptr, (fcml_usize) size);
35 }
36
37 static void default_memory_free(fcml_ptr memory_block) {
38 free(memory_block);
39 }
40
41 static fcml_fp_env_memory_alloc_handler memory_alloc = default_memory_alloc;
42 static fcml_fp_env_memory_realloc_handler memory_realloc =
43 default_memory_realloc;
44 static fcml_fp_env_memory_free_handler memory_free = default_memory_free;
45
46 fcml_fp_env_memory_alloc_handler LIB_CALL fcml_fn_env_register_memory_alloc_handler(
47 fcml_fp_env_memory_alloc_handler handler) {
48 fcml_fp_env_memory_alloc_handler tmp = memory_alloc;
49 memory_alloc = handler;
50 return tmp;
51 }
52
53 fcml_fp_env_memory_realloc_handler LIB_CALL fcml_fn_env_register_memory_realloc_handler(
54 fcml_fp_env_memory_realloc_handler handler) {
55 fcml_fp_env_memory_realloc_handler tmp = memory_realloc;
56 memory_realloc = handler;
57 return tmp;
58 }
59
60 fcml_fp_env_memory_free_handler LIB_CALL fcml_fn_env_register_memory_free_handler(
61 fcml_fp_env_memory_free_handler handler) {
62 fcml_fp_env_memory_free_handler tmp = memory_free;
63 memory_free = handler;
64 return tmp;
65 }
66
67 fcml_ptr fcml_fn_env_memory_alloc_clear(fcml_usize size) {
68 fcml_ptr ptr = fcml_fn_env_memory_alloc(size);
69 if (ptr) {
70 fcml_fn_env_memory_clear(ptr, size);
71 }
72 return ptr;
73 }
74
75 fcml_ptr fcml_fn_env_memory_alloc(fcml_usize size) {
76 return memory_alloc(size);
77 }
78
79 fcml_ptr fcml_fn_env_memory_realloc(fcml_ptr ptr, fcml_usize size) {
80 return memory_realloc(ptr, size);
81 }
82
83 void fcml_fn_env_memory_copy(fcml_ptr dest, const fcml_ptr src,
84 fcml_usize len) {
85 memcpy(dest, src, (fcml_usize) len);
86 }
87
88 void fcml_fn_env_memory_clear(fcml_ptr src, fcml_usize len) {
89 memset(src, 0, (fcml_usize) len);
90 }
91
92 fcml_bool fcml_fn_env_memory_cmp(const fcml_ptr src1,
93 const fcml_ptr src2, fcml_usize len) {
94 return strncmp((char*) src1, (char*) src2, len) == 0 ?
95 FCML_TRUE :
96 FCML_FALSE;
97 }
98
99 void fcml_fn_env_memory_free(fcml_ptr ptr) {
100 memory_free(ptr);
101 }
102
103 fcml_string fcml_fn_env_str_strldup(const fcml_string str, fcml_usize size) {
104 fcml_string new_str = (fcml_string) fcml_fn_env_memory_alloc(size + 1);
105 if (new_str) {
106 memcpy(new_str, str, (fcml_usize) size);
107 new_str[size] = '\0';
108 }
109 return new_str;
110 }
111
112 fcml_bool fcml_fn_env_str_strblank(const fcml_string str) {
113 fcml_usize len = fcml_fn_env_str_strlen(str);
114 fcml_int i;
115 for (i = 0; i < len; i++) {
116 if (!isspace(str[i])) {
117 return FCML_FALSE;
118 }
119 }
120 return FCML_TRUE;
121 }
122
123 fcml_usize fcml_fn_env_str_strlen(const fcml_string str) {
124 return (fcml_usize) strlen(str);
125 }
126
127 void fcml_fn_env_str_strcpy( fcml_string dst, const fcml_string src) {
128 strcpy(dst, src);
129 }
130
131 fcml_bool fcml_fn_env_str_strcmp(const fcml_string src1,
132 const fcml_string src2) {
133 return !strcmp(src1, src2);
134 }
135
136 void fcml_fn_env_str_strncpy( fcml_string dst, const fcml_string src,
137 fcml_usize len) {
138 strncpy(dst, src, (fcml_usize) len);
139 }
140
141 fcml_string fcml_fn_env_str_strdup(const fcml_string str) {
142 fcml_usize size = (fcml_usize) (strlen(str) + 1);
143 fcml_string new_str = (fcml_string) fcml_fn_env_memory_alloc(size);
144 if (new_str) {
145 memcpy(new_str, str, (fcml_usize) size);
146 }
147 return new_str;
148 }
149
150 fcml_string fcml_fn_env_str_stralloc(fcml_usize len) {
151 return (fcml_string) fcml_fn_env_memory_alloc_clear(len);
152 }
153
154 void fcml_fn_env_str_strclr( fcml_string str) {
155 str[0] = '\0';
156 }
157
158 void fcml_fn_env_str_strfree( fcml_string str) {
159 if (str) {
160 fcml_fn_env_memory_free(str);
161 }
162 }
163
164 void fcml_fn_env_str_vsnprintf( fcml_string buffer, fcml_usize maxlen,
165 const fcml_string format, va_list args) {
166 vsnprintf(buffer, (fcml_usize) maxlen, format, args);
167 }
168
169 void fcml_fn_env_str_snprintf( fcml_string buffer, fcml_usize maxlen,
170 fcml_string format, ...) {
171 va_list args;
172 va_start(args, format);
173 vsnprintf(buffer, (fcml_usize) maxlen, format, args);
174 va_end(args);
175 }
176
177 fcml_bool fcml_fn_env_is_alpha(fcml_char c) {
178 return isalpha(c);
179 }
180
181 fcml_bool fcml_fn_env_is_digit(fcml_char c) {
182 return isdigit(c);
183 }
184