poaflocParser Of Arguments For Lines Of Commands |
| git clone git://git.dimitrijedobrota.com/poafloc.git |
| Log | Files | Refs | README | LICENSE | HACKING | CONTRIBUTING | CODE_OF_CONDUCT | BUILDING | |
poafloc.cpp (9917B)
1 #include <algorithm> 2 #include <cstring> 3 #include <format> 4 #include <iostream> 5 #include <sstream> 6 7 #include "poafloc/poafloc.hpp" 8 9 namespace poafloc { 10 11 int parse(const arg_t* argp, 12 int argc, 13 char* argv[], 14 unsigned flags, 15 void* input) noexcept 16 { 17 Parser parser(argp, flags, input); 18 return parser.parse(static_cast<std::size_t>(argc), argv); 19 } 20 21 void usage(const Parser* parser) 22 { 23 help(parser, stderr, Help::STD_USAGE); 24 } 25 26 void help(const Parser* parser, FILE* stream, unsigned flags) 27 { 28 if ((parser == nullptr) || (stream == nullptr)) return; 29 30 if ((flags & LONG) != 0U) parser->help(stream); 31 else if ((flags & USAGE) != 0U) parser->usage(stream); 32 else if ((flags & SEE) != 0U) parser->see(stream); 33 34 if ((parser->flags() & NO_EXIT) != 0U) return; 35 36 if ((flags & EXIT_ERR) != 0U) exit(2); 37 if ((flags & EXIT_OK) != 0U) exit(0); 38 } 39 40 void failure(const Parser* parser, 41 int status, 42 int errnum, 43 const char* fmt, 44 std::va_list args) 45 { 46 (void)errnum; 47 48 std::cerr << parser->name() << ": "; 49 std::ignore = std::vfprintf(stderr, fmt, args); // NOLINT 50 std::cerr << '\n'; 51 52 if (status != 0) exit(status); 53 } 54 55 void failure( 56 const Parser* parser, int status, int errnum, const char* fmt, ...) 57 { 58 std::va_list args; 59 va_start(args, fmt); 60 failure(parser, status, errnum, fmt, args); 61 va_end(args); 62 } 63 64 Parser::Parser(const arg_t* argp, unsigned flags, void* input) 65 : m_argp(argp) 66 , m_flags(flags) 67 , m_input(input) 68 { 69 int group = 0; 70 int key_last = 0; 71 bool hidden = false; 72 73 for (int i = 0; true; i++) 74 { 75 const auto& opt = argp->options[i]; // NOLINT 76 77 if ((opt.name == nullptr) && (opt.key == 0) && (opt.message == nullptr)) 78 break; 79 80 if ((opt.name == nullptr) && (opt.key == 0)) 81 { 82 group = opt.group != 0U ? opt.group : group + 1; 83 m_help_entries.emplace_back(nullptr, opt.message, group); 84 continue; 85 } 86 87 if (opt.key == 0) 88 { 89 // non alias without a key, silently ignoring 90 if ((opt.flags & ALIAS) == 0) continue; 91 92 // nothing to alias, silently ignoring 93 if (key_last == 0) continue; 94 95 // option not valid, silently ignoring 96 if (!m_trie.insert(opt.name, key_last)) continue; 97 98 if (hidden) continue; 99 if ((opt.flags & Option::HIDDEN) != 0U) continue; 100 101 m_help_entries.back().push(opt.name); 102 } 103 else 104 { 105 // duplicate key, silently ignoring 106 if (m_options.contains(opt.key)) continue; 107 108 if (opt.name != nullptr) m_trie.insert(opt.name, opt.key); 109 m_options[key_last = opt.key] = &opt; 110 111 bool const arg_opt = (opt.flags & Option::ARG_OPTIONAL) != 0U; 112 113 if ((opt.flags & ALIAS) == 0U) 114 { 115 hidden = (opt.flags & Option::HIDDEN) != 0; 116 if (hidden) continue; 117 118 m_help_entries.emplace_back(opt.arg, opt.message, group, arg_opt); 119 120 if (opt.name != nullptr) m_help_entries.back().push(opt.name); 121 122 if (std::isprint(opt.key) != 0U) 123 { 124 m_help_entries.back().push(static_cast<char>(opt.key & 0xFF)); 125 } 126 } 127 else 128 { 129 // nothing to alias, silently ignoring 130 if (key_last == 0) continue; 131 if (hidden) continue; 132 if ((opt.flags & Option::HIDDEN) != 0U) continue; 133 134 if (opt.name != nullptr) m_help_entries.back().push(opt.name); 135 if (std::isprint(opt.key) != 0U) 136 { 137 m_help_entries.back().push(static_cast<char>(opt.key & 0xFF)); 138 } 139 } 140 } 141 } 142 143 if ((m_flags & NO_HELP) == 0U) 144 { 145 m_help_entries.emplace_back(nullptr, "Give this help list", -1); 146 m_help_entries.back().push("help"); 147 m_help_entries.back().push('?'); 148 m_help_entries.emplace_back(nullptr, "Give a short usage message", -1); 149 m_help_entries.back().push("usage"); 150 } 151 152 std::sort(begin(m_help_entries), end(m_help_entries)); 153 } 154 155 int Parser::parse(std::size_t argc, char* argv[]) 156 { 157 const std::span args(argv, argv + argc); 158 159 std::vector<const char*> args_free; 160 std::size_t idx = 0; 161 int arg_cnt = 0; 162 int err_code = 0; 163 164 const bool is_help = (m_flags & NO_HELP) == 0U; 165 const bool is_error = (m_flags & NO_ERRS) == 0U; 166 167 m_name = basename(args[0]); 168 m_argp->parse(Key::INIT, nullptr, this); 169 170 for (idx = 1; idx < argc; idx++) 171 { 172 if (args[idx][0] != '-') 173 { 174 if ((m_flags & IN_ORDER) != 0U) 175 { 176 err_code = m_argp->parse(Key::ARG, args[idx], this); 177 if (err_code != 0) goto error; 178 } 179 else args_free.push_back(args[idx]); 180 181 arg_cnt++; 182 continue; 183 } 184 185 // stop parsing options, rest are normal arguments 186 if (std::strcmp(args[idx], "--") == 0) break; 187 188 if (args[idx][1] != '-') 189 { // short option 190 const std::string opt = args[idx] + 1; 191 192 // loop over ganged options 193 for (std::size_t j = 0; opt[j] != 0; j++) 194 { 195 const char key = opt[j]; 196 197 if (is_help && key == '?') 198 { 199 if (is_error) ::poafloc::help(this, stderr, STD_HELP); 200 continue; 201 } 202 203 if (!m_options.contains(key)) 204 { 205 err_code = handle_unknown(false, args[idx]); 206 goto error; 207 } 208 209 const auto* option = m_options[key]; 210 bool const is_opt = (option->flags & ARG_OPTIONAL) != 0; 211 212 if (option->arg == nullptr) 213 { 214 err_code = m_argp->parse(key, nullptr, this); 215 if (err_code != 0) goto error; 216 continue; 217 } 218 219 if (opt[j + 1] != 0) 220 { 221 err_code = m_argp->parse(key, opt.substr(j + 1).c_str(), this); 222 if (err_code != 0) goto error; 223 break; 224 } 225 226 if (is_opt) 227 { 228 err_code = m_argp->parse(key, nullptr, this); 229 if (err_code != 0) goto error; 230 continue; 231 } 232 233 if (idx + 1 != argc) 234 { 235 err_code = m_argp->parse(key, args[++idx], this); 236 if (err_code != 0) goto error; 237 break; 238 } 239 240 err_code = handle_missing(true, args[idx]); 241 goto error; 242 } 243 } 244 else 245 { // long option 246 const std::string tmp = args[idx] + 2; 247 const auto pos = tmp.find_first_of('='); 248 const auto opt = tmp.substr(0, pos); 249 const auto arg = tmp.substr(pos + 1); 250 251 if (is_help && opt == "help") 252 { 253 if (pos != std::string::npos) 254 { 255 err_code = handle_excess(args[idx]); 256 goto error; 257 } 258 259 if (!is_error) continue; 260 ::poafloc::help(this, stderr, STD_HELP); 261 } 262 263 if (is_help && opt == "usage") 264 { 265 if (pos != std::string::npos) 266 { 267 err_code = handle_excess(args[idx]); 268 goto error; 269 } 270 271 if (!is_error) continue; 272 ::poafloc::help(this, stderr, STD_USAGE); 273 } 274 275 const int key = m_trie.get(opt); 276 if (key == 0) 277 { 278 err_code = handle_unknown(false, args[idx]); 279 goto error; 280 } 281 282 const auto* option = m_options[key]; 283 if (pos != std::string::npos && option->arg == nullptr) 284 { 285 err_code = handle_excess(args[idx]); 286 goto error; 287 } 288 289 const bool is_opt = (option->flags & ARG_OPTIONAL) != 0; 290 291 if (option->arg == nullptr) 292 { 293 err_code = m_argp->parse(key, nullptr, this); 294 if (err_code != 0) goto error; 295 continue; 296 } 297 298 if (pos != std::string::npos) 299 { 300 err_code = m_argp->parse(key, arg.c_str(), this); 301 if (err_code != 0) goto error; 302 continue; 303 } 304 305 if (is_opt) 306 { 307 err_code = m_argp->parse(key, nullptr, this); 308 if (err_code != 0) goto error; 309 continue; 310 } 311 312 if (idx + 1 != argc) 313 { 314 err_code = m_argp->parse(key, args[++idx], this); 315 if (err_code != 0) goto error; 316 continue; 317 } 318 319 err_code = handle_missing(false, args[idx]); 320 goto error; 321 } 322 } 323 324 // parse previous arguments if IN_ORDER is not set 325 for (const auto* const arg : args_free) 326 { 327 err_code = m_argp->parse(Key::ARG, arg, this); 328 if (err_code != 0) goto error; 329 } 330 331 // parse rest argv as normal arguments 332 for (idx = idx + 1; idx < argc; idx++) 333 { 334 err_code = m_argp->parse(Key::ARG, args[idx], this); 335 if (err_code != 0) goto error; 336 arg_cnt++; 337 } 338 339 if (arg_cnt == 0) m_argp->parse(Key::NO_ARGS, nullptr, this); 340 341 err_code = m_argp->parse(Key::END, nullptr, this); 342 if (err_code != 0) goto error; 343 344 err_code = m_argp->parse(Key::SUCCESS, nullptr, this); 345 if (err_code != 0) goto error; 346 347 return 0; 348 349 error: 350 m_argp->parse(Key::ERROR, nullptr, this); 351 return err_code; 352 } 353 354 int Parser::handle_unknown(bool shrt, const char* argv) 355 { 356 if ((m_flags & NO_ERRS) != 0U) 357 return m_argp->parse(Key::ERROR, nullptr, this); 358 359 static const char* const unknown_fmt[2] = { 360 "unrecognized option '-%s'\n", 361 "invalid option -- '%s'\n", 362 }; 363 364 failure(this, 1, 0, unknown_fmt[shrt], argv + 1); // NOLINT 365 see(stderr); 366 367 if ((m_flags & NO_EXIT) != 0U) return 1; 368 exit(1); 369 } 370 371 int Parser::handle_missing(bool shrt, const char* argv) 372 { 373 if ((m_flags & NO_ERRS) != 0U) 374 return m_argp->parse(Key::ERROR, nullptr, this); 375 376 static const char* const missing_fmt[2] = { 377 "option '-%s' requires an argument\n", 378 "option requires an argument -- '%s'\n", 379 }; 380 381 failure(this, 2, 0, missing_fmt[shrt], argv + 1); // NOLINT 382 see(stderr); 383 384 if ((m_flags & NO_EXIT) != 0U) return 2; 385 exit(2); 386 } 387 388 int Parser::handle_excess(const char* argv) 389 { 390 if ((m_flags & NO_ERRS) != 0U) 391 { 392 return m_argp->parse(Key::ERROR, nullptr, this); 393 } 394 395 failure(this, 3, 0, "option '%s' doesn't allow an argument\n", argv); 396 see(stderr); 397 398 if ((m_flags & NO_EXIT) != 0U) return 3; 399 exit(3); 400 } 401 402 std::string Parser::basename(const std::string& name) 403 { 404 return name.substr(name.find_first_of('/') + 1); 405 } 406 407 } // namespace poafloc