#include "Python.h"

#include <ctype.h>

#include "frameobject.h"

#include "expat.h"

#include "pyexpat.h"

#define XML_COMBINED_VERSION (10000*XML_MAJOR_VERSION+100*XML_MINOR_VERSION+XML_MICRO_VERSION)

#define FIX_TRACE

enum HandlerTypes {

};

static PyObject *ErrorObject;

typedef struct {

PyObject_HEAD

XML_Parser itself;

int ordered_attributes; /* Return attributes as a list. */

int specified_attributes; /* Report only specified attributes. */

int in_callback; /* Is a callback active? */

int ns_prefixes; /* Namespace-triplets mode? */

XML_Char *buffer; /* Buffer used when accumulating characters */

/* NULL if not enabled */

int buffer_size; /* Size of buffer, in XML_Char units */

int buffer_used; /* Buffer units in use */

PyObject *intern; /* Dictionary to intern strings */

PyObject **handlers;

} xmlparseobject;

#define CHARACTER_DATA_BUFFER_SIZE 8192

static PyTypeObject Xmlparsetype;

typedef void (*xmlhandlersetter)(XML_Parser self, void *meth);

typedef void* xmlhandler;

struct HandlerInfo {

};

static struct HandlerInfo handler_info[64];

static int

set_error_attr(PyObject *err, char *name, int value)

{

PyObject *v = PyLong_FromLong(value);

if (v == NULL || PyObject_SetAttrString(err, name, v) == -1) {

Py_XDECREF(v);

return 0;

}

Py_DECREF(v);

return 1;

}

static PyObject *

set_error(xmlparseobject *self, enum XML_Error code)

{

PyObject *err;

char buffer[256];

XML_Parser parser = self->itself;

int lineno = XML_GetErrorLineNumber(parser);

int column = XML_GetErrorColumnNumber(parser);

/* There is no risk of overflowing this buffer, since

sprintf(buffer, "%.200s: line %i, column %i",

XML_ErrorString(code), lineno, column);

err = PyObject_CallFunction(ErrorObject, "s", buffer);

if ( err != NULL

&& set_error_attr(err, "code", code)

&& set_error_attr(err, "offset", column)

&& set_error_attr(err, "lineno", lineno)) {

PyErr_SetObject(ErrorObject, err);

}

Py_XDECREF(err);

return NULL;

}

static int

have_handler(xmlparseobject *self, int type)

{

PyObject *handler = self->handlers[type];

return handler != NULL;

}

static PyObject *

get_handler_name(struct HandlerInfo *hinfo)

{

PyObject *name = hinfo->nameobj;

if (name == NULL) {

name = PyUnicode_FromString(hinfo->name);

hinfo->nameobj = name;

}

Py_XINCREF(name);

return name;

}

static PyObject *

conv_string_to_unicode(const XML_Char *str)

{

/* XXX currently this code assumes that XML_Char is 8-bit,

/* UTF-8 from Expat, Unicode desired */

if (str == NULL) {

Py_INCREF(Py_None);

return Py_None;

}

return PyUnicode_DecodeUTF8(str, strlen(str), "strict");

}

static PyObject *

conv_string_len_to_unicode(const XML_Char *str, int len)

{

/* XXX currently this code assumes that XML_Char is 8-bit,

/* UTF-8 from Expat, Unicode desired */

if (str == NULL) {

Py_INCREF(Py_None);

return Py_None;

}

return PyUnicode_DecodeUTF8((const char *)str, len, "strict");

}

static void clear_handlers(xmlparseobject *self, int initial);

static int

error_external_entity_ref_handler(XML_Parser parser,

const XML_Char *publicId)

{

return 0;

}

static void

noop_character_data_handler(void *userData, const XML_Char *data, int len)

{

/* Do nothing. */

}

static void

flag_error(xmlparseobject *self)

{

clear_handlers(self, 0);

XML_SetExternalEntityRefHandler(self->itself,

error_external_entity_ref_handler);

}

static PyCodeObject*

getcode(enum HandlerTypes slot, char* func_name, int lineno)

{

if (handler_info[slot].tb_code == NULL) {

handler_info[slot].tb_code =

PyCode_NewEmpty(__FILE__, func_name, lineno);

}

return handler_info[slot].tb_code;

}

#ifdef FIX_TRACE

static int

