|
10554
|
1 /* ----------------------------------------------------------------------- *
|
|
|
2 *
|
|
|
3 * Copyright 1996-2016 The NASM Authors - All Rights Reserved
|
|
|
4 * See the file AUTHORS included with the NASM distribution for
|
|
|
5 * the specific copyright holders.
|
|
|
6 *
|
|
|
7 * Redistribution and use in source and binary forms, with or without
|
|
|
8 * modification, are permitted provided that the following
|
|
|
9 * conditions are met:
|
|
|
10 *
|
|
|
11 * * Redistributions of source code must retain the above copyright
|
|
|
12 * notice, this list of conditions and the following disclaimer.
|
|
|
13 * * Redistributions in binary form must reproduce the above
|
|
|
14 * copyright notice, this list of conditions and the following
|
|
|
15 * disclaimer in the documentation and/or other materials provided
|
|
|
16 * with the distribution.
|
|
|
17 *
|
|
|
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
|
|
|
19 * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
|
|
|
20 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
|
21 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
|
22 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
|
|
|
23 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
|
24 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
|
25 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
|
26 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
|
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
|
|
|
29 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
|
|
|
30 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
31 *
|
|
|
32 * ----------------------------------------------------------------------- */
|
|
|
33
|
|
|
34 /*
|
|
|
35 * nasmlib.c library routines for the Netwide Assembler
|
|
|
36 */
|
|
|
37
|
|
|
38 #include "compiler.h"
|
|
|
39
|
|
|
40 #include <stdlib.h>
|
|
|
41 #include <ctype.h>
|
|
|
42
|
|
|
43 #include "nasmlib.h"
|
|
|
44
|
|
|
45 /*
|
|
|
46 * Prepare a table of tolower() results. This avoids function calls
|
|
|
47 * on some platforms.
|
|
|
48 */
|
|
|
49
|
|
|
50 unsigned char nasm_tolower_tab[256];
|
|
|
51
|
|
|
52 void tolower_init(void)
|
|
|
53 {
|
|
|
54 int i;
|
|
|
55
|
|
|
56 for (i = 0; i < 256; i++)
|
|
|
57 nasm_tolower_tab[i] = tolower(i);
|
|
|
58 }
|
|
|
59
|
|
|
60 #ifndef nasm_stricmp
|
|
|
61 int nasm_stricmp(const char *s1, const char *s2)
|
|
|
62 {
|
|
|
63 unsigned char c1, c2;
|
|
|
64 int d;
|
|
|
65
|
|
|
66 while (1) {
|
|
|
67 c1 = nasm_tolower(*s1++);
|
|
|
68 c2 = nasm_tolower(*s2++);
|
|
|
69 d = c1-c2;
|
|
|
70
|
|
|
71 if (d)
|
|
|
72 return d;
|
|
|
73 if (!c1)
|
|
|
74 break;
|
|
|
75 }
|
|
|
76 return 0;
|
|
|
77 }
|
|
|
78 #endif
|
|
|
79
|
|
|
80 #ifndef nasm_strnicmp
|
|
|
81 int nasm_strnicmp(const char *s1, const char *s2, size_t n)
|
|
|
82 {
|
|
|
83 unsigned char c1, c2;
|
|
|
84 int d;
|
|
|
85
|
|
|
86 while (n--) {
|
|
|
87 c1 = nasm_tolower(*s1++);
|
|
|
88 c2 = nasm_tolower(*s2++);
|
|
|
89 d = c1-c2;
|
|
|
90
|
|
|
91 if (d)
|
|
|
92 return d;
|
|
|
93 if (!c1)
|
|
|
94 break;
|
|
|
95 }
|
|
|
96 return 0;
|
|
|
97 }
|
|
|
98 #endif
|
|
|
99
|
|
|
100 int nasm_memicmp(const char *s1, const char *s2, size_t n)
|
|
|
101 {
|
|
|
102 unsigned char c1, c2;
|
|
|
103 int d;
|
|
|
104
|
|
|
105 while (n--) {
|
|
|
106 c1 = nasm_tolower(*s1++);
|
|
|
107 c2 = nasm_tolower(*s2++);
|
|
|
108 d = c1-c2;
|
|
|
109 if (d)
|
|
|
110 return d;
|
|
|
111 }
|
|
|
112 return 0;
|
|
|
113 }
|
|
|
114
|
|
|
115 #ifndef nasm_strsep
|
|
|
116 char *nasm_strsep(char **stringp, const char *delim)
|
|
|
117 {
|
|
|
118 char *s = *stringp;
|
|
|
119 char *e;
|
|
|
120
|
|
|
121 if (!s)
|
|
|
122 return NULL;
|
|
|
123
|
|
|
124 e = strpbrk(s, delim);
|
|
|
125 if (e)
|
|
|
126 *e++ = '\0';
|
|
|
127
|
|
|
128 *stringp = e;
|
|
|
129 return s;
|
|
|
130 }
|
|
|
131 #endif
|
|
|
132
|
|
|
133 /* skip leading spaces */
|
|
|
134 char *nasm_skip_spaces(const char *p)
|
|
|
135 {
|
|
|
136 if (p)
|
|
|
137 while (*p && nasm_isspace(*p))
|
|
|
138 p++;
|
|
|
139 return (char *)p;
|
|
|
140 }
|
|
|
141
|
|
|
142 /* skip leading non-spaces */
|
|
|
143 char *nasm_skip_word(const char *p)
|
|
|
144 {
|
|
|
145 if (p)
|
|
|
146 while (*p && !nasm_isspace(*p))
|
|
|
147 p++;
|
|
|
148 return (char *)p;
|
|
|
149 }
|
|
|
150
|
|
|
151 /* zap leading spaces with zero */
|
|
|
152 char *nasm_zap_spaces_fwd(char *p)
|
|
|
153 {
|
|
|
154 if (p)
|
|
|
155 while (*p && nasm_isspace(*p))
|
|
|
156 *p++ = 0x0;
|
|
|
157 return p;
|
|
|
158 }
|
|
|
159
|
|
|
160 /* zap spaces with zero in reverse order */
|
|
|
161 char *nasm_zap_spaces_rev(char *p)
|
|
|
162 {
|
|
|
163 if (p)
|
|
|
164 while (*p && nasm_isspace(*p))
|
|
|
165 *p-- = 0x0;
|
|
|
166 return p;
|
|
|
167 }
|
|
|
168
|
|
|
169 /* zap leading and trailing spaces */
|
|
|
170 char *nasm_trim_spaces(char *p)
|
|
|
171 {
|
|
|
172 p = nasm_zap_spaces_fwd(p);
|
|
|
173 nasm_zap_spaces_fwd(nasm_skip_word(p));
|
|
|
174
|
|
|
175 return p;
|
|
|
176 }
|
|
|
177
|
|
|
178 /*
|
|
|
179 * return the word extracted from a stream
|
|
|
180 * or NULL if nothing left
|
|
|
181 */
|
|
|
182 char *nasm_get_word(char *p, char **tail)
|
|
|
183 {
|
|
|
184 char *word = nasm_skip_spaces(p);
|
|
|
185 char *next = nasm_skip_word(word);
|
|
|
186
|
|
|
187 if (word && *word) {
|
|
|
188 if (*next)
|
|
|
189 *next++ = '\0';
|
|
|
190 } else
|
|
|
191 word = next = NULL;
|
|
|
192
|
|
|
193 /* NOTE: the tail may start with spaces */
|
|
|
194 *tail = next;
|
|
|
195
|
|
|
196 return word;
|
|
|
197 }
|
|
|
198
|
|
|
199 /*
|
|
|
200 * Extract "opt=val" values from the stream and
|
|
|
201 * returns "opt"
|
|
|
202 *
|
|
|
203 * Exceptions:
|
|
|
204 * 1) If "=val" passed the NULL returned though
|
|
|
205 * you may continue handling the tail via "next"
|
|
|
206 * 2) If "=" passed the NULL is returned and "val"
|
|
|
207 * is set to NULL as well
|
|
|
208 */
|
|
|
209 char *nasm_opt_val(char *p, char **val, char **next)
|
|
|
210 {
|
|
|
211 char *q, *nxt;
|
|
|
212
|
|
|
213 *val = *next = NULL;
|
|
|
214
|
|
|
215 p = nasm_get_word(p, &nxt);
|
|
|
216 if (!p)
|
|
|
217 return NULL;
|
|
|
218
|
|
|
219 q = strchr(p, '=');
|
|
|
220 if (q) {
|
|
|
221 if (q == p)
|
|
|
222 p = NULL;
|
|
|
223 *q++='\0';
|
|
|
224 if (*q) {
|
|
|
225 *val = q;
|
|
|
226 } else {
|
|
|
227 q = nasm_get_word(q + 1, &nxt);
|
|
|
228 if (q)
|
|
|
229 *val = q;
|
|
|
230 }
|
|
|
231 } else {
|
|
|
232 q = nasm_skip_spaces(nxt);
|
|
|
233 if (q && *q == '=') {
|
|
|
234 q = nasm_get_word(q + 1, &nxt);
|
|
|
235 if (q)
|
|
|
236 *val = q;
|
|
|
237 }
|
|
|
238 }
|
|
|
239
|
|
|
240 *next = nxt;
|
|
|
241 return p;
|
|
|
242 }
|
