completions.c File Reference

Implementation of shell completion generation from options registry. More...

Go to the source code of this file.

Functions
asciichat_error_t	completions_generate_bash (FILE *output)
asciichat_error_t	completions_generate_fish (FILE *output)
asciichat_error_t	completions_generate_zsh (FILE *output)
asciichat_error_t	completions_generate_powershell (FILE *output)
asciichat_error_t	completions_generate_for_shell (completion_format_t format, FILE *output)
const char *	completions_get_shell_name (completion_format_t format)
completion_format_t	completions_parse_shell_name (const char *shell_name)
option_descriptor_t *	completions_collect_all_modes_unique (size_t *count)
	Collect options from all modes with deduplication.

Detailed Description

Implementation of shell completion generation from options registry.

Definition in file completions.c.

Function Documentation

completions_collect_all_modes_unique()

option_descriptor_t * completions_collect_all_modes_unique

(

size_t *

count

)

Collect options from all modes with deduplication.

Iterates through all completion modes (MODE_DISCOVERY, MODE_SERVER, MODE_CLIENT, MODE_MIRROR, MODE_DISCOVERY_SERVICE) and collects unique options by long_name. Useful for generators that need to show completions for options across multiple modes.

Parameters

[out]

count

Pointer to receive the count of unique options

Returns

Dynamically allocated array of option_descriptor_t, must be freed by caller. Returns NULL if no options found.

Note

The caller must free the returned pointer with SAFE_FREE()

Definition at line 96 of file completions.c.

                                                                         {
  if (!count) {
    return NULL;
  }
 
  option_descriptor_t *combined_opts = NULL;
  size_t combined_count = 0;
 
  /* All completion modes to iterate through */
  asciichat_mode_t modes[] = {MODE_DISCOVERY, MODE_SERVER, MODE_CLIENT, MODE_MIRROR, MODE_DISCOVERY_SERVICE};
  const size_t modes_len = sizeof(modes) / sizeof(modes[0]);
 
  for (size_t m = 0; m < modes_len; m++) {
    size_t mode_count = 0;
    const option_descriptor_t *mode_opts = options_registry_get_for_mode(modes[m], &mode_count);
    if (mode_opts) {
      /* Collect unique options by long_name */
      for (size_t i = 0; i < mode_count; i++) {
        bool already_has = false;
        for (size_t j = 0; j < combined_count; j++) {
          if (strcmp(combined_opts[j].long_name, mode_opts[i].long_name) == 0) {
            already_has = true;
            break;
          }
        }
        if (!already_has) {
          combined_count++;
          option_descriptor_t *temp = (option_descriptor_t *)SAFE_REALLOC(
              combined_opts, combined_count * sizeof(option_descriptor_t), option_descriptor_t *);
          if (temp) {
            combined_opts = temp;
            combined_opts[combined_count - 1] = mode_opts[i];
          }
        }
      }
      SAFE_FREE(mode_opts);
    }
  }
 
  *count = combined_count;
  return combined_opts;
}

References options_registry_get_for_mode().

completions_generate_bash()

asciichat_error_t completions_generate_bash

(

FILE *

output

)

Definition at line 367 of file bash.c.

                                                          {
  if (!output) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Output stream cannot be NULL");
  }
 
  bash_write_header(output);
  asciichat_error_t err = bash_write_all_options(output);
  if (err != ASCIICHAT_OK) {
    return err;
  }
  bash_write_completion_logic(output);
  bash_write_footer(output);
 
  return ASCIICHAT_OK;
}

Referenced by completions_generate_for_shell().

completions_generate_fish()

asciichat_error_t completions_generate_fish

(

FILE *

output

)