trace_frame(PyThreadState *tstate, PyFrameObject *f, int code, PyObject *val)

{

int result = 0;

if (!tstate->use_tracing || tstate->tracing)

return 0;

if (tstate->c_profilefunc != NULL) {

tstate->tracing++;

result = tstate->c_profilefunc(tstate->c_profileobj,

f, code , val);

tstate->use_tracing = ((tstate->c_tracefunc != NULL)

|| (tstate->c_profilefunc != NULL));

tstate->tracing--;

if (result)

return result;

}

if (tstate->c_tracefunc != NULL) {

tstate->tracing++;

result = tstate->c_tracefunc(tstate->c_traceobj,

f, code , val);

tstate->use_tracing = ((tstate->c_tracefunc != NULL)

|| (tstate->c_profilefunc != NULL));

tstate->tracing--;

}

return result;

}

static int

trace_frame_exc(PyThreadState *tstate, PyFrameObject *f)

{

PyObject *type, *value, *traceback, *arg;

int err;

if (tstate->c_tracefunc == NULL)

return 0;

PyErr_Fetch(&type, &value, &traceback);

if (value == NULL) {

value = Py_None;

Py_INCREF(value);

}

arg = PyTuple_Pack(3, type, value, traceback);

if (arg == NULL) {

PyErr_Restore(type, value, traceback);

return 0;

}

err = trace_frame(tstate, f, PyTrace_EXCEPTION, arg);

Py_DECREF(arg);

if (err == 0)

PyErr_Restore(type, value, traceback);

else {

Py_XDECREF(type);

Py_XDECREF(value);

Py_XDECREF(traceback);

}

return err;

}

static PyObject*

call_with_frame(PyCodeObject *c, PyObject* func, PyObject* args,

xmlparseobject *self)

{

PyThreadState *tstate = PyThreadState_GET();

PyFrameObject *f;

PyObject *res;

if (c == NULL)

return NULL;

f = PyFrame_New(tstate, c, PyEval_GetGlobals(), NULL);

if (f == NULL)

return NULL;

tstate->frame = f;

#ifdef FIX_TRACE

if (trace_frame(tstate, f, PyTrace_CALL, Py_None) < 0) {

return NULL;

}

res = PyEval_CallObject(func, args);

if (res == NULL) {

if (tstate->curexc_traceback == NULL)

PyTraceBack_Here(f);

XML_StopParser(self->itself, XML_FALSE);

#ifdef FIX_TRACE

if (trace_frame_exc(tstate, f) < 0) {

return NULL;

}

}

else {

if (trace_frame(tstate, f, PyTrace_RETURN, res) < 0) {

Py_XDECREF(res);

res = NULL;

}

}

}

tstate->frame = f->f_back;

Py_DECREF(f);

return res;

}

static PyObject*

string_intern(xmlparseobject *self, const char* str)

{

PyObject *result = conv_string_to_unicode(str);

PyObject *value;

/* result can be NULL if the unicode conversion failed. */

if (!result)

return result;

if (!self->intern)

return result;

value = PyDict_GetItem(self->intern, result);

if (!value) {

if (PyDict_SetItem(self->intern, result, result) == 0)

return result;

else

return NULL;

}

Py_INCREF(value);

Py_DECREF(result);

return value;

}

static int

call_character_handler(xmlparseobject *self, const XML_Char *buffer, int len)

{

PyObject *args;

PyObject *temp;

if (!have_handler(self, CharacterData))

return -1;

args = PyTuple_New(1);

if (args == NULL)

return -1;

temp = (conv_string_len_to_unicode(buffer, len));

if (temp == NULL) {

Py_DECREF(args);

flag_error(self);

XML_SetCharacterDataHandler(self->itself,

noop_character_data_handler);

return -1;

}

PyTuple_SET_ITEM(args, 0, temp);

/* temp is now a borrowed reference; consider it unused. */

self->in_callback = 1;

temp = call_with_frame(getcode(CharacterData, "CharacterData", __LINE__),

self->handlers[CharacterData], args, self);

/* temp is an owned reference again, or NULL */

self->in_callback = 0;

Py_DECREF(args);

if (temp == NULL) {

flag_error(self);

XML_SetCharacterDataHandler(self->itself,

noop_character_data_handler);

return -1;

}

Py_DECREF(temp);

return 0;

}

