@enjoys/context-engine 1.0.0 → 1.0.2

package/data/completion/c.json

@@ -0,0 +1,1067 @@
+{
+  "language": "c",
+  "completions": [
+    {
+      "label": "printf",
+      "kind": 1,
+      "detail": "Print formatted output to stdout",
+      "documentation": { "value": "Writes formatted output to stdout.\n\n```c\nprintf(\"Hello %s, age %d\\n\", name, age);\nprintf(\"%.2f\\n\", 3.14159);\n```" },
+      "insertText": "printf(\"${1:format}\", ${2:args})",
+      "insertTextRules": 4,
+      "sortText": "00_printf"
+    },
+    {
+      "label": "scanf",
+      "kind": 1,
+      "detail": "Read formatted input from stdin",
+      "documentation": { "value": "Reads formatted input from stdin.\n\n```c\nint n;\nscanf(\"%d\", &n);\nchar name[50];\nscanf(\"%49s\", name);\n```" },
+      "insertText": "scanf(\"${1:format}\", ${2:&var})",
+      "insertTextRules": 4,
+      "sortText": "00_scanf"
+    },
+    {
+      "label": "fprintf",
+      "kind": 1,
+      "detail": "Print formatted output to a stream",
+      "documentation": { "value": "Writes formatted output to a file stream.\n\n```c\nFILE *fp = fopen(\"log.txt\", \"w\");\nfprintf(fp, \"Error code: %d\\n\", code);\nfprintf(stderr, \"Error: %s\\n\", msg);\n```" },
+      "insertText": "fprintf(${1:stream}, \"${2:format}\", ${3:args})",
+      "insertTextRules": 4,
+      "sortText": "00_fprintf"
+    },
+    {
+      "label": "fscanf",
+      "kind": 1,
+      "detail": "Read formatted input from a stream",
+      "documentation": { "value": "Reads formatted input from a file stream.\n\n```c\nFILE *fp = fopen(\"data.txt\", \"r\");\nint x;\nfscanf(fp, \"%d\", &x);\n```" },
+      "insertText": "fscanf(${1:stream}, \"${2:format}\", ${3:&var})",
+      "insertTextRules": 4,
+      "sortText": "00_fscanf"
+    },
+    {
+      "label": "sprintf",
+      "kind": 1,
+      "detail": "Print formatted output to a string",
+      "documentation": { "value": "Writes formatted output to a character string buffer.\n\n```c\nchar buf[256];\nsprintf(buf, \"Name: %s, Score: %d\", name, score);\n```" },
+      "insertText": "sprintf(${1:buf}, \"${2:format}\", ${3:args})",
+      "insertTextRules": 4,
+      "sortText": "00_sprintf"
+    },
+    {
+      "label": "snprintf",
+      "kind": 1,
+      "detail": "Print formatted output to a string with size limit",
+      "documentation": { "value": "Writes formatted output to a buffer with a maximum size to prevent overflow.\n\n```c\nchar buf[64];\nsnprintf(buf, sizeof(buf), \"Value: %d\", val);\n```" },
+      "insertText": "snprintf(${1:buf}, ${2:size}, \"${3:format}\", ${4:args})",
+      "insertTextRules": 4,
+      "sortText": "00_snprintf"
+    },
+    {
+      "label": "fopen",
+      "kind": 1,
+      "detail": "Open a file",
+      "documentation": { "value": "Opens a file and returns a FILE pointer.\n\n```c\nFILE *fp = fopen(\"data.txt\", \"r\");\nif (fp == NULL) {\n    perror(\"fopen\");\n    return 1;\n}\n```\nModes: \"r\" read, \"w\" write, \"a\" append, \"rb\" binary read, \"wb\" binary write." },
+      "insertText": "fopen(\"${1:filename}\", \"${2:r}\")",
+      "insertTextRules": 4,
+      "sortText": "00_fopen"
+    },
+    {
+      "label": "fclose",
+      "kind": 1,
+      "detail": "Close a file",
+      "documentation": { "value": "Closes an open file stream and flushes the buffer.\n\n```c\nfclose(fp);\n```" },
+      "insertText": "fclose(${1:fp})",
+      "insertTextRules": 4,
+      "sortText": "00_fclose"
+    },
+    {
+      "label": "fread",
+      "kind": 1,
+      "detail": "Read binary data from a file",
+      "documentation": { "value": "Reads binary data from a file stream.\n\n```c\nchar buf[1024];\nsize_t n = fread(buf, 1, sizeof(buf), fp);\n```" },
+      "insertText": "fread(${1:ptr}, ${2:size}, ${3:count}, ${4:stream})",
+      "insertTextRules": 4,
+      "sortText": "00_fread"
+    },
+    {
+      "label": "fwrite",
+      "kind": 1,
+      "detail": "Write binary data to a file",
+      "documentation": { "value": "Writes binary data to a file stream.\n\n```c\nfwrite(data, sizeof(int), count, fp);\n```" },
+      "insertText": "fwrite(${1:ptr}, ${2:size}, ${3:count}, ${4:stream})",
+      "insertTextRules": 4,
+      "sortText": "00_fwrite"
+    },
+    {
+      "label": "fgets",
+      "kind": 1,
+      "detail": "Read a line from a stream",
+      "documentation": { "value": "Reads a line from a file stream into a buffer.\n\n```c\nchar line[256];\nwhile (fgets(line, sizeof(line), fp) != NULL) {\n    printf(\"%s\", line);\n}\n```" },
+      "insertText": "fgets(${1:buf}, ${2:size}, ${3:stream})",
+      "insertTextRules": 4,
+      "sortText": "00_fgets"
+    },
+    {
+      "label": "fputs",
+      "kind": 1,
+      "detail": "Write a string to a stream",
+      "documentation": { "value": "Writes a string to a file stream without a trailing newline.\n\n```c\nfputs(\"Hello, World!\\n\", fp);\n```" },
+      "insertText": "fputs(${1:str}, ${2:stream})",
+      "insertTextRules": 4,
+      "sortText": "00_fputs"
+    },
+    {
+      "label": "fseek",
+      "kind": 1,
+      "detail": "Set file position indicator",
+      "documentation": { "value": "Sets the file position indicator for a stream.\n\n```c\nfseek(fp, 0, SEEK_SET);  // beginning\nfseek(fp, 0, SEEK_END);  // end\nfseek(fp, offset, SEEK_CUR);  // relative\n```" },
+      "insertText": "fseek(${1:stream}, ${2:offset}, ${3:SEEK_SET})",
+      "insertTextRules": 4,
+      "sortText": "00_fseek"
+    },
+    {
+      "label": "ftell",
+      "kind": 1,
+      "detail": "Get current file position",
+      "documentation": { "value": "Returns the current file position indicator.\n\n```c\nlong pos = ftell(fp);\n```" },
+      "insertText": "ftell(${1:stream})",
+      "insertTextRules": 4,
+      "sortText": "00_ftell"
+    },
+    {
+      "label": "rewind",
+      "kind": 1,
+      "detail": "Reset file position to beginning",
+      "documentation": { "value": "Resets the file position to the beginning of the file.\n\n```c\nrewind(fp);\n```" },
+      "insertText": "rewind(${1:stream})",
+      "insertTextRules": 4,
+      "sortText": "00_rewind"
+    },
+    {
+      "label": "feof",
+      "kind": 1,
+      "detail": "Check end-of-file indicator",
+      "documentation": { "value": "Tests the end-of-file indicator for a stream.\n\n```c\nwhile (!feof(fp)) {\n    fgets(line, sizeof(line), fp);\n}\n```" },
+      "insertText": "feof(${1:stream})",
+      "insertTextRules": 4,
+      "sortText": "00_feof"
+    },
+    {
+      "label": "fflush",
+      "kind": 1,
+      "detail": "Flush a stream",
+      "documentation": { "value": "Flushes the output buffer of a stream.\n\n```c\nfflush(stdout);\nfflush(fp);\n```" },
+      "insertText": "fflush(${1:stream})",
+      "insertTextRules": 4,
+      "sortText": "00_fflush"
+    },
+    {
+      "label": "perror",
+      "kind": 1,
+      "detail": "Print error message",
+      "documentation": { "value": "Prints a descriptive error message to stderr based on errno.\n\n```c\nFILE *fp = fopen(\"missing.txt\", \"r\");\nif (!fp) {\n    perror(\"fopen\");\n}\n```" },
+      "insertText": "perror(\"${1:msg}\")",
+      "insertTextRules": 4,
+      "sortText": "00_perror"
+    },
+    {
+      "label": "malloc",
+      "kind": 1,
+      "detail": "Allocate memory",
+      "documentation": { "value": "Allocates a block of uninitialized memory on the heap.\n\n```c\nint *arr = (int *)malloc(n * sizeof(int));\nif (arr == NULL) {\n    perror(\"malloc\");\n    exit(1);\n}\nfree(arr);\n```" },
+      "insertText": "malloc(${1:size})",
+      "insertTextRules": 4,
+      "sortText": "00_malloc"
+    },
+    {
+      "label": "calloc",
+      "kind": 1,
+      "detail": "Allocate and zero-initialize memory",
+      "documentation": { "value": "Allocates memory for an array and initializes all bytes to zero.\n\n```c\nint *arr = (int *)calloc(n, sizeof(int));\nif (!arr) {\n    perror(\"calloc\");\n    exit(1);\n}\nfree(arr);\n```" },
+      "insertText": "calloc(${1:count}, ${2:size})",
+      "insertTextRules": 4,
+      "sortText": "00_calloc"
+    },
+    {
+      "label": "realloc",
+      "kind": 1,
+      "detail": "Reallocate memory block",
+      "documentation": { "value": "Resizes a previously allocated memory block.\n\n```c\nint *tmp = (int *)realloc(arr, new_size * sizeof(int));\nif (!tmp) {\n    perror(\"realloc\");\n    free(arr);\n    exit(1);\n}\narr = tmp;\n```" },
+      "insertText": "realloc(${1:ptr}, ${2:new_size})",
+      "insertTextRules": 4,
+      "sortText": "00_realloc"
+    },
+    {
+      "label": "free",
+      "kind": 1,
+      "detail": "Free allocated memory",
+      "documentation": { "value": "Deallocates previously allocated memory.\n\n```c\nfree(ptr);\nptr = NULL;\n```" },
+      "insertText": "free(${1:ptr})",
+      "insertTextRules": 4,
+      "sortText": "00_free"
+    },
+    {
+      "label": "exit",
+      "kind": 1,
+      "detail": "Terminate the program",
+      "documentation": { "value": "Terminates the calling process with the given exit status.\n\n```c\nexit(EXIT_SUCCESS);\nexit(EXIT_FAILURE);\n```" },
+      "insertText": "exit(${1:EXIT_SUCCESS})",
+      "insertTextRules": 4,
+      "sortText": "00_exit"
+    },
+    {
+      "label": "abort",
+      "kind": 1,
+      "detail": "Abort the program abnormally",
+      "documentation": { "value": "Causes abnormal program termination by raising SIGABRT.\n\n```c\nabort();\n```" },
+      "insertText": "abort()",
+      "insertTextRules": 4,
+      "sortText": "00_abort"
+    },
+    {
+      "label": "atoi",
+      "kind": 1,
+      "detail": "Convert string to integer",
+      "documentation": { "value": "Converts a string to an integer. No error handling — prefer strtol.\n\n```c\nint n = atoi(\"42\");\n```" },
+      "insertText": "atoi(${1:str})",
+      "insertTextRules": 4,
+      "sortText": "00_atoi"
+    },
+    {
+      "label": "atof",
+      "kind": 1,
+      "detail": "Convert string to double",
+      "documentation": { "value": "Converts a string to a double. No error handling — prefer strtod.\n\n```c\ndouble d = atof(\"3.14\");\n```" },
+      "insertText": "atof(${1:str})",
+      "insertTextRules": 4,
+      "sortText": "00_atof"
+    },
+    {
+      "label": "strtol",
+      "kind": 1,
+      "detail": "Convert string to long integer",
+      "documentation": { "value": "Converts a string to a long integer with error detection.\n\n```c\nchar *end;\nlong val = strtol(\"123abc\", &end, 10);\nif (*end != '\\0') {\n    printf(\"Trailing chars: %s\\n\", end);\n}\n```" },
+      "insertText": "strtol(${1:str}, ${2:&endptr}, ${3:10})",
+      "insertTextRules": 4,
+      "sortText": "00_strtol"
+    },
+    {
+      "label": "strtod",
+      "kind": 1,
+      "detail": "Convert string to double",
+      "documentation": { "value": "Converts a string to a double with error detection.\n\n```c\nchar *end;\ndouble val = strtod(\"3.14xyz\", &end);\n```" },
+      "insertText": "strtod(${1:str}, ${2:&endptr})",
+      "insertTextRules": 4,
+      "sortText": "00_strtod"
+    },
+    {
+      "label": "rand",
+      "kind": 1,
+      "detail": "Generate pseudo-random number",
+      "documentation": { "value": "Returns a pseudo-random integer in [0, RAND_MAX].\n\n```c\nsrand(time(NULL));\nint r = rand() % 100;  // 0-99\n```" },
+      "insertText": "rand()",
+      "insertTextRules": 4,
+      "sortText": "00_rand"
+    },
+    {
+      "label": "srand",
+      "kind": 1,
+      "detail": "Seed the random number generator",
+      "documentation": { "value": "Seeds the pseudo-random number generator used by rand().\n\n```c\nsrand((unsigned int)time(NULL));\n```" },
+      "insertText": "srand(${1:(unsigned int)time(NULL)})",
+      "insertTextRules": 4,
+      "sortText": "00_srand"
+    },
+    {
+      "label": "qsort",
+      "kind": 1,
+      "detail": "Sort an array",
+      "documentation": { "value": "Sorts an array using a comparison function.\n\n```c\nint cmp(const void *a, const void *b) {\n    return (*(int *)a - *(int *)b);\n}\nqsort(arr, n, sizeof(int), cmp);\n```" },
+      "insertText": "qsort(${1:base}, ${2:nmemb}, ${3:size}, ${4:compar})",
+      "insertTextRules": 4,
+      "sortText": "00_qsort"
+    },
+    {
+      "label": "bsearch",
+      "kind": 1,
+      "detail": "Binary search a sorted array",
+      "documentation": { "value": "Searches a sorted array for a key using binary search.\n\n```c\nint key = 42;\nint *found = (int *)bsearch(&key, arr, n, sizeof(int), cmp);\n```" },
+      "insertText": "bsearch(${1:&key}, ${2:base}, ${3:nmemb}, ${4:size}, ${5:compar})",
+      "insertTextRules": 4,
+      "sortText": "00_bsearch"
+    },
+    {
+      "label": "abs",
+      "kind": 1,
+      "detail": "Compute absolute value of an integer",
+      "documentation": { "value": "Returns the absolute value of an integer.\n\n```c\nint val = abs(-42);  // 42\n```" },
+      "insertText": "abs(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "00_abs"
+    },
+    {
+      "label": "system",
+      "kind": 1,
+      "detail": "Execute a shell command",
+      "documentation": { "value": "Passes a command string to the host command processor.\n\n```c\nsystem(\"ls -la\");\nint ret = system(\"gcc -o out main.c\");\n```" },
+      "insertText": "system(\"${1:command}\")",
+      "insertTextRules": 4,
+      "sortText": "00_system"
+    },
+    {
+      "label": "getenv",
+      "kind": 1,
+      "detail": "Get environment variable",
+      "documentation": { "value": "Returns the value of an environment variable, or NULL if not found.\n\n```c\nconst char *home = getenv(\"HOME\");\nif (home) printf(\"Home: %s\\n\", home);\n```" },
+      "insertText": "getenv(\"${1:name}\")",
+      "insertTextRules": 4,
+      "sortText": "00_getenv"
+    },
+    {
+      "label": "strlen",
+      "kind": 1,
+      "detail": "Get string length",
+      "documentation": { "value": "Returns the length of a null-terminated string (not including the null byte).\n\n```c\nsize_t len = strlen(\"hello\");  // 5\n```" },
+      "insertText": "strlen(${1:str})",
+      "insertTextRules": 4,
+      "sortText": "00_strlen"
+    },
+    {
+      "label": "strcpy",
+      "kind": 1,
+      "detail": "Copy a string",
+      "documentation": { "value": "Copies a string to a destination buffer. Unsafe — prefer strncpy or snprintf.\n\n```c\nchar dest[64];\nstrcpy(dest, \"hello\");\n```" },
+      "insertText": "strcpy(${1:dest}, ${2:src})",
+      "insertTextRules": 4,
+      "sortText": "00_strcpy"
+    },
+    {
+      "label": "strncpy",
+      "kind": 1,
+      "detail": "Copy a bounded string",
+      "documentation": { "value": "Copies up to n characters from src to dest. May not null-terminate if src is longer.\n\n```c\nchar dest[64];\nstrncpy(dest, src, sizeof(dest) - 1);\ndest[sizeof(dest) - 1] = '\\0';\n```" },
+      "insertText": "strncpy(${1:dest}, ${2:src}, ${3:n})",
+      "insertTextRules": 4,
+      "sortText": "00_strncpy"
+    },
+    {
+      "label": "strcat",
+      "kind": 1,
+      "detail": "Concatenate strings",
+      "documentation": { "value": "Appends src to the end of dest. Unsafe — prefer strncat.\n\n```c\nchar buf[128] = \"Hello, \";\nstrcat(buf, \"World!\");\n```" },
+      "insertText": "strcat(${1:dest}, ${2:src})",
+      "insertTextRules": 4,
+      "sortText": "00_strcat"
+    },
+    {
+      "label": "strncat",
+      "kind": 1,
+      "detail": "Concatenate bounded strings",
+      "documentation": { "value": "Appends at most n characters from src to dest, then null-terminates.\n\n```c\nstrncat(dest, src, sizeof(dest) - strlen(dest) - 1);\n```" },
+      "insertText": "strncat(${1:dest}, ${2:src}, ${3:n})",
+      "insertTextRules": 4,
+      "sortText": "00_strncat"
+    },
+    {
+      "label": "strcmp",
+      "kind": 1,
+      "detail": "Compare two strings",
+      "documentation": { "value": "Compares two strings lexicographically. Returns 0 if equal, <0 if s1<s2, >0 if s1>s2.\n\n```c\nif (strcmp(a, b) == 0) {\n    printf(\"Strings are equal\\n\");\n}\n```" },
+      "insertText": "strcmp(${1:s1}, ${2:s2})",
+      "insertTextRules": 4,
+      "sortText": "00_strcmp"
+    },
+    {
+      "label": "strncmp",
+      "kind": 1,
+      "detail": "Compare bounded strings",
+      "documentation": { "value": "Compares up to n characters of two strings.\n\n```c\nif (strncmp(line, \"GET \", 4) == 0) {\n    // handle GET request\n}\n```" },
+      "insertText": "strncmp(${1:s1}, ${2:s2}, ${3:n})",
+      "insertTextRules": 4,
+      "sortText": "00_strncmp"
+    },
+    {
+      "label": "strchr",
+      "kind": 1,
+      "detail": "Find first occurrence of character",
+      "documentation": { "value": "Returns a pointer to the first occurrence of a character in a string.\n\n```c\nchar *p = strchr(str, ':');\nif (p) printf(\"Found at index %ld\\n\", p - str);\n```" },
+      "insertText": "strchr(${1:str}, ${2:ch})",
+      "insertTextRules": 4,
+      "sortText": "00_strchr"
+    },
+    {
+      "label": "strrchr",
+      "kind": 1,
+      "detail": "Find last occurrence of character",
+      "documentation": { "value": "Returns a pointer to the last occurrence of a character in a string.\n\n```c\nchar *ext = strrchr(filename, '.');\n```" },
+      "insertText": "strrchr(${1:str}, ${2:ch})",
+      "insertTextRules": 4,
+      "sortText": "00_strrchr"
+    },
+    {
+      "label": "strstr",
+      "kind": 1,
+      "detail": "Find substring",
+      "documentation": { "value": "Finds the first occurrence of a substring within a string.\n\n```c\nchar *p = strstr(haystack, \"needle\");\nif (p) printf(\"Found at index %ld\\n\", p - haystack);\n```" },
+      "insertText": "strstr(${1:haystack}, ${2:needle})",
+      "insertTextRules": 4,
+      "sortText": "00_strstr"
+    },
+    {
+      "label": "memcpy",
+      "kind": 1,
+      "detail": "Copy memory block",
+      "documentation": { "value": "Copies n bytes from src to dest. Regions must not overlap (use memmove instead).\n\n```c\nmemcpy(dest, src, n * sizeof(int));\n```" },
+      "insertText": "memcpy(${1:dest}, ${2:src}, ${3:n})",
+      "insertTextRules": 4,
+      "sortText": "00_memcpy"
+    },
+    {
+      "label": "memmove",
+      "kind": 1,
+      "detail": "Move memory block (overlap-safe)",
+      "documentation": { "value": "Copies n bytes from src to dest, handling overlapping regions safely.\n\n```c\nmemmove(arr + 1, arr, (n - 1) * sizeof(int));\n```" },
+      "insertText": "memmove(${1:dest}, ${2:src}, ${3:n})",
+      "insertTextRules": 4,
+      "sortText": "00_memmove"
+    },
+    {
+      "label": "memset",
+      "kind": 1,
+      "detail": "Fill memory with a byte value",
+      "documentation": { "value": "Fills n bytes of memory with the specified byte value.\n\n```c\nmemset(buf, 0, sizeof(buf));\nmemset(arr, -1, n * sizeof(int));\n```" },
+      "insertText": "memset(${1:ptr}, ${2:value}, ${3:n})",
+      "insertTextRules": 4,
+      "sortText": "00_memset"
+    },
+    {
+      "label": "memcmp",
+      "kind": 1,
+      "detail": "Compare memory blocks",
+      "documentation": { "value": "Compares n bytes of two memory blocks.\n\n```c\nif (memcmp(buf1, buf2, n) == 0) {\n    printf(\"Buffers are equal\\n\");\n}\n```" },
+      "insertText": "memcmp(${1:ptr1}, ${2:ptr2}, ${3:n})",
+      "insertTextRules": 4,
+      "sortText": "00_memcmp"
+    },
+    {
+      "label": "sqrt",
+      "kind": 1,
+      "detail": "Compute square root",
+      "documentation": { "value": "Returns the square root of x. Requires linking with -lm.\n\n```c\n#include <math.h>\ndouble r = sqrt(25.0);  // 5.0\n```" },
+      "insertText": "sqrt(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "00_sqrt"
+    },
+    {
+      "label": "pow",
+      "kind": 1,
+      "detail": "Raise to power",
+      "documentation": { "value": "Returns base raised to the power of exp.\n\n```c\ndouble val = pow(2.0, 10.0);  // 1024.0\n```" },
+      "insertText": "pow(${1:base}, ${2:exp})",
+      "insertTextRules": 4,
+      "sortText": "00_pow"
+    },
+    {
+      "label": "fabs",
+      "kind": 1,
+      "detail": "Absolute value of a double",
+      "documentation": { "value": "Returns the absolute value of a floating-point number.\n\n```c\ndouble d = fabs(-3.14);  // 3.14\n```" },
+      "insertText": "fabs(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "00_fabs"
+    },
+    {
+      "label": "ceil",
+      "kind": 1,
+      "detail": "Round up to nearest integer",
+      "documentation": { "value": "Returns the smallest integer not less than x.\n\n```c\ndouble c = ceil(2.3);  // 3.0\n```" },
+      "insertText": "ceil(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "00_ceil"
+    },
+    {
+      "label": "floor",
+      "kind": 1,
+      "detail": "Round down to nearest integer",
+      "documentation": { "value": "Returns the largest integer not greater than x.\n\n```c\ndouble f = floor(2.9);  // 2.0\n```" },
+      "insertText": "floor(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "00_floor"
+    },
+    {
+      "label": "round",
+      "kind": 1,
+      "detail": "Round to nearest integer",
+      "documentation": { "value": "Rounds x to the nearest integer, halfway cases away from zero.\n\n```c\ndouble r = round(2.5);  // 3.0\n```" },
+      "insertText": "round(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "00_round"
+    },
+    {
+      "label": "sin",
+      "kind": 1,
+      "detail": "Compute sine",
+      "documentation": { "value": "Returns the sine of x (in radians).\n\n```c\ndouble s = sin(M_PI / 2);  // 1.0\n```" },
+      "insertText": "sin(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "00_sin"
+    },
+    {
+      "label": "cos",
+      "kind": 1,
+      "detail": "Compute cosine",
+      "documentation": { "value": "Returns the cosine of x (in radians).\n\n```c\ndouble c = cos(0.0);  // 1.0\n```" },
+      "insertText": "cos(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "00_cos"
+    },
+    {
+      "label": "tan",
+      "kind": 1,
+      "detail": "Compute tangent",
+      "documentation": { "value": "Returns the tangent of x (in radians).\n\n```c\ndouble t = tan(M_PI / 4);  // ~1.0\n```" },
+      "insertText": "tan(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "00_tan"
+    },
+    {
+      "label": "log",
+      "kind": 1,
+      "detail": "Compute natural logarithm",
+      "documentation": { "value": "Returns the natural logarithm (base e) of x.\n\n```c\ndouble l = log(M_E);  // 1.0\n```" },
+      "insertText": "log(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "00_log"
+    },
+    {
+      "label": "log10",
+      "kind": 1,
+      "detail": "Compute base-10 logarithm",
+      "documentation": { "value": "Returns the base-10 logarithm of x.\n\n```c\ndouble l = log10(1000.0);  // 3.0\n```" },
+      "insertText": "log10(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "00_log10"
+    },
+    {
+      "label": "exp",
+      "kind": 1,
+      "detail": "Compute exponential (e^x)",
+      "documentation": { "value": "Returns e raised to the power x.\n\n```c\ndouble e = exp(1.0);  // ~2.71828\n```" },
+      "insertText": "exp(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "00_exp"
+    },
+    {
+      "label": "if",
+      "kind": 14,
+      "detail": "if statement",
+      "documentation": { "value": "Conditional execution.\n\n```c\nif (condition) {\n    // code\n}\n```" },
+      "insertText": "if (${1:condition}) {\n\t${2}\n}",
+      "insertTextRules": 4,
+      "sortText": "01_if"
+    },
+    {
+      "label": "else",
+      "kind": 14,
+      "detail": "else clause",
+      "documentation": { "value": "Alternative branch of an if statement.\n\n```c\nif (x > 0) {\n    // positive\n} else {\n    // non-positive\n}\n```" },
+      "insertText": "else {\n\t${1}\n}",
+      "insertTextRules": 4,
+      "sortText": "01_else"
+    },
+    {
+      "label": "for",
+      "kind": 14,
+      "detail": "for loop",
+      "documentation": { "value": "Loop with initialization, condition, and increment.\n\n```c\nfor (int i = 0; i < n; i++) {\n    // body\n}\n```" },
+      "insertText": "for (${1:int i = 0}; ${2:i < n}; ${3:i++}) {\n\t${4}\n}",
+      "insertTextRules": 4,
+      "sortText": "01_for"
+    },
+    {
+      "label": "while",
+      "kind": 14,
+      "detail": "while loop",
+      "documentation": { "value": "Loop that repeats while a condition is true.\n\n```c\nwhile (condition) {\n    // body\n}\n```" },
+      "insertText": "while (${1:condition}) {\n\t${2}\n}",
+      "insertTextRules": 4,
+      "sortText": "01_while"
+    },
+    {
+      "label": "do",
+      "kind": 14,
+      "detail": "do-while loop",
+      "documentation": { "value": "Loop that executes at least once.\n\n```c\ndo {\n    // body\n} while (condition);\n```" },
+      "insertText": "do {\n\t${1}\n} while (${2:condition});",
+      "insertTextRules": 4,
+      "sortText": "01_do"
+    },
+    {
+      "label": "switch",
+      "kind": 14,
+      "detail": "switch statement",
+      "documentation": { "value": "Multi-way branch based on an integer expression.\n\n```c\nswitch (val) {\n    case 1: break;\n    default: break;\n}\n```" },
+      "insertText": "switch (${1:expr}) {\n\tcase ${2:value}:\n\t\t${3}\n\t\tbreak;\n\tdefault:\n\t\tbreak;\n}",
+      "insertTextRules": 4,
+      "sortText": "01_switch"
+    },
+    {
+      "label": "case",
+      "kind": 14,
+      "detail": "case label in switch",
+      "documentation": { "value": "A case label inside a switch statement.\n\n```c\ncase 1:\n    printf(\"one\\n\");\n    break;\n```" },
+      "insertText": "case ${1:value}:\n\t${2}\n\tbreak;",
+      "insertTextRules": 4,
+      "sortText": "01_case"
+    },
+    {
+      "label": "break",
+      "kind": 14,
+      "detail": "Break out of loop or switch",
+      "documentation": { "value": "Exits the nearest enclosing loop or switch statement." },
+      "insertText": "break;",
+      "insertTextRules": 4,
+      "sortText": "01_break"
+    },
+    {
+      "label": "continue",
+      "kind": 14,
+      "detail": "Skip to next loop iteration",
+      "documentation": { "value": "Skips the rest of the current loop iteration and continues with the next." },
+      "insertText": "continue;",
+      "insertTextRules": 4,
+      "sortText": "01_continue"
+    },
+    {
+      "label": "return",
+      "kind": 14,
+      "detail": "Return from function",
+      "documentation": { "value": "Returns a value from a function.\n\n```c\nreturn 0;\nreturn result;\n```" },
+      "insertText": "return ${1:0};",
+      "insertTextRules": 4,
+      "sortText": "01_return"
+    },
+    {
+      "label": "typedef",
+      "kind": 14,
+      "detail": "Create a type alias",
+      "documentation": { "value": "Defines a new name for an existing type.\n\n```c\ntypedef unsigned long ulong;\ntypedef struct Node Node;\n```" },
+      "insertText": "typedef ${1:type} ${2:alias};",
+      "insertTextRules": 4,
+      "sortText": "01_typedef"
+    },
+    {
+      "label": "struct",
+      "kind": 14,
+      "detail": "Define a structure",
+      "documentation": { "value": "Defines a composite data type.\n\n```c\nstruct Point {\n    int x;\n    int y;\n};\n```" },
+      "insertText": "struct ${1:Name} {\n\t${2}\n};",
+      "insertTextRules": 4,
+      "sortText": "01_struct"
+    },
+    {
+      "label": "enum",
+      "kind": 14,
+      "detail": "Define an enumeration",
+      "documentation": { "value": "Defines a set of named integer constants.\n\n```c\nenum Color { RED, GREEN, BLUE };\n```" },
+      "insertText": "enum ${1:Name} {\n\t${2:VALUE1},\n\t${3:VALUE2}\n};",
+      "insertTextRules": 4,
+      "sortText": "01_enum"
+    },
+    {
+      "label": "union",
+      "kind": 14,
+      "detail": "Define a union",
+      "documentation": { "value": "Defines a type where all members share the same memory.\n\n```c\nunion Data {\n    int i;\n    float f;\n    char str[20];\n};\n```" },
+      "insertText": "union ${1:Name} {\n\t${2}\n};",
+      "insertTextRules": 4,
+      "sortText": "01_union"
+    },
+    {
+      "label": "sizeof",
+      "kind": 14,
+      "detail": "Get size of type or variable",
+      "documentation": { "value": "Returns the size in bytes of a type or expression.\n\n```c\nsize_t s = sizeof(int);      // typically 4\nsize_t a = sizeof(arr) / sizeof(arr[0]); // array length\n```" },
+      "insertText": "sizeof(${1:type})",
+      "insertTextRules": 4,
+      "sortText": "01_sizeof"
+    },
+    {
+      "label": "static",
+      "kind": 14,
+      "detail": "Static storage duration / internal linkage",
+      "documentation": { "value": "Gives a variable static storage or restricts a function/variable to file scope.\n\n```c\nstatic int counter = 0;\nstatic void helper(void) { }\n```" },
+      "insertText": "static ",
+      "insertTextRules": 4,
+      "sortText": "01_static"
+    },
+    {
+      "label": "extern",
+      "kind": 14,
+      "detail": "External linkage declaration",
+      "documentation": { "value": "Declares a variable or function defined in another translation unit.\n\n```c\nextern int global_count;\nextern void init(void);\n```" },
+      "insertText": "extern ${1:type} ${2:name};",
+      "insertTextRules": 4,
+      "sortText": "01_extern"
+    },
+    {
+      "label": "const",
+      "kind": 14,
+      "detail": "Constant qualifier",
+      "documentation": { "value": "Declares a read-only variable.\n\n```c\nconst int MAX = 100;\nconst char *msg = \"hello\";\n```" },
+      "insertText": "const ${1:type} ${2:name} = ${3:value};",
+      "insertTextRules": 4,
+      "sortText": "01_const"
+    },
+    {
+      "label": "volatile",
+      "kind": 14,
+      "detail": "Volatile qualifier",
+      "documentation": { "value": "Tells the compiler not to optimize access to this variable — it may change unexpectedly.\n\n```c\nvolatile int flag = 0;\n```" },
+      "insertText": "volatile ${1:type} ${2:name};",
+      "insertTextRules": 4,
+      "sortText": "01_volatile"
+    },
+    {
+      "label": "inline",
+      "kind": 14,
+      "detail": "Inline function hint",
+      "documentation": { "value": "Suggests to the compiler to inline a function for performance.\n\n```c\nstatic inline int max(int a, int b) {\n    return a > b ? a : b;\n}\n```" },
+      "insertText": "inline ",
+      "insertTextRules": 4,
+      "sortText": "01_inline"
+    },
+    {
+      "label": "goto",
+      "kind": 14,
+      "detail": "Jump to a label",
+      "documentation": { "value": "Unconditional jump to a labeled statement. Often used for cleanup in C.\n\n```c\nif (error)\n    goto cleanup;\ncleanup:\n    free(ptr);\n```" },
+      "insertText": "goto ${1:label};",
+      "insertTextRules": 4,
+      "sortText": "01_goto"
+    },
+    {
+      "label": "#include",
+      "kind": 14,
+      "detail": "Include a header file",
+      "documentation": { "value": "Includes a header file.\n\n```c\n#include <stdio.h>\n#include \"myheader.h\"\n```" },
+      "insertText": "#include <${1:header}.h>",
+      "insertTextRules": 4,
+      "sortText": "02_include"
+    },
+    {
+      "label": "#define",
+      "kind": 14,
+      "detail": "Define a macro",
+      "documentation": { "value": "Defines a preprocessor macro.\n\n```c\n#define PI 3.14159\n#define MAX(a, b) ((a) > (b) ? (a) : (b))\n```" },
+      "insertText": "#define ${1:NAME} ${2:value}",
+      "insertTextRules": 4,
+      "sortText": "02_define"
+    },
+    {
+      "label": "#ifdef",
+      "kind": 14,
+      "detail": "Conditional compilation (if defined)",
+      "documentation": { "value": "Compiles the following code only if the macro is defined.\n\n```c\n#ifdef DEBUG\n    printf(\"Debug mode\\n\");\n#endif\n```" },
+      "insertText": "#ifdef ${1:MACRO}\n${2}\n#endif",
+      "insertTextRules": 4,
+      "sortText": "02_ifdef"
+    },
+    {
+      "label": "#ifndef",
+      "kind": 14,
+      "detail": "Conditional compilation (if not defined)",
+      "documentation": { "value": "Compiles the following code only if the macro is NOT defined. Commonly used as include guards.\n\n```c\n#ifndef MY_HEADER_H\n#define MY_HEADER_H\n// declarations\n#endif\n```" },
+      "insertText": "#ifndef ${1:MACRO}\n#define ${1:MACRO}\n${2}\n#endif",
+      "insertTextRules": 4,
+      "sortText": "02_ifndef"
+    },
+    {
+      "label": "#endif",
+      "kind": 14,
+      "detail": "End conditional compilation",
+      "documentation": { "value": "Ends a conditional compilation block started by #if, #ifdef, or #ifndef." },
+      "insertText": "#endif",
+      "insertTextRules": 4,
+      "sortText": "02_endif"
+    },
+    {
+      "label": "#if",
+      "kind": 14,
+      "detail": "Conditional compilation (expression)",
+      "documentation": { "value": "Compiles the following code if the expression evaluates to true.\n\n```c\n#if defined(__linux__)\n    // Linux-specific code\n#elif defined(_WIN32)\n    // Windows-specific code\n#endif\n```" },
+      "insertText": "#if ${1:expression}\n${2}\n#endif",
+      "insertTextRules": 4,
+      "sortText": "02_if"
+    },
+    {
+      "label": "#elif",
+      "kind": 14,
+      "detail": "Else-if in conditional compilation",
+      "documentation": { "value": "Provides an alternative condition in a preprocessing conditional.\n\n```c\n#if defined(__linux__)\n    // ...\n#elif defined(_WIN32)\n    // ...\n#endif\n```" },
+      "insertText": "#elif ${1:expression}",
+      "insertTextRules": 4,
+      "sortText": "02_elif"
+    },
+    {
+      "label": "#pragma",
+      "kind": 14,
+      "detail": "Compiler pragma directive",
+      "documentation": { "value": "Provides implementation-defined instructions to the compiler.\n\n```c\n#pragma once\n#pragma pack(push, 1)\n#pragma warning(disable: 4996)\n```" },
+      "insertText": "#pragma ${1:once}",
+      "insertTextRules": 4,
+      "sortText": "02_pragma"
+    },
+    {
+      "label": "main function",
+      "kind": 15,
+      "detail": "Main entry point with argc/argv",
+      "documentation": { "value": "Standard main function entry point.\n\n```c\nint main(int argc, char *argv[]) {\n    return 0;\n}\n```" },
+      "insertText": "int main(int argc, char *argv[]) {\n\t${1}\n\treturn 0;\n}",
+      "insertTextRules": 4,
+      "sortText": "03_main"
+    },
+    {
+      "label": "struct definition",
+      "kind": 27,
+      "detail": "Define a typedef struct",
+      "documentation": { "value": "Creates a typedef'd struct.\n\n```c\ntypedef struct {\n    int x;\n    int y;\n} Point;\n```" },
+      "insertText": "typedef struct {\n\t${2:int member};\n} ${1:Name};",
+      "insertTextRules": 4,
+      "sortText": "03_struct_def"
+    },
+    {
+      "label": "for loop",
+      "kind": 27,
+      "detail": "Standard indexed for loop",
+      "documentation": { "value": "Standard for loop iterating from 0 to n.\n\n```c\nfor (int i = 0; i < n; i++) {\n    // body\n}\n```" },
+      "insertText": "for (int ${1:i} = 0; ${1:i} < ${2:n}; ${1:i}++) {\n\t${3}\n}",
+      "insertTextRules": 4,
+      "sortText": "03_for_loop"
+    },
+    {
+      "label": "while loop",
+      "kind": 27,
+      "detail": "While loop snippet",
+      "documentation": { "value": "A while loop template.\n\n```c\nwhile (condition) {\n    // body\n}\n```" },
+      "insertText": "while (${1:condition}) {\n\t${2}\n}",
+      "insertTextRules": 4,
+      "sortText": "03_while_loop"
+    },
+    {
+      "label": "switch case",
+      "kind": 27,
+      "detail": "Switch-case snippet",
+      "documentation": { "value": "A switch-case template.\n\n```c\nswitch (expr) {\n    case VAL1:\n        break;\n    case VAL2:\n        break;\n    default:\n        break;\n}\n```" },
+      "insertText": "switch (${1:expr}) {\n\tcase ${2:VAL1}:\n\t\t${3}\n\t\tbreak;\n\tcase ${4:VAL2}:\n\t\t${5}\n\t\tbreak;\n\tdefault:\n\t\t${6}\n\t\tbreak;\n}",
+      "insertTextRules": 4,
+      "sortText": "03_switch_case"
+    },
+    {
+      "label": "malloc+free pattern",
+      "kind": 27,
+      "detail": "Allocate, use, and free memory",
+      "documentation": { "value": "Allocates memory, checks for NULL, and frees it.\n\n```c\nint *arr = (int *)malloc(n * sizeof(int));\nif (!arr) { perror(\"malloc\"); exit(1); }\n// use arr\nfree(arr);\n```" },
+      "insertText": "${1:int} *${2:ptr} = (${1:int} *)malloc(${3:n} * sizeof(${1:int}));\nif (!${2:ptr}) {\n\tperror(\"malloc\");\n\texit(EXIT_FAILURE);\n}\n${4:// use ptr}\nfree(${2:ptr});\n${2:ptr} = NULL;",
+      "insertTextRules": 4,
+      "sortText": "03_malloc_free"
+    },
+    {
+      "label": "file open+close",
+      "kind": 27,
+      "detail": "Open, read/write, and close a file",
+      "documentation": { "value": "Opens a file, checks for errors, performs I/O, and closes it.\n\n```c\nFILE *fp = fopen(\"file.txt\", \"r\");\nif (!fp) { perror(\"fopen\"); return 1; }\n// read/write\nfclose(fp);\n```" },
+      "insertText": "FILE *${1:fp} = fopen(\"${2:filename}\", \"${3:r}\");\nif (!${1:fp}) {\n\tperror(\"fopen\");\n\treturn ${4:1};\n}\n${5:// read/write operations}\nfclose(${1:fp});",
+      "insertTextRules": 4,
+      "sortText": "03_file_open_close"
+    },
+    {
+      "label": "header guard",
+      "kind": 27,
+      "detail": "Include guard for header files",
+      "documentation": { "value": "Standard include guard pattern.\n\n```c\n#ifndef MY_HEADER_H\n#define MY_HEADER_H\n// declarations\n#endif /* MY_HEADER_H */\n```" },
+      "insertText": "#ifndef ${1:HEADER}_H\n#define ${1:HEADER}_H\n\n${2:// declarations}\n\n#endif /* ${1:HEADER}_H */",
+      "insertTextRules": 4,
+      "sortText": "03_header_guard"
+    },
+    {
+      "label": "function definition",
+      "kind": 27,
+      "detail": "Function definition snippet",
+      "documentation": { "value": "Template for defining a function.\n\n```c\nint my_func(int param) {\n    return 0;\n}\n```" },
+      "insertText": "${1:int} ${2:func_name}(${3:void}) {\n\t${4}\n\treturn ${5:0};\n}",
+      "insertTextRules": 4,
+      "sortText": "03_func_def"
+    },
+    {
+      "label": "enum definition",
+      "kind": 27,
+      "detail": "Typedef enum definition",
+      "documentation": { "value": "Creates a typedef'd enum.\n\n```c\ntypedef enum {\n    STATE_INIT,\n    STATE_RUNNING,\n    STATE_DONE\n} State;\n```" },
+      "insertText": "typedef enum {\n\t${2:VALUE1},\n\t${3:VALUE2}\n} ${1:EnumName};",
+      "insertTextRules": 4,
+      "sortText": "03_enum_def"
+    },
+    {
+      "label": "linked list node",
+      "kind": 27,
+      "detail": "Singly linked list node struct",
+      "documentation": { "value": "Defines a singly linked list node.\n\n```c\ntypedef struct Node {\n    int data;\n    struct Node *next;\n} Node;\n```" },
+      "insertText": "typedef struct ${1:Node} {\n\t${2:int data};\n\tstruct ${1:Node} *next;\n} ${1:Node};",
+      "insertTextRules": 4,
+      "sortText": "03_linked_list"
+    },
+    {
+      "label": "do-while loop",
+      "kind": 27,
+      "detail": "Do-while loop snippet",
+      "documentation": { "value": "A do-while loop that runs at least once.\n\n```c\ndo {\n    // body\n} while (condition);\n```" },
+      "insertText": "do {\n\t${1}\n} while (${2:condition});",
+      "insertTextRules": 4,
+      "sortText": "03_do_while"
+    },
+    {
+      "label": "if-else",
+      "kind": 27,
+      "detail": "If-else snippet",
+      "documentation": { "value": "An if-else block.\n\n```c\nif (condition) {\n    // true\n} else {\n    // false\n}\n```" },
+      "insertText": "if (${1:condition}) {\n\t${2}\n} else {\n\t${3}\n}",
+      "insertTextRules": 4,
+      "sortText": "03_if_else"
+    },
+    {
+      "label": "puts",
+      "kind": 1,
+      "detail": "Write a string to stdout with newline",
+      "documentation": { "value": "Writes a string to stdout and appends a newline.\n\n```c\nputs(\"Hello, World!\");\n```" },
+      "insertText": "puts(\"${1:str}\")",
+      "insertTextRules": 4,
+      "sortText": "00_puts"
+    },
+    {
+      "label": "getchar",
+      "kind": 1,
+      "detail": "Read a character from stdin",
+      "documentation": { "value": "Reads the next character from stdin.\n\n```c\nint ch = getchar();\n```" },
+      "insertText": "getchar()",
+      "insertTextRules": 4,
+      "sortText": "00_getchar"
+    },
+    {
+      "label": "putchar",
+      "kind": 1,
+      "detail": "Write a character to stdout",
+      "documentation": { "value": "Writes a character to stdout.\n\n```c\nputchar('A');\n```" },
+      "insertText": "putchar(${1:ch})",
+      "insertTextRules": 4,
+      "sortText": "00_putchar"
+    },
+    {
+      "label": "strtok",
+      "kind": 1,
+      "detail": "Tokenize a string",
+      "documentation": { "value": "Splits a string into tokens based on delimiter characters.\n\n```c\nchar str[] = \"one,two,three\";\nchar *tok = strtok(str, \",\");\nwhile (tok) {\n    printf(\"%s\\n\", tok);\n    tok = strtok(NULL, \",\");\n}\n```" },
+      "insertText": "strtok(${1:str}, \"${2:delim}\")",
+      "insertTextRules": 4,
+      "sortText": "00_strtok"
+    },
+    {
+      "label": "isalpha",
+      "kind": 1,
+      "detail": "Check if character is alphabetic",
+      "documentation": { "value": "Tests whether a character is an alphabetic letter.\n\n```c\n#include <ctype.h>\nif (isalpha(ch)) { /* ... */ }\n```" },
+      "insertText": "isalpha(${1:ch})",
+      "insertTextRules": 4,
+      "sortText": "00_isalpha"
+    },
+    {
+      "label": "isdigit",
+      "kind": 1,
+      "detail": "Check if character is a digit",
+      "documentation": { "value": "Tests whether a character is a decimal digit.\n\n```c\n#include <ctype.h>\nif (isdigit(ch)) { /* ... */ }\n```" },
+      "insertText": "isdigit(${1:ch})",
+      "insertTextRules": 4,
+      "sortText": "00_isdigit"
+    },
+    {
+      "label": "toupper",
+      "kind": 1,
+      "detail": "Convert character to uppercase",
+      "documentation": { "value": "Converts a lowercase letter to uppercase.\n\n```c\nchar upper = toupper('a');  // 'A'\n```" },
+      "insertText": "toupper(${1:ch})",
+      "insertTextRules": 4,
+      "sortText": "00_toupper"
+    },
+    {
+      "label": "tolower",
+      "kind": 1,
+      "detail": "Convert character to lowercase",
+      "documentation": { "value": "Converts an uppercase letter to lowercase.\n\n```c\nchar lower = tolower('Z');  // 'z'\n```" },
+      "insertText": "tolower(${1:ch})",
+      "insertTextRules": 4,
+      "sortText": "00_tolower"
+    },
+    {
+      "label": "time",
+      "kind": 1,
+      "detail": "Get current calendar time",
+      "documentation": { "value": "Returns the current calendar time as time_t.\n\n```c\n#include <time.h>\ntime_t now = time(NULL);\nprintf(\"%s\", ctime(&now));\n```" },
+      "insertText": "time(${1:NULL})",
+      "insertTextRules": 4,
+      "sortText": "00_time"
+    },
+    {
+      "label": "clock",
+      "kind": 1,
+      "detail": "Get processor time used",
+      "documentation": { "value": "Returns processor time consumed by the program.\n\n```c\nclock_t start = clock();\n// ... work ...\nclock_t end = clock();\ndouble elapsed = (double)(end - start) / CLOCKS_PER_SEC;\n```" },
+      "insertText": "clock()",
+      "insertTextRules": 4,
+      "sortText": "00_clock"
+    },
+    {
+      "label": "assert",
+      "kind": 1,
+      "detail": "Runtime assertion",
+      "documentation": { "value": "Aborts the program if the expression is false (in debug builds).\n\n```c\n#include <assert.h>\nassert(ptr != NULL);\nassert(n > 0);\n```" },
+      "insertText": "assert(${1:expression})",
+      "insertTextRules": 4,
+      "sortText": "00_assert"
+    },
+    {
+      "label": "NULL",
+      "kind": 5,
+      "detail": "Null pointer constant",
+      "documentation": { "value": "Null pointer constant, typically defined as `((void *)0)` or `0`.\n\n```c\nint *p = NULL;\nif (p == NULL) { /* ... */ }\n```" },
+      "insertText": "NULL",
+      "insertTextRules": 4,
+      "sortText": "00_NULL"
+    },
+    {
+      "label": "EOF",
+      "kind": 5,
+      "detail": "End-of-file indicator",
+      "documentation": { "value": "End-of-file constant, typically -1. Used to detect end of input.\n\n```c\nint ch;\nwhile ((ch = getchar()) != EOF) {\n    putchar(ch);\n}\n```" },
+      "insertText": "EOF",
+      "insertTextRules": 4,
+      "sortText": "00_EOF"
+    },
+    {
+      "label": "FILE",
+      "kind": 6,
+      "detail": "File stream type",
+      "documentation": { "value": "Opaque type for file stream operations defined in stdio.h.\n\n```c\nFILE *fp = fopen(\"data.txt\", \"r\");\n```" },
+      "insertText": "FILE",
+      "insertTextRules": 4,
+      "sortText": "00_FILE"
+    },
+    {
+      "label": "size_t",
+      "kind": 6,
+      "detail": "Unsigned size type",
+      "documentation": { "value": "Unsigned integer type returned by sizeof. Defined in stddef.h / stdlib.h.\n\n```c\nsize_t len = strlen(str);\n```" },
+      "insertText": "size_t",
+      "insertTextRules": 4,
+      "sortText": "00_size_t"
+    }
+  ]
+}