xcftools.h File Reference

#include "config.h"
#include "enums.h"
#include <stddef.h>
#include <stdio.h>
#include <inttypes.h>
#include <netinet/in.h>

Go to the source code of this file.

Classes
struct	rect
struct	tileDimensions
struct	xcfImage
struct	xcfLayer
struct	xcfTiles

Macros
#define	_(s)   (s)
#define	__ATTRIBUTE__(x)
#define	__STDC_FORMAT_MACROS
#define	disjointRects(A, B)    ((A).l >= (B).r || (A).r <= (B).l || (A).t >= (B).b || (A).b <= (B).t)
#define	isSubrect(A, B)    ((A).l >= (B).l && (A).r <= (B).r && (A).t >= (B).t && (A).b <= (B).b)
#define	N_(s)   (s)
#define	nls_init()   (void)0
#define	strcasecmp   strcmp
#define	TILE_HEIGHT   (1<<TILE_SHIFT)
#define	TILE_LEFT(x)   ((x) & -TILE_WIDTH)
#define	TILE_NUM(x)   ((x) >> TILE_SHIFT)
#define	TILE_SHIFT   6
#define	TILE_TOP(y)   ((y) & -TILE_HEIGHT)
#define	TILE_WIDTH   (1<<TILE_SHIFT)
#define	XCF_ERROR   1
#define	XCF_OK   0
#define	XCF_PTR_EMPTY   0
#define	xcfBE(a)
#define	xcfL(a)   ((a) & 3 ? xcfBE(a) : ntohl(*(uint32_t *)(xcf_file + (a))))
#define	xcfLE(a)

