Appendix B  All Pads Base Types

This appendix gives the full set of signatures for the read, write, format, and accumulation functions for each base type that is part of the standard Pads distribution. It also describes how read behavior differs with different setting for the read mask, as well as error behavior for each possible error that can occur during reading.

This information is also available in the type-specific include files which can be found under the padsc/include/ptypes directory.

B.1  Counting: Character encodings

/* ================================================================================
 * CHAR COUNTING FUNCTIONS
 *
 * DEFAULT                     ASCII                       EBCDIC
 * ————————–  ————————–  ————————
 * PcountX_read                Pa_countX_read              Pe_countX_read
 * PcountXtoY                  Pa_countXtoY_read           Pe_countXtoY_read
 *
 * countX counts occurrences of char x between the current IO cursor
 * and the first EOR or EOF, while countXtoY counts occurrences of x
 * between the current IO cursor and the first occurrence of char y.
 * x and y are always specified as ASCII chars.  They are converted to
 * EBCDIC if the EBCDIC form is used or if the DEFAULT form is used
 * and pads->disc->def->charset is Pcharset_EBCDIC.
 *
 * If parameter count_max is non-zero, then the count functions also
 * stop counting after scanning count_max characters, in which case an
 * error is returned.  If the IO discipline is not record-based and
 * count_max is zero, an error is returned immediately: you *must*
 * specify a count_max > 0 when using an IO discipline that has no
 * records.
 */

/*
 * For countX, if param eor_required is non-zero, then encountering EOF
 * before EOR produces an error.
 *
 * These functions do not change the IO cursor position.
 *
 * countX outcomes:
 *   1. IO cursor is already at EOF and eor_required is non-zero:
 *     + pd->loc.b/e set to EOF ’location’
 *     + if P_Test_NotIgnore(*m), pd->errCode set to P_AT_EOF,
 *         pd->nerr set to 1, and an error is reported
 *     + P_ERR returned   
 *   2. EOF is encountered before EOR and eor_required is non-zero:
 *     + pd->loc.b/e set to current IO cursor location
 *     + if P_Test_NotIgnore(*m), pd->errCode set to P_EOF_BEFORE_EOR,
 *         pd->nerr set to 1, and an error is reported
 *     + P_ERR returned
 *   3. count_max is > 0 and count_max limit is reached before x
 *       or EOR or EOF:
 *     + pd->loc.b/e set to current IO cursor location
 *     + if P_Test_NotIgnore(*m), pd->errCode set to P_COUNT_MAX_LIMIT,
 *         pd->nerr set to 1, and an error is reported
 *     + P_ERR returned
 *   4. EOR is encountered, or EOF is encounterd and eor_required is zero:
 *     + (*res_out) is set to the number of occurrences of x from the
 *        IO cursor to EOR/EOF
 *     + P_OK returned
 */

/*
 * countXtoY outcomes:
 *   1. IO cursor is already at EOF
 *     + pd->loc.b/e set to EOF ’location’
 *     + if P_Test_NotIgnore(*m), pd->errCode set to P_AT_EOF,
 *         pd->nerr set to 1, and an error is reported
 *     + P_ERR returned   
 *   2. y is not found before EOR or EOF is hit
 *     + pd->loc.b/e set to current IO cursor location
 *     + if P_Test_NotIgnore(*m), pd->errCode set to
 *         P_CHAR_LIT_NOT_FOUND, pd->nerr set to 1,
 *         and an error is reported
 *     + P_ERR returned
 *   3. y is not found and count_max > 0 and count_max limit is hit 
 *     + pd->loc.b/e set to current IO cursor location
 *     + if P_Test_NotIgnore(*), pd->errCode set to P_COUNT_MAX_LIMIT,
 *         pd->nerr set to 1, and an error is reported
 *     P_ERR returned
 *   4. Char y is found
 *     + (*res_out) is set to the number of occurrences of x
 *       from the IO cursor to first y
 *     + P_OK returned
 */

Perror_t Pa_countX_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Pint32 *res_out,
                    Puint8 x, int eor_required, size_t count_max
                    );

Perror_t Pa_countXtoY_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Pint32 *res_out,
                    Puint8 x, Puint8 y, size_t count_max
                    );

Perror_t Pe_countX_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Pint32 *res_out,
                    Puint8 x, int eor_required, size_t count_max
                    );

Perror_t Pe_countXtoY_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Pint32 *res_out,
                    Puint8 x, Puint8 y, size_t count_max
                    );

Perror_t PcountX_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Pint32 *res_out,
                    Puint8 x, int eor_required, size_t count_max
                    );

Perror_t PcountXtoY_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Pint32 *res_out,
                    Puint8 x, Puint8 y, size_t count_max
                    );

ssize_t PcountX_write2io(P_t *pads, Sfio_t *io, Puint8 x, int eor_required,
                    size_t count_max, Pbase_pd *pd, Pint32 *val
                    );

ssize_t PcountX_write2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    Puint8 x, int eor_required, size_t count_max, Pbase_pd *pd,
                    Pint32 *val
                    );

ssize_t PcountXtoY_write2io(P_t *pads, Sfio_t *io, Puint8 x, Puint8 y,
                    size_t count_max, Pbase_pd *pd, Pint32 *val
                    );

ssize_t PcountXtoY_write2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    Puint8 x, Puint8 y, size_t count_max, Pbase_pd *pd, Pint32 *val
                    );

ssize_t PcountX_write_xml_2io(P_t *pads, Sfio_t *io, Puint8 x, int eor_required,
                    size_t count_max, Pbase_pd *pd, Pint32 *val, const char *tag,
                    int indent
                    );

ssize_t PcountX_write_xml_2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    Puint8 x, int eor_required, size_t count_max, Pbase_pd *pd,
                    Pint32 *val, const char *tag, int indent
                    );

ssize_t PcountXtoY_write_xml_2io(P_t *pads, Sfio_t *io, Puint8 x, Puint8 y,
                    size_t count_max, Pbase_pd *pd, Pint32 *val, const char *tag,
                    int indent
                    );

ssize_t PcountXtoY_write_xml_2buf(P_t *pads, Pbyte *buf, size_t buf_len,
                    int *buf_full, Puint8 x, Puint8 y, size_t count_max, Pbase_pd *pd,
                    Pint32 *val, const char *tag, int indent
                    );

B.2  Chars: Character encodings

/* ================================================================================
 * READ
 */

/* ================================================================================
 * CHAR READ FUNCTIONS
 * 
 * DEFAULT                   ASCII                     EBCDIC
 * ————————  ————————  —————————-
 * Pchar_read                Pa_char_read              Pe_char_read
 *
 * Cases:
 *  (1) A character is not available:
 *        + pd->loc set to the current IO position
 *        + if P_Test_NotIgnore(*m), pd->errCode is set to
 *            P_WIDTH_NOT_AVAILABLE, pd->nerr is set to 1,
 *            and an error is reported
 *        + the IO cursor is not advanced
 *        + P_ERR is returned
 *  (2) A character is available and P_Test_NotSet(*m)
 *        + the IO cursor is advanced by 1 byte
 *        + P_OK is returned
 *  (3) A character is available and P_Test_Set(*m)
 *        + (*c_out) is set to the ASCII equivalent of the character, where
 *             a conversion fom EBCDIC to ASCII occurs if the EBCDIC form is
 *             used or if the DEFAULT form is used and
 *             pads->disc->def_charset is Pcharset_EBCDIC.
 *        + the IO cursor is advanced by 1 byte
 *        + P_OK is returned
 */

Perror_t Pa_char_read(P_t *pads,const Pbase_m *m,Pbase_pd *pd,Pchar *c_out);

Perror_t Pe_char_read(P_t *pads,const Pbase_m *m,Pbase_pd *pd,Pchar *c_out);

Perror_t Pchar_read(P_t *pads,const Pbase_m *m,Pbase_pd *pd,Pchar *c_out);

/* ================================================================================
 * WRITE
 */

