static void XMLCALL endNamespaceHandler(void* userData, const char* prefix) {
    XML_Parser parser = reinterpret_cast<XML_Parser>(userData);
    Stack* stack = reinterpret_cast<Stack*>(XML_GetUserData(parser));

    assert(!stack->nodeStack.empty());
    stack->nodeStack.pop();
}
Esempio n. 2
0
static int
pdb_xml_external_entity_ref_cb (XML_Parser xml_parser,
                                const XML_Char *context,
                                const XML_Char *base,
                                const XML_Char *system_id,
                                const XML_Char *public_id)
{
  PdbXmlParser *parser = XML_GetUserData (xml_parser);
  PdbXmlStackEntry *stack_top;
  XML_Parser external_parser;
  GError *error = NULL;
  char *filename;
  gboolean ret;

  if (system_id == NULL)
    {
      g_set_error (&parser->abort_error,
                   PDB_ERROR,
                   PDB_ERROR_BAD_FORMAT,
                   _("%s:%i:%i: An external entity was encountered "
                     "without a system id"),
                   pdb_xml_get_current_filename (parser),
                   pdb_xml_get_current_line_number (parser),
                   pdb_xml_get_current_column_number (parser));
      return XML_STATUS_ERROR;
    }

  external_parser = XML_ExternalEntityParserCreate (xml_parser,
                                                    context,
                                                    NULL);
  pdb_xml_init_parser (parser, external_parser);

  if (base)
    filename = g_strconcat (base, "/", system_id, NULL);
  else
    filename = g_strdup (system_id);

  g_array_set_size (parser->stack, parser->stack->len + 1);
  stack_top = &g_array_index (parser->stack,
                              PdbXmlStackEntry,
                              parser->stack->len - 1);
  stack_top->parser = external_parser;
  stack_top->filename = NULL;

  ret = pdb_xml_parse (parser, filename, &error);

  g_free (filename);

  XML_ParserFree (external_parser);

  g_array_set_size (parser->stack, parser->stack->len - 1);

  if (ret)
    return XML_STATUS_OK;
  else
    {
      parser->abort_error = error;
      return XML_STATUS_ERROR;
    }
}
Esempio n. 3
0
static ERL_NIF_TERM parse(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
    XML_Parser **parser;
    int is_final, res, errcode;
    ErlNifBinary stream;
    char *errstring;

    assert(argc == 3);

    if (!enif_get_resource(env, argv[0], PARSER_POINTER, (void **)&parser))
        return enif_make_badarg(env);

    if (!enif_is_binary(env, argv[1]))
        return enif_make_badarg(env);

    enif_get_int(env, argv[2], &is_final);
    enif_inspect_binary(env, argv[1], &stream);

    expat_parser *parser_data = XML_GetUserData((XML_Parser)(*parser));
    parser_data->result = enif_make_list(env, 0);
    parser_data->env = env;
    XML_SetUserData((XML_Parser)(*parser), parser_data);

    res = XML_Parse((XML_Parser)(*parser), (const char *)stream.data, stream.size, is_final);
    if(!res)
        {
            errcode = XML_GetErrorCode((XML_Parser)(*parser));
            errstring = (char *)XML_ErrorString(errcode);

            return enif_make_tuple(env, 2, ERROR,
                                   enif_make_string(env, errstring, ERL_NIF_LATIN1));
        }

    return enif_make_tuple(env, 2, OK, parser_data->result);
};
int _68k_extentrefhandler(XML_Parser parser, const char *context, const char *base,
	const char *sysid, const char *pubid)
{
	M68kXML_Parser p = XML_GetUserData(parser);
	void *arg = p->extenthandlerarg;
	return (int)call_68k_code(p->IExec, p->extentrefhandler, 5, arg ? arg : p, context, base, sysid, pubid);
}
static void XMLCALL characterDataHandler(void* userData, const char* s, int len) {
    XML_Parser parser = reinterpret_cast<XML_Parser>(userData);
    Stack* stack = reinterpret_cast<Stack*>(XML_GetUserData(parser));

    if (!s || len <= 0) {
        return;
    }

    // See if we can just append the text to a previous text node.
    if (!stack->nodeStack.empty()) {
        Node* currentParent = stack->nodeStack.top();
        if (!currentParent->children.empty()) {
            Node* lastChild = currentParent->children.back().get();
            if (lastChild->type == NodeType::kText) {
                Text* text = static_cast<Text*>(lastChild);
                text->text += util::utf8ToUtf16(StringPiece(s, len));
                return;
            }
        }
    }

    std::unique_ptr<Text> text = util::make_unique<Text>();
    text->text = util::utf8ToUtf16(StringPiece(s, len));
    addToStack(stack, parser, std::move(text));
}
Esempio n. 6
0
END_TEST

