@enjoys/context-engine 1.0.0 → 1.0.2

package/data/hover/bash.json

@@ -0,0 +1,245 @@
+{
+  "language": "bash",
+  "hovers": {
+    "echo": {
+      "contents": [
+        { "value": "```bash\necho [-neE] [string ...]\n```\nDisplay a line of text to stdout. `-n` suppresses the trailing newline. `-e` enables interpretation of backslash escapes (`\\t`, `\\n`, `\\\\`, `\\a`, `\\b`, `\\c`, `\\0nnn`, `\\xHH`). `-E` disables escape interpretation (default)." }
+      ]
+    },
+    "printf": {
+      "contents": [
+        { "value": "```bash\nprintf [-v var] format [arguments ...]\n```\nWrite formatted output to stdout. Format specifiers: `%s` (string), `%d` (decimal), `%f` (float), `%x` (hex), `%o` (octal), `%b` (backslash escapes), `%%` (literal %). `-v var` stores the result in a variable instead of printing." }
+      ]
+    },
+    "read": {
+      "contents": [
+        { "value": "```bash\nread [-ers] [-a array] [-d delim] [-i text] [-n nchars] [-N nchars] [-p prompt] [-t timeout] [-u fd] [name ...]\n```\nRead a line from stdin and split it into fields. `-r` disables backslash escaping. `-p` displays a prompt. `-t` sets a timeout in seconds. `-a` reads into an array. `-s` hides input (for passwords). `-d` sets an alternate delimiter." }
+      ]
+    },
+    "cd": {
+      "contents": [
+        { "value": "```bash\ncd [-L|-P] [directory]\n```\nChange the shell working directory. Without arguments, changes to `$HOME`. `cd -` changes to `$OLDPWD` (previous directory). `-L` follows symbolic links (default). `-P` uses the physical directory structure (resolves symlinks)." }
+      ]
+    },
+    "pwd": {
+      "contents": [
+        { "value": "```bash\npwd [-LP]\n```\nPrint the absolute pathname of the current working directory. `-L` displays the logical path preserving symlinks (default). `-P` displays the physical path with all symlinks resolved." }
+      ]
+    },
+    "export": {
+      "contents": [
+        { "value": "```bash\nexport [-fn] [-p] [name[=value] ...]\n```\nSet environment variables for child processes. Variables marked for export are inherited by any subsequently executed commands. `-n` removes the export property. `-f` exports shell functions. `-p` lists all exported variables." }
+      ]
+    },
+    "source": {
+      "contents": [
+        { "value": "```bash\nsource filename [arguments]\n# or: . filename [arguments]\n```\nRead and execute commands from a file in the **current** shell environment. Unlike executing a script (which runs in a subshell), sourced files can modify variables, functions, and aliases in the calling shell." }
+      ]
+    },
+    "alias": {
+      "contents": [
+        { "value": "```bash\nalias [-p] [name[=value] ...]\n```\nDefine or display command aliases. An alias substitutes a string for the first word of a simple command. Aliases are expanded when a command is read, not when it is executed. Use `\\command` to bypass an alias." }
+      ]
+    },
+    "trap": {
+      "contents": [
+        { "value": "```bash\ntrap [-lp] [action] [signal ...]\n```\nExecute a command when the shell receives a signal or on certain events. Common signals: `EXIT` (on shell exit), `ERR` (on command failure with `set -e`), `INT` (Ctrl+C), `TERM` (termination), `DEBUG` (before every command), `RETURN` (after function/source return). Use `trap - signal` to reset to default." }
+      ]
+    },
+    "set": {
+      "contents": [
+        { "value": "```bash\nset [-abefhkmnptuvxBCEHPT] [-o option-name] [--] [arg ...]\n```\nSet or unset shell options and positional parameters. Common options:\n- `-e` — exit immediately if a command exits with non-zero status\n- `-u` — treat unset variables as an error\n- `-x` — print commands and arguments as they are executed\n- `-o pipefail` — return the exit status of the rightmost failed command in a pipeline\n- `--` — end of options; remaining args become positional parameters" }
+      ]
+    },
+    "declare": {
+      "contents": [
+        { "value": "```bash\ndeclare [-aAfFgiIlnrtux] [-p] [name[=value] ...]\n```\nDeclare variables and set their attributes. Flags: `-i` (integer), `-a` (indexed array), `-A` (associative array), `-r` (readonly), `-x` (export), `-l` (lowercase on assignment), `-u` (uppercase on assignment), `-n` (nameref), `-g` (global scope in functions). Inside functions, `declare` creates local variables unless `-g` is specified." }
+      ]
+    },
+    "local": {
+      "contents": [
+        { "value": "```bash\nlocal [-aAfFgiIlnrtux] [name[=value] ...]\n```\nDeclare a variable as local to a function. The variable is visible only within the function and its child functions. Accepts the same attribute flags as `declare`. Can only be used within a function body." }
+      ]
+    },
+    "test": {
+      "contents": [
+        { "value": "```bash\ntest expression\n[ expression ]\n[[ expression ]]\n```\nEvaluate conditional expressions. Returns 0 (true) or 1 (false).\n\n**File tests:** `-f` (regular file), `-d` (directory), `-e` (exists), `-r` (readable), `-w` (writable), `-x` (executable), `-s` (non-empty), `-L` (symlink)\n\n**String tests:** `-z` (empty), `-n` (non-empty), `=` / `==` (equal), `!=` (not equal)\n\n**Integer tests:** `-eq`, `-ne`, `-gt`, `-lt`, `-ge`, `-le`\n\n**Logical:** `!` (not), `-a` / `&&` (and), `-o` / `||` (or)\n\nPrefer `[[ ]]` for safer word-splitting behavior and regex support (`=~`)." }
+      ]
+    },
+    "if": {
+      "contents": [
+        { "value": "```bash\nif command-list; then\n    command-list\n[elif command-list; then\n    command-list] ...\n[else\n    command-list]\nfi\n```\nConditional execution. The `if` command-list is executed; if its exit status is 0, the `then` block runs. Otherwise, each `elif` is tested in turn. If none match, the `else` block runs (if present). Note: `if` tests the **exit status** of a command, not a boolean expression directly." }
+      ]
+    },
+    "for": {
+      "contents": [
+        { "value": "```bash\n# List form:\nfor name [in word ...]; do\n    command-list\ndone\n\n# C-style form:\nfor (( expr1; expr2; expr3 )); do\n    command-list\ndone\n```\nIterate over a list of words or use arithmetic expressions. In the list form, if `in word ...` is omitted, iterates over `\"$@\"`. The variable `name` is set to each word in turn." }
+      ]
+    },
+    "while": {
+      "contents": [
+        { "value": "```bash\nwhile command-list; do\n    command-list\ndone\n```\nExecute commands repeatedly as long as the test command-list returns exit status 0. Commonly used with `read` to process files line by line: `while IFS= read -r line; do ... done < file`." }
+      ]
+    },
+    "until": {
+      "contents": [
+        { "value": "```bash\nuntil command-list; do\n    command-list\ndone\n```\nExecute commands repeatedly until the test command-list returns exit status 0. Logically equivalent to `while ! command-list; do ... done`." }
+      ]
+    },
+    "case": {
+      "contents": [
+        { "value": "```bash\ncase word in\n    pattern1 | pattern2) commands ;;\n    pattern3) commands ;;&\n    pattern4) commands ;&\n    *) default-commands ;;\nesac\n```\nPattern matching construct. Each pattern is a glob pattern. `;;` terminates the clause. `;&` falls through to the next clause unconditionally. `;;&` tests the next pattern. `*` matches anything (default case). Patterns support `*`, `?`, `[...]`, and extended globs if `extglob` is set." }
+      ]
+    },
+    "select": {
+      "contents": [
+        { "value": "```bash\nselect name [in word ...]; do\n    command-list\ndone\n```\nCreate a numbered menu from `word` list. Displays items with numbers, prompts with `$PS3`, stores the chosen word in `name` and the user's raw input in `$REPLY`. Loops until `break` or EOF (Ctrl+D). If `in word ...` is omitted, uses positional parameters." }
+      ]
+    },
+    "function": {
+      "contents": [
+        { "value": "```bash\n# Two forms:\nname() { command-list; }\nfunction name [()] { command-list; }\n```\nDefine a function that can be called by name. Arguments are accessed as `$1`, `$2`, etc. `$@` for all arguments, `$#` for count. Use `local` for local variables. Use `return [n]` to exit with a status. Functions can be exported with `export -f name`." }
+      ]
+    },
+    "shift": {
+      "contents": [
+        { "value": "```bash\nshift [n]\n```\nShift positional parameters to the left by `n` positions (default 1). After `shift`, `$1` takes the value formerly in `$2`, `$2` takes `$3`, and so on. `$#` is decremented. Commonly used in argument-parsing loops." }
+      ]
+    },
+    "eval": {
+      "contents": [
+        { "value": "```bash\neval [arg ...]\n```\nConcatenate all arguments into a single command string and execute it in the current shell. Useful for executing dynamically constructed commands. **Use with caution** — eval can introduce code injection vulnerabilities if used with untrusted input." }
+      ]
+    },
+    "exec": {
+      "contents": [
+        { "value": "```bash\nexec [-cl] [-a name] [command [arguments ...]] [redirections ...]\n```\nReplace the current shell process with the specified command (no new process is created). If no command is given, redirections apply to the current shell. `-c` causes the command to execute with an empty environment. Commonly used for file descriptor manipulation: `exec 3>file`, `exec > >(tee log)`." }
+      ]
+    },
+    "return": {
+      "contents": [
+        { "value": "```bash\nreturn [n]\n```\nReturn from a shell function or sourced script with exit status `n`. If `n` is omitted, returns the exit status of the last command executed. Only valid inside a function or a sourced (`.`/`source`) script." }
+      ]
+    },
+    "exit": {
+      "contents": [
+        { "value": "```bash\nexit [n]\n```\nExit the shell with status `n`. If `n` is omitted, the status is that of the last command executed. Convention: 0 = success, 1 = general error, 2 = misuse of built-in, 126 = not executable, 127 = command not found, 128+N = killed by signal N." }
+      ]
+    },
+    "readonly": {
+      "contents": [
+        { "value": "```bash\nreadonly [-aAfp] [name[=value] ...]\n```\nMark variables or functions as read-only. Readonly variables cannot be reassigned or unset. `-a` for indexed arrays, `-A` for associative arrays, `-f` for functions. `-p` displays all readonly names." }
+      ]
+    },
+    "getopts": {
+      "contents": [
+        { "value": "```bash\ngetopts optstring name [args]\n```\nParse command-line options. Each call processes one option. `optstring` lists valid option letters; append `:` for options requiring arguments. On success, stores the option in `name`, the argument in `$OPTARG`, and advances `$OPTIND`. Returns non-zero when all options are processed." }
+      ]
+    },
+    "wait": {
+      "contents": [
+        { "value": "```bash\nwait [-fn] [-p varname] [id ...]\n```\nWait for background processes to finish. Without arguments, waits for all child processes. With a PID/job ID, waits for that specific process. `-n` waits for the next job to terminate and returns its exit status. `-p varname` stores the PID of the waited process (Bash 5.1+)." }
+      ]
+    },
+    "shopt": {
+      "contents": [
+        { "value": "```bash\nshopt [-pqsu] [-o] [optname ...]\n```\nSet or unset shell optional behavior. `-s` enables, `-u` disables. Common options:\n- `extglob` — extended pattern matching (`?(pat)`, `*(pat)`, `+(pat)`, `@(pat)`, `!(pat)`)\n- `globstar` — `**` matches directories recursively\n- `nullglob` — unmatched globs expand to nothing\n- `dotglob` — globs match dotfiles\n- `nocasematch` — case-insensitive matching in `case` and `[[`" }
+      ]
+    },
+    "$?": {
+      "contents": [
+        { "value": "```bash\n$?\n```\nThe exit status of the most recently executed foreground pipeline. `0` indicates success, non-zero indicates failure. After a pipeline, `$?` reflects the status of the last command (or rightmost failing command with `set -o pipefail`). Use `${PIPESTATUS[@]}` to access individual exit codes from each pipeline stage." }
+      ]
+    },
+    "$#": {
+      "contents": [
+        { "value": "```bash\n$#\n```\nThe number of positional parameters (command-line arguments). In a script, counts the arguments passed on invocation. Inside a function, counts the function's arguments. Does not include `$0`." }
+      ]
+    },
+    "$@": {
+      "contents": [
+        { "value": "```bash\n$@\n\"$@\"\n```\nAll positional parameters. When quoted (`\"$@\"`), each parameter is preserved as a separate word, correctly handling arguments with spaces. This is almost always the correct way to forward arguments. Equivalent to `\"$1\" \"$2\" ...`." }
+      ]
+    },
+    "$*": {
+      "contents": [
+        { "value": "```bash\n$*\n\"$*\"\n```\nAll positional parameters. When quoted (`\"$*\"`), expands to a single string with parameters joined by the first character of `$IFS` (default: space). Unquoted, behaves like `$@`. Rarely preferred over `\"$@\"`." }
+      ]
+    },
+    "$$": {
+      "contents": [
+        { "value": "```bash\n$$\n```\nThe process ID (PID) of the current shell. In a subshell `(...)`, `$$` still refers to the parent shell's PID. Use `$BASHPID` to get the actual PID of the current subshell (Bash 4.0+). Commonly used to create unique temporary filenames." }
+      ]
+    },
+    "$!": {
+      "contents": [
+        { "value": "```bash\n$!\n```\nThe PID of the most recently backgrounded process (started with `&`). Useful for tracking background jobs: `command & pid=$!; wait $pid`." }
+      ]
+    },
+    "$0": {
+      "contents": [
+        { "value": "```bash\n$0\n```\nThe name of the shell or the shell script being executed. In an interactive shell, typically `bash` or `-bash`. In a script, it is the path used to invoke the script. Use `${BASH_SOURCE[0]}` for the actual source file (works inside sourced scripts)." }
+      ]
+    },
+    "IFS": {
+      "contents": [
+        { "value": "```bash\nIFS=$' \\t\\n'  # default value\n```\nInternal Field Separator. Determines how the shell splits words after expansion and how `read` splits input. Default: space, tab, newline. Set `IFS=''` to disable splitting. Set `IFS=:` to split PATH-like variables. Often set locally in a subshell or function: `(IFS=,; echo \"${array[*]}\")`." }
+      ]
+    },
+    "PATH": {
+      "contents": [
+        { "value": "```bash\nPATH=/usr/local/bin:/usr/bin:/bin\n```\nColon-separated list of directories the shell searches (left to right) when locating commands. Prepend directories for priority: `PATH=\"/my/bin:$PATH\"`. Append for fallback: `PATH=\"$PATH:/my/bin\"`. Empty components (`::`or leading/trailing `:`) refer to the current directory." }
+      ]
+    },
+    "HOME": {
+      "contents": [
+        { "value": "```bash\nHOME=/home/username\n```\nThe home directory of the current user. Set at login from `/etc/passwd`. Used as the default directory for `cd` (no arguments), and for tilde expansion (`~` expands to `$HOME`, `~user` to that user's home)." }
+      ]
+    },
+    "BASH_SOURCE": {
+      "contents": [
+        { "value": "```bash\nBASH_SOURCE  # array variable\n```\nAn array whose members are the source filenames for each function in the call stack. `${BASH_SOURCE[0]}` is the file containing the currently executing code. Particularly useful for finding the script's own directory:\n```bash\nSCRIPT_DIR=\"$(cd \"$(dirname \"${BASH_SOURCE[0]}\")\" && pwd)\"\n```" }
+      ]
+    },
+    "PIPESTATUS": {
+      "contents": [
+        { "value": "```bash\nPIPESTATUS  # array variable\n```\nAn array containing the exit statuses of the processes in the most recently executed foreground pipeline. `${PIPESTATUS[0]}` is the first command's status, `${PIPESTATUS[1]}` the second, etc. Useful for checking individual stages: `cmd1 | cmd2; echo \"${PIPESTATUS[@]}\"`." }
+      ]
+    },
+    "RANDOM": {
+      "contents": [
+        { "value": "```bash\nRANDOM\n```\nEach reference generates a random integer between 0 and 32767. Assigning a value seeds the generator for reproducible sequences. For a range 0 to N-1: `$((RANDOM % N))`. For better randomness in scripts, consider `/dev/urandom`." }
+      ]
+    },
+    "SECONDS": {
+      "contents": [
+        { "value": "```bash\nSECONDS\n```\nThe number of seconds since the shell was started. Assigning a value resets the counter:\n```bash\nSECONDS=0\n# ... operations ...\necho \"Elapsed: ${SECONDS}s\"\n```" }
+      ]
+    },
+    "FUNCNAME": {
+      "contents": [
+        { "value": "```bash\nFUNCNAME  # array variable\n```\nAn array of function names in the call stack. `${FUNCNAME[0]}` is the current function, `${FUNCNAME[1]}` is the caller, etc. The last element is `main` (for top-level code). Only meaningful inside functions." }
+      ]
+    },
+    "BASH_REMATCH": {
+      "contents": [
+        { "value": "```bash\nBASH_REMATCH  # array variable\n```\nPopulated by the `=~` operator in `[[ ]]`. Element 0 contains the entire match, elements 1+ contain capture group matches:\n```bash\nif [[ \"hello123\" =~ ^([a-z]+)([0-9]+)$ ]]; then\n    echo \"${BASH_REMATCH[0]}\"  # hello123\n    echo \"${BASH_REMATCH[1]}\"  # hello\n    echo \"${BASH_REMATCH[2]}\"  # 123\nfi\n```" }
+      ]
+    },
+    "mapfile": {
+      "contents": [
+        { "value": "```bash\nmapfile [-d delim] [-n count] [-O origin] [-s count] [-t] [-u fd] [-C callback] [-c quantum] [array]\n```\nRead lines from stdin into an indexed array. Default array is `MAPFILE`. `-t` strips trailing delimiters. `-n count` reads at most N lines. `-s count` skips the first N lines. Also available as `readarray`.\n```bash\nmapfile -t lines < file.txt\necho \"${lines[0]}\"\n```" }
+      ]
+    },
+    "let": {
+      "contents": [
+        { "value": "```bash\nlet expression [expression ...]\n```\nEvaluate arithmetic expressions. Each expression is an arithmetic expression using C-style operators: `+`, `-`, `*`, `/`, `%`, `**`, `++`, `--`, comparisons, bitwise and logical operators. Returns 0 if the last expression is non-zero, 1 otherwise. Equivalent to `(( expression ))`." }
+      ]
+    },
+    "history": {
+      "contents": [
+        { "value": "```bash\nhistory [-c] [-d offset] [n]\nhistory -anrw [filename]\n```\nDisplay or manipulate command history. `history n` shows the last N entries. `-c` clears the history list. `-d N` deletes entry N. `-a` appends new entries to the history file. `-r` reads the history file. `-w` writes the current history to the file. `HISTSIZE` controls the in-memory list size, `HISTFILESIZE` the file size." }
+      ]
+    }
+  }
+}

