internal.cpp

/******************************************************************************
 * Project:  PROJ.4
 * Purpose:  This is primarily material originating from pj_obs_api.c
 *           (now proj_4D_api.c), that does not fit into the API
 *           category. Hence this pile of tubings and fittings for
 *           PROJ.4 internal plumbing.
 *
 * Author:   Thomas Knudsen,  thokn@sdfe.dk,  2017-07-05
 *
 ******************************************************************************
 * Copyright (c) 2016, 2017, 2018, Thomas Knudsen/SDFE
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 *****************************************************************************/

#define FROM_PROJ_CPP

#include <ctype.h>
#include <errno.h>
#include <math.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>

#include "geodesic.h"
#include "proj_internal.h"

#include "proj/internal/internal.hpp"

using namespace NS_PROJ::internal;

enum pj_io_units pj_left(PJ *P) {
    enum pj_io_units u = P->inverted ? P->right : P->left;
    if (u == PJ_IO_UNITS_CLASSIC)
        return PJ_IO_UNITS_PROJECTED;
    return u;
}

enum pj_io_units pj_right(PJ *P) {
    enum pj_io_units u = P->inverted ? P->left : P->right;
    if (u == PJ_IO_UNITS_CLASSIC)
        return PJ_IO_UNITS_PROJECTED;
    return u;
}

/* Work around non-constness of MSVC HUGE_VAL by providing functions rather than
 * constants */
PJ_COORD proj_coord_error(void) {
    PJ_COORD c;
    c.v[0] = c.v[1] = c.v[2] = c.v[3] = HUGE_VAL;
    return c;
}

/**************************************************************************************/
PJ_COORD pj_approx_2D_trans(PJ *P, PJ_DIRECTION direction, PJ_COORD coo) {
    /***************************************************************************************
    Behave mostly as proj_trans, but attempt to use 2D interfaces only.
    Used in gie.c, to enforce testing 2D code, and by PJ_pipeline.c to implement
    chained calls starting out with a call to its 2D interface.
    ***************************************************************************************/
    if (nullptr == P)
        return coo;
    if (P->inverted)
        direction = static_cast<PJ_DIRECTION>(-direction);
    switch (direction) {
    case PJ_FWD: {
        const auto xy = pj_fwd(coo.lp, P);
        coo.xy = xy;
        return coo;
    }
    case PJ_INV: {
        const auto lp = pj_inv(coo.xy, P);
        coo.lp = lp;
        return coo;
    }
    case PJ_IDENT:
        break;
    }
    return coo;
}

/**************************************************************************************/
PJ_COORD pj_approx_3D_trans(PJ *P, PJ_DIRECTION direction, PJ_COORD coo) {
    /***************************************************************************************
    Companion to pj_approx_2D_trans.

    Behave mostly as proj_trans, but attempt to use 3D interfaces only.
    Used in gie.c, to enforce testing 3D code, and by PJ_pipeline.c to implement
    chained calls starting out with a call to its 3D interface.
    ***************************************************************************************/
    if (nullptr == P)
        return coo;
    if (P->inverted)
        direction = static_cast<PJ_DIRECTION>(-direction);
    switch (direction) {
    case PJ_FWD: {
        const auto xyz = pj_fwd3d(coo.lpz, P);
        coo.xyz = xyz;
        return coo;
    }
    case PJ_INV: {
        const auto lpz = pj_inv3d(coo.xyz, P);
        coo.lpz = lpz;
        return coo;
    }
    case PJ_IDENT:
        break;
    }
    return coo;
}

/**************************************************************************************/
int pj_has_inverse(PJ *P) {
    /***************************************************************************************
    Check if a a PJ has an inverse.
    ***************************************************************************************/
    return ((P->inverted && (P->fwd || P->fwd3d || P->fwd4d)) ||
            (P->inv || P->inv3d || P->inv4d));
}

