Where Online Learning is simpler!
The C and C++ Include Header Files
cat -n /usr/include/gawkapi.h
1 /* 2 * gawkapi.h -- Definitions for use by extension functions calling into gawk. 3 */ 4 5 /* 6 * copyright (c) 2012-2019, 2021-2024, the free software foundation, inc. 7 * 8 * This file is part of GAWK, the GNU implementation of the 9 * AWK Programming Language. 10 * 11 * GAWK is free software; you can redistribute it and/or modify 12 * it under the terms of the GNU General Public License as published by 13 * the Free Software Foundation; either version 3 of the License, or 14 * (at your option) any later version. 15 * 16 * GAWK is distributed in the hope that it will be useful, 17 * but WITHOUT ANY WARRANTY; without even the implied warranty of 18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 19 * GNU General Public License for more details. 20 * 21 * You should have received a copy of the GNU General Public License 22 * along with this program; if not, write to the Free Software 23 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA 24 */ 25 26 /* 27 * The following types and/or macros and/or functions are referenced 28 * in this file. For correct use, you must therefore include the 29 * corresponding standard header file BEFORE including this file. 30 * 31 * FILE - <stdio.h> 32 * NULL - <stddef.h> 33 * memset(), memcpy() - <string.h> 34 * size_t - <sys/types.h> 35 * struct stat - <sys/stat.h> 36 * 37 * Due to portability concerns, especially to systems that are not 38 * fully standards-compliant, it is your responsibility to include 39 * the correct files in the correct way. This requirement is necessary 40 * in order to keep this file clean, instead of becoming a portability 41 * hodge-podge as can be seen in the gawk source code. 42 * 43 * To pass reasonable integer values for ERRNO, you will also need to 44 * include <errno.h>. 45 */ 46 47 #ifndef _GAWK_API_H 48 #define _GAWK_API_H 49 50 /* 51 * General introduction: 52 * 53 * This API purposely restricts itself to ISO C 90 features. In particular, no 54 * bool, no // comments, no use of the restrict keyword, or anything else, 55 * in order to provide maximal portability. 56 * 57 * Exception: the "inline" keyword is used below in the "constructor" 58 * functions. If your compiler doesn't support it, you should either 59 * -Dinline='' on your command line, or use the autotools and include a 60 * config.h in your extensions. 61 * 62 * Additional important information: 63 * 64 * 1. ALL string values in awk_value_t objects need to come from api_malloc(). 65 * Gawk will handle releasing the storage if necessary. This is slightly 66 * awkward, in that you can't take an awk_value_t that you got from gawk 67 * and reuse it directly, even for something that is conceptually pass 68 * by value. 69 * 70 * 2. Due to gawk internals, after using sym_update() to install an array 71 * into gawk, you have to retrieve the array cookie from the value 72 * passed in to sym_update(). Like so: 73 * 74 * new_array = create_array(); 75 * val.val_type = AWK_ARRAY; 76 * val.array_cookie = new_array; 77 * sym_update("array", & val); // install array in the symbol table 78 * 79 * new_array = val.array_cookie; // MUST DO THIS 80 * 81 * // fill in new array with lots of subscripts and values 82 * 83 * Similarly, if installing a new array as a subarray of an existing 84 * array, you must add the new array to its parent before adding any 85 * elements to it. 86 * 87 * You must also retrieve the value of the array_cookie after the call 88 * to set_element(). 89 * 90 * Thus, the correct way to build an array is to work "top down". 91 * Create the array, and immediately install it in gawk's symbol table 92 * using sym_update(), or install it as an element in a previously 93 * existing array using set_element(). 94 * 95 * Thus the new array must ultimately be rooted in a global symbol. This is 96 * necessary before installing any subarrays in it, due to gawk's 97 * internal implementation. Strictly speaking, this is required only 98 * for arrays that will have subarrays as elements; however it is 99 * a good idea to always do this. This restriction may be relaxed 100 * in a subsequent revision of the API. 101 * 102 * 3. While each routine in the API has a few lines of summary for it 103 * in this header, said summaries are not standalone, adequate documentation. You 104 * should read the chapter in the gawk manual on writing extensions. Find it online 105 * at https://www.gnu.org/software/gawk/manual/html_node/Dynamic-Extensions.html, 106 * or in the Info files distributed with gawk. 107 */ 108 109 /* Allow use in C++ code. */ 110 #ifdef __cplusplus 111 extern "C" { 112 #endif 113 114 /* This is used to keep extensions from modifying certain fields in some structs. */ 115 #ifdef GAWK 116 #define awk_const 117 #else 118 #define awk_const const 119 #endif 120 121 typedef enum awk_bool { 122 awk_false = 0, 123 awk_true 124 } awk_bool_t; /* we don't use <stdbool.h> on purpose */ 125 126 /* 127 * If an input parser would like to specify the field positions in the input 128 * record, it may populate an awk_fieldwidth_info_t structure to indicate 129 * the location of each field. The use_chars boolean controls whether the 130 * field lengths are specified in terms of bytes or potentially multi-byte 131 * characters. Performance will be better if the values are supplied in 132 * terms of bytes. The fields[0].skip value indicates how many bytes (or 133 * characters) to skip before $1, and fields[0].len is the length of $1, etc. 134 */ 135 136 typedef struct { 137 awk_bool_t use_chars; /* false ==> use bytes */ 138 size_t nf; 139 struct awk_field_info { 140 size_t skip; /* amount to skip before field starts */ 141 size_t len; /* length of field */ 142 } fields[1]; /* actual dimension should be nf */ 143 } awk_fieldwidth_info_t; 144 145 /* 146 * This macro calculates the total struct size needed. This is useful when 147 * calling malloc or realloc. 148 */ 149 #define awk_fieldwidth_info_size(NF) (sizeof(awk_fieldwidth_info_t) + \ 150 (((NF)-1) * sizeof(struct awk_field_info))) 151 152 /* The information about input files that input parsers need to know: */ 153 typedef struct awk_input { 154 const char *name; /* filename */ 155 int fd; /* file descriptor */ 156 #define INVALID_HANDLE (-1) 157 void *opaque; /* private data for input parsers */ 158 159 /* 160 * The get_record function is called to read the next record of data. 161 * 162 * It should return the length of the input record or EOF, and it 163 * should set *out to point to the contents of $0. The rt_start 164 * and rt_len arguments should be used to return RT to gawk. 165 * If EOF is not returned, the parser must set *rt_len (and 166 * *rt_start if *rt_len is non-zero). 167 * 168 * Note that gawk will make a copy of the record in *out, so the 169 * parser is responsible for managing its own memory buffer. 170 * Similarly, gawk will make its own copy of RT, so the parser 171 * is also responsible for managing this memory. 172 * 173 * It is guaranteed that errcode is a valid pointer, so there is 174 * no need to test for a NULL value. Gawk sets *errcode to 0, 175 * so there is no need to set it unless an error occurs. 176 * 177 * If an error does occur, the function should return EOF and set 178 * *errcode to a positive value. In that case, if *errcode is greater 179 * than zero, gawk will automatically update the ERRNO variable based 180 * on the value of *errcode (e.g., setting *errcode = errno should do 181 * the right thing). 182 * 183 * If field_width is non-NULL, then *field_width will be initialized 184 * to NULL, and the function may set it to point to a structure 185 * supplying field width information to override the default 186 * gawk field parsing mechanism. Note that this structure will not 187 * be copied by gawk; it must persist at least until the next call 188 * to get_record or close_func. Note also that field_width will 189 * be NULL when getline is assigning the results to a variable, thus 190 * field parsing is not needed. 191 */ 192 int (*get_record)(char **out, struct awk_input *iobuf, int *errcode, 193 char **rt_start, size_t *rt_len, 194 const awk_fieldwidth_info_t **field_width); 195 196 /* 197 * This replaces the POSIX read() system call. Use it if you want to 198 * manage reading raw bytes yourself, and let gawk parse the record. 199 */ 200 ssize_t (*read_func)(int, void *, size_t); 201 202 /* 203 * The close_func is called to allow the parser to free private data. 204 * Gawk itself will close the fd unless close_func first sets it to 205 * INVALID_HANDLE. 206 */ 207 void (*close_func)(struct awk_input *iobuf); 208 209 /* put last, for alignment. bleah */ 210 struct stat sbuf; /* stat buf */ 211 212 } awk_input_buf_t; 213 214 typedef struct awk_input_parser { 215 const char *name; /* name of parser */ 216 217 /* 218 * The can_take_file function should return true if the parser 219 * would like to parse this file. It should not change any gawk 220 * state! 221 */ 222 awk_bool_t (*can_take_file)(const awk_input_buf_t *iobuf); 223 224 /* 225 * If this parser is selected, then take_control_of will be called. 226 * It can assume that a previous call to can_take_file was successful, 227 * and no gawk state has changed since that call. It should populate 228 * the awk_input_buf_t's get_record, close_func, and opaque values as needed. 229 * It should return true if successful. 230 */ 231 awk_bool_t (*take_control_of)(awk_input_buf_t *iobuf); 232 233 awk_const struct awk_input_parser *awk_const next; /* for use by gawk */ 234 } awk_input_parser_t; 235 236 /* 237 * Similar for output wrapper. 238 */ 239 240 /* First the data structure */ 241 typedef struct awk_output_buf { 242 const char *name; /* name of output file */ 243 const char *mode; /* mode argument to fopen */ 244 FILE *fp; /* stdio file pointer */ 245 awk_bool_t redirected; /* true if a wrapper is active */ 246 void *opaque; /* for use by output wrapper */ 247 248 /* 249 * Replacement functions for I/O. Just like the regular 250 * versions but also take the opaque pointer argument. 251 */ 252 size_t (*gawk_fwrite)(const void *buf, size_t size, size_t count, 253 FILE *fp, void *opaque); 254 int (*gawk_fflush)(FILE *fp, void *opaque); 255 int (*gawk_ferror)(FILE *fp, void *opaque); 256 int (*gawk_fclose)(FILE *fp, void *opaque); 257 } awk_output_buf_t; 258 259 /* Next the output wrapper registered with gawk */ 260 typedef struct awk_output_wrapper { 261 const char *name; /* name of the wrapper */ 262 263 /* 264 * The can_take_file function should return true if the wrapper 265 * would like to process this file. It should not change any gawk 266 * state! 267 */ 268 awk_bool_t (*can_take_file)(const awk_output_buf_t *outbuf); 269 270 /* 271 * If this wrapper is selected, then take_control_of will be called. 272 * It can assume that a previous call to can_take_file was successful, 273 * and no gawk state has changed since that call. It should populate 274 * the awk_output_buf_t function pointers and opaque pointer as needed. 275 * It should return true if successful. 276 */ 277 awk_bool_t (*take_control_of)(awk_output_buf_t *outbuf); 278 279 awk_const struct awk_output_wrapper *awk_const next; /* for use by gawk */ 280 } awk_output_wrapper_t; 281 282 /* A two-way processor combines an input parser and an output wrapper. */ 283 typedef struct awk_two_way_processor { 284 const char *name; /* name of the two-way processor */ 285 286 /* 287 * The can_take_file function should return true if the two-way 288 * processor would like to parse this file. It should not change 289 * any gawk state! 290 */ 291 awk_bool_t (*can_take_two_way)(const char *name); 292 293 /* 294 * If this processor is selected, then take_control_of will be called. 295 * It can assume that a previous call to can_take_file was successful, 296 * and no gawk state has changed since that call. It should populate 297 * the awk_input_buf_t and awk_otuput_buf_t structures as needed. 298 * It should return true if successful. 299 */ 300 awk_bool_t (*take_control_of)(const char *name, awk_input_buf_t *inbuf, 301 awk_output_buf_t *outbuf); 302 303 awk_const struct awk_two_way_processor *awk_const next; /* for use by gawk */ 304 } awk_two_way_processor_t; 305 306 #define gawk_api_major_version 4 307 #define gawk_api_minor_version 0 308 309 /* Current version of the API. */ 310 enum { 311 GAWK_API_MAJOR_VERSION = gawk_api_major_version, 312 GAWK_API_MINOR_VERSION = gawk_api_minor_version 313 }; 314 315 /* A number of typedefs related to different types of values. */ 316 317 /* 318 * A mutable string. Gawk owns the memory pointed to if it supplied 319 * the value. Otherwise, it takes ownership of the memory pointed to. 320 * 321 * The API deals exclusively with regular chars; these strings may 322 * be multibyte encoded in the current locale's encoding and character 323 * set. Gawk will convert internally to wide characters if necessary. 324 * 325 * Note that a string provided by gawk will always be terminated 326 * with a '\0' character. 327 */ 328 typedef struct awk_string { 329 char *str; /* data */ 330 size_t len; /* length thereof, in chars */ 331 } awk_string_t; 332 333 enum AWK_NUMBER_TYPE { 334 AWK_NUMBER_TYPE_DOUBLE, 335 AWK_NUMBER_TYPE_MPFR, 336 AWK_NUMBER_TYPE_MPZ 337 }; 338 339 /* 340 * When type is AWK_NUMBER_MPFR or AWK_NUMBER_MPZ, the memory pointed to 341 * by the ptr member belongs to gawk if it came from gawk. Otherwise the 342 * memory belongs to the extension and gawk copies it when its received. 343 * See the manual for further discussion. 344 */ 345 346 typedef struct awk_number { 347 double d; /* always populated in data received from gawk */ 348 enum AWK_NUMBER_TYPE type; 349 void *ptr; /* either NULL or mpfr_ptr or mpz_ptr */ 350 } awk_number_t; 351 352 /* Arrays are represented as an opaque type. */ 353 typedef void *awk_array_t; 354 355 /* Scalars can be represented as an opaque type. */ 356 typedef void *awk_scalar_t; 357 358 /* Any value can be stored as a cookie. */ 359 typedef void *awk_value_cookie_t; 360 361 /* 362 * This tag defines the type of a value. 363 * 364 * Values are associated with regular variables and with array elements. 365 * Since arrays can be multidimensional (as can regular variables) 366 * it's valid to have a "value" that is actually an array. 367 */ 368 typedef enum { 369 AWK_UNDEFINED, 370 AWK_NUMBER, 371 AWK_STRING, 372 AWK_REGEX, 373 AWK_STRNUM, 374 AWK_ARRAY, 375 AWK_SCALAR, /* opaque access to a variable */ 376 AWK_VALUE_COOKIE, /* for updating a previously created value */ 377 AWK_BOOL 378 } awk_valtype_t; 379 380 /* 381 * An awk value. The val_type tag indicates what 382 * is in the union. 383 */ 384 typedef struct awk_value { 385 awk_valtype_t val_type; 386 union { 387 awk_string_t s; 388 awk_number_t n; 389 awk_array_t a; 390 awk_scalar_t scl; 391 awk_value_cookie_t vc; 392 awk_bool_t b; 393 } u; 394 #define str_value u.s 395 #define strnum_value str_value 396 #define regex_value str_value 397 #define num_value u.n.d 398 #define num_type u.n.type 399 #define num_ptr u.n.ptr 400 #define array_cookie u.a 401 #define scalar_cookie u.scl 402 #define value_cookie u.vc 403 #define bool_value u.b 404 } awk_value_t; 405 406 /* 407 * A "flattened" array element. Gawk produces an array of these 408 * inside the awk_flat_array_t. 409 * ALL memory pointed to belongs to gawk. Individual elements may 410 * be marked for deletion. New elements must be added individually, 411 * one at a time, using the separate API for that purpose. 412 */ 413 414 typedef struct awk_element { 415 /* convenience linked list pointer, not used by gawk */ 416 struct awk_element *next; 417 enum { 418 AWK_ELEMENT_DEFAULT = 0, /* set by gawk */ 419 AWK_ELEMENT_DELETE = 1 /* set by extension if 420 should be deleted */ 421 } flags; 422 awk_value_t index; 423 awk_value_t value; 424 } awk_element_t; 425 426 /* 427 * A "flattened" array. See the description above for how 428 * to use the elements contained herein. 429 */ 430 typedef struct awk_flat_array { 431 awk_const void *awk_const opaque1; /* private data for use by gawk */ 432 awk_const void *awk_const opaque2; /* private data for use by gawk */ 433 awk_const size_t count; /* how many elements */ 434 awk_element_t elements[1]; /* will be extended */ 435 } awk_flat_array_t; 436 437 /* 438 * A record describing an extension function. Upon being 439 * loaded, the extension should pass in one of these to gawk for 440 * each C function. 441 * 442 * Each called function must fill in the result with either a scalar 443 * (number, string, or regex). Gawk takes ownership of any string memory. 444 * 445 * The called function must return the value of `result'. 446 * This is for the convenience of the calling code inside gawk. 447 * 448 * Each extension function may decide what to do if the number of 449 * arguments isn't what it expected. Following awk functions, it 450 * is likely OK to ignore extra arguments. 451 * 452 * 'min_required_args' indicates how many arguments MUST be passed. 453 * The API will throw a fatal error if not enough are passed. 454 * 455 * 'max_expected_args' is more benign; if more than that are passed, 456 * the API prints a lint message (IFF lint is enabled, of course). 457 * 458 * In any case, the extension function itself need not compare the 459 * actual number of arguments passed to those two values if it does 460 * not want to. 461 */ 462 typedef struct awk_ext_func { 463 const char *name; 464 awk_value_t *(*const function)(int num_actual_args, 465 awk_value_t *result, 466 struct awk_ext_func *finfo); 467 const size_t max_expected_args; 468 const size_t min_required_args; 469 awk_bool_t suppress_lint; 470 void *data; /* opaque pointer to any extra state */ 471 } awk_ext_func_t; 472 473 typedef void *awk_ext_id_t; /* opaque type for extension id */ 474 475 /* 476 * The API into gawk. Lots of functions here. We hope that they are 477 * logically organized. 478 * 479 * !!! If you make any changes to this structure, please remember to bump !!! 480 * !!! gawk_api_major_version and/or gawk_api_minor_version. !!! 481 */ 482 typedef struct gawk_api { 483 /* First, data fields. */ 484 485 /* These are what gawk thinks the API version is. */ 486 awk_const int major_version; 487 awk_const int minor_version; 488 489 /* GMP/MPFR versions, if extended-precision is available */ 490 awk_const int gmp_major_version; 491 awk_const int gmp_minor_version; 492 awk_const int mpfr_major_version; 493 awk_const int mpfr_minor_version; 494 495 /* 496 * These can change on the fly as things happen within gawk. 497 * Currently only do_lint is prone to change, but we reserve 498 * the right to allow the others to do so also. 499 * 500 * N.B. If we ever again need to add an additional do_flags value, 501 * it would be wise to convert this from an array to a bitmask. If 502 * we add a new do_flags value and bump DO_FLAGS_SIZE, then it requires 503 * us to increment the ABI version. If we use a bitmask instead, then 504 * we will be free to add new flags without breaking ABI compatibility. 505 */ 506 #define DO_FLAGS_SIZE 7 507 awk_const int do_flags[DO_FLAGS_SIZE]; 508 /* Use these as indices into do_flags[] array to check the values */ 509 #define gawk_do_lint 0 510 #define gawk_do_traditional 1 511 #define gawk_do_profile 2 512 #define gawk_do_sandbox 3 513 #define gawk_do_debug 4 514 #define gawk_do_mpfr 5 515 #define gawk_do_csv 6 516 517 /* Next, registration functions: */ 518 519 /* 520 * Add a function to the interpreter, returns true upon success. 521 * Gawk does not modify what func points to, but the extension 522 * function itself receives this pointer and can modify what it 523 * points to, thus it's not const. 524 */ 525 awk_bool_t (*api_add_ext_func)(awk_ext_id_t id, const char *name_space, 526 awk_ext_func_t *func); 527 528 /* Register an input parser; for opening files read-only */ 529 void (*api_register_input_parser)(awk_ext_id_t id, 530 awk_input_parser_t *input_parser); 531 532 /* Register an output wrapper, for writing files */ 533 void (*api_register_output_wrapper)(awk_ext_id_t id, 534 awk_output_wrapper_t *output_wrapper); 535 536 /* Register a processor for two way I/O */ 537 void (*api_register_two_way_processor)(awk_ext_id_t id, 538 awk_two_way_processor_t *two_way_processor); 539 540 /* 541 * Add an exit call back. 542 * 543 * arg0 is a private data pointer for use by the extension; 544 * gawk saves it and passes it into the function pointed 545 * to by funcp at exit. 546 * 547 * Exit callback functions are called in LIFO order. 548 */ 549 void (*api_awk_atexit)(awk_ext_id_t id, 550 void (*funcp)(void *data, int exit_status), 551 void *arg0); 552 553 /* Register a version string for this extension with gawk. */ 554 void (*api_register_ext_version)(awk_ext_id_t id, const char *version); 555 556 /* Functions to print messages */ 557 void (*api_fatal)(awk_ext_id_t id, const char *format, ...); 558 void (*api_warning)(awk_ext_id_t id, const char *format, ...); 559 void (*api_lintwarn)(awk_ext_id_t id, const char *format, ...); 560 void (*api_nonfatal)(awk_ext_id_t id, const char *format, ...); 561 562 /* Functions to update ERRNO */ 563 void (*api_update_ERRNO_int)(awk_ext_id_t id, int errno_val); 564 void (*api_update_ERRNO_string)(awk_ext_id_t id, const char *string); 565 void (*api_unset_ERRNO)(awk_ext_id_t id); 566 567 /* 568 * All of the functions that return a value from inside gawk 569 * (get a parameter, get a global variable, get an array element) 570 * behave in the same way. 571 * 572 * For a function parameter, the return is false if the argument 573 * count is out of range, or if the actual parameter does not match 574 * what is specified in wanted. In that case, result->val_type 575 * will hold the actual type of what was passed. 576 * 577 * Similarly for symbol table access to variables and array elements, 578 * the return is false if the actual variable or array element does 579 * not match what was requested, and result->val_type will hold 580 * the actual type. 581 582 Table entry is type returned: 583 584 585 +----------------------------------------------------------------+ 586 | Type of Actual Value: | 587 +--------+--------+--------+--------+--------+-------+-----------+ 588 | String | Strnum | Number | Regex | Bool | Array | Undefined | 589 +-----------+-----------+--------+--------+--------+--------+--------+-------+-----------+ 590 | | String | String | String | String | String | String | false | false | 591 | +-----------+--------+--------+--------+--------+--------+-------+-----------+ 592 | | Strnum | false | Strnum | Strnum | false | false | false | false | 593 | +-----------+--------+--------+--------+--------+--------+-------+-----------+ 594 | | Number | Number | Number | Number | false | Number | false | false | 595 | +-----------+--------+--------+--------+--------+--------+-------+-----------+ 596 | | Regex | false | false | false | Regex | false | false | false | 597 | +-----------+--------+--------+--------+--------+--------+-------+-----------+ 598 | Type | Bool | false | false | false | false | Bool | false | false | 599 | Requested +-----------+--------+--------+--------+--------+--------+-------+-----------+ 600 | | Array | false | false | false | false | false | Array | false | 601 | +-----------+--------+--------+--------+--------+--------+-------+-----------+ 602 | | Scalar | Scalar | Scalar | Scalar | Scalar | Scalar | false | false | 603 | +-----------+--------+--------+--------+--------+--------+-------+-----------+ 604 | | Undefined | String | Strnum | Number | Regex | Bool | Array | Undefined | 605 | +-----------+--------+--------+--------+--------+--------+-------+-----------+ 606 | | Value | false | false | false | false | false | false | false | 607 | | Cookie | | | | | | | | 608 +-----------+-----------+--------+--------+--------+--------+--------+-------+-----------+ 609 */ 610 611 /* Functions to handle parameters passed to the extension. */ 612 613 /* 614 * Get the count'th parameter, zero-based. 615 * Returns false if count is out of range, or if actual parameter 616 * does not match what is specified in wanted. In that case, 617 * result->val_type is as described above. 618 */ 619 awk_bool_t (*api_get_argument)(awk_ext_id_t id, size_t count, 620 awk_valtype_t wanted, 621 awk_value_t *result); 622 623 /* 624 * Convert a parameter that was undefined into an array 625 * (provide call-by-reference for arrays). Returns false 626 * if count is too big, or if the argument's type is 627 * not undefined. 628 */ 629 awk_bool_t (*api_set_argument)(awk_ext_id_t id, 630 size_t count, 631 awk_array_t array); 632 633 /* 634 * Symbol table access: 635 * - Read-only access to special variables (NF, etc.) 636 * - One special exception: PROCINFO. 637 * - Use sym_update() to change a value, including from UNDEFINED 638 * to scalar or array. 639 */ 640 /* 641 * Lookup a variable, fill in value. No messing with the value 642 * returned. 643 * Returns false if the variable doesn't exist or if the wrong type 644 * was requested. In the latter case, vaule->val_type will have 645 * the real type, as described above. 646 * 647 * awk_value_t val; 648 * if (! api->sym_lookup(id, name, wanted, & val)) 649 * error_code_here(); 650 * else { 651 * // safe to use val 652 * } 653 */ 654 awk_bool_t (*api_sym_lookup)(awk_ext_id_t id, 655 const char *name_space, 656 const char *name, 657 awk_valtype_t wanted, 658 awk_value_t *result); 659 660 /* 661 * Update a value. Adds it to the symbol table if not there. 662 * Changing types (scalar <--> array) is not allowed. 663 * In fact, using this to update an array is not allowed, either. 664 * Such an attempt returns false. 665 */ 666 awk_bool_t (*api_sym_update)(awk_ext_id_t id, 667 const char *name_space, 668 const char *name, 669 awk_value_t *value); 670 671 /* 672 * A ``scalar cookie'' is an opaque handle that provide access 673 * to a global variable or array. It is an optimization that 674 * avoids looking up variables in gawk's symbol table every time 675 * access is needed. 676 * 677 * This function retrieves the current value of a scalar cookie. 678 * Once you have obtained a scalar_cookie using sym_lookup, you can 679 * use this function to get its value more efficiently. 680 * 681 * Return will be false if the value cannot be retrieved. 682 * 683 * Flow is thus 684 * awk_value_t val; 685 * awk_scalar_t cookie; 686 * api->sym_lookup(id, "variable", AWK_SCALAR, & val); // get the cookie 687 * cookie = val.scalar_cookie; 688 * ... 689 * api->sym_lookup_scalar(id, cookie, wanted, & val); // get the value 690 */ 691 awk_bool_t (*api_sym_lookup_scalar)(awk_ext_id_t id, 692 awk_scalar_t cookie, 693 awk_valtype_t wanted, 694 awk_value_t *result); 695 696 /* 697 * Update the value associated with a scalar cookie. 698 * Flow is 699 * sym_lookup with wanted == AWK_SCALAR 700 * if returns false 701 * sym_update with real initial value to install it 702 * sym_lookup again with AWK_SCALAR 703 * else 704 * use the scalar cookie 705 * 706 * Return will be false if the new value is not one of 707 * AWK_STRING, AWK_NUMBER, AWK_REGEX. 708 * 709 * Here too, the built-in variables may not be updated. 710 */ 711 awk_bool_t (*api_sym_update_scalar)(awk_ext_id_t id, 712 awk_scalar_t cookie, awk_value_t *value); 713 714 /* Cached values */ 715 716 /* 717 * Create a cached string,regex, or numeric value for efficient later 718 * assignment. This improves performance when you want to assign 719 * the same value to one or more variables repeatedly. Only 720 * AWK_NUMBER, AWK_STRING, AWK_REGEX and AWK_STRNUM values are allowed. 721 * Any other type is rejected. We disallow AWK_UNDEFINED since that 722 * case would result in inferior performance. 723 */ 724 awk_bool_t (*api_create_value)(awk_ext_id_t id, awk_value_t *value, 725 awk_value_cookie_t *result); 726 727 /* 728 * Release the memory associated with a cookie from api_create_value. 729 * Please call this to free memory when the value is no longer needed. 730 */ 731 awk_bool_t (*api_release_value)(awk_ext_id_t id, awk_value_cookie_t vc); 732 733 /* Array management */ 734 735 /* 736 * Retrieve total number of elements in array. 737 * Returns false if some kind of error. 738 */ 739 awk_bool_t (*api_get_element_count)(awk_ext_id_t id, 740 awk_array_t a_cookie, size_t *count); 741 742 /* 743 * Return the value of an element - read only! 744 * Use set_array_element() to change it. 745 * Behavior for value and return is same as for api_get_argument 746 * and sym_lookup. 747 */ 748 awk_bool_t (*api_get_array_element)(awk_ext_id_t id, 749 awk_array_t a_cookie, 750 const awk_value_t *const index, 751 awk_valtype_t wanted, 752 awk_value_t *result); 753 754 /* 755 * Change (or create) element in existing array with 756 * index and value. 757 * 758 * ARGV and ENVIRON may not be updated. 759 */ 760 awk_bool_t (*api_set_array_element)(awk_ext_id_t id, awk_array_t a_cookie, 761 const awk_value_t *const index, 762 const awk_value_t *const value); 763 764 /* 765 * Remove the element with the given index. 766 * Returns true if removed or false if element did not exist. 767 */ 768 awk_bool_t (*api_del_array_element)(awk_ext_id_t id, 769 awk_array_t a_cookie, const awk_value_t* const index); 770 771 /* Create a new array cookie to which elements may be added. */ 772 awk_array_t (*api_create_array)(awk_ext_id_t id); 773 774 /* Clear out an array. */ 775 awk_bool_t (*api_clear_array)(awk_ext_id_t id, awk_array_t a_cookie); 776 777 /* 778 * Flatten out an array with type conversions as requested. 779 * This supersedes the earlier api_flatten_array function that 780 * did not allow the caller to specify the requested types. 781 * (That API is still available as a macro, defined below.) 782 */ 783 awk_bool_t (*api_flatten_array_typed)(awk_ext_id_t id, 784 awk_array_t a_cookie, 785 awk_flat_array_t **data, 786 awk_valtype_t index_type, awk_valtype_t value_type); 787 788 /* When done, delete any marked elements, release the memory. */ 789 awk_bool_t (*api_release_flattened_array)(awk_ext_id_t id, 790 awk_array_t a_cookie, 791 awk_flat_array_t *data); 792 793 /* 794 * Hooks to provide access to gawk's memory allocation functions. 795 * This ensures that memory passed between gawk and the extension 796 * is allocated and released by the same library. 797 */ 798 void *(*api_malloc)(size_t size); 799 void *(*api_calloc)(size_t nmemb, size_t size); 800 void *(*api_realloc)(void *ptr, size_t size); 801 void (*api_free)(void *ptr); 802 803 /* 804 * Obsolete function, should not be used. It remains only 805 * for binary compatibility. Any value it returns should be 806 * freed via api_free. 807 */ 808 void *(*api_get_mpfr)(awk_ext_id_t id); 809 810 /* 811 * Obsolete function, should not be used. It remains only 812 * for binary compatibility. Any value it returns should be 813 * freed via api_free. 814 */ 815 void *(*api_get_mpz)(awk_ext_id_t id); 816 817 /* 818 * Look up a file. If the name is NULL or name_len is 0, it returns 819 * data for the currently open input file corresponding to FILENAME 820 * (and it will not access the filetype argument, so that may be 821 * undefined). 822 * 823 * If the file is not already open, try to open it. 824 * 825 * The "filetype" argument should be one of: 826 * 827 * ">", ">>", "<", "|>", "|<", and "|&" 828 * 829 * If the file is not already open, and the fd argument is non-negative, 830 * gawk will use that file descriptor instead of opening the file 831 * in the usual way. 832 * 833 * If the fd is non-negative, but the file exists already, gawk 834 * ignores the fd and returns the existing file. It is the caller's 835 * responsibility to notice that the fd in the returned 836 * awk_input_buf_t does not match the requested value. 837 * 838 * Note that supplying a file descriptor is currently NOT supported 839 * for pipes. It should work for input, output, append, and two-way 840 * (coprocess) sockets. If the filetype is two-way, we assume that 841 * it is a socket! 842 * 843 * Note that in the two-way case, the input and output file descriptors 844 * may differ. To check for success, one must check that either of 845 * them matches. 846 * 847 * ibufp and obufp point at gawk's internal copies of the 848 * awk_input_buf_t and awk_output_t associated with the open 849 * file. Treat these data structures as read-only! 850 */ 851 awk_bool_t (*api_get_file)(awk_ext_id_t id, 852 const char *name, 853 size_t name_len, 854 const char *filetype, 855 int fd, 856 /* 857 * Return values (on success, one or both should 858 * be non-NULL): 859 */ 860 const awk_input_buf_t **ibufp, 861 const awk_output_buf_t **obufp); 862 863 /* Destroy an array. */ 864 awk_bool_t (*api_destroy_array)(awk_ext_id_t id, awk_array_t a_cookie); 865 } gawk_api_t; 866 867 #ifndef GAWK /* these are not for the gawk code itself! */ 868 /* 869 * Use these if you want to define "global" variables named api 870 * and ext_id to make the code a little easier to read. 871 * See the sample boilerplate code, below. 872 */ 873 #define do_lint (api->do_flags[gawk_do_lint]) 874 #define do_traditional (api->do_flags[gawk_do_traditional]) 875 #define do_profile (api->do_flags[gawk_do_profile]) 876 #define do_sandbox (api->do_flags[gawk_do_sandbox]) 877 #define do_debug (api->do_flags[gawk_do_debug]) 878 #define do_mpfr (api->do_flags[gawk_do_mpfr]) 879 #define do_csv (api->do_flags[gawk_do_csv]) 880 881 #define get_argument(count, wanted, result) \ 882 (api->api_get_argument(ext_id, count, wanted, result)) 883 #define set_argument(count, new_array) \ 884 (api->api_set_argument(ext_id, count, new_array)) 885 886 #define fatal api->api_fatal 887 #define nonfatal api->api_nonfatal 888 #define warning api->api_warning 889 #define lintwarn api->api_lintwarn 890 891 #define register_input_parser(parser) (api->api_register_input_parser(ext_id, parser)) 892 #define register_output_wrapper(wrapper) (api->api_register_output_wrapper(ext_id, wrapper)) 893 #define register_two_way_processor(processor) \ 894 (api->api_register_two_way_processor(ext_id, processor)) 895 896 #define update_ERRNO_int(e) (api->api_update_ERRNO_int(ext_id, e)) 897 #define update_ERRNO_string(str) \ 898 (api->api_update_ERRNO_string(ext_id, str)) 899 #define unset_ERRNO() (api->api_unset_ERRNO(ext_id)) 900 901 #define add_ext_func(ns, func) (api->api_add_ext_func(ext_id, ns, func)) 902 #define awk_atexit(funcp, arg0) (api->api_awk_atexit(ext_id, funcp, arg0)) 903 904 #define sym_lookup(name, wanted, result) \ 905 sym_lookup_ns("", name, wanted, result) 906 #define sym_update(name, value) \ 907 sym_update_ns("", name, value) 908 909 #define sym_lookup_ns(name_space, name, wanted, result) \ 910 (api->api_sym_lookup(ext_id, name_space, name, wanted, result)) 911 #define sym_update_ns(name_space, name, value) \ 912 (api->api_sym_update(ext_id, name_space, name, value)) 913 914 #define sym_lookup_scalar(scalar_cookie, wanted, result) \ 915 (api->api_sym_lookup_scalar(ext_id, scalar_cookie, wanted, result)) 916 #define sym_update_scalar(scalar_cookie, value) \ 917 (api->api_sym_update_scalar)(ext_id, scalar_cookie, value) 918 919 #define get_array_element(array, index, wanted, result) \ 920 (api->api_get_array_element(ext_id, array, index, wanted, result)) 921 922 #define set_array_element(array, index, value) \ 923 (api->api_set_array_element(ext_id, array, index, value)) 924 925 #define set_array_element_by_elem(array, elem) \ 926 (api->api_set_array_element(ext_id, array, & (elem)->index, & (elem)->value)) 927 928 #define del_array_element(array, index) \ 929 (api->api_del_array_element(ext_id, array, index)) 930 931 #define get_element_count(array, count_p) \ 932 (api->api_get_element_count(ext_id, array, count_p)) 933 934 #define create_array() (api->api_create_array(ext_id)) 935 936 #define destroy_array(array) (api->api_destroy_array(ext_id, array)) 937 938 #define clear_array(array) (api->api_clear_array(ext_id, array)) 939 940 #define flatten_array_typed(array, data, index_type, value_type) \ 941 (api->api_flatten_array_typed(ext_id, array, data, index_type, value_type)) 942 943 #define flatten_array(array, data) \ 944 flatten_array_typed(array, data, AWK_STRING, AWK_UNDEFINED) 945 946 #define release_flattened_array(array, data) \ 947 (api->api_release_flattened_array(ext_id, array, data)) 948 949 #define gawk_malloc(size) (api->api_malloc(size)) 950 #define gawk_calloc(nmemb, size) (api->api_calloc(nmemb, size)) 951 #define gawk_realloc(ptr, size) (api->api_realloc(ptr, size)) 952 #define gawk_free(ptr) (api->api_free(ptr)) 953 954 #define create_value(value, result) \ 955 (api->api_create_value(ext_id, value,result)) 956 957 #define release_value(value) \ 958 (api->api_release_value(ext_id, value)) 959 960 #define get_file(name, namelen, filetype, fd, ibuf, obuf) \ 961 (api->api_get_file(ext_id, name, namelen, filetype, fd, ibuf, obuf)) 962 963 /* These two are obsolete and should not be used. */ 964 #define get_mpfr_ptr() (api->api_get_mpfr(ext_id)) 965 #define get_mpz_ptr() (api->api_get_mpz(ext_id)) 966 967 #define register_ext_version(version) \ 968 (api->api_register_ext_version(ext_id, version)) 969 970 #define emalloc(pointer, type, size, message) \ 971 do { \ 972 if ((pointer = (type) gawk_malloc(size)) == 0) \ 973 fatal(ext_id, "%s: malloc of %d bytes failed", message, size); \ 974 } while(0) 975 976 #define ezalloc(pointer, type, size, message) \ 977 do { \ 978 if ((pointer = (type) gawk_calloc(1, size)) == 0) \ 979 fatal(ext_id, "%s: calloc of %d bytes failed", message, size); \ 980 } while(0) 981 982 #define erealloc(pointer, type, size, message) \ 983 do { \ 984 if ((pointer = (type) gawk_realloc(pointer, size)) == 0) \ 985 fatal(ext_id, "%s: realloc of %d bytes failed", message, size); \ 986 } while(0) 987 988 /* Constructor functions */ 989 990 /* r_make_string_type --- make a string or strnum or regexp value in result from the passed-in string */ 991 992 static inline awk_value_t * 993 r_make_string_type(const gawk_api_t *api, /* needed for emalloc */ 994 awk_ext_id_t ext_id, /* ditto */ 995 const char *string, 996 size_t length, 997 awk_bool_t duplicate, 998 awk_value_t *result, 999 awk_valtype_t val_type) 1000 { 1001 char *cp = NULL; 1002 1003 memset(result, 0, sizeof(*result)); 1004 1005 result->val_type = val_type; 1006 result->str_value.len = length; 1007 1008 if (duplicate) { 1009 emalloc(cp, char *, length + 1, "r_make_string"); 1010 memcpy(cp, string, length); 1011 cp[length] = '\0'; 1012 result->str_value.str = cp; 1013 } else { 1014 result->str_value.str = (char *) string; 1015 } 1016 1017 return result; 1018 } 1019 1020 /* r_make_string --- make a string value in result from the passed-in string */ 1021 1022 static inline awk_value_t * 1023 r_make_string(const gawk_api_t *api, /* needed for emalloc */ 1024 awk_ext_id_t ext_id, /* ditto */ 1025 const char *string, 1026 size_t length, 1027 awk_bool_t duplicate, 1028 awk_value_t *result) 1029 { 1030 return r_make_string_type(api, ext_id, string, length, duplicate, result, AWK_STRING); 1031 } 1032 1033 #define make_const_string(str, len, result) r_make_string(api, ext_id, str, len, awk_true, result) 1034 #define make_malloced_string(str, len, result) r_make_string(api, ext_id, str, len, awk_false, result) 1035 1036 #define make_const_regex(str, len, result) r_make_string_type(api, ext_id, str, len, awk_true, result, AWK_REGEX) 1037 #define make_malloced_regex(str, len, result) r_make_string_type(api, ext_id, str, len, awk_false, result, AWK_REGEX) 1038 1039 /* 1040 * Note: The caller may not create a STRNUM, but it can create a string that is 1041 * flagged as user input that MAY be a STRNUM. Gawk will decide whether it's a 1042 * STRNUM or a string by checking whether the string is numeric. 1043 */ 1044 #define make_const_user_input(str, len, result) r_make_string_type(api, ext_id, str, len, 1, result, AWK_STRNUM) 1045 #define make_malloced_user_input(str, len, result) r_make_string_type(api, ext_id, str, len, 0, result, AWK_STRNUM) 1046 1047 /* make_null_string --- make a null string value */ 1048 1049 static inline awk_value_t * 1050 make_null_string(awk_value_t *result) 1051 { 1052 memset(result, 0, sizeof(*result)); 1053 result->val_type = AWK_UNDEFINED; 1054 1055 return result; 1056 } 1057 1058 /* make_number --- make a number value in result */ 1059 1060 static inline awk_value_t * 1061 make_number(double num, awk_value_t *result) 1062 { 1063 result->val_type = AWK_NUMBER; 1064 result->num_value = num; 1065 result->num_type = AWK_NUMBER_TYPE_DOUBLE; 1066 return result; 1067 } 1068 1069 /* 1070 * make_number_mpz --- make an mpz number value in result. 1071 * The mpz_ptr must be from a call to get_mpz_ptr. 1072 */ 1073 1074 static inline awk_value_t * 1075 make_number_mpz(void *mpz_ptr, awk_value_t *result) 1076 { 1077 result->val_type = AWK_NUMBER; 1078 result->num_type = AWK_NUMBER_TYPE_MPZ; 1079 result->num_ptr = mpz_ptr; 1080 return result; 1081 } 1082 1083 /* 1084 * make_number_mpfr --- make an mpfr number value in result. 1085 * The mpfr_ptr must be from a call to get_mpfr_ptr. 1086 */ 1087 1088 static inline awk_value_t * 1089 make_number_mpfr(void *mpfr_ptr, awk_value_t *result) 1090 { 1091 result->val_type = AWK_NUMBER; 1092 result->num_type = AWK_NUMBER_TYPE_MPFR; 1093 result->num_ptr = mpfr_ptr; 1094 return result; 1095 } 1096 1097 /* make_bool --- make a bool value in result */ 1098 1099 static inline awk_value_t * 1100 make_bool(awk_bool_t boolval, awk_value_t *result) 1101 { 1102 result->val_type = AWK_BOOL; 1103 result->bool_value = boolval; 1104 return result; 1105 } 1106 1107 1108 /* 1109 * Each extension must define a function with this prototype: 1110 * 1111 * int dl_load(gawk_api_t *api_p, awk_ext_id_t id) 1112 * 1113 * The return value should be zero on failure and non-zero on success. 1114 * 1115 * For the macros to work, the function should save api_p in a global 1116 * variable named 'api' and save id in a global variable named 'ext_id'. 1117 * In addition, a global function pointer named 'init_func' should be 1118 * defined and set to either NULL or an initialization function that 1119 * returns non-zero on success and zero upon failure. 1120 */ 1121 1122 extern int dl_load(const gawk_api_t *const api_p, awk_ext_id_t id); 1123 1124 #if 0 1125 /* Boilerplate code: */ 1126 int plugin_is_GPL_compatible; 1127 1128 static gawk_api_t *const api; 1129 static awk_ext_id_t ext_id; 1130 static const char *ext_version = NULL; /* or ... = "some string" */ 1131 1132 static awk_ext_func_t func_table[] = { 1133 { "name", do_name, 1 }, 1134 /* ... */ 1135 }; 1136 1137 /* EITHER: */ 1138 1139 static awk_bool_t (*init_func)(void) = NULL; 1140 1141 /* OR: */ 1142 1143 static awk_bool_t 1144 init_my_extension(void) 1145 { 1146 ... 1147 } 1148 1149 static awk_bool_t (*init_func)(void) = init_my_extension; 1150 1151 dl_load_func(func_table, some_name, "name_space_in_quotes") 1152 #endif 1153 1154 #define dl_load_func(func_table, extension, name_space) \ 1155 int dl_load(const gawk_api_t *const api_p, awk_ext_id_t id) \ 1156 { \ 1157 size_t i, j; \ 1158 int errors = 0; \ 1159 \ 1160 api = api_p; \ 1161 ext_id = (void **) id; \ 1162 \ 1163 if (api->major_version != GAWK_API_MAJOR_VERSION \ 1164 || api->minor_version < GAWK_API_MINOR_VERSION) { \ 1165 fprintf(stderr, #extension ": version mismatch with gawk!\n"); \ 1166 fprintf(stderr, "\tmy version (API %d.%d), gawk version (API %d.%d)\n", \ 1167 GAWK_API_MAJOR_VERSION, GAWK_API_MINOR_VERSION, \ 1168 api->major_version, api->minor_version); \ 1169 exit(1); \ 1170 } \ 1171 \ 1172 check_mpfr_version(extension); \ 1173 \ 1174 /* load functions */ \ 1175 for (i = 0, j = sizeof(func_table) / sizeof(func_table[0]); i < j; i++) { \ 1176 if (func_table[i].name == NULL) \ 1177 break; \ 1178 if (! add_ext_func(name_space, & func_table[i])) { \ 1179 warning(ext_id, #extension ": could not add %s", \ 1180 func_table[i].name); \ 1181 errors++; \ 1182 } \ 1183 } \ 1184 \ 1185 if (init_func != NULL) { \ 1186 if (! init_func()) { \ 1187 warning(ext_id, #extension ": initialization function failed"); \ 1188 errors++; \ 1189 } \ 1190 } \ 1191 \ 1192 if (ext_version != NULL) \ 1193 register_ext_version(ext_version); \ 1194 \ 1195 return (errors == 0); \ 1196 } 1197 1198 #if defined __GNU_MP_VERSION && defined MPFR_VERSION_MAJOR 1199 #define check_mpfr_version(extension) do { \ 1200 if (api->gmp_major_version != __GNU_MP_VERSION \ 1201 || api->gmp_minor_version < __GNU_MP_VERSION_MINOR) { \ 1202 fprintf(stderr, #extension ": GMP version mismatch with gawk!\n"); \ 1203 fprintf(stderr, "\tmy version (%d, %d), gawk version (%d, %d)\n", \ 1204 __GNU_MP_VERSION, __GNU_MP_VERSION_MINOR, \ 1205 api->gmp_major_version, api->gmp_minor_version); \ 1206 exit(1); \ 1207 } \ 1208 if (api->mpfr_major_version != MPFR_VERSION_MAJOR \ 1209 || api->mpfr_minor_version < MPFR_VERSION_MINOR) { \ 1210 fprintf(stderr, #extension ": MPFR version mismatch with gawk!\n"); \ 1211 fprintf(stderr, "\tmy version (%d, %d), gawk version (%d, %d)\n", \ 1212 MPFR_VERSION_MAJOR, MPFR_VERSION_MINOR, \ 1213 api->mpfr_major_version, api->mpfr_minor_version); \ 1214 exit(1); \ 1215 } \ 1216 } while (0) 1217 #else 1218 #define check_mpfr_version(extension) /* nothing */ 1219 #endif 1220 1221 #endif /* GAWK */ 1222 1223 #ifdef __cplusplus 1224 } 1225 #endif /* C++ */ 1226 1227 #endif /* _GAWK_API_H */