Definition at line 130 of file fish.c.

                                                          {
  if (!output) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Output stream cannot be NULL");
  }
 
  fprintf(output,
          "# Fish completion script for ascii-chat\n"
          "# Generated from options registry - DO NOT EDIT MANUALLY\n"
          "\n"
          "complete -c ascii-chat -f\n"
          "\n"
          "function __fish_ascii_chat_using_mode\n"
          "    set -l cmd (commandline -opc)\n"
          "    for arg in $cmd\n"
          "        if contains -- $arg server client mirror\n"
          "            echo $arg\n"
          "            return 0\n"
          "        end\n"
          "    end\n"
          "    return 1\n"
          "end\n"
          "\n"
          "function __fish_ascii_chat_mode_is\n"
          "    test (string match -q $argv[1] (command __fish_ascii_chat_using_mode))\n"
          "end\n"
          "\n"
          "function __fish_ascii_chat_no_mode\n"
          "    not __fish_ascii_chat_using_mode > /dev/null\n"
          "end\n"
          "\n"
          "# Modes\n"
          "complete -c ascii-chat -n __fish_ascii_chat_no_mode -a server -d 'Run a video chat server'\n"
          "complete -c ascii-chat -n __fish_ascii_chat_no_mode -a client -d 'Connect to a video chat server'\n"
          "complete -c ascii-chat -n __fish_ascii_chat_no_mode -a mirror -d 'View webcam locally without network'\n"
          "\n");
 
  /* Binary options - use unified display API matching help system */
  size_t binary_count = 0;
  const option_descriptor_t *binary_opts = options_registry_get_for_display(MODE_DISCOVERY, true, &binary_count);
 
  fprintf(output, "# Binary-level options (same as 'ascii-chat --help')\n");
  if (binary_opts) {
    for (size_t i = 0; i < binary_count; i++) {
      fish_write_option(output, &binary_opts[i], "");
    }
    SAFE_FREE(binary_opts);
  }
  fprintf(output, "\n");
 
  /* Server options - use unified display API matching help system */
  size_t server_count = 0;
  const option_descriptor_t *server_opts = options_registry_get_for_display(MODE_SERVER, false, &server_count);
 
  fprintf(output, "# Server options (same as 'ascii-chat server --help')\n");
  if (server_opts) {
    for (size_t i = 0; i < server_count; i++) {
      fish_write_option(output, &server_opts[i], "-n '__fish_seen_subcommand_from server'");
    }
    SAFE_FREE(server_opts);
  }
  fprintf(output, "\n");
 
  /* Client options - use unified display API matching help system */
  size_t client_count = 0;
  const option_descriptor_t *client_opts = options_registry_get_for_display(MODE_CLIENT, false, &client_count);
 
  fprintf(output, "# Client options (same as 'ascii-chat client --help')\n");
  if (client_opts) {
    for (size_t i = 0; i < client_count; i++) {
      fish_write_option(output, &client_opts[i], "-n '__fish_seen_subcommand_from client'");
    }
    SAFE_FREE(client_opts);
  }
  fprintf(output, "\n");
 
  /* Mirror options - use unified display API matching help system */
  size_t mirror_count = 0;
  const option_descriptor_t *mirror_opts = options_registry_get_for_display(MODE_MIRROR, false, &mirror_count);
 
  fprintf(output, "# Mirror options (same as 'ascii-chat mirror --help')\n");
  if (mirror_opts) {
    for (size_t i = 0; i < mirror_count; i++) {
      fish_write_option(output, &mirror_opts[i], "-n '__fish_seen_subcommand_from mirror'");
    }
    SAFE_FREE(mirror_opts);
  }
  fprintf(output, "\n");
 
  /* Discovery-service options */
  size_t discovery_svc_count = 0;
  const option_descriptor_t *discovery_svc_opts =
      options_registry_get_for_display(MODE_DISCOVERY_SERVICE, false, &discovery_svc_count);
 
  fprintf(output, "# Discovery-service options (same as 'ascii-chat discovery-service --help')\n");
  if (discovery_svc_opts) {
    for (size_t i = 0; i < discovery_svc_count; i++) {
      fish_write_option(output, &discovery_svc_opts[i], "-n '__fish_seen_subcommand_from discovery-service'");
    }
    SAFE_FREE(discovery_svc_opts);
  }
 
  return ASCIICHAT_OK;
}