static int

flush_character_buffer(xmlparseobject *self)

{

int rc;

if (self->buffer == NULL || self->buffer_used == 0)

return 0;

rc = call_character_handler(self, self->buffer, self->buffer_used);

self->buffer_used = 0;

return rc;

}

static void

my_CharacterDataHandler(void *userData, const XML_Char *data, int len)

{

xmlparseobject *self = (xmlparseobject *) userData;

if (self->buffer == NULL)

call_character_handler(self, data, len);

else {

if ((self->buffer_used + len) > self->buffer_size) {

if (flush_character_buffer(self) < 0)

return;

/* handler might have changed; drop the rest on the floor

if (!have_handler(self, CharacterData))

return;

}

if (len > self->buffer_size) {

call_character_handler(self, data, len);

self->buffer_used = 0;

}

else {

memcpy(self->buffer + self->buffer_used,

data, len * sizeof(XML_Char));

self->buffer_used += len;

}

}

}

static void

my_StartElementHandler(void *userData,

const XML_Char *name, const XML_Char *atts[])

{

xmlparseobject *self = (xmlparseobject *)userData;

if (have_handler(self, StartElement)) {

PyObject *container, *rv, *args;

int i, max;

if (flush_character_buffer(self) < 0)

return;

/* Set max to the number of slots filled in atts[]; max/2 is

if (self->specified_attributes) {

max = XML_GetSpecifiedAttributeCount(self->itself);

}

else {

max = 0;

while (atts[max] != NULL)

max += 2;

}

/* Build the container. */

if (self->ordered_attributes)

container = PyList_New(max);

else

container = PyDict_New();

if (container == NULL) {

flag_error(self);

return;

}

for (i = 0; i < max; i += 2) {

PyObject *n = string_intern(self, (XML_Char *) atts[i]);

PyObject *v;

if (n == NULL) {

flag_error(self);

Py_DECREF(container);

return;

}

v = conv_string_to_unicode((XML_Char *) atts[i+1]);

if (v == NULL) {

flag_error(self);

Py_DECREF(container);

Py_DECREF(n);

return;

}

if (self->ordered_attributes) {

PyList_SET_ITEM(container, i, n);

PyList_SET_ITEM(container, i+1, v);

}

else if (PyDict_SetItem(container, n, v)) {

flag_error(self);

Py_DECREF(n);

Py_DECREF(v);

return;

}

else {

Py_DECREF(n);

Py_DECREF(v);

}

}

args = string_intern(self, name);

if (args != NULL)

args = Py_BuildValue("(NN)", args, container);

if (args == NULL) {

Py_DECREF(container);

return;

}

/* Container is now a borrowed reference; ignore it. */

self->in_callback = 1;

rv = call_with_frame(getcode(StartElement, "StartElement", __LINE__),

self->handlers[StartElement], args, self);

self->in_callback = 0;

Py_DECREF(args);

if (rv == NULL) {

flag_error(self);

return;

}

Py_DECREF(rv);

}

}

#define RC_HANDLER(RC, NAME, PARAMS, INIT, PARAM_FORMAT, CONVERSION, \

RETURN, GETUSERDATA) \

static RC \

my_##NAME##Handler PARAMS {\

xmlparseobject *self = GETUSERDATA ; \

PyObject *args = NULL; \

PyObject *rv = NULL; \

INIT \

\

if (have_handler(self, NAME)) { \

if (flush_character_buffer(self) < 0) \

return RETURN; \

args = Py_BuildValue PARAM_FORMAT ;\

if (!args) { flag_error(self); return RETURN;} \

self->in_callback = 1; \

rv = call_with_frame(getcode(NAME,#NAME,__LINE__), \

self->handlers[NAME], args, self); \

self->in_callback = 0; \

Py_DECREF(args); \

if (rv == NULL) { \

flag_error(self); \

return RETURN; \

} \

CONVERSION \

Py_DECREF(rv); \

} \

return RETURN; \

}

#define VOID_HANDLER(NAME, PARAMS, PARAM_FORMAT) \

RC_HANDLER(void, NAME, PARAMS, ;, PARAM_FORMAT, ;, ;,\

(xmlparseobject *)userData)

#define INT_HANDLER(NAME, PARAMS, PARAM_FORMAT)\

