/*

* licensed under the same terms as the ReportLab Toolkit

* see http://www.reportlab.co.uk/svn/public/reportlab/trunk/reportlab/license.txt

* for details.

* history http://www.reportlab.co.uk/cgi-bin/viewcvs.cgi/public/reportlab/trunk/reportlab/lib/_rl_accel.c

*/

#include "Python.h"

#if PY_MAJOR_VERSION >= 3

#	define isPy3

#endif

#include <stdlib.h>

#include <math.h>

#define DEFERRED_ADDRESS(A) 0

#if defined(__GNUC__) || defined(sun) || defined(_AIX) || defined(__hpux)

#	define STRICMP strcasecmp

#elif defined(_MSC_VER)

#	define STRICMP stricmp

#elif defined(macintosh)

# include <extras.h>

# define strdup _strdup

# define STRICMP _stricmp

#else

#	error "Don't know how to define STRICMP"

#endif

#ifndef max

#	define max(a,b) ((a)>(b)?(a):(b))

#endif

#ifndef min

#	define min(a,b) ((a)<(b)?(a):(b))

#endif

#define VERSION "0.72"

#define MODULE "_rl_accel"

struct module_state	{

	int moduleLineno;

#ifndef isPy3

	PyObject *module;

#endif

	};

#ifdef isPy3

#	define GETSTATE(m) ((struct module_state*)PyModule_GetState(m))

#	define STRNAME "str"

#	define BYTESNAME "bytes"

#else

	static struct module_state _state;

#	include "bytesobject.h"

#	ifndef PyVarObject_HEAD_INIT

#		define PyVarObject_HEAD_INIT(type, size) \

        	PyObject_HEAD_INIT(type) size,

#	endif

#	ifndef Py_TYPE

#		define Py_TYPE(ob) (((PyObject*)(ob))->ob_type)

#	endif

#	define PyBytes_AS_STRING	PyString_AS_STRING

#	define PyBytes_AsString		PyString_AsString

#	define PyBytes_GET_SIZE 	PyString_GET_SIZE

#	define GETSTATE(m) (&_state)

#	define STRNAME "unicode"

#	define BYTESNAME "str"

#endif

#define ERROR_EXIT() {GETSTATE(module)->moduleLineno=__LINE__;goto L_ERR;}

#define ADD_TB(module,name) _add_TB(module,name)

#include "compile.h"

#include "frameobject.h"

#include "traceback.h"

static void _add_TB(PyObject *module,char *funcname)

{

	int	moduleLineno = GETSTATE(module)->moduleLineno;

	PyObject *py_globals = NULL;

	PyCodeObject *py_code = NULL;

	PyFrameObject *py_frame = NULL;

#ifdef isPy3

	py_globals = PyModule_GetDict(module);

#else

	py_globals = PyModule_GetDict(GETSTATE(module)->module);

#endif

	if(!py_globals) goto bad;

	py_code = PyCode_NewEmpty(

						__FILE__,		/*PyObject *filename,*/

						funcname,	/*PyObject *name,*/

						moduleLineno	/*int firstlineno,*/

						);

	if(!py_code) goto bad;

	py_frame = PyFrame_New(

		PyThreadState_Get(), /*PyThreadState *tstate,*/

		py_code,			 /*PyCodeObject *code,*/

		py_globals,			 /*PyObject *globals,*/

		0					 /*PyObject *locals*/

		);

	if(!py_frame) goto bad;

	py_frame->f_lineno = moduleLineno;

	PyTraceBack_Here(py_frame);

bad:

	Py_XDECREF(py_code);

	Py_XDECREF(py_frame);

}

#define a85_0		   1L

#define a85_1		   85L

#define a85_2		 7225L

#define a85_3	   614125L

#define a85_4	 52200625L

PyObject *_a85_encode(PyObject *module, PyObject *args)

