/src/WasmEdge/lib/po/argument_parser.cpp

Source (jump to first uncovered line)
// SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2019-2024 Second State INC

#include "po/argument_parser.h"
#include "common/defines.h"
#include "common/spdlog.h"
#include "system/winapi.h"
#include <cstdio>

namespace WasmEdge {
namespace PO {

cxx20::expected<bool, Error> ArgumentParser::SubCommandDescriptor::parse(
    std::FILE *Out, Span<const char *> ProgramNamePrefix, int Argc,
    const char *Argv[], int ArgP, const bool &VersionOpt) noexcept {
  ProgramNames.reserve(ProgramNamePrefix.size() + 1);
  ProgramNames.assign(ProgramNamePrefix.begin(), ProgramNamePrefix.end());
  if (ArgP < Argc) {
    ProgramNames.push_back(Argv[ArgP]);
  }
  ArgumentDescriptor *CurrentDesc = nullptr;
  bool FirstNonOption = true;
  bool Escaped = false;
  auto PositionalIter = PositionalList.cbegin();
  for (int ArgI = ArgP + 1; ArgI < Argc; ++ArgI) {
    std::string_view Arg = Argv[ArgI];
    if (!Escaped && Arg.size() >= 2 && Arg[0] == '-') {
      if (Arg[1] == '-') {
        if (Arg.size() == 2) {
          Escaped = true;
        } else {
          // long option
          if (CurrentDesc && CurrentDesc->nargs() == 0) {
            CurrentDesc->default_value();
          }
          if (auto Res = consume_long_option_with_argument(Arg); !Res) {
            return cxx20::unexpected(Res.error());
          } else {
            CurrentDesc = *Res;
          }
        }
      } else {
        // short options
        if (CurrentDesc && CurrentDesc->nargs() == 0) {
          CurrentDesc->default_value();
        }
        if (auto Res = consume_short_options(Arg); !Res) {
          return cxx20::unexpected(Res.error());
        } else {
          CurrentDesc = *Res;
        }
      }
    } else if (!Escaped && CurrentDesc) {
      consume_argument(*CurrentDesc, Arg);
      CurrentDesc = nullptr;
    } else {
      // no more options
      if (FirstNonOption) {
        FirstNonOption = false;
        if (!SubCommandMap.empty()) {
          if (auto Iter = SubCommandMap.find(Arg);
              Iter != SubCommandMap.end()) {
            auto &Child = this[Iter->second];
            Child.SC->select();
            return Child.parse(Out, ProgramNames, Argc, Argv, ArgI, VersionOpt);
          }
        }
      }
      Escaped = true;
      if (CurrentDesc) {
        if (auto Res = consume_argument(*CurrentDesc, Arg); !Res) {
          return cxx20::unexpected(Res.error());
        } else {
          CurrentDesc = *Res;
        }
      } else {
        if (PositionalIter == PositionalList.cend()) {
          return cxx20::unexpected<Error>(
              std::in_place, ErrCode::InvalidArgument,
              "positional argument exceeds maximum consuming."s);
        }
        if (auto Res =
                consume_argument(ArgumentDescriptors[*PositionalIter], Arg);
            !Res) {
          return cxx20::unexpected(Res.error());
        } else {
          CurrentDesc = *Res;
        }
        ++PositionalIter;
      }
    }
  }
  if (CurrentDesc && CurrentDesc->nargs() == 0) {
    CurrentDesc->default_value();
  }

  if (VersionOpt) {
    return true;
  }
  if (!HelpOpt->value()) {
    for (const auto &Desc : ArgumentDescriptors) {
      if (Desc.nargs() < Desc.min_nargs()) {
        help(Out);
        return false;
      }
    }
  } else {
    help(Out);
    return true;
  }
  return true;
}

void ArgumentParser::SubCommandDescriptor::usage(
    std::FILE *Out) const noexcept {
  fmt::print(Out, "{}USAGE{}\n"sv, YELLOW_COLOR, RESET_COLOR);
  for (const char *Part : ProgramNames) {
    fmt::print(Out, "\t{}"sv, Part);
  }
  if (!SubCommandList.empty()) {
    fmt::print(Out, " [SUBCOMMANDS]"sv);
  }
  if (!NonpositionalList.empty()) {
    fmt::print(Out, " [OPTIONS]"sv);
  }
  bool First = true;
  for (const auto &Index : PositionalList) {
    const auto &Desc = ArgumentDescriptors[Index];
    if (Desc.hidden()) {
      continue;
    }

    if (First) {
      fmt::print(Out, " [--]"sv);
      First = false;
    }

    const bool Optional = (Desc.min_nargs() == 0);
    fmt::print(Out, " "sv);
    if (Optional) {
      fmt::print(Out, "["sv);
    }
    switch (ArgumentDescriptors[Index].max_nargs()) {
    case 0:
      break;
    case 1:
      fmt::print(Out, "{}"sv, Desc.meta());
      break;
    default:
      fmt::print(Out, "{} ..."sv, Desc.meta());
      break;
    }
    if (Optional) {
      fmt::print(Out, "]"sv);
    }
  }
  fmt::print(Out, "\n"sv);
}

void ArgumentParser::SubCommandDescriptor::help(std::FILE *Out) const noexcept {
// For enabling Windows PowerShell color support.
#if WASMEDGE_OS_WINDOWS && WINAPI_PARTITION_DESKTOP
  winapi::HANDLE_ OutputHandler =
      winapi::GetStdHandle(winapi::STD_OUTPUT_HANDLE_);
  if (OutputHandler != winapi::INVALID_HANDLE_VALUE_) {
    winapi::DWORD_ ConsoleMode = 0;
    if (winapi::GetConsoleMode(OutputHandler, &ConsoleMode)) {
      ConsoleMode |= winapi::ENABLE_VIRTUAL_TERMINAL_PROCESSING_;
      winapi::SetConsoleMode(OutputHandler, ConsoleMode);
    }
  }
#endif

  usage(Out);
  const constexpr std::string_view kIndent = "\t"sv;

  fmt::print(Out, "\n"sv);
  if (!SubCommandList.empty()) {
    fmt::print(Out, "{}SUBCOMMANDS{}\n"sv, YELLOW_COLOR, RESET_COLOR);
    for (const auto Offset : SubCommandList) {
      fmt::print(Out, "{}{}"sv, kIndent, GREEN_COLOR);
      bool First = true;
      for (const auto &Name : this[Offset].SubCommandNames) {
        if (!First) {
          fmt::print(Out, "|"sv);
        }
        fmt::print(Out, "{}"sv, Name);
        First = false;
      }
      fmt::print(Out, "{}\n"sv, RESET_COLOR);
      indent_output(Out, kIndent, 2, 80, this[Offset].SC->description());
      fmt::print(Out, "\n"sv);
    }
    fmt::print(Out, "\n"sv);
  }

  fmt::print(Out, "{}OPTIONS{}\n"sv, YELLOW_COLOR, RESET_COLOR);
  for (const auto &Index : NonpositionalList) {
    const auto &Desc = ArgumentDescriptors[Index];
    if (Desc.hidden()) {
      continue;
    }

    fmt::print(Out, "{}{}\n"sv, kIndent, GREEN_COLOR);
    bool First = true;
    for (const auto &Option : Desc.options()) {
      if (!First) {
        fmt::print(Out, "|"sv);
      }
      if (Option.size() == 1) {
        fmt::print(Out, "-{}"sv, Option);
      } else {
        fmt::print(Out, "--{}"sv, Option);
      }
      First = false;
    }
    fmt::print(Out, "{}\n"sv, RESET_COLOR);
    indent_output(Out, kIndent, 2, 80, Desc.description());
    fmt::print(Out, "\n"sv);
  }
}

void ArgumentParser::SubCommandDescriptor::indent_output(
    std::FILE *Out, const std::string_view kIndent, std::size_t IndentCount,
    std::size_t ScreenWidth, std::string_view Desc) const noexcept {
  const std::size_t Width = ScreenWidth - kIndent.size() * IndentCount;
  while (Desc.size() > Width) {
    const std::size_t SpacePos = Desc.find_last_of(' ', Width);
    if (SpacePos != std::string_view::npos) {
      for (std::size_t I = 0; I < IndentCount; ++I) {
        fmt::print(Out, "{}"sv, kIndent);
      }
      fmt::print(Out, "{}\n"sv, Desc.substr(0, SpacePos));
      const std::size_t WordPos = Desc.find_first_not_of(' ', SpacePos);
      if (WordPos != std::string_view::npos) {
        Desc = Desc.substr(WordPos);
      } else {
        Desc = {};
      }
    }
  }
  if (!Desc.empty()) {
    for (std::size_t I = 0; I < IndentCount; ++I) {
      fmt::print(Out, "{}"sv, kIndent);
    }
    fmt::print(Out, "{}"sv, Desc);
  }
}

cxx20::expected<ArgumentParser::ArgumentDescriptor *, Error>
ArgumentParser::SubCommandDescriptor::consume_short_options(
    std::string_view Arg) noexcept {
  ArgumentDescriptor *CurrentDesc = nullptr;
  for (std::size_t I = 1; I < Arg.size(); ++I) {
    if (CurrentDesc && CurrentDesc->nargs() == 0) {
      CurrentDesc->default_value();
    }
    std::string_view Option = Arg.substr(I, 1);
    if (auto Res = consume_short_option(Option); !Res) {
      return cxx20::unexpected(Res.error());
    } else {
      CurrentDesc = *Res;
    }
  }
  return CurrentDesc;
}

cxx20::expected<ArgumentParser::ArgumentDescriptor *, Error>
ArgumentParser::SubCommandDescriptor::consume_long_option_with_argument(
    std::string_view Arg) noexcept {
  if (auto Pos = Arg.find('=', 2); Pos != std::string_view::npos) {
    // long option with argument
    std::string_view Option = Arg.substr(2, Pos - 2);
    std::string_view Argument = Arg.substr(Pos + 1);
    if (auto Res = consume_long_option(Option); !Res) {
      return cxx20::unexpected<Error>(Res.error());
    } else if (ArgumentDescriptor *CurrentDesc = *Res; !CurrentDesc) {
      return cxx20::unexpected<Error>(std::in_place, ErrCode::InvalidArgument,
                                      "option "s + std::string(Option) +
                                          "doesn't need arguments."s);
    } else {
      consume_argument(*CurrentDesc, Argument);
      return nullptr;
    }
  } else {
    // long option without argument
    std::string_view Option = Arg.substr(2);
    return consume_long_option(Option);
  }
}

cxx20::expected<ArgumentParser::ArgumentDescriptor *, Error>
ArgumentParser::SubCommandDescriptor::consume_short_option(
    std::string_view Option) noexcept {
  auto Iter = ArgumentMap.find(Option);
  if (Iter == ArgumentMap.end()) {
    return cxx20::unexpected<Error>(std::in_place, ErrCode::InvalidArgument,
                                    "unknown option: "s + std::string(Option));
  }
  ArgumentDescriptor &CurrentDesc = ArgumentDescriptors[Iter->second];
  if (CurrentDesc.max_nargs() == 0) {
    CurrentDesc.default_value();
    return nullptr;
  }
  return &CurrentDesc;
}

cxx20::expected<ArgumentParser::ArgumentDescriptor *, Error>
ArgumentParser::SubCommandDescriptor::consume_long_option(
    std::string_view Option) noexcept {
  auto Iter = ArgumentMap.find(Option);
  if (Iter == ArgumentMap.end()) {
    return cxx20::unexpected<Error>(std::in_place, ErrCode::InvalidArgument,
                                    "unknown option: "s + std::string(Option));
  }
  ArgumentDescriptor &CurrentDesc = ArgumentDescriptors[Iter->second];
  if (CurrentDesc.max_nargs() == 0) {
    CurrentDesc.default_value();
    return nullptr;
  }
  return &CurrentDesc;
}

cxx20::expected<ArgumentParser::ArgumentDescriptor *, Error>
ArgumentParser::SubCommandDescriptor::consume_argument(
    ArgumentDescriptor &CurrentDesc, std::string_view Argument) noexcept {
  if (auto Res = CurrentDesc.argument(std::string(Argument)); !Res) {
    return cxx20::unexpected(Res.error());
  }
  if (++CurrentDesc.nargs() >= CurrentDesc.max_nargs()) {
    return nullptr;
  }
  return &CurrentDesc;
}

bool ArgumentParser::parse(std::FILE *Out, int Argc,
                           const char *Argv[]) noexcept {
  if (auto Res = SubCommandDescriptors.front().parse(Out, {}, Argc, Argv, 0,
                                                     VerOpt.value());
      !Res) {
    fmt::print(Out, "{}\n"sv, Res.error().message());
    return false;
  } else {
    return *Res || VerOpt.value();
  }
}

} // namespace PO
} // namespace WasmEdge