/* Move P to a new context - or to the default context if 0 is specified */
void proj_context_set(PJ *P, PJ_CONTEXT *ctx) {
    if (nullptr == ctx)
        ctx = pj_get_default_ctx();
    proj_assign_context(P, ctx);
}

void proj_context_inherit(PJ *parent, PJ *child) {
    if (nullptr == parent)
        proj_assign_context(child, pj_get_default_ctx());
    else
        proj_assign_context(child, pj_get_ctx(parent));
}

/*****************************************************************************/
char *pj_chomp(char *c) {
    /******************************************************************************
    Strip pre- and postfix whitespace. Inline comments (indicated by '#') are
    considered whitespace.
    ******************************************************************************/
    size_t i, n;
    char *comment;
    char *start = c;

    if (nullptr == c)
        return nullptr;

    comment = strchr(c, '#');
    if (comment)
        *comment = 0;

    n = strlen(c);
    if (0 == n)
        return c;

    /* Eliminate postfix whitespace */
    for (i = n - 1; (i > 0) && (isspace(c[i]) || ';' == c[i]); i--)
        c[i] = 0;

    /* Find start of non-whitespace */
    while (0 != *start && (';' == *start || isspace(*start)))
        start++;

    n = strlen(start);
    if (0 == n) {
        c[0] = 0;
        return c;
    }

    memmove(c, start, n + 1);
    return c;
}

/*****************************************************************************/
char *pj_shrink(char *c) {
    /******************************************************************************
    Collapse repeated whitespace. Remove '+' and ';'. Make ',' and '=' greedy,
    consuming their surrounding whitespace.
    ******************************************************************************/
    size_t i, j, n;

    /* Flag showing that a whitespace (ws) has been written after last non-ws */
    bool ws = false;

    if (nullptr == c)
        return nullptr;

    pj_chomp(c);
    n = strlen(c);
    if (n == 0)
        return c;

    /* First collapse repeated whitespace (including +/;) */
    i = 0;
    bool in_string = false;
    for (j = 0; j < n; j++) {

        if (in_string) {
            if (c[j] == '"' && c[j + 1] == '"') {
                c[i++] = c[j];
                j++;
            } else if (c[j] == '"') {
                in_string = false;
            }
            c[i++] = c[j];
            continue;
        }

        /* Eliminate prefix '+', only if preceded by whitespace */
        /* (i.e. keep it in 1.23e+08) */
        if ((i > 0) && ('+' == c[j]) && ws)
            c[j] = ' ';
        if ((i == 0) && ('+' == c[j]))
            c[j] = ' ';

        // Detect a string beginning after '='
        if (c[j] == '"' && i > 0 && c[i - 1] == '=') {
            in_string = true;
            ws = false;
            c[i++] = c[j];
            continue;
        }

        if (isspace(c[j]) || ';' == c[j]) {
            if (false == ws && (i > 0))
                c[i++] = ' ';
            ws = true;
            continue;
        } else {
            ws = false;
            c[i++] = c[j];
        }
    }
    c[i] = 0;
    n = strlen(c);

    /* Then make ',' and '=' greedy */
    i = 0;
    for (j = 0; j < n; j++) {
        if (i == 0) {
            c[i++] = c[j];
            continue;
        }

        /* Skip space before '='/',' */
        if ('=' == c[j] || ',' == c[j]) {
            if (c[i - 1] == ' ')
                c[i - 1] = c[j];
            else
                c[i++] = c[j];
            continue;
        }

        if (' ' == c[j] && ('=' == c[i - 1] || ',' == c[i - 1]))
            continue;

        c[i++] = c[j];
    }
    c[i] = 0;
    return c;
}