/* Regression test for SF bug #616863. */
static int XMLCALL
external_entity_handler(XML_Parser parser,
                        const XML_Char *context,
                        const XML_Char *base,
                        const XML_Char *systemId,
                        const XML_Char *publicId) 
{
    int callno = 1 + (int)XML_GetUserData(parser);
    char *text;
    XML_Parser p2;

    if (callno == 1)
        text = ("<!ELEMENT doc (e+)>\n"
                "<!ATTLIST doc xmlns CDATA #IMPLIED>\n"
                "<!ELEMENT e EMPTY>\n");
    else
        text = ("<?xml version='1.0' encoding='us-ascii'?>"
                "<e/>");

    XML_SetUserData(parser, (void *) callno);
    p2 = XML_ExternalEntityParserCreate(parser, context, NULL);
    if (XML_Parse(p2, text, strlen(text), XML_TRUE) == XML_STATUS_ERROR) {
        xml_failure(p2);
        return 0;
    }
    XML_ParserFree(p2);
    return 1;
}
Esempio n. 7
0
void sb_parser_destroy(XML_Parser p)
{
    void *x = XML_GetUserData(p);
    if (x)
        free(x);
    XML_ParserFree(p);
}
Esempio n. 8
0
void XMLCALL LoadPropertyTreeFromXml_OnEndRootElement(
  void *userData, const XML_Char *name)
{
  XML_Parser parser = (XML_Parser)userData;
  Sys::PropertyTree* result = (Sys::PropertyTree*)XML_GetUserData(parser);
  std::string s = Sys::TrimSpaces(result->Text());
  result->SetText(s.c_str());
}
static void XMLCALL endElementHandler(void* userData, const char* name) {
    XML_Parser parser = reinterpret_cast<XML_Parser>(userData);
    Stack* stack = reinterpret_cast<Stack*>(XML_GetUserData(parser));

    assert(!stack->nodeStack.empty());
    stack->nodeStack.top()->comment = std::move(stack->pendingComment);
    stack->nodeStack.pop();
}
Esempio n. 10
0
void XMLCALL LoadPropertyTreeFromXml_OnStartElement(
  void *userData, const XML_Char *name, const XML_Char **props)
{
  XML_Parser parser = (XML_Parser)userData;
  Sys::PropertyTree* result = (Sys::PropertyTree*)XML_GetUserData(parser);
  result = result->CreateChild(name);
  CopyAllProps(result, props);
  XML_SetUserData(parser, result);
}
Esempio n. 11
0
void XMLCALL LoadPropertyTreeFromXml_OnCharacterData(
  void *userData, const XML_Char *text, int textLength)
{
  XML_Parser parser = (XML_Parser)userData;
  Sys::PropertyTree* result = (Sys::PropertyTree*)XML_GetUserData(parser);
  std::string s = result->Text(); // (!) performance warning
  s.append(text, textLength);
  result->SetText(s.data(), (int)s.length());
}
Esempio n. 12
0
static void XMLCALL commentDataHandler(void* userData, const char* comment) {
    XML_Parser parser = reinterpret_cast<XML_Parser>(userData);
    Stack* stack = reinterpret_cast<Stack*>(XML_GetUserData(parser));

    if (!stack->pendingComment.empty()) {
        stack->pendingComment += '\n';
    }
    stack->pendingComment += util::utf8ToUtf16(comment);
}
Esempio n. 13
0
void parser_dtor(ErlNifEnv *env, void* obj)
{
    XML_Parser* parser = (XML_Parser*) obj;
    if(!parser)
        return;

    expat_parser* parser_data = XML_GetUserData(*parser);
    enif_free(parser_data);
    XML_ParserFree(*parser);
};
Esempio n. 14
0
void XMLCALL LoadPropertyTreeFromXml_OnStartRootElement(
  void *userData, const XML_Char *name, const XML_Char **props)
{
  XML_Parser parser = (XML_Parser)userData;
  Sys::PropertyTree* result = (Sys::PropertyTree*)XML_GetUserData(parser);
  result->SetName(name);
  CopyAllProps(result, props);
  XML_SetElementHandler(parser,
    LoadPropertyTreeFromXml_OnStartElement,
    LoadPropertyTreeFromXml_OnEndElement);
}
Esempio n. 15
0
int ParserEngine::handleExternalEntityRef(XML_Parser parser, const XML_Char* context, const XML_Char* base, const XML_Char* systemId, const XML_Char* publicId)
{
	ParserEngine* pThis = reinterpret_cast<ParserEngine*>(XML_GetUserData(parser));

	if (!context && !pThis->_externalParameterEntities) return XML_STATUS_ERROR;
	if (context && !pThis->_externalGeneralEntities) return XML_STATUS_ERROR;

	InputSource* pInputSource = 0;
	EntityResolver* pEntityResolver = 0;
	EntityResolverImpl defaultResolver;

	XMLString sysId(systemId);
	XMLString pubId;
	if (publicId) pubId.assign(publicId);
	
	URI uri(fromXMLString(pThis->_context.back()->getSystemId()));
	uri.resolve(fromXMLString(sysId));

	if (pThis->_pEntityResolver)
	{
		pEntityResolver = pThis->_pEntityResolver;
		pInputSource = pEntityResolver->resolveEntity(publicId ? &pubId : 0, toXMLString(uri.toString()));
	}
	if (!pInputSource && pThis->_externalGeneralEntities)
	{
		pEntityResolver = &defaultResolver;
		pInputSource = pEntityResolver->resolveEntity(publicId ? &pubId : 0, toXMLString(uri.toString()));
	}

	if (pInputSource)
	{
		XML_Parser extParser = XML_ExternalEntityParserCreate(pThis->_parser, context, 0);
		if (!extParser) throw XMLException("Cannot create external entity parser");

		try
		{
			pThis->parseExternal(extParser, pInputSource);
		}
		catch (XMLException&)
		{
			pEntityResolver->releaseInputSource(pInputSource);
			XML_ParserFree(extParser);
			throw;
		}
		pEntityResolver->releaseInputSource(pInputSource);
		XML_ParserFree(extParser);
		return XML_STATUS_OK;
	}
	else return XML_STATUS_ERROR;
}
Esempio n. 16
0
void HostileFactory::setFactoryCallbacks(XML_Parser p, XML_StartElementHandler start, XML_EndElementHandler end,RenderableAbstractFactory * renderableFactory)
{
	currentHostile = new Hostile();
	oldStart = start;
	oldEnd = end;
	oldUserData = XML_GetUserData(p);
	currentParer = p;

	g_renderableFactory = renderableFactory;

	//Put hostile factory handler
	XML_SetUserData(currentParer, currentHostile);
	XML_SetElementHandler(currentParer, hostile_xmlstart, hostile_xmlend);
}
Esempio n. 17
0
            node_expat::node_expat(parser_expat* parser, node_expat* parent, int depth, node::_t_on_parsed_node on_parsed, const char* tag, const char**atts):node(tag, parent, depth, on_parsed),_parser(parser) {
                /*
                Implementar lectura de atts
                this->set_attribute(id, value);
                */
                for (size_t i =0; atts[i]; i+=2) {
                    this->set_attribute(atts[i], atts[i+1]);
                    }

                __walker_depth = depth;
                _old_user_data = XML_GetUserData(_parser->get_parser());
                __container = new expat_handler_container(this);
                XML_SetUserData(_parser->get_parser(), __container);
                }