/* ================================================================================
 * CHAR WRITE FUNCTIONS
 * DEFAULT                     ASCII                        EBCDIC
 * ————————–  —————————  ———————–
 * Pchar_write2io              Pa_char_write2io             Pe_char_write2io
 *
 * Pchar_write2buf             Pa_char_write2buf            Pe_char_write2buf
 */

ssize_t Pa_char_write2io(P_t *pads,Sfio_t *io,Pbase_pd *pd,Pchar *c);

ssize_t Pa_char_write2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    Pbase_pd *pd, Pchar *c
                    );

ssize_t Pa_char_write_xml_2io(P_t *pads, Sfio_t *io, Pbase_pd *pd, Pchar *c,
                    const char *tag, int indent
                    );

ssize_t Pa_char_write_xml_2buf(P_t *pads, Pbyte *buf, size_t buf_len,
                    int *buf_full, Pbase_pd *pd, Pchar *c, const char *tag,
                    int indent
                    );

ssize_t Pe_char_write2io(P_t *pads,Sfio_t *io,Pbase_pd *pd,Pchar *c);

ssize_t Pe_char_write2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    Pbase_pd *pd, Pchar *c
                    );

ssize_t Pe_char_write_xml_2io(P_t *pads, Sfio_t *io, Pbase_pd *pd, Pchar *c,
                    const char *tag, int indent
                    );

ssize_t Pe_char_write_xml_2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    Pbase_pd *pd, Pchar *c, const char *tag, int indent
                    );

ssize_t Pchar_write2io(P_t *pads,Sfio_t *io,Pbase_pd *pd,Pchar *c);

ssize_t Pchar_write2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    Pbase_pd *pd, Pchar *c
                    );

ssize_t Pchar_write_xml_2io(P_t *pads, Sfio_t *io, Pbase_pd *pd, Pchar *c,
                    const char *tag, int indent
                    );

ssize_t Pchar_write_xml_2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    Pbase_pd *pd, Pchar *c, const char *tag, int indent
                    );

ssize_t Pa_char_fmt2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    int *requested_out, const char *delims, Pbase_m *m, Pbase_pd *pd,
                    Pchar *rep
                    );

ssize_t Pa_char_fmt2buf_final(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    int *requested_out, const char *delims, Pbase_m *m, Pbase_pd *pd,
                    Pchar *rep
                    );

ssize_t Pa_char_fmt2io(P_t *pads, Sfio_t *io, int *requested_out, const char *delims,
                    Pbase_m *m, Pbase_pd *pd, Pchar *rep
                    );

ssize_t Pe_char_fmt2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    int *requested_out, const char *delims, Pbase_m *m, Pbase_pd *pd,
                    Pchar *rep
                    );

ssize_t Pe_char_fmt2buf_final(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    int *requested_out, const char *delims, Pbase_m *m, Pbase_pd *pd,
                    Pchar *rep
                    );

ssize_t Pe_char_fmt2io(P_t *pads, Sfio_t *io, int *requested_out, const char *delims,
                    Pbase_m *m, Pbase_pd *pd, Pchar *rep
                    );

ssize_t Pchar_fmt2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    int *requested_out, const char *delims, Pbase_m *m, Pbase_pd *pd,
                    Pchar *rep
                    );

ssize_t Pchar_fmt2buf_final(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    int *requested_out, const char *delims, Pbase_m *m, Pbase_pd *pd,
                    Pchar *rep
                    );

ssize_t Pchar_fmt2io(P_t *pads, Sfio_t *io, int *requested_out, const char *delims,
                    Pbase_m *m, Pbase_pd *pd, Pchar *rep
                    );

B.3  Strings: Character encodings

/* ================================================================================
 * READ
 */

/* ================================================================================
 * STRING READ FUNCTIONS
 *
 * DEFAULT                      ASCII                          EBCDIC
 * ————————–  —————————–  ——————-
 * Pstring_FW_read             Pa_string_FW_read              Pe_string_FW_read
 * Pstring_read                Pa_string_read                 Pe_string_read
 * Pstring_ME_read             Pa_string_ME_read              Pe_string_ME_read
 * Pstring_CME_read            Pa_string_CME_read             Pe_string_CME_read
 * Pstring_SE_read             Pa_string_SE_read              Pe_string_SE_read
 * Pstring_CSE_read            Pa_string_CSE_read             Pe_string_CSE_read
 *
 * The string read functions each has a different way of specifying
 * the extent of the string:
 *   + all string_FW_read functions specify a fixed width.
 *     N.B.: width zero is allowed: the result is an empty string
 *       (and the IO cursor does not move)
 *   + all string_read functions specify a single stop character.
 *       if 0 (NULL) is used, then this will match a NULL in the data,
 *       and eor/eof will ALSO successfully terminate the string 
 *   + all string_ME_read and string_CME_read functions specify a
 *       Match Expression (string includes all chars that match)
 *   + all string_SE_read and string_CSE_read specify a Stop Expression
 *       (string terminated by encountering ’stop chars’ that match)
 */

/*
 * The ME/SE functions take a string containing a regular expression,
 * while the CME/CSE functions take a compiled form of regular
 * expression (see Pregexp_compile).
 *
 * stop chars and regular expressions are specified using ASCII, but
 * reading/matching occurs using converted EBCDIC forms if an EBCDIC
 * form is used or if a DEFAULT form is used and
 * pads->disc->def_charset is Pcharset_EBCDIC.
 * 
 * For all stop cases, the stop char/chars are not included in the
 * resulting string.  Note that if the IO cursor is already at a stop
 * condition, then a string of length zero results.
 *
 * If an expected stop char/pattern/width is found, P_OK is returned.
 * If P_TestSet(*m) then:

 *   + (*s_out) is set to contain an in-memory string.  If the
 *     original data is ASCII, then s_out will either share the string
 *     or contain a copy of the string, depending on
 *     pads->disc->copy_strings.  If the original data is EBCDIC, s_out
 *     always contains a copy of the string that has been converted to
 *     ASCII.  N.B. : (*s_out) should have been initialized at some
 *     point prior using Pstring_init or one of the initializing
 *     P_STRING macros.  (It can be initialized once and re-used in
 *     string read calls many times.)
 */

/* Cleanup note: If pads->disc->copy_strings is non-zero, the memory
 * allocated in (*s_out) should ultimately be freed using
 * Pstring_cleanup.
 *
 * If an expected stop condition is not encountered, the
 * IO cursor position is unchanged.  Error codes used:
 *     P_WIDTH_NOT_AVAILABLE
 *     P_STOPCHAR_NOT_FOUND
 *     P_STOPREGEXP_NOT_FOUND
 *     P_INVALID_REGEXP
 * 
 * EBCDIC Example: passing ’|’ (vertical bar, which is code 124 in
 * ASCII) to Pe_string_read as the stop char will result in a search
 * for the EBCDIC encoding of vertical bar (code 79 in EBCDIC), and
 * (*s_out) will be a string containing all chars between the IO
 * cursor and the EBCDIC vertical bar, with each EBCDIC char converted
 * to ASCII.
 */

Perror_t Pa_string_FW_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Pstring *s_out,
                    size_t width
                    );

Perror_t Pa_string_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Pstring *s_out,
                    Pchar stopChar
                    );

Perror_t Pa_string_ME_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Pstring *s_out,
                    const char *matchRegexp
                    );

Perror_t Pa_string_CME_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Pstring *s_out,
                    Pregexp_t *matchRegexp
                    );

Perror_t Pa_string_SE_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Pstring *s_out,
                    const char *stopRegexp
                    );

Perror_t Pa_string_CSE_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Pstring *s_out,
                    Pregexp_t *stopRegexp
                    );

Perror_t Pe_string_FW_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Pstring *s_out,
                    size_t width
                    );

Perror_t Pe_string_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Pstring *s_out,
                    Pchar stopChar
                    );

Perror_t Pe_string_ME_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Pstring *s_out,
                    const char *matchRegexp
                    );

Perror_t Pe_string_CME_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Pstring *s_out,
                    Pregexp_t *matchRegexp
                    );

