Lines Matching defs:entity
373 /* false once a parameter entity reference has been skipped */
399 ENTITY *entity;
406 XML_ACCOUNT_ENTITY_EXPANSION, /* intermediate bytes produced during entity
461 static enum XML_Error processInternalEntity(XML_Parser parser, ENTITY *entity,
579 static void entityTrackingReportStats(XML_Parser parser, ENTITY *entity,
581 static void entityTrackingOnOpen(XML_Parser parser, ENTITY *entity,
583 static void entityTrackingOnClose(XML_Parser parser, ENTITY *entity,
958 parsers (i.e. external entity parsers) will inherit it
1481 /* external parameter entity parsers share the DTD structure
2382 return XML_L("illegal parameter entity reference");
2384 return XML_L("undefined entity");
2386 return XML_L("recursive entity reference");
2388 return XML_L("asynchronous entity");
2392 return XML_L("reference to binary entity");
2394 return XML_L("reference to external entity in attribute");
2396 return XML_L("XML or text declaration not at start of entity");
2404 return XML_L("error in processing external entity reference");
2410 return XML_L("entity declared in parameter entity");
2422 return XML_L("incomplete markup in parameter entity");
2438 return XML_L("cannot suspend in external parameter entity");
2830 ENTITY *entity;
2852 entity = (ENTITY *)lookup(parser, &dtd->generalEntities, name, 0);
2855 if yes, check that the entity exists, and that it is internal,
2856 otherwise call the skipped entity or default handler.
2859 if (! entity)
2861 else if (! entity->is_internal)
2863 } else if (! entity) {
2870 if (entity->open)
2872 if (entity->notation)
2874 if (entity->textPtr) {
2878 parser->m_skippedEntityHandler(parser->m_handlerArg, entity->name,
2884 result = processInternalEntity(parser, entity, XML_FALSE);
2889 entity->open = XML_TRUE;
2891 entity->open = XML_FALSE;
2895 parser->m_externalEntityRefHandlerArg, context, entity->base,
2896 entity->systemId, entity->publicId))
4008 if (parser->m_parentParser) { /* we are parsing an external entity */
4180 * from the internal entity processing, and IGNORE sections are an
4422 so we consider the external parameter entity read */
4465 /* found end of entity value - can store it now */
4474 * that to happen, a parameter entity parsing handler must have attempted
4593 /* found end of entity value - can store it now */
4830 ENTITY *entity = (ENTITY *)lookup(parser, &dtd->paramEntities,
4832 if (! entity) {
4835 * external entity parsing, so no allocation will happen
4841 entity->base = parser->m_curBase;
4844 parser->m_externalEntityRefHandlerArg, 0, entity->base,
4845 entity->systemId, entity->publicId))
4877 ENTITY *entity = (ENTITY *)lookup(parser, &dtd->paramEntities,
4879 if (! entity)
4881 entity->base = parser->m_curBase;
4884 parser->m_externalEntityRefHandlerArg, 0, entity->base,
4885 entity->systemId, entity->publicId))
5165 entity, then the entity declaration is not considered "internal"
5195 entity, then the entity declaration is not considered "internal"
5375 ENTITY *entity;
5380 entity = (ENTITY *)lookup(parser, &dtd->paramEntities, name, 0);
5383 if yes, check that the entity exists, and that it is internal,
5384 otherwise call the skipped entity handler
5389 if (! entity)
5391 else if (! entity->is_internal) {
5398 * 'if' statement. That means the only entity in the hash
5400 * given as a parameter entity name in XML syntax, so the
5402 * the test for an internal entity.
5414 } else if (! entity) {
5424 if (entity->open)
5426 if (entity->textPtr) {
5430 result = processInternalEntity(parser, entity, betweenDecl);
5438 entity->open = XML_TRUE;
5439 entityTrackingOnOpen(parser, entity, __LINE__);
5441 parser->m_externalEntityRefHandlerArg, 0, entity->base,
5442 entity->systemId, entity->publicId)) {
5443 entityTrackingOnClose(parser, entity, __LINE__);
5444 entity->open = XML_FALSE;
5447 entityTrackingOnClose(parser, entity, __LINE__);
5448 entity->open = XML_FALSE;
5715 processInternalEntity(XML_Parser parser, ENTITY *entity, XML_Bool betweenDecl) {
5730 entity->open = XML_TRUE;
5732 entityTrackingOnOpen(parser, entity, __LINE__);
5734 entity->processed = 0;
5737 openEntity->entity = entity;
5742 textStart = (const char *)entity->textPtr;
5743 textEnd = (const char *)(entity->textPtr + entity->textLen);
5748 if (entity->is_param) {
5762 entity->processed = (int)(next - textStart);
5766 entityTrackingOnClose(parser, entity, __LINE__);
5768 entity->open = XML_FALSE;
5781 ENTITY *entity;
5789 entity = openEntity->entity;
5790 textStart = ((const char *)entity->textPtr) + entity->processed;
5791 textEnd = (const char *)(entity->textPtr + entity->textLen);
5796 if (entity->is_param) {
5812 entity->processed = (int)(next - (const char *)entity->textPtr);
5817 entityTrackingOnClose(parser, entity, __LINE__);
5819 entity->open = XML_FALSE;
5826 // upcoming call to XML_ResumeParser continue with entity content, or it would
5834 if (entity->is_param) {
5955 ENTITY *entity;
5977 entity = (ENTITY *)lookup(parser, &dtd->generalEntities, name, 0);
5980 if yes, check that the entity exists, and that it is internal.
5992 if (! entity)
5994 else if (! entity->is_internal)
5996 } else if (! entity) {
5997 /* Cannot report skipped entity here - see comments on
6009 if (entity->open) {
6013 * The "if (entity->open)" check catches recursive entity
6015 * entity, it must have gone through this code before and
6022 * here with entity->open being TRUE.
6032 if (entity->notation) {
6037 if (! entity->textPtr) {
6043 const XML_Char *textEnd = entity->textPtr + entity->textLen;
6044 entity->open = XML_TRUE;
6046 entityTrackingOnOpen(parser, entity, __LINE__);
6049 isCdata, (const char *)entity->textPtr,
6053 entityTrackingOnClose(parser, entity, __LINE__);
6055 entity->open = XML_FALSE;
6063 * Getting that would require an entity name to contain an
6096 since this would indicate an external entity; therefore we
6122 ENTITY *entity;
6130 entity = (ENTITY *)lookup(parser, &dtd->paramEntities, name, 0);
6132 if (! entity) {
6134 /* cannot report skipped entity here - see comments on
6142 if (entity->open) {
6148 if (entity->systemId) {
6151 entity->open = XML_TRUE;
6152 entityTrackingOnOpen(parser, entity, __LINE__);
6154 parser->m_externalEntityRefHandlerArg, 0, entity->base,
6155 entity->systemId, entity->publicId)) {
6156 entityTrackingOnClose(parser, entity, __LINE__);
6157 entity->open = XML_FALSE;
6161 entityTrackingOnClose(parser, entity, __LINE__);
6162 entity->open = XML_FALSE;
6168 entity->open = XML_TRUE;
6169 entityTrackingOnOpen(parser, entity, __LINE__);
6171 parser, parser->m_internalEncoding, (const char *)entity->textPtr,
6172 (const char *)(entity->textPtr + entity->textLen),
6174 entityTrackingOnClose(parser, entity, __LINE__);
6175 entity->open = XML_FALSE;
6183 within markup declarations, e.g entity values in this case. */
6354 * entity, already converted to internal format). This by
6914 /* Copy the entity tables. */
7249 * place to copy the text of a simple general entity. By that
7250 * point, the name of the entity is already stored in the pool, so
7801 entityTrackingReportStats(XML_Parser rootParser, ENTITY *entity,
7810 const char *const entityName = entity->name;
7820 entity->is_param ? "%" : "&", entityName, action, entity->textLen,
7825 entityTrackingOnOpen(XML_Parser originParser, ENTITY *entity, int sourceLine) {
7836 entityTrackingReportStats(rootParser, entity, "OPEN ", sourceLine);
7840 entityTrackingOnClose(XML_Parser originParser, ENTITY *entity, int sourceLine) {
7844 entityTrackingReportStats(rootParser, entity, "CLOSE", sourceLine);