RC_HANDLER(int, NAME, PARAMS, int rc=0;, PARAM_FORMAT, \

rc = PyLong_AsLong(rv);, rc, \

(xmlparseobject *)userData)

VOID_HANDLER(EndElement,

(void *userData, const XML_Char *name),

("(N)", string_intern(self, name)))

VOID_HANDLER(ProcessingInstruction,

(void *userData,

const XML_Char *target,

const XML_Char *data),

("(NO&)", string_intern(self, target), conv_string_to_unicode ,data))

VOID_HANDLER(UnparsedEntityDecl,

(void *userData,

const XML_Char *entityName,

const XML_Char *base,

const XML_Char *systemId,

const XML_Char *publicId,

const XML_Char *notationName),

("(NNNNN)",

string_intern(self, entityName), string_intern(self, base),

string_intern(self, systemId), string_intern(self, publicId),

string_intern(self, notationName)))

VOID_HANDLER(EntityDecl,

(void *userData,

const XML_Char *entityName,

int is_parameter_entity,

const XML_Char *value,

int value_length,

const XML_Char *base,

const XML_Char *systemId,

const XML_Char *publicId,

const XML_Char *notationName),

("NiNNNNN",

string_intern(self, entityName), is_parameter_entity,

(conv_string_len_to_unicode(value, value_length)),

string_intern(self, base), string_intern(self, systemId),

string_intern(self, publicId),

string_intern(self, notationName)))

VOID_HANDLER(XmlDecl,

(void *userData,

const XML_Char *version,

const XML_Char *encoding,

int standalone),

("(O&O&i)",

conv_string_to_unicode ,version, conv_string_to_unicode ,encoding,

standalone))

static PyObject *

conv_content_model(XML_Content * const model,

PyObject *(*conv_string)(const XML_Char *))

{

PyObject *result = NULL;

PyObject *children = PyTuple_New(model->numchildren);

int i;

if (children != NULL) {

assert(model->numchildren < INT_MAX);

for (i = 0; i < (int)model->numchildren; ++i) {

PyObject *child = conv_content_model(&model->children[i],

conv_string);

if (child == NULL) {

Py_XDECREF(children);

return NULL;

}

PyTuple_SET_ITEM(children, i, child);

}

result = Py_BuildValue("(iiO&N)",

model->type, model->quant,

conv_string,model->name, children);

}

return result;

}

static void

my_ElementDeclHandler(void *userData,

const XML_Char *name,

XML_Content *model)

{

xmlparseobject *self = (xmlparseobject *)userData;

PyObject *args = NULL;

if (have_handler(self, ElementDecl)) {

PyObject *rv = NULL;

PyObject *modelobj, *nameobj;

if (flush_character_buffer(self) < 0)

goto finally;

modelobj = conv_content_model(model, (conv_string_to_unicode));

if (modelobj == NULL) {

flag_error(self);

goto finally;

}

nameobj = string_intern(self, name);

if (nameobj == NULL) {

Py_DECREF(modelobj);

flag_error(self);

goto finally;

}

args = Py_BuildValue("NN", nameobj, modelobj);

if (args == NULL) {

Py_DECREF(modelobj);

flag_error(self);

goto finally;

}

self->in_callback = 1;

rv = call_with_frame(getcode(ElementDecl, "ElementDecl", __LINE__),

self->handlers[ElementDecl], args, self);

self->in_callback = 0;

if (rv == NULL) {

flag_error(self);

goto finally;

}

Py_DECREF(rv);

}

finally:

Py_XDECREF(args);

XML_FreeContentModel(self->itself, model);

return;

}

VOID_HANDLER(AttlistDecl,

(void *userData,

const XML_Char *elname,

const XML_Char *attname,

const XML_Char *att_type,

const XML_Char *dflt,

int isrequired),

("(NNO&O&i)",

string_intern(self, elname), string_intern(self, attname),

conv_string_to_unicode ,att_type, conv_string_to_unicode ,dflt,

isrequired))

#if XML_COMBINED_VERSION >= 19504

VOID_HANDLER(SkippedEntity,

(void *userData,

const XML_Char *entityName,

int is_parameter_entity),

("Ni",

string_intern(self, entityName), is_parameter_entity))

