408 lines
18 KiB
C
408 lines
18 KiB
C
/*
|
|
Copyright (c) 2016-2018 Chung, Hyung-Hwan. All rights reserved.
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
modification, are permitted provided that the following conditions
|
|
are met:
|
|
1. Redistributions of source code must retain the above copyright
|
|
notice, this list of conditions and the following disclaimer.
|
|
2. Redistributions in binary form must reproduce the above copyright
|
|
notice, this list of conditions and the following disclaimer in the
|
|
documentation and/or other materials provided with the distribution.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR
|
|
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#ifndef _HAK_FMT_H_
|
|
#define _HAK_FMT_H_
|
|
|
|
#include <hak-cmn.h>
|
|
#include <stdarg.h>
|
|
|
|
/** \file
|
|
* This file defines various formatting functions.
|
|
*/
|
|
|
|
/**
|
|
* The hak_fmt_intmax_flag_t type defines enumerators to change the
|
|
* behavior of hak_fmt_intmax() and hak_fmt_uintmax().
|
|
*/
|
|
enum hak_fmt_intmax_flag_t
|
|
{
|
|
/* Use lower 6 bits to represent base between 2 and 36 inclusive.
|
|
* Upper bits are used for these flag options */
|
|
|
|
/** Don't truncate if the buffer is not large enough */
|
|
HAK_FMT_INTMAX_NOTRUNC = (0x40 << 0),
|
|
#define HAK_FMT_INTMAX_NOTRUNC HAK_FMT_INTMAX_NOTRUNC
|
|
#define HAK_FMT_UINTMAX_NOTRUNC HAK_FMT_INTMAX_NOTRUNC
|
|
#define HAK_FMT_INTMAX_TO_BCSTR_NOTRUNC HAK_FMT_INTMAX_NOTRUNC
|
|
#define HAK_FMT_UINTMAX_TO_BCSTR_NOTRUNC HAK_FMT_INTMAX_NOTRUNC
|
|
#define HAK_FMT_INTMAX_TO_UCSTR_NOTRUNC HAK_FMT_INTMAX_NOTRUNC
|
|
#define HAK_FMT_UINTMAX_TO_UCSTR_NOTRUNC HAK_FMT_INTMAX_NOTRUNC
|
|
#define HAK_FMT_INTMAX_TO_OOCSTR_NOTRUNC HAK_FMT_INTMAX_NOTRUNC
|
|
#define HAK_FMT_UINTMAX_TO_OOCSTR_NOTRUNC HAK_FMT_INTMAX_NOTRUNC
|
|
|
|
/** Don't append a terminating null */
|
|
HAK_FMT_INTMAX_NONULL = (0x40 << 1),
|
|
#define HAK_FMT_INTMAX_NONULL HAK_FMT_INTMAX_NONULL
|
|
#define HAK_FMT_UINTMAX_NONULL HAK_FMT_INTMAX_NONULL
|
|
#define HAK_FMT_INTMAX_TO_BCSTR_NONULL HAK_FMT_INTMAX_NONULL
|
|
#define HAK_FMT_UINTMAX_TO_BCSTR_NONULL HAK_FMT_INTMAX_NONULL
|
|
#define HAK_FMT_INTMAX_TO_UCSTR_NONULL HAK_FMT_INTMAX_NONULL
|
|
#define HAK_FMT_UINTMAX_TO_UCSTR_NONULL HAK_FMT_INTMAX_NONULL
|
|
#define HAK_FMT_INTMAX_TO_OOCSTR_NONULL HAK_FMT_INTMAX_NONULL
|
|
#define HAK_FMT_UINTMAX_TO_OOCSTR_NONULL HAK_FMT_INTMAX_NONULL
|
|
|
|
/** Produce no digit for a value of zero */
|
|
HAK_FMT_INTMAX_NOZERO = (0x40 << 2),
|
|
#define HAK_FMT_INTMAX_NOZERO HAK_FMT_INTMAX_NOZERO
|
|
#define HAK_FMT_UINTMAX_NOZERO HAK_FMT_INTMAX_NOZERO
|
|
#define HAK_FMT_INTMAX_TO_BCSTR_NOZERO HAK_FMT_INTMAX_NOZERO
|
|
#define HAK_FMT_UINTMAX_TO_BCSTR_NOZERO HAK_FMT_INTMAX_NOZERO
|
|
#define HAK_FMT_INTMAX_TO_UCSTR_NOZERO HAK_FMT_INTMAX_NOZERO
|
|
#define HAK_FMT_UINTMAX_TO_UCSTR_NOZERO HAK_FMT_INTMAX_NOZERO
|
|
#define HAK_FMT_INTMAX_TO_OOCSTR_NOZERO HAK_FMT_INTMAX_NOZERO
|
|
#define HAK_FMT_UINTMAX_TO_OOCSTR_NOZERO HAK_FMT_INTMAX_NOZERO
|
|
|
|
/** Produce a leading zero for a non-zero value */
|
|
HAK_FMT_INTMAX_ZEROLEAD = (0x40 << 3),
|
|
#define HAK_FMT_INTMAX_ZEROLEAD HAK_FMT_INTMAX_ZEROLEAD
|
|
#define HAK_FMT_UINTMAX_ZEROLEAD HAK_FMT_INTMAX_ZEROLEAD
|
|
#define HAK_FMT_INTMAX_TO_BCSTR_ZEROLEAD HAK_FMT_INTMAX_ZEROLEAD
|
|
#define HAK_FMT_UINTMAX_TO_BCSTR_ZEROLEAD HAK_FMT_INTMAX_ZEROLEAD
|
|
#define HAK_FMT_INTMAX_TO_UCSTR_ZEROLEAD HAK_FMT_INTMAX_ZEROLEAD
|
|
#define HAK_FMT_UINTMAX_TO_UCSTR_ZEROLEAD HAK_FMT_INTMAX_ZEROLEAD
|
|
#define HAK_FMT_INTMAX_TO_OOCSTR_ZEROLEAD HAK_FMT_INTMAX_ZEROLEAD
|
|
#define HAK_FMT_UINTMAX_TO_OOCSTR_ZEROLEAD HAK_FMT_INTMAX_ZEROLEAD
|
|
|
|
/** Use uppercase letters for alphabetic digits */
|
|
HAK_FMT_INTMAX_UPPERCASE = (0x40 << 4),
|
|
#define HAK_FMT_INTMAX_UPPERCASE HAK_FMT_INTMAX_UPPERCASE
|
|
#define HAK_FMT_UINTMAX_UPPERCASE HAK_FMT_INTMAX_UPPERCASE
|
|
#define HAK_FMT_INTMAX_TO_BCSTR_UPPERCASE HAK_FMT_INTMAX_UPPERCASE
|
|
#define HAK_FMT_UINTMAX_TO_BCSTR_UPPERCASE HAK_FMT_INTMAX_UPPERCASE
|
|
#define HAK_FMT_INTMAX_TO_UCSTR_UPPERCASE HAK_FMT_INTMAX_UPPERCASE
|
|
#define HAK_FMT_UINTMAX_TO_UCSTR_UPPERCASE HAK_FMT_INTMAX_UPPERCASE
|
|
#define HAK_FMT_INTMAX_TO_OOCSTR_UPPERCASE HAK_FMT_INTMAX_UPPERCASE
|
|
#define HAK_FMT_UINTMAX_TO_OOCSTR_UPPERCASE HAK_FMT_INTMAX_UPPERCASE
|
|
|
|
/** Insert a plus sign for a positive integer including 0 */
|
|
HAK_FMT_INTMAX_PLUSSIGN = (0x40 << 5),
|
|
#define HAK_FMT_INTMAX_PLUSSIGN HAK_FMT_INTMAX_PLUSSIGN
|
|
#define HAK_FMT_UINTMAX_PLUSSIGN HAK_FMT_INTMAX_PLUSSIGN
|
|
#define HAK_FMT_INTMAX_TO_BCSTR_PLUSSIGN HAK_FMT_INTMAX_PLUSSIGN
|
|
#define HAK_FMT_UINTMAX_TO_BCSTR_PLUSSIGN HAK_FMT_INTMAX_PLUSSIGN
|
|
#define HAK_FMT_INTMAX_TO_UCSTR_PLUSSIGN HAK_FMT_INTMAX_PLUSSIGN
|
|
#define HAK_FMT_UINTMAX_TO_UCSTR_PLUSSIGN HAK_FMT_INTMAX_PLUSSIGN
|
|
#define HAK_FMT_INTMAX_TO_OOCSTR_PLUSSIGN HAK_FMT_INTMAX_PLUSSIGN
|
|
#define HAK_FMT_UINTMAX_TO_OOCSTR_PLUSSIGN HAK_FMT_INTMAX_PLUSSIGN
|
|
|
|
/** Insert a space for a positive integer including 0 */
|
|
HAK_FMT_INTMAX_EMPTYSIGN = (0x40 << 6),
|
|
#define HAK_FMT_INTMAX_EMPTYSIGN HAK_FMT_INTMAX_EMPTYSIGN
|
|
#define HAK_FMT_UINTMAX_EMPTYSIGN HAK_FMT_INTMAX_EMPTYSIGN
|
|
#define HAK_FMT_INTMAX_TO_BCSTR_EMPTYSIGN HAK_FMT_INTMAX_EMPTYSIGN
|
|
#define HAK_FMT_UINTMAX_TO_BCSTR_EMPTYSIGN HAK_FMT_INTMAX_EMPTYSIGN
|
|
#define HAK_FMT_INTMAX_TO_UCSTR_EMPTYSIGN HAK_FMT_INTMAX_EMPTYSIGN
|
|
#define HAK_FMT_UINTMAX_TO_UCSTR_EMPTYSIGN HAK_FMT_INTMAX_EMPTYSIGN
|
|
|
|
/** Fill the right part of the string */
|
|
HAK_FMT_INTMAX_FILLRIGHT = (0x40 << 7),
|
|
#define HAK_FMT_INTMAX_FILLRIGHT HAK_FMT_INTMAX_FILLRIGHT
|
|
#define HAK_FMT_UINTMAX_FILLRIGHT HAK_FMT_INTMAX_FILLRIGHT
|
|
#define HAK_FMT_INTMAX_TO_BCSTR_FILLRIGHT HAK_FMT_INTMAX_FILLRIGHT
|
|
#define HAK_FMT_UINTMAX_TO_BCSTR_FILLRIGHT HAK_FMT_INTMAX_FILLRIGHT
|
|
#define HAK_FMT_INTMAX_TO_UCSTR_FILLRIGHT HAK_FMT_INTMAX_FILLRIGHT
|
|
#define HAK_FMT_UINTMAX_TO_UCSTR_FILLRIGHT HAK_FMT_INTMAX_FILLRIGHT
|
|
#define HAK_FMT_INTMAX_TO_OOCSTR_FILLRIGHT HAK_FMT_INTMAX_FILLRIGHT
|
|
#define HAK_FMT_UINTMAX_TO_OOCSTR_FILLRIGHT HAK_FMT_INTMAX_FILLRIGHT
|
|
|
|
/** Fill between the sign chacter and the digit part */
|
|
HAK_FMT_INTMAX_FILLCENTER = (0x40 << 8)
|
|
#define HAK_FMT_INTMAX_FILLCENTER HAK_FMT_INTMAX_FILLCENTER
|
|
#define HAK_FMT_UINTMAX_FILLCENTER HAK_FMT_INTMAX_FILLCENTER
|
|
#define HAK_FMT_INTMAX_TO_BCSTR_FILLCENTER HAK_FMT_INTMAX_FILLCENTER
|
|
#define HAK_FMT_UINTMAX_TO_BCSTR_FILLCENTER HAK_FMT_INTMAX_FILLCENTER
|
|
#define HAK_FMT_INTMAX_TO_UCSTR_FILLCENTER HAK_FMT_INTMAX_FILLCENTER
|
|
#define HAK_FMT_UINTMAX_TO_UCSTR_FILLCENTER HAK_FMT_INTMAX_FILLCENTER
|
|
#define HAK_FMT_INTMAX_TO_OOCSTR_FILLCENTER HAK_FMT_INTMAX_FILLCENTER
|
|
#define HAK_FMT_UINTMAX_TO_OOCSTR_FILLCENTER HAK_FMT_INTMAX_FILLCENTER
|
|
};
|
|
|
|
/* =========================================================================
|
|
* FORMATTED OUTPUT
|
|
* ========================================================================= */
|
|
typedef struct hak_fmtout_t hak_fmtout_t;
|
|
|
|
typedef int (*hak_fmtout_putbchars_t) (
|
|
hak_t* hak,
|
|
hak_fmtout_t* fmtout,
|
|
const hak_bch_t* ptr,
|
|
hak_oow_t len
|
|
);
|
|
|
|
typedef int (*hak_fmtout_putuchars_t) (
|
|
hak_t* hak,
|
|
hak_fmtout_t* fmtout,
|
|
const hak_uch_t* ptr,
|
|
hak_oow_t len
|
|
);
|
|
|
|
typedef int (*hak_fmtout_putobj_t) (
|
|
hak_t* hak,
|
|
hak_fmtout_t* fmtout,
|
|
hak_oop_t obj
|
|
);
|
|
|
|
enum hak_fmtout_fmt_type_t
|
|
{
|
|
HAK_FMTOUT_FMT_TYPE_BCH = 0,
|
|
HAK_FMTOUT_FMT_TYPE_UCH
|
|
};
|
|
typedef enum hak_fmtout_fmt_type_t hak_fmtout_fmt_type_t;
|
|
|
|
struct hak_fmtout_t
|
|
{
|
|
hak_oow_t count; /* out */
|
|
|
|
hak_mmgr_t* mmgr; /* in */
|
|
hak_fmtout_putbchars_t putbchars; /* in */
|
|
hak_fmtout_putuchars_t putuchars; /* in */
|
|
hak_fmtout_putobj_t putobj; /* in - %O is not handled if it's not set. */
|
|
hak_bitmask_t mask; /* in */
|
|
void* ctx; /* in */
|
|
|
|
/* internally set as input */
|
|
hak_fmtout_fmt_type_t fmt_type;
|
|
const void* fmt_str;
|
|
};
|
|
|
|
/* =========================================================================
|
|
* FORMATTED INPUT
|
|
* ========================================================================= */
|
|
|
|
typedef struct hak_fmtin_t hak_fmtin_t;
|
|
|
|
struct hak_fmtin_t
|
|
{
|
|
#if 0
|
|
hak_fmtin_getbchars_t getbchars; /* in */
|
|
hak_fmtin_getuchars_t getuchars; /* in */
|
|
#endif
|
|
void* ctx; /* in */
|
|
};
|
|
|
|
#if defined(__cplusplus)
|
|
extern "C" {
|
|
#endif
|
|
|
|
/**
|
|
* The hak_fmt_intmax_to_bcstr() function formats an integer \a value to a
|
|
* multibyte string according to the given base and writes it to a buffer
|
|
* pointed to by \a buf. It writes to the buffer at most \a size characters
|
|
* including the terminating null. The base must be between 2 and 36 inclusive
|
|
* and can be ORed with zero or more #hak_fmt_intmax_to_bcstr_flag_t enumerators.
|
|
* This ORed value is passed to the function via the \a base_and_flags
|
|
* parameter. If the formatted string is shorter than \a bufsize, the redundant
|
|
* slots are filled with the fill character \a fillchar if it is not a null
|
|
* character. The filling behavior is determined by the flags shown below:
|
|
*
|
|
* - If #HAK_FMT_INTMAX_TO_BCSTR_FILLRIGHT is set in \a base_and_flags, slots
|
|
* after the formatting string are filled.
|
|
* - If #HAK_FMT_INTMAX_TO_BCSTR_FILLCENTER is set in \a base_and_flags, slots
|
|
* before the formatting string are filled. However, if it contains the
|
|
* sign character, the slots between the sign character and the digit part
|
|
* are filled.
|
|
* - If neither #HAK_FMT_INTMAX_TO_BCSTR_FILLRIGHT nor #HAK_FMT_INTMAX_TO_BCSTR_FILLCENTER
|
|
* , slots before the formatting string are filled.
|
|
*
|
|
* The \a precision parameter specified the minimum number of digits to
|
|
* produce from the \a value. If \a value produces fewer digits than
|
|
* \a precision, the actual digits are padded with '0' to meet the precision
|
|
* requirement. You can pass a negative number if you don't wish to specify
|
|
* precision.
|
|
*
|
|
* The terminating null is not added if #HAK_FMT_INTMAX_TO_BCSTR_NONULL is set;
|
|
* The #HAK_FMT_INTMAX_TO_BCSTR_UPPERCASE flag indicates that the function should
|
|
* use the uppercase letter for a alphabetic digit;
|
|
* You can set #HAK_FMT_INTMAX_TO_BCSTR_NOTRUNC if you require lossless formatting.
|
|
* The #HAK_FMT_INTMAX_TO_BCSTR_PLUSSIGN flag and #HAK_FMT_INTMAX_TO_BCSTR_EMPTYSIGN
|
|
* ensures that the plus sign and a space is added for a positive integer
|
|
* including 0 respectively.
|
|
* The #HAK_FMT_INTMAX_TO_BCSTR_ZEROLEAD flag ensures that the numeric string
|
|
* begins with '0' before applying the prefix.
|
|
* You can set the #HAK_FMT_INTMAX_TO_BCSTR_NOZERO flag if you want the value of
|
|
* 0 to produce nothing. If both #HAK_FMT_INTMAX_TO_BCSTR_NOZERO and
|
|
* #HAK_FMT_INTMAX_TO_BCSTR_ZEROLEAD are specified, '0' is still produced.
|
|
*
|
|
* If \a prefix is not #HAK_NULL, it is inserted before the digits.
|
|
*
|
|
* \return
|
|
* - -1 if the base is not between 2 and 36 inclusive.
|
|
* - negated number of characters required for lossless formatting
|
|
* - if \a bufsize is 0.
|
|
* - if #HAK_FMT_INTMAX_TO_BCSTR_NOTRUNC is set and \a bufsize is less than
|
|
* the minimum required for lossless formatting.
|
|
* - number of characters written to the buffer excluding a terminating
|
|
* null in all other cases.
|
|
*/
|
|
HAK_EXPORT int hak_fmt_intmax_to_bcstr (
|
|
hak_bch_t* buf, /**< buffer pointer */
|
|
int bufsize, /**< buffer size */
|
|
hak_intmax_t value, /**< integer to format */
|
|
int base_and_flags, /**< base ORed with flags */
|
|
int precision, /**< precision */
|
|
hak_bch_t fillchar, /**< fill character */
|
|
const hak_bch_t* prefix /**< prefix */
|
|
);
|
|
|
|
/**
|
|
* The hak_fmt_intmax_to_ucstr() function formats an integer \a value to a
|
|
* wide-character string according to the given base and writes it to a buffer
|
|
* pointed to by \a buf. It writes to the buffer at most \a size characters
|
|
* including the terminating null. The base must be between 2 and 36 inclusive
|
|
* and can be ORed with zero or more #hak_fmt_intmax_to_ucstr_flag_t enumerators.
|
|
* This ORed value is passed to the function via the \a base_and_flags
|
|
* parameter. If the formatted string is shorter than \a bufsize, the redundant
|
|
* slots are filled with the fill character \a fillchar if it is not a null
|
|
* character. The filling behavior is determined by the flags shown below:
|
|
*
|
|
* - If #HAK_FMT_INTMAX_TO_UCSTR_FILLRIGHT is set in \a base_and_flags, slots
|
|
* after the formatting string are filled.
|
|
* - If #HAK_FMT_INTMAX_TO_UCSTR_FILLCENTER is set in \a base_and_flags, slots
|
|
* before the formatting string are filled. However, if it contains the
|
|
* sign character, the slots between the sign character and the digit part
|
|
* are filled.
|
|
* - If neither #HAK_FMT_INTMAX_TO_UCSTR_FILLRIGHT nor #HAK_FMT_INTMAX_TO_UCSTR_FILLCENTER
|
|
* , slots before the formatting string are filled.
|
|
*
|
|
* The \a precision parameter specified the minimum number of digits to
|
|
* produce from the \ value. If \a value produces fewer digits than
|
|
* \a precision, the actual digits are padded with '0' to meet the precision
|
|
* requirement. You can pass a negative number if don't wish to specify
|
|
* precision.
|
|
*
|
|
* The terminating null is not added if #HAK_FMT_INTMAX_TO_UCSTR_NONULL is set;
|
|
* The #HAK_FMT_INTMAX_TO_UCSTR_UPPERCASE flag indicates that the function should
|
|
* use the uppercase letter for a alphabetic digit;
|
|
* You can set #HAK_FMT_INTMAX_TO_UCSTR_NOTRUNC if you require lossless formatting.
|
|
* The #HAK_FMT_INTMAX_TO_UCSTR_PLUSSIGN flag and #HAK_FMT_INTMAX_TO_UCSTR_EMPTYSIGN
|
|
* ensures that the plus sign and a space is added for a positive integer
|
|
* including 0 respectively.
|
|
* The #HAK_FMT_INTMAX_TO_UCSTR_ZEROLEAD flag ensures that the numeric string
|
|
* begins with 0 before applying the prefix.
|
|
* You can set the #HAK_FMT_INTMAX_TO_UCSTR_NOZERO flag if you want the value of
|
|
* 0 to produce nothing. If both #HAK_FMT_INTMAX_TO_UCSTR_NOZERO and
|
|
* #HAK_FMT_INTMAX_TO_UCSTR_ZEROLEAD are specified, '0' is still produced.
|
|
*
|
|
* If \a prefix is not #HAK_NULL, it is inserted before the digits.
|
|
*
|
|
* \return
|
|
* - -1 if the base is not between 2 and 36 inclusive.
|
|
* - negated number of characters required for lossless formatting
|
|
* - if \a bufsize is 0.
|
|
* - if #HAK_FMT_INTMAX_TO_UCSTR_NOTRUNC is set and \a bufsize is less than
|
|
* the minimum required for lossless formatting.
|
|
* - number of characters written to the buffer excluding a terminating
|
|
* null in all other cases.
|
|
*/
|
|
HAK_EXPORT int hak_fmt_intmax_to_ucstr (
|
|
hak_uch_t* buf, /**< buffer pointer */
|
|
int bufsize, /**< buffer size */
|
|
hak_intmax_t value, /**< integer to format */
|
|
int base_and_flags, /**< base ORed with flags */
|
|
int precision, /**< precision */
|
|
hak_uch_t fillchar, /**< fill character */
|
|
const hak_uch_t* prefix /**< prefix */
|
|
);
|
|
|
|
/**
|
|
* The hak_fmt_uintmax_to_bcstr() function formats an unsigned integer \a value
|
|
* to a multibyte string buffer. It behaves the same as hak_fmt_intmax_to_bcstr()
|
|
* except that it handles an unsigned integer.
|
|
*/
|
|
HAK_EXPORT int hak_fmt_uintmax_to_bcstr (
|
|
hak_bch_t* buf, /**< buffer pointer */
|
|
int bufsize, /**< buffer size */
|
|
hak_uintmax_t value, /**< integer to format */
|
|
int base_and_flags, /**< base ORed with flags */
|
|
int precision, /**< precision */
|
|
hak_bch_t fillchar, /**< fill character */
|
|
const hak_bch_t* prefix /**< prefix */
|
|
);
|
|
|
|
/**
|
|
* The hak_fmt_uintmax_to_ucstr() function formats an unsigned integer \a value
|
|
* to a multibyte string buffer. It behaves the same as hak_fmt_intmax_to_ucstr()
|
|
* except that it handles an unsigned integer.
|
|
*/
|
|
HAK_EXPORT int hak_fmt_uintmax_to_ucstr (
|
|
hak_uch_t* buf, /**< buffer pointer */
|
|
int bufsize, /**< buffer size */
|
|
hak_uintmax_t value, /**< integer to format */
|
|
int base_and_flags, /**< base ORed with flags */
|
|
int precision, /**< precision */
|
|
hak_uch_t fillchar, /**< fill character */
|
|
const hak_uch_t* prefix /**< prefix */
|
|
);
|
|
|
|
#if defined(HAK_OOCH_IS_BCH)
|
|
# define hak_fmt_intmax_to_oocstr hak_fmt_intmax_to_bcstr
|
|
# define hak_fmt_uintmax_to_oocstr hak_fmt_uintmax_to_bcstr
|
|
#else
|
|
# define hak_fmt_intmax_to_oocstr hak_fmt_intmax_to_ucstr
|
|
# define hak_fmt_uintmax_to_oocstr hak_fmt_uintmax_to_ucstr
|
|
#endif
|
|
|
|
|
|
/* TODO: hak_fmt_fltmax_to_bcstr()... hak_fmt_fltmax_to_ucstr() */
|
|
|
|
|
|
/* =========================================================================
|
|
* FORMATTED OUTPUT
|
|
* ========================================================================= */
|
|
HAK_EXPORT int hak_bfmt_outv (
|
|
hak_t* hak,
|
|
hak_fmtout_t* fmtout,
|
|
const hak_bch_t* fmt,
|
|
va_list ap
|
|
);
|
|
|
|
HAK_EXPORT int hak_ufmt_outv (
|
|
hak_t* hak,
|
|
hak_fmtout_t* fmtout,
|
|
const hak_uch_t* fmt,
|
|
va_list ap
|
|
);
|
|
|
|
|
|
HAK_EXPORT int hak_bfmt_out (
|
|
hak_t* hak,
|
|
hak_fmtout_t* fmtout,
|
|
const hak_bch_t* fmt,
|
|
...
|
|
);
|
|
|
|
HAK_EXPORT int hak_ufmt_out (
|
|
hak_t* hak,
|
|
hak_fmtout_t* fmtout,
|
|
const hak_uch_t* fmt,
|
|
...
|
|
);
|
|
|
|
#if defined(__cplusplus)
|
|
}
|
|
#endif
|
|
|
|
#endif
|