Perror_t Pe_string_SE_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Pstring *s_out,
                    const char *stopRegexp
                    );

Perror_t Pe_string_CSE_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Pstring *s_out,
                    Pregexp_t *stopRegexp
                    );

Perror_t Pstring_FW_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Pstring *s_out,
                    size_t width
                    );

Perror_t Pstring_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Pstring *s_out,
                    Pchar stopChar
                    );

Perror_t Pstring_ME_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Pstring *s_out,
                    const char *matchRegexp
                    );

Perror_t Pstring_CME_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Pstring *s_out,
                    Pregexp_t *matchRegexp
                    );

Perror_t Pstring_SE_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Pstring *s_out,
                    const char *stopRegexp
                    );

Perror_t Pstring_CSE_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Pstring *s_out,
                    Pregexp_t *stopRegexp
                    );

/* ================================================================================
 * WRITE
 */

/* ================================================================================
 * STRING WRITE FUNCTIONS
 * DEFAULT                      ASCII                          EBCDIC
 * ————————-  —————————–  ———————-
 * Pstring_FW_write2io        Pa_string_FW_write2io          Pe_string_FW_write2io
 * Pstring_write2io           Pa_string_write2io             Pe_string_write2io
 * Pstring_ME_write2io        Pa_string_ME_write2io          Pe_string_ME_write2io
 * Pstring_CME_write2io       Pa_string_CME_write2io         Pe_string_CME_write2io
 * Pstring_SE_write2io        Pa_string_SE_write2io          Pe_string_SE_write2io
 * Pstring_CSE_write2io       Pa_string_CSE_write2io         Pe_string_CSE_write2io
 *
 * Pstring_FW_write2buf       Pa_string_FW_write2buf         Pe_string_FW_write2buf
 * Pstring_write2buf          Pa_string_write2buf            Pe_string_write2buf
 * Pstring_ME_write2buf       Pa_string_ME_write2buf         Pe_string_ME_write2buf
 * Pstring_CME_write2buf      Pa_string_CME_write2buf        Pe_string_CME_write2buf
 * Pstring_SE_write2buf       Pa_string_SE_write2buf         Pe_string_SE_write2buf
 * Pstring_CSE_write2buf      Pa_string_CSE_write2buf        Pe_string_CSE_write2buf
 */

ssize_t Pa_string_FW_write2io(P_t *pads, Sfio_t *io, Pbase_pd *pd, Pstring *s,
                    size_t width
                    );

ssize_t Pa_string_FW_write2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    Pbase_pd *pd, Pstring *s, size_t width
                    );

ssize_t Pa_string_write2io(P_t *pads, Sfio_t *io, Pbase_pd *pd, Pstring *s,
                    Pchar stopChar
                    );

ssize_t Pa_string_write2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    Pbase_pd *pd, Pstring *s, Pchar stopChar
                    );

ssize_t Pa_string_ME_write2io(P_t *pads, Sfio_t *io, Pbase_pd *pd, Pstring *s,
                    const char *matchRegexp
                    );

ssize_t Pa_string_ME_write2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    Pbase_pd *pd, Pstring *s, const char *matchRegexp
                    );

ssize_t Pa_string_CME_write2io(P_t *pads, Sfio_t *io, Pbase_pd *pd, Pstring *s,
                    Pregexp_t *matchRegexp
                    );

ssize_t Pa_string_CME_write2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    Pbase_pd *pd, Pstring *s, Pregexp_t *matchRegexp
                    );

ssize_t Pa_string_SE_write2io(P_t *pads, Sfio_t *io, Pbase_pd *pd, Pstring *s,
                    const char *stopRegexp
                    );

ssize_t Pa_string_SE_write2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    Pbase_pd *pd, Pstring *s, const char *stopRegexp
                    );

ssize_t Pa_string_CSE_write2io(P_t *pads, Sfio_t *io, Pbase_pd *pd, Pstring *s,
                    Pregexp_t *stopRegexp
                    );

ssize_t Pa_string_CSE_write2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    Pbase_pd *pd, Pstring *s, Pregexp_t *stopRegexp
                    );

ssize_t Pa_string_FW_write_xml_2io(P_t *pads, Sfio_t *io, Pbase_pd *pd, Pstring *s,
                    const char *tag, int indent, size_t width
                    );

ssize_t Pa_string_FW_write_xml_2buf(P_t *pads, Pbyte *buf, size_t buf_len,
                    int *buf_full, Pbase_pd *pd, Pstring *s, const char *tag,
                    int indent, size_t width
                    );

ssize_t Pa_string_write_xml_2io(P_t *pads, Sfio_t *io, Pbase_pd *pd, Pstring *s,
                    const char *tag, int indent, Pchar stopChar
                    );

ssize_t Pa_string_write_xml_2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    Pbase_pd *pd, Pstring *s, const char *tag, int indent,
                    Pchar stopChar
                    );

ssize_t Pa_string_ME_write_xml_2io(P_t *pads, Sfio_t *io, Pbase_pd *pd, Pstring *s,
                    const char *tag, int indent, const char *matchRegexp
                    );

ssize_t Pa_string_ME_write_xml_2buf(P_t *pads, Pbyte *buf, size_t buf_len,
                    int *buf_full, Pbase_pd *pd, Pstring *s, const char *tag,
                    int indent, const char *matchRegexp
                    );

ssize_t Pa_string_CME_write_xml_2io(P_t *pads, Sfio_t *io, Pbase_pd *pd, Pstring *s,
                    const char *tag, int indent, Pregexp_t *matchRegexp
                    );

ssize_t Pa_string_CME_write_xml_2buf(P_t *pads, Pbyte *buf, size_t buf_len,
                    int *buf_full, Pbase_pd *pd, Pstring *s, const char *tag,
                    int indent, Pregexp_t *matchRegexp
                    );

ssize_t Pa_string_SE_write_xml_2io(P_t *pads, Sfio_t *io, Pbase_pd *pd, Pstring *s,
                    const char *tag, int indent, const char *stopRegexp
                    );

ssize_t Pa_string_SE_write_xml_2buf(P_t *pads, Pbyte *buf, size_t buf_len,
                    int *buf_full, Pbase_pd *pd, Pstring *s, const char *tag,
                    int indent, const char *stopRegexp
                    );

ssize_t Pa_string_CSE_write_xml_2io(P_t *pads, Sfio_t *io, Pbase_pd *pd, Pstring *s,
                    const char *tag, int indent, Pregexp_t *stopRegexp
                    );

ssize_t Pa_string_CSE_write_xml_2buf(P_t *pads, Pbyte *buf, size_t buf_len,
                    int *buf_full, Pbase_pd *pd, Pstring *s, const char *tag,
                    int indent, Pregexp_t *stopRegexp
                    );

ssize_t Pe_string_FW_write2io(P_t *pads, Sfio_t *io, Pbase_pd *pd, Pstring *s,
                    size_t width
                    );

ssize_t Pe_string_FW_write2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    Pbase_pd *pd, Pstring *s, size_t width
                    );

ssize_t Pe_string_write2io(P_t *pads, Sfio_t *io, Pbase_pd *pd, Pstring *s,
                    Pchar stopChar
                    );

ssize_t Pe_string_write2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    Pbase_pd *pd, Pstring *s, Pchar stopChar
                    );

ssize_t Pe_string_ME_write2io(P_t *pads, Sfio_t *io, Pbase_pd *pd, Pstring *s,
                    const char *matchRegexp
                    );

ssize_t Pe_string_ME_write2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    Pbase_pd *pd, Pstring *s, const char *matchRegexp
                    );

ssize_t Pe_string_CME_write2io(P_t *pads, Sfio_t *io, Pbase_pd *pd, Pstring *s,
                    Pregexp_t *matchRegexp
                    );

ssize_t Pe_string_CME_write2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    Pbase_pd *pd, Pstring *s, Pregexp_t *matchRegexp
                    );

ssize_t Pe_string_SE_write2io(P_t *pads, Sfio_t *io, Pbase_pd *pd, Pstring *s,
                    const char *stopRegexp
                    );