References options_registry_get_for_display().

Referenced by completions_generate_for_shell().

completions_generate_for_shell()

asciichat_error_t completions_generate_for_shell	(	completion_format_t	format,
		FILE *	output
	)

Definition at line 20 of file completions.c.

                                                                                           {
  if (!output) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Output stream cannot be NULL");
  }
 
  switch (format) {
  case COMPLETION_FORMAT_BASH:
    return completions_generate_bash(output);
  case COMPLETION_FORMAT_FISH:
    return completions_generate_fish(output);
  case COMPLETION_FORMAT_ZSH:
    return completions_generate_zsh(output);
  case COMPLETION_FORMAT_POWERSHELL:
    return completions_generate_powershell(output);
  default:
    return SET_ERRNO(ERROR_INVALID_PARAM, "Unknown completion format: %d", format);
  }
}

References completions_generate_bash(), completions_generate_fish(), completions_generate_powershell(), and completions_generate_zsh().

Referenced by action_completions().

completions_generate_powershell()

asciichat_error_t completions_generate_powershell

(

FILE *

output

)

Definition at line 130 of file powershell.c.

                                                                {
  if (!output) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Output stream cannot be NULL");
  }
 
  fprintf(output, "# PowerShell completion script for ascii-chat\n"
                  "# Generated from options registry - DO NOT EDIT MANUALLY\n"
                  "# Usage: ascii-chat --completions powershell | Out-String | Invoke-Expression\n"
                  "\n"
                  "$script:AsciiChatCompleter = {\n"
                  "  param($wordToComplete, $commandAst, $cursorPosition)\n"
                  "\n"
                  "  $words = @($commandAst.CommandElements | ForEach-Object { $_.Value })\n"
                  "  $mode = $null\n"
                  "\n"
                  "  foreach ($word in $words) {\n"
                  "    if ($word -in @('server', 'client', 'mirror')) {\n"
                  "      $mode = $word\n"
                  "      break\n"
                  "    }\n"
                  "  }\n"
                  "\n"
                  "  $binaryOptions = @(\n");
 
  /* Binary options - use unified display API matching help system */
  size_t binary_count = 0;
  const option_descriptor_t *binary_opts = options_registry_get_for_display(MODE_DISCOVERY, true, &binary_count);
 
  if (binary_opts) {
    for (size_t i = 0; i < binary_count; i++) {
      ps_write_option(output, &binary_opts[i]);
    }
    SAFE_FREE(binary_opts);
  }
 
  fprintf(output, "  )\n\n  $serverOptions = @(\n");
 
  /* Server options - use unified display API matching help system */
  size_t server_count = 0;
  const option_descriptor_t *server_opts = options_registry_get_for_display(MODE_SERVER, false, &server_count);
 
  if (server_opts) {
    for (size_t i = 0; i < server_count; i++) {
      ps_write_option(output, &server_opts[i]);
    }
    SAFE_FREE(server_opts);
  }
 
  fprintf(output, "  )\n\n  $clientOptions = @(\n");
 
  /* Client options - use unified display API matching help system */
  size_t client_count = 0;
  const option_descriptor_t *client_opts = options_registry_get_for_display(MODE_CLIENT, false, &client_count);
 
  if (client_opts) {
    for (size_t i = 0; i < client_count; i++) {
      ps_write_option(output, &client_opts[i]);
    }
    SAFE_FREE(client_opts);
  }
 
  fprintf(output, "  )\n\n  $mirrorOptions = @(\n");
 
  /* Mirror options - use unified display API matching help system */
  size_t mirror_count = 0;
  const option_descriptor_t *mirror_opts = options_registry_get_for_display(MODE_MIRROR, false, &mirror_count);
 
  if (mirror_opts) {
    for (size_t i = 0; i < mirror_count; i++) {
      ps_write_option(output, &mirror_opts[i]);
    }
    SAFE_FREE(mirror_opts);
  }
 
  fprintf(output, "  )\n\n  $discoverySvcOptions = @(\n");
 
  /* Discovery-service options */
  size_t discovery_svc_count = 0;
  const option_descriptor_t *discovery_svc_opts =
      options_registry_get_for_display(MODE_DISCOVERY_SERVICE, false, &discovery_svc_count);
 
  if (discovery_svc_opts) {
    for (size_t i = 0; i < discovery_svc_count; i++) {
      ps_write_option(output, &discovery_svc_opts[i]);
    }
    SAFE_FREE(discovery_svc_opts);
  }
 
  fprintf(output,
          "  )\n"
          "\n"
          "  $options = $binaryOptions\n"
          "  \n"
          "  if ($mode -eq 'server') {\n"
          "    $options += $serverOptions\n"
          "  } elseif ($mode -eq 'client') {\n"
          "    $options += $clientOptions\n"
          "  } elseif ($mode -eq 'mirror') {\n"
          "    $options += $mirrorOptions\n"
          "  } elseif ($mode -eq 'discovery-service') {\n"
          "    $options += $discoverySvcOptions\n"
          "  }\n"
          "\n"
          "  if (-not $mode -and -not $wordToComplete.StartsWith('-')) {\n"
          "    @('server', 'client', 'mirror', 'discovery-service') | Where-Object { $_ -like \"$wordToComplete*\" } | "
          "ForEach-Object {\n"
          "      [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', \"Mode: $_\")\n"
          "    }\n"
          "  } else {\n"
          "    $options | Where-Object { $_.Name -like \"$wordToComplete*\" } | ForEach-Object {\n"
          "      if ($_.Values) {\n"
          "        $_.Values | ForEach-Object {\n"
          "          [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_.Description)\n"
          "        }\n"
          "      } else {\n"
          "        [System.Management.Automation.CompletionResult]::new($_.Name, $_.Name, 'ParameterValue', "
          "$_.Description)\n"
          "      }\n"
          "    }\n"
          "  }\n"
          "}\n"
          "\n"
          "Register-ArgumentCompleter -CommandName ascii-chat -ScriptBlock $script:AsciiChatCompleter\n");
 
  return ASCIICHAT_OK;
}

