File: | src/usr.bin/vi/build/../vi/v_increment.c |
Warning: | line 232, column 2 Null pointer passed as 1st argument to memory copy function |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /* $OpenBSD: v_increment.c,v 1.9 2016/01/06 22:28:52 millert Exp $ */ | |||
2 | ||||
3 | /*- | |||
4 | * Copyright (c) 1992, 1993, 1994 | |||
5 | * The Regents of the University of California. All rights reserved. | |||
6 | * Copyright (c) 1992, 1993, 1994, 1995, 1996 | |||
7 | * Keith Bostic. All rights reserved. | |||
8 | * | |||
9 | * See the LICENSE file for redistribution information. | |||
10 | */ | |||
11 | ||||
12 | #include "config.h" | |||
13 | ||||
14 | #include <sys/types.h> | |||
15 | #include <sys/queue.h> | |||
16 | #include <sys/time.h> | |||
17 | ||||
18 | #include <bitstring.h> | |||
19 | #include <ctype.h> | |||
20 | #include <errno(*__errno()).h> | |||
21 | #include <limits.h> | |||
22 | #include <stdio.h> | |||
23 | #include <stdlib.h> | |||
24 | #include <string.h> | |||
25 | ||||
26 | #include "../common/common.h" | |||
27 | #include "vi.h" | |||
28 | ||||
29 | static char * const fmt[] = { | |||
30 | #define DEC0 0 | |||
31 | "%ld", | |||
32 | #define SDEC1 1 | |||
33 | "%+ld", | |||
34 | #define HEXC2 2 | |||
35 | "0X%0*lX", | |||
36 | #define HEXL3 3 | |||
37 | "0x%0*lx", | |||
38 | #define OCTAL4 4 | |||
39 | "%#0*lo", | |||
40 | }; | |||
41 | ||||
42 | static void inc_err(SCR *, enum nresult); | |||
43 | ||||
44 | /* | |||
45 | * v_increment -- [count]#[#+-] | |||
46 | * Increment/decrement a keyword number. | |||
47 | * | |||
48 | * PUBLIC: int v_increment(SCR *, VICMD *); | |||
49 | */ | |||
50 | int | |||
51 | v_increment(SCR *sp, VICMD *vp) | |||
52 | { | |||
53 | enum nresult nret; | |||
54 | u_long ulval; | |||
55 | long change, ltmp, lval; | |||
56 | size_t beg, blen, end, len, nlen, wlen; | |||
57 | int base, isempty, rval; | |||
58 | char *bp, *ntype, *p, *t, nbuf[100]; | |||
59 | ||||
60 | /* Validate the operator. */ | |||
61 | if (vp->character == '#') | |||
| ||||
62 | vp->character = '+'; | |||
63 | if (vp->character != '+' && vp->character != '-') { | |||
64 | v_emsg(sp, vp->kp->usage, VIM_USAGE); | |||
65 | return (1); | |||
66 | } | |||
67 | ||||
68 | /* If new value set, save it off, but it has to fit in a long. */ | |||
69 | if (F_ISSET(vp, VC_C1SET)(((vp)->flags) & ((0x00000800)))) { | |||
70 | if (vp->count > LONG_MAX0x7fffffffffffffffL) { | |||
71 | inc_err(sp, NUM_OVER); | |||
72 | return (1); | |||
73 | } | |||
74 | change = vp->count; | |||
75 | } else | |||
76 | change = 1; | |||
77 | ||||
78 | /* Get the line. */ | |||
79 | if (db_eget(sp, vp->m_start.lno, &p, &len, &isempty)) { | |||
80 | if (isempty) | |||
81 | goto nonum; | |||
82 | return (1); | |||
83 | } | |||
84 | ||||
85 | /* | |||
86 | * Skip any leading space before the number. Getting a cursor word | |||
87 | * implies moving the cursor to its beginning, if we moved, refresh | |||
88 | * now. | |||
89 | */ | |||
90 | for (beg = vp->m_start.cno; beg < len && isspace(p[beg]); ++beg); | |||
91 | if (beg >= len) | |||
92 | goto nonum; | |||
93 | if (beg
| |||
94 | sp->cno = beg; | |||
95 | (void)vs_refresh(sp, 0); | |||
96 | } | |||
97 | ||||
98 | #undef ishex | |||
99 | #define ishex(c)(isdigit(c) || strchr("abcdefABCDEF", (c))) (isdigit(c) || strchr("abcdefABCDEF", (c))) | |||
100 | #undef isoctal | |||
101 | #define isoctal(c)(isdigit(c) && (c) != '8' && (c) != '9') (isdigit(c) && (c) != '8' && (c) != '9') | |||
102 | ||||
103 | /* | |||
104 | * Look for 0[Xx], or leading + or - signs, guess at the base. | |||
105 | * The character after that must be a number. Wlen is set to | |||
106 | * the remaining characters in the line that could be part of | |||
107 | * the number. | |||
108 | */ | |||
109 | wlen = len - beg; | |||
110 | if (p[beg] == '0' && wlen > 2 && | |||
111 | (p[beg + 1] == 'X' || p[beg + 1] == 'x')) { | |||
112 | base = 16; | |||
113 | end = beg + 2; | |||
114 | if (!ishex(p[end])(isdigit(p[end]) || strchr("abcdefABCDEF", (p[end])))) | |||
115 | goto decimal; | |||
116 | ntype = p[beg + 1] == 'X' ? fmt[HEXC2] : fmt[HEXL3]; | |||
117 | } else if (p[beg] == '0' && wlen > 1) { | |||
118 | base = 8; | |||
119 | end = beg + 1; | |||
120 | if (!isoctal(p[end])(isdigit(p[end]) && (p[end]) != '8' && (p[end ]) != '9')) | |||
121 | goto decimal; | |||
122 | ntype = fmt[OCTAL4]; | |||
123 | } else if (wlen >= 1 && (p[beg] == '+' || p[beg] == '-')) { | |||
124 | base = 10; | |||
125 | end = beg + 1; | |||
126 | ntype = fmt[SDEC1]; | |||
127 | if (!isdigit(p[end])) | |||
128 | goto nonum; | |||
129 | } else { | |||
130 | decimal: base = 10; | |||
131 | end = beg; | |||
132 | ntype = fmt[DEC0]; | |||
133 | if (!isdigit(p[end])) { | |||
134 | nonum: msgq(sp, M_ERR, "Cursor not in a number"); | |||
135 | return (1); | |||
136 | } | |||
137 | } | |||
138 | ||||
139 | /* Find the end of the word, possibly correcting the base. */ | |||
140 | while (++end < len) { | |||
141 | switch (base) { | |||
142 | case 8: | |||
143 | if (isoctal(p[end])(isdigit(p[end]) && (p[end]) != '8' && (p[end ]) != '9')) | |||
144 | continue; | |||
145 | if (p[end] == '8' || p[end] == '9') { | |||
146 | base = 10; | |||
147 | ntype = fmt[DEC0]; | |||
148 | continue; | |||
149 | } | |||
150 | break; | |||
151 | case 10: | |||
152 | if (isdigit(p[end])) | |||
153 | continue; | |||
154 | break; | |||
155 | case 16: | |||
156 | if (ishex(p[end])(isdigit(p[end]) || strchr("abcdefABCDEF", (p[end])))) | |||
157 | continue; | |||
158 | break; | |||
159 | default: | |||
160 | abort(); | |||
161 | /* NOTREACHED */ | |||
162 | } | |||
163 | break; | |||
164 | } | |||
165 | wlen = (end - beg); | |||
166 | ||||
167 | /* | |||
168 | * XXX | |||
169 | * If the line was at the end of the buffer, we have to copy it | |||
170 | * so we can guarantee that it's NULL-terminated. We make the | |||
171 | * buffer big enough to fit the line changes as well, and only | |||
172 | * allocate once. | |||
173 | */ | |||
174 | GET_SPACE_RET(sp, bp, blen, len + 50){ GS *L__gp = (sp) == ((void *)0) ? ((void *)0) : (sp)->gp ; if (L__gp == ((void *)0) || (((L__gp)->flags) & ((0x0100 )))) { (bp) = ((void *)0); (blen) = 0; { void *L__bincp; if ( ((len + 50)) > ((blen))) { if ((L__bincp = binc(((sp)), (( bp)), &((blen)), ((len + 50)))) == ((void *)0)) return (1 ); ((bp)) = L__bincp; } }; } else { { void *L__bincp; if (((len + 50)) > (L__gp->tmp_blen)) { if ((L__bincp = binc(((sp )), (L__gp->tmp_bp), &(L__gp->tmp_blen), ((len + 50 )))) == ((void *)0)) return (1); (L__gp->tmp_bp) = L__bincp ; } }; (bp) = L__gp->tmp_bp; (blen) = L__gp->tmp_blen; ( ((L__gp)->flags) |= ((0x0100))); } }; | |||
175 | if (end == len) { | |||
176 | memmove(bp, &p[beg], wlen); | |||
177 | bp[wlen] = '\0'; | |||
178 | t = bp; | |||
179 | } else | |||
180 | t = &p[beg]; | |||
181 | ||||
182 | /* | |||
183 | * Octal or hex deal in unsigned longs, everything else is done | |||
184 | * in signed longs. | |||
185 | */ | |||
186 | if (base
| |||
187 | if ((nret = nget_slong(&lval, t, NULL((void *)0), 10)) != NUM_OK) | |||
188 | goto err; | |||
189 | ltmp = vp->character == '-' ? -change : change; | |||
190 | if (lval > 0 && ltmp > 0 && !NPFITS(LONG_MAX, lval, ltmp)(((unsigned long)(0x7fffffffffffffffL)) - (lval) >= (ltmp) )) { | |||
191 | nret = NUM_OVER; | |||
192 | goto err; | |||
193 | } | |||
194 | if (lval < 0 && ltmp < 0 && !NNFITS(LONG_MIN, lval, ltmp)(((long)((-0x7fffffffffffffffL-1))) - (lval) <= (ltmp))) { | |||
195 | nret = NUM_UNDER; | |||
196 | goto err; | |||
197 | } | |||
198 | lval += ltmp; | |||
199 | /* If we cross 0, signed numbers lose their sign. */ | |||
200 | if (lval
| |||
201 | ntype = fmt[DEC0]; | |||
202 | nlen = snprintf(nbuf, sizeof(nbuf), ntype, lval); | |||
203 | if (nlen >= sizeof(nbuf)) | |||
204 | nlen = sizeof(nbuf) - 1; | |||
205 | } else { | |||
206 | if ((nret = nget_uslong(&ulval, t, NULL((void *)0), base)) != NUM_OK) | |||
207 | goto err; | |||
208 | if (vp->character == '+') { | |||
209 | if (!NPFITS(ULONG_MAX, ulval, change)(((unsigned long)(0xffffffffffffffffUL)) - (ulval) >= (change ))) { | |||
210 | nret = NUM_OVER; | |||
211 | goto err; | |||
212 | } | |||
213 | ulval += change; | |||
214 | } else { | |||
215 | if (ulval < change) { | |||
216 | nret = NUM_UNDER; | |||
217 | goto err; | |||
218 | } | |||
219 | ulval -= change; | |||
220 | } | |||
221 | ||||
222 | /* Correct for literal "0[Xx]" in format. */ | |||
223 | if (base == 16) | |||
224 | wlen -= 2; | |||
225 | ||||
226 | nlen = snprintf(nbuf, sizeof(nbuf), ntype, wlen, ulval); | |||
227 | if (nlen >= sizeof(nbuf)) | |||
228 | nlen = sizeof(nbuf) - 1; | |||
229 | } | |||
230 | ||||
231 | /* Build the new line. */ | |||
232 | memmove(bp, p, beg); | |||
| ||||
233 | memmove(bp + beg, nbuf, nlen); | |||
234 | memmove(bp + beg + nlen, p + end, len - beg - (end - beg)); | |||
235 | len = beg + nlen + (len - beg - (end - beg)); | |||
236 | ||||
237 | nret = NUM_OK; | |||
238 | rval = db_set(sp, vp->m_start.lno, bp, len); | |||
239 | ||||
240 | if (0) { | |||
241 | err: rval = 1; | |||
242 | inc_err(sp, nret); | |||
243 | } | |||
244 | if (bp != NULL((void *)0)) | |||
245 | FREE_SPACE(sp, bp, blen){ GS *L__gp = (sp) == ((void *)0) ? ((void *)0) : (sp)->gp ; if (L__gp != ((void *)0) && (bp) == L__gp->tmp_bp ) (((L__gp)->flags) &= ~((0x0100))); else free(bp); }; | |||
246 | return (rval); | |||
247 | } | |||
248 | ||||
249 | static void | |||
250 | inc_err(SCR *sp, enum nresult nret) | |||
251 | { | |||
252 | switch (nret) { | |||
253 | case NUM_ERR: | |||
254 | break; | |||
255 | case NUM_OK: | |||
256 | abort(); | |||
257 | /* NOREACHED */ | |||
258 | case NUM_OVER: | |||
259 | msgq(sp, M_ERR, "Resulting number too large"); | |||
260 | break; | |||
261 | case NUM_UNDER: | |||
262 | msgq(sp, M_ERR, "Resulting number too small"); | |||
263 | break; | |||
264 | } | |||
265 | } |