inputbasic.c

Go to the documentation of this file.

/***************************************************************************
 *   stick2xyz - Can create and convert stick figure animations for CG.    *
 *   Copyright (C) 2021 by Kevin McBride <dolphindddd@aol.com>             *
 *                                                                         *
 *  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 3 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, see <http://www.gnu.org/licenses/>.  *
 ***************************************************************************/
 
 
#include "inputbasicpriv.h"
 
 
#ifndef     DOXYGEN_BUILD
 
/* Used for versioning. */
static int modversion[] = 
      {STICK2XYZ_VER_MAJOR, STICK2XYZ_VER_MINOR, STICK2XYZ_VER_REVISION};
/* The file descriptors we are outputting tty information to. */
static FILE * modttyout = NULL;
static FILE * modttyerr = NULL;
 
#ifndef     STICK2XYZ_NO_MODLANGPACKS
/* Used for dynamically accessing the language libraries. */
stick2xyz_print_ptr stick2xyz_lang_lib_inputbasic = NULL;
 
void inputbasic_lang ( stick2xyz_print_ptr newval )
{
      stick2xyz_lang_lib_inputbasic = newval;
}
#endif      /* not STICK2XYZ_NO_MODLANGPACKS */
 
 
/* Input General Module Info Functions */
stick2xyz_pctchar inputbasic_name ( void )
{
      return stick2xyz_inputbasic_modname();
}
 
stick2xyz_pctchar inputbasic_desc ( void )
{
      return stick2xyz_inputbasic_moddesc();
}
 
void inputbasic_version ( int * dest )
{
      dest[0] = modversion[0];
      dest[1] = modversion[1];
      dest[2] = modversion[2];
}
 
int inputbasic_type ( void )
{
#ifdef      UNICODE
#ifdef      DEBUG
      return STICK2XYZ_MODTYPE_INPUT_UNICODE_DEBUG;
#else /* not DEBUG */
      return STICK2XYZ_MODTYPE_INPUT_UNICODE;
#endif      /* not DEBUG */
#else /* not UNICODE */
#ifdef      DEBUG
      return STICK2XYZ_MODTYPE_INPUT_DEBUG;
#else /* not DEBUG */
      return STICK2XYZ_MODTYPE_INPUT;
#endif      /* not DEBUG */
#endif      /* not UNICODE */
}
 
 
void inputbasic_set_tty ( void * fildescout, void * fildescerr )
{
      modttyout = (FILE *)fildescout;
      modttyerr = (FILE *)fildescerr;
}
 
FILE * input_basic_get_ttyout ( void )
{
      if ( modttyout == NULL )
            return stdout;
      else
            return modttyout;
}
 
FILE * input_basic_get_ttyerr ( void )
{
      if ( modttyerr == NULL )
            return stderr;
      else
            return modttyerr;
}
 
 
int inputbasic_type_supported ( uint32_t filtype )
{
 
      if ( filtype == STICK2XYZ_INPUT_TYPE_AUTO )
            return 1;
      if ( filtype & STICK2XYZ_INPUT_TYPE_PLAIN )
            return 1;
      if ( filtype & STICK2XYZ_INPUT_TYPE_GZIP )
#ifdef      HAVE_ZLIB_H
            return 1;
#else /* not HAVE_ZLIB_H */
            return 0;
#endif      /* not HAVE_ZLIB_H */
      if ( filtype & STICK2XYZ_INPUT_TYPE_BZIP2 )
#ifdef      HAVE_BZLIB_H
            return 1;
#else /* not HAVE_BZLIB_H */
            return 0;
#endif      /* not HAVE_BZLIB_H */
      if ( filtype & STICK2XYZ_INPUT_TYPE_LZMA2 )
#ifdef      HAVE_LZMA_H
            return 1;
#else /* not HAVE_LZMA_H */
            return 0;
#endif      /* not HAVE_LZMA_H */
 
      return 0;
}
 
 
uint32_t inputbasic_get_supportedalgorithm ( void )
{
      uint32_t retval;
 
      retval = STICK2XYZ_INPUT_TYPE_PLAIN;
#ifdef      HAVE_ZLIB_H
      retval |= STICK2XYZ_INPUT_TYPE_GZIP;
#endif      /* HAVE_ZLIB_H */
#ifdef      HAVE_BZLIB_H
      retval |= STICK2XYZ_INPUT_TYPE_BZIP2;
#endif      /* HAVE_BZLIB_H */
#ifdef      HAVE_LZMA_H
      retval |= STICK2XYZ_INPUT_TYPE_LZMA2;
#endif      /* HAVE_LZMA_H */
 
#ifdef      UNICODE
      retval |= STICK2XYZ_INPUT_TYPE_UTF16BE;
      retval |= STICK2XYZ_INPUT_TYPE_UTF16LE;
      retval |= STICK2XYZ_INPUT_TYPE_UTF32BE;
      retval |= STICK2XYZ_INPUT_TYPE_UTF32LE;
#endif      /* UNICODE */
 
      return retval;
}
 
 
uint32_t inputbasic_get_algorithm ( input_handle handle )
{
      struct input_basic_handle * handle_priv;
 
      /* If handle is NULL, we can't do anything. */
      if ( handle == NULL )
            return -1;
 
      /* Cast the handle. */
      handle_priv = (struct input_basic_handle *)handle;
 
#ifdef      HAVE_ZLIB_H
      /* Determine if the type is gzip. */
      if ( handle_priv->input_basic_handle_flags & INPUTBASIC_GZIP )
            return STICK2XYZ_INPUT_TYPE_GZIP;
#endif      /* HAVE_ZLIB_H */
 
#ifdef      HAVE_BZLIB_H
      /* Determine if the type is bzip2. */
      if ( handle_priv->input_basic_handle_flags & INPUTBASIC_BZIP2 )
            return STICK2XYZ_INPUT_TYPE_BZIP2;
#endif      /* HAVE_BZLIB_H */
 
#ifdef      HAVE_LZMA_H
      /* Determine if the type is LZMA2. */
      if ( handle_priv->input_basic_handle_flags & INPUTBASIC_LZMA2 )
            return STICK2XYZ_INPUT_TYPE_LZMA2;
#endif      /* HAVE_LZMA_H */
 
      /* The type is plain. */
      return STICK2XYZ_INPUT_TYPE_PLAIN;
}
 
