8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 #include <stdio.h>
27 #include <string.h>
28 #include <jni.h>
29
30 #include "jli_util.h"
31
32 /*
33 * Returns a pointer to a block of at least 'size' bytes of memory.
34 * Prints error message and exits if the memory could not be allocated.
35 */
36 void *
37 JLI_MemAlloc(size_t size)
38 {
39 void *p = malloc(size);
40 if (p == 0) {
41 perror("malloc");
42 exit(1);
43 }
44 return p;
45 }
46
47 /*
48 * Equivalent to realloc(size).
49 * Prints error message and exits if the memory could not be reallocated.
80 */
81 void
82 JLI_MemFree(void *ptr)
83 {
84 free(ptr);
85 }
86
87 /*
88 * debug helpers we use
89 */
90 static jboolean _launcher_debug = JNI_FALSE;
91
92 void
93 JLI_TraceLauncher(const char* fmt, ...)
94 {
95 va_list vl;
96 if (_launcher_debug != JNI_TRUE) return;
97 va_start(vl, fmt);
98 vprintf(fmt,vl);
99 va_end(vl);
100 }
101
102 void
103 JLI_SetTraceLauncher()
104 {
105 if (getenv(JLDEBUG_ENV_ENTRY) != 0) {
106 _launcher_debug = JNI_TRUE;
107 JLI_TraceLauncher("----%s----\n", JLDEBUG_ENV_ENTRY);
108 }
109 }
110
111 jboolean
112 JLI_IsTraceLauncher()
113 {
114 return _launcher_debug;
115 }
116
117 int
118 JLI_StrCCmp(const char *s1, const char* s2)
119 {
120 return JLI_StrNCmp(s1, s2, JLI_StrLen(s2));
121 }
|
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 #include <stdio.h>
27 #include <string.h>
28 #include <stdarg.h>
29 #include "jli_util.h"
30
31 /*
32 * Returns a pointer to a block of at least 'size' bytes of memory.
33 * Prints error message and exits if the memory could not be allocated.
34 */
35 void *
36 JLI_MemAlloc(size_t size)
37 {
38 void *p = malloc(size);
39 if (p == 0) {
40 perror("malloc");
41 exit(1);
42 }
43 return p;
44 }
45
46 /*
47 * Equivalent to realloc(size).
48 * Prints error message and exits if the memory could not be reallocated.
79 */
80 void
81 JLI_MemFree(void *ptr)
82 {
83 free(ptr);
84 }
85
86 /*
87 * debug helpers we use
88 */
89 static jboolean _launcher_debug = JNI_FALSE;
90
91 void
92 JLI_TraceLauncher(const char* fmt, ...)
93 {
94 va_list vl;
95 if (_launcher_debug != JNI_TRUE) return;
96 va_start(vl, fmt);
97 vprintf(fmt,vl);
98 va_end(vl);
99 fflush(stdout);
100 }
101
102 void
103 JLI_SetTraceLauncher()
104 {
105 if (getenv(JLDEBUG_ENV_ENTRY) != 0) {
106 _launcher_debug = JNI_TRUE;
107 JLI_TraceLauncher("----%s----\n", JLDEBUG_ENV_ENTRY);
108 }
109 }
110
111 jboolean
112 JLI_IsTraceLauncher()
113 {
114 return _launcher_debug;
115 }
116
117 int
118 JLI_StrCCmp(const char *s1, const char* s2)
119 {
120 return JLI_StrNCmp(s1, s2, JLI_StrLen(s2));
121 }
122
123 JLI_List
124 JLI_List_new(size_t capacity)
125 {
126 JLI_List l = (JLI_List) JLI_MemAlloc(sizeof(struct JLI_List_));
127 l->capacity = capacity;
128 l->elements = (char **) JLI_MemAlloc(capacity * sizeof(l->elements[0]));
129 l->size = 0;
130 return l;
131 }
132
133 void
134 JLI_List_free(JLI_List sl)
135 {
136 if (sl) {
137 if (sl->elements) {
138 size_t i;
139 for (i = 0; i < sl->size; i++)
140 JLI_MemFree(sl->elements[i]);
141 JLI_MemFree(sl->elements);
142 }
143 JLI_MemFree(sl);
144 }
145 }
146
147 void
148 JLI_List_ensureCapacity(JLI_List sl, size_t capacity)
149 {
150 if (sl->capacity < capacity) {
151 while (sl->capacity < capacity)
152 sl->capacity *= 2;
153 sl->elements = JLI_MemRealloc(sl->elements,
154 sl->capacity * sizeof(sl->elements[0]));
155 }
156 }
157
158 void
159 JLI_List_add(JLI_List sl, char *str)
160 {
161 JLI_List_ensureCapacity(sl, sl->size+1);
162 sl->elements[sl->size++] = str;
163 }
164
165 void
166 JLI_List_addSubstring(JLI_List sl, const char *beg, size_t len)
167 {
168 char *str = (char *) JLI_MemAlloc(len+1);
169 memcpy(str, beg, len);
170 str[len] = '\0';
171 JLI_List_ensureCapacity(sl, sl->size+1);
172 sl->elements[sl->size++] = str;
173 }
174
175 char *
176 JLI_List_combine(JLI_List sl)
177 {
178 size_t i;
179 size_t size;
180 char *str;
181 char *p;
182 for (i = 0, size = 1; i < sl->size; i++)
183 size += JLI_StrLen(sl->elements[i]);
184
185 str = JLI_MemAlloc(size);
186
187 for (i = 0, p = str; i < sl->size; i++) {
188 size_t len = JLI_StrLen(sl->elements[i]);
189 memcpy(p, sl->elements[i], len);
190 p += len;
191 }
192 *p = '\0';
193
194 return str;
195 }
196
197 char *
198 JLI_List_join(JLI_List sl, char sep)
199 {
200 size_t i;
201 size_t size;
202 char *str;
203 char *p;
204 for (i = 0, size = 1; i < sl->size; i++)
205 size += JLI_StrLen(sl->elements[i]) + 1;
206
207 str = JLI_MemAlloc(size);
208
209 for (i = 0, p = str; i < sl->size; i++) {
210 size_t len = JLI_StrLen(sl->elements[i]);
211 if (i > 0) *p++ = sep;
212 memcpy(p, sl->elements[i], len);
213 p += len;
214 }
215 *p = '\0';
216
217 return str;
218 }
219
220 JLI_List
221 JLI_List_split(const char *str, char sep)
222 {
223 const char *p, *q;
224 size_t len = JLI_StrLen(str);
225 int count;
226 JLI_List sl;
227 for (count = 1, p = str; p < str + len; p++)
228 count += (*p == sep);
229 sl = JLI_List_new(count);
230 for (p = str;;) {
231 for (q = p; q <= str + len; q++) {
232 if (*q == sep || *q == '\0') {
233 JLI_List_addSubstring(sl, p, q - p);
234 if (*q == '\0')
235 return sl;
236 p = q + 1;
237 }
238 }
239 }
240 }
|