VOID_HANDLER(NotationDecl,

(void *userData,

const XML_Char *notationName,

const XML_Char *base,

const XML_Char *systemId,

const XML_Char *publicId),

("(NNNN)",

string_intern(self, notationName), string_intern(self, base),

string_intern(self, systemId), string_intern(self, publicId)))

VOID_HANDLER(StartNamespaceDecl,

(void *userData,

const XML_Char *prefix,

const XML_Char *uri),

("(NN)",

string_intern(self, prefix), string_intern(self, uri)))

VOID_HANDLER(EndNamespaceDecl,

(void *userData,

const XML_Char *prefix),

("(N)", string_intern(self, prefix)))

VOID_HANDLER(Comment,

(void *userData, const XML_Char *data),

("(O&)", conv_string_to_unicode ,data))

VOID_HANDLER(StartCdataSection,

(void *userData),

("()"))

VOID_HANDLER(EndCdataSection,

(void *userData),

("()"))

VOID_HANDLER(Default,

(void *userData, const XML_Char *s, int len),

("(N)", (conv_string_len_to_unicode(s,len))))

VOID_HANDLER(DefaultHandlerExpand,

(void *userData, const XML_Char *s, int len),

("(N)", (conv_string_len_to_unicode(s,len))))

INT_HANDLER(NotStandalone,

(void *userData),

("()"))

RC_HANDLER(int, ExternalEntityRef,

(XML_Parser parser,

const XML_Char *context,

const XML_Char *base,

const XML_Char *systemId,

const XML_Char *publicId),

int rc=0;,

("(O&NNN)",

conv_string_to_unicode ,context, string_intern(self, base),

string_intern(self, systemId), string_intern(self, publicId)),

rc = PyLong_AsLong(rv);, rc,

XML_GetUserData(parser))

VOID_HANDLER(StartDoctypeDecl,

(void *userData, const XML_Char *doctypeName,

const XML_Char *sysid, const XML_Char *pubid,

int has_internal_subset),

("(NNNi)", string_intern(self, doctypeName),

string_intern(self, sysid), string_intern(self, pubid),

has_internal_subset))

VOID_HANDLER(EndDoctypeDecl, (void *userData), ("()"))

static PyObject *

get_parse_result(xmlparseobject *self, int rv)

{

if (PyErr_Occurred()) {

return NULL;

}

if (rv == 0) {

return set_error(self, XML_GetErrorCode(self->itself));

}

if (flush_character_buffer(self) < 0) {

return NULL;

}

return PyLong_FromLong(rv);

}

