sixtp-utils.cpp

/********************************************************************
 * sixtp-utils.c                                                    *
 * Copyright (c) 2001 Gnumatic, Inc.                                *
 *                                                                  *
 * This program 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 2 of   *
 * the License, or (at your option) any later version.              *
 *                                                                  *
 * This program 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, contact:                        *
 *                                                                  *
 * Free Software Foundation           Voice:  +1-617-542-5942       *
 * 51 Franklin Street, Fifth Floor    Fax:    +1-617-542-2652       *
 * Boston, MA  02110-1301,  USA       gnu@gnu.org                   *
 *                                                                  *
 ********************************************************************/
 
#include <guid.hpp>
#include <config.h>
 
#include <ctype.h>
#include <glib.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include <time.h>
#include <errno.h>
 
#ifndef HAVE_STRPTIME
#include "strptime.h"
#endif
#include <gnc-date.h>
 
#include "sixtp.h"
#include "sixtp-utils.h"
 
#include <charconv>
#include <cctype>
 
static QofLogModule log_module = GNC_MOD_IO;
 
gboolean
isspace_str (const gchar* str, int nomorethan)
{
    const gchar* cursor = str;
    while (*cursor && (nomorethan != 0))
    {
        if (!isspace (*cursor))
        {
            return (FALSE);
        }
        cursor++;
        nomorethan--;
    }
    return (TRUE);
}
 
gboolean
allow_and_ignore_only_whitespace (GSList* sibling_data,
                                  gpointer parent_data,
                                  gpointer global_data,
                                  gpointer* result,
                                  const char* text,
                                  int length)
{
    return (isspace_str (text, length));
}
 
gboolean
generic_accumulate_chars (GSList* sibling_data,
                          gpointer parent_data,
                          gpointer global_data,
                          gpointer* result,
 
                          const char* text,
                          int length)
{
    gchar* copytxt = g_strndup (text, length);
    g_return_val_if_fail (result, FALSE);
 
    *result = copytxt;
    return (TRUE);
}
 
 
void
generic_free_data_for_children (gpointer data_for_children,
                                GSList* data_from_children,
                                GSList* sibling_data,
                                gpointer parent_data,
                                gpointer global_data,
                                gpointer* result,
                                const gchar* tag)
{
    if (data_for_children) g_free (data_for_children);
}
 
gchar*
concatenate_child_result_chars (GSList* data_from_children)
{
    GSList* lp;
    gchar* name = g_strdup ("");
 
    g_return_val_if_fail (name, NULL);
 
    /* child data lists are in reverse chron order */
    data_from_children = g_slist_reverse (g_slist_copy (data_from_children));
 
    for (lp = data_from_children; lp; lp = lp->next)
    {
        sixtp_child_result* cr = (sixtp_child_result*) lp->data;
        if (cr->type != SIXTP_CHILD_RESULT_CHARS)
        {
            PERR ("result type is not chars");
            g_slist_free (data_from_children);
            g_free (name);
            return (NULL);
        }
        else
        {
            char* temp;
            temp = g_strconcat (name, (gchar*) cr->data, nullptr);
            g_free (name);
            name = temp;
        }
    }
    g_slist_free (data_from_children);
    return (name);
}
 
/****************************************************************************/
/* string to data converters...
 */
 
 
template <typename T>
static bool parse_chars_into_num (std::string_view sv, T* num_ptr)
{
    if (!num_ptr)
        return false;
 
    while (!sv.empty() && std::isspace (sv.front ())) sv.remove_prefix (1);
    while (!sv.empty() && std::isspace (sv.back ())) sv.remove_suffix (1);
 
    auto res = std::from_chars (sv.begin(), sv.end(), *num_ptr);
    return (res.ec == std::errc{} && res.ptr == sv.end());
}
 
/*********/
/* double
 */
 
gboolean
string_to_double (std::string_view sv, double* result)
{
#if __cpp_lib_to_chars >= 201611L
    return parse_chars_into_num<double>(sv, result);
#else
    // because from_chars in cpp < 201611L cannot parse floats
    g_return_val_if_fail (result, false);
    std::string str{sv};
    char* endptr = nullptr;
    *result = std::strtod (str.c_str(), &endptr);
    return (endptr != str.c_str());
#endif
}
 
/*********/
/* gint64
 */
gboolean
string_to_gint64 (std::string_view sv, gint64* v)
{
    return parse_chars_into_num<gint64>(sv, v);
}
 
/*********/
/* guint16
 */
gboolean
string_to_guint16 (std::string_view sv, guint16* v)
{
    return parse_chars_into_num<guint16>(sv, v);
}
 
