/*

 * gawkapi.h -- Definitions for use by extension functions calling into gawk.

 */

/*

 * Copyright (C) 2012-2018 the Free Software Foundation, Inc.

 *

 * This file is part of GAWK, the GNU implementation of the

 * AWK Programming Language.

 *

 * GAWK is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 3 of the License, or

 * (at your option) any later version.

 *

 * GAWK is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA

 */

/*

 * The following types and/or macros and/or functions are referenced

 * in this file.  For correct use, you must therefore include the

 * corresponding standard header file BEFORE including this file.

 *

 * FILE			- <stdio.h>

 * NULL			- <stddef.h>

 * memset(), memcpy()	- <string.h>

 * size_t		- <sys/types.h>

 * struct stat		- <sys/stat.h>

 *

 * Due to portability concerns, especially to systems that are not

 * fully standards-compliant, it is your responsibility to include

 * the correct files in the correct way. This requirement is necessary

 * in order to keep this file clean, instead of becoming a portability

 * hodge-podge as can be seen in the gawk source code.

 *

 * To pass reasonable integer values for ERRNO, you will also need to

 * include <errno.h>.

 */

#ifndef _GAWK_API_H

#define _GAWK_API_H

/*

 * General introduction:

 *

 * This API purposely restricts itself to ISO C 90 features.  In particular, no

 * bool, no // comments, no use of the restrict keyword, or anything else,

 * in order to provide maximal portability.

 *

 * Exception: the "inline" keyword is used below in the "constructor"

 * functions. If your compiler doesn't support it, you should either

 * -Dinline='' on your command line, or use the autotools and include a

 * config.h in your extensions.

 *

 * Additional important information:

 *

 * 1. ALL string values in awk_value_t objects need to come from api_malloc().

 * Gawk will handle releasing the storage if necessary.  This is slightly

 * awkward, in that you can't take an awk_value_t that you got from gawk

 * and reuse it directly, even for something that is conceptually pass

 * by value.

 *

 * 2. Due to gawk internals, after using sym_update() to install an array

 * into gawk, you have to retrieve the array cookie from the value

 * passed in to sym_update().  Like so:

 *

 *	new_array = create_array();

 *	val.val_type = AWK_ARRAY;

 *	val.array_cookie = new_array;

 *	sym_update("array", & val);	// install array in the symbol table

 *

 *	new_array = val.array_cookie;	// MUST DO THIS

 *

 *	// fill in new array with lots of subscripts and values

 *

 * Similarly, if installing a new array as a subarray of an existing

 * array, you must add the new array to its parent before adding any

 * elements to it.

 *

 * You must also retrieve the value of the array_cookie after the call

 * to set_element().

 *

 * Thus, the correct way to build an array is to work "top down".

 * Create the array, and immediately install it in gawk's symbol table

 * using sym_update(), or install it as an element in a previously

 * existing array using set_element().

 *

 * Thus the new array must ultimately be rooted in a global symbol. This is

 * necessary before installing any subarrays in it, due to gawk's

 * internal implementation.  Strictly speaking, this is required only

 * for arrays that will have subarrays as elements; however it is

 * a good idea to always do this.  This restriction may be relaxed

 * in a subsequent revision of the API.

 */

/* Allow use in C++ code.  */

#ifdef __cplusplus

extern "C" {

#endif

/* This is used to keep extensions from modifying certain fields in some structs. */

#ifdef GAWK

#define awk_const

#else

#define awk_const const

#endif

typedef enum awk_bool {

	awk_false = 0,

	awk_true

} awk_bool_t;	/* we don't use <stdbool.h> on purpose */

/*

 * If an input parser would like to specify the field positions in the input

 * record, it may populate an awk_fieldwidth_info_t structure to indicate

 * the location of each field. The use_chars boolean controls whether the

 * field lengths are specified in terms of bytes or potentially multi-byte

 * characters. Performance will be better if the values are supplied in

 * terms of bytes. The fields[0].skip value indicates how many bytes (or

 * characters) to skip before $1, and fields[0].len is the length of $1, etc.

 */

typedef struct {

	awk_bool_t	use_chars;	/* false ==> use bytes */

	size_t		nf;

	struct awk_field_info {

		size_t	skip;	/* amount to skip before field starts */

		size_t	len;	/* length of field */

	} fields[1];		/* actual dimension should be nf */

} awk_fieldwidth_info_t;

/*

 * This macro calculates the total struct size needed. This is useful when

 * calling malloc or realloc.

 */

#define awk_fieldwidth_info_size(NF) (sizeof(awk_fieldwidth_info_t) + \

			(((NF)-1) * sizeof(struct awk_field_info)))