uint32_t inputbasic_get_utftype ( input_handle handle )
{
      /* If handle is NULL, we can't do anything. */
      if ( handle == NULL )
            return -1;
 
#ifdef      UNICODE
      struct input_basic_handle * handle_priv;
 
      /* Cast the handle. */
      handle_priv = (struct input_basic_handle *)handle;
 
      /* Determine if the type is UTF-16 Big Endian. */
      if ( handle_priv->input_basic_handle_flags & INPUTBASIC_UTF16_BIG )
            return STICK2XYZ_INPUT_TYPE_UTF16BE;
      /* Determine if the type is UTF-16 Little Endian. */
      if ( handle_priv->input_basic_handle_flags & INPUTBASIC_UTF16_LITTLE )
            return STICK2XYZ_INPUT_TYPE_UTF16LE;
      /* Determine if the type is UTF-16 Big Endian. */
      if ( handle_priv->input_basic_handle_flags & INPUTBASIC_UTF32_BIG )
            return STICK2XYZ_INPUT_TYPE_UTF32BE;
      /* Determine if the type is UTF-16 Little Endian. */
      if ( handle_priv->input_basic_handle_flags & INPUTBASIC_UTF32_LITTLE )
            return STICK2XYZ_INPUT_TYPE_UTF32LE;
#endif      /* not UNICODE */
 
      /* The type is UTF-8. */
      return STICK2XYZ_INPUT_TYPE_UTF8;
}
 
uint64_t inputbasic_get_lineno ( input_handle handle )
{
      struct input_basic_handle * handle_priv;
 
      /* If handle is NULL, we can't do anything. */
      if ( handle == NULL )
            return 0;
 
      /* Cast the handle. */
      handle_priv = (struct input_basic_handle *)handle;
 
      /* Return the line number to the caller. */
      return handle_priv->input_basic_handle_lineno;
}
#endif      /* not DOXYGEN_BUILD */
 
 
#ifndef     STICK2XYZ_STATIC
/* Input Basic Module Info Functions */
stick2xyz_pctchar mod_input_name ( void )
{
      return (stick2xyz_pctchar)inputbasic_name();
}
 
stick2xyz_pctchar mod_input_desc ( void )
{
      return (stick2xyz_pctchar)inputbasic_desc();
}
 
void mod_input_version ( int * dest )
{
      inputbasic_version(dest);
}
 
int mod_input_type ( void )
{
      return inputbasic_type();
}
 