{

	unsigned char	*inData;

	int				length, blocks, extra, i, k, lim;

	unsigned long	block, res;

	char			*buf;

	PyObject		*retVal=NULL, *inObj, *_o1=NULL;

	if(!PyArg_ParseTuple(args, "O", &inObj)) return NULL;

	if(PyUnicode_Check(inObj)){

		_o1 = PyUnicode_AsLatin1String(inObj);

		if(!_o1){

			PyErr_SetString(PyExc_ValueError,"argument not decodable as latin1");

			ERROR_EXIT();

			}

		inData = PyBytes_AsString(_o1);

		inObj = _o1;

		if(!inData){

			PyErr_SetString(PyExc_ValueError,"argument not converted to internal char string");

			ERROR_EXIT();

			}

		}

	else if(!PyBytes_Check(inObj)){

		PyErr_SetString(PyExc_ValueError,"argument should be " BYTESNAME " or latin1 decodable " STRNAME);

		ERROR_EXIT();

		}

	inData = PyBytes_AsString(inObj);

	length = PyBytes_GET_SIZE(inObj);

	blocks = length / 4;

	extra = length % 4;

	buf = (char*)malloc((blocks+1)*5+3);

	lim = 4*blocks;

	for(k=i=0; i<lim; i += 4){

		/*

		 * If you evere have trouble with this consider using masking to ensure

		 * that the shifted quantity is only 8 bits long

		 */

		block = ((unsigned long)inData[i]<<24)|((unsigned long)inData[i+1]<<16)

				|((unsigned long)inData[i+2]<<8)|((unsigned long)inData[i+3]);

		if (block == 0) buf[k++] = 'z';

		else {

			res = block/a85_4;

			buf[k++] = (char)(res+33);

			block -= res*a85_4;

			res = block/a85_3;

			buf[k++] = (char)(res+33);

			block -= res*a85_3;

			res = block/a85_2;

			buf[k++] = (char)(res+33);

			block -= res*a85_2;

			res = block / a85_1;

			buf[k++] = (char)(res+33);

			buf[k++] = (char)(block-res*a85_1+33);

			}

		}

	if(extra>0){

		block = 0L;

		for (i=0; i<extra; i++)

			block += (unsigned long)inData[length-extra+i] << (24-8*i);

		res = block/a85_4;

		buf[k++] = (char)(res+33);

		if(extra>=1){

			block -= res*a85_4;

			res = block/a85_3;

			buf[k++] = (char)(res+33);

			if(extra>=2){

				block -= res*a85_3;

				res = block/a85_2;

				buf[k++] = (char)(res+33);

				if(extra>=3) buf[k++] = (char)((block-res*a85_2)/a85_1+33);

				}

			}

		}

	buf[k++] = '~';

	buf[k++] = '>';

	retVal = PyUnicode_FromStringAndSize(buf, k);

	free(buf);

	if(!retVal){

		PyErr_SetString(PyExc_ValueError,"failed to create return " STRNAME " value" );

		ERROR_EXIT();

		}

L_exit:

	Py_XDECREF(_o1);

	return retVal;

L_ERR:

	ADD_TB(module,"asciiBase85Encode");

	goto L_exit;

}

PyObject *_a85_decode(PyObject *module, PyObject *args)