PyDoc_STRVAR(xmlparse_Parse__doc__,

Parse XML data. `isfinal' should be true at end of input.");

#define MAX_CHUNK_SIZE (1 << 20)

static PyObject *

xmlparse_Parse(xmlparseobject *self, PyObject *args)

{

PyObject *data;

int isFinal = 0;

const char *s;

Py_ssize_t slen;

Py_buffer view;

int rc;

if (!PyArg_ParseTuple(args, "O|i:Parse", &data, &isFinal))

return NULL;

if (PyUnicode_Check(data)) {

PyObject *bytes;

bytes = PyUnicode_AsUTF8String(data);

if (bytes == NULL)

return NULL;

view.buf = NULL;

s = PyBytes_AS_STRING(bytes);

slen = PyBytes_GET_SIZE(bytes);

/* Explicitly set UTF-8 encoding. Return code ignored. */

(void)XML_SetEncoding(self->itself, "utf-8");

}

else {

if (PyObject_GetBuffer(data, &view, PyBUF_SIMPLE) < 0)

return NULL;

s = view.buf;

slen = view.len;

}

while (slen > MAX_CHUNK_SIZE) {

rc = XML_Parse(self->itself, s, MAX_CHUNK_SIZE, 0);

if (!rc)

goto done;

s += MAX_CHUNK_SIZE;

slen -= MAX_CHUNK_SIZE;

}

rc = XML_Parse(self->itself, s, slen, isFinal);

done:

if (view.buf != NULL)

PyBuffer_Release(&view);

return get_parse_result(self, rc);

}

#define BUF_SIZE 2048

static int

readinst(char *buf, int buf_size, PyObject *meth)

{

PyObject *str;

Py_ssize_t len;

char *ptr;

str = PyObject_CallFunction(meth, "n", buf_size);

if (str == NULL)

goto error;

if (PyBytes_Check(str))

ptr = PyBytes_AS_STRING(str);

else if (PyByteArray_Check(str))

ptr = PyByteArray_AS_STRING(str);

else {

PyErr_Format(PyExc_TypeError,

"read() did not return a bytes object (type=%.400s)",

Py_TYPE(str)->tp_name);

goto error;

}

len = Py_SIZE(str);

if (len > buf_size) {

PyErr_Format(PyExc_ValueError,

"read() returned too much data: "

"%i bytes requested, %zd returned",

buf_size, len);

goto error;

}

memcpy(buf, ptr, len);

Py_DECREF(str);

/* len <= buf_size <= INT_MAX */

return (int)len;

error:

Py_XDECREF(str);

return -1;

}

PyDoc_STRVAR(xmlparse_ParseFile__doc__,

Parse XML data from file-like object.");

static PyObject *

xmlparse_ParseFile(xmlparseobject *self, PyObject *f)

{

int rv = 1;

PyObject *readmethod = NULL;

readmethod = PyObject_GetAttrString(f, "read");

if (readmethod == NULL) {

PyErr_SetString(PyExc_TypeError,

"argument must have 'read' attribute");

return NULL;

}

for (;;) {

int bytes_read;

void *buf = XML_GetBuffer(self->itself, BUF_SIZE);

if (buf == NULL) {

Py_XDECREF(readmethod);

return PyErr_NoMemory();

}

bytes_read = readinst(buf, BUF_SIZE, readmethod);

if (bytes_read < 0) {

Py_DECREF(readmethod);

return NULL;

}

rv = XML_ParseBuffer(self->itself, bytes_read, bytes_read == 0);

if (PyErr_Occurred()) {

Py_XDECREF(readmethod);

return NULL;

}

if (!rv || bytes_read == 0)

break;

}

Py_XDECREF(readmethod);

return get_parse_result(self, rv);

}

PyDoc_STRVAR(xmlparse_SetBase__doc__,

Set the base URL for the parser.");

static PyObject *

xmlparse_SetBase(xmlparseobject *self, PyObject *args)

{

char *base;

if (!PyArg_ParseTuple(args, "s:SetBase", &base))

return NULL;

if (!XML_SetBase(self->itself, base)) {

return PyErr_NoMemory();

}

Py_INCREF(Py_None);

return Py_None;

}

PyDoc_STRVAR(xmlparse_GetBase__doc__,

Return base URL string for the parser.");

static PyObject *

xmlparse_GetBase(xmlparseobject *self, PyObject *unused)

{

return Py_BuildValue("z", XML_GetBase(self->itself));

}

PyDoc_STRVAR(xmlparse_GetInputContext__doc__,

for an element with many attributes), not all of the text may be available.");

static PyObject *

xmlparse_GetInputContext(xmlparseobject *self, PyObject *unused)

{

if (self->in_callback) {

int offset, size;

const char *buffer

= XML_GetInputContext(self->itself, &offset, &size);

if (buffer != NULL)

return PyBytes_FromStringAndSize(buffer + offset,

size - offset);

else

Py_RETURN_NONE;

}

else

Py_RETURN_NONE;

}

PyDoc_STRVAR(xmlparse_ExternalEntityParserCreate__doc__,

information passed to the ExternalEntityRefHandler.");

static PyObject *

xmlparse_ExternalEntityParserCreate(xmlparseobject *self, PyObject *args)

{

char *context;

char *encoding = NULL;

xmlparseobject *new_parser;

int i;

if (!PyArg_ParseTuple(args, "z|s:ExternalEntityParserCreate",

&context, &encoding)) {

return NULL;

}

new_parser = PyObject_GC_New(xmlparseobject, &Xmlparsetype);

if (new_parser == NULL)

return NULL;

new_parser->buffer_size = self->buffer_size;

new_parser->buffer_used = 0;

new_parser->buffer = NULL;

new_parser->ordered_attributes = self->ordered_attributes;

new_parser->specified_attributes = self->specified_attributes;

new_parser->in_callback = 0;

new_parser->ns_prefixes = self->ns_prefixes;

new_parser->itself = XML_ExternalEntityParserCreate(self->itself, context,

encoding);

new_parser->handlers = 0;

new_parser->intern = self->intern;

Py_XINCREF(new_parser->intern);

PyObject_GC_Track(new_parser);