ssize_t Pe_string_SE_write2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    Pbase_pd *pd, Pstring *s, const char *stopRegexp
                    );

ssize_t Pe_string_CSE_write2io(P_t *pads, Sfio_t *io, Pbase_pd *pd, Pstring *s,
                    Pregexp_t *stopRegexp
                    );

ssize_t Pe_string_CSE_write2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    Pbase_pd *pd, Pstring *s, Pregexp_t *stopRegexp
                    );

ssize_t Pe_string_FW_write_xml_2io(P_t *pads, Sfio_t *io, Pbase_pd *pd, Pstring *s,
                    const char *tag, int indent, size_t width
                    );

ssize_t Pe_string_FW_write_xml_2buf(P_t *pads, Pbyte *buf, size_t buf_len,
                    int *buf_full, Pbase_pd *pd, Pstring *s, const char *tag,
                    int indent, size_t width
                    );

ssize_t Pe_string_write_xml_2io(P_t *pads, Sfio_t *io, Pbase_pd *pd, Pstring *s,
                    const char *tag, int indent, Pchar stopChar
                    );

ssize_t Pe_string_write_xml_2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    Pbase_pd *pd, Pstring *s, const char *tag, int indent,
                    Pchar stopChar
                    );

ssize_t Pe_string_ME_write_xml_2io(P_t *pads, Sfio_t *io, Pbase_pd *pd, Pstring *s,
                    const char *tag, int indent, const char *matchRegexp
                    );

ssize_t Pe_string_ME_write_xml_2buf(P_t *pads, Pbyte *buf, size_t buf_len,
                    int *buf_full, Pbase_pd *pd, Pstring *s, const char *tag,
                    int indent, const char *matchRegexp
                    );

ssize_t Pe_string_CME_write_xml_2io(P_t *pads, Sfio_t *io, Pbase_pd *pd, Pstring *s,
                    const char *tag, int indent, Pregexp_t *matchRegexp
                    );

ssize_t Pe_string_CME_write_xml_2buf(P_t *pads, Pbyte *buf, size_t buf_len,
                    int *buf_full, Pbase_pd *pd, Pstring *s, const char *tag,
                    int indent, Pregexp_t *matchRegexp
                    );

ssize_t Pe_string_SE_write_xml_2io(P_t *pads, Sfio_t *io, Pbase_pd *pd, Pstring *s,
                    const char *tag, int indent, const char *stopRegexp
                    );

ssize_t Pe_string_SE_write_xml_2buf(P_t *pads, Pbyte *buf, size_t buf_len,
                    int *buf_full, Pbase_pd *pd, Pstring *s, const char *tag,
                    int indent, const char *stopRegexp
                    );

ssize_t Pe_string_CSE_write_xml_2io(P_t *pads, Sfio_t *io, Pbase_pd *pd, Pstring *s,
                    const char *tag, int indent, Pregexp_t *stopRegexp
                    );

ssize_t Pe_string_CSE_write_xml_2buf(P_t *pads, Pbyte *buf, size_t buf_len,
                    int *buf_full, Pbase_pd *pd, Pstring *s, const char *tag,
                    int indent, Pregexp_t *stopRegexp
                    );

ssize_t Pstring_FW_write2io(P_t *pads, Sfio_t *io, Pbase_pd *pd, Pstring *s,
                    size_t width
                    );

ssize_t Pstring_FW_write2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    Pbase_pd *pd, Pstring *s, size_t width
                    );

ssize_t Pstring_write2io(P_t *pads, Sfio_t *io, Pbase_pd *pd, Pstring *s,
                    Pchar stopChar
                    );

ssize_t Pstring_write2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    Pbase_pd *pd, Pstring *s, Pchar stopChar
                    );

ssize_t Pstring_ME_write2io(P_t *pads, Sfio_t *io, Pbase_pd *pd, Pstring *s,
                    const char *matchRegexp
                    );

ssize_t Pstring_ME_write2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    Pbase_pd *pd, Pstring *s, const char *matchRegexp
                    );

ssize_t Pstring_CME_write2io(P_t *pads, Sfio_t *io, Pbase_pd *pd, Pstring *s,
                    Pregexp_t *matchRegexp
                    );

ssize_t Pstring_CME_write2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    Pbase_pd *pd, Pstring *s, Pregexp_t *matchRegexp
                    );

ssize_t Pstring_SE_write2io(P_t *pads, Sfio_t *io, Pbase_pd *pd, Pstring *s,
                    const char *stopRegexp
                    );

ssize_t Pstring_SE_write2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    Pbase_pd *pd, Pstring *s, const char *stopRegexp
                    );

ssize_t Pstring_CSE_write2io(P_t *pads, Sfio_t *io, Pbase_pd *pd, Pstring *s,
                    Pregexp_t *stopRegexp
                    );

ssize_t Pstring_CSE_write2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    Pbase_pd *pd, Pstring *s, Pregexp_t *stopRegexp
                    );

ssize_t Pstring_FW_write_xml_2io(P_t *pads, Sfio_t *io, Pbase_pd *pd, Pstring *s,
                    const char *tag, int indent, size_t width
                    );

ssize_t Pstring_FW_write_xml_2buf(P_t *pads, Pbyte *buf, size_t buf_len,
                    int *buf_full, Pbase_pd *pd, Pstring *s, const char *tag,
                    int indent, size_t width
                    );

ssize_t Pstring_write_xml_2io(P_t *pads, Sfio_t *io, Pbase_pd *pd, Pstring *s,
                    const char *tag, int indent, Pchar stopChar
                    );

ssize_t Pstring_write_xml_2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    Pbase_pd *pd, Pstring *s, const char *tag, int indent,
                    Pchar stopChar
                    );

ssize_t Pstring_ME_write_xml_2io(P_t *pads, Sfio_t *io, Pbase_pd *pd, Pstring *s,
                    const char *tag, int indent, const char *matchRegexp
                    );

ssize_t Pstring_ME_write_xml_2buf(P_t *pads, Pbyte *buf, size_t buf_len,
                    int *buf_full, Pbase_pd *pd, Pstring *s, const char *tag,
                    int indent, const char *matchRegexp
                    );

ssize_t Pstring_CME_write_xml_2io(P_t *pads, Sfio_t *io, Pbase_pd *pd, Pstring *s,
                    const char *tag, int indent, Pregexp_t *matchRegexp
                    );

ssize_t Pstring_CME_write_xml_2buf(P_t *pads, Pbyte *buf, size_t buf_len,
                    int *buf_full, Pbase_pd *pd, Pstring *s, const char *tag,
                    int indent, Pregexp_t *matchRegexp
                    );

ssize_t Pstring_SE_write_xml_2io(P_t *pads, Sfio_t *io, Pbase_pd *pd, Pstring *s,
                    const char *tag, int indent, const char *stopRegexp
                    );

ssize_t Pstring_SE_write_xml_2buf(P_t *pads, Pbyte *buf, size_t buf_len,
                    int *buf_full, Pbase_pd *pd, Pstring *s, const char *tag,
                    int indent, const char *stopRegexp
                    );

ssize_t Pstring_CSE_write_xml_2io(P_t *pads, Sfio_t *io, Pbase_pd *pd, Pstring *s,
                    const char *tag, int indent, Pregexp_t *stopRegexp
                    );

ssize_t Pstring_CSE_write_xml_2buf(P_t *pads, Pbyte *buf, size_t buf_len,
                    int *buf_full, Pbase_pd *pd, Pstring *s, const char *tag,
                    int indent, Pregexp_t *stopRegexp
                    );

ssize_t Pa_string_FW_fmt2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    int *requested_out, const char *delims, Pbase_m *m, Pbase_pd *pd,
                    Pstring *rep, size_t width
                    );

ssize_t Pa_string_FW_fmt2buf_final(P_t *pads, Pbyte *buf, size_t buf_len,
                    int *buf_full, int *requested_out, const char *delims, Pbase_m *m,
                    Pbase_pd *pd, Pstring *rep, size_t width
                    );