void mod_input_set_tty ( void * fildescout, void * fildescerr )
{
      inputbasic_set_tty(fildescout, fildescerr);
}
 
 
int mod_input_type_supported ( uint32_t filtype )
{
      return inputbasic_type_supported(filtype);
}
 
 
uint32_t mod_input_get_supportedalgorithm ( void )
{
      return inputbasic_get_supportedalgorithm();
}
 
 
input_handle mod_input_fopen ( const char * filnam )
{
      return inputbasic_fopen(filnam);
}
 
 
input_handle mod_input_fopen_bt ( const char * filnam, uint32_t * filtype )
{
      return inputbasic_fopen_bt(filnam, filtype);
}
 
 
#ifdef      UNICODE
input_handle mod_input_fwopen ( const wchar_t * filnam )
{
      return inputbasic_fwopen(filnam);
}
 
 
input_handle mod_input_fwopen_bt ( const wchar_t * filnam, uint32_t * filtype )
{
      return inputbasic_fwopen_bt(filnam, filtype);
}
#endif      /* UNICODE */
 
 
input_handle mod_input_fdopen ( int fildes )
{
      return inputbasic_fdopen(fildes);
}
 
 
input_handle mod_input_fdopen_bt ( int fildes, uint32_t * filtype )
{
      return inputbasic_fdopen_bt(fildes, filtype);
}
 
 
input_handle mod_input_open ( void * fildes )
{
      return inputbasic_open(fildes);
}
 
 
input_handle mod_input_open_bt ( void * fildes, uint32_t * filtype )
{
      return inputbasic_open_bt(fildes, filtype);
}
 
 
void mod_input_close ( input_handle handle )
{
      inputbasic_close(handle);
}
 
 
uint32_t mod_input_get_algorithm ( input_handle handle )
{
      return inputbasic_get_algorithm(handle);
}
 
uint32_t mod_input_get_utftype ( input_handle handle )
{
      return inputbasic_get_utftype(handle);
}
 
uint64_t mod_input_get_lineno ( input_handle handle )
{
      return inputbasic_get_lineno(handle);
}
 
int mod_input_read (
      input_handle handle,
      struct input_buf * dest,
      size_t dest_size,
      size_t dest_str_size
)
{
      return inputbasic_read(
            handle, dest, dest_size, dest_str_size);
}
 
 
#ifdef      DOXYGEN_BUILD
int mod_input_init ( int multithread )
{
      return 1;
}
 
int mod_input_release ( void )
{
      return 0;
}
 
int mod_input_sigterm ( input_sigterm_ready func, int modnumber )
{
      return 1;
}
#endif /*  DOXYGEN_BUILD */
 
 
 
#ifndef     STICK2XYZ_NO_MODLANGPACKS
void mod_input_lang ( stick2xyz_print_ptr newval )
{
      inputbasic_lang(newval);
}
#endif      /* not STICK2XYZ_NO_MODLANGPACKS */
 
 
#else /* STICK2XYZ_STATIC */
void inputbasic_funcptrs_setup ( struct input_funcptrs * ptr )
{
      ptr->input_funcptrs_name = &inputbasic_name;
      ptr->input_funcptrs_desc = &inputbasic_desc;
      ptr->input_funcptrs_version = &inputbasic_version;
      ptr->input_funcptrs_type = &inputbasic_type;
      ptr->input_funcptrs_set_tty = &inputbasic_set_tty;
 
      ptr->input_funcptrs_init = NULL;
      ptr->input_funcptrs_release = NULL;
      ptr->input_funcptrs_sigterm = NULL;
 
      ptr->input_funcptrs_type_supported = &inputbasic_type_supported;
      ptr->input_funcptrs_get_supportedalgorithm =
            &inputbasic_get_supportedalgorithm;
 
      ptr->input_funcptrs_open = &inputbasic_open;
      ptr->input_funcptrs_open_bt = &inputbasic_open_bt;
      ptr->input_funcptrs_fopen = &inputbasic_fopen;
      ptr->input_funcptrs_fopen_bt = &inputbasic_fopen_bt;
      ptr->input_funcptrs_fdopen = &inputbasic_fdopen;
      ptr->input_funcptrs_fdopen_bt = &inputbasic_fdopen_bt;
#ifdef      UNICODE
      ptr->input_funcptrs_fwopen = &inputbasic_fwopen;
      ptr->input_funcptrs_fwopen_bt = &inputbasic_fwopen_bt;
#endif      /* UNICODE */
      ptr->input_funcptrs_close = &inputbasic_close;
 
      ptr->input_funcptrs_get_algorithm =
            &inputbasic_get_algorithm;
      ptr->input_funcptrs_get_utftype =
            &inputbasic_get_utftype;
      ptr->input_funcptrs_get_lineno =
            &inputbasic_get_lineno;
 
      ptr->input_funcptrs_read = &inputbasic_read;
}
#endif      /* STICK2XYZ_STATIC */