1 /* 2 * Copyright (c) 2005, 2012, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 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. 49 */ 50 void * 51 JLI_MemRealloc(void *ptr, size_t size) 52 { 53 void *p = realloc(ptr, size); 54 if (p == 0) { 55 perror("realloc"); 56 exit(1); 57 } 58 return p; 59 } 60 61 /* 62 * Wrapper over strdup(3C) which prints an error message and exits if memory 63 * could not be allocated. 64 */ 65 char * 66 JLI_StringDup(const char *s1) 67 { 68 char *s = strdup(s1); 69 if (s == NULL) { 70 perror("strdup"); 71 exit(1); 72 } 73 return s; 74 } 75 76 /* 77 * Very equivalent to free(ptr). 78 * Here to maintain pairing with the above routines. 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; | 1 /* 2 * Copyright (c) 2005, 2018, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 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 "jni.h" 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 JNIEXPORT void * JNICALL 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. 50 */ 51 void * 52 JLI_MemRealloc(void *ptr, size_t size) 53 { 54 void *p = realloc(ptr, size); 55 if (p == 0) { 56 perror("realloc"); 57 exit(1); 58 } 59 return p; 60 } 61 62 /* 63 * Wrapper over strdup(3C) which prints an error message and exits if memory 64 * could not be allocated. 65 */ 66 JNIEXPORT char * JNICALL 67 JLI_StringDup(const char *s1) 68 { 69 char *s = strdup(s1); 70 if (s == NULL) { 71 perror("strdup"); 72 exit(1); 73 } 74 return s; 75 } 76 77 /* 78 * Very equivalent to free(ptr). 79 * Here to maintain pairing with the above routines. 80 */ 81 JNIEXPORT void JNICALL 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 fflush(stdout); 101 } 102 103 JNIEXPORT void JNICALL 104 JLI_SetTraceLauncher() 105 { 106 if (getenv(JLDEBUG_ENV_ENTRY) != 0) { 107 _launcher_debug = JNI_TRUE; 108 JLI_TraceLauncher("----%s----\n", JLDEBUG_ENV_ENTRY); 109 } 110 } 111 112 jboolean 113 JLI_IsTraceLauncher() 114 { 115 return _launcher_debug; 116 } 117 118 int 119 JLI_StrCCmp(const char *s1, const char* s2) 120 { 121 return JLI_StrNCmp(s1, s2, JLI_StrLen(s2)); 122 } 123 124 JNIEXPORT JLI_List JNICALL 125 JLI_List_new(size_t capacity) 126 { 127 JLI_List l = (JLI_List) JLI_MemAlloc(sizeof(struct JLI_List_)); 128 l->capacity = capacity; 129 l->elements = (char **) JLI_MemAlloc(capacity * sizeof(l->elements[0])); 130 l->size = 0; 131 return l; 132 } 133 134 void 135 JLI_List_free(JLI_List sl) 136 { 137 if (sl) { 138 if (sl->elements) { 139 size_t i; 140 for (i = 0; i < sl->size; i++) 141 JLI_MemFree(sl->elements[i]); 142 JLI_MemFree(sl->elements); 143 } 144 JLI_MemFree(sl); 145 } 146 } 147 148 void 149 JLI_List_ensureCapacity(JLI_List sl, size_t capacity) 150 { 151 if (sl->capacity < capacity) { 152 while (sl->capacity < capacity) 153 sl->capacity *= 2; 154 sl->elements = JLI_MemRealloc(sl->elements, 155 sl->capacity * sizeof(sl->elements[0])); 156 } 157 } 158 159 JNIEXPORT void JNICALL 160 JLI_List_add(JLI_List sl, char *str) 161 { 162 JLI_List_ensureCapacity(sl, sl->size+1); 163 sl->elements[sl->size++] = str; 164 } 165 166 void 167 JLI_List_addSubstring(JLI_List sl, const char *beg, size_t len) 168 { 169 char *str = (char *) JLI_MemAlloc(len+1); 170 memcpy(str, beg, len); 171 str[len] = '\0'; 172 JLI_List_ensureCapacity(sl, sl->size+1); 173 sl->elements[sl->size++] = str; 174 } 175 176 char * 177 JLI_List_combine(JLI_List sl) 178 { 179 size_t i; |