embedded_resources.h File Reference

Embedded resource management for production builds. More...

Go to the source code of this file.

Functions
int	get_manpage_template (FILE **out_file, const char **out_content, size_t *out_len)
	Get man page template source (embedded or filesystem)
int	get_manpage_content (FILE **out_file, const char **out_content, size_t *out_len)
	Get man page content source (embedded or filesystem)
void	release_manpage_resources (FILE *file)
	Release resources obtained from get_manpage_*.

Variables
const char	embedded_manpage_template []
	Behavior based on build type.
const size_t	embedded_manpage_template_size
	Size of embedded_manpage_template (excluding null terminator)

Detailed Description

Embedded resource management for production builds.

This module provides unified access to embedded documentation resources in production builds while maintaining fast iteration in development.

Build-Time Behavior:

• Production builds (Release, RelWithDebInfo): Resources are embedded at compile time using CMake scripts. The binary is self-contained.
• Development builds (Debug, Dev): Resources are read from filesystem for fast iteration (edit → rebuild → test → no wait).

Resource Types:

1. Man page template (share/man/man1/ascii-chat.1.in)
2. Man page content (share/man/man1/ascii-chat.1.content)

Example Usage:

// Get man page template (works in both production and development)
FILE *template_file = NULL;
const char *template_str = NULL;
size_t template_len = 0;
 
int result = get_manpage_template(&template_file, &template_str, &template_len);
if (result != 0) {
    log_error("Failed to load man page template");
    return;
}
 
// Use template (either from FILE* or const char*)
if (template_str) {
    // Production: parse in-memory string
    parse_from_memory(template_str, template_len);
} else {
    // Development: parse from file
    parse_from_file(template_file);
}
 
// Always clean up
release_manpage_resources(template_file);

Definition in file embedded_resources.h.

Function Documentation

get_manpage_content()

int get_manpage_content	(	FILE **	out_file,
		const char **	out_content,
		size_t *	out_len
	)

Get man page content source (embedded or filesystem)

Same behavior as get_manpage_template() but for the content file. See get_manpage_template() documentation for usage details.

Parameters

out_file	Output pointer for FILE* (development) or NULL (production)
out_content	Output pointer for const char* (production) or NULL (dev)
out_len	Output pointer for size_t (production) or NULL (development)

Returns

0 on success, -1 on error

Definition at line 75 of file embedded.c.

                                                                                    {
  // Content is now consolidated into the template - return empty
  if (out_content) {
    *out_content = "";
  }
  if (out_len) {
    *out_len = 0;
  }
  if (out_file) {
    *out_file = NULL;
  }
 
  log_debug("Man page content is now consolidated into template (empty)");
  return 0;
}

References log_debug.

get_manpage_template()

int get_manpage_template	(	FILE **	out_file,
		const char **	out_content,
		size_t *	out_len
	)

Get man page template source (embedded or filesystem)

Automatically selects between embedded and filesystem resources based on build type:

• Release builds (NDEBUG defined): Returns embedded string
• Debug builds (NDEBUG undefined): Reads from filesystem

Parameter Usage:

• In production: out_content and out_len are set, out_file is NULL
• In development: out_file is set to open FILE*, others are NULL
• Caller must check which one is non-NULL to determine source

Parameters

out_file	Output pointer for FILE* (development) or NULL (production)
out_content	Output pointer for const char* (production) or NULL (dev)
out_len	Output pointer for size_t (production) or NULL (development)

Returns

0 on success, -1 on error

Note

Caller must call release_manpage_resources(out_file) when done

Do NOT free out_content - it's either static or managed elsewhere

Definition at line 22 of file embedded.c.

                                                                                     {
#ifdef NDEBUG
  // Release build: Return embedded data
  if (out_content) {
    *out_content = embedded_manpage_template;
  }
  if (out_len) {
    *out_len = embedded_manpage_template_size;
  }
  if (out_file) {
    *out_file = NULL;
  }
 
  log_debug("Using embedded man page template (%zu bytes)", embedded_manpage_template_size);
  return 0;
#else
  // Debug build: Read from filesystem
  if (!out_file) {
    SET_ERRNO(ERROR_INVALID_PARAM, "out_file cannot be NULL in development mode");
    return -1;
  }
 
  // Construct absolute path using ASCIICHAT_RESOURCE_DIR (set at build time)
#ifdef ASCIICHAT_RESOURCE_DIR
  static char path_buffer[PATH_MAX];
  safe_snprintf(path_buffer, sizeof(path_buffer), "%s/share/man/man1/ascii-chat.1.in", ASCIICHAT_RESOURCE_DIR);
  const char *path = path_buffer;
#else
  // Fallback: try relative path if ASCIICHAT_RESOURCE_DIR not defined
  const char *path = "share/man/man1/ascii-chat.1.in";
#endif
 
  // Use binary mode to ensure fread byte count matches ftell file size.
  // Text mode on Windows translates \r\n to \n, causing size mismatch.
  FILE *f = platform_fopen("file_stream", path, "rb");
  if (!f) {
    SET_ERRNO_SYS(ERROR_CONFIG, "Failed to open man page template: %s", path);
    return -1;
  }
 
  *out_file = f;
  if (out_content) {
    *out_content = NULL;
  }
  if (out_len) {
    *out_len = 0;
  }
 
  log_debug("Using filesystem man page template: %s", path);
  return 0;
#endif
}

References embedded_manpage_template, embedded_manpage_template_size, ERROR_CONFIG, ERROR_INVALID_PARAM, log_debug, platform_fopen(), safe_snprintf(), SET_ERRNO, and SET_ERRNO_SYS.

Referenced by manpage_resources_load().

release_manpage_resources()

void release_manpage_resources

(

FILE *

file

)

Release resources obtained from get_manpage_*.

Properly cleans up resources based on build type:

• Production: No-op (embedded strings are static)
• Development: Closes FILE* if non-NULL

Parameters

file	FILE* obtained from get_manpage_template/content(), or NULL

Note

Safe to call with NULL

Only closes file, does NOT free content pointer

Definition at line 91 of file embedded.c.

                                           {
#ifdef NDEBUG
  // Release build: No-op (embedded data is static, not heap-allocated)
  (void)file; // Suppress unused parameter warning
#else
  // Debug build: Close file handle if present
  if (file) {
    fclose(file);
  }
#endif
}

Variable Documentation

embedded_manpage_template

const char embedded_manpage_template[]

extern

Behavior based on build type.

In CMake:

• NDEBUG is defined in Release/RelWithDebInfo builds → use embedded resources
• NDEBUG is undefined in Debug/Dev builds → use filesystem resources

Embedded man page template content (auto-generated at build time)

Referenced by get_manpage_template().

embedded_manpage_template_size

const size_t embedded_manpage_template_size

extern

Size of embedded_manpage_template (excluding null terminator)

Referenced by get_manpage_template().