/*********/
/* guint
 */
gboolean
string_to_guint (std::string_view sv, guint* v)
{
    return parse_chars_into_num<guint>(sv, v);
}
 
/************/
/* hex string
 */
 
gboolean
hex_string_to_binary (const gchar* str,  void** v, guint64* data_len)
{
    /* Convert a hex string to binary.  No whitespace allowed. */
    const gchar* cursor = str;
    guint64 str_len;
    gboolean error = FALSE;
 
    g_return_val_if_fail (str, FALSE);
    g_return_val_if_fail (v, FALSE);
    g_return_val_if_fail (data_len, FALSE);
 
    str_len = strlen (str);
    /* Since no whitespace is allowed and hex encoding is 2 text chars
       per binary char, the result must be half the input size and the
       input size must be even. */
    if ((str_len % 2) != 0) return (FALSE);
    *data_len = 0;
    *v = g_new0 (char, str_len / 2);
 
    g_return_val_if_fail (*v, FALSE);
 
    while (*cursor && * (cursor + 1))
    {
        gchar tmpstr[2];
        int tmpint;
 
        if (isspace (*cursor) || isspace (* (cursor + 1)))
        {
            error = TRUE;
        }
        else
        {
            int num_read;
            tmpstr[0] = *cursor;
            tmpstr[0] = * (cursor + 1);
 
            if ((sscanf (tmpstr, "%x%n", &tmpint, &num_read) < 1)
                || (num_read != 2))
            {
                error = TRUE;
            }
            else
            {
                * ((gchar*) (v + *data_len)) = tmpint;
                *data_len += 1;
                cursor += 2;
            }
        }
    }
 
    if (error || (*data_len != (str_len / 2)))
    {
        g_free (*v);
        *v = NULL;
        *data_len = 0;
        return (FALSE);
    }
 
    return (TRUE);
}
 
/***************************************************************************/
/* simple chars only parser - just grabs all it's contained chars and
   does what you specify in the end handler - if you pass NULL as the
   end handler to simple_chars_only_parser_new, the characters are just
   passed to the parent as a new string.
 
   input: NA
   returns: gchar array allocated via g_new, etc.
 
   start: NA
   chars: generic_accumulate_chars.
   end: varies - default is to concatenate all accumulated chars and return.
 
   cleanup-result: g_free (for chars)
   cleanup-chars: g_free (for chars)
   fail: NA
   result-fail: g_free (for chars)
   chars-fail: g_free (for chars)
 
 */
 
gboolean
generic_return_chars_end_handler (gpointer data_for_children,
                                  GSList* data_from_children,
                                  GSList* sibling_data,
                                  gpointer parent_data,
                                  gpointer global_data,
                                  gpointer* result,
                                  const gchar* tag)
{
    gchar* txt = NULL;
 
    txt = concatenate_child_result_chars (data_from_children);
    g_return_val_if_fail (txt, FALSE);
    *result = txt;
    return (TRUE);
}
 
 
sixtp*
simple_chars_only_parser_new (sixtp_end_handler end_handler)
{
    return sixtp_set_any (
               sixtp_new (), FALSE,
               SIXTP_END_HANDLER_ID, (end_handler
                                      ? end_handler
                                      : generic_return_chars_end_handler),
               SIXTP_CHARACTERS_HANDLER_ID, generic_accumulate_chars,
               SIXTP_CLEANUP_RESULT_ID, sixtp_child_free_data,
               SIXTP_CLEANUP_CHARS_ID, sixtp_child_free_data,
               SIXTP_RESULT_FAIL_ID, sixtp_child_free_data,
               SIXTP_CHARS_FAIL_ID, sixtp_child_free_data,
               SIXTP_NO_MORE_HANDLERS);
}
 
/****************************************************************************/
/* generic timespec handler for XML Version 1 files.
 
   A collection of node functions intended to parse a sub-node set
   that looks like this:
 
     <date-posted>
       <s>Mon, 05 Jun 2000 23:16:19 -0500</s>
       <ns>658864000</ns>
     </date-posted>
 
   and produce a time64.  The start handler for the top allocates
   the time64 and passes it to the children.  The <s> block sets
   the seconds and the <ns> block is ignored.  If
   all goes well, returns the time64 as the result.
*/
 
/* Top level timespec node:
 
   input: user end handler *
   returns: time64
 
   start: Allocates Time64ParseInfo* for data_for_children.
   characters: none (whitespace only).
   end: g_free Time64ParseInfo + any other actions
 
   cleanup-result: NA
   cleanup-chars: NA
   fail: g_free data_for_children.
   result-fail: g_free data_for_children.
   chars-fail: NA
 
 */
 