Coverage Report

Created: 2025-07-18 06:13

Line	Count	Source (jump to first uncovered line)
1		// SPDX-License-Identifier: Apache-2.0
2		// SPDX-FileCopyrightText: 2019-2024 Second State INC
3
4		#include "po/argument_parser.h"
5		#include "common/defines.h"
6		#include "common/spdlog.h"
7		#include "system/winapi.h"
8		#include <cstdio>
9
10		namespace WasmEdge {
11		namespace PO {
12
13		cxx20::expected<bool, Error> ArgumentParser::SubCommandDescriptor::parse(
14		std::FILE Out, Span<const char > ProgramNamePrefix, int Argc,
15	1.95k	const char *Argv[], int ArgP, const bool &VersionOpt) noexcept {
16	1.95k	ProgramNames.reserve(ProgramNamePrefix.size() + 1);
17	1.95k	ProgramNames.assign(ProgramNamePrefix.begin(), ProgramNamePrefix.end());
18	1.95k	if (ArgP < Argc) {
19	1.95k	ProgramNames.push_back(Argv[ArgP]);
20	1.95k	}
21	1.95k	ArgumentDescriptor *CurrentDesc = nullptr;
22	1.95k	bool FirstNonOption = true;
23	1.95k	bool Escaped = false;
24	1.95k	auto PositionalIter = PositionalList.cbegin();
25	2.67M	for (int ArgI = ArgP + 1; ArgI < Argc; ++ArgI) {
26	2.67M	std::string_view Arg = Argv[ArgI];
27	2.67M	if (!Escaped && Arg.size() >= 2 && Arg[0] == '-') {
28	290k	if (Arg[1] == '-') {
29	288k	if (Arg.size() == 2) {
30	97	Escaped = true;
31	288k	} else {
32		// long option
33	288k	if (CurrentDesc && CurrentDesc->nargs() == 0) {
34	2.46k	CurrentDesc->default_value();
35	2.46k	}
36	288k	if (auto Res = consume_long_option_with_argument(Arg); !Res) {
37	333	return cxx20::unexpected(Res.error());
38	288k	} else {
39	288k	CurrentDesc = *Res;
40	288k	}
41	288k	}
42	288k	} else {
43		// short options
44	2.34k	if (CurrentDesc && CurrentDesc->nargs() == 0) {
45	316	CurrentDesc->default_value();
46	316	}
47	2.34k	if (auto Res = consume_short_options(Arg); !Res) {
48	31	return cxx20::unexpected(Res.error());
49	2.31k	} else {
50	2.31k	CurrentDesc = *Res;
51	2.31k	}
52	2.34k	}
53	2.38M	} else if (!Escaped && CurrentDesc) {
54	2.47k	consume_argument(*CurrentDesc, Arg);
55	2.47k	CurrentDesc = nullptr;
56	2.37M	} else {
57		// no more options
58	2.37M	if (FirstNonOption) {
59	798	FirstNonOption = false;
60	798	if (!SubCommandMap.empty()) {
61	0	if (auto Iter = SubCommandMap.find(Arg);
62	0	Iter != SubCommandMap.end()) {
63	0	auto &Child = this[Iter->second];
64	0	Child.SC->select();
65	0	return Child.parse(Out, ProgramNames, Argc, Argv, ArgI, VersionOpt);
66	0	}
67	0	}
68	798	}
69	2.37M	Escaped = true;
70	2.37M	if (CurrentDesc) {
71	2.37M	if (auto Res = consume_argument(*CurrentDesc, Arg); !Res) {
72	3	return cxx20::unexpected(Res.error());
73	2.37M	} else {
74	2.37M	CurrentDesc = *Res;
75	2.37M	}
76	2.37M	} else {
77	1.17k	if (PositionalIter == PositionalList.cend()) {
78	0	return cxx20::unexpected<Error>(
79	0	std::in_place, ErrCode::InvalidArgument,
80	0	"positional argument exceeds maximum consuming."s);
81	0	}
82	1.17k	if (auto Res =
83	1.17k	consume_argument(ArgumentDescriptors[*PositionalIter], Arg);
84	1.17k	!Res) {
85	0	return cxx20::unexpected(Res.error());
86	1.17k	} else {
87	1.17k	CurrentDesc = *Res;
88	1.17k	}
89	1.17k	++PositionalIter;
90	1.17k	}
91	2.37M	}
92	2.67M	}
93	1.58k	if (CurrentDesc && CurrentDesc->nargs() == 0) {
94	30	CurrentDesc->default_value();
95	30	}
96
97	1.58k	if (VersionOpt) {
98	310	return true;
99	310	}
100	1.27k	if (!HelpOpt->value()) {
101	20.0k	for (const auto &Desc : ArgumentDescriptors) {
102	20.0k	if (Desc.nargs() < Desc.min_nargs()) {
103	549	help(Out);
104	549	return false;
105	549	}
106	20.0k	}
107	1.23k	} else {
108	46	help(Out);
109	46	return true;
110	46	}
111	681	return true;
112	1.27k	}
113
114		void ArgumentParser::SubCommandDescriptor::usage(
115	595	std::FILE *Out) const noexcept {
116	595	fmt::print(Out, "{}USAGE{}\n"sv, YELLOW_COLOR, RESET_COLOR);
117	595	for (const char *Part : ProgramNames) {
118	595	fmt::print(Out, "\t{}"sv, Part);
119	595	}
120	595	if (!SubCommandList.empty()) {
121	0	fmt::print(Out, " [SUBCOMMANDS]"sv);
122	0	}
123	595	if (!NonpositionalList.empty()) {
124	595	fmt::print(Out, " [OPTIONS]"sv);
125	595	}
126	595	bool First = true;
127	1.19k	for (const auto &Index : PositionalList) {
128	1.19k	const auto &Desc = ArgumentDescriptors[Index];
129	1.19k	if (Desc.hidden()) {
130	0	continue;
131	0	}
132
133	1.19k	if (First) {
134	595	fmt::print(Out, " [--]"sv);
135	595	First = false;
136	595	}
137
138	1.19k	const bool Optional = (Desc.min_nargs() == 0);
139	1.19k	fmt::print(Out, " "sv);
140	1.19k	if (Optional) {
141	595	fmt::print(Out, "["sv);
142	595	}
143	1.19k	switch (ArgumentDescriptors[Index].max_nargs()) {
144	0	case 0:
145	0	break;
146	595	case 1:
147	595	fmt::print(Out, "{}"sv, Desc.meta());
148	595	break;
149	595	default:
150	595	fmt::print(Out, "{} ..."sv, Desc.meta());
151	595	break;
152	1.19k	}
153	1.19k	if (Optional) {
154	595	fmt::print(Out, "]"sv);
155	595	}
156	1.19k	}
157	595	fmt::print(Out, "\n"sv);
158	595	}
159
160	595	void ArgumentParser::SubCommandDescriptor::help(std::FILE *Out) const noexcept {
161		// For enabling Windows PowerShell color support.
162		#if WASMEDGE_OS_WINDOWS && WINAPI_PARTITION_DESKTOP
163		winapi::HANDLE_ OutputHandler =
164		winapi::GetStdHandle(winapi::STD_OUTPUT_HANDLE_);
165		if (OutputHandler != winapi::INVALID_HANDLE_VALUE_) {
166		winapi::DWORD_ ConsoleMode = 0;
167		if (winapi::GetConsoleMode(OutputHandler, &ConsoleMode)) {
168		ConsoleMode \|= winapi::ENABLE_VIRTUAL_TERMINAL_PROCESSING_;
169		winapi::SetConsoleMode(OutputHandler, ConsoleMode);
170		}
171		}
172		#endif
173
174	595	usage(Out);
175	595	const constexpr std::string_view kIndent = "\t"sv;
176
177	595	fmt::print(Out, "\n"sv);
178	595	if (!SubCommandList.empty()) {
179	0	fmt::print(Out, "{}SUBCOMMANDS{}\n"sv, YELLOW_COLOR, RESET_COLOR);
180	0	for (const auto Offset : SubCommandList) {
181	0	fmt::print(Out, "{}{}"sv, kIndent, GREEN_COLOR);
182	0	bool First = true;
183	0	for (const auto &Name : this[Offset].SubCommandNames) {
184	0	if (!First) {
185	0	fmt::print(Out, "\|"sv);
186	0	}
187	0	fmt::print(Out, "{}"sv, Name);
188	0	First = false;
189	0	}
190	0	fmt::print(Out, "{}\n"sv, RESET_COLOR);
191	0	indent_output(Out, kIndent, 2, 80, this[Offset].SC->description());
192	0	fmt::print(Out, "\n"sv);
193	0	}
194	0	fmt::print(Out, "\n"sv);
195	0	}
196
197	595	fmt::print(Out, "{}OPTIONS{}\n"sv, YELLOW_COLOR, RESET_COLOR);
198	14.8k	for (const auto &Index : NonpositionalList) {
199	14.8k	const auto &Desc = ArgumentDescriptors[Index];
200	14.8k	if (Desc.hidden()) {
201	0	continue;
202	0	}
203
204	14.8k	fmt::print(Out, "{}{}\n"sv, kIndent, GREEN_COLOR);
205	14.8k	bool First = true;
206	16.0k	for (const auto &Option : Desc.options()) {
207	16.0k	if (!First) {
208	1.19k	fmt::print(Out, "\|"sv);
209	1.19k	}
210	16.0k	if (Option.size() == 1) {
211	1.19k	fmt::print(Out, "-{}"sv, Option);
212	14.8k	} else {
213	14.8k	fmt::print(Out, "--{}"sv, Option);
214	14.8k	}
215	16.0k	First = false;
216	16.0k	}
217	14.8k	fmt::print(Out, "{}\n"sv, RESET_COLOR);
218	14.8k	indent_output(Out, kIndent, 2, 80, Desc.description());
219	14.8k	fmt::print(Out, "\n"sv);
220	14.8k	}
221	595	}
222
223		void ArgumentParser::SubCommandDescriptor::indent_output(
224		std::FILE *Out, const std::string_view kIndent, std::size_t IndentCount,
225	14.8k	std::size_t ScreenWidth, std::string_view Desc) const noexcept {
226	14.8k	const std::size_t Width = ScreenWidth - kIndent.size() * IndentCount;
227	18.4k	while (Desc.size() > Width) {
228	3.57k	const std::size_t SpacePos = Desc.find_last_of(' ', Width);
229	3.57k	if (SpacePos != std::string_view::npos) {
230	10.7k	for (std::size_t I = 0; I < IndentCount; ++I) {
231	7.14k	fmt::print(Out, "{}"sv, kIndent);
232	7.14k	}
233	3.57k	fmt::print(Out, "{}\n"sv, Desc.substr(0, SpacePos));
234	3.57k	const std::size_t WordPos = Desc.find_first_not_of(' ', SpacePos);
235	3.57k	if (WordPos != std::string_view::npos) {
236	3.57k	Desc = Desc.substr(WordPos);
237	3.57k	} else {
238	0	Desc = {};
239	0	}
240	3.57k	}
241	3.57k	}
242	14.8k	if (!Desc.empty()) {
243	44.6k	for (std::size_t I = 0; I < IndentCount; ++I) {
244	29.7k	fmt::print(Out, "{}"sv, kIndent);
245	29.7k	}
246	14.8k	fmt::print(Out, "{}"sv, Desc);
247	14.8k	}
248	14.8k	}
249
250		cxx20::expected<ArgumentParser::ArgumentDescriptor *, Error>
251		ArgumentParser::SubCommandDescriptor::consume_short_options(
252	2.34k	std::string_view Arg) noexcept {
253	2.34k	ArgumentDescriptor *CurrentDesc = nullptr;
254	1.15M	for (std::size_t I = 1; I < Arg.size(); ++I) {
255	1.15M	if (CurrentDesc && CurrentDesc->nargs() == 0) {
256	0	CurrentDesc->default_value();
257	0	}
258	1.15M	std::string_view Option = Arg.substr(I, 1);
259	1.15M	if (auto Res = consume_short_option(Option); !Res) {
260	31	return cxx20::unexpected(Res.error());
261	1.15M	} else {
262	1.15M	CurrentDesc = *Res;
263	1.15M	}
264	1.15M	}
265	2.31k	return CurrentDesc;
266	2.34k	}
267
268		cxx20::expected<ArgumentParser::ArgumentDescriptor *, Error>
269		ArgumentParser::SubCommandDescriptor::consume_long_option_with_argument(
270	288k	std::string_view Arg) noexcept {
271	288k	if (auto Pos = Arg.find('=', 2); Pos != std::string_view::npos) {
272		// long option with argument
273	275k	std::string_view Option = Arg.substr(2, Pos - 2);
274	275k	std::string_view Argument = Arg.substr(Pos + 1);
275	275k	if (auto Res = consume_long_option(Option); !Res) {
276	49	return cxx20::unexpected<Error>(Res.error());
277	275k	} else if (ArgumentDescriptor CurrentDesc = Res; !CurrentDesc) {
278	14	return cxx20::unexpected<Error>(std::in_place, ErrCode::InvalidArgument,
279	14	"option "s + std::string(Option) +
280	14	"doesn't need arguments."s);
281	275k	} else {
282	275k	consume_argument(*CurrentDesc, Argument);
283	275k	return nullptr;
284	275k	}
285	275k	} else {
286		// long option without argument
287	12.6k	std::string_view Option = Arg.substr(2);
288	12.6k	return consume_long_option(Option);
289	12.6k	}
290	288k	}
291
292		cxx20::expected<ArgumentParser::ArgumentDescriptor *, Error>
293		ArgumentParser::SubCommandDescriptor::consume_short_option(
294	1.15M	std::string_view Option) noexcept {
295	1.15M	auto Iter = ArgumentMap.find(Option);
296	1.15M	if (Iter == ArgumentMap.end()) {
297	31	return cxx20::unexpected<Error>(std::in_place, ErrCode::InvalidArgument,
298	31	"unknown option: "s + std::string(Option));
299	31	}
300	1.15M	ArgumentDescriptor &CurrentDesc = ArgumentDescriptors[Iter->second];
301	1.15M	if (CurrentDesc.max_nargs() == 0) {
302	1.15M	CurrentDesc.default_value();
303	1.15M	return nullptr;
304	1.15M	}
305	0	return &CurrentDesc;
306	1.15M	}
307
308		cxx20::expected<ArgumentParser::ArgumentDescriptor *, Error>
309		ArgumentParser::SubCommandDescriptor::consume_long_option(
310	288k	std::string_view Option) noexcept {
311	288k	auto Iter = ArgumentMap.find(Option);
312	288k	if (Iter == ArgumentMap.end()) {
313	319	return cxx20::unexpected<Error>(std::in_place, ErrCode::InvalidArgument,
314	319	"unknown option: "s + std::string(Option));
315	319	}
316	288k	ArgumentDescriptor &CurrentDesc = ArgumentDescriptors[Iter->second];
317	288k	if (CurrentDesc.max_nargs() == 0) {
318	1.87k	CurrentDesc.default_value();
319	1.87k	return nullptr;
320	1.87k	}
321	286k	return &CurrentDesc;
322	288k	}
323
324		cxx20::expected<ArgumentParser::ArgumentDescriptor *, Error>
325		ArgumentParser::SubCommandDescriptor::consume_argument(
326	2.65M	ArgumentDescriptor &CurrentDesc, std::string_view Argument) noexcept {
327	2.65M	if (auto Res = CurrentDesc.argument(std::string(Argument)); !Res) {
328	2.28k	return cxx20::unexpected(Res.error());
329	2.28k	}
330	2.65M	if (++CurrentDesc.nargs() >= CurrentDesc.max_nargs()) {
331	66.7k	return nullptr;
332	66.7k	}
333	2.58M	return &CurrentDesc;
334	2.65M	}
335
336		bool ArgumentParser::parse(std::FILE *Out, int Argc,
337	1.95k	const char *Argv[]) noexcept {
338	1.95k	if (auto Res = SubCommandDescriptors.front().parse(Out, {}, Argc, Argv, 0,
339	1.95k	VerOpt.value());
340	1.95k	!Res) {
341	367	fmt::print(Out, "{}\n"sv, Res.error().message());
342	367	return false;
343	1.58k	} else {
344	1.58k	return *Res \|\| VerOpt.value();
345	1.58k	}
346	1.95k	}
347
348		} // namespace PO
349		} // namespace WasmEdge