diff options
Diffstat (limited to 'modules')
| -rw-r--r-- | modules/cpp/api | 290 | ||||
| -rw-r--r-- | modules/cpp/init.lua | 4 | ||||
| -rw-r--r-- | modules/cpp/tags | 268 |
3 files changed, 561 insertions, 1 deletions
diff --git a/modules/cpp/api b/modules/cpp/api new file mode 100644 index 00000000..dbd36560 --- /dev/null +++ b/modules/cpp/api @@ -0,0 +1,290 @@ +assert assert(int expression) [void]\nMacro used for internal error detection. (Ignored if NDEBUG is defined where \n<assert.h> is included.) If `expression` equals zero, message printed on stderr\nand abort called to terminate execution. Source filename and line number in\nmessage are from preprocessor macros __FILE__ and __LINE__. + +isalnum isalnum(int c) [int]\nisalpha(c) or isdigit(c) +isalpha isalpha(int c) [int]\nisupper(c) or islower(c) +iscntrl iscntrl(int c) [int]\nis control character. In ASCII, control characters are 0x00 (NUL) to 0x1F (US),\nand 0x7F (DEL) +isdigit isdigit(int c) [int]\nis decimal digit +isgraph isgraph(int c) [int]\nis printing character other than space +islower islower(int c) [int]\nis lower-case letter +isprint isprint(int c) [int]\nis printing character (including space). In ASCII, printing characters are 0x20\n(' ') to 0x7E ('~') +ispunct ispunct(int c) [int]\nis printing character other than space, letter, digit +isspace isspace(int c) [int]\nis space, formfeed, newline, carriage return, tab, vertical tab +isupper isupper(int c) [int]\nis upper-case letter +isxdigit isxdigit(int c) [int]\nis hexadecimal digit +tolower tolower(int c) [int]\nreturn lower-case equivalent +toupper toupper(int c) [int]\nreturn upper-case equivalent + +errno errno\nobject to which certain library functions assign specific positive values on\nerror +EDOM EDOM\ncode used for domain errors +ERANGE ERANGE\ncode used for range errors + +FLT_RADIX FLT_RADIX\nradix of floating-point representations +FLT_ROUNDS FLT_ROUNDS\nfloating-point rounding mode + +FLT_DIG FLT_DIG\nprecision of float (in decimal digits) +DBL_DIG DBL_DIG\nprecision of double (in decimal digits) +LDBL_DIG LDBL_DIG\nprecision of long double (in decimal digits) + +FLT_EPSILON FLT_EPSILON\nsmallest float number x such that 1.0 + x != 1.0 +DBL_EPSILON DBL_EPSILON\nsmallest double number x such that 1.0 + x != 1.0 +LDBL_EPSILON LDBL_EPSILON\nsmallest long double number x such that 1.0 + x != 1.0 + +FLT_MANT_DIG FLT_MANT_DIG\nnumber of float digits, base FLT_RADIX, in mantissa +DBL_MANT_DIG DBL_MANT_DIG\nnumber of double digits, base FLT_RADIX, in mantissa +LDBL_MANT_DIG LDBL_MANT_DIG\nnumber of long double digits, base FLT_RADIX, in mantissa + +FLT_MAX FLT_MAX\nmaximum float number +DBL_MAX DBL_MAX\nmaximum double number +LDBL_MAX LDBL_MAX\nmaximum long double number + +FLT_MAX_EXP FLT_MAX_EXP\nlargest positive integer exponent to which FLT_RADIX can be raised and remain\nrepresentable +DBL_MAX_EXP DBL_MAX_EXP\nlargest positive integer exponent to which FLT_RADIX can be raised and remain\nrepresentable +LDBL_MAX_EXP LDBL_MAX_EXP\nlargest positive integer exponent to which FLT_RADIX can be raised and remain\nrepresentable + +FLT_MIN FLT_MIN\nminimum normalised float number +DBL_MIN DBL_MIN\nminimum normalised double number +LDBL_MIN LDBL_MIN\nminimum normalised long double number + +FLT_MIN_EXP FLT_MIN_EXP\nsmallest negative integer exponent to which FLT_RADIX can be raised and remain\nrepresentable +DBL_MIN_EXP DBL_MIN_EXP\nsmallest negative integer exponent to which FLT_RADIX can be raised and remain\nrepresentable +LDBL_MIN_EXP LDBL_MIN_EXP\nsmallest negative integer exponent to which FLT_RADIX can be raised and remain\nrepresentable + +CHAR_BIT CHAR_BIT\nnumber of bits in a char +CHAR_MAX CHAR_MAX\nmaximum value of type char +CHAR_MIN CHAR_MIN\nminimum value of type char +SCHAR_MAX SCHAR_MAX\nmaximum value of type signed char +SCHAR_MIN SCHAR_MIN\nminimum value of type signed char +UCHAR_MAX UCHAR_MAX\nmaximum value of type unsigned char +SHRT_MAX SHRT_MAX\nmaximum value of type short +SHRT_MIN SHRT_MIN\nminimum value of type short +USHRT_MAX USHRT_MAX\nmaximum value of type unsigned short +INT_MAX INT_MAX\nmaximum value of type int +INT_MIN INT_MIN\nminimum value of type int +UINT_MAX UINT_MAX\nmaximum value of type unsigned int +LONG_MAX LONG_MAX\nmaximum value of type long +LONG_MIN LONG_MIN\nminimum value of type long +ULONG_MAX ULONG_MAX\nmaximum value of type unsigned long + +lconv lconv [struct]\nDescribes formatting of monetary and other numeric values\nImplementations may change field order and include additional fields. Standard C\nLibrary functions use only `decimal_point`. +decimal_point lconv.decimal_point [char*]\ndecimal point for non-monetary values +grouping lconv.grouping [char*]\nsizes of digit groups for non-monetary values +thousands_sep lconv.thousands_sep [char*]\nseparator for digit groups for non-monetary values (left of "decimal point") +currency_symbol lconv.currency_symbol [char*]\ncurrency symbol +int_curr_symbol lconv.int_curr_symbol [char*]\ninternational currency symbol +mon_decimal_point lconv.mon_decimal_point [char*]\ndecimal point for monetary values +mon_grouping lconv.mon_grouping [char*]\nsizes of digit groups for monetary values +mon_thousands_sep lconv.mon_thousands_sep [char*]\nseparator for digit groups for monetary values (left of "decimal point") +negative_sign lconv.negative_sign [char*]\nnegative sign for monetary values +positive_sign lconv.positive_sign [char*]\npositive sign for monetary values +frac_digits lconv.frac_digits [char]\nnumber of digits to be displayed to right of "decimal point" for monetary values +int_frac_digits lconv.int_frac_digits [char]\nnumber of digits to be displayed to right of "decimal point" for international\nmonetary values +n_cs_precedes lconv.n_cs_precedes [char]\nwhether currency symbol precedes (1) or follows (0) negative monetary values +n_sep_by_space lconv.n_sep_by_space [char]\nwhether currency symbol is (1) or is not (0) separated by space from negative\nmonetary values +n_sign_posn lconv.n_sign_posn [char]\nformat for negative monetary values:\n0: parentheses surround quantity and currency symbol\n 1: sign precedes quantity and currency symbol\n 2: sign follows quantity and currency symbol\n 3: sign immediately precedes currency symbol\n 4: sign immediately follows currency symbol +p_cs_precedes lconv.p_cs_precedes [char]\nwhether currency symbol precedes (1) or follows (0) positive monetary values +p_sep_by_space lconv.p_sep_by_space [char]\nwhether currency symbol is (1) or is not (0) separated by space from\nnon-negative monetary values +p_sign_posn lconv.p_sign_posn [char]\nformat for non-negative monetary values, with values as for n_sign_posn + +localeconv localeconv(void) [lconv*]\nreturns pointer to formatting information for current locale +setlocale setlocale(int category, const char* locale) [char*]\nSets components of locale according to specified `category` and `locale`.\nReturns string describing new locale or null on error. (Implementations are\npermitted to define values of `category` additional to those describe here.) +LC_ALL LC_ALL\ncategory argument for all categories +LC_NUMERIC LC_NUMERIC\ncategory for numeric formatting information +LC_MONETARY LC_MONETARY\ncategory for monetary formatting information +LC_COLLATE LC_COLLATE\ncategory for information affecting collating functions +LC_CTYPE LC_CTYPE\ncategory for information affecting character class tests functions +LC_TIME LC_TIME\ncategory for information affecting time conversions functions +NULL NULL\nnull pointer constant + +HUGE_VAL HUGE_VAL\nmagnitude returned (with correct sign) on overflow error +exp exp(double x) [double]\nexponential of `x` +log log(double x) [double]\nnatural logarithm of `x` +log10 log10(double x) [double]\nbase-10 logarithm of `x` +pow pow(double x, double y) [double]\n`x` raised to power `y` +sqrt sqrt(double x) [double]\nsquare root of `x` +ceil ceil(double x) [double]\nsmallest integer not less than `x` +floor floor(double x) [double]\nlargest integer not greater than `x` +fabs fabs(double x) [double]\nabsolute value of `x` +ldexp ldexp(double x, int n) [double]\n`x` times 2 to the power `n` +frexp frexp(double x, int* exp) [double]\nif `x` non-zero, returns value, with absolute value in interval [1/2, 1), and\nassigns to `*exp` integer such that product of return value and 2 raised to the\npower `*exp` equals `x`; if `x` zero, both return value and `*exp` are zero +modf modf(double x, double* ip) [double]\nreturns fractional part and assigns to `*ip` integral part of `x`, both with\nsame sign as `x` +fmod fmod(double x, double y) [double]\nif `y` non-zero, floating-point remainder of `x`/`y`, with same sign as `x`; if\n`y` zero, result is implementation-defined +sin sin(double x) [double]\nsine of `x` +cos cos(double x) [double]\ncosine of `x` +tan tan(double x) [double]\ntangent of `x` +asin asin(double x) [double]\narc-sine of `x` +acos acos(double x) [double]\narc-cosine of `x` +atan atan(double x) [double]\narc-tangent of `x` +atan2 atan2(double y, double x) [double]\narc-tangent of `y`/`x` +sinh sinh(double x) [double]\nhyperbolic sine of `x` +cosh cosh(double x) [double]\nhyperbolic cosine of `x` +tanh tanh(double x) [double]\nhyperbolic tangent of `x` + +jmp_buf jmp_buf\ntype of object holding context information +setjmp setjmp(jmp_buf env) [int]\nSaves context information in `env` and returns zero. Subsequent call to longjmp\nwith same `env` returns non-zero. +longjmp longjmp(jmp_buf env, int val) [void]\nRestores context saved by most recent call to setjmp with specified `env`.\nExecution resumes as a second return from setjmp, with returned value `val` if\nspecified value non-zero, or 1 otherwise. + +SIGABRT SIGABRT\nabnormal termination +SIGFPE SIGFPE\narithmetic error +SIGILL SIGILL\ninvalid execution +SIGINT SIGINT\n(asynchronous) interactive attention +SIGSEGV SIGSEGV\nillegal storage access +SIGTERM SIGTERM\n(asynchronous) termination request +SIG_DFL SIG_DFL\nspecifies default signal handling +SIG_ERR SIG_ERR\nsignal return value indicating error +SIG_IGN SIG_IGN\nspecifies that signal should be ignored +raise raise(int sig) [int]\nSends signal sig. Returns zero on success. + +va_list va_list\ntype of object holding context information +va_start va_start(va_list ap, lastarg) [void]\nInitialisation macro which must be called once before any unnamed argument is\naccessed. Stores context information in `ap`. `lastarg` is the last named\nparameter of the function. +va_arg va_arg(va_list ap, type) [type]\nYields value of the type (`type`) and value of the next unnamed argument. +va_end va_end(va_list ap) [void]\nTermination macro which must be called once after argument processing and before\nexit from function. + +NULL NULL\nNull pointer constant. +offsetof offsetof(stype, m)\nOffset (in bytes) of member m from start of structure type `stype`. +ptrdiff_t ptrdiff_t\nType for objects declared to store result of subtracting pointers. +size_t size_t\nType for objects declared to store result of sizeof operator. + +BUFSIZ BUFSIZ\nSize of buffer used by setbuf. +EOF EOF\nValue used to indicate end-of-stream or to report an error. +FILENAME_MAX FILENAME_MAX\nMaximum length required for array of characters to hold a filename. +FOPEN_MAX FOPEN_MAX\nMaximum number of files which may be open simultaneously. +L_tmpnam L_tmpnam\nNumber of characters required for temporary filename generated by tmpnam. +NULL NULL\nNull pointer constant. +SEEK_CUR SEEK_CUR\nValue for origin argument to fseek specifying current file position. +SEEK_END SEEK_END\nValue for origin argument to fseek specifying end of file. +SEEK_SET SEEK_SET\nValue for origin argument to fseek specifying beginning of file. +TMP_MAX TMP_MAX\nMinimum number of unique filenames generated by calls to tmpnam. +_IOFBF _IOFBF\nValue for mode argument to setvbuf specifying full buffering. +_IOLBF _IOLBF\nValue for mode argument to setvbuf specifying line buffering. +_IONBF _IONBF\nValue for mode argument to setvbuf specifying no buffering. +stdin stdin\nFile pointer for standard input stream. Automatically opened when program\nexecution begins. +stdout stdout\nFile pointer for standard output stream. Automatically opened when program\nexecution begins. +stderr stderr\nFile pointer for standard error stream. Automatically opened when program\nexecution begins. +FILE FILE\nType of object holding information necessary to control a stream. +fpos_t fpos_t\nType for objects declared to store file position information. +size_t size_t\nType for objects declared to store result of sizeof operator. +fopen fopen(const char* filename, const char* mode) [FILE*]\nOpens file named `filename` and returns a stream, or NULL on failure. `mode` may\nbe one of the following for text files:\n "r": text reading\n "w": text writing\n "a": text append\n "r+": text update (reading and writing)\n "w+": text update, discarding previous content (if any)\n "a+": text append, reading, and writing at end\nor one of those strings with b included (after the first character), for\nbinary files. +freopen freopen(const char* filename, const char* mode, FILE* stream) [FILE*]\nCloses file associated with `stream`, then opens file `filename` with specified\nmode and associates it with `stream`. Returns `stream` or NULL on error. +fflush fflush(FILE* stream) [int]\nFlushes stream `stream` and returns zero on success or EOF on error. Effect\nundefined for input stream. fflush(NULL) flushes all output streams. +fclose fclose(FILE* stream) [int]\nCloses stream `stream` (after flushing, if output stream). Returns EOF on error,\nzero otherwise. +remove remove(const char* filename) [int]\nRemoves specified file. Returns non-zero on failure. +rename rename(const char* oldname, const char* newname) [int]\nChanges name of file `oldname` to `newname`. Returns non-zero on failure. +tmpfile tmpfile() [FILE*]\nCreates temporary file (mode "wb+") which will be removed when closed or on\nnormal program termination. Returns stream or NULL on failure. +tmpnam tmpnam(char s[L_tmpnam]) [char*]\nAssigns to `s` (if `s` non-null) and returns unique name for a temporary file.\nUnique name is returned for each of the first TMP_MAX invocations. +setvbuf setvbuf(FILE* stream, char* buf, int mode, size_t size) [int]\nControls buffering for stream `stream`. mode is _IOFBF for full buffering,\n_IOLBF for line buffering, _IONBF for no buffering. Non-null `buf` specifies\nbuffer of size `size` to be used; otherwise, a buffer is allocated. Returns\nnon-zero on error. Call must be before any other operation on stream. +setbuf setbuf(FILE* stream, char* buf) [void]\nControls buffering for stream `stream`. For null `buf`, turns off buffering,\notherwise equivalent to `(void)setvbuf(stream, buf, _IOFBF, BUFSIZ)`. +fprintf fprintf(FILE* stream, const char* format, ...) [int]\nConverts (according to format `format`) and writes output to stream `stream`.\nNumber of characters written, or negative value on error, is returned.\nConversion specifications consist of:\n * %\n * (optional) flag:\n -: left adjust\n +: always sign\n space: space if no sign\n 0: zero pad\n #: Alternate form: for conversion character o, first digit will be zero, for\n [xX], prefix 0x or 0X to non-zero value, for [eEfgG], always decimal\n point, for [gG] trailing zeros not removed.\n * (optional) minimum width: if specified as *, value taken from next argument\n (which must be int).\n * (optional) . (separating width from precision):\n * (optional) precision: for conversion character s, maximum characters to be\n printed from the string, for [eEf], digits after decimal point, for [gG],\n significant digits, for an integer, minimum number of digits to be printed.\n If specified as *, value taken from next argument (which must be int).\n * (optional) length modifier:\n h: short or unsigned short\n l: long or unsigned long\n L: long double\n * conversion character:\n d,i: int argument, printed in signed decimal notation\n o: int argument, printed in unsigned octal notation\n x,X: int argument, printed in unsigned hexadecimal notation\n u: int argument, printed in unsigned decimal notation\n c: int argument, printed as single character\n s: char* argument\n f: double argument, printed with format [-]mmm.ddd\n e,E: double argument, printed with format [-]m.dddddd(e|E)(+|-)xx\n g,G: double argument\n p: void* argument, printed as pointer\n n: int* argument : the number of characters written to this point is written\n into argument\n %: no argument; prints % +printf printf(const char* format, ...) [int]\nprintf(f, ...) is equivalent to fprintf(stdout, f, ...) +sprintf sprintf(char* s, const char* format, ...) [int]\nLike fprintf, but output written into string `s`, which *must be large enough to\nhold the output*, rather than to a stream. Output is NUL-terminated. Returns\nlength (excluding the terminating NUL). +vfprintf vfprintf(FILE* stream, const char* format, va_list arg) [int]\nEquivalent to fprintf with variable argument list replaced by `arg`, which must\nhave been initialised by the va_start macro (and may have been used in calls to\nva_arg). +vprintf vprintf(const char* format, va_list arg) [int]\nEquivalent to printf with variable argument list replaced by `arg`, which must\nhave been initialised by the va_start macro (and may have been used in calls to\nva_arg). +vsprintf vsprintf(char* s, const char* format, va_list arg) [int]\nEquivalent to sprintf with variable argument list replaced by `arg`, which must\nhave been initialised by the va_start macro (and may have been used in calls to\nva_arg). +fscanf fscanf(FILE* stream, const char* format, ...) [int]\nPerforms formatted input conversion, reading from stream `stream` according to\nformat `format`. The function returns when `format` is fully processed. Returns\nnumber of items converted and assigned, or EOF if end-of-file or error occurs\nbefore any conversion. Each of the arguments following format *must be a\npointer*. Format string may contain:\n * blanks and tabs, which are ignored\n * ordinary characters, which are expected to match next non-white-space of\n input\n * conversion specifications, consisting of:\n * %\n * (optional) assignment suppression character "*"\n * (optional) maximum field width\n * (optional) target width indicator:\n h: argument is pointer to short rather than int\n l: argument is pointer to long rather than int, or double rather than\n float\n L: argument is pointer to long double rather than float\n * conversion character:\n d: decimal integer; int* parameter required\n i: integer; int* parameter required; decimal, octal or hex\n o: octal integer; int* parameter required\n u: unsigned decimal integer; unsigned int* parameter required\n x: hexadecimal integer; int* parameter required\n c: characters; char* parameter required; white-space is not skipped, and\n NUL-termination is not performed\n s: string of non-white-space; char* parameter required; string is\n NUL-terminated\n e,f,g: floating-point number; float* parameter required\n p: pointer value; void* parameter required\n n: chars read so far; int* parameter required\n [...]: longest non-empty string from specified set; char* parameter\n required; string is NUL-terminated\n [^...]: longest non-empty string not from specified set; char* parameter\n required; string is NUL-terminated\n %: literal %; no assignment +scanf scanf(const char* format, ...) [int]\nscanf(f, ...) is equivalent to fscanf(stdin, f, ...) +sscanf sscanf(char* s, const char* format, ...) [int]\nLike fscanf, but input read from string `s`. +fgetc fgetc(FILE* stream) [int]\nReturns next character from (input) stream `stream`, or EOF on end-of-file or\nerror. +fgets fgets(char* s, int n, FILE* stream) [char*]\nCopies characters from (input) stream `stream` to `s`, stopping when `n`-1\ncharacters copied, newline copied, end-of-file reached or error occurs. If no\nerror, `s` is NUL-terminated. Returns NULL on end-of-file or error, `s`\notherwise. +fputc fputc(int c, FILE* stream) [int]\nWrites `c`, to stream `stream`. Returns `c`, or EOF on error. +fputs fputs(const char* s, FILE* stream) [char*]\nWrites `s`, to (output) stream `stream`. Returns non-negative on success or EOF\non error. +getc getc(FILE* stream) [int]\nEquivalent to fgetc except that it may be a macro. +getchar getchar(void) [int]\nEquivalent to getc(stdin). +gets gets(char* s) [char*]\nCopies characters from stdin into `s` until newline encountered, end-of-file\nreached, or error occurs. Does not copy newline. NUL-terminates `s`. Returns\n`s`, or NULL on end-of-file or error. *Should not be used because of the\npotential for buffer overflow.* +putc putc(int c, FILE* stream) [int]\nEquivalent to fputc except that it may be a macro. +putchar putchar(int c) [int]\nputchar(c) is equivalent to putc(c, stdout). +puts puts(const char* s) [int]\nWrites `s` (excluding terminating NUL) and a newline to stdout. Returns\nnon-negative on success, EOF on error. +ungetc ungetc(int c, FILE* stream) [int]\nPushes `c` (which must not be EOF), onto (input) stream `stream` such that it\nwill be returned by the next read. Only one character of pushback is guaranteed\n(for each stream). Returns `c`, or EOF on error. +fread fread(void* ptr, size_t size, size_t nobj, FILE* stream) [size_t]\nReads (at most) `nobj` objects of size `size` from stream `stream` into `ptr`\nand returns number of objects read. (feof and ferror can be used to check\nstatus.) +fwrite fwrite(const void* ptr, size_t size, size_t nobj, FILE* stream) [size_t]\nWrites to stream `stream`, `nobj` objects of size `size` from array `ptr`.\nReturns number of objects written. +fseek fseek(FILE* stream, long offset, int origin) [int]\nSets file position for stream `stream` and clears end-of-file indicator. For a\nbinary stream, file position is set to `offset` bytes from the position\nindicated by `origin`: beginning of file for SEEK_SET, current position for\nSEEK_CUR, or end of file for SEEK_END. Behaviour is similar for a text stream,\nbut `offset` must be zero or, for SEEK_SET only, a value returned by ftell.\nReturns non-zero on error. +ftell ftell(FILE* stream) [long]\nReturns current file position for stream `stream`, or -1 on error. +rewind rewind(FILE* stream) [void]\nEquivalent to fseek(stream, 0L, SEEK_SET); clearerr(stream). +fgetpos fgetpos(FILE* stream, fpos_t* ptr) [int]\nStores current file position for stream `stream` in `*ptr`. Returns non-zero on\nerror. +fsetpos fsetpos(FILE* stream, const fpos_t* ptr) [int]\nSets current position of stream `stream` to `*ptr`. Returns non-zero on error. +clearerr clearerr(FILE* stream) [void]\nClears end-of-file and error indicators for stream `stream`. +feof feof(FILE* stream) [int]\nReturns non-zero if end-of-file indicator is set for stream `stream`. +ferror ferror(FILE* stream) [int]\nReturns non-zero if error indicator is set for stream `stream`. +perror perror(const char* s) [void]\nPrints `s` (if non-null) and strerror(errno) to standard error as would:\n fprintf(stderr, "%s: %s\n", (s != NULL ? s : ""), strerror(errno)) + +EXIT_FAILURE EXIT_FAILURE\nValue for status argument to exit indicating failure. +EXIT_SUCCESS EXIT_SUCCESS\nValue for status argument to exit indicating success. +RAND_MAX RAND_MAX\nMaximum value returned by rand(). +NULL NULL\nNull pointer constant. +div_t div_t\nReturn type of div(). +quot div_t.quot [int]\nquotient +rem div_t.rem [int]\nremainder +ldiv_t ldiv_t\nReturn type of ldiv(). +qout ldiv_t.quot [long]\nquotient +rem ldiv_t.rem [long]\nremainder +size_t size_t\nType for objects declared to store result of sizeof operator. +abs abs(int n) [int] +labs labs(long n) [long]\nReturns absolute value of `n`. +div div(int num, int denom) [div_t] +ldiv ldiv(long num, long denom) [ldiv_t]\nReturns quotient and remainder of `num`/`denom`. +atof atof(const char* s) [double]\nEquivalent to strtod(s, (char**)NULL) except that errno is not necessarily set\non conversion error. +atoi atoi(const char* s) [int]\nEquivalent to (int)strtol(s, (char**)NULL, 10) except that errno is not\nnecessarily set on conversion error. +atol atol(const char* s) [long]\nEquivalent to strtol(s, (char**)NULL, 10) except that errno is not necessarily\nset on conversion error. +strtod strtod(const char* s, char** endp) [double]\nConverts initial characters (ignoring leading white space) of `s` to type\ndouble. If `endp` non-null, stores pointer to unconverted suffix in `*endp`. On\noverflow, sets errno to ERANGE and returns HUGE_VAL with the appropriate sign;\non underflow, sets errno to ERANGE and returns zero; otherwise returns converted\nvalue. +strtol strtol(const char* s, char** endp, int base) [long]\nConverts initial characters (ignoring leading white space) of `s` to type long.\nIf `endp` non-null, stores pointer to unconverted suffix in `*endp`. If base\nbetween 2 and 36, that base used for conversion; if zero, leading (after any\nsign) 0X or 0x implies hexadecimal, leading 0 (after any sign) implies octal,\notherwise decimal assumed. Leading 0X or 0x permitted for base hexadecimal. On\noverflow, sets errno to ERANGE and returns LONG_MAX or LONG_MIN (as appropriate\nfor sign); otherwise returns converted value. +strtoul strtoul(const char* s, char** endp, int base) [unsigned long]\nAs for strtol except result is unsigned long and value on overflow is ULONG_MAX. +calloc calloc(size_t nobj, size_t size) [void*]\nReturns pointer to _zero-initialised_ newly-allocated space for an array of\n`nobj` objects each of size `size`, or NULL on error. +malloc malloc(size_t size) [void*]\nReturns pointer to _uninitialised_ newly-allocated space for an object of size\n`size`, or NULL on error. +realloc realloc(void* p, size_t size) [void*]\nReturns pointer to newly-allocated space for an object of size `size`,\ninitialised, to minimum of old and new sizes, to existing contents of `p` (if\nnon-null), or NULL on error. On success, old object deallocated, otherwise\nunchanged. +free free(void* p) [void]\nIf `p` non-null, deallocates space to which it points. +abort abort() [void]\nTerminates program abnormally, by calling raise(SIGABRT). +exit exit(int status) [void]\nTerminates program normally. Functions installed using atexit are called (in\nreverse order to that in which installed), open files are flushed, open streams\nare closed and control is returned to environment. `status` is returned to\nenvironment in implementation-dependent manner. Zero or EXIT_SUCCESS indicates\nsuccessful termination and EXIT_FAILURE indicates unsuccessful termination.\nImplementations may define other values. +atexit atexit(void (*fcm)(void)) [int]\nRegisters `fcn` to be called when program terminates normally (or when main\nreturns). Returns non-zero on failure. +system system(const char* s) [int]\nIf `s` is not NULL, passes `s` to environment for execution, and returns \nreported by command processor; if `s` is NULL, non-zero returned if environment\nhas a command processor. +getenv getenv(const char* name) [char*]\nReturns string associated with name `name` from implementation's environment, or\nNULL if no such string exists. +bsearch bsearch(const void* key, const void* base, size_t n, size_t size, int (*cmp)(const void* keyval, const void* datum)) [void*]\nSearches ordered array `base` (of `n` objects each of size `size`) for item\nmatching key according to comparison function `cmp`. `cmp` must return negative\nvalue if first argument is less than second, zero if equal and positive if\ngreater. Items of `base` are assumed to be in ascending order (according to\n`cmp`). Returns a pointer to an item matching `key`, or NULL if none found. +qsort qsort(void* base, size_t n, size_t size, int (*cmp)(const void*, const void*)) [void]\nArranges into ascending order array `base` (of `n` objects each of size `size`)\naccording to comparison function `cmp`. `cmp` must return negative value if\nfirst argument is less than second, zero if equal and positive if greater. +rand rand(void) [int]\nReturns pseudo-random number in range 0 to RAND_MAX. +srand srand(unsigned int seed) [void]\nUses seed as seed for new sequence of pseudo-random numbers. Initial seed is 1. + +NULL NULL\nNull pointer constant. +size_t size_t\nType for objects declared to store result of sizeof operator. +strcpy strcpy(char* s, const char* ct) [char*]\nCopies `ct` to `s` including terminating NUL and returns `s`. +strncpy strncpy(char* s, const char* ct, size_t n) [char*]\nCopies at most `n` characters of `ct` to `s`. Pads with NUL characters if `ct`\nis of length less than `n`. *Note that this may leave `s` without\nNUL-termination.* Return `s`. +strcat strcat(char* s, const char* ct) [char*]\nConcatenate `ct` to `s` and return `s`. +strncat strncat(char* s, const char* ct, size_t n) [char*]\nConcatenate at most `n` characters of `ct` to `s`. NUL-terminates `s` and return it. +strcmp strcmp(const char* cs, const char* ct) [int]\nCompares `cs` with `ct`, returning negative value if `cs`<`ct`, zero if\n`cs`==`ct`, positive value if `cs`>`ct`. +strncmp strncmp(const char* cs, const char* ct, size_t n) [int]\nCompares at most (the first) `n` characters of `cs` and `ct`, returning negative\nvalue if `cs`<`ct`, zero if `cs`==`ct`, positive value if `cs`>`ct`. +strcoll strcoll(const char* cs, const char* ct) [int]\nCompares `cs` with `ct` according to locale, returning negative value if\n`cs`<`ct`, zero if `cs`==`ct`, positive value if `cs`>`ct`. +strchr strchr(const char* cs, int c) [char*]\nReturns pointer to first occurrence of `c` in `cs`, or NULL if not found. +strrchr strrchr(const char* cs, int c) [char*]\nReturns pointer to last occurrence of `c` in `cs`, or NULL if not found. +strspn strspn(const char* cs, const char* ct) [size_t]\nReturns length of prefix of `cs` which consists of characters which are in `ct`. +strcspn strcspn(const char* cs, const char* ct) [size_t]\nReturns length of prefix of `cs` which consists of characters which are not in\n`ct`. +strpbrk strpbrk(const char* cs, const char* ct) [char*]\nReturns pointer to first occurrence in `cs` of any character of `ct`, or NULL if\nnone is found. +strstr strstr(const char* cs, const char* ct) [char*]\nReturns pointer to first occurrence of `ct` within `cs`, or NULL if none is\nfound. +strlen strlen(const char* cs) [size_t]\nReturns length of `cs`. +strerror strerror(int n) [char*]\nReturns pointer to implementation-defined message string corresponding with\nerror `n`. +strtok strtok(char* s, const char* t) [char*]\nSearches `s` for next token delimited by any character from `ct`. Non-NULL `s`\nindicates the first call of a sequence. If a token is found, it is\nNUL-terminated and returned, otherwise NULL is returned. `ct` need not be\nidentical for each call in a sequence. +strxfrm strxfrm(char* s, const char* ct, size_t n) [size_t]\nStores in `s` no more than `n` characters (including terminating NUL) of a\nstring produced from `ct` according to a locale-specific transformation. Returns\nlength of entire transformed string. +memcpy memcpy(void* s, const void* ct, size_t n) [void*]\nCopies `n` characters from `ct` to `s` and returns `s`. *`s` may be corrupted if\nobjects overlap.* +memmove memmove(void* s, const void* ct, size_t n) [void*]\nCopies `n` characters from `ct` to `s` and returns `s`. *`s` will not be\ncorrupted if objects overlap.* +memcmp memcmp(const void* cs, const void* ct, size_t n) [int]\nCompares at most (the first) `n` characters of `cs` and `ct`, returning negative\nvalue if `cs`<`ct`, zero if `cs`==`ct`, positive value if `cs`>`ct`. +memchr memchr(const void* cs, int c, size_t n) [void*]\nReturns pointer to first occurrence of `c` in first `n` characters of `cs`, or\nNULL if not found. +memset memset(void* s, int c, size_t n) [void*]\nReplaces each of the first `n` characters of `s` by `c` and returns `s`. + +CLOCKS_PER_SEC CLOCKS_PER_SEC\nThe number of clock_t units per second. +NULL NULL\nNull pointer constant. +clock_t clock_t\nAn arithmetic type elapsed processor representing time. +time_t time_t\nAn arithmetic type representing calendar time. +tm tm [struct]\nRepresents the components of calendar time\nImplementations may change field order and include additional fields. +tm_set tm.tm_sec [int]\nseconds after the minute +tm_min tm.tm_min [int]\nminutes after the hour +tm_hour tm.tm_hour [int]\nhours since midnight +tm_mday tm.tm_mday [int]\nday of the month +tm_mon tm.tm_mon [int]\nmonths *since* January +tm_year tm.tm_year [int]\nyears since 1900 +tm_wday tm.tm_wday [int]\ndays since Sunday +tm_yday tm.tm_yday [int]\ndays since January 1 +tm_isdst tm.tm_isdst [int]\nDaylight Saving Time flag : is positive if DST is in effect, zero if not in\neffect, negative if information not known. +clock clock(void) [clock_t]\nReturns elapsed processor time used by program or -1 if not available. +time time(time_t* tp) [time_t]\nReturns current calendar time or -1 if not available. If `tp` is non-NULL,\nreturn value is also assigned to `*tp`. +difftime difftime(time_t time2, time_t time1) [double]\nReturns the difference in seconds between `time2` and `time1`. +mktime mktime(struct tm* tp) [time_t]\nIf necessary, adjusts fields of `*tp` to fall withing normal ranges. Returns the\ncorresponding calendar time, or -1 if it cannot be represented. +asctime asctime(const struct tm* tp) [char*]\nReturns the given time as a string of the form:\n Sun Jan 3 13:08:42 1988\n\0 +ctime ctime(const time_t* tp) [char*]\nReturns string equivalent to calendar time `tp` converted to local time.\nEquivalent to: asctime(localtime(tp)) +gmtime gmtime(const time_t* tp) [struct tm*]\nReturns calendar time `*tp` converted to Coordinated Universal Time, or NULL if\nnot available. +localtime localtime(const time_t* tp) [struct tm*]\nReturns calendar time `*tp` converted into local time. +strftime strftime(char* s, size_t smax, const char* fmt, const struct tm* tp) [size_t]\nFormats `*tp` into `s` according to `fmt`. Places no more than `smax` characters\ninto `s`, and returns number of characters produced (excluding terminating NUL),\nor 0 if greater than `smax`. Formatting conversions (`%c`) are:\n A: name of weekday\n a: abbreviated name of weekday\n B: name of month\n b: abbreviated name of month\n c: local date and time representation\n d: day of month [01-31]\n H: hour (24-hour clock) [00-23]\n I: hour (12-hour clock) [01-12]\n j: day of year [001-366]\n M: minute [00-59]\n m: month [01-12]\n p: local equivalent of "AM" or "PM"\n S: second [00-61]\n U: week number of year (Sunday as 1st day of week) [00-53]\n W: week number of year (Monday as 1st day of week) [00-53]\n w: weekday (Sunday as 0) [0-6]\n X: local time representation\n x: local date representation\n Y: year with century\n y: year without century [00-99]\n Z: name (if any) of time zone\n %: %\nLocal time may differ from calendar time because of time zone. diff --git a/modules/cpp/init.lua b/modules/cpp/init.lua index 55555a65..8f661fe0 100644 --- a/modules/cpp/init.lua +++ b/modules/cpp/init.lua @@ -59,8 +59,10 @@ sense.ctags_kinds = { s = 'classes', t = 'classes' } +sense:load_ctags(_HOME..'/modules/cpp/tags', true) +sense.api_files = { _HOME..'/modules/cpp/api' } sense.syntax.type_declarations = { - '(%u[%w_%.]+)[%s%*&]+%_[^%w_]', -- Foo bar, Foo *bar, Foo* bar, Foo &bar, etc. + '([%w_%.]+)[%s%*&]+%_[^%w_]', -- Foo bar, Foo *bar, Foo* bar, Foo &bar, etc. } sense:add_trigger('.') sense:add_trigger('->') diff --git a/modules/cpp/tags b/modules/cpp/tags new file mode 100644 index 00000000..d7ab2dda --- /dev/null +++ b/modules/cpp/tags @@ -0,0 +1,268 @@ +assert _ 0;" f +isalnum _ 0;" f +isalpha _ 0;" f +iscontrl _ 0;" f +isdigit _ 0;" f +isgraph _ 0;" f +islower _ 0;" f +isprint _ 0;" f +ispunct _ 0;" f +isspace _ 0;" f +isupper _ 0;" f +isxdigit _ 0;" f +tolower _ 0;" f +toupper _ 0;" f +errno _ 0;" m +EDOM _ 0;" m +ERANGE _ 0;" m +FLT_RADIX _ 0;" m +FLT_ROUNDS _ 0;" m +FLT_DIG _ 0;" m +DBL_DIG _ 0;" m +LDBL_DIG _ 0;" m +FLT_EPSILON _ 0;" m +DBL_EPSILON _ 0;" m +LDBL_EPSILON _ 0;" m +FLT_MANT_DIG _ 0;" m +DBL_MANT_DIG _ 0;" m +LDBL_MANT_DIG _ 0;" m +FLT_MAX _ 0;" m +DBL_MAX _ 0;" m +LDBL_MAX _ 0;" m +FLT_MAX_EXP _ 0;" m +DBL_MAX_EXP _ 0;" m +LDBL_MAX_EXP _ 0;" m +FLT_MIN _ 0;" m +DBL_MIN _ 0;" m +LDBL_MIN _ 0;" m +FLT_MIN_EXP _ 0;" m +DBL_MIN_EXP _ 0;" m +LDBL_MIN_EXP _ 0;" m +CHAR_BIT _ 0;" m +CHAR_MAX _ 0;" m +CHAR_MIN _ 0;" m +SCHAR_MAX _ 0;" m +SCHAR_MIN _ 0;" m +UCHAR_MAX _ 0;" m +SHRT_MAX _ 0;" m +SHRT_MIN _ 0;" m +USHRT_MAX _ 0;" m +INT_MAX _ 0;" m +INT_MIN _ 0;" m +UINT_MAX _ 0;" m +LONG_MAX _ 0;" m +LONG_MIN _ 0;" m +ULONG_MAX _ 0;" m +lconv _ 0;" s +decimal_point _ 0;" m class:lconv +grouping _ 0;" m class:lconv +thousands_sep _ 0;" m class:lconv +currency_symbol _ 0;" m class:lconv +int_curr_symbol _ 0;" m class:lconv +mon_decimal_point _ 0;" m class:lconv +mon_grouping _ 0;" m class:lconv +mon_thousands_sep _ 0;" m class:lconv +negative_sign _ 0;" m class:lconv +positive_sign _ 0;" m class:lconv +frac_digits _ 0;" m class:lconv +int_frac_digits _ 0;" m class:lconv +n_cs_precedes _ 0;" m class:lconv +n_sep_by_space _ 0;" m class:lconv +n_sign_posn _ 0;" m class:lconv +p_cs_precedes _ 0;" m class:lconv +p_sep_by_space _ 0;" m class:lconv +p_sign_posn _ 0;" m class:lconv +localeconv _ 0;" f +setlocale _ 0;" f +LC_ALL _ 0;" m +LC_NUMERIC _ 0;" m +LC_MONETARY _ 0;" m +LC_COLLATE _ 0;" m +LC_CTYPE _ 0;" m +LC_TIME _ 0;" m +NULL _ 0;" m +HUGE_VAL _ 0;" m +exp _ 0;" f +log _ 0;" f +log10 _ 0;" f +pow _ 0;" f +sqrt _ 0;" f +ceil _ 0;" f +floor _ 0;" f +fabs _ 0;" f +ldexp _ 0;" f +frexp _ 0;" f +modf _ 0;" f +fmod _ 0;" f +sin _ 0;" f +cos _ 0;" f +tan _ 0;" f +asin _ 0;" f +acos _ 0;" f +atan _ 0;" f +atan2 _ 0;" f +sinh _ 0;" f +cosh _ 0;" f +tanh _ 0;" f +jmp_buf _ 0;" f +setjmp _ 0;" f +longjmp _ 0;" f +SIGABRT _ 0;" m +SIGFPE _ 0;" m +SIGILL _ 0;" m +SIGINT _ 0;" m +SIGSEGV _ 0;" m +SIGTERM _ 0;" m +SIG_DFL _ 0;" m +SIG_ERR _ 0;" m +SIG_IGN _ 0;" m +raise _ 0;" f +va_list _ 0;" m +va_start _ 0;" f +va_arg _ 0;" f +va_end _ 0;" f +NULL _ 0;" m +offsetof _ 0;" f +ptrdiff_t _ 0;" t +size_t _ 0;" t +BUFSIZ _ 0;" m +EOF _ 0;" m +FILENAME_MA _ 0;" mX +FOPEN_MAX _ 0;" m +L_tmpnam _ 0;" m +NULL _ 0;" m +SEEK_CUR _ 0;" m +SEEK_END _ 0;" m +SEEK_SET _ 0;" m +TMP_MAX _ 0;" m +_IOFBF _ 0;" m +_IOLBF _ 0;" m +_IONBF _ 0;" m +stdin _ 0;" m +stdout _ 0;" m +stderr _ 0;" m +FILE _ 0;" t +fpos_t _ 0;" t +size_t _ 0;" t +fopen _ 0;" f +freopen _ 0;" f +fflush _ 0;" f +fclose _ 0;" f +remove _ 0;" f +rename _ 0;" f +tmpfile _ 0;" f +tmpnam _ 0;" f +setvbuf _ 0;" f +setbuf _ 0;" f +fprintf _ 0;" f +printf _ 0;" f +sprintf _ 0;" f +vfprintf _ 0;" f +vprintf _ 0;" f +vsprintf _ 0;" f +fscanf _ 0;" f +scanf _ 0;" f +sscanf _ 0;" f +fgetc _ 0;" f +fgets _ 0;" f +fputc _ 0;" f +fputs _ 0;" f +getc _ 0;" f +getchar _ 0;" f +gets _ 0;" f +putc _ 0;" f +putchar _ 0;" f +puts _ 0;" f +ungetc _ 0;" f +fread _ 0;" f +fwrite _ 0;" f +fseek _ 0;" f +ftell _ 0;" f +rewind _ 0;" f +fgetpos _ 0;" f +fsetpos _ 0;" f +clearerr _ 0;" f +feof _ 0;" f +ferror _ 0;" f +perror _ 0;" f +EXIT_FAILURE _ 0;" m +EXIT_SUCCESS _ 0;" m +RAND_MAX _ 0;" m +NULL _ 0;" m +div_t _ 0;" s +quot _ 0;" m class:div_t +rem _ 0;" m class:div_t +ldiv_t _ 0;" s +qout _ 0;" m class:ldiv_t +rem _ 0;" m class:ldiv_t +size_t _ 0;" t +abs _ 0;" f +labs _ 0;" f +div _ 0;" f +ldiv _ 0;" f +atof _ 0;" f +atoi _ 0;" f +atol _ 0;" f +strtod _ 0;" f +strtol _ 0;" f +strtoul _ 0;" f +calloc _ 0;" f +malloc _ 0;" f +realloc _ 0;" f +free _ 0;" f +abort _ 0;" f +exit _ 0;" f +atexit _ 0;" f +system _ 0;" f +getenv _ 0;" f +bsearch _ 0;" f +qsort _ 0;" f +rand _ 0;" f +srand _ 0;" f +NULL _ 0;" m +size_t _ 0;" t +strcpy _ 0;" f +strncpy _ 0;" f +strcat _ 0;" f +strncat _ 0;" f +strcmp _ 0;" f +strncmp _ 0;" f +strcoll _ 0;" f +strchr _ 0;" f +strrchr _ 0;" f +strspn _ 0;" f +strcspn _ 0;" f +strpbrk _ 0;" f +strstr _ 0;" f +strlen _ 0;" f +strerror _ 0;" f +strtok _ 0;" f +strxfrm _ 0;" f +memcpy _ 0;" f +memmove _ 0;" f +memcmp _ 0;" f +memchr _ 0;" f +memset _ 0;" f +CLOCKS_PER_SEC _ 0;" m +NULL _ 0;" m +clock_t _ 0;" t +time_t _ 0;" t +tm _ 0;" s +tm_set _ 0;" m class:tm +tm_min _ 0;" m class:tm +tm_hour _ 0;" m class:tm +tm_mday _ 0;" m class:tm +tm_mon _ 0;" m class:tm +tm_year _ 0;" m class:tm +tm_wday _ 0;" m class:tm +tm_yday _ 0;" m class:tm +tm_isdst _ 0;" m class:tm +clock _ 0;" f +time _ 0;" f +difftime _ 0;" f +mktime _ 0;" f +asctime _ 0;" f +ctime _ 0;" f +gmtime _ 0;" f +localtime _ 0;" f +strftime _ 0;" f |