Functions
int	closeout (FILE *, const char *)
int	computeDimensions (struct tileDimensions *)
void void void	FatalBadXCF (const char *format,...) __ATTRIBUTE__((format(printf
void	FatalGeneric (int status, const char *format,...) __ATTRIBUTE__((format(printf
void void	FatalUnexpected (const char *format,...) __ATTRIBUTE__((format(printf
void void void void	FatalUnsupportedXCF (const char *format,...) __ATTRIBUTE__((format(printf
void	free_or_close_xcf (void)
int	getBasicXcfInfo (void)
void void void void void	gpl_blurb (void)
FILE *	openout (const char *)
void	read_or_mmap_xcf (const char *filename, const char *unzipper)
int	xcfCheckspace (uint32_t addr, int spaceafter, const char *format,...) __ATTRIBUTE__((format(printf
void	xcffree (void *)
void *	xcfmalloc (size_t size)
int	xcfNextprop (uint32_t *master, uint32_t *body, PropType *type)
int int	xcfOffset (uint32_t addr, int spaceafter, uint32_t *apparent)
const char *	xcfString (uint32_t ptr, uint32_t *after)

Variables
const char *	progname
int	use_utf8
int	verboseFlag
struct xcfImage	XCF
uint8_t *	xcf_file
size_t	xcf_length

Macro Definition Documentation

_

#define _

(

s

)

(s)

Definition at line 32 of file xcftools.h.

__ATTRIBUTE__

#define __ATTRIBUTE__

(

x

)

Definition at line 55 of file xcftools.h.

__STDC_FORMAT_MACROS

#define __STDC_FORMAT_MACROS

Definition at line 38 of file xcftools.h.

disjointRects

#define disjointRects	(		A,
			B )    ((A).l >= (B).r || (A).r <= (B).l || (A).t >= (B).b || (A).b <= (B).t)

Definition at line 135 of file xcftools.h.

#define disjointRects(A,B) \
  ((A).l >= (B).r || (A).r <= (B).l || (A).t >= (B).b || (A).b <= (B).t)

isSubrect

#define isSubrect	(		A,
			B )    ((A).l >= (B).l && (A).r <= (B).r && (A).t >= (B).t && (A).b <= (B).b)

Definition at line 133 of file xcftools.h.

#define isSubrect(A,B) \
  ((A).l >= (B).l && (A).r <= (B).r && (A).t >= (B).t && (A).b <= (B).b)

N_

#define N_

(

s

)

(s)

Definition at line 35 of file xcftools.h.

nls_init

#define nls_init

(

)

(void)0

Definition at line 33 of file xcftools.h.

strcasecmp

#define strcasecmp   strcmp

Definition at line 73 of file xcftools.h.

TILE_HEIGHT

#define TILE_HEIGHT   (1<<TILE_SHIFT)

Definition at line 155 of file xcftools.h.

TILE_LEFT

#define TILE_LEFT

(

x

)

((x) & -TILE_WIDTH)

Definition at line 161 of file xcftools.h.

TILE_NUM

#define TILE_NUM

(

x

)

((x) >> TILE_SHIFT)

Definition at line 163 of file xcftools.h.

TILE_SHIFT

#define TILE_SHIFT   6

Definition at line 153 of file xcftools.h.

TILE_TOP

#define TILE_TOP

(

y

)

((y) & -TILE_HEIGHT)

Definition at line 162 of file xcftools.h.

TILE_WIDTH

#define TILE_WIDTH   (1<<TILE_SHIFT)

Definition at line 154 of file xcftools.h.

XCF_ERROR

#define XCF_ERROR   1

Definition at line 105 of file xcftools.h.

XCF_OK

#define XCF_OK   0

Definition at line 106 of file xcftools.h.

XCF_PTR_EMPTY

#define XCF_PTR_EMPTY   0

Definition at line 107 of file xcftools.h.

xcfBE

#define xcfBE

(

a

)

Value:

                   ( ((uint32_t)xcf_file[(a)  ] << 24) + \
                   ((uint32_t)xcf_file[(a)+1] << 16) + \
                   ((uint32_t)xcf_file[(a)+2] << 8 ) + \
                   ((uint32_t)xcf_file[(a)+3]      ) )

Definition at line 79 of file xcftools.h.

#define xcfBE(a) ( ((uint32_t)xcf_file[(a)  ] << 24) + \
                   ((uint32_t)xcf_file[(a)+1] << 16) + \
                   ((uint32_t)xcf_file[(a)+2] << 8 ) + \
                   ((uint32_t)xcf_file[(a)+3]      ) )

xcfL

#define xcfL

(

a

)

((a) & 3 ? xcfBE(a) : ntohl(*(uint32_t *)(xcf_file + (a))))

Definition at line 91 of file xcftools.h.

xcfLE

#define xcfLE

(

a

)

Value:

                   ( ((uint32_t)xcf_file[(a)  ]      ) + \
                   ((uint32_t)xcf_file[(a)+1] << 8 ) + \
                   ((uint32_t)xcf_file[(a)+2] << 16) + \
                   ((uint32_t)xcf_file[(a)+3] << 24) )

Definition at line 83 of file xcftools.h.

#define xcfLE(a) ( ((uint32_t)xcf_file[(a)  ]      ) + \
                   ((uint32_t)xcf_file[(a)+1] << 8 ) + \
                   ((uint32_t)xcf_file[(a)+2] << 16) + \
                   ((uint32_t)xcf_file[(a)+3] << 24) )

Function Documentation

closeout()

int closeout	(	FILE *	f,
		const char *	name )

Definition at line 152 of file utils.c.

{
  if( f == NULL )
    return XCF_OK;
  if( fflush(f) == 0 ) {
    errno = 0 ;
    if( !ferror(f) ) {
      if( fclose(f) == 0 )
        return XCF_OK;
    } else if( errno == 0 ) {
      /* Attempt to coax a valid errno out of the standard library,
       * following an idea by Bruno Haible
       * https://lists.gnu.org/archive/html/bug-gnulib/2003-09/msg00157.html
       */
      if( fputc('\0', f) != EOF &&
          fflush(f) == 0 )
        errno = EIO ; /* Argh, everything succedes. Just call it an I/O error */
    }
  }
  FatalUnexpected(_("!Error writing file %s"),name);
  return XCF_ERROR;
}

References _, FatalUnexpected(), XCF_ERROR, and XCF_OK.

computeDimensions()

int computeDimensions

(

struct tileDimensions *

d

)

Definition at line 220 of file xcf-general.c.

{
  // [ CVE-2019-5086 and CVE-2019-5087 ]
  // This part of code is the check to prevent integer overflow, see CVE-2019-5086 and CVE-2019-5087
 
  if ((d->c.l + d->width) * 4 > INT_MAX) {
    FatalBadXCF(("Width is too large (%d)! Stopping execution...\n"), (d->c.l + d->width));
    return XCF_ERROR;
  }
 
  if ((d->c.t + d->height) * 4 > INT_MAX) {
    FatalBadXCF(("Height is too large (%d)! Stopping execution...\n"), (d->c.t + d->height));
    return XCF_ERROR;
  }
  // [ CVE-2019-5086 and CVE-2019-5087 ]
 
  d->c.r = d->c.l + d->width ;
  d->c.b = d->c.t + d->height ;
  d->tilesx = (d->width+TILE_WIDTH-1)/TILE_WIDTH ;
  d->tilesy = (d->height+TILE_HEIGHT-1)/TILE_HEIGHT ;
  d->ntiles = d->tilesx * d->tilesy ;
 
  return XCF_OK;
}

References FatalBadXCF(), TILE_HEIGHT, TILE_WIDTH, XCF_ERROR, and XCF_OK.

FatalBadXCF()

void void void FatalBadXCF	(	const char *	format,
			... )

FatalGeneric()

void FatalGeneric	(	int	status,
		const char *	format,
			... )

FatalUnexpected()

void void FatalUnexpected	(	const char *	format,
			... )

FatalUnsupportedXCF()

void void void void FatalUnsupportedXCF	(	const char *	format,
			... )

free_or_close_xcf()

void free_or_close_xcf

(

void

)

getBasicXcfInfo()

int getBasicXcfInfo

(

void

)

Definition at line 248 of file xcf-general.c.

{
  uint32_t ptr, data, layerfile ;
  PropType type ;
  int i, j ;
 
  int errorStatus;
  uint32_t ptrout;
 
  if (xcfCheckspace(0,14+7*4,"(very short)") != XCF_OK) {
     return XCF_ERROR;
  }
 
  if( strcmp((char*)xcf_file,"gimp xcf file") == 0 )
    XCF.version = 0 ;
  else if( xcf_file[13] == 0 &&
          sscanf((char*)xcf_file,"gimp xcf v%d",&XCF.version) == 1 )
    ;
  else {
    FatalBadXCF(_("Not an XCF file at all (magic not recognized)"));
    return XCF_ERROR;
  }
 
  if (XCF.version < 0 || XCF.version > 2) {
    fprintf(stderr, _("Warning: XCF version %d not supported (trying anyway...)\n"), XCF.version);
  }
 
  XCF.compression = COMPRESS_NONE ;
  XCF.colormapptr = 0 ;
 
  ptr = 14 ;
  XCF.width    = xcfL(ptr); ptr += 4 ;
  XCF.height   = xcfL(ptr); ptr += 4 ;
  XCF.type     = xcfL(ptr); ptr += 4 ;
  while( (errorStatus = xcfNextprop(&ptr,&data, &type)) != XCF_ERROR && type != PROP_END ) {
      if (errorStatus != XCF_OK) {
          return XCF_ERROR;
      }
 
    switch(type) {
    case PROP_COLORMAP:
      XCF.colormapptr = data ;
      break ;
    case PROP_COMPRESSION:
      XCF.compression = xcf_file[data] ;
      break ;
    default:
      /* Ignore unknown properties */
      break ;
    }
  }
 
  layerfile = ptr ;
  XCF.numLayers = 0;
  while (1) {
      errorStatus = xcfOffset(ptr,8*4, &ptrout);
      if (errorStatus != XCF_OK) {
          return XCF_ERROR;
      }
      if (!ptrout) {
          break;
      }
      XCF.numLayers++;
      ptr+=4;
  }
  XCF.layers = xcfmalloc(XCF.numLayers * sizeof(struct xcfLayer)) ;
  for( i = 0 ; i < XCF.numLayers ; i++ ) {
    struct xcfLayer *L = XCF.layers + i ;
    ptr = xcfL(layerfile+4*(XCF.numLayers-1-i)) ;
 
    L->mode = GIMP_NORMAL_MODE ;
    L->opacity = 255 ;
    L->isVisible = 1 ;
    L->hasMask = 0 ;
    L->dim.width = xcfL(ptr); ptr+=4 ;
    L->dim.height = xcfL(ptr); ptr+=4 ;
    L->type = xcfL(ptr); ptr+=4 ;
    L->name = xcfString(ptr,&ptr);
    if (L->name == XCF_PTR_EMPTY) {
        return XCF_ERROR;
    }
    L->propptr = ptr ;
 
    L->isGroup = 0;
    L->pathLength = 0;
    L->path = NULL;
 
    while( (errorStatus = xcfNextprop(&ptr,&data, &type)) != XCF_ERROR && type != PROP_END ) {
        if (errorStatus != XCF_OK) {
            xcffree(XCF.layers);
            XCF.layers = XCF_PTR_EMPTY;
            return XCF_ERROR;
        }
      switch(type) {
      case PROP_OPACITY:
        L->opacity = xcfL(data);
        if( L->opacity > 255 )
          L->opacity = 255 ;
        break ;
      case PROP_VISIBLE:
        L->isVisible = xcfL(data) != 0 ;
        break ;
      case PROP_APPLY_MASK:
        L->hasMask = xcfL(data) != 0 ;
        break ;
      case PROP_OFFSETS:
        L->dim.c.l = (int32_t)(xcfL(data  )) ;
        L->dim.c.t = (int32_t)(xcfL(data+4)) ;
        break ;
      case PROP_MODE:
        L->mode = xcfL(data);
        break ;
      case PROP_GROUP_ITEM:
        L->isGroup = 1 ;
        break;
      case PROP_ITEM_PATH:
        L->pathLength = (ptr - data - 2) / 4 ;
 
        if ( L->pathLength != 0 ) {
 
          L->path = xcfmalloc( L->pathLength * sizeof(unsigned) ) ;
 
          for ( j = 0; j!=L->pathLength; j++ )
            *(L->path + j) = (unsigned)xcfL(data + 4 * j);
        }
        break;
      default:
        /* Ignore unknown properties */
        break ;
      }
    }
    if ((errorStatus = xcfCheckspace(ptr,8,"(end of layer %s)",L->name)) != XCF_OK) {
        xcffree(XCF.layers);
        XCF.layers = XCF_PTR_EMPTY;
        return XCF_ERROR;
    }
    L->pixels.tileptrs = 0 ;
    if (xcfOffset(ptr  , 4*4, &(L->pixels.hierarchy)) != XCF_OK) {
        xcffree(XCF.layers);
        XCF.layers = XCF_PTR_EMPTY;
        return XCF_ERROR;
    }
    L->mask.tileptrs = 0 ;
    if (xcfOffset(ptr+4, 4*4, &(L->mask.hierarchy)) != XCF_OK) {
        xcffree(XCF.layers);
        XCF.layers = XCF_PTR_EMPTY;
        return XCF_ERROR;
    }
 
    if (computeDimensions(&L->dim) != XCF_OK) {
        return XCF_ERROR;
    }
  }
  return XCF_OK;
}

References _, tileDimensions::c, xcfImage::colormapptr, COMPRESS_NONE, xcfImage::compression, computeDimensions(), xcfLayer::dim, FatalBadXCF(), GIMP_NORMAL_MODE, xcfLayer::hasMask, tileDimensions::height, xcfImage::height, xcfTiles::hierarchy, xcfLayer::isGroup, xcfLayer::isVisible, rect::l, xcfImage::layers, xcfLayer::mask, xcfLayer::mode, xcfLayer::name, xcfImage::numLayers, xcfLayer::opacity, xcfLayer::path, xcfLayer::pathLength, xcfLayer::pixels, PROP_APPLY_MASK, PROP_COLORMAP, PROP_COMPRESSION, PROP_END, PROP_GROUP_ITEM, PROP_ITEM_PATH, PROP_MODE, PROP_OFFSETS, PROP_OPACITY, PROP_VISIBLE, xcfLayer::propptr, rect::t, xcfTiles::tileptrs, xcfLayer::type, xcfImage::type, xcfImage::version, tileDimensions::width, xcfImage::width, XCF, XCF_ERROR, xcf_file, XCF_OK, XCF_PTR_EMPTY, xcfCheckspace(), xcffree(), xcfL, xcfmalloc(), xcfNextprop(), xcfOffset(), and xcfString().

gpl_blurb()

void void void void void gpl_blurb

(

void

)

Definition at line 102 of file utils.c.

{
  fprintf(stderr,PACKAGE_STRING "\n");
  fprintf(stderr,
          _("Type \"%s -h\" to get an option summary.\n"),progname);
  /* don't exit here - Krita will close otherwise */
  /* exit(1) ; */
}

References _, PACKAGE_STRING, and progname.

openout()

FILE * openout

(

const char *

name

)

Definition at line 138 of file utils.c.

{
  FILE *newfile ;
  if( strcmp(name,"-") == 0 )
    return stdout ;
  newfile = fopen(name,"wb") ;
  if( newfile == NULL ) {
    FatalUnexpected(_("!Cannot create file %s"),name);
    return XCF_PTR_EMPTY;
  }
  return newfile ;
}

References _, FatalUnexpected(), and XCF_PTR_EMPTY.

read_or_mmap_xcf()

void read_or_mmap_xcf	(	const char *	filename,
		const char *	unzipper )

xcfCheckspace()

int xcfCheckspace	(	uint32_t	addr,
		int	spaceafter,
		const char *	format,
			... )

xcffree()

void xcffree

(

void *

block

)

Definition at line 125 of file utils.c.

{
  if( xcf_file &&
      (uint8_t*)block >= xcf_file &&
      (uint8_t*)block < xcf_file + xcf_length )
    ;
  else
    free(block);
}

References xcf_file, and xcf_length.

xcfmalloc()

void * xcfmalloc

(

size_t

size

)

Definition at line 114 of file utils.c.

{
  void *ptr = malloc(size);
  if( !ptr ) {
    FatalUnexpected(_("Out of memory"));
    return XCF_PTR_EMPTY;
  }
  return ptr ;
}

References _, FatalUnexpected(), and XCF_PTR_EMPTY.

xcfNextprop()

int xcfNextprop	(	uint32_t *	master,
		uint32_t *	body,
		PropType *	type )

Definition at line 52 of file xcf-general.c.

{
  int response;
 
  if (typeOut ==  0) {
      return XCF_ERROR;
  }
 
  uint32_t ptr, length, total, minlength ;
  PropType type ;
  ptr = *master ;
  if ((response = xcfCheckspace(ptr,8,"(property header)")) != XCF_OK) {
      return XCF_ERROR;
  }
  type = xcfL(ptr);
  length = xcfL(ptr+4);
  *body = ptr+8 ;
 
  switch(type) {
  case PROP_COLORMAP:
    {
      uint32_t ncolors ;
      if ((response = xcfCheckspace(ptr+8,4,"(colormap length)")) != XCF_OK) {
          return XCF_ERROR;
      }
      ncolors = xcfL(ptr+8) ;
      if( ncolors > 256 ) {
        FatalBadXCF("Colormap has %" PRIu32 " entries",ncolors);
        return XCF_ERROR;
      }
 
      /* Surprise! Some older version of the Gimp computed the wrong length
       * word, and the _reader_ always just reads three bytes per color
       * and ignores the length tag! Duplicate this so we too can read
       * the buggy XCF files.
       */
      length = minlength = 4+3*ncolors;
      break;
    }
  case PROP_COMPRESSION: minlength = 1; break;
  case PROP_OPACITY:     minlength = 4; break;
  case PROP_APPLY_MASK:  minlength = 4; break;
  case PROP_OFFSETS:     minlength = 8; break;
  case PROP_MODE:        minlength = 4; break;
  default:               minlength = 0; break;
  }
  if( length < minlength ) {
    FatalBadXCF("Short %s property at %" PRIX32 " (%" PRIu32 "<%" PRIu32 ")",
                showPropType(type),ptr,length,minlength);
    return XCF_ERROR;
  }
  *master = ptr+8+length ;
  total = 8 + length + (type != PROP_END ? 8 : 0) ;
  if( total < length ) { /* Check overwrap */
    FatalBadXCF("Overlong property at %" PRIX32, ptr);
    return XCF_ERROR;
  }
  if((response = xcfCheckspace(ptr,total,"Overlong property at %" PRIX32,ptr)) != 0) {
      return XCF_ERROR;
  }
  *typeOut = type;
  return XCF_OK;
}

References FatalBadXCF(), length(), PROP_APPLY_MASK, PROP_COLORMAP, PROP_COMPRESSION, PROP_END, PROP_MODE, PROP_OFFSETS, PROP_OPACITY, showPropType(), XCF_ERROR, XCF_OK, xcfCheckspace(), and xcfL.

xcfOffset()

int int xcfOffset	(	uint32_t	addr,
		int	spaceafter,
		uint32_t *	apparent )

Definition at line 34 of file xcf-general.c.

{
  if (!apparent) {
      return XCF_ERROR;
  }
  if(xcfCheckspace(addr,4,"(xcfOffset)") != XCF_OK) {
      return XCF_ERROR;
  }
  *apparent = xcfL(addr);
  if (xcfCheckspace(*apparent,spaceafter,
                "Too large offset (%" PRIX32 ") at position %" PRIX32,
                                *apparent,addr) != XCF_OK) {
      return XCF_ERROR;
  }
  return XCF_OK;
}

References XCF_ERROR, XCF_OK, xcfCheckspace(), and xcfL.

xcfString()

const char * xcfString	(	uint32_t	ptr,
		uint32_t *	after )

Definition at line 117 of file xcf-general.c.

{
  uint32_t length ;
  unsigned i ;
  ICONV_CONST char *utf8master ;
 
  if (xcfCheckspace(ptr,4,"(string length)") != XCF_OK) {
      return XCF_PTR_EMPTY;
  }
  length = xcfL(ptr) ;
  ptr += 4 ;
  if (xcfCheckspace(ptr,length,"(string)") != XCF_OK) {
      return XCF_PTR_EMPTY;
  }
  utf8master = (ICONV_CONST char*)(xcf_file+ptr) ;
  if( after ) *after = ptr + length ;
  if( length == 0 || utf8master[length-1] != 0 ) {
    FatalBadXCF("String at %" PRIX32 " not zero-terminated",ptr-4);
    return XCF_PTR_EMPTY;
  }
  length-- ;
 
  if( use_utf8 ) return utf8master ;
 
  /* We assume that the local character set includes ASCII...
   * Check if conversion is needed at all
   */
  for( i=0 ; ; i++ ) {
    if( i == length )
      return utf8master ; /* Only ASCII after all */
    if( utf8master[i] == 0 ) {
      FatalBadXCF("String at %" PRIX32 " has embedded zeroes",ptr-4);
      return XCF_PTR_EMPTY;
    }
    if( (int8_t) utf8master[i] < 0 )
      break ;
  }
#ifdef HAVE_ICONV
  {
    size_t targetsize = length+1 ;
    int sloppy_translation = 0 ;
    iconv_t cd = iconv_open("//TRANSLIT","UTF-8");
    if( cd == (iconv_t) -1 ) {
      cd = iconv_open("","UTF-8");
      sloppy_translation = 1 ;
    }
    if( cd == (iconv_t) -1 )
      iconv_close(cd) ; /* Give up; perhaps iconv doesn't know UTF-8 */
    else
      while(1) {
        char *buffer = xcfmalloc(targetsize) ;
        ICONV_CONST char *inbuf = utf8master ;
        char *outbuf = buffer ;
        size_t incount = length ;
        size_t outcount = targetsize ;
        while(1) { /* Loop for systems without //ICONV support */
          size_t result = iconv(cd,&inbuf,&incount,&outbuf,&outcount) ;
          if( result == (size_t)-1 && errno == EILSEQ &&
              sloppy_translation && outcount > 0 ) {
            *outbuf++ = '?' ;
            outcount-- ;
            while( (int8_t)*inbuf < 0 ) inbuf++, incount-- ;
            continue ;
          }
          if( result != (size_t)-1 ) {
            if( outcount == 0 )
              errno = E2BIG ;
            else {
              *outbuf = 0 ;
              iconv_close(cd) ;
              return buffer ;
            }
          }
          break ;
        }
        if( errno == EILSEQ || errno == EINVAL ) {
          FatalBadXCF("Bad UTF-8 encoding '%s' at %" PRIXPTR,
                      inbuf,(uintptr_t)((inbuf-utf8master)+ptr));
          return XCF_PTR_EMPTY;
        }
        if( errno == E2BIG ) {
          targetsize += 1+incount ;
          xcffree(buffer) ;
          continue ;
        }
        FatalUnexpected("!iconv on layer name at %" PRIX32, ptr);
        return XCF_PTR_EMPTY:
      }
  }
#endif
  {
    static int warned = 0 ;
    if( !warned ) {
      fprintf(stderr,_("Warning: one or more layer names could not be\n"
                       "         translated to the local character set.\n"));
      warned = 1 ;
    }
  }
  return utf8master ;
}

References _, FatalBadXCF(), FatalUnexpected(), ICONV_CONST, length(), use_utf8, xcf_file, XCF_OK, XCF_PTR_EMPTY, xcfCheckspace(), xcffree(), xcfL, and xcfmalloc().

Variable Documentation

progname

const char* progname

extern

Definition at line 25 of file utils.c.

use_utf8

int use_utf8

extern

Definition at line 31 of file xcf-general.c.

verboseFlag

int verboseFlag

extern

Definition at line 26 of file utils.c.

XCF

struct xcfImage XCF

xcf_file

uint8_t* xcf_file

extern

Definition at line 29 of file xcf-general.c.

xcf_length

size_t xcf_length

extern

Definition at line 30 of file xcf-general.c.