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 | } |
243 | |