gboolean
generic_timespec_start_handler (GSList* sibling_data, gpointer parent_data,
                                gpointer global_data,
                                gpointer* data_for_children, gpointer* result,
                                const gchar* tag, gchar** attrs)
{
    Time64ParseInfo* tsp = g_new0 (Time64ParseInfo, 1);
    g_return_val_if_fail (tsp, FALSE);
    *data_for_children = tsp;
    return (TRUE);
}
 
/* You can't use this function directly.  You have to call it from
   your own end handler.  If it returns TRUE, *result will contain the
   new timespec.  Otherwise, you can presume that everything's been
   cleaned up properly and return FALSE.  */
gboolean
timespec_parse_ok (Time64ParseInfo* info)
{
    return info->s_block_count != 1;
}
 
/* generic_timespec_end_handler - must be customized and provided by
   the user. */
 
/* <s> (parent timespec-node)
 
   input: Time64ParseInfo *
   returns: NA
 
   start: NA
   characters: accumulate.
   end: convert characters to secs part of input time64 and inc s_block_count.
 
   cleanup-result: NA
   cleanup-chars: g_free data.
   fail: NA
   result-fail: NA
   chars-fail: g_free data.
 
 */
 
gboolean
generic_timespec_secs_end_handler (gpointer data_for_children,
                                   GSList*  data_from_children, GSList* sibling_data,
                                   gpointer parent_data, gpointer global_data,
                                   gpointer* result, const gchar* tag)
{
    gchar* txt = NULL;
    Time64ParseInfo* info = (Time64ParseInfo*) parent_data;
 
    g_return_val_if_fail (parent_data, FALSE);
 
    txt = concatenate_child_result_chars (data_from_children);
    g_return_val_if_fail (txt, FALSE);
 
    info->time = gnc_iso8601_to_time64_gmt (txt);
    g_free (txt);
 
// gnc_iso8601_to_time64_gmt returns INT64_MAX on failure.
    g_return_val_if_fail (info->time < INT64_MAX, FALSE);
 
    info->s_block_count++;
    return (TRUE);
}
 
/* <s> (parent timespec-node)
 
   input: Time64ParseInfo *
   returns: NA
 
   start: NA
   characters: accumulate.
   end: NA
 
   cleanup-result: NA
   cleanup-chars: NA.
   fail: NA
   result-fail: NA
   chars-fail: g_free data.
 
 */
 
gboolean
generic_timespec_nsecs_end_handler (gpointer data_for_children,
                                    GSList*  data_from_children, GSList* sibling_data,
                                    gpointer parent_data, gpointer global_data,
                                    gpointer* result, const gchar* tag)
{
    return TRUE;
}
 
static sixtp*
timespec_sixtp_new (sixtp_end_handler ender)
{
    return sixtp_set_any (
               sixtp_new (), FALSE,
               SIXTP_CHARACTERS_HANDLER_ID, generic_accumulate_chars,
               SIXTP_END_HANDLER_ID, ender,
               SIXTP_CLEANUP_CHARS_ID, sixtp_child_free_data,
               SIXTP_CHARS_FAIL_ID, sixtp_child_free_data,
               SIXTP_NO_MORE_HANDLERS);
}
 
sixtp*
generic_timespec_parser_new (sixtp_end_handler end_handler)
{
    sixtp* top_level =
        sixtp_set_any (sixtp_new (), FALSE,
                       SIXTP_START_HANDLER_ID, generic_timespec_start_handler,
                       SIXTP_CHARACTERS_HANDLER_ID, allow_and_ignore_only_whitespace,
                       SIXTP_END_HANDLER_ID, end_handler,
                       SIXTP_CLEANUP_RESULT_ID, sixtp_child_free_data,
                       SIXTP_FAIL_HANDLER_ID, generic_free_data_for_children,
                       SIXTP_RESULT_FAIL_ID, sixtp_child_free_data,
                       SIXTP_NO_MORE_HANDLERS);
    g_return_val_if_fail (top_level, NULL);
 
    if (!sixtp_add_some_sub_parsers (
            top_level, TRUE,
            "s", timespec_sixtp_new (generic_timespec_secs_end_handler),
            "ns", timespec_sixtp_new (generic_timespec_nsecs_end_handler),
            NULL, NULL))
    {
        return NULL;
    }
 
    return (top_level);
}
 