/* The information about input files that input parsers need to know: */

typedef struct awk_input {

	const char *name;	/* filename */

	int fd;			/* file descriptor */

#define INVALID_HANDLE (-1)

	void *opaque;           /* private data for input parsers */

	/*

	 * The get_record function is called to read the next record of data.

	 *

	 * It should return the length of the input record or EOF, and it

	 * should set *out to point to the contents of $0. The rt_start

	 * and rt_len arguments should be used to return RT to gawk.

	 * If EOF is not returned, the parser must set *rt_len (and

	 * *rt_start if *rt_len is non-zero).

	 *

	 * Note that gawk will make a copy of the record in *out, so the

	 * parser is responsible for managing its own memory buffer.

	 * Similarly, gawk will make its own copy of RT, so the parser

	 * is also responsible for managing this memory.

	 *

	 * It is guaranteed that errcode is a valid pointer, so there is

	 * no need to test for a NULL value.  Gawk sets *errcode to 0,

	 * so there is no need to set it unless an error occurs.

	 *

	 * If an error does occur, the function should return EOF and set

	 * *errcode to a positive value.  In that case, if *errcode is greater

	 * than zero, gawk will automatically update the ERRNO variable based

	 * on the value of *errcode (e.g., setting *errcode = errno should do

	 * the right thing).

	 *

	 * If field_width is non-NULL, then *field_width will be initialized

	 * to NULL, and the function may set it to point to a structure

	 * supplying field width information to override the default

	 * gawk field parsing mechanism. Note that this structure will not

	 * be copied by gawk; it must persist at least until the next call

	 * to get_record or close_func. Note also that field_width will

	 * be NULL when getline is assigning the results to a variable, thus

	 * field parsing is not needed.

	 */

	int (*get_record)(char **out, struct awk_input *iobuf, int *errcode,

			char **rt_start, size_t *rt_len,

			const awk_fieldwidth_info_t **field_width);

	/*

	 * No argument prototype on read_func to allow for older systems

	 * whose headers are not up to date.

	 */

	ssize_t (*read_func)();

	/*

	 * The close_func is called to allow the parser to free private data.

	 * Gawk itself will close the fd unless close_func first sets it to

	 * INVALID_HANDLE.

	 */

	void (*close_func)(struct awk_input *iobuf);

	/* put last, for alignment. bleah */

	struct stat sbuf;       /* stat buf */

} awk_input_buf_t;

typedef struct awk_input_parser {

	const char *name;	/* name of parser */

	/*

	 * The can_take_file function should return true if the parser

	 * would like to parse this file.  It should not change any gawk

	 * state!

	 */

	awk_bool_t (*can_take_file)(const awk_input_buf_t *iobuf);

	/*

	 * If this parser is selected, then take_control_of will be called.

	 * It can assume that a previous call to can_take_file was successful,

	 * and no gawk state has changed since that call.  It should populate

	 * the awk_input_buf_t's get_record, close_func, and opaque values as needed.

	 * It should return true if successful.

	 */

	awk_bool_t (*take_control_of)(awk_input_buf_t *iobuf);

	awk_const struct awk_input_parser *awk_const next;	/* for use by gawk */

} awk_input_parser_t;

/*

 * Similar for output wrapper.

 */

/* First the data structure */