Esempio n. 18
0
bool my_parse_callback( const char *buff, void *opaque )
{
	struct user_data_struct *ds = (struct user_data_struct *)opaque;
	if ( XML_Parse( ds->parser, buff,
			strlen(buff), XML_FALSE ) == XML_STATUS_ERROR )
	{
		std::cout << "Error parsing xml output:"
					<< buff << std::endl;
	}
	else
		ds->parsed_xml = true;

	FeXMLParser *p = (FeXMLParser *)XML_GetUserData( ds->parser );
	return p->get_continue_parse(); // return false to cancel callback
}
Esempio n. 19
0
void XMLCALL LoadPropertyTreeFromXml_OnEndElement(
  void *userData, const XML_Char *name)
{
  XML_Parser parser = (XML_Parser)userData;
  Sys::PropertyTree* result = (Sys::PropertyTree*)XML_GetUserData(parser);
  std::string s = Sys::TrimSpaces(result->Text());
  result->SetText(s.c_str());
  result = result->Parent();
  XML_SetUserData(parser, result);
  if (result == NULL)
  {
    // Expat reads first root tag only, so we do not need
    // protection from multiple root tags.
  }
}
Esempio n. 20
0
static void XMLCALL startNamespaceHandler(void* userData, const char* prefix, const char* uri) {
    XML_Parser parser = reinterpret_cast<XML_Parser>(userData);
    Stack* stack = reinterpret_cast<Stack*>(XML_GetUserData(parser));

    std::unique_ptr<Namespace> ns = util::make_unique<Namespace>();
    if (prefix) {
        ns->namespacePrefix = util::utf8ToUtf16(prefix);
    }

    if (uri) {
        ns->namespaceUri = util::utf8ToUtf16(uri);
    }

    addToStack(stack, parser, std::move(ns));
}
Esempio n. 21
0
/****************************************************************************************************************
 * Entry end
*****************************************************************************************************************/
static void XMLCALL _NFentryEnd (void *argPtr, const char *entry) {
	CMreturn ret;
	NFdata_t   *data;
	NFobject_p object, parent;
	XML_Parser parser = (XML_Parser) argPtr;

	data = (NFdata_t *) XML_GetUserData (parser);

	if (data->Skip) {
		if (strcmp (data->SkipName,entry) == 0) {
			data->SkipLevel--;
			if (data->SkipLevel == 0) {
				data->Skip = false;
				free (data->SkipName);
			}
		}
		return;
	}
	data->Stack--;
	object = data->Objects [data->Stack];
	parent = data->Stack > 0 ? data->Objects [data->Stack - 1] : (NFobject_p) NULL;
	switch (object->Type) {
	case NFcompAggregate: ret = NFparseCompAggregateFinalize (parent, object); break;
	case NFcompContainer: ret = NFparseCompContainerFinalize (parent, object); break;
	case NFcompInput:     ret = NFparseCompInputFinalize     (parent, object); break;
	case NFcompModel:     ret = NFparseCompModelFinalize     (object);         break;
	case NFcompRegion:    ret = NFparseCompRegionFinalize    (parent, object); break;
	case NFnumInitial:    ret = NFparseNumVariableFinalize   (parent, object); break;
	case NFnumParameter:  ret = NFparseNumParameterFinalize  (parent, object); break;
	case NFnumVariable:   ret = NFparseNumVariableFinalize   (parent, object); break;
	case NFmodDerivative: ret = NFparseModDerivativeFinalize (parent, object); break;
	case NFmodInterface:  ret = NFparseModInterfaceFinalize  (parent, object); break;
	case NFmodEquation:   ret = NFparseModEquationFinalize   (parent, object); break;
	case NFmodProcess:    ret = NFparseModProcessFinalize    (parent, object); break;
	case NFmodRoute:      ret = NFparseModRouteFinalize      (parent, object); break;
	case NFobjAlias:      ret = NFparseObjAliasFinalize      (parent, object); break;
	case NFobjCategory:   ret = NFparseObjCategoryFinalize   (parent, object); break;
	case NFobjOutput:     ret = NFparseObjOutputFinalize     (parent, object); break;
	case NFobjPlugin:     CMmsgPrint (CMmsgAppError, "This should never happen! %s:%d\n",__FILE__,__LINE__); break;
	}
	if (ret == CMfailed) goto Abort;
	data->Objects [data->Stack] = (NFobject_p) NULL;
	return;

Abort:
	data->Abort = true;
	return;
}
Esempio n. 22
0
static size_t parseStreamCallback(void *contents, size_t length, size_t nmemb, void *userp)
{
    XML_Parser parser = (XML_Parser) userp;
    size_t real_size = length * nmemb;
    struct ParserStruct *state = (struct ParserStruct *) XML_GetUserData(parser);

    /* Only parse if we're not already in a failure state. */
    if (state->ok && XML_Parse(parser, contents, real_size, 0) == 0) {
        int error_code = XML_GetErrorCode(parser);
        fprintf(stderr, "Parsing response buffer of length %lu failed with error code %d (%s).\n",
                real_size, error_code, XML_ErrorString(error_code));
        state->ok = 0;
    }

    return real_size;
}
Esempio n. 23
0
static ERL_NIF_TERM free_parser(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
    XML_Parser **parser;

    assert(argc == 1);

    if (!enif_get_resource(env, argv[0], PARSER_POINTER, (void **)&parser))
        return enif_make_badarg(env);

    expat_parser *parser_data = XML_GetUserData((XML_Parser)(*parser));
    enif_free(parser_data);

    XML_ParserFree((XML_Parser)(*parser));

    return OK;
};
Esempio n. 24
0
BrokerMessage *sb_parser_process(XML_Parser p, char *buffer, int len)
{
    BrokerParserData *bp = (BrokerParserData *) XML_GetUserData(p);
    bp->msg = calloc(1, sizeof(BrokerMessage));
    XML_ParserReset(p, NULL);
    XML_SetUserData(p, bp);
    XML_SetElementHandler(p, sbx_start, sbx_end);
    XML_SetCharacterDataHandler(p, getText);

    if (!XML_Parse(p, buffer, len, 1)) {
        fprintf(stderr, "Parse error at line %d:\n%s\n",
                XML_GetCurrentLineNumber(p),
                XML_ErrorString(XML_GetErrorCode(p)));
        exit(-1);
    }

    return bp->msg;
}
Esempio n. 25
0
static ERL_NIF_TERM reset_parser(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
    XML_Parser **parser;

    assert(argc == 1);

    if (!enif_get_resource(env, argv[0], PARSER_POINTER, (void **)&parser))
        return enif_make_badarg(env);

    expat_parser *parser_data = XML_GetUserData((XML_Parser)(*parser));
    parser_data->result = enif_make_list(env, 0);
    parser_data->xmlns = (ERL_NIF_TERM)NULL;
    parser_data->env = env;

    assert(XML_TRUE == XML_ParserReset((XML_Parser)(*parser), "UTF-8"));
    init_parser((XML_Parser)(*parser), parser_data);

    return OK;
};
Esempio n. 26
0
int _xml_externalEntityRefHandler(XML_ParserStruct* /* void* */ parserPtr,
                                  const XML_Char *openEntityNames,
                                  const XML_Char *base,
                                  const XML_Char *systemId,
                                  const XML_Char *publicId) {
  XmlParser *parser = (XmlParser*)XML_GetUserData((XML_Parser)parserPtr);
  int ret = 0; /* abort if no handler is set (should be configurable?) */
  if (parser && parser->externalEntityRefHandler) {
    Array args = Array::Create();
    args.append(parser);
    args.append(_xml_xmlchar_zval(openEntityNames, 0,
                                  parser->target_encoding));
    args.append(_xml_xmlchar_zval(base, 0, parser->target_encoding));
    args.append(_xml_xmlchar_zval(systemId, 0, parser->target_encoding));
    args.append(_xml_xmlchar_zval(publicId, 0, parser->target_encoding));
    ret = xml_call_handler(parser, parser->externalEntityRefHandler, args);
  }
  return ret;
}
Esempio n. 27
0
END_TEST