/****************************************************************************/
/* <?> generic guid handler...
 
   Attempts to parse the current accumulated characters data as a guid
   and return it.
 
   input: NA
   returns: GncGUID*
 
   start: NA
   characters: return string copy for accumulation in end handler.
   end: concatenate all chars and create and return GncGUID*, if possible.
 
   cleanup-result: g_free the GncGUID*
   cleanup-chars: g_free the result string.
   fail: NA
   result-fail: g_free the GncGUID*
   chars-fail: g_free the result string.
 
 */
 
gboolean
generic_guid_end_handler (gpointer data_for_children,
                          GSList*  data_from_children, GSList* sibling_data,
                          gpointer parent_data, gpointer global_data,
                          gpointer* result, const gchar* tag)
{
    gchar* txt = NULL;
    GncGUID* gid;
    gboolean ok;
 
    txt = concatenate_child_result_chars (data_from_children);
    g_return_val_if_fail (txt, FALSE);
 
    gid = g_new (GncGUID, 1);
    if (!gid)
    {
        g_free (txt);
        return (FALSE);
    }
 
    ok = string_to_guid (txt, gid);
    g_free (txt);
 
    if (!ok)
    {
        PERR ("couldn't parse GncGUID");
        g_free (gid);
        return (FALSE);
    }
 
    *result = gid;
    return (TRUE);
}
 
sixtp*
generic_guid_parser_new (void)
{
    return sixtp_set_any (
               sixtp_new (), FALSE,
               SIXTP_CHARACTERS_HANDLER_ID, generic_accumulate_chars,
               SIXTP_CLEANUP_CHARS_ID, sixtp_child_free_data,
               SIXTP_CHARS_FAIL_ID, sixtp_child_free_data,
               SIXTP_END_HANDLER_ID, generic_guid_end_handler,
               SIXTP_RESULT_FAIL_ID, sixtp_child_free_data,
               SIXTP_CLEANUP_RESULT_ID, sixtp_child_free_data,
               SIXTP_NO_MORE_HANDLERS);
}
 
/****************************************************************************/
/* <?> generic gnc_numeric handler...
 
   Attempts to parse the current accumulated characters data as a
   gnc_numeric and return it.
 
   input: NA
   returns: gnc_numeric*
 
   start: NA
   characters: return string copy for accumulation in end handler.
   end: concatenate all chars and create and return gnc_numeric*, if possible.
 
   cleanup-result: g_free the gnc_numeric*
   cleanup-chars: g_free the result string.
   fail: NA
   result-fail: g_free the gnc_numeric*
   chars-fail: g_free the result string.
 
 */
 
gboolean
generic_gnc_numeric_end_handler (gpointer data_for_children,
                                 GSList*  data_from_children, GSList* sibling_data,
                                 gpointer parent_data, gpointer global_data,
                                 gpointer* result, const gchar* tag)
{
    gnc_numeric* num = NULL;
    gchar* txt = NULL;
    gboolean ok = FALSE;
 
    txt = concatenate_child_result_chars (data_from_children);
 
    if (txt)
    {
        num = g_new (gnc_numeric, 1);
        if (num)
        {
            *num = gnc_numeric_from_string (txt);
            if (!gnc_numeric_check (*num))
            {
                ok = TRUE;
                *result = num;
            }
        }
    }
 
    g_free (txt);
    if (!ok)
    {
        PERR ("couldn't parse numeric quantity");
        g_free (num);
    }
 
    return (ok);
}
 
sixtp*
generic_gnc_numeric_parser_new (void)
{
    return sixtp_set_any (
               sixtp_new (), FALSE,
               SIXTP_CHARACTERS_HANDLER_ID, generic_accumulate_chars,
               SIXTP_CLEANUP_CHARS_ID, sixtp_child_free_data,
               SIXTP_CHARS_FAIL_ID, sixtp_child_free_data,
               SIXTP_END_HANDLER_ID, generic_gnc_numeric_end_handler,
               SIXTP_RESULT_FAIL_ID, sixtp_child_free_data,
               SIXTP_CLEANUP_RESULT_ID, sixtp_child_free_data,
               SIXTP_NO_MORE_HANDLERS);
}
 
/***************************************************************************/
 
sixtp*
restore_char_generator (sixtp_end_handler ender)
{
    return sixtp_set_any (
               sixtp_new (), FALSE,
               SIXTP_CHARACTERS_HANDLER_ID, generic_accumulate_chars,
               SIXTP_END_HANDLER_ID, ender,
               SIXTP_CLEANUP_CHARS_ID, sixtp_child_free_data,
               SIXTP_CHARS_FAIL_ID, sixtp_child_free_data,
               SIXTP_NO_MORE_HANDLERS);
}
 
/***************************** END OF FILE *********************************/