package/data/hover/c.json

@@ -0,0 +1,265 @@
+{
+  "language": "c",
+  "hovers": {
+    "printf": {
+      "contents": [
+        { "value": "```c\nint printf(const char *format, ...)\n```\nPrint formatted output to stdout. Returns the number of characters written, or a negative value on error. Format specifiers: %d (int), %f (double), %s (string), %c (char), %p (pointer), %x (hex), %o (octal), %u (unsigned), %zu (size_t), %ld (long), %lld (long long). Width and precision: %10d (min width), %.2f (precision), %-20s (left-align).\n\n**Header:** `<stdio.h>`" }
+      ]
+    },
+    "scanf": {
+      "contents": [
+        { "value": "```c\nint scanf(const char *format, ...)\n```\nRead formatted input from stdin. Arguments must be pointers — use `&` for non-array types. Returns the number of input items successfully matched and assigned, or EOF on input failure. Use field width to prevent buffer overflow: `%49s`.\n\n**Header:** `<stdio.h>`" }
+      ]
+    },
+    "fprintf": {
+      "contents": [
+        { "value": "```c\nint fprintf(FILE *stream, const char *format, ...)\n```\nWrite formatted output to the specified file stream. Commonly used with `stderr` for error messages: `fprintf(stderr, \"Error: %s\\n\", msg)`. Returns the number of characters written.\n\n**Header:** `<stdio.h>`" }
+      ]
+    },
+    "sprintf": {
+      "contents": [
+        { "value": "```c\nint sprintf(char *str, const char *format, ...)\n```\nWrite formatted output to a string buffer. **Warning:** No bounds checking — risk of buffer overflow. Prefer `snprintf()` for safe formatting. Returns the number of characters written (excluding null terminator).\n\n**Header:** `<stdio.h>`" }
+      ]
+    },
+    "snprintf": {
+      "contents": [
+        { "value": "```c\nint snprintf(char *str, size_t size, const char *format, ...)\n```\nWrite at most `size-1` characters to `str`, always null-terminating. Returns the number of characters that *would* have been written if the buffer were large enough (excluding null terminator). Safe alternative to `sprintf()`.\n\n**Header:** `<stdio.h>` (C99)" }
+      ]
+    },
+    "fopen": {
+      "contents": [
+        { "value": "```c\nFILE *fopen(const char *filename, const char *mode)\n```\nOpen a file and return a FILE pointer. Returns NULL on failure (check errno/perror). Modes: `\"r\"` (read), `\"w\"` (write/truncate), `\"a\"` (append), `\"r+\"` (read+write), `\"w+\"` (read+write/truncate), `\"a+\"` (read+append). Add `\"b\"` for binary mode on Windows.\n\n**Header:** `<stdio.h>`" }
+      ]
+    },
+    "fclose": {
+      "contents": [
+        { "value": "```c\nint fclose(FILE *stream)\n```\nClose an open file stream and flush unwritten buffered data. Returns 0 on success, EOF on failure. Always close files when done to avoid resource leaks.\n\n**Header:** `<stdio.h>`" }
+      ]
+    },
+    "fgets": {
+      "contents": [
+        { "value": "```c\nchar *fgets(char *str, int n, FILE *stream)\n```\nRead at most `n-1` characters from stream, stopping at newline or EOF. Always null-terminates. The newline character is included in the string if read. Returns `str` on success, NULL on failure or EOF. Preferred over `gets()` (which is removed in C11).\n\n**Header:** `<stdio.h>`" }
+      ]
+    },
+    "fread": {
+      "contents": [
+        { "value": "```c\nsize_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream)\n```\nRead up to `nmemb` elements of `size` bytes each from stream into buffer. Returns the number of elements successfully read (may be less than nmemb on EOF or error). Use `feof()` and `ferror()` to distinguish.\n\n**Header:** `<stdio.h>`" }
+      ]
+    },
+    "fwrite": {
+      "contents": [
+        { "value": "```c\nsize_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream)\n```\nWrite `nmemb` elements of `size` bytes each from buffer to stream. Returns the number of elements successfully written. A short count indicates an error.\n\n**Header:** `<stdio.h>`" }
+      ]
+    },
+    "malloc": {
+      "contents": [
+        { "value": "```c\nvoid *malloc(size_t size)\n```\nAllocate `size` bytes of uninitialized heap memory. Returns a pointer to the allocated block, or NULL on failure. Always check the return value. The memory must be freed with `free()` to prevent leaks. Cast the return in C++, optional in C.\n\n**Header:** `<stdlib.h>`" }
+      ]
+    },
+    "calloc": {
+      "contents": [
+        { "value": "```c\nvoid *calloc(size_t nmemb, size_t size)\n```\nAllocate memory for an array of `nmemb` elements of `size` bytes each, initialized to zero. Returns NULL on failure. Safer than malloc for arrays since it checks for multiplication overflow on some implementations.\n\n**Header:** `<stdlib.h>`" }
+      ]
+    },
+    "realloc": {
+      "contents": [
+        { "value": "```c\nvoid *realloc(void *ptr, size_t size)\n```\nResize a previously allocated memory block to `size` bytes. May move the block to a new address. Returns NULL on failure (original block is unchanged). **Never assign directly back to ptr** — use a temporary to avoid losing the original pointer on failure.\n\n**Header:** `<stdlib.h>`" }
+      ]
+    },
+    "free": {
+      "contents": [
+        { "value": "```c\nvoid free(void *ptr)\n```\nDeallocate memory previously returned by `malloc()`, `calloc()`, or `realloc()`. Passing NULL is safe (no-op). Double-free and use-after-free cause undefined behavior. Best practice: set pointer to NULL after freeing.\n\n**Header:** `<stdlib.h>`" }
+      ]
+    },
+    "exit": {
+      "contents": [
+        { "value": "```c\nvoid exit(int status)\n```\nTerminate the program with the given exit status. Calls functions registered with `atexit()`, flushes and closes all open streams, removes temporary files. Use `EXIT_SUCCESS` (0) or `EXIT_FAILURE` (1). Does not return.\n\n**Header:** `<stdlib.h>`" }
+      ]
+    },
+    "atoi": {
+      "contents": [
+        { "value": "```c\nint atoi(const char *nptr)\n```\nConvert a string to an integer. Skips leading whitespace, reads optional sign and digits. Returns 0 if no conversion is possible. **No error detection** — does not distinguish between \"0\" and invalid input. Prefer `strtol()` for robust parsing.\n\n**Header:** `<stdlib.h>`" }
+      ]
+    },
+    "strtol": {
+      "contents": [
+        { "value": "```c\nlong strtol(const char *nptr, char **endptr, int base)\n```\nConvert string to long integer with error detection. `base` can be 0 (auto-detect: 0x=hex, 0=octal, else decimal) or 2–36. Sets `*endptr` to first unconverted char. Sets `errno` to `ERANGE` on overflow/underflow.\n\n**Header:** `<stdlib.h>`" }
+      ]
+    },
+    "qsort": {
+      "contents": [
+        { "value": "```c\nvoid qsort(void *base, size_t nmemb, size_t size,\n           int (*compar)(const void *, const void *))\n```\nSort an array in-place. The comparison function receives pointers to elements and must return <0, 0, or >0. Not guaranteed to be stable (equal elements may be reordered). Typical comparator: `return *(int*)a - *(int*)b;`.\n\n**Header:** `<stdlib.h>`" }
+      ]
+    },
+    "strlen": {
+      "contents": [
+        { "value": "```c\nsize_t strlen(const char *s)\n```\nReturn the length of string `s`, not counting the terminating null byte. The string must be null-terminated — passing an unterminated buffer is undefined behavior. Returns a `size_t` (unsigned).\n\n**Header:** `<string.h>`" }
+      ]
+    },
+    "strcpy": {
+      "contents": [
+        { "value": "```c\nchar *strcpy(char *dest, const char *src)\n```\nCopy the string `src` (including null terminator) to `dest`. The destination must be large enough to hold the result. **Unsafe** — no bounds checking. Prefer `strncpy()` or `snprintf()` to prevent buffer overflows.\n\n**Header:** `<string.h>`" }
+      ]
+    },
+    "strncpy": {
+      "contents": [
+        { "value": "```c\nchar *strncpy(char *dest, const char *src, size_t n)\n```\nCopy up to `n` characters from `src` to `dest`. If `src` is shorter than `n`, pads with null bytes. **Warning:** Does NOT null-terminate if `src` has `n` or more characters. Always manually null-terminate: `dest[n-1] = '\\0';`.\n\n**Header:** `<string.h>`" }
+      ]
+    },
+    "strcmp": {
+      "contents": [
+        { "value": "```c\nint strcmp(const char *s1, const char *s2)\n```\nCompare two null-terminated strings lexicographically. Returns 0 if equal, negative if `s1 < s2`, positive if `s1 > s2`. Comparison is based on unsigned char values. Use `strncmp()` for bounded comparison.\n\n**Header:** `<string.h>`" }
+      ]
+    },
+    "strcat": {
+      "contents": [
+        { "value": "```c\nchar *strcat(char *dest, const char *src)\n```\nAppend string `src` to the end of `dest`. The destination must have enough space for both strings plus the null terminator. **Unsafe** — prefer `strncat()` to prevent buffer overflow.\n\n**Header:** `<string.h>`" }
+      ]
+    },
+    "strstr": {
+      "contents": [
+        { "value": "```c\nchar *strstr(const char *haystack, const char *needle)\n```\nFind the first occurrence of substring `needle` in `haystack`. Returns a pointer to the beginning of the match, or NULL if not found. If `needle` is empty, returns `haystack`.\n\n**Header:** `<string.h>`" }
+      ]
+    },
+    "memcpy": {
+      "contents": [
+        { "value": "```c\nvoid *memcpy(void *dest, const void *src, size_t n)\n```\nCopy `n` bytes from `src` to `dest`. The memory regions **must not overlap** — use `memmove()` if they might. Returns `dest`. Commonly used for copying structs, arrays, and binary data.\n\n**Header:** `<string.h>`" }
+      ]
+    },
+    "memmove": {
+      "contents": [
+        { "value": "```c\nvoid *memmove(void *dest, const void *src, size_t n)\n```\nCopy `n` bytes from `src` to `dest`, safely handling overlapping memory regions. Slower than `memcpy()` but always correct. Returns `dest`.\n\n**Header:** `<string.h>`" }
+      ]
+    },
+    "memset": {
+      "contents": [
+        { "value": "```c\nvoid *memset(void *s, int c, size_t n)\n```\nFill the first `n` bytes of memory area `s` with byte value `c`. Commonly used to zero-initialize: `memset(buf, 0, sizeof(buf))`. Note: sets *bytes*, not ints — `memset(arr, 1, n)` does NOT set each int to 1.\n\n**Header:** `<string.h>`" }
+      ]
+    },
+    "memcmp": {
+      "contents": [
+        { "value": "```c\nint memcmp(const void *s1, const void *s2, size_t n)\n```\nCompare the first `n` bytes of two memory areas. Returns 0 if equal, negative if `s1 < s2`, positive if `s1 > s2`. Compares bytes as unsigned char values.\n\n**Header:** `<string.h>`" }
+      ]
+    },
+    "strtok": {
+      "contents": [
+        { "value": "```c\nchar *strtok(char *str, const char *delim)\n```\nTokenize a string by splitting at delimiter characters. First call: pass the string. Subsequent calls: pass NULL to continue. **Modifies the original string** by inserting null bytes. **Not thread-safe** — use `strtok_r()` for thread safety.\n\n**Header:** `<string.h>`" }
+      ]
+    },
+    "sqrt": {
+      "contents": [
+        { "value": "```c\ndouble sqrt(double x)\n```\nCompute the non-negative square root of `x`. Domain error if `x` is negative. For float/long double variants, use `sqrtf()` / `sqrtl()` (C99). Link with `-lm`.\n\n**Header:** `<math.h>`" }
+      ]
+    },
+    "pow": {
+      "contents": [
+        { "value": "```c\ndouble pow(double base, double exp)\n```\nCompute `base` raised to the power `exp`. Domain error if `base` is negative and `exp` is not an integer. For integer exponents, consider manual multiplication for better performance. Link with `-lm`.\n\n**Header:** `<math.h>`" }
+      ]
+    },
+    "fabs": {
+      "contents": [
+        { "value": "```c\ndouble fabs(double x)\n```\nReturn the absolute value of double `x`. Use `abs()` for integers, `fabsf()` for float, `fabsl()` for long double. Link with `-lm`.\n\n**Header:** `<math.h>`" }
+      ]
+    },
+    "sizeof": {
+      "contents": [
+        { "value": "```c\nsizeof(type-or-expression)\n```\nCompile-time operator that returns the size in bytes of a type or expression as `size_t`. Can be applied to types: `sizeof(int)`, variables: `sizeof(x)`, or arrays: `sizeof(arr)/sizeof(arr[0])` for array length. For VLAs (C99), evaluated at runtime." }
+      ]
+    },
+    "struct": {
+      "contents": [
+        { "value": "```c\nstruct Name {\n    type member1;\n    type member2;\n};\n```\nDefine a composite data type that groups related variables. Access members with `.` (direct) or `->` (via pointer). Can be typedef'd: `typedef struct { int x, y; } Point;`. Commonly used with `malloc()` for dynamic allocation." }
+      ]
+    },
+    "enum": {
+      "contents": [
+        { "value": "```c\nenum Name { VALUE1, VALUE2, VALUE3 };\n```\nDefine a set of named integer constants. By default, values start at 0 and increment by 1. Can assign explicit values: `enum { A = 1, B = 5, C = 10 };`. Values are of type `int`. Commonly typedef'd: `typedef enum { ... } Name;`." }
+      ]
+    },
+    "union": {
+      "contents": [
+        { "value": "```c\nunion Name {\n    type1 member1;\n    type2 member2;\n};\n```\nDefine a type where all members share the same memory location. The size of the union equals the size of its largest member. Only one member should be active at a time. Reading a different member than the one last written is implementation-defined." }
+      ]
+    },
+    "typedef": {
+      "contents": [
+        { "value": "```c\ntypedef existing_type new_name;\n```\nCreate an alias for an existing type. Common uses: `typedef unsigned long ulong;`, `typedef struct Node Node;`, `typedef void (*callback_t)(int);` (function pointer type). Does not create a new type — just an alias." }
+      ]
+    },
+    "static": {
+      "contents": [
+        { "value": "```c\nstatic type variable;\nstatic return_type function(params);\n```\nTwo meanings depending on context: (1) At file scope: restricts visibility to the current translation unit (internal linkage). (2) Inside a function: the variable retains its value between calls (static storage duration). Initializes to zero if not explicitly initialized." }
+      ]
+    },
+    "extern": {
+      "contents": [
+        { "value": "```c\nextern type variable;\nextern return_type function(params);\n```\nDeclare a variable or function that is defined in another translation unit. Tells the compiler the symbol exists elsewhere and will be resolved at link time. Typically placed in header files." }
+      ]
+    },
+    "const": {
+      "contents": [
+        { "value": "```c\nconst type name = value;\n```\nDeclare a read-only variable. Attempting to modify a `const` variable is undefined behavior. Pointer-to-const: `const int *p` (data is const). Const pointer: `int *const p` (pointer is const). Const pointer to const: `const int *const p` (both const)." }
+      ]
+    },
+    "volatile": {
+      "contents": [
+        { "value": "```c\nvolatile type name;\n```\nTell the compiler that the variable may change at any time (e.g., hardware registers, signal handlers, shared memory). Prevents the compiler from optimizing away reads/writes to this variable. Does NOT provide atomicity or memory ordering guarantees." }
+      ]
+    },
+    "inline": {
+      "contents": [
+        { "value": "```c\nstatic inline return_type function(params) { ... }\n```\nSuggest to the compiler that the function body be expanded at the call site instead of performing a function call. Only a hint — the compiler may ignore it. Typically used with `static` in headers. C99 feature." }
+      ]
+    },
+    "NULL": {
+      "contents": [
+        { "value": "```c\n#define NULL ((void *)0)\n```\nNull pointer constant representing a pointer that points to no valid object. Defined in `<stddef.h>`, `<stdio.h>`, `<stdlib.h>`, `<string.h>`, and others. Always check pointer return values against NULL." }
+      ]
+    },
+    "EOF": {
+      "contents": [
+        { "value": "```c\n#define EOF (-1)\n```\nEnd-of-file indicator, a negative integer (typically -1). Returned by `getchar()`, `fgetc()`, `scanf()`, and other input functions to signal end of input or error. Important: Use `int` (not `char`) to store the return value to distinguish EOF from valid characters." }
+      ]
+    },
+    "size_t": {
+      "contents": [
+        { "value": "```c\ntypedef unsigned long size_t;  // typical\n```\nUnsigned integer type returned by `sizeof` and used for sizes and counts. Guaranteed to hold the size of any object. Use `%zu` format specifier for printf. Defined in `<stddef.h>`, `<stdlib.h>`, `<string.h>`, `<stdio.h>`." }
+      ]
+    },
+    "FILE": {
+      "contents": [
+        { "value": "```c\ntypedef struct _IO_FILE FILE;\n```\nOpaque type for file stream I/O. Created by `fopen()`, closed by `fclose()`. Standard streams: `stdin` (standard input), `stdout` (standard output), `stderr` (standard error). All stdio.h I/O functions operate on `FILE *`.\n\n**Header:** `<stdio.h>`" }
+      ]
+    },
+    "#include": {
+      "contents": [
+        { "value": "```c\n#include <header.h>    // system headers\n#include \"header.h\"    // local headers\n```\nPreprocessor directive that includes the contents of a file. Angle brackets search system include paths first; quotes search the current directory first. This is textual inclusion — the file contents replace the `#include` line." }
+      ]
+    },
+    "#define": {
+      "contents": [
+        { "value": "```c\n#define NAME value\n#define MACRO(x, y) ((x) + (y))\n```\nPreprocessor directive that defines a macro. Object-like macros substitute a value; function-like macros take parameters. Always parenthesize macro arguments and the entire expression to prevent operator precedence issues. Use `#undef` to undefine." }
+      ]
+    },
+    "errno": {
+      "contents": [
+        { "value": "```c\nextern int errno;\n```\nThread-local error number set by system calls and library functions on error. Check immediately after a function call — it may be overwritten by subsequent calls. Common values: `EACCES`, `ENOENT`, `ENOMEM`, `EINVAL`, `EIO`. Use `perror()` or `strerror(errno)` for messages.\n\n**Header:** `<errno.h>`" }
+      ]
+    },
+    "assert": {
+      "contents": [
+        { "value": "```c\nassert(expression);\n```\nRuntime assertion macro. If `expression` evaluates to 0 (false), prints a diagnostic message to stderr and calls `abort()`. Disabled when `NDEBUG` is defined before including `<assert.h>`. Use for documenting and checking invariants during development.\n\n**Header:** `<assert.h>`" }
+      ]
+    },
+    "time": {
+      "contents": [
+        { "value": "```c\ntime_t time(time_t *tloc)\n```\nReturn the current calendar time as `time_t` (seconds since Unix epoch: 1970-01-01 00:00:00 UTC). Returns `(time_t)-1` on error. If `tloc` is not NULL, the value is also stored at `*tloc`. Convert to human-readable with `ctime()`, `localtime()`, or `gmtime()`.\n\n**Header:** `<time.h>`" }
+      ]
+    },
+    "signal": {
+      "contents": [
+        { "value": "```c\nvoid (*signal(int signum, void (*handler)(int)))(int)\n```\nSet a signal handler for signal `signum`. Handler can be `SIG_DFL` (default), `SIG_IGN` (ignore), or a custom function. Returns the previous handler. Common signals: `SIGINT` (Ctrl+C), `SIGTERM` (termination), `SIGSEGV` (segfault), `SIGABRT` (abort).\n\n**Header:** `<signal.h>`" }
+      ]
+    }
+  }
+}