ssize_t Pa_string_fmt2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    int *requested_out, const char *delims, Pbase_m *m, Pbase_pd *pd,
                    Pstring *rep, Pchar stopChar
                    );

ssize_t Pa_string_fmt2buf_final(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    int *requested_out, const char *delims, Pbase_m *m, Pbase_pd *pd,
                    Pstring *rep, Pchar stopChar
                    );

ssize_t Pa_string_ME_fmt2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    int *requested_out, const char *delims, Pbase_m *m, Pbase_pd *pd,
                    Pstring *rep, const char *matchRegexp
                    );

ssize_t Pa_string_ME_fmt2buf_final(P_t *pads, Pbyte *buf, size_t buf_len,
                    int *buf_full, int *requested_out, const char *delims, Pbase_m *m,
                    Pbase_pd *pd, Pstring *rep, const char *matchRegexp
                    );

ssize_t Pa_string_CME_fmt2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    int *requested_out, const char *delims, Pbase_m *m, Pbase_pd *pd,
                    Pstring *rep, Pregexp_t *matchRegexp
                    );

ssize_t Pa_string_CME_fmt2buf_final(P_t *pads, Pbyte *buf, size_t buf_len,
                    int *buf_full, int *requested_out, const char *delims, Pbase_m *m,
                    Pbase_pd *pd, Pstring *rep, Pregexp_t *matchRegexp
                    );

ssize_t Pa_string_SE_fmt2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    int *requested_out, const char *delims, Pbase_m *m, Pbase_pd *pd,
                    Pstring *rep, const char *stopRegexp
                    );

ssize_t Pa_string_SE_fmt2buf_final(P_t *pads, Pbyte *buf, size_t buf_len,
                    int *buf_full, int *requested_out, const char *delims, Pbase_m *m,
                    Pbase_pd *pd, Pstring *rep, const char *stopRegexp
                    );

ssize_t Pa_string_CSE_fmt2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    int *requested_out, const char *delims, Pbase_m *m, Pbase_pd *pd,
                    Pstring *rep, Pregexp_t *stopRegexp
                    );

ssize_t Pa_string_CSE_fmt2buf_final(P_t *pads, Pbyte *buf, size_t buf_len,
                    int *buf_full, int *requested_out, const char *delims, Pbase_m *m,
                    Pbase_pd *pd, Pstring *rep, Pregexp_t *stopRegexp
                    );

ssize_t Pa_string_FW_fmt2io(P_t *pads, Sfio_t *io, int *requested_out,
                    const char *delims, Pbase_m *m, Pbase_pd *pd, Pstring *rep,
                    size_t width
                    );

ssize_t Pa_string_fmt2io(P_t *pads, Sfio_t *io, int *requested_out,
                    const char *delims, Pbase_m *m, Pbase_pd *pd, Pstring *rep,
                    Pchar stopChar
                    );

ssize_t Pa_string_ME_fmt2io(P_t *pads, Sfio_t *io, int *requested_out,
                    const char *delims, Pbase_m *m, Pbase_pd *pd, Pstring *rep,
                    const char *matchRegexp
                    );

ssize_t Pa_string_CME_fmt2io(P_t *pads, Sfio_t *io, int *requested_out,
                    const char *delims, Pbase_m *m, Pbase_pd *pd, Pstring *rep,
                    Pregexp_t *matchRegexp
                    );

ssize_t Pa_string_SE_fmt2io(P_t *pads, Sfio_t *io, int *requested_out,
                    const char *delims, Pbase_m *m, Pbase_pd *pd, Pstring *rep,
                    const char *stopRegexp
                    );

ssize_t Pa_string_CSE_fmt2io(P_t *pads, Sfio_t *io, int *requested_out,
                    const char *delims, Pbase_m *m, Pbase_pd *pd, Pstring *rep,
                    Pregexp_t *stopRegexp
                    );

ssize_t Pe_string_FW_fmt2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    int *requested_out, const char *delims, Pbase_m *m, Pbase_pd *pd,
                    Pstring *rep, size_t width
                    );

ssize_t Pe_string_FW_fmt2buf_final(P_t *pads, Pbyte *buf, size_t buf_len,
                    int *buf_full, int *requested_out, const char *delims, Pbase_m *m,
                    Pbase_pd *pd, Pstring *rep, size_t width
                    );

ssize_t Pe_string_fmt2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    int *requested_out, const char *delims, Pbase_m *m, Pbase_pd *pd,
                    Pstring *rep, Pchar stopChar
                    );

ssize_t Pe_string_fmt2buf_final(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    int *requested_out, const char *delims, Pbase_m *m, Pbase_pd *pd,
                    Pstring *rep, Pchar stopChar
                    );

ssize_t Pe_string_ME_fmt2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    int *requested_out, const char *delims, Pbase_m *m, Pbase_pd *pd,
                    Pstring *rep, const char *matchRegexp
                    );

ssize_t Pe_string_ME_fmt2buf_final(P_t *pads, Pbyte *buf, size_t buf_len,
                    int *buf_full, int *requested_out, const char *delims, Pbase_m *m,
                    Pbase_pd *pd, Pstring *rep, const char *matchRegexp
                    );

ssize_t Pe_string_CME_fmt2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    int *requested_out, const char *delims, Pbase_m *m, Pbase_pd *pd,
                    Pstring *rep, Pregexp_t *matchRegexp
                    );

ssize_t Pe_string_CME_fmt2buf_final(P_t *pads, Pbyte *buf, size_t buf_len,
                    int *buf_full, int *requested_out, const char *delims, Pbase_m *m,
                    Pbase_pd *pd, Pstring *rep, Pregexp_t *matchRegexp
                    );

ssize_t Pe_string_SE_fmt2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    int *requested_out, const char *delims, Pbase_m *m, Pbase_pd *pd,
                    Pstring *rep, const char *stopRegexp
                    );

ssize_t Pe_string_SE_fmt2buf_final(P_t *pads, Pbyte *buf, size_t buf_len,
                    int *buf_full, int *requested_out, const char *delims, Pbase_m *m,
                    Pbase_pd *pd, Pstring *rep, const char *stopRegexp
                    );

ssize_t Pe_string_CSE_fmt2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    int *requested_out, const char *delims, Pbase_m *m, Pbase_pd *pd,
                    Pstring *rep, Pregexp_t *stopRegexp
                    );

ssize_t Pe_string_CSE_fmt2buf_final(P_t *pads, Pbyte *buf, size_t buf_len,
                    int *buf_full, int *requested_out, const char *delims, Pbase_m *m,
                    Pbase_pd *pd, Pstring *rep, Pregexp_t *stopRegexp
                    );

ssize_t Pe_string_FW_fmt2io(P_t *pads, Sfio_t *io, int *requested_out,
                    const char *delims, Pbase_m *m, Pbase_pd *pd, Pstring *rep,
                    size_t width
                    );

ssize_t Pe_string_fmt2io(P_t *pads, Sfio_t *io, int *requested_out,
                    const char *delims, Pbase_m *m, Pbase_pd *pd, Pstring *rep,
                    Pchar stopChar
                    );

ssize_t Pe_string_ME_fmt2io(P_t *pads, Sfio_t *io, int *requested_out,
                    const char *delims, Pbase_m *m, Pbase_pd *pd, Pstring *rep,
                    const char *matchRegexp
                    );

ssize_t Pe_string_CME_fmt2io(P_t *pads, Sfio_t *io, int *requested_out,
                    const char *delims, Pbase_m *m, Pbase_pd *pd, Pstring *rep,
                    Pregexp_t *matchRegexp
                    );

ssize_t Pe_string_SE_fmt2io(P_t *pads, Sfio_t *io, int *requested_out,
                    const char *delims, Pbase_m *m, Pbase_pd *pd, Pstring *rep,
                    const char *stopRegexp
                    );