typedef struct awk_output_buf {

	const char *name;	/* name of output file */

	const char *mode;	/* mode argument to fopen */

	FILE *fp;		/* stdio file pointer */

	awk_bool_t redirected;	/* true if a wrapper is active */

	void *opaque;		/* for use by output wrapper */

	/*

	 * Replacement functions for I/O.  Just like the regular

	 * versions but also take the opaque pointer argument.

	 */

	size_t (*gawk_fwrite)(const void *buf, size_t size, size_t count,

				FILE *fp, void *opaque);

	int (*gawk_fflush)(FILE *fp, void *opaque);

	int (*gawk_ferror)(FILE *fp, void *opaque);

	int (*gawk_fclose)(FILE *fp, void *opaque);

} awk_output_buf_t;

/* Next the output wrapper registered with gawk */

typedef struct awk_output_wrapper {

	const char *name;	/* name of the wrapper */

	/*

	 * The can_take_file function should return true if the wrapper

	 * would like to process this file.  It should not change any gawk

	 * state!

	 */

	awk_bool_t (*can_take_file)(const awk_output_buf_t *outbuf);

	/*

	 * If this wrapper is selected, then take_control_of will be called.

	 * It can assume that a previous call to can_take_file was successful,

	 * and no gawk state has changed since that call.  It should populate

	 * the awk_output_buf_t function pointers and opaque pointer as needed.

	 * It should return true if successful.

	 */

	awk_bool_t (*take_control_of)(awk_output_buf_t *outbuf);

	awk_const struct awk_output_wrapper *awk_const next;  /* for use by gawk */

} awk_output_wrapper_t;

/* A two-way processor combines an input parser and an output wrapper. */

typedef struct awk_two_way_processor {

	const char *name;	/* name of the two-way processor */

	/*

	 * The can_take_file function should return true if the two-way

	 * processor would like to parse this file.  It should not change

	 * any gawk state!

	 */

	awk_bool_t (*can_take_two_way)(const char *name);

	/*

	 * If this processor is selected, then take_control_of will be called.

	 * It can assume that a previous call to can_take_file was successful,

	 * and no gawk state has changed since that call.  It should populate

	 * the awk_input_buf_t and awk_otuput_buf_t structures as needed.

	 * It should return true if successful.

	 */

	awk_bool_t (*take_control_of)(const char *name, awk_input_buf_t *inbuf,

					awk_output_buf_t *outbuf);

	awk_const struct awk_two_way_processor *awk_const next;  /* for use by gawk */

} awk_two_way_processor_t;

#define gawk_api_major_version 2

#define gawk_api_minor_version 0

/* Current version of the API. */

enum {

	GAWK_API_MAJOR_VERSION = gawk_api_major_version,

	GAWK_API_MINOR_VERSION = gawk_api_minor_version

};

/* A number of typedefs related to different types of values. */

/*

 * A mutable string. Gawk owns the memory pointed to if it supplied

 * the value. Otherwise, it takes ownership of the memory pointed to.

 *

 * The API deals exclusively with regular chars; these strings may

 * be multibyte encoded in the current locale's encoding and character

 * set. Gawk will convert internally to wide characters if necessary.

 *

 * Note that a string provided by gawk will always be terminated

 * with a '\0' character.

 */

typedef struct awk_string {

	char *str;	/* data */

	size_t len;	/* length thereof, in chars */

} awk_string_t;

enum AWK_NUMBER_TYPE {

	AWK_NUMBER_TYPE_DOUBLE,

	AWK_NUMBER_TYPE_MPFR,

	AWK_NUMBER_TYPE_MPZ

};

typedef struct awk_number {

	double d;	/* always populated in data received from gawk */

	enum AWK_NUMBER_TYPE type;

	void *ptr;	/* either NULL or mpfr_ptr or mpz_ptr */

} awk_number_t;

/* Arrays are represented as an opaque type. */

typedef void *awk_array_t;

/* Scalars can be represented as an opaque type. */

typedef void *awk_scalar_t;

/* Any value can be stored as a cookie. */

typedef void *awk_value_cookie_t;

