OLD | NEW |
(Empty) | |
| 1 /* quotearg.h - quote arguments for output |
| 2 |
| 3 Copyright (C) 1998, 1999, 2000, 2001, 2002, 2004, 2006, 2008 Free |
| 4 Software Foundation, Inc. |
| 5 |
| 6 This program is free software: you can redistribute it and/or modify |
| 7 it under the terms of the GNU General Public License as published by |
| 8 the Free Software Foundation; either version 3 of the License, or |
| 9 (at your option) any later version. |
| 10 |
| 11 This program is distributed in the hope that it will be useful, |
| 12 but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 14 GNU General Public License for more details. |
| 15 |
| 16 You should have received a copy of the GNU General Public License |
| 17 along with this program. If not, see <http://www.gnu.org/licenses/>. */ |
| 18 |
| 19 /* Written by Paul Eggert <eggert@twinsun.com> */ |
| 20 |
| 21 #ifndef QUOTEARG_H_ |
| 22 # define QUOTEARG_H_ 1 |
| 23 |
| 24 # include <stddef.h> |
| 25 |
| 26 /* Basic quoting styles. For each style, an example is given on the |
| 27 input strings "simple", "\0 \t\n'\"\033?""?/\\", and "a:b", using |
| 28 quotearg_buffer, quotearg_mem, and quotearg_colon_mem with that |
| 29 style and the default flags and quoted characters. Note that the |
| 30 examples are shown here as valid C strings rather than what |
| 31 displays on a terminal (with "??/" as a trigraph for "\\"). */ |
| 32 enum quoting_style |
| 33 { |
| 34 /* Output names as-is (ls --quoting-style=literal). Can result in |
| 35 embedded null bytes if QA_ELIDE_NULL_BYTES is not in |
| 36 effect. |
| 37 |
| 38 quotearg_buffer: |
| 39 "simple", "\0 \t\n'\"\033??/\\", "a:b" |
| 40 quotearg: |
| 41 "simple", " \t\n'\"\033??/\\", "a:b" |
| 42 quotearg_colon: |
| 43 "simple", " \t\n'\"\033??/\\", "a:b" |
| 44 */ |
| 45 literal_quoting_style, |
| 46 |
| 47 /* Quote names for the shell if they contain shell metacharacters |
| 48 or would cause ambiguous output (ls --quoting-style=shell). |
| 49 Can result in embedded null bytes if QA_ELIDE_NULL_BYTES is not |
| 50 in effect. |
| 51 |
| 52 quotearg_buffer: |
| 53 "simple", "'\0 \t\n'\\''\"\033??/\\'", "a:b" |
| 54 quotearg: |
| 55 "simple", "' \t\n'\\''\"\033??/\\'", "a:b" |
| 56 quotearg_colon: |
| 57 "simple", "' \t\n'\\''\"\033??/\\'", "'a:b'" |
| 58 */ |
| 59 shell_quoting_style, |
| 60 |
| 61 /* Quote names for the shell, even if they would normally not |
| 62 require quoting (ls --quoting-style=shell-always). Can result |
| 63 in embedded null bytes if QA_ELIDE_NULL_BYTES is not in effect. |
| 64 Behaves like shell_quoting_style if QA_ELIDE_OUTER_QUOTES is in |
| 65 effect. |
| 66 |
| 67 quotearg_buffer: |
| 68 "'simple'", "'\0 \t\n'\\''\"\033??/\\'", "'a:b'" |
| 69 quotearg: |
| 70 "'simple'", "' \t\n'\\''\"\033??/\\'", "'a:b'" |
| 71 quotearg_colon: |
| 72 "'simple'", "' \t\n'\\''\"\033??/\\'", "'a:b'" |
| 73 */ |
| 74 shell_always_quoting_style, |
| 75 |
| 76 /* Quote names as for a C language string (ls --quoting-style=c). |
| 77 Behaves like c_maybe_quoting_style if QA_ELIDE_OUTER_QUOTES is |
| 78 in effect. Split into consecutive strings if |
| 79 QA_SPLIT_TRIGRAPHS. |
| 80 |
| 81 quotearg_buffer: |
| 82 "\"simple\"", "\"\\0 \\t\\n'\\\"\\033??/\\\\\"", "\"a:b\"" |
| 83 quotearg: |
| 84 "\"simple\"", "\"\\0 \\t\\n'\\\"\\033??/\\\\\"", "\"a:b\"" |
| 85 quotearg_colon: |
| 86 "\"simple\"", "\"\\0 \\t\\n'\\\"\\033??/\\\\\"", "\"a\\:b\"" |
| 87 */ |
| 88 c_quoting_style, |
| 89 |
| 90 /* Like c_quoting_style except omit the surrounding double-quote |
| 91 characters if no quoted characters are encountered. |
| 92 |
| 93 quotearg_buffer: |
| 94 "simple", "\"\\0 \\t\\n'\\\"\\033??/\\\\\"", "a:b" |
| 95 quotearg: |
| 96 "simple", "\"\\0 \\t\\n'\\\"\\033??/\\\\\"", "a:b" |
| 97 quotearg_colon: |
| 98 "simple", "\"\\0 \\t\\n'\\\"\\033??/\\\\\"", "\"a:b\"" |
| 99 */ |
| 100 c_maybe_quoting_style, |
| 101 |
| 102 /* Like c_quoting_style except always omit the surrounding |
| 103 double-quote characters (ls --quoting-style=escape). |
| 104 |
| 105 quotearg_buffer: |
| 106 "simple", "\\0 \\t\\n'\"\\033??/\\\\", "a:b" |
| 107 quotearg: |
| 108 "simple", "\\0 \\t\\n'\"\\033??/\\\\", "a:b" |
| 109 quotearg_colon: |
| 110 "simple", "\\0 \\t\\n'\"\\033??/\\\\", "a\\:b" |
| 111 */ |
| 112 escape_quoting_style, |
| 113 |
| 114 /* Like clocale_quoting_style, but quote `like this' instead of |
| 115 "like this" in the default C locale (ls --quoting-style=locale). |
| 116 |
| 117 LC_MESSAGES=C |
| 118 quotearg_buffer: |
| 119 "`simple'", "`\\0 \\t\\n\\'\"\\033??/\\\\'", "`a:b'" |
| 120 quotearg: |
| 121 "`simple'", "`\\0 \\t\\n\\'\"\\033??/\\\\'", "`a:b'" |
| 122 quotearg_colon: |
| 123 "`simple'", "`\\0 \\t\\n\\'\"\\033??/\\\\'", "`a\\:b'" |
| 124 |
| 125 LC_MESSAGES=pt_PT.utf8 |
| 126 quotearg_buffer: |
| 127 "\302\253simple\302\273", |
| 128 "\302\253\\0 \\t\\n'\"\\033??/\\\\\302\253", "\302\253a:b\302\273" |
| 129 quotearg: |
| 130 "\302\253simple\302\273", |
| 131 "\302\253\\0 \\t\\n'\"\\033??/\\\\\302\253", "\302\253a:b\302\273" |
| 132 quotearg_colon: |
| 133 "\302\253simple\302\273", |
| 134 "\302\253\\0 \\t\\n'\"\\033??/\\\\\302\253", "\302\253a\\:b\302\273" |
| 135 */ |
| 136 locale_quoting_style, |
| 137 |
| 138 /* Like c_quoting_style except use quotation marks appropriate for |
| 139 the locale (ls --quoting-style=clocale). |
| 140 |
| 141 LC_MESSAGES=C |
| 142 quotearg_buffer: |
| 143 "\"simple\"", "\"\\0 \\t\\n'\\\"\\033??/\\\\\"", "\"a:b\"" |
| 144 quotearg: |
| 145 "\"simple\"", "\"\\0 \\t\\n'\\\"\\033??/\\\\\"", "\"a:b\"" |
| 146 quotearg_colon: |
| 147 "\"simple\"", "\"\\0 \\t\\n'\\\"\\033??/\\\\\"", "\"a\\:b\"" |
| 148 |
| 149 LC_MESSAGES=pt_PT.utf8 |
| 150 quotearg_buffer: |
| 151 "\302\253simple\302\273", |
| 152 "\302\253\\0 \\t\\n'\"\\033??/\\\\\302\253", "\302\253a:b\302\273" |
| 153 quotearg: |
| 154 "\302\253simple\302\273", |
| 155 "\302\253\\0 \\t\\n'\"\\033??/\\\\\302\253", "\302\253a:b\302\273" |
| 156 quotearg_colon: |
| 157 "\302\253simple\302\273", |
| 158 "\302\253\\0 \\t\\n'\"\\033??/\\\\\302\253", "\302\253a\\:b\302\273" |
| 159 */ |
| 160 clocale_quoting_style |
| 161 }; |
| 162 |
| 163 /* Flags for use in set_quoting_flags. */ |
| 164 enum quoting_flags |
| 165 { |
| 166 /* Always elide null bytes from styles that do not quote them, |
| 167 even when the length of the result is available to the |
| 168 caller. */ |
| 169 QA_ELIDE_NULL_BYTES = 0x01, |
| 170 |
| 171 /* Omit the surrounding quote characters if no escaped characters |
| 172 are encountered. Note that if no other character needs |
| 173 escaping, then neither does the escape character. */ |
| 174 QA_ELIDE_OUTER_QUOTES = 0x02, |
| 175 |
| 176 /* In the c_quoting_style and c_maybe_quoting_style, split ANSI |
| 177 trigraph sequences into concatenated strings (for example, |
| 178 "?""?/" rather than "??/", which could be confused with |
| 179 "\\"). */ |
| 180 QA_SPLIT_TRIGRAPHS = 0x04 |
| 181 }; |
| 182 |
| 183 /* For now, --quoting-style=literal is the default, but this may change. */ |
| 184 # ifndef DEFAULT_QUOTING_STYLE |
| 185 # define DEFAULT_QUOTING_STYLE literal_quoting_style |
| 186 # endif |
| 187 |
| 188 /* Names of quoting styles and their corresponding values. */ |
| 189 extern char const *const quoting_style_args[]; |
| 190 extern enum quoting_style const quoting_style_vals[]; |
| 191 |
| 192 struct quoting_options; |
| 193 |
| 194 /* The functions listed below set and use a hidden variable |
| 195 that contains the default quoting style options. */ |
| 196 |
| 197 /* Allocate a new set of quoting options, with contents initially identical |
| 198 to O if O is not null, or to the default if O is null. |
| 199 It is the caller's responsibility to free the result. */ |
| 200 struct quoting_options *clone_quoting_options (struct quoting_options *o); |
| 201 |
| 202 /* Get the value of O's quoting style. If O is null, use the default. */ |
| 203 enum quoting_style get_quoting_style (struct quoting_options *o); |
| 204 |
| 205 /* In O (or in the default if O is null), |
| 206 set the value of the quoting style to S. */ |
| 207 void set_quoting_style (struct quoting_options *o, enum quoting_style s); |
| 208 |
| 209 /* In O (or in the default if O is null), |
| 210 set the value of the quoting options for character C to I. |
| 211 Return the old value. Currently, the only values defined for I are |
| 212 0 (the default) and 1 (which means to quote the character even if |
| 213 it would not otherwise be quoted). */ |
| 214 int set_char_quoting (struct quoting_options *o, char c, int i); |
| 215 |
| 216 /* In O (or in the default if O is null), |
| 217 set the value of the quoting options flag to I, which can be a |
| 218 bitwise combination of enum quoting_flags, or 0 for default |
| 219 behavior. Return the old value. */ |
| 220 int set_quoting_flags (struct quoting_options *o, int i); |
| 221 |
| 222 /* Place into buffer BUFFER (of size BUFFERSIZE) a quoted version of |
| 223 argument ARG (of size ARGSIZE), using O to control quoting. |
| 224 If O is null, use the default. |
| 225 Terminate the output with a null character, and return the written |
| 226 size of the output, not counting the terminating null. |
| 227 If BUFFERSIZE is too small to store the output string, return the |
| 228 value that would have been returned had BUFFERSIZE been large enough. |
| 229 If ARGSIZE is -1, use the string length of the argument for ARGSIZE. |
| 230 On output, BUFFER might contain embedded null bytes if ARGSIZE was |
| 231 not -1, the style of O does not use backslash escapes, and the |
| 232 flags of O do not request elision of null bytes.*/ |
| 233 size_t quotearg_buffer (char *buffer, size_t buffersize, |
| 234 char const *arg, size_t argsize, |
| 235 struct quoting_options const *o); |
| 236 |
| 237 /* Like quotearg_buffer, except return the result in a newly allocated |
| 238 buffer. It is the caller's responsibility to free the result. The |
| 239 result will not contain embedded null bytes. */ |
| 240 char *quotearg_alloc (char const *arg, size_t argsize, |
| 241 struct quoting_options const *o); |
| 242 |
| 243 /* Like quotearg_alloc, except that the length of the result, |
| 244 excluding the terminating null byte, is stored into SIZE if it is |
| 245 non-NULL. The result might contain embedded null bytes if ARGSIZE |
| 246 was not -1, SIZE was not NULL, the style of O does not use |
| 247 backslash escapes, and the flags of O do not request elision of |
| 248 null bytes.*/ |
| 249 char *quotearg_alloc_mem (char const *arg, size_t argsize, |
| 250 size_t *size, struct quoting_options const *o); |
| 251 |
| 252 /* Use storage slot N to return a quoted version of the string ARG. |
| 253 Use the default quoting options. |
| 254 The returned value points to static storage that can be |
| 255 reused by the next call to this function with the same value of N. |
| 256 N must be nonnegative. The output of all functions in the |
| 257 quotearg_n family are guaranteed to not contain embedded null |
| 258 bytes.*/ |
| 259 char *quotearg_n (int n, char const *arg); |
| 260 |
| 261 /* Equivalent to quotearg_n (0, ARG). */ |
| 262 char *quotearg (char const *arg); |
| 263 |
| 264 /* Use storage slot N to return a quoted version of the argument ARG |
| 265 of size ARGSIZE. This is like quotearg_n (N, ARG), except it can |
| 266 quote null bytes. */ |
| 267 char *quotearg_n_mem (int n, char const *arg, size_t argsize); |
| 268 |
| 269 /* Equivalent to quotearg_n_mem (0, ARG, ARGSIZE). */ |
| 270 char *quotearg_mem (char const *arg, size_t argsize); |
| 271 |
| 272 /* Use style S and storage slot N to return a quoted version of the string ARG. |
| 273 This is like quotearg_n (N, ARG), except that it uses S with no other |
| 274 options to specify the quoting method. */ |
| 275 char *quotearg_n_style (int n, enum quoting_style s, char const *arg); |
| 276 |
| 277 /* Use style S and storage slot N to return a quoted version of the |
| 278 argument ARG of size ARGSIZE. This is like quotearg_n_style |
| 279 (N, S, ARG), except it can quote null bytes. */ |
| 280 char *quotearg_n_style_mem (int n, enum quoting_style s, |
| 281 char const *arg, size_t argsize); |
| 282 |
| 283 /* Equivalent to quotearg_n_style (0, S, ARG). */ |
| 284 char *quotearg_style (enum quoting_style s, char const *arg); |
| 285 |
| 286 /* Equivalent to quotearg_n_style_mem (0, S, ARG, ARGSIZE). */ |
| 287 char *quotearg_style_mem (enum quoting_style s, |
| 288 char const *arg, size_t argsize); |
| 289 |
| 290 /* Like quotearg (ARG), except also quote any instances of CH. */ |
| 291 char *quotearg_char (char const *arg, char ch); |
| 292 |
| 293 /* Like quotearg_char (ARG, CH), except it can quote null bytes. */ |
| 294 char *quotearg_char_mem (char const *arg, size_t argsize, char ch); |
| 295 |
| 296 /* Equivalent to quotearg_char (ARG, ':'). */ |
| 297 char *quotearg_colon (char const *arg); |
| 298 |
| 299 /* Like quotearg_colon (ARG), except it can quote null bytes. */ |
| 300 char *quotearg_colon_mem (char const *arg, size_t argsize); |
| 301 |
| 302 /* Free any dynamically allocated memory. */ |
| 303 void quotearg_free (void); |
| 304 |
| 305 #endif /* !QUOTEARG_H_ */ |
OLD | NEW |