ssize_t Pe_string_CSE_fmt2io(P_t *pads, Sfio_t *io, int *requested_out,
                    const char *delims, Pbase_m *m, Pbase_pd *pd, Pstring *rep,
                    Pregexp_t *stopRegexp
                    );

ssize_t Pstring_FW_fmt2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    int *requested_out, const char *delims, Pbase_m *m, Pbase_pd *pd,
                    Pstring *rep, size_t width
                    );

ssize_t Pstring_FW_fmt2buf_final(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    int *requested_out, const char *delims, Pbase_m *m, Pbase_pd *pd,
                    Pstring *rep, size_t width
                    );

ssize_t Pstring_fmt2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    int *requested_out, const char *delims, Pbase_m *m, Pbase_pd *pd,
                    Pstring *rep, Pchar stopChar
                    );

ssize_t Pstring_fmt2buf_final(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    int *requested_out, const char *delims, Pbase_m *m, Pbase_pd *pd,
                    Pstring *rep, Pchar stopChar
                    );

ssize_t Pstring_ME_fmt2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    int *requested_out, const char *delims, Pbase_m *m, Pbase_pd *pd,
                    Pstring *rep, const char *matchRegexp
                    );

ssize_t Pstring_ME_fmt2buf_final(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    int *requested_out, const char *delims, Pbase_m *m, Pbase_pd *pd,
                    Pstring *rep, const char *matchRegexp
                    );

ssize_t Pstring_CME_fmt2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    int *requested_out, const char *delims, Pbase_m *m, Pbase_pd *pd,
                    Pstring *rep, Pregexp_t *matchRegexp
                    );

ssize_t Pstring_CME_fmt2buf_final(P_t *pads, Pbyte *buf, size_t buf_len,
                    int *buf_full, int *requested_out, const char *delims, Pbase_m *m,
                    Pbase_pd *pd, Pstring *rep, Pregexp_t *matchRegexp
                    );

ssize_t Pstring_SE_fmt2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    int *requested_out, const char *delims, Pbase_m *m, Pbase_pd *pd,
                    Pstring *rep, const char *stopRegexp
                    );

ssize_t Pstring_SE_fmt2buf_final(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    int *requested_out, const char *delims, Pbase_m *m, Pbase_pd *pd,
                    Pstring *rep, const char *stopRegexp
                    );

ssize_t Pstring_CSE_fmt2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    int *requested_out, const char *delims, Pbase_m *m, Pbase_pd *pd,
                    Pstring *rep, Pregexp_t *stopRegexp
                    );

ssize_t Pstring_CSE_fmt2buf_final(P_t *pads, Pbyte *buf, size_t buf_len,
                    int *buf_full, int *requested_out, const char *delims, Pbase_m *m,
                    Pbase_pd *pd, Pstring *rep, Pregexp_t *stopRegexp
                    );

ssize_t Pstring_FW_fmt2io(P_t *pads, Sfio_t *io, int *requested_out,
                    const char *delims, Pbase_m *m, Pbase_pd *pd, Pstring *rep,
                    size_t width
                    );

ssize_t Pstring_fmt2io(P_t *pads, Sfio_t *io, int *requested_out, const char *delims,
                    Pbase_m *m, Pbase_pd *pd, Pstring *rep, Pchar stopChar
                    );

ssize_t Pstring_ME_fmt2io(P_t *pads, Sfio_t *io, int *requested_out,
                    const char *delims, Pbase_m *m, Pbase_pd *pd, Pstring *rep,
                    const char *matchRegexp
                    );

ssize_t Pstring_CME_fmt2io(P_t *pads, Sfio_t *io, int *requested_out,
                    const char *delims, Pbase_m *m, Pbase_pd *pd, Pstring *rep,
                    Pregexp_t *matchRegexp
                    );

ssize_t Pstring_SE_fmt2io(P_t *pads, Sfio_t *io, int *requested_out,
                    const char *delims, Pbase_m *m, Pbase_pd *pd, Pstring *rep,
                    const char *stopRegexp
                    );

ssize_t Pstring_CSE_fmt2io(P_t *pads, Sfio_t *io, int *requested_out,
                    const char *delims, Pbase_m *m, Pbase_pd *pd, Pstring *rep,
                    Pregexp_t *stopRegexp
                    );

B.4  IP addresses: Character encodings

/* ================================================================================
 * IP ADDRESS READ FUNCTIONS
 *
 * DEFAULT                        ASCII                          EBCDIC
 * —————————–  —————————–  —————————–
 * Pip_read                       Pa_ip_read                     Pe_ip_read
 *
 * Attempts to read a numeric IP address string, i.e., an IP address
 * form consisting of four numeric parts with values 0-255,
 * separated by ".", with an optional trailing dot.  
 */

/* The result is a single Puint32 value with each part encoded in one
 * of the four bytes.  part1 is stored in the high-order byte, part4
 * in the low-order byte.  You can obtain each part using the macro
 *
 *   P_IP_PART(addr, part)
 *
 * where part must be from 1 to 4.
 *
 * The digit chars and "." char are read as EBCDIC chars if the EBCDIC
 * form is used or if the DEFAULT form is used and
 * pads->disc->def_charset is Pcharset_EBCDIC.  Otherwise the data is
 * read as ASCII chars.
 */

/* If the current IO cursor position points to a valid IP address string:
 *   + Sets (*res_out) to the resulting Puint32
 *   + advances the IO cursor position to just after the last legal
 *      character in the IP address string
 *   + returns P_OK
 * Otherwise:
 *   + pd->loc.b/e set to the IO cursor position
 *   + IO cursor is not advanced
 *   + if P_Test_NotIgnore(*m), pd->errCode set to P_INVALID_IP,
 *         pd->nerr set to 1, and an error is reported
 *   + returns P_ERR
 */

Perror_t Pa_ip_read(P_t *pads,const Pbase_m *m,Pbase_pd *pd,Puint32 *res_out);

Perror_t Pe_ip_read(P_t *pads,const Pbase_m *m,Pbase_pd *pd,Puint32 *res_out);

Perror_t Pip_read(P_t *pads,const Pbase_m *m,Pbase_pd *pd,Puint32 *res_out);

/* The helper macro P_IP_PART(addr, part) takes a Puint32 addr
 * and a part number from 1 to 4, and produces the specified part.
 */

/* ================================================================================
 * IP WRITE FUNCTIONS
 * DEFAULT                        ASCII                          EBCDIC
 * —————————–  —————————–  —————————–
 * Pip_write2io                   Pa_ip_write2io                 Pe_ip_write2io 
 *
 * Pip_write2buf                  Pa_ip_write2buf                Pe_ip_write2buf
 */

ssize_t Pa_ip_write2io(P_t *pads,Sfio_t *io,Pbase_pd *pd,Puint32 *d);

ssize_t Pa_ip_write2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    Pbase_pd *pd, Puint32 *d
                    );

ssize_t Pa_ip_write_xml_2io(P_t *pads, Sfio_t *io, Pbase_pd *pd, Puint32 *d,
                    const char *tag, int indent
                    );

ssize_t Pa_ip_write_xml_2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    Pbase_pd *pd, Puint32 *d, const char *tag, int indent
                    );

ssize_t Pe_ip_write2io(P_t *pads,Sfio_t *io,Pbase_pd *pd,Puint32 *d);

ssize_t Pe_ip_write2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    Pbase_pd *pd, Puint32 *d
                    );

ssize_t Pe_ip_write_xml_2io(P_t *pads, Sfio_t *io, Pbase_pd *pd, Puint32 *d,
                    const char *tag, int indent
                    );

ssize_t Pe_ip_write_xml_2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    Pbase_pd *pd, Puint32 *d, const char *tag, int indent
                    );

ssize_t Pip_write2io(P_t *pads,Sfio_t *io,Pbase_pd *pd,Puint32 *d);

ssize_t Pip_write2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    Pbase_pd *pd, Puint32 *d
                    );

ssize_t Pip_write_xml_2io(P_t *pads, Sfio_t *io, Pbase_pd *pd, Puint32 *d,
                    const char *tag, int indent
                    );