{

	unsigned char	*inData, *p, *q, *tmp, *buf;

	unsigned int	length, blocks, extra, k, num, c1, c2, c3, c4, c5;

	static unsigned pad[] = {0,0,0xffffff,0xffff,0xff};

	PyObject		*retVal=NULL, *inObj, *_o1=NULL;

	if(!PyArg_ParseTuple(args, "O", &inObj)) return NULL;

	if(PyUnicode_Check(inObj)){

		_o1 = PyUnicode_AsLatin1String(inObj);

		if(!_o1){

			PyErr_SetString(PyExc_ValueError,"argument not decodable as latin1");

			ERROR_EXIT();

			}

		inData = PyBytes_AsString(_o1);

		inObj = _o1;

		if(!inData){

			PyErr_SetString(PyExc_ValueError,"argument not converted to internal char string");

			ERROR_EXIT();

			}

		}

	else if(!PyBytes_Check(inObj)){

		PyErr_SetString(PyExc_ValueError,"argument should be " BYTESNAME " or latin1 decodable " STRNAME);

		ERROR_EXIT();

		}

	inData = PyBytes_AsString(inObj);

	length = PyBytes_GET_SIZE(inObj);

	for(k=0,q=inData, p=q+length;q<p && (q=(unsigned char*)strchr((const char*)q,'z'));k++, q++);	/*count 'z'*/

	length += k*4;

	tmp = q = (unsigned char*)malloc(length+1);

	while(inData<p && (k = *inData++)){

		if(isspace(k)) continue;

		if(k=='z'){

			/*turn 'z' into '!!!!!'*/

			memcpy(q,"!!!!!",5);

			q += 5;

			}

		else

			*q++ = k;

		}

	inData = tmp;

	length = q - inData;

	buf = inData+length-2;

	if(buf[0]!='~' || buf[1]!='>'){

		PyErr_SetString(PyExc_ValueError, "Invalid terminator for Ascii Base 85 Stream");

		free(inData);

		ERROR_EXIT();

		}

	length -= 2;

	buf[0] = 0;

	blocks = length / 5;

	extra = length % 5;

	buf = (unsigned char*)malloc((blocks+1)*4);

	q = inData+blocks*5;

	for(k=0;inData<q;inData+=5){

		c1 = inData[0]-33;

		c2 = inData[1]-33;

		c3 = inData[2]-33;

		c4 = inData[3]-33;

		c5 = inData[4]-33;

		num = (((c1*85+c2)*85+c3)*85+c4)*85+c5;

		buf[k++] = num>>24;

		buf[k++] = num>>16;

		buf[k++] = num>>8;

		buf[k++] = num;

		}

	if(extra>1){

		c1 = inData[0]-33;

		c2 = extra>=2 ? inData[1]-33: 0;

		c3 = extra>=3 ? inData[2]-33: 0;

		c4 = extra>=4 ? inData[3]-33: 0;

		c5 = 0;

		num = (((c1*85+c2)*85+c3)*85+c4)*85+c5 + pad[extra];

		if(extra>1){

			buf[k++] = num>>24;

			if(extra>2){

				buf[k++] = num>>16;

				if(extra>3){

					buf[k++] = num>>8;

					}

				}

			}

		}

	retVal = PyBytes_FromStringAndSize((const char*)buf, k);

	free(buf);

	free(tmp);

	if(!retVal){

		PyErr_SetString(PyExc_ValueError,"failed to create return " BYTESNAME " value" );

		ERROR_EXIT();

		}

L_exit:

	Py_XDECREF(_o1);

	return retVal;

L_ERR:

	ADD_TB(module,"asciiBase85Decode");

	goto L_exit;

}

static	char* _fp_fmts[]={"%.0f", "%.1f", "%.2f", "%.3f", "%.4f", "%.5f", "%.6f"};

static	char *_fp_one(PyObject* module,PyObject *pD)

{

	double	d, ad;

	static	char s[30];

	int l;

	char*	dot;

	if((pD=PyNumber_Float(pD))){

		d = PyFloat_AS_DOUBLE(pD);

		Py_DECREF(pD);

		}

	else {

		PyErr_SetString(PyExc_ValueError, "bad numeric value");

		return NULL;

		}

	ad = fabs(d);

	if(ad<=1.0e-7){

		s[0]='0';

		s[1]=0;

		}

	else{

		if(ad>1e20){

			PyErr_SetString(PyExc_ValueError, "number too large");

			return NULL;

			}

		if(ad>1) l = min(max(0,6-(int)log10(ad)),6);

		else l = 6;

		sprintf(s,_fp_fmts[l], d);

		if(l){

			l = strlen(s)-1;

			while(l && s[l]=='0') l--;

			if(s[l]=='.' || s[l]==',') s[l]=0;

			else {

				s[l+1]=0;

				if(s[0]=='0' && (s[1]=='.'||s[1]==',')){

					if(s[1]==',') s[1] = '.';

					return s+1;

					}

				}

			if((dot=strchr(s,','))) *dot = '.';

			}

		}

	return s;

}

PyObject *_fp_str(PyObject *module, PyObject *args)