/*****************************************************************************/
size_t pj_trim_argc(char *args) {
    /******************************************************************************
    Trim all unnecessary whitespace (and non-essential syntactic tokens) from
    the argument string, args, and count its number of elements.
    ******************************************************************************/
    size_t i, m, n;
    pj_shrink(args);
    n = strlen(args);
    if (n == 0)
        return 0;
    bool in_string = false;
    for (i = m = 0; i < n; i++) {
        if (in_string) {
            if (args[i] == '"' && args[i + 1] == '"') {
                i++;
            } else if (args[i] == '"') {
                in_string = false;
            }
        } else if (args[i] == '=' && args[i + 1] == '"') {
            i++;
            in_string = true;
        } else if (' ' == args[i]) {
            args[i] = 0;
            m++;
        }
    }
    return m + 1;
}

static void unquote_string(char *param_str) {

    size_t len = strlen(param_str);
    // Remove leading and terminating spaces after equal sign
    const char *equal = strstr(param_str, "=\"");
    if (equal && equal - param_str + 1 >= 2 && param_str[len - 1] == '"') {
        size_t dst = equal + 1 - param_str;
        size_t src = dst + 1;
        for (; param_str[src]; dst++, src++) {
            if (param_str[src] == '"') {
                if (param_str[src + 1] == '"') {
                    src++;
                } else {
                    break;
                }
            }
            param_str[dst] = param_str[src];
        }
        param_str[dst] = '\0';
    }
}

/*****************************************************************************/
char **pj_trim_argv(size_t argc, char *args) {
    /******************************************************************************
    Create an argv-style array from elements placed in the argument string,
    args.

    args is a trimmed string as returned by pj_trim_argc(), and argc is the
    number of trimmed strings found (i.e. the return value of pj_trim_args()).
    Hence, int argc    = pj_trim_argc (args); char **argv = pj_trim_argv (argc,
    args); will produce a classic style (argc, argv) pair from a string of
    whitespace separated args. No new memory is allocated for storing the
    individual args (they stay in the args string), but for the pointers to the
    args a new array is allocated and returned.

    It is the duty of the caller to free this array.
    ******************************************************************************/

    if (nullptr == args)
        return nullptr;
    if (0 == argc)
        return nullptr;

    /* turn the input string into an array of strings */
    char **argv = (char **)calloc(argc, sizeof(char *));
    if (nullptr == argv)
        return nullptr;
    for (size_t i = 0, j = 0; j < argc; j++) {
        argv[j] = args + i;
        char *str = argv[j];
        size_t nLen = strlen(str);
        i += nLen + 1;
        unquote_string(str);
    }
    return argv;
}

/*****************************************************************************/
std::string pj_double_quote_string_param_if_needed(const std::string &str) {
    /*****************************************************************************/
    if (str.find(' ') == std::string::npos) {
        return str;
    }
    std::string ret;
    ret += '"';
    ret += replaceAll(str, "\"", "\"\"");
    ret += '"';
    return ret;
}

/*****************************************************************************/
char *pj_make_args(size_t argc, char **argv) {
    /******************************************************************************
    pj_make_args is the inverse of the pj_trim_argc/pj_trim_argv combo: It
    converts free format command line input to something proj_create can
    consume.

    Allocates, and returns, an array of char, large enough to hold a whitespace
    separated copy of the args in argv. It is the duty of the caller to free
    this array.
    ******************************************************************************/
    try {
        std::string s;
        for (size_t i = 0; i < argc; i++) {
            const char *equal = strchr(argv[i], '=');
            if (equal) {
                s += std::string(argv[i], equal - argv[i] + 1);
                s += pj_double_quote_string_param_if_needed(equal + 1);
            } else {
                s += argv[i];
            }
            s += ' ';
        }

        char *p = pj_strdup(s.c_str());
        return pj_shrink(p);
    } catch (const std::exception &) {
        return nullptr;
    }
}

/*****************************************************************************/
void proj_context_errno_set(PJ_CONTEXT *ctx, int err) {
    /******************************************************************************
    Raise an error directly on a context, without going through a PJ belonging
    to that context.
    ******************************************************************************/
    if (nullptr == ctx)
        ctx = pj_get_default_ctx();
    ctx->last_errno = err;
    if (err == 0)
        return;
    errno = err;
}