#!/usr/bin/env python3 """Generate LspCpp protocol types and handler registrations from the LSP metaModel.""" from __future__ import annotations import argparse import json import re import sys from collections import OrderedDict from dataclasses import dataclass, field from pathlib import Path from typing import Dict, Iterable, List, Optional, Set, Tuple SCRIPT_DIR = Path(__file__).resolve().parent if str(SCRIPT_DIR) not in sys.path: sys.path.insert(0, str(SCRIPT_DIR)) import check_lsp_metamodel_coverage as coverage # noqa: E402 GENERATED_HEADER = "include/LibLsp/lsp/generated/lsp_generated_protocol.h" HANDLER_FILE = "src/lsp/ProtocolJsonHandler.cpp" GENERATED_INCLUDE = "LibLsp/lsp/generated/lsp_generated_protocol.h" BEGIN_HEADER = "// BEGIN LSPGEN generated protocol types" END_HEADER = "// END LSPGEN generated protocol types" BEGIN_CLIENT_REQ = " // BEGIN LSPGEN client request registrations" END_CLIENT_REQ = " // END LSPGEN client request registrations" BEGIN_SERVER_REQ = " // BEGIN LSPGEN server-initiated request registrations" END_SERVER_REQ = " // END LSPGEN server-initiated request registrations" BEGIN_RSP = " // BEGIN LSPGEN response registrations" END_RSP = " // END LSPGEN response registrations" BEGIN_NTF = " // BEGIN LSPGEN notification registrations" END_NTF = " // END LSPGEN notification registrations" BASE_TYPE_MAP = { "string": "std::string", "boolean": "bool", "integer": "int32_t", "uinteger": "uint32_t", "decimal": "double", "null": "JsonNull", "URI": "lsDocumentUri", "DocumentUri": "lsDocumentUri", "RegExp": "std::string", } KNOWN_TYPE_ALIASES = { "TextDocumentIdentifier": "lsTextDocumentIdentifier", "VersionedTextDocumentIdentifier": "lsVersionedTextDocumentIdentifier", "TextDocumentItem": "lsTextDocumentItem", "TextDocumentPositionParams": "lsTextDocumentPositionParams", "Range": "lsRange", "Position": "lsPosition", "Diagnostic": "lsDiagnostic", "TextEdit": "lsTextEdit", "Location": "lsLocation", "LocationLink": "lsLocationLink", "WorkspaceEdit": "lsWorkspaceEdit", "Command": "lsCommandWithAny", "MarkupContent": "MarkupContent", "MarkedString": "lsMarkedString", "SymbolInformation": "lsSymbolInformation", "DocumentHighlight": "lsDocumentHighlight", "CompletionItem": "lsCompletionItem", "CompletionList": "CompletionList", "CodeAction": "CodeAction", "DocumentSymbol": "lsDocumentSymbol", "FoldingRange": "lsFoldingRange", "SemanticTokens": "SemanticTokens", "InlayHint": "lsInlayHint", "CallHierarchyItem": "CallHierarchyItem", "TypeHierarchyItem": "TypeHierarchyItem", "LSPAny": "lsp::Any", "LSPObject": "lsp::Any", "LSPArray": "lsp::Any", } HEADER_INCLUDES = [ "LibLsp/JsonRpc/NotificationInMessage.h", "LibLsp/JsonRpc/RequestInMessage.h", "LibLsp/JsonRpc/lsResponseMessage.h", "LibLsp/lsp/lsAny.h", "LibLsp/lsp/lsDocumentUri.h", "LibLsp/lsp/lsRange.h", "LibLsp/lsp/lsPosition.h", "LibLsp/lsp/lsTextDocumentIdentifier.h", "LibLsp/lsp/symbol.h", ] @dataclass class MethodTarget: method: str kind: str # request | notification symbol: str params_cpp: str result_cpp: Optional[str] message_direction: str needs_type_gen: bool needs_request_parser: bool needs_response_parser: bool needs_notification_parser: bool @dataclass class GenerationPlan: methods: List[MethodTarget] = field(default_factory=list) type_names: Set[str] = field(default_factory=set) client_request_blocks: List[str] = field(default_factory=list) server_request_blocks: List[str] = field(default_factory=list) response_blocks: List[str] = field(default_factory=list) notification_blocks: List[str] = field(default_factory=list) header_body: str = "" collisions: List[str] = field(default_factory=list) class MetaModelIndex: def __init__(self, metamodel_path: Path): payload = coverage.load_json(metamodel_path) self.version = payload.get("metaData", {}).get("version", "unknown") self.requests = {entry["method"]: entry for entry in payload.get("requests", [])} self.notifications = {entry["method"]: entry for entry in payload.get("notifications", [])} self.structures = {entry["name"]: entry for entry in payload.get("structures", [])} self.enumerations = {entry["name"]: entry for entry in payload.get("enumerations", [])} self.type_aliases = {entry["name"]: entry for entry in payload.get("typeAliases", [])} def entry_for(self, method: str) -> Tuple[str, dict]: if method in self.requests: return "request", self.requests[method] if method in self.notifications: return "notification", self.notifications[method] raise KeyError(f"Unknown LSP method: {method}") class ExistingTypesIndex: def __init__(self, repo_root: Path): self.repo_root = repo_root self.structs: Set[str] = set() self.enums: Set[str] = set() self.symbols: Set[str] = set() self.generated_symbols: Set[str] = set() self._scan() def _scan(self) -> None: generated_path = self.repo_root / GENERATED_HEADER generated_text = generated_path.read_text(encoding="utf-8") if generated_path.exists() else "" for macro in ("DEFINE_REQUEST_RESPONSE_TYPE", "DEFINE_NOTIFICATION_TYPE"): for symbol, _method in coverage.extract_macros(generated_text, macro): self.generated_symbols.add(symbol) for pattern in coverage.HEADER_GLOBS: for path in self.repo_root.glob(pattern): if path.resolve() == generated_path.resolve(): continue text = path.read_text(encoding="utf-8") self.structs.update(re.findall(r"\bstruct\s+(\w+)", text)) self.enums.update(re.findall(r"\benum class\s+(\w+)", text)) for macro in ("DEFINE_REQUEST_RESPONSE_TYPE", "DEFINE_NOTIFICATION_TYPE"): for symbol, _method in coverage.extract_macros(text, macro): self.symbols.add(symbol) for relative_path in coverage.EXTRA_HEADER_FILES: text = (self.repo_root / relative_path).read_text(encoding="utf-8") for macro in ("DEFINE_REQUEST_RESPONSE_TYPE", "DEFINE_NOTIFICATION_TYPE"): for symbol, _method in coverage.extract_macros(text, macro): self.symbols.add(symbol) def has_type(self, name: str) -> bool: return name in self.structs or name in self.enums or name in KNOWN_TYPE_ALIASES def has_symbol(self, name: str) -> bool: if name in self.generated_symbols: return False return name in self.symbols class TypeResolver: def __init__(self, index: MetaModelIndex, existing: ExistingTypesIndex): self.index = index self.existing = existing self.pending_structs: OrderedDict[str, dict] = OrderedDict() self.pending_enums: OrderedDict[str, dict] = OrderedDict() self.pending_aliases: OrderedDict[str, dict] = OrderedDict() self.generated_structs: Set[str] = set() self.generated_enums: Set[str] = set() self.generated_aliases: Set[str] = set() self.generation_order: List[Tuple[str, str]] = [] self.required_includes: Set[str] = set() def collect_dependencies(self, type_node: dict) -> None: kind = type_node.get("kind") if kind == "reference": self._collect_reference(type_node["name"]) elif kind == "array": self.collect_dependencies(type_node["element"]) elif kind == "map": self.collect_dependencies(type_node["value"]) elif kind == "or": for item in type_node.get("items", []): self.collect_dependencies(item) elif kind == "tuple": for item in type_node.get("items", []): self.collect_dependencies(item) def _collect_reference(self, name: str) -> None: if self.existing.has_type(name) or name in KNOWN_TYPE_ALIASES: return if name in self.pending_structs or name in self.pending_enums or name in self.pending_aliases: return if name in self.index.structures: self.pending_structs[name] = self.index.structures[name] entry = self.index.structures[name] for prop in entry.get("properties", []): self.collect_dependencies(prop["type"]) for mixin in entry.get("mixins", []): self.collect_dependencies(mixin) elif name in self.index.enumerations: self.pending_enums[name] = self.index.enumerations[name] elif name in self.index.type_aliases: self.pending_aliases[name] = self.index.type_aliases[name] self.collect_dependencies(self.index.type_aliases[name]["type"]) def resolve(self, type_node: dict, *, nullable_union: bool = False) -> str: kind = type_node.get("kind") if kind == "base": mapped = BASE_TYPE_MAP.get(type_node["name"], type_node["name"]) if mapped == type_node["name"] and mapped not in BASE_TYPE_MAP.values(): return "lsp::Any" return mapped if kind == "reference": name = type_node["name"] if name in KNOWN_TYPE_ALIASES: return KNOWN_TYPE_ALIASES[name] if self.existing.has_type(name): return name if name in self.generated_structs or name in self.pending_structs: return name if name in self.generated_enums or name in self.pending_enums: return name if name in self.generated_aliases or name in self.pending_aliases: return name self._collect_reference(name) return name if kind == "array": element = self.resolve(type_node["element"]) return f"std::vector<{element}>" if kind == "map": value = self.resolve(type_node["value"]) return f"std::map" if kind == "literal": return "lsp::Any" if kind == "stringLiteral": return "std::string" if kind == "or": return self._resolve_or(type_node, nullable_union=nullable_union) if kind == "tuple": parts = [self.resolve(item) for item in type_node.get("items", [])] if len(parts) == 2: return f"std::pair<{parts[0]}, {parts[1]}>" return "lsp::Any" return "lsp::Any" def _resolve_or(self, type_node: dict, *, nullable_union: bool) -> str: items = type_node.get("items", []) non_null = [item for item in items if not (item.get("kind") == "base" and item.get("name") == "null")] if len(non_null) == 1 and len(items) == 2: inner = self.resolve(non_null[0]) if nullable_union: return f"Nullable<{inner}>" return f"optional<{inner}>" resolved = [self.resolve(item) for item in non_null] if not resolved: return "JsonNull" if len(resolved) == 1: return resolved[0] if len(resolved) == 2: return f"std::pair, optional<{resolved[1]}>>" pair = resolved[-1] for item in reversed(resolved[:-1]): pair = f"std::pair, optional<{pair}>>" return pair def finalize_pending(self) -> None: while self.pending_structs or self.pending_enums or self.pending_aliases: if self.pending_enums: name = next(iter(self.pending_enums)) self.pending_enums.pop(name) self.generated_enums.add(name) self.generation_order.append(("enum", name)) continue if self.pending_aliases: name = next(iter(self.pending_aliases)) entry = self.pending_aliases.pop(name) self.collect_dependencies(entry["type"]) self.generated_aliases.add(name) self.generation_order.append(("alias", name)) continue name = next(iter(self.pending_structs)) entry = self.pending_structs.pop(name) for prop in entry.get("properties", []): self.collect_dependencies(prop["type"]) for mixin in entry.get("mixins", []): self.collect_dependencies(mixin) self.generated_structs.add(name) self.generation_order.append(("struct", name)) def type_name_to_symbol(type_name: str) -> str: for suffix in ("Request", "Notification"): if type_name.endswith(suffix): base = type_name[: -len(suffix)] break else: base = type_name if not base: base = type_name return f"gen_{base[0].lower()}{base[1:]}" def method_to_symbol(method: str) -> str: cleaned = method.replace("$/", "$").replace("/", "_").replace("-", "_") return f"gen_{cleaned}" def choose_symbol(entry: dict, method: str) -> str: type_name = entry.get("typeName") if type_name: symbol = type_name_to_symbol(type_name) return symbol return method_to_symbol(method) def build_targets( report: coverage.CoverageReport, index: MetaModelIndex, forced_methods: Set[str], ) -> List[MethodTarget]: targets: Dict[str, MethodTarget] = {} def add_method(method: str, *, needs_type: bool, req: bool, rsp: bool, ntf: bool) -> None: kind, entry = index.entry_for(method) symbol = choose_symbol(entry, method) resolver = TypeResolver(index, ExistingTypesIndex(report.repo_root)) if kind == "request": params_cpp = resolver.resolve(entry["params"]) result_cpp = resolver.resolve(entry["result"], nullable_union=True) else: params_cpp = resolver.resolve(entry["params"]) result_cpp = None targets[method] = MethodTarget( method=method, kind=kind, symbol=symbol, params_cpp=params_cpp, result_cpp=result_cpp, message_direction=entry.get("messageDirection", "clientToServer"), needs_type_gen=needs_type, needs_request_parser=req, needs_response_parser=rsp, needs_notification_parser=ntf, ) if forced_methods: for method in sorted(forced_methods): kind, _entry = index.entry_for(method) add_method( method, needs_type=True, req=kind == "request", rsp=kind == "request", ntf=kind == "notification", ) return list(targets.values()) for method in report.remaining.get("missing_type_declaration", []): kind, _entry = index.entry_for(method) add_method( method, needs_type=True, req=kind == "request", rsp=kind == "request", ntf=kind == "notification", ) for method in report.remaining.get("missing_request_parser", []): if method in targets: targets[method].needs_request_parser = True else: add_method(method, needs_type=False, req=True, rsp=False, ntf=False) for method in report.remaining.get("missing_response_parser", []): if method in targets: targets[method].needs_response_parser = True else: add_method(method, needs_type=False, req=False, rsp=True, ntf=False) for method in report.remaining.get("missing_notification_parser", []): if method in targets: targets[method].needs_notification_parser = True else: add_method(method, needs_type=False, req=False, rsp=False, ntf=True) return list(targets.values()) def render_enum(name: str, entry: dict) -> str: lines = [f"enum class {name}", "{"] for item in entry.get("values", []): value = item.get("value") item_name = item["name"] if isinstance(value, int): lines.append(f" {item_name} = {value},") else: lines.append(f" {item_name},") lines.append("};") lines.append(f"MAKE_REFLECT_TYPE_PROXY({name})") return "\n".join(lines) def render_alias(name: str, cpp_type: str) -> str: return f"using {name} = {cpp_type};" def flatten_properties(entry: dict, index: MetaModelIndex) -> List[dict]: props: List[dict] = [] seen: Set[str] = set() for mixin in entry.get("mixins", []): if mixin.get("kind") != "reference": continue mixin_entry = index.structures.get(mixin["name"]) if not mixin_entry: continue for prop in flatten_properties(mixin_entry, index): if prop["name"] not in seen: props.append(prop) seen.add(prop["name"]) for prop in entry.get("properties", []): if prop["name"] not in seen: props.append(prop) seen.add(prop["name"]) return props def render_struct(name: str, entry: dict, index: MetaModelIndex, resolver: TypeResolver) -> str: props = flatten_properties(entry, index) fields: List[str] = [] reflect_fields: List[str] = [] swap_fields: List[str] = [] for prop in props: cpp_type = resolver.resolve(prop["type"]) if prop.get("optional"): cpp_type = f"optional<{cpp_type}>" fields.append(f" {cpp_type} {prop['name']};") reflect_fields.append(prop["name"]) swap_fields.append(prop["name"]) lines = [f"struct {name}", "{"] if fields: lines.extend(fields) else: lines.append(" // generated empty struct") if swap_fields: lines.append(f" MAKE_SWAP_METHOD({name}, {', '.join(swap_fields)})") lines.append("};") lines.append(f"MAKE_REFLECT_STRUCT({name}, {', '.join(reflect_fields) if reflect_fields else ''})") return "\n".join(line for line in lines if line is not None) def render_method_macro(target: MethodTarget) -> str: if target.kind == "notification": return ( f'DEFINE_NOTIFICATION_TYPE({target.symbol}, {target.params_cpp}, "{target.method}")' ) return ( f"DEFINE_REQUEST_RESPONSE_TYPE(" f"{target.symbol}, {target.params_cpp}, {target.result_cpp}, \"{target.method}\")" ) def render_request_registration(symbol: str) -> str: return ( f" handler.method2request[{symbol}::request::kMethodInfo] = [](Reader& visitor)\n" f" {{ return {symbol}::request::ReflectReader(visitor); }};" ) def render_response_registration(symbol: str) -> str: return ( f" handler.method2response[{symbol}::request::kMethodInfo] = [](Reader& visitor)\n" f" {{\n" f" if (visitor.HasMember(\"error\"))\n" f" {{\n" f" return Rsp_Error::ReflectReader(visitor);\n" f" }}\n" f" return {symbol}::response::ReflectReader(visitor);\n" f" }};" ) def render_notification_registration(symbol: str) -> str: return ( f" handler.method2notification[{symbol}::notify::kMethodInfo] = [](Reader& visitor)\n" f" {{ return {symbol}::notify::ReflectReader(visitor); }};" ) def generate_plan( report: coverage.CoverageReport, index: MetaModelIndex, forced_methods: Set[str], *, force: bool, ) -> GenerationPlan: plan = GenerationPlan() existing = ExistingTypesIndex(report.repo_root) targets = build_targets(report, index, forced_methods) plan.methods = targets if not targets: return plan resolver = TypeResolver(index, existing) for target in targets: if not target.needs_type_gen: continue kind, entry = index.entry_for(target.method) resolver.collect_dependencies(entry["params"]) if kind == "request": resolver.collect_dependencies(entry["result"]) plan.type_names.update(resolver.pending_structs) plan.type_names.update(resolver.pending_enums) plan.type_names.update(resolver.pending_aliases) # Merge all dependencies from all targets merged_resolver = TypeResolver(index, existing) for target in targets: if not target.needs_type_gen: continue kind, entry = index.entry_for(target.method) merged_resolver.collect_dependencies(entry["params"]) if kind == "request": merged_resolver.collect_dependencies(entry["result"]) merged_resolver.finalize_pending() for name in merged_resolver.generated_structs | merged_resolver.generated_enums | merged_resolver.generated_aliases: if existing.has_type(name) and name not in existing.generated_symbols and not force: plan.collisions.append(f"type {name}") for target in targets: if existing.has_symbol(target.symbol) and not force: plan.collisions.append(f"symbol {target.symbol}") body_parts: List[str] = [BEGIN_HEADER, ""] for kind, name in merged_resolver.generation_order: if kind == "enum": body_parts.append(render_enum(name, index.enumerations[name])) elif kind == "alias": alias_cpp = merged_resolver.resolve(index.type_aliases[name]["type"]) body_parts.append(render_alias(name, alias_cpp)) elif kind == "struct": body_parts.append(render_struct(name, index.structures[name], index, merged_resolver)) body_parts.append("") for target in targets: if target.needs_type_gen: body_parts.append(render_method_macro(target)) body_parts.append("") body_parts.append(END_HEADER) plan.header_body = "\n".join(body_parts).rstrip() + "\n" for target in targets: if target.needs_request_parser: block = render_request_registration(target.symbol) if target.message_direction == "serverToClient": plan.server_request_blocks.append(block) else: plan.client_request_blocks.append(block) if target.needs_response_parser: plan.response_blocks.append(render_response_registration(target.symbol)) if target.needs_notification_parser: plan.notification_blocks.append(render_notification_registration(target.symbol)) return plan def wrap_block(begin: str, end: str, lines: List[str]) -> str: if not lines: return "" return begin + "\n" + "\n".join(lines) + "\n" + end def render_generated_header(plan: GenerationPlan) -> str: includes = "\n".join(f'#include "{inc}"' for inc in HEADER_INCLUDES) return ( "#pragma once\n\n" f"{includes}\n\n" f"{plan.header_body}" ) def write_generated_header(path: Path, plan: GenerationPlan) -> None: if path.exists(): existing = path.read_text(encoding="utf-8") pattern = re.compile(re.escape(BEGIN_HEADER) + r".*?" + re.escape(END_HEADER), re.DOTALL) if pattern.search(existing): header_text = pattern.sub(plan.header_body.rstrip(), existing) else: header_text = existing.rstrip() + "\n\n" + plan.header_body else: header_text = render_generated_header(plan) path.parent.mkdir(parents=True, exist_ok=True) path.write_text(header_text if header_text.endswith("\n") else header_text + "\n", encoding="utf-8") def insert_or_replace_block(content: str, function_name: str, begin: str, end: str, lines: List[str]) -> str: if not lines: return content wrapped = wrap_block(begin, end, lines) pattern = re.compile( rf"(void {re.escape(function_name)}\(MessageJsonHandler& handler\)\s*\{{)(.*?)(\n\}})", re.DOTALL, ) match = pattern.search(content) if not match: raise RuntimeError(f"Could not locate function {function_name} in {HANDLER_FILE}") body = match.group(2) sentinel_pattern = re.compile(re.escape(begin) + r".*?" + re.escape(end), re.DOTALL) if sentinel_pattern.search(body): body = sentinel_pattern.sub(wrapped, body) else: body = body.rstrip() + "\n\n" + wrapped return content[: match.start()] + match.group(1) + body + match.group(3) + content[match.end() :] LEGACY_SENTINEL_PAIRS = ( (" // BEGIN LSPGEN request registrations", " // END LSPGEN request registrations"), ) def remove_legacy_sentinels(content: str) -> str: for begin, end in LEGACY_SENTINEL_PAIRS: pattern = re.compile(re.escape(begin) + r".*?" + re.escape(end), re.DOTALL) content = pattern.sub("", content) return content def patch_handler_content(content: str, plan: GenerationPlan) -> str: content = remove_legacy_sentinels(content) include_line = f'#include "{GENERATED_INCLUDE}"' if include_line not in content: marker = '#include "LibLsp/lsp/workspace/configuration.h"' if marker in content: content = content.replace(marker, marker + "\n" + include_line) else: content = include_line + "\n" + content content = insert_or_replace_block( content, "AddStadardResponseJsonRpcMethod", BEGIN_RSP, END_RSP, plan.response_blocks, ) content = insert_or_replace_block( content, "AddNotifyJsonRpcMethod", BEGIN_NTF, END_NTF, plan.notification_blocks, ) content = insert_or_replace_block( content, "AddStadardResponseJsonRpcMethod", BEGIN_SERVER_REQ, END_SERVER_REQ, plan.server_request_blocks, ) content = insert_or_replace_block( content, "AddStandardRequestJsonRpcMethod", BEGIN_CLIENT_REQ, END_CLIENT_REQ, plan.client_request_blocks, ) return content def parse_args() -> argparse.Namespace: parser = argparse.ArgumentParser(description="Generate LspCpp protocol types from the LSP metaModel.") parser.add_argument("--repo-root", type=Path, default=Path(__file__).resolve().parents[1]) parser.add_argument("--metamodel", type=Path, default=None) parser.add_argument("--allowlist", type=Path, default=None) parser.add_argument("--method", action="append", default=[], help="Generate for specific method(s), bypassing allowlist.") parser.add_argument("--write", action="store_true", help="Write generated files (default is dry-run).") parser.add_argument("--force", action="store_true", help="Allow overwriting existing generated symbols/types.") return parser.parse_args() def main() -> int: args = parse_args() report = coverage.analyze_coverage(args.repo_root, args.metamodel, args.allowlist) index = MetaModelIndex(report.metamodel_path) forced = set(args.method) plan = generate_plan(report, index, forced, force=args.force) print("LspCpp lspgen plan") print(f" metaModel: {report.metamodel_path} (version {index.version})") print(f" methods: {len(plan.methods)}") if plan.collisions: print(f" collisions: {len(plan.collisions)}") for item in plan.collisions: print(f" - {item}") if not args.force: print("Refusing to write due to collisions (use --force to override).") return 1 if not plan.methods: print("Nothing to generate.") return 0 print("Targets:") for target in plan.methods: flags = [] if target.needs_type_gen: flags.append("types") if target.needs_request_parser: flags.append("request") if target.needs_response_parser: flags.append("response") if target.needs_notification_parser: flags.append("notification") print(f" - {target.method} ({target.symbol}) [{', '.join(flags)}]") header_path = report.repo_root / GENERATED_HEADER handler_path = report.repo_root / HANDLER_FILE header_text = render_generated_header(plan) print() print(f"Generated header preview ({header_path}):") print("-" * 40) preview = header_text if len(header_text) <= 4000 else header_text[:4000] + "\n... (truncated)" print(preview) print("-" * 40) if plan.client_request_blocks or plan.server_request_blocks or plan.response_blocks or plan.notification_blocks: print("Handler registration blocks:") for block in ( plan.client_request_blocks + plan.server_request_blocks + plan.response_blocks + plan.notification_blocks ): print(block) print() if not args.write: print("Dry-run only. Re-run with --write to apply changes.") return 0 header_path.parent.mkdir(parents=True, exist_ok=True) write_generated_header(header_path, plan) handler_text = handler_path.read_text(encoding="utf-8") handler_path.write_text(patch_handler_content(handler_text, plan), encoding="utf-8") print(f"Wrote {header_path}") print(f"Updated {handler_path}") return 0 if __name__ == "__main__": sys.exit(main())