{

	int				aL;

	PyObject		*retVal;

	char			*pD;

	char			*buf, *pB;

	int				i;

	if((aL=PySequence_Length(args))>=0){

		if(aL==1){

			retVal = PySequence_GetItem(args,0);

			if((i=PySequence_Length(retVal))>=0){

				aL = i;

				args = retVal;

				}

			else PyErr_Clear();

			Py_DECREF(retVal);

			}

		buf=malloc(31*aL);

		pB = buf;

		for(i=0;i<aL;i++){

			retVal = PySequence_GetItem(args,i);

			if(retVal){

				pD = _fp_one(module,retVal);

				Py_DECREF(retVal);

				}

			else pD = NULL;

			if(!pD){

				free(buf);

				return NULL;

				}

			if(pB!=buf){

				*pB++ = ' ';

				}

			strcpy(pB,pD);

			pB = pB + strlen(pB);

			}

		*pB = 0;

#ifdef isPy3

		retVal = PyUnicode_FromString(buf);

#else

		retVal = PyBytes_FromString(buf);

#endif

		free(buf);

		return retVal;

		}

	else {

		PyErr_Clear();

		PyArg_ParseTuple(args, "O:_fp_str", &retVal);

		return NULL;

		}

}

static PyObject *_escapePDF(unsigned char* text, int textlen)

{

	unsigned char*	out = PyMem_Malloc((textlen<<2)+1);

	int				j=0, i=0;

	char			buf[4];

	PyObject*		ret;

	while(i<textlen){

		unsigned char c = text[i++];

		if(c<32 || c>=127){

			sprintf(buf,"%03o",c);

			out[j++] = '\\';

			out[j++] = buf[0];

			out[j++] = buf[1];

			out[j++] = buf[2];

			}

		else {

			if(c=='\\' || c=='(' || c==')') out[j++] = '\\';

			out[j++] = c;

			}

		}

#ifdef isPy3

	ret = PyUnicode_FromStringAndSize((const char *)out,j);

#else

	ret = PyBytes_FromStringAndSize((const char *)out,j);

#endif

	PyMem_Free(out);

	return ret;

}

static PyObject *escapePDF(PyObject *module, PyObject* args)

{

	unsigned char	*text;

	int				textLen;

	if (!PyArg_ParseTuple(args, "s#:escapePDF", &text, &textLen)) return NULL;

	return _escapePDF(text,textLen);

}

static PyObject *sameFrag(PyObject *module, PyObject* args)

{

	PyObject *f, *g;

	static char *names[] = {"fontName", "fontSize", "textColor", "rise", "underline", "strike", "link", "backColor", NULL};

	int	r=0, t;

	char **p;

	if (!PyArg_ParseTuple(args, "OO:sameFrag", &f, &g)) return NULL;

	if(PyObject_HasAttrString(f,"cbDefn")||PyObject_HasAttrString(g,"cbDefn")

		|| PyObject_HasAttrString(f,"lineBreak")||PyObject_HasAttrString(g,"lineBreak")) goto L0;

	for(p=names;*p;p++){

		PyObject *fa, *ga;

		fa = PyObject_GetAttrString(f,*p);

		ga = PyObject_GetAttrString(g,*p);

		if(fa && ga){

#ifdef	isPy3

			t = PyObject_RichCompareBool(fa,ga,Py_NE);

#else

			t = PyObject_Compare(fa,ga);

#endif

			Py_DECREF(fa);

			Py_DECREF(ga);

			if(PyErr_Occurred()) goto L1;

			}

		else{

			t = fa==ga ? 0 : 1;

			Py_XDECREF(fa);

			Py_XDECREF(ga);

			PyErr_Clear();

			}

		if(t) goto L0;

		}

	r = 1;

L0:	return PyBool_FromLong((long)r);

L1:	return NULL;

}

static PyObject *ttfonts_calcChecksum(PyObject *module, PyObject* args)

{

	unsigned char	*data;

	int				dataLen;

	unsigned long	Sum = 0L;

	unsigned char	*EndPtr;

	unsigned long n;

	int leftover;

	if (!PyArg_ParseTuple(args, "s#:calcChecksum", &data, &dataLen)) return NULL;

	EndPtr = data + (dataLen & ~3);

	/*full ULONGs*/

	while(data < EndPtr){

		n = ((*data++) << 24);

		n += ((*data++) << 16);

		n += ((*data++) << 8);

		n += ((*data++));

		Sum += n;

		}

	/*pad with zeros*/

	leftover = dataLen & 3;

	if(leftover){

		n = ((*data++) << 24);

		if (leftover>1) n += ((*data++) << 16);

		if (leftover>2) n += ((*data++) << 8);