static int
external_entity_loader(XML_Parser parser,
                       const XML_Char *context,
                       const XML_Char *base,
                       const XML_Char *systemId,
                       const XML_Char *publicId)
{
    char *text = (char *)XML_GetUserData(parser);
    XML_Parser extparser;

    extparser = XML_ExternalEntityParserCreate(parser, context, NULL);
    if (extparser == NULL)
        fail("Could not create external entity parser.");
    if (XML_Parse(extparser, text, strlen(text), 1) == XML_STATUS_ERROR) {
        xml_failure(parser);
        return 0;
    }
    return 1;
}
Esempio n. 28
0
static void XMLCALL startElementHandler(void* userData, const char* name, const char** attrs) {
    XML_Parser parser = reinterpret_cast<XML_Parser>(userData);
    Stack* stack = reinterpret_cast<Stack*>(XML_GetUserData(parser));

    std::unique_ptr<Element> el = util::make_unique<Element>();
    splitName(name, &el->namespaceUri, &el->name);

    while (*attrs) {
        Attribute attribute;
        splitName(*attrs++, &attribute.namespaceUri, &attribute.name);
        attribute.value = util::utf8ToUtf16(*attrs++);

        // Insert in sorted order.
        auto iter = std::lower_bound(el->attributes.begin(), el->attributes.end(), attribute,
                                     lessAttribute);
        el->attributes.insert(iter, std::move(attribute));
    }

    el->comment = std::move(stack->pendingComment);
    addToStack(stack, parser, std::move(el));
}
Esempio n. 29
0
int 
RS_XML(externalEntityHandler)(XML_Parser parser, const XML_Char *context, 
                              const XML_Char *base, const XML_Char *systemId, 
                                const XML_Char *publicId)
{
 RS_XMLParserData *parserData = (RS_XMLParserData*)XML_GetUserData(parser);
 USER_OBJECT_ opArgs;
 int i, num;
  const XML_Char *xml_args[4];
  num = sizeof(xml_args)/sizeof(xml_args[0]);
   xml_args[0] = context; xml_args[1] = base;xml_args[2] = systemId; xml_args[3] = publicId;

  opArgs = NEW_LIST(num);
  for(i =0;i < num; i++) {
    RECURSIVE_DATA(opArgs)[i] = NEW_CHARACTER(1); 
    CHARACTER_DATA(RECURSIVE_DATA(opArgs)[i])[0] = ENC_COPY_TO_USER_STRING(xml_args[i] ? xml_args[i] : "");
  }

 RS_XML(callUserFunction)("externalEntity", NULL, parserData, opArgs);
 return(1); /* ok to go on */
}
Esempio n. 30
0
/****************************************************************************************************************
 * Entry text
*****************************************************************************************************************/
static void XMLCALL _NFentryText (void *argPtr, const char *str, int len) {
	char *whiteChars = " \t\n";
	size_t i, start, end;
	bool white;
	NFdata_t *data;
//	NFobject_p object;
	XML_Parser parser = (XML_Parser) argPtr;

	data = (NFdata_t *) XML_GetUserData (parser);

	if (data->Skip) return;
	
	for (start = 0;start < len; start++) {
		for (i = 0;i < strlen (whiteChars); ++i)
			if (str [start] == whiteChars [i]) { white = true; break; }
		if (white == false) break;
		white = false;
	}
	if (start == len) return;

	for (end = len;end > 0; end--) {
		for (i = 0;i < strlen (whiteChars); ++i)
			if (str [end - 1] == whiteChars [i]) { white = true; break; }
		if (white == false) break;
		white = false;
	}
	if (end - start + 1 > data->BufferLen) {
		if ((data->Buffer = (char *) realloc (data->Buffer,end - start + 1)) == (char *) NULL) {
			CMmsgPrint (CMmsgSysError,"Memory allocation error in %s:%d\n\n",__FILE__,__LINE__);
			return;
		}
		data->BufferLen = end - start + 1;
	}

	strncpy (data->Buffer, str + start, end - start);
	data->Buffer [end - start] = '\0';
//	TODO Initialize
//	object->Notes = CMstrAppend (object->Notes, data->Buffer, "\n");
}