References options_registry_get_for_display().

Referenced by completions_generate_for_shell().

completions_generate_zsh()

asciichat_error_t completions_generate_zsh

(

FILE *

output

)

Definition at line 105 of file zsh.c.

                                                         {
  if (!output) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Output stream cannot be NULL");
  }
 
  fprintf(output, "#compdef _ascii_chat ascii-chat\n"
#ifndef NDEBUG
                  "#compdef _ascii_chat build/bin/ascii-chat ./build/bin/ascii-chat\n"
#endif
                  "# Zsh completion script for ascii-chat\n"
                  "# Generated from options registry - DO NOT EDIT MANUALLY\n"
                  "\n"
                  "_ascii_chat() {\n"
                  "  local curcontext=\"$curcontext\" state line\n"
                  "  _arguments -C \\\n");
 
  /* Binary options - use unified display API matching help system */
  size_t binary_count = 0;
  const option_descriptor_t *binary_opts = options_registry_get_for_display(MODE_DISCOVERY, true, &binary_count);
 
  if (binary_opts) {
    for (size_t i = 0; i < binary_count; i++) {
      zsh_write_option(output, &binary_opts[i]);
    }
    SAFE_FREE(binary_opts);
  }
 
  fprintf(output, "    '1:mode:(server client mirror discovery-service)' \\\n"
                  "    '*::mode args:_ascii_chat_subcommand'\n"
                  "}\n"
                  "\n"
                  "_ascii_chat_subcommand() {\n"
                  "  case $line[1] in\n"
                  "  server)\n"
                  "    _arguments \\\n");
 
  /* Server options - use unified display API matching help system */
  size_t server_count = 0;
  const option_descriptor_t *server_opts = options_registry_get_for_display(MODE_SERVER, false, &server_count);
 
  if (server_opts) {
    for (size_t i = 0; i < server_count; i++) {
      zsh_write_option(output, &server_opts[i]);
    }
    SAFE_FREE(server_opts);
  }
 
  fprintf(output, "      && return 0\n"
                  "    ;;\n"
                  "  client)\n"
                  "    _arguments \\\n");
 
  /* Client options - use unified display API matching help system */
  size_t client_count = 0;
  const option_descriptor_t *client_opts = options_registry_get_for_display(MODE_CLIENT, false, &client_count);
 
  if (client_opts) {
    for (size_t i = 0; i < client_count; i++) {
      zsh_write_option(output, &client_opts[i]);
    }
    SAFE_FREE(client_opts);
  }
 
  fprintf(output, "      && return 0\n"
                  "    ;;\n"
                  "  mirror)\n"
                  "    _arguments \\\n");
 
  /* Mirror options - use unified display API matching help system */
  size_t mirror_count = 0;
  const option_descriptor_t *mirror_opts = options_registry_get_for_display(MODE_MIRROR, false, &mirror_count);
 
  if (mirror_opts) {
    for (size_t i = 0; i < mirror_count; i++) {
      zsh_write_option(output, &mirror_opts[i]);
    }
    SAFE_FREE(mirror_opts);
  }
 
  fprintf(output, "      && return 0\n"
                  "    ;;\n"
                  "  discovery-service)\n"
                  "    _arguments \\\n");
 
  /* Discovery-service options */
  size_t discovery_svc_count = 0;
  const option_descriptor_t *discovery_svc_opts =
      options_registry_get_for_display(MODE_DISCOVERY_SERVICE, false, &discovery_svc_count);
 
  if (discovery_svc_opts) {
    for (size_t i = 0; i < discovery_svc_count; i++) {
      zsh_write_option(output, &discovery_svc_opts[i]);
    }
    SAFE_FREE(discovery_svc_opts);
  }
 
  fprintf(output, "      && return 0\n"
                  "    ;;\n"
                  "  esac\n"
                  "}\n"
                  "\n"
                  "_ascii_chat \"$@\"\n");
 
  return ASCIICHAT_OK;
}