ssize_t Pip_write_xml_2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    Pbase_pd *pd, Puint32 *d, const char *tag, int indent
                    );

ssize_t Pa_ip_fmt2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    int *requested_out, const char *delims, Pbase_m *m, Pbase_pd *pd,
                    Puint32 *rep
                    );

ssize_t Pa_ip_fmt2buf_final(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    int *requested_out, const char *delims, Pbase_m *m, Pbase_pd *pd,
                    Puint32 *rep
                    );

ssize_t Pa_ip_fmt2io(P_t *pads, Sfio_t *io, int *requested_out, const char *delims,
                    Pbase_m *m, Pbase_pd *pd, Puint32 *rep
                    );

ssize_t Pe_ip_fmt2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    int *requested_out, const char *delims, Pbase_m *m, Pbase_pd *pd,
                    Puint32 *rep
                    );

ssize_t Pe_ip_fmt2buf_final(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    int *requested_out, const char *delims, Pbase_m *m, Pbase_pd *pd,
                    Puint32 *rep
                    );

ssize_t Pe_ip_fmt2io(P_t *pads, Sfio_t *io, int *requested_out, const char *delims,
                    Pbase_m *m, Pbase_pd *pd, Puint32 *rep
                    );

ssize_t Pip_fmt2buf(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    int *requested_out, const char *delims, Pbase_m *m, Pbase_pd *pd,
                    Puint32 *rep);

ssize_t Pip_fmt2buf_final(P_t *pads, Pbyte *buf, size_t buf_len, int *buf_full,
                    int *requested_out, const char *delims, Pbase_m *m, Pbase_pd *pd,
                    Puint32 *rep
                    );

ssize_t Pip_fmt2io(P_t *pads, Sfio_t *io, int *requested_out, const char *delims,
                    Pbase_m *m, Pbase_pd *pd, Puint32 *rep);

B.5  Timestamp, date, and time types: Character encodings

/* ================================================================================
 * READ FUNCTIONS
 *
 * DEFAULT                      ASCII                          EBCDIC
 * —————————- —————————–  —————————–
 * Ptimestamp_explicit_FW_read  Pa_timestamp_explicit_FW_read  Pe_timestamp_explicit_FW_read
 * Ptimestamp_explicit_read     Pa_timestamp_explicit_read     Pe_timestamp_explicit_read
 * Ptimestamp_explicit_ME_read  Pa_timestamp_explicit_ME_read  Pe_timestamp_explicit_ME_read
 * Ptimestamp_explicit_CME_read Pa_timestamp_explicit_CME_read Pe_timestamp_explicit_CME_read
 * Ptimestamp_explicit_SE_read  Pa_timestamp_explicit_SE_read  Pe_timestamp_explicit_SE_read
 * Ptimestamp_explicit_CSE_read Pa_timestamp_explicit_CSE_read Pe_timestamp_explicit_CSE_read
 *
 * Pdate_explicit_FW_read       Pa_date_explicit_FW_read       Pe_date_explicit_FW_read
 * Pdate_explicit_read          Pa_date_explicit_read          Pe_date_explicit_read
 * Pdate_explicit_ME_read       Pa_date_explicit_ME_read       Pe_date_explicit_ME_read
 * Pdate_explicit_CME_read      Pa_date_explicit_CME_read      Pe_date_explicit_CME_read
 * Pdate_explicit_SE_read       Pa_date_explicit_SE_read       Pe_date_explicit_SE_read
 * Pdate_explicit_CSE_read      Pa_date_explicit_CSE_read      Pe_date_explicit_CSE_read
 *
 * Ptime_explicit_FW_read       Pa_time_explicit_FW_read       Pe_time_explicit_FW_read
 * Ptime_explicit_read          Pa_time_explicit_read          Pe_time_explicit_read
 * Ptime_explicit_ME_read       Pa_time_explicit_ME_read       Pe_time_explicit_ME_read
 * Ptime_explicit_CME_read      Pa_time_explicit_CME_read      Pe_time_explicit_CME_read
 * Ptime_explicit_SE_read       Pa_time_explicit_SE_read       Pe_time_explicit_SE_read
 * Ptime_explicit_CSE_read      Pa_time_explicit_CSE_read      Pe_time_explicit_CSE_read
 */

/*
 * Ptimestamp_FW_read           Pa_timestamp_FW_read           Pe_timestamp_FW_read
 * Ptimestamp_read              Pa_timestamp_read              Pe_timestamp_read
 * Ptimestamp_ME_read           Pa_timestamp_ME_read           Pe_timestamp_ME_read
 * Ptimestamp_CME_read          Pa_timestamp_CME_read          Pe_timestamp_CME_read
 * Ptimestamp_SE_read           Pa_timestamp_SE_read           Pe_timestamp_SE_read
 * Ptimestamp_CSE_read          Pa_timestamp_CSE_read          Pe_timestamp_CSE_read
 *
 * Pdate_FW_read                Pa_date_FW_read                Pe_date_FW_read
 * Pdate_read                   Pa_date_read                   Pe_date_read
 * Pdate_ME_read                Pa_date_ME_read                Pe_date_ME_read
 * Pdate_CME_read               Pa_date_CME_read               Pe_date_CME_read
 * Pdate_SE_read                Pa_date_SE_read                Pe_date_SE_read
 * Pdate_CSE_read               Pa_date_CSE_read               Pe_date_CSE_read
 *
 * Ptime_FW_read                Pa_time_FW_read                Pe_time_FW_read
 * Ptime_read                   Pa_time_read                   Pe_time_read
 * Ptime_ME_read                Pa_time_ME_read                Pe_time_ME_read
 * Ptime_CME_read               Pa_time_CME_read               Pe_time_CME_read
 * Ptime_SE_read                Pa_time_SE_read                Pe_time_SE_read
 * Ptime_CSE_read               Pa_time_CSE_read               Pe_time_CSE_read
 */

/*
 * Ptimestamp_explicit variants: 
 *
 *    Converts ASCII/EBCDIC char date/time description into seconds
 *    since Midnight Jan 1, 1970.  Format-based parsing is based on
 *    libast’s tmdate function.  Input format and input time zone are
 *    specified explicitly.  The format used controls whether input is
 *    date and time, just date, or just time.  Default output format
 *    is set via disc->out_formats.timestamp_explicit
 *
 * Pdate_explicit variants:
 *
 *    Like Ptimestamp_explicit, with explicit format and time zone
 *    argument.  INTENDED to be used for just date, but format
 *    determines which strings are accepted. If treated as a full timestamp
 *    (time in seconds since Midnight Jan 1, 1970), the result has a
 *    ’time of day’ component of 0 hours, 0 minutes, 0 seconds.
 *    Default output format is set via disc->out_formats.date_explicit
 *
 * Ptime_explicit variants:
 *
 *    Like Ptimestamp_explicit, with explicit format and time zone
 *    argument.  INTENDED to be used for just time, but format
 *    determines which strings are accepted.  The resulting
 *    time in seconds is just the contribution of the specified time of day,
 *    thus if treated as a full timestamp, the time would fall on Jan 1, 1970.
 *    Default output format is set via disc->out_formats.time_explicit
 */

