@enjoys/context-engine 1.0.0 → 1.0.2

package/data/defination/c.json

@@ -0,0 +1,865 @@
+{
+  "language": "c",
+  "definitions": {
+    "printf": {
+      "signature": "int printf(const char *format, ...)",
+      "description": "Writes formatted output to stdout. 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). Returns the number of characters written, or a negative value on error.",
+      "type": "function",
+      "module": "stdio.h",
+      "members": {}
+    },
+    "scanf": {
+      "signature": "int scanf(const char *format, ...)",
+      "description": "Reads formatted input from stdin. Arguments must be pointers (use & for non-pointer types). Returns the number of input items successfully matched and assigned, or EOF on failure.",
+      "type": "function",
+      "module": "stdio.h",
+      "members": {}
+    },
+    "fprintf": {
+      "signature": "int fprintf(FILE *stream, const char *format, ...)",
+      "description": "Writes formatted output to the specified file stream. Returns the number of characters written, or a negative value on error.",
+      "type": "function",
+      "module": "stdio.h",
+      "members": {}
+    },
+    "fscanf": {
+      "signature": "int fscanf(FILE *stream, const char *format, ...)",
+      "description": "Reads formatted input from the specified file stream. Returns the number of input items successfully matched and assigned.",
+      "type": "function",
+      "module": "stdio.h",
+      "members": {}
+    },
+    "sprintf": {
+      "signature": "int sprintf(char *str, const char *format, ...)",
+      "description": "Writes formatted output to a character buffer. Risk of buffer overflow — prefer snprintf. Returns the number of characters written (not including the null terminator).",
+      "type": "function",
+      "module": "stdio.h",
+      "members": {}
+    },
+    "snprintf": {
+      "signature": "int snprintf(char *str, size_t size, const char *format, ...)",
+      "description": "Writes at most size-1 formatted characters to str, always null-terminating. Returns the number of characters that would have been written if the buffer were large enough.",
+      "type": "function",
+      "module": "stdio.h",
+      "members": {}
+    },
+    "fopen": {
+      "signature": "FILE *fopen(const char *filename, const char *mode)",
+      "description": "Opens a file and returns a FILE pointer. Modes: \"r\" (read), \"w\" (write/truncate), \"a\" (append), \"r+\" (read/write), \"w+\" (read/write/truncate), \"a+\" (read/append). Add \"b\" for binary mode. Returns NULL on failure.",
+      "type": "function",
+      "module": "stdio.h",
+      "members": {}
+    },
+    "fclose": {
+      "signature": "int fclose(FILE *stream)",
+      "description": "Closes an open file stream, flushing any unwritten data. Returns 0 on success or EOF on failure.",
+      "type": "function",
+      "module": "stdio.h",
+      "members": {}
+    },
+    "fread": {
+      "signature": "size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream)",
+      "description": "Reads up to nmemb elements of the given size from stream into the buffer pointed to by ptr. Returns the number of elements successfully read.",
+      "type": "function",
+      "module": "stdio.h",
+      "members": {}
+    },
+    "fwrite": {
+      "signature": "size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream)",
+      "description": "Writes up to nmemb elements of the given size from the buffer pointed to by ptr to stream. Returns the number of elements successfully written.",
+      "type": "function",
+      "module": "stdio.h",
+      "members": {}
+    },
+    "fgets": {
+      "signature": "char *fgets(char *str, int n, FILE *stream)",
+      "description": "Reads at most n-1 characters from stream into str, stopping at a newline or EOF. Always null-terminates. Returns str on success, NULL on failure or EOF.",
+      "type": "function",
+      "module": "stdio.h",
+      "members": {}
+    },
+    "fputs": {
+      "signature": "int fputs(const char *str, FILE *stream)",
+      "description": "Writes a string to stream (without appending a newline). Returns a non-negative value on success, EOF on error.",
+      "type": "function",
+      "module": "stdio.h",
+      "members": {}
+    },
+    "fseek": {
+      "signature": "int fseek(FILE *stream, long offset, int whence)",
+      "description": "Sets the file position indicator. whence can be SEEK_SET (beginning), SEEK_CUR (current), or SEEK_END (end). Returns 0 on success.",
+      "type": "function",
+      "module": "stdio.h",
+      "members": {}
+    },
+    "ftell": {
+      "signature": "long ftell(FILE *stream)",
+      "description": "Returns the current file position indicator for stream, or -1L on error.",
+      "type": "function",
+      "module": "stdio.h",
+      "members": {}
+    },
+    "rewind": {
+      "signature": "void rewind(FILE *stream)",
+      "description": "Sets the file position to the beginning of the file and clears error indicators.",
+      "type": "function",
+      "module": "stdio.h",
+      "members": {}
+    },
+    "feof": {
+      "signature": "int feof(FILE *stream)",
+      "description": "Tests the end-of-file indicator for stream. Returns non-zero if the EOF indicator is set.",
+      "type": "function",
+      "module": "stdio.h",
+      "members": {}
+    },
+    "fflush": {
+      "signature": "int fflush(FILE *stream)",
+      "description": "Flushes the output buffer of a stream. If stream is NULL, flushes all open output streams. Returns 0 on success, EOF on error.",
+      "type": "function",
+      "module": "stdio.h",
+      "members": {}
+    },
+    "perror": {
+      "signature": "void perror(const char *s)",
+      "description": "Prints a descriptive error message to stderr. The message consists of the string s followed by a colon, a space, and the error message corresponding to the current errno value.",
+      "type": "function",
+      "module": "stdio.h",
+      "members": {}
+    },
+    "puts": {
+      "signature": "int puts(const char *s)",
+      "description": "Writes a string to stdout followed by a newline. Returns a non-negative integer on success, EOF on error.",
+      "type": "function",
+      "module": "stdio.h",
+      "members": {}
+    },
+    "getchar": {
+      "signature": "int getchar(void)",
+      "description": "Reads the next character from stdin. Returns the character as an unsigned char cast to int, or EOF on end-of-file or error.",
+      "type": "function",
+      "module": "stdio.h",
+      "members": {}
+    },
+    "putchar": {
+      "signature": "int putchar(int c)",
+      "description": "Writes a character to stdout. Returns the character written, or EOF on error.",
+      "type": "function",
+      "module": "stdio.h",
+      "members": {}
+    },
+    "malloc": {
+      "signature": "void *malloc(size_t size)",
+      "description": "Allocates size bytes of uninitialized memory on the heap. Returns a pointer to the allocated memory, or NULL if allocation fails. The returned pointer must be freed with free().",
+      "type": "function",
+      "module": "stdlib.h",
+      "members": {}
+    },
+    "calloc": {
+      "signature": "void *calloc(size_t nmemb, size_t size)",
+      "description": "Allocates memory for an array of nmemb elements, each of size bytes, and initializes all bytes to zero. Returns NULL on failure.",
+      "type": "function",
+      "module": "stdlib.h",
+      "members": {}
+    },
+    "realloc": {
+      "signature": "void *realloc(void *ptr, size_t size)",
+      "description": "Resizes the memory block pointed to by ptr to size bytes. If ptr is NULL, equivalent to malloc(size). If size is 0, equivalent to free(ptr). Returns the new pointer (may differ from ptr), or NULL on failure.",
+      "type": "function",
+      "module": "stdlib.h",
+      "members": {}
+    },
+    "free": {
+      "signature": "void free(void *ptr)",
+      "description": "Deallocates memory previously allocated by malloc, calloc, or realloc. Passing NULL is safe and does nothing. Double-free causes undefined behavior.",
+      "type": "function",
+      "module": "stdlib.h",
+      "members": {}
+    },
+    "exit": {
+      "signature": "void exit(int status)",
+      "description": "Terminates the calling process. Calls atexit-registered functions and flushes/closes all open streams. Use EXIT_SUCCESS (0) or EXIT_FAILURE (1) as status.",
+      "type": "function",
+      "module": "stdlib.h",
+      "members": {}
+    },
+    "abort": {
+      "signature": "void abort(void)",
+      "description": "Causes abnormal program termination by raising SIGABRT. Does not call atexit handlers or flush streams.",
+      "type": "function",
+      "module": "stdlib.h",
+      "members": {}
+    },
+    "atoi": {
+      "signature": "int atoi(const char *nptr)",
+      "description": "Converts a string to an integer. Skips leading whitespace, reads an optional sign and digits. No error detection — prefer strtol for robust parsing.",
+      "type": "function",
+      "module": "stdlib.h",
+      "members": {}
+    },
+    "atof": {
+      "signature": "double atof(const char *nptr)",
+      "description": "Converts a string to a double. Equivalent to strtod(nptr, NULL). No error detection — prefer strtod for robust parsing.",
+      "type": "function",
+      "module": "stdlib.h",
+      "members": {}
+    },
+    "strtol": {
+      "signature": "long strtol(const char *nptr, char **endptr, int base)",
+      "description": "Converts a string to a long integer with the given base (0 for auto-detect, 2–36). Sets *endptr to the first unconverted character. Sets errno to ERANGE on overflow.",
+      "type": "function",
+      "module": "stdlib.h",
+      "members": {}
+    },
+    "strtod": {
+      "signature": "double strtod(const char *nptr, char **endptr)",
+      "description": "Converts a string to a double. Sets *endptr to the first unconverted character. Sets errno to ERANGE for overflow/underflow.",
+      "type": "function",
+      "module": "stdlib.h",
+      "members": {}
+    },
+    "rand": {
+      "signature": "int rand(void)",
+      "description": "Returns a pseudo-random integer in the range [0, RAND_MAX]. Seed with srand() for different sequences. Not thread-safe — use rand_r or platform-specific alternatives.",
+      "type": "function",
+      "module": "stdlib.h",
+      "members": {}
+    },
+    "srand": {
+      "signature": "void srand(unsigned int seed)",
+      "description": "Seeds the pseudo-random number generator used by rand(). Using the same seed produces the same sequence. Common pattern: srand(time(NULL)).",
+      "type": "function",
+      "module": "stdlib.h",
+      "members": {}
+    },
+    "qsort": {
+      "signature": "void qsort(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *))",
+      "description": "Sorts an array of nmemb elements, each of size bytes, using the comparison function compar. The comparison function should return <0, 0, or >0.",
+      "type": "function",
+      "module": "stdlib.h",
+      "members": {}
+    },
+    "bsearch": {
+      "signature": "void *bsearch(const void *key, const void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *))",
+      "description": "Searches a sorted array of nmemb elements for key using binary search. Returns a pointer to the matching element, or NULL if not found.",
+      "type": "function",
+      "module": "stdlib.h",
+      "members": {}
+    },
+    "abs": {
+      "signature": "int abs(int j)",
+      "description": "Returns the absolute value of an integer. For long values use labs(), for long long use llabs(), for floating-point use fabs().",
+      "type": "function",
+      "module": "stdlib.h",
+      "members": {}
+    },
+    "system": {
+      "signature": "int system(const char *command)",
+      "description": "Passes the command string to the host command processor. Returns implementation-defined status. If command is NULL, returns non-zero if a command processor is available.",
+      "type": "function",
+      "module": "stdlib.h",
+      "members": {}
+    },
+    "getenv": {
+      "signature": "char *getenv(const char *name)",
+      "description": "Returns a pointer to the value of the environment variable name, or NULL if not found. The returned string should not be modified.",
+      "type": "function",
+      "module": "stdlib.h",
+      "members": {}
+    },
+    "strlen": {
+      "signature": "size_t strlen(const char *s)",
+      "description": "Returns the number of characters in the string s, not including the terminating null byte.",
+      "type": "function",
+      "module": "string.h",
+      "members": {}
+    },
+    "strcpy": {
+      "signature": "char *strcpy(char *dest, const char *src)",
+      "description": "Copies the string src including the null terminator to dest. The destination must be large enough. Unsafe — prefer strncpy or snprintf to prevent buffer overflow.",
+      "type": "function",
+      "module": "string.h",
+      "members": {}
+    },
+    "strncpy": {
+      "signature": "char *strncpy(char *dest, const char *src, size_t n)",
+      "description": "Copies up to n characters from src to dest. If src is shorter than n, the remainder is padded with null bytes. Warning: may not null-terminate if src has n or more characters.",
+      "type": "function",
+      "module": "string.h",
+      "members": {}
+    },
+    "strcat": {
+      "signature": "char *strcat(char *dest, const char *src)",
+      "description": "Appends the string src to the end of dest. The destination must have enough space. Unsafe — prefer strncat.",
+      "type": "function",
+      "module": "string.h",
+      "members": {}
+    },
+    "strncat": {
+      "signature": "char *strncat(char *dest, const char *src, size_t n)",
+      "description": "Appends at most n characters from src to dest, then appends a null terminator. The destination must have enough space for the result.",
+      "type": "function",
+      "module": "string.h",
+      "members": {}
+    },
+    "strcmp": {
+      "signature": "int strcmp(const char *s1, const char *s2)",
+      "description": "Compares two strings lexicographically. Returns 0 if equal, a negative value if s1 < s2, or a positive value if s1 > s2.",
+      "type": "function",
+      "module": "string.h",
+      "members": {}
+    },
+    "strncmp": {
+      "signature": "int strncmp(const char *s1, const char *s2, size_t n)",
+      "description": "Compares up to n characters of two strings. Returns 0 if the first n characters are equal.",
+      "type": "function",
+      "module": "string.h",
+      "members": {}
+    },
+    "strchr": {
+      "signature": "char *strchr(const char *s, int c)",
+      "description": "Returns a pointer to the first occurrence of character c in string s, or NULL if not found. The terminating null byte is considered part of the string.",
+      "type": "function",
+      "module": "string.h",
+      "members": {}
+    },
+    "strrchr": {
+      "signature": "char *strrchr(const char *s, int c)",
+      "description": "Returns a pointer to the last occurrence of character c in string s, or NULL if not found.",
+      "type": "function",
+      "module": "string.h",
+      "members": {}
+    },
+    "strstr": {
+      "signature": "char *strstr(const char *haystack, const char *needle)",
+      "description": "Finds the first occurrence of the substring needle in the string haystack. Returns a pointer to the beginning of the match, or NULL if not found.",
+      "type": "function",
+      "module": "string.h",
+      "members": {}
+    },
+    "strtok": {
+      "signature": "char *strtok(char *str, const char *delim)",
+      "description": "Splits a string into tokens. The first call takes the string; subsequent calls with NULL continue tokenizing. Modifies the original string. Not thread-safe — use strtok_r instead.",
+      "type": "function",
+      "module": "string.h",
+      "members": {}
+    },
+    "memcpy": {
+      "signature": "void *memcpy(void *dest, const void *src, size_t n)",
+      "description": "Copies n bytes from src to dest. The memory regions must not overlap — use memmove for overlapping regions. Returns dest.",
+      "type": "function",
+      "module": "string.h",
+      "members": {}
+    },
+    "memmove": {
+      "signature": "void *memmove(void *dest, const void *src, size_t n)",
+      "description": "Copies n bytes from src to dest, correctly handling overlapping memory regions. Returns dest.",
+      "type": "function",
+      "module": "string.h",
+      "members": {}
+    },
+    "memset": {
+      "signature": "void *memset(void *s, int c, size_t n)",
+      "description": "Fills the first n bytes of the memory area pointed to by s with the byte value c. Returns s. Commonly used to zero-initialize buffers.",
+      "type": "function",
+      "module": "string.h",
+      "members": {}
+    },
+    "memcmp": {
+      "signature": "int memcmp(const void *s1, const void *s2, size_t n)",
+      "description": "Compares the first n bytes of two memory areas. Returns 0 if equal, a negative value if s1 < s2, or a positive value if s1 > s2.",
+      "type": "function",
+      "module": "string.h",
+      "members": {}
+    },
+    "sqrt": {
+      "signature": "double sqrt(double x)",
+      "description": "Computes the non-negative square root of x. Domain error if x is negative. Link with -lm.",
+      "type": "function",
+      "module": "math.h",
+      "members": {}
+    },
+    "pow": {
+      "signature": "double pow(double base, double exp)",
+      "description": "Computes base raised to the power exp. Domain error if base is negative and exp is not an integer. Link with -lm.",
+      "type": "function",
+      "module": "math.h",
+      "members": {}
+    },
+    "fabs": {
+      "signature": "double fabs(double x)",
+      "description": "Returns the absolute value of the floating-point number x.",
+      "type": "function",
+      "module": "math.h",
+      "members": {}
+    },
+    "ceil": {
+      "signature": "double ceil(double x)",
+      "description": "Returns the smallest integer value not less than x (round up toward positive infinity).",
+      "type": "function",
+      "module": "math.h",
+      "members": {}
+    },
+    "floor": {
+      "signature": "double floor(double x)",
+      "description": "Returns the largest integer value not greater than x (round down toward negative infinity).",
+      "type": "function",
+      "module": "math.h",
+      "members": {}
+    },
+    "round": {
+      "signature": "double round(double x)",
+      "description": "Rounds x to the nearest integer, halfway cases away from zero. C99.",
+      "type": "function",
+      "module": "math.h",
+      "members": {}
+    },
+    "sin": {
+      "signature": "double sin(double x)",
+      "description": "Computes the sine of x, where x is in radians.",
+      "type": "function",
+      "module": "math.h",
+      "members": {}
+    },
+    "cos": {
+      "signature": "double cos(double x)",
+      "description": "Computes the cosine of x, where x is in radians.",
+      "type": "function",
+      "module": "math.h",
+      "members": {}
+    },
+    "tan": {
+      "signature": "double tan(double x)",
+      "description": "Computes the tangent of x, where x is in radians.",
+      "type": "function",
+      "module": "math.h",
+      "members": {}
+    },
+    "log": {
+      "signature": "double log(double x)",
+      "description": "Computes the natural (base-e) logarithm of x. Domain error if x is negative; pole error if x is zero.",
+      "type": "function",
+      "module": "math.h",
+      "members": {}
+    },
+    "log10": {
+      "signature": "double log10(double x)",
+      "description": "Computes the base-10 logarithm of x. Domain error if x is negative; pole error if x is zero.",
+      "type": "function",
+      "module": "math.h",
+      "members": {}
+    },
+    "exp": {
+      "signature": "double exp(double x)",
+      "description": "Computes e raised to the power x. Range error on overflow.",
+      "type": "function",
+      "module": "math.h",
+      "members": {}
+    },
+    "asin": {
+      "signature": "double asin(double x)",
+      "description": "Computes the arc sine of x. The result is in the range [-pi/2, pi/2]. Domain error if x is outside [-1, 1].",
+      "type": "function",
+      "module": "math.h",
+      "members": {}
+    },
+    "acos": {
+      "signature": "double acos(double x)",
+      "description": "Computes the arc cosine of x. The result is in the range [0, pi]. Domain error if x is outside [-1, 1].",
+      "type": "function",
+      "module": "math.h",
+      "members": {}
+    },
+    "atan": {
+      "signature": "double atan(double x)",
+      "description": "Computes the arc tangent of x. The result is in the range [-pi/2, pi/2].",
+      "type": "function",
+      "module": "math.h",
+      "members": {}
+    },
+    "atan2": {
+      "signature": "double atan2(double y, double x)",
+      "description": "Computes the arc tangent of y/x, using the signs of both arguments to determine the quadrant. The result is in the range [-pi, pi].",
+      "type": "function",
+      "module": "math.h",
+      "members": {}
+    },
+    "isalpha": {
+      "signature": "int isalpha(int c)",
+      "description": "Tests whether c is an alphabetic character (a-z, A-Z). Returns non-zero if true, 0 if false.",
+      "type": "function",
+      "module": "ctype.h",
+      "members": {}
+    },
+    "isdigit": {
+      "signature": "int isdigit(int c)",
+      "description": "Tests whether c is a decimal digit (0-9). Returns non-zero if true, 0 if false.",
+      "type": "function",
+      "module": "ctype.h",
+      "members": {}
+    },
+    "isalnum": {
+      "signature": "int isalnum(int c)",
+      "description": "Tests whether c is alphanumeric (letter or digit). Returns non-zero if true, 0 if false.",
+      "type": "function",
+      "module": "ctype.h",
+      "members": {}
+    },
+    "isspace": {
+      "signature": "int isspace(int c)",
+      "description": "Tests whether c is a whitespace character (space, tab, newline, etc.). Returns non-zero if true, 0 if false.",
+      "type": "function",
+      "module": "ctype.h",
+      "members": {}
+    },
+    "isupper": {
+      "signature": "int isupper(int c)",
+      "description": "Tests whether c is an uppercase letter (A-Z). Returns non-zero if true, 0 if false.",
+      "type": "function",
+      "module": "ctype.h",
+      "members": {}
+    },
+    "islower": {
+      "signature": "int islower(int c)",
+      "description": "Tests whether c is a lowercase letter (a-z). Returns non-zero if true, 0 if false.",
+      "type": "function",
+      "module": "ctype.h",
+      "members": {}
+    },
+    "toupper": {
+      "signature": "int toupper(int c)",
+      "description": "Converts a lowercase letter to uppercase. If c is not a lowercase letter, it is returned unchanged.",
+      "type": "function",
+      "module": "ctype.h",
+      "members": {}
+    },
+    "tolower": {
+      "signature": "int tolower(int c)",
+      "description": "Converts an uppercase letter to lowercase. If c is not an uppercase letter, it is returned unchanged.",
+      "type": "function",
+      "module": "ctype.h",
+      "members": {}
+    },
+    "isprint": {
+      "signature": "int isprint(int c)",
+      "description": "Tests whether c is a printable character, including space. Returns non-zero if true, 0 if false.",
+      "type": "function",
+      "module": "ctype.h",
+      "members": {}
+    },
+    "ispunct": {
+      "signature": "int ispunct(int c)",
+      "description": "Tests whether c is a punctuation character (printable, not space, not alphanumeric). Returns non-zero if true, 0 if false.",
+      "type": "function",
+      "module": "ctype.h",
+      "members": {}
+    },
+    "time": {
+      "signature": "time_t time(time_t *tloc)",
+      "description": "Returns the current calendar time as a time_t value, or (time_t)-1 on error. If tloc is not NULL, the return value is also stored at *tloc.",
+      "type": "function",
+      "module": "time.h",
+      "members": {}
+    },
+    "clock": {
+      "signature": "clock_t clock(void)",
+      "description": "Returns the processor time consumed by the program so far, or (clock_t)-1 if unavailable. Divide by CLOCKS_PER_SEC to get seconds.",
+      "type": "function",
+      "module": "time.h",
+      "members": {}
+    },
+    "difftime": {
+      "signature": "double difftime(time_t time1, time_t time0)",
+      "description": "Returns the difference between two time_t values (time1 - time0) as a double in seconds.",
+      "type": "function",
+      "module": "time.h",
+      "members": {}
+    },
+    "mktime": {
+      "signature": "time_t mktime(struct tm *timeptr)",
+      "description": "Converts a broken-down time (struct tm) to a time_t calendar time. Normalizes the fields of timeptr. Returns (time_t)-1 on error.",
+      "type": "function",
+      "module": "time.h",
+      "members": {}
+    },
+    "localtime": {
+      "signature": "struct tm *localtime(const time_t *timep)",
+      "description": "Converts a time_t value to a broken-down time in the local timezone. Returns a pointer to a static struct tm (not thread-safe — use localtime_r).",
+      "type": "function",
+      "module": "time.h",
+      "members": {}
+    },
+    "gmtime": {
+      "signature": "struct tm *gmtime(const time_t *timep)",
+      "description": "Converts a time_t value to a broken-down time in UTC. Returns a pointer to a static struct tm (not thread-safe — use gmtime_r).",
+      "type": "function",
+      "module": "time.h",
+      "members": {}
+    },
+    "strftime": {
+      "signature": "size_t strftime(char *s, size_t max, const char *format, const struct tm *tm)",
+      "description": "Formats a broken-down time according to the format string. Format specifiers: %Y (year), %m (month), %d (day), %H (hour), %M (minute), %S (second), %A (weekday name), etc.",
+      "type": "function",
+      "module": "time.h",
+      "members": {}
+    },
+    "ctime": {
+      "signature": "char *ctime(const time_t *timep)",
+      "description": "Converts a time_t value to a human-readable string in the form \"Wed Jun 30 21:49:08 1993\\n\". Returns a pointer to a static buffer.",
+      "type": "function",
+      "module": "time.h",
+      "members": {}
+    },
+    "signal": {
+      "signature": "void (*signal(int signum, void (*handler)(int)))(int)",
+      "description": "Sets the disposition of signal signum to handler: SIG_DFL (default), SIG_IGN (ignore), or a custom function. Returns the previous handler, or SIG_ERR on error.",
+      "type": "function",
+      "module": "signal.h",
+      "members": {}
+    },
+    "raise": {
+      "signature": "int raise(int sig)",
+      "description": "Sends signal sig to the calling process. Returns 0 on success, non-zero on failure. Common signals: SIGINT, SIGTERM, SIGABRT, SIGSEGV.",
+      "type": "function",
+      "module": "signal.h",
+      "members": {}
+    },
+    "assert": {
+      "signature": "void assert(scalar expression)",
+      "description": "Macro that aborts the program with a diagnostic message if the expression evaluates to 0 (false). Disabled when NDEBUG is defined.",
+      "type": "function",
+      "module": "assert.h",
+      "members": {}
+    },
+    "errno": {
+      "signature": "int errno",
+      "description": "Thread-local error number variable set by system calls and library functions on error. Common values: EACCES (permission denied), ENOENT (no such file), ENOMEM (out of memory), EINVAL (invalid argument).",
+      "type": "variable",
+      "module": "errno.h",
+      "members": {}
+    },
+    "strerror": {
+      "signature": "char *strerror(int errnum)",
+      "description": "Returns a pointer to a string describing the error code errnum. The returned string should not be modified.",
+      "type": "function",
+      "module": "string.h",
+      "members": {}
+    },
+    "FILE": {
+      "signature": "typedef struct _IO_FILE FILE",
+      "description": "Opaque type representing a file stream. Used with all stdio.h file I/O functions. Standard streams: stdin, stdout, stderr.",
+      "type": "type",
+      "module": "stdio.h",
+      "members": {}
+    },
+    "size_t": {
+      "signature": "typedef unsigned long size_t",
+      "description": "Unsigned integer type returned by sizeof and used for memory sizes and counts throughout the standard library. Guaranteed to hold the size of any object.",
+      "type": "type",
+      "module": "stddef.h",
+      "members": {}
+    },
+    "ptrdiff_t": {
+      "signature": "typedef long ptrdiff_t",
+      "description": "Signed integer type representing the difference between two pointers. Result of subtracting one pointer from another.",
+      "type": "type",
+      "module": "stddef.h",
+      "members": {}
+    },
+    "int8_t": {
+      "signature": "typedef signed char int8_t",
+      "description": "Exact-width signed 8-bit integer type. Range: -128 to 127.",
+      "type": "type",
+      "module": "stdint.h",
+      "members": {}
+    },
+    "uint8_t": {
+      "signature": "typedef unsigned char uint8_t",
+      "description": "Exact-width unsigned 8-bit integer type. Range: 0 to 255.",
+      "type": "type",
+      "module": "stdint.h",
+      "members": {}
+    },
+    "int16_t": {
+      "signature": "typedef short int16_t",
+      "description": "Exact-width signed 16-bit integer type. Range: -32768 to 32767.",
+      "type": "type",
+      "module": "stdint.h",
+      "members": {}
+    },
+    "uint16_t": {
+      "signature": "typedef unsigned short uint16_t",
+      "description": "Exact-width unsigned 16-bit integer type. Range: 0 to 65535.",
+      "type": "type",
+      "module": "stdint.h",
+      "members": {}
+    },
+    "int32_t": {
+      "signature": "typedef int int32_t",
+      "description": "Exact-width signed 32-bit integer type. Range: -2147483648 to 2147483647.",
+      "type": "type",
+      "module": "stdint.h",
+      "members": {}
+    },
+    "uint32_t": {
+      "signature": "typedef unsigned int uint32_t",
+      "description": "Exact-width unsigned 32-bit integer type. Range: 0 to 4294967295.",
+      "type": "type",
+      "module": "stdint.h",
+      "members": {}
+    },
+    "int64_t": {
+      "signature": "typedef long long int64_t",
+      "description": "Exact-width signed 64-bit integer type. Range: -9223372036854775808 to 9223372036854775807.",
+      "type": "type",
+      "module": "stdint.h",
+      "members": {}
+    },
+    "uint64_t": {
+      "signature": "typedef unsigned long long uint64_t",
+      "description": "Exact-width unsigned 64-bit integer type. Range: 0 to 18446744073709551615.",
+      "type": "type",
+      "module": "stdint.h",
+      "members": {}
+    },
+    "intptr_t": {
+      "signature": "typedef long intptr_t",
+      "description": "Signed integer type capable of holding a pointer value. Can safely cast a void* to intptr_t and back.",
+      "type": "type",
+      "module": "stdint.h",
+      "members": {}
+    },
+    "uintptr_t": {
+      "signature": "typedef unsigned long uintptr_t",
+      "description": "Unsigned integer type capable of holding a pointer value. Can safely cast a void* to uintptr_t and back.",
+      "type": "type",
+      "module": "stdint.h",
+      "members": {}
+    },
+    "time_t": {
+      "signature": "typedef long time_t",
+      "description": "Arithmetic type representing calendar time. Typically the number of seconds since the Unix epoch (1970-01-01 00:00:00 UTC).",
+      "type": "type",
+      "module": "time.h",
+      "members": {}
+    },
+    "clock_t": {
+      "signature": "typedef long clock_t",
+      "description": "Arithmetic type representing processor time. Divide by CLOCKS_PER_SEC to convert to seconds.",
+      "type": "type",
+      "module": "time.h",
+      "members": {}
+    },
+    "struct tm": {
+      "signature": "struct tm",
+      "description": "Broken-down time structure representing calendar date and time components.",
+      "type": "type",
+      "module": "time.h",
+      "members": {
+        "tm_sec": { "type": "int", "description": "Seconds after the minute [0, 60] (60 for leap second)" },
+        "tm_min": { "type": "int", "description": "Minutes after the hour [0, 59]" },
+        "tm_hour": { "type": "int", "description": "Hours since midnight [0, 23]" },
+        "tm_mday": { "type": "int", "description": "Day of the month [1, 31]" },
+        "tm_mon": { "type": "int", "description": "Months since January [0, 11]" },
+        "tm_year": { "type": "int", "description": "Years since 1900" },
+        "tm_wday": { "type": "int", "description": "Days since Sunday [0, 6]" },
+        "tm_yday": { "type": "int", "description": "Days since January 1 [0, 365]" },
+        "tm_isdst": { "type": "int", "description": "Daylight saving time flag (>0 if DST, 0 if not, <0 if unknown)" }
+      }
+    },
+    "div_t": {
+      "signature": "typedef struct { int quot; int rem; } div_t",
+      "description": "Structure returned by div() containing the quotient and remainder of integer division.",
+      "type": "type",
+      "module": "stdlib.h",
+      "members": {
+        "quot": { "type": "int", "description": "Quotient of the division" },
+        "rem": { "type": "int", "description": "Remainder of the division" }
+      }
+    },
+    "NULL": {
+      "signature": "#define NULL ((void *)0)",
+      "description": "Null pointer constant. Defined in stddef.h, stdio.h, stdlib.h, string.h and other headers. Tests for a null pointer: if (ptr == NULL) or if (!ptr).",
+      "type": "macro",
+      "module": "stddef.h",
+      "members": {}
+    },
+    "EOF": {
+      "signature": "#define EOF (-1)",
+      "description": "End-of-file indicator, a negative integer constant (typically -1). Returned by character input functions to indicate end of input or error.",
+      "type": "macro",
+      "module": "stdio.h",
+      "members": {}
+    },
+    "SEEK_SET": {
+      "signature": "#define SEEK_SET 0",
+      "description": "File position constant for fseek: offset is relative to the beginning of the file.",
+      "type": "macro",
+      "module": "stdio.h",
+      "members": {}
+    },
+    "SEEK_CUR": {
+      "signature": "#define SEEK_CUR 1",
+      "description": "File position constant for fseek: offset is relative to the current position.",
+      "type": "macro",
+      "module": "stdio.h",
+      "members": {}
+    },
+    "SEEK_END": {
+      "signature": "#define SEEK_END 2",
+      "description": "File position constant for fseek: offset is relative to the end of the file.",
+      "type": "macro",
+      "module": "stdio.h",
+      "members": {}
+    },
+    "EXIT_SUCCESS": {
+      "signature": "#define EXIT_SUCCESS 0",
+      "description": "Indicates successful program termination. Passed to exit() or returned from main().",
+      "type": "macro",
+      "module": "stdlib.h",
+      "members": {}
+    },
+    "EXIT_FAILURE": {
+      "signature": "#define EXIT_FAILURE 1",
+      "description": "Indicates unsuccessful program termination. Passed to exit() or returned from main().",
+      "type": "macro",
+      "module": "stdlib.h",
+      "members": {}
+    },
+    "RAND_MAX": {
+      "signature": "#define RAND_MAX 2147483647",
+      "description": "The maximum value returned by rand(). At least 32767.",
+      "type": "macro",
+      "module": "stdlib.h",
+      "members": {}
+    },
+    "BUFSIZ": {
+      "signature": "#define BUFSIZ 8192",
+      "description": "Default buffer size for setbuf. Typically 512 or 8192 bytes.",
+      "type": "macro",
+      "module": "stdio.h",
+      "members": {}
+    },
+    "stdin": {
+      "signature": "extern FILE *stdin",
+      "description": "Standard input stream. Connected to keyboard input by default.",
+      "type": "variable",
+      "module": "stdio.h",
+      "members": {}
+    },
+    "stdout": {
+      "signature": "extern FILE *stdout",
+      "description": "Standard output stream. Connected to terminal output by default. Line-buffered when connected to a terminal.",
+      "type": "variable",
+      "module": "stdio.h",
+      "members": {}
+    },
+    "stderr": {
+      "signature": "extern FILE *stderr",
+      "description": "Standard error stream. Connected to terminal output by default. Unbuffered for immediate error reporting.",
+      "type": "variable",
+      "module": "stdio.h",
+      "members": {}
+    }
+  }
+}