snprintb.c revision 1.4.2.1
1 /* $NetBSD: snprintb.c,v 1.4.2.1 2009/05/13 17:23:18 jym Exp $ */ 2 3 /*- 4 * Copyright (c) 2002 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 17 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 18 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 19 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 26 * POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29 /* 30 * snprintb: print an interpreted bitmask to a buffer 31 * 32 * => returns the length of the buffer that would be required to print the 33 * string minus the terminating NUL. 34 */ 35 #ifndef _STANDALONE 36 # ifndef _KERNEL 37 38 # if HAVE_NBTOOL_CONFIG_H 39 # include "nbtool_config.h" 40 # endif 41 42 # include <sys/cdefs.h> 43 # if defined(LIBC_SCCS) && !defined(lint) 44 __RCSID("$NetBSD: snprintb.c,v 1.4.2.1 2009/05/13 17:23:18 jym Exp $"); 45 # endif 46 47 # include <sys/types.h> 48 # include <sys/inttypes.h> 49 # include <stdio.h> 50 # include <util.h> 51 # include <errno.h> 52 # else 53 # include <sys/cdefs.h> 54 __KERNEL_RCSID(0, "$NetBSD: snprintb.c,v 1.4.2.1 2009/05/13 17:23:18 jym Exp $"); 55 # include <sys/param.h> 56 # include <sys/inttypes.h> 57 # include <sys/systm.h> 58 # include <lib/libkern/libkern.h> 59 # endif 60 61 int 62 snprintb_m(char *buf, size_t buflen, const char *bitfmt, uint64_t val, 63 size_t l_max) 64 { 65 char *bp = buf, *s_bp = NULL; 66 const char *c_fmt, *s_fmt = NULL, *cur_fmt; 67 const char *sbase; 68 int bit, ch, t_len, s_len = 0, l_len, f_len, v_len, sep; 69 int restart = 0; 70 uint64_t field; 71 72 #ifdef _KERNEL 73 /* 74 * For safety; no other *s*printf() do this, but in the kernel 75 * we don't usually check the return value 76 */ 77 (void)memset(buf, 0, buflen); 78 #endif /* _KERNEL */ 79 80 ch = *bitfmt++; 81 switch (ch != '\177' ? ch : *bitfmt++) { 82 case 8: 83 sbase = "0%" PRIo64; 84 break; 85 case 10: 86 sbase = "%" PRId64; 87 break; 88 case 16: 89 sbase = "0x%" PRIx64; 90 break; 91 default: 92 goto internal; 93 } 94 95 /* Reserve space for trailing blank line if needed */ 96 if (l_max > 0) 97 buflen--; 98 99 t_len = snprintf(bp, buflen, sbase, val); 100 if (t_len < 0) 101 goto internal; 102 103 v_len = l_len = t_len; 104 105 if ((size_t)t_len < buflen) 106 bp += t_len; 107 else 108 bp += buflen - 1; 109 110 /* 111 * If the value we printed was 0 and we're using the old-style format, 112 * we're done. 113 */ 114 if ((val == 0) && (ch != '\177')) 115 goto terminate; 116 117 #define STORE(c) { l_len++; \ 118 if ((size_t)(++t_len) < buflen) \ 119 *bp++ = (c); \ 120 } while ( /* CONSTCOND */ 0) 121 122 #define BACKUP { if (s_bp != NULL) { \ 123 bp = s_bp; s_bp = NULL; \ 124 t_len -= l_len - s_len; \ 125 restart = 1; \ 126 bitfmt = s_fmt; \ 127 } \ 128 STORE('>'); STORE('\0'); \ 129 if ((size_t)t_len < buflen) \ 130 snprintf(bp, buflen - t_len, sbase, val); \ 131 t_len += v_len; l_len = v_len; bp += v_len; \ 132 } while ( /* CONSTCOND */ 0) 133 134 #define PUTSEP \ 135 if (l_max > 0 && (size_t)l_len >= l_max) { \ 136 BACKUP; \ 137 STORE('<'); \ 138 } else { \ 139 /* Remember separator location */ \ 140 if ( l_max > 0 && sep != '<') { \ 141 s_len = l_len; \ 142 s_bp = bp; \ 143 s_fmt = cur_fmt; \ 144 } \ 145 STORE(sep); \ 146 restart = 0; \ 147 } \ 148 149 #define PUTCHR(c) \ 150 if (l_max > 0 && (size_t)l_len >= (l_max - 1)) { \ 151 BACKUP; \ 152 if (restart == 0) { \ 153 STORE(c); \ 154 } else \ 155 sep = '<'; \ 156 } else { \ 157 STORE(c); \ 158 restart = 0; \ 159 } \ 160 161 #define PUTS(s) while ((ch = *(s)++) != 0) { \ 162 PUTCHR(ch); \ 163 if (restart) \ 164 break; \ 165 } 166 167 /* 168 * Chris Torek's new bitmask format is identified by a leading \177 169 */ 170 sep = '<'; 171 if (ch != '\177') { 172 /* old (standard) format. */ 173 for (;(bit = *bitfmt) != 0;) { 174 cur_fmt = bitfmt++; 175 if (val & (1 << (bit - 1))) { 176 PUTSEP; 177 if (restart) 178 continue; 179 sep = ','; 180 for (; (ch = *bitfmt) > ' '; ++bitfmt) { 181 PUTCHR(ch); 182 if (restart) 183 break; 184 } 185 } else 186 for (; *bitfmt > ' '; ++bitfmt) 187 continue; 188 } 189 } else { 190 /* new quad-capable format; also does fields. */ 191 field = val; 192 while (c_fmt = bitfmt, (ch = *bitfmt++) != '\0') { 193 bit = *bitfmt++; /* now 0-origin */ 194 switch (ch) { 195 case 'b': 196 if (((u_int)(val >> bit) & 1) == 0) 197 goto skip; 198 cur_fmt = c_fmt; 199 PUTSEP; 200 if (restart) 201 break; 202 PUTS(bitfmt); 203 if (restart == 0) 204 sep = ','; 205 break; 206 case 'f': 207 case 'F': 208 cur_fmt = c_fmt; 209 f_len = *bitfmt++; /* field length */ 210 field = (val >> bit) & 211 (((uint64_t)1 << f_len) - 1); 212 if (ch == 'F') /* just extract */ 213 break; 214 PUTSEP; 215 if (restart == 0) { 216 sep = ','; 217 PUTS(bitfmt); 218 } 219 if (restart == 0) { 220 PUTCHR('='); 221 } 222 if (restart == 0) { 223 f_len = snprintf(bp, buflen - t_len, 224 sbase, field); 225 if (f_len < 0) 226 goto internal; 227 t_len += f_len; 228 l_len += f_len; 229 if ((size_t)t_len < buflen) 230 bp += f_len; 231 if (l_max > 0 && 232 (size_t)l_len > l_max) { 233 PUTCHR('#'); 234 } 235 } 236 break; 237 case '=': 238 case ':': 239 /* 240 * Here "bit" is actually a value instead, 241 * to be compared against the last field. 242 * This only works for values in [0..255], 243 * of course. 244 */ 245 if ((int)field != bit) 246 goto skip; 247 if (ch == '=') { 248 PUTCHR('='); 249 } 250 PUTS(bitfmt); 251 break; 252 default: 253 skip: 254 while (*bitfmt++ != '\0') 255 continue; 256 break; 257 } 258 } 259 } 260 l_len++; 261 if ((size_t)(++t_len) < buflen) 262 *bp++ = '>'; 263 terminate: 264 *bp++ = '\0'; 265 if (l_max != 0) { 266 t_len++; 267 *bp = '\0'; 268 } 269 return t_len; 270 internal: 271 #ifndef _KERNEL 272 errno = EINVAL; 273 #endif 274 return -1; 275 } 276 277 int 278 snprintb(char *buf, size_t buflen, const char *bitfmt, uint64_t val) 279 { 280 return snprintb_m(buf, buflen, bitfmt, val, 0); 281 } 282 #endif 283
Indexes created Thu Oct 02 14:10:14 GMT 2025