/*
 * Ptimestamp variants:
 *
 *    Like Ptimestamp_explicit, but input format and input time zone
 *    are taken from disc->in_formats.timestamp and
 *    disc->in_time_zone.  INTENDED to be used for both a date and
 *    time, but format determines actual use.  Default output format
 *    is set via disc->out_formats.timestamp
 *
 * Pdate variants:
 *
 *    Like Pdate_explicit, but input format and input time zone are
 *    taken from disc->in_formats.date and disc->in_time_zone.
 *    INTENDED to be used for just date, but format determines which
 *    strings are accepted. If treated as a full timestamp (time in seconds
 *    since Midnight Jan 1, 1970), the result has a ’time of day’ component
 *    of 0 hours, 0 minutes, 0 seconds.  Default output format is set
 *    via disc->out_formats.date
 *
 * Ptime variants:
 *
 *    Like Ptime_explicit, but input format and input time zone are
 *    taken from disc->in_formats.time and disc->in_time_zone.
 *    INTENDED to be used for just time, but format determines which
 *    strings are accepted.  The resulting time in seconds is just the
 *    contribution of the specified time of day, thus if treated as a
 *    full timestamp, the time would fall on Jan 1, 1970.
 *    Default output format is set via disc->out_formats.time
 *
 * Each of the types above corresponds to one of the Pstring variants.
 * In each case one specifies the extent of a ’string’ in the input
 * that is to be converted to a Puint32 representing the date in
 * seconds since the epoch.  For the different date formats that are
 * supported, see the discussion of disc->in_formats in pads.h.
 *
 * If the current IO cursor position points to a valid date string:
 *   + Sets (*res_out) to the resulting date in seconds since the epoch
 *   + advances the IO cursor position to just after the last
 *     legal character in the date string
 *   + returns P_OK
 * Otherwise:
 *   + does not advance the IO cursor pos
 *   + returns P_ERR
 */

Perror_t Pa_timestamp_explicit_FW_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, size_t width, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Pa_timestamp_explicit_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, Pchar stopChar, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Pa_timestamp_explicit_ME_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, const char *matchRegexp, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Pa_timestamp_explicit_CME_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, Pregexp_t *matchRegexp, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Pa_timestamp_explicit_SE_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, const char *stopRegexp, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Pa_timestamp_explicit_CSE_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, Pregexp_t *stopRegexp, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Pa_date_explicit_FW_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, size_t width, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Pa_date_explicit_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, Pchar stopChar, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Pa_date_explicit_ME_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, const char *matchRegexp, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Pa_date_explicit_CME_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, Pregexp_t *matchRegexp, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Pa_date_explicit_SE_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, const char *stopRegexp, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Pa_date_explicit_CSE_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, Pregexp_t *stopRegexp, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Pa_time_explicit_FW_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, size_t width, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Pa_time_explicit_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, Pchar stopChar, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Pa_time_explicit_ME_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, const char *matchRegexp, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Pa_time_explicit_CME_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, Pregexp_t *matchRegexp, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Pa_time_explicit_SE_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, const char *stopRegexp, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Pa_time_explicit_CSE_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, Pregexp_t *stopRegexp, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Pa_timestamp_FW_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, size_t width
                    );

Perror_t Pa_timestamp_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, Pchar stopChar
                    );

Perror_t Pa_timestamp_ME_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, const char *matchRegexp
                    );

Perror_t Pa_timestamp_CME_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, Pregexp_t *matchRegexp
                    );

Perror_t Pa_timestamp_SE_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, const char *stopRegexp
                    );

Perror_t Pa_timestamp_CSE_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, Pregexp_t *stopRegexp
                    );

Perror_t Pa_date_FW_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Puint32 *res_out,
                    size_t width
                    );

Perror_t Pa_date_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Puint32 *res_out,
                    Pchar stopChar
                    );

Perror_t Pa_date_ME_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Puint32 *res_out,
                    const char *matchRegexp
                    );

Perror_t Pa_date_CME_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Puint32 *res_out,
                    Pregexp_t *matchRegexp
                    );

Perror_t Pa_date_SE_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Puint32 *res_out,
                    const char *stopRegexp
                    );

Perror_t Pa_date_CSE_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Puint32 *res_out,
                    Pregexp_t *stopRegexp
                    );

Perror_t Pa_time_FW_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Puint32 *res_out,
                    size_t width
                    );

Perror_t Pa_time_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Puint32 *res_out,
                    Pchar stopChar
                    );

Perror_t Pa_time_ME_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Puint32 *res_out,
                    const char *matchRegexp
                    );

Perror_t Pa_time_CME_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Puint32 *res_out,
                    Pregexp_t *matchRegexp
                    );

Perror_t Pa_time_SE_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Puint32 *res_out,
                    const char *stopRegexp
                    );

Perror_t Pa_time_CSE_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Puint32 *res_out,
                    Pregexp_t *stopRegexp
                    );

Perror_t Pe_timestamp_explicit_FW_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, size_t width, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Pe_timestamp_explicit_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, Pchar stopChar, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Pe_timestamp_explicit_ME_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, const char *matchRegexp, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Pe_timestamp_explicit_CME_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, Pregexp_t *matchRegexp, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Pe_timestamp_explicit_SE_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, const char *stopRegexp, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Pe_timestamp_explicit_CSE_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, Pregexp_t *stopRegexp, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Pe_date_explicit_FW_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, size_t width, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Pe_date_explicit_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, Pchar stopChar, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Pe_date_explicit_ME_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, const char *matchRegexp, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Pe_date_explicit_CME_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, Pregexp_t *matchRegexp, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Pe_date_explicit_SE_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, const char *stopRegexp, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Pe_date_explicit_CSE_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, Pregexp_t *stopRegexp, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Pe_time_explicit_FW_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, size_t width, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Pe_time_explicit_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, Pchar stopChar, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Pe_time_explicit_ME_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, const char *matchRegexp, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Pe_time_explicit_CME_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, Pregexp_t *matchRegexp, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Pe_time_explicit_SE_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, const char *stopRegexp, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Pe_time_explicit_CSE_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, Pregexp_t *stopRegexp, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Pe_timestamp_FW_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, size_t width
                    );

Perror_t Pe_timestamp_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, Pchar stopChar
                    );

Perror_t Pe_timestamp_ME_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, const char *matchRegexp
                    );

Perror_t Pe_timestamp_CME_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, Pregexp_t *matchRegexp
                    );

Perror_t Pe_timestamp_SE_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, const char *stopRegexp
                    );

Perror_t Pe_timestamp_CSE_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, Pregexp_t *stopRegexp
                    );

Perror_t Pe_date_FW_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Puint32 *res_out,
                    size_t width
                    );

Perror_t Pe_date_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Puint32 *res_out,
                    Pchar stopChar
                    );

Perror_t Pe_date_ME_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Puint32 *res_out,
                    const char *matchRegexp
                    );

Perror_t Pe_date_CME_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Puint32 *res_out,
                    Pregexp_t *matchRegexp
                    );

Perror_t Pe_date_SE_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Puint32 *res_out,
                    const char *stopRegexp
                    );

Perror_t Pe_date_CSE_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Puint32 *res_out,
                    Pregexp_t *stopRegexp
                    );

Perror_t Pe_time_FW_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Puint32 *res_out,
                    size_t width
                    );

Perror_t Pe_time_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Puint32 *res_out,
                    Pchar stopChar
                    );

Perror_t Pe_time_ME_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Puint32 *res_out,
                    const char *matchRegexp
                    );

Perror_t Pe_time_CME_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Puint32 *res_out,
                    Pregexp_t *matchRegexp
                    );

Perror_t Pe_time_SE_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Puint32 *res_out,
                    const char *stopRegexp
                    );

Perror_t Pe_time_CSE_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd, Puint32 *res_out,
                    Pregexp_t *stopRegexp
                    );

Perror_t Ptimestamp_explicit_FW_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, size_t width, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Ptimestamp_explicit_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, Pchar stopChar, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Ptimestamp_explicit_ME_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, const char *matchRegexp, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Ptimestamp_explicit_CME_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, Pregexp_t *matchRegexp, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Ptimestamp_explicit_SE_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, const char *stopRegexp, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Ptimestamp_explicit_CSE_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, Pregexp_t *stopRegexp, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Pdate_explicit_FW_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, size_t width, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Pdate_explicit_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, Pchar stopChar, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Pdate_explicit_ME_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, const char *matchRegexp, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Pdate_explicit_CME_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, Pregexp_t *matchRegexp, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Pdate_explicit_SE_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, const char *stopRegexp, const char *format,
                    Tm_zone_t *tzone
                    );

Perror_t Pdate_explicit_CSE_read(P_t *pads, const Pbase_m *m, Pbase_pd *pd,
                    Puint32 *res_out, Pregexp_t *stopRegexp, const char *format,
                    Tm_zone_t *tzone
                    );