References options_registry_get_for_display().

Referenced by completions_generate_for_shell().

completions_get_shell_name()

const char * completions_get_shell_name

(

completion_format_t

format

)

Definition at line 39 of file completions.c.

                                                                   {
  switch (format) {
  case COMPLETION_FORMAT_BASH:
    return "bash";
  case COMPLETION_FORMAT_FISH:
    return "fish";
  case COMPLETION_FORMAT_ZSH:
    return "zsh";
  case COMPLETION_FORMAT_POWERSHELL:
    return "powershell";
  default:
    return "unknown";
  }
}

Referenced by action_completions().

completions_parse_shell_name()

completion_format_t completions_parse_shell_name

(

const char *

shell_name

)

Definition at line 54 of file completions.c.

                                                                         {
  if (!shell_name) {
    return COMPLETION_FORMAT_UNKNOWN;
  }
 
  /* Convert to lowercase for case-insensitive matching */
  char lower[32] = {0};
  size_t len = strlen(shell_name);
  if (len >= sizeof(lower)) {
    return COMPLETION_FORMAT_UNKNOWN;
  }
 
  for (size_t i = 0; i < len; i++) {
    lower[i] = tolower((unsigned char)shell_name[i]);
  }
 
  if (strcmp(lower, "bash") == 0) {
    return COMPLETION_FORMAT_BASH;
  } else if (strcmp(lower, "fish") == 0) {
    return COMPLETION_FORMAT_FISH;
  } else if (strcmp(lower, "zsh") == 0) {
    return COMPLETION_FORMAT_ZSH;
  } else if (strcmp(lower, "powershell") == 0 || strcmp(lower, "ps") == 0) {
    return COMPLETION_FORMAT_POWERSHELL;
  }
 
  return COMPLETION_FORMAT_UNKNOWN;
}

Referenced by action_completions().