/*

 * This tag defines the type of a value.

 *

 * Values are associated with regular variables and with array elements.

 * Since arrays can be multidimensional (as can regular variables)

 * it's valid to have a "value" that is actually an array.

 */

typedef enum {

	AWK_UNDEFINED,

	AWK_NUMBER,

	AWK_STRING,

	AWK_REGEX,

	AWK_STRNUM,

	AWK_ARRAY,

	AWK_SCALAR,		/* opaque access to a variable */

	AWK_VALUE_COOKIE	/* for updating a previously created value */

} awk_valtype_t;

/*

 * An awk value. The val_type tag indicates what

 * is in the union.

 */

typedef struct awk_value {

	awk_valtype_t	val_type;

	union {

		awk_string_t	s;

		awk_number_t	n;

		awk_array_t	a;

		awk_scalar_t	scl;

		awk_value_cookie_t vc;

	} u;

#define str_value	u.s

#define strnum_value	str_value

#define regex_value	str_value

#define num_value	u.n.d

#define num_type	u.n.type

#define num_ptr		u.n.ptr

#define array_cookie	u.a

#define scalar_cookie	u.scl

#define value_cookie	u.vc

} awk_value_t;

/*

 * A "flattened" array element. Gawk produces an array of these

 * inside the awk_flat_array_t.

 * ALL memory pointed to belongs to gawk. Individual elements may

 * be marked for deletion. New elements must be added individually,

 * one at a time, using the separate API for that purpose.

 */

typedef struct awk_element {

	/* convenience linked list pointer, not used by gawk */

	struct awk_element *next;

	enum {

		AWK_ELEMENT_DEFAULT = 0,	/* set by gawk */

		AWK_ELEMENT_DELETE = 1		/* set by extension if

						   should be deleted */

	} flags;

	awk_value_t	index;

	awk_value_t	value;

} awk_element_t;

/*

 * A "flattened" array. See the description above for how

 * to use the elements contained herein.

 */

typedef struct awk_flat_array {

	awk_const void *awk_const opaque1;	/* private data for use by gawk */

	awk_const void *awk_const opaque2;	/* private data for use by gawk */

	awk_const size_t count;			/* how many elements */

	awk_element_t elements[1];		/* will be extended */

} awk_flat_array_t;

/*

 * A record describing an extension function. Upon being

 * loaded, the extension should pass in one of these to gawk for

 * each C function.

 *

 * Each called function must fill in the result with either a scalar

 * (number, string, or regex). Gawk takes ownership of any string memory.

 *

 * The called function must return the value of `result'.

 * This is for the convenience of the calling code inside gawk.

 *

 * Each extension function may decide what to do if the number of

 * arguments isn't what it expected.  Following awk functions, it

 * is likely OK to ignore extra arguments.

 *

 * 'min_required_args' indicates how many arguments MUST be passed.

 * The API will throw a fatal error if not enough are passed.

 *

 * 'max_expected_args' is more benign; if more than that are passed,

 * the API prints a lint message (IFF lint is enabled, of course).

 *

 * In any case, the extension function itself need not compare the

 * actual number of arguments passed to those two values if it does

 * not want to.

 */

typedef struct awk_ext_func {

	const char *name;

	awk_value_t *(*const function)(int num_actual_args,

					awk_value_t *result,

					struct awk_ext_func *finfo);

	const size_t max_expected_args;

	const size_t min_required_args;

	awk_bool_t suppress_lint;

	void *data;		/* opaque pointer to any extra state */

} awk_ext_func_t;

typedef void *awk_ext_id_t;	/* opaque type for extension id */

/*

 * The API into gawk. Lots of functions here. We hope that they are

 * logically organized.

 */

typedef struct gawk_api {

	/* First, data fields. */

	/* These are what gawk thinks the API version is. */

	awk_const int major_version;

	awk_const int minor_version;

	/* GMP/MPFR versions, if extended-precision is available */

	awk_const int gmp_major_version;

	awk_const int gmp_minor_version;

	awk_const int mpfr_major_version;

	awk_const int mpfr_minor_version;

	/*

	 * These can change on the fly as things happen within gawk.

	 * Currently only do_lint is prone to change, but we reserve

	 * the right to allow the others to do so also.

	 */

#define DO_FLAGS_SIZE	6

	awk_const int do_flags[DO_FLAGS_SIZE];

/* Use these as indices into do_flags[] array to check the values */

#define gawk_do_lint		0

#define gawk_do_traditional	1

#define gawk_do_profile		2

#define gawk_do_sandbox		3

#define gawk_do_debug		4

#define gawk_do_mpfr		5

	/* Next, registration functions: */

	/*

	 * Add a function to the interpreter, returns true upon success. 

	 * Gawk does not modify what func points to, but the extension

	 * function itself receives this pointer and can modify what it

	 * points to, thus it's not const.

	 */

	awk_bool_t (*api_add_ext_func)(awk_ext_id_t id, const char *name_space,

			awk_ext_func_t *func);

	/* Register an input parser; for opening files read-only */

	void (*api_register_input_parser)(awk_ext_id_t id,

					awk_input_parser_t *input_parser);

	/* Register an output wrapper, for writing files */

	void (*api_register_output_wrapper)(awk_ext_id_t id,

					awk_output_wrapper_t *output_wrapper);

	/* Register a processor for two way I/O */

	void (*api_register_two_way_processor)(awk_ext_id_t id,

				awk_two_way_processor_t *two_way_processor);

	/*

	 * Add an exit call back.

	 *

	 * arg0 is a private data pointer for use by the extension;

	 * gawk saves it and passes it into the function pointed

	 * to by funcp at exit.

	 *

	 * Exit callback functions are called in LIFO order.

	 */

	void (*api_awk_atexit)(awk_ext_id_t id,

			void (*funcp)(void *data, int exit_status),

			void *arg0);

	/* Register a version string for this extension with gawk. */

	void (*api_register_ext_version)(awk_ext_id_t id, const char *version);

	/* Functions to print messages */

	void (*api_fatal)(awk_ext_id_t id, const char *format, ...);

	void (*api_warning)(awk_ext_id_t id, const char *format, ...);

	void (*api_lintwarn)(awk_ext_id_t id, const char *format, ...);

	void (*api_nonfatal)(awk_ext_id_t id, const char *format, ...);

	/* Functions to update ERRNO */

	void (*api_update_ERRNO_int)(awk_ext_id_t id, int errno_val);

	void (*api_update_ERRNO_string)(awk_ext_id_t id, const char *string);

	void (*api_unset_ERRNO)(awk_ext_id_t id);

	/*

	 * All of the functions that return a value from inside gawk

	 * (get a parameter, get a global variable, get an array element)

	 * behave in the same way.

	 *

	 * For a function parameter, the return is false if the argument

	 * count is out of range, or if the actual paramater does not match

	 * what is specified in wanted. In that case,  result->val_type

	 * will hold the actual type of what was passed.

	 *

	 * Similarly for symbol table access to variables and array elements,

	 * the return is false if the actual variable or array element does

	 * not match what was requested, and result->val_type will hold

	 * the actual type.

	Table entry is type returned:

	                        +-------------------------------------------------------+

	                        |                   Type of Actual Value:               |

	                        +--------+--------+--------+--------+-------+-----------+

	                        | String | Strnum | Number | Regex  | Array | Undefined |

	+-----------+-----------+--------+--------+--------+--------+-------+-----------+

	|           | String    | String | String | String | String | false | false     |

	|           +-----------+--------+--------+--------+--------+-------+-----------+

	|           | Strnum    | false  | Strnum | Strnum | false  | false | false     |

	|           +-----------+--------+--------+--------+--------+-------+-----------+

	|           | Number    | Number | Number | Number | false  | false | false     |

	|           +-----------+--------+--------+--------+--------+-------+-----------+

	|           | Regex     | false  | false  | false  | Regex  | false | false     |

	|           +-----------+--------+--------+--------+--------+-------+-----------+

	|   Type    | Array     | false  | false  | false  | false  | Array | false     |

	| Requested +-----------+--------+--------+--------+--------+-------+-----------+

	|           | Scalar    | Scalar | Scalar | Scalar | Scalar | false | false     |

	|           +-----------+--------+--------+--------+--------+-------+-----------+

	|           | Undefined | String | Strnum | Number | Regex  | Array | Undefined |

	|           +-----------+--------+--------+--------+--------+-------+-----------+

	|           | Value     | false  | false  | false  | false  | false | false     |

	|           | Cookie    |        |        |        |        |       |           |

	+-----------+-----------+--------+--------+--------+--------+-------+-----------+

	*/

	/* Functions to handle parameters passed to the extension. */

	/*

	 * Get the count'th paramater, zero-based.

	 * Returns false if count is out of range, or if actual paramater

	 * does not match what is specified in wanted. In that case,

	 * result->val_type is as described above.

	 */

	awk_bool_t (*api_get_argument)(awk_ext_id_t id, size_t count,

					  awk_valtype_t wanted,

					  awk_value_t *result);

	/*

	 * Convert a parameter that was undefined into an array

	 * (provide call-by-reference for arrays).  Returns false

	 * if count is too big, or if the argument's type is

	 * not undefined.

	 */

	awk_bool_t (*api_set_argument)(awk_ext_id_t id,

					size_t count,

					awk_array_t array);

	/*

	 * Symbol table access:

	 * 	- Read-only access to special variables (NF, etc.)

	 * 	- One special exception: PROCINFO.

	 *	- Use sym_update() to change a value, including from UNDEFINED

	 *	  to scalar or array.

	 */

	/*

	 * Lookup a variable, fill in value. No messing with the value

	 * returned.

	 * Returns false if the variable doesn't exist or if the wrong type

	 * was requested.  In the latter case, vaule->val_type will have

	 * the real type, as described above.

	 *

	 * 	awk_value_t val;

	 * 	if (! api->sym_lookup(id, name, wanted, & val))

	 * 		error_code_here();

	 *	else {

	 *		// safe to use val

	 *	}

	 */

	awk_bool_t (*api_sym_lookup)(awk_ext_id_t id,

				const char *name,

				awk_valtype_t wanted,

				awk_value_t *result);

	/*

	 * Update a value. Adds it to the symbol table if not there.

	 * Changing types (scalar <--> array) is not allowed.

	 * In fact, using this to update an array is not allowed, either.

	 * Such an attempt returns false.

	 */

	awk_bool_t (*api_sym_update)(awk_ext_id_t id,

				const char *name,

				awk_value_t *value);

	/*

	 * A ``scalar cookie'' is an opaque handle that provide access

	 * to a global variable or array. It is an optimization that

	 * avoids looking up variables in gawk's symbol table every time

	 * access is needed.

	 *

	 * This function retrieves the current value of a scalar cookie.

	 * Once you have obtained a scalar_cookie using sym_lookup, you can

	 * use this function to get its value more efficiently.

	 *

	 * Return will be false if the value cannot be retrieved.

	 *

	 * Flow is thus

	 *	awk_value_t val;

	 * 	awk_scalar_t cookie;

	 * 	api->sym_lookup(id, "variable", AWK_SCALAR, & val);	// get the cookie

	 *	cookie = val.scalar_cookie;

	 *	...

	 *	api->sym_lookup_scalar(id, cookie, wanted, & val);	// get the value

	 */

	awk_bool_t (*api_sym_lookup_scalar)(awk_ext_id_t id,

				awk_scalar_t cookie,

				awk_valtype_t wanted,

				awk_value_t *result);

	/*

	 * Update the value associated with a scalar cookie.

	 * Flow is

	 * 	sym_lookup with wanted == AWK_SCALAR

	 * 	if returns false

	 * 		sym_update with real initial value to install it

	 * 		sym_lookup again with AWK_SCALAR

	 *	else

	 *		use the scalar cookie

	 *

	 * Return will be false if the new value is not one of

	 * AWK_STRING, AWK_NUMBER, AWK_REGEX.

	 *

	 * Here too, the built-in variables may not be updated.

	 */

	awk_bool_t (*api_sym_update_scalar)(awk_ext_id_t id,

				awk_scalar_t cookie, awk_value_t *value);

	/* Cached values */

	/*

	 * Create a cached string,regex, or numeric value for efficient later

	 * assignment. This improves performance when you want to assign

	 * the same value to one or more variables repeatedly.  Only

	 * AWK_NUMBER, AWK_STRING, AWK_REGEX and AWK_STRNUM values are allowed.

	 * Any other type is rejected.  We disallow AWK_UNDEFINED since that

	 * case would result in inferior performance.

	 */

	awk_bool_t (*api_create_value)(awk_ext_id_t id, awk_value_t *value,

		    awk_value_cookie_t *result);

	/*

	 * Release the memory associated with a cookie from api_create_value.

	 * Please call this to free memory when the value is no longer needed.

	 */

	awk_bool_t (*api_release_value)(awk_ext_id_t id, awk_value_cookie_t vc);

	/* Array management */

	/*

	 * Retrieve total number of elements in array.

	 * Returns false if some kind of error.

	 */

	awk_bool_t (*api_get_element_count)(awk_ext_id_t id,

			awk_array_t a_cookie, size_t *count);

	/*

	 * Return the value of an element - read only!

	 * Use set_array_element() to change it.

	 * Behavior for value and return is same as for api_get_argument

	 * and sym_lookup.

	 */

	awk_bool_t (*api_get_array_element)(awk_ext_id_t id,

			awk_array_t a_cookie,

			const awk_value_t *const index,

			awk_valtype_t wanted,

			awk_value_t *result);

	/*

	 * Change (or create) element in existing array with

	 * index and value.

	 *

	 * ARGV and ENVIRON may not be updated.

	 */

	awk_bool_t (*api_set_array_element)(awk_ext_id_t id, awk_array_t a_cookie,

					const awk_value_t *const index,

					const awk_value_t *const value);

	/*

	 * Remove the element with the given index.

	 * Returns true if removed or false if element did not exist.

	 */

	awk_bool_t (*api_del_array_element)(awk_ext_id_t id,

			awk_array_t a_cookie, const awk_value_t* const index);

	/* Create a new array cookie to which elements may be added. */

	awk_array_t (*api_create_array)(awk_ext_id_t id);

	/* Clear out an array. */

	awk_bool_t (*api_clear_array)(awk_ext_id_t id, awk_array_t a_cookie);

	/*

	 * Flatten out an array with type conversions as requested.

	 * This supersedes the earlier api_flatten_array function that

	 * did not allow the caller to specify the requested types.

	 * (That API is still available as a macro, defined below.)

	 */

	awk_bool_t (*api_flatten_array_typed)(awk_ext_id_t id,

			awk_array_t a_cookie,

			awk_flat_array_t **data,

			awk_valtype_t index_type, awk_valtype_t value_type);

	/* When done, delete any marked elements, release the memory. */

	awk_bool_t (*api_release_flattened_array)(awk_ext_id_t id,

			awk_array_t a_cookie,

			awk_flat_array_t *data);

	/*

	 * Hooks to provide access to gawk's memory allocation functions.

	 * This ensures that memory passed between gawk and the extension

	 * is allocated and released by the same library.

	 */

	void *(*api_malloc)(size_t size);

	void *(*api_calloc)(size_t nmemb, size_t size);

	void *(*api_realloc)(void *ptr, size_t size);

	void (*api_free)(void *ptr);

	/*

	 * A function that returns mpfr data should call this function

	 * to allocate and initialize an mpfr_ptr for use in an

	 * awk_value_t structure that will be handed to gawk.

	 */

	void *(*api_get_mpfr)(awk_ext_id_t id);

	/*

	 * A function that returns mpz data should call this function

	 * to allocate and initialize an mpz_ptr for use in an

	 * awk_value_t structure that will be handed to gawk.

	 */

	void *(*api_get_mpz)(awk_ext_id_t id);

        /*

	 * Look up a file.  If the name is NULL or name_len is 0, it returns

	 * data for the currently open input file corresponding to FILENAME

	 * (and it will not access the filetype argument, so that may be

	 * undefined).

	 *

	 * If the file is not already open, try to open it.

	 *

	 * The "filetype" argument should be one of:

	 *

	 *    ">", ">>", "<", "|>", "|<", and "|&"

	 *

	 * If the file is not already open, and the fd argument is non-negative,

	 * gawk will use that file descriptor instead of opening the file

	 * in the usual way.

	 *

	 * If the fd is non-negative, but the file exists already, gawk

	 * ignores the fd and returns the existing file.  It is the caller's

	 * responsibility to notice that the fd in the returned

	 * awk_input_buf_t does not match the requested value.

	 *

	 * Note that supplying a file descriptor is currently NOT supported

	 * for pipes. It should work for input, output, append, and two-way

	 * (coprocess) sockets.  If the filetype is two-way, we assume that

	 * it is a socket!

	 *

	 * Note that in the two-way case, the input and output file descriptors

	 * may differ.  To check for success, one must check that either of

	 * them matches.

	 *

	 * ibufp and obufp point at gawk's internal copies of the

	 * awk_input_buf_t and awk_output_t associated with the open

	 * file.  Treat these data structures as read-only!

	 */

	awk_bool_t (*api_get_file)(awk_ext_id_t id,

			const char *name,

			size_t name_len,

			const char *filetype,

			int fd,

			/*

			 * Return values (on success, one or both should

			 * be non-NULL):

			 */

			const awk_input_buf_t **ibufp,

			const awk_output_buf_t **obufp);

} gawk_api_t;

#ifndef GAWK	/* these are not for the gawk code itself! */

/*

 * Use these if you want to define "global" variables named api

 * and ext_id to make the code a little easier to read.

 * See the sample boilerplate code, below.

 */

#define do_lint		(api->do_flags[gawk_do_lint])

#define do_traditional	(api->do_flags[gawk_do_traditional])

#define do_profile	(api->do_flags[gawk_do_profile])

#define do_sandbox	(api->do_flags[gawk_do_sandbox])

#define do_debug	(api->do_flags[gawk_do_debug])

#define do_mpfr		(api->do_flags[gawk_do_mpfr])

#define get_argument(count, wanted, result) \

	(api->api_get_argument(ext_id, count, wanted, result))

#define set_argument(count, new_array) \

	(api->api_set_argument(ext_id, count, new_array))

#define fatal		api->api_fatal

#define nonfatal	api->api_nonfatal

#define warning		api->api_warning

#define lintwarn	api->api_lintwarn

#define register_input_parser(parser)	(api->api_register_input_parser(ext_id, parser))

#define register_output_wrapper(wrapper) (api->api_register_output_wrapper(ext_id, wrapper))

#define register_two_way_processor(processor) \

	(api->api_register_two_way_processor(ext_id, processor))

#define update_ERRNO_int(e)	(api->api_update_ERRNO_int(ext_id, e))

#define update_ERRNO_string(str) \

	(api->api_update_ERRNO_string(ext_id, str))

#define unset_ERRNO()	(api->api_unset_ERRNO(ext_id))

#define add_ext_func(ns, func)	(api->api_add_ext_func(ext_id, ns, func))

#define awk_atexit(funcp, arg0)	(api->api_awk_atexit(ext_id, funcp, arg0))

#define sym_lookup(name, wanted, result) \

	(api->api_sym_lookup(ext_id, name, wanted, result))

#define sym_lookup_scalar(scalar_cookie, wanted, result) \

	(api->api_sym_lookup_scalar(ext_id, scalar_cookie, wanted, result))

#define sym_update(name, value) \

	(api->api_sym_update(ext_id, name, value))

#define sym_update_scalar(scalar_cookie, value) \

	(api->api_sym_update_scalar)(ext_id, scalar_cookie, value)

#define get_array_element(array, index, wanted, result) \

	(api->api_get_array_element(ext_id, array, index, wanted, result))