Lines Matching defs:entity

396   /* false once a parameter entity reference has been skipped */
422 ENTITY *entity;
429 XML_ACCOUNT_ENTITY_EXPANSION, /* intermediate bytes produced during entity
484 static enum XML_Error processInternalEntity(XML_Parser parser, ENTITY *entity,
529 static enum XML_Error storeSelfEntityValue(XML_Parser parser, ENTITY *entity);
609 static void entityTrackingReportStats(XML_Parser parser, ENTITY *entity,
611 static void entityTrackingOnOpen(XML_Parser parser, ENTITY *entity,
613 static void entityTrackingOnClose(XML_Parser parser, ENTITY *entity,
1050 parsers (i.e. external entity parsers) will inherit it
1579 /* external parameter entity parsers share the DTD structure
2452 return XML_L("illegal parameter entity reference");
2454 return XML_L("undefined entity");
2456 return XML_L("recursive entity reference");
2458 return XML_L("asynchronous entity");
2462 return XML_L("reference to binary entity");
2464 return XML_L("reference to external entity in attribute");
2466 return XML_L("XML or text declaration not at start of entity");
2474 return XML_L("error in processing external entity reference");
2480 return XML_L("entity declared in parameter entity");
2492 return XML_L("incomplete markup in parameter entity");
2508 return XML_L("cannot suspend in external parameter entity");
2915 ENTITY *entity;
2937 entity = (ENTITY *)lookup(parser, &dtd->generalEntities, name, 0);
2940 if yes, check that the entity exists, and that it is internal,
2941 otherwise call the skipped entity or default handler.
2944 if (! entity)
2946 else if (! entity->is_internal)
2948 } else if (! entity) {
2955 if (entity->open)
2957 if (entity->notation)
2959 if (entity->textPtr) {
2963 parser->m_skippedEntityHandler(parser->m_handlerArg, entity->name,
2969 result = processInternalEntity(parser, entity, XML_FALSE);
2974 entity->open = XML_TRUE;
2976 entity->open = XML_FALSE;
2980 parser->m_externalEntityRefHandlerArg, context, entity->base,
2981 entity->systemId, entity->publicId))
4093 if (parser->m_parentParser) { /* we are parsing an external entity */
4265 * from the internal entity processing, and IGNORE sections are an
4507 so we consider the external parameter entity read */
4550 /* found end of entity value - can store it now */
4559 * that to happen, a parameter entity parsing handler must have attempted
4678 /* found end of entity value - can store it now */
4917 ENTITY *entity = (ENTITY *)lookup(parser, &dtd->paramEntities,
4919 if (! entity) {
4922 * external entity parsing, so no allocation will happen
4928 entity->base = parser->m_curBase;
4931 parser->m_externalEntityRefHandlerArg, 0, entity->base,
4932 entity->systemId, entity->publicId))
4964 ENTITY *entity = (ENTITY *)lookup(parser, &dtd->paramEntities,
4966 if (! entity)
4968 entity->base = parser->m_curBase;
4971 parser->m_externalEntityRefHandlerArg, 0, entity->base,
4972 entity->systemId, entity->publicId))
5220 // This will store "&entity123;" in entity->textPtr
5284 entity, then the entity declaration is not considered "internal"
5314 entity, then the entity declaration is not considered "internal"
5494 ENTITY *entity;
5499 entity = (ENTITY *)lookup(parser, &dtd->paramEntities, name, 0);
5502 if yes, check that the entity exists, and that it is internal,
5503 otherwise call the skipped entity handler
5508 if (! entity)
5510 else if (! entity->is_internal) {
5517 * 'if' statement. That means the only entity in the hash
5519 * given as a parameter entity name in XML syntax, so the
5521 * the test for an internal entity.
5533 } else if (! entity) {
5543 if (entity->open)
5545 if (entity->textPtr) {
5549 result = processInternalEntity(parser, entity, betweenDecl);
5557 entity->open = XML_TRUE;
5558 entityTrackingOnOpen(parser, entity, __LINE__);
5560 parser->m_externalEntityRefHandlerArg, 0, entity->base,
5561 entity->systemId, entity->publicId)) {
5562 entityTrackingOnClose(parser, entity, __LINE__);
5563 entity->open = XML_FALSE;
5566 entityTrackingOnClose(parser, entity, __LINE__);
5567 entity->open = XML_FALSE;
5834 processInternalEntity(XML_Parser parser, ENTITY *entity, XML_Bool betweenDecl) {
5849 entity->open = XML_TRUE;
5851 entityTrackingOnOpen(parser, entity, __LINE__);
5853 entity->processed = 0;
5856 openEntity->entity = entity;
5861 textStart = (const char *)entity->textPtr;
5862 textEnd = (const char *)(entity->textPtr + entity->textLen);
5866 if (entity->is_param) {
5880 entity->processed = (int)(next - textStart);
5882 } else if (parser->m_openInternalEntities->entity == entity) {
5884 entityTrackingOnClose(parser, entity, __LINE__);
5886 entity->open = XML_FALSE;
5899 ENTITY *entity;
5907 entity = openEntity->entity;
5908 textStart = ((const char *)entity->textPtr) + entity->processed;
5909 textEnd = (const char *)(entity->textPtr + entity->textLen);
5913 if (entity->is_param) {
5929 entity->processed = (int)(next - (const char *)entity->textPtr);
5934 entityTrackingOnClose(parser, entity, __LINE__);
5936 entity->open = XML_FALSE;
5943 // upcoming call to XML_ResumeParser continue with entity content, or it would
5950 if (entity->is_param) {
6069 ENTITY *entity;
6091 entity = (ENTITY *)lookup(parser, &dtd->generalEntities, name, 0);
6094 if yes, check that the entity exists, and that it is internal.
6106 if (! entity)
6108 else if (! entity->is_internal)
6110 } else if (! entity) {
6111 /* Cannot report skipped entity here - see comments on
6123 if (entity->open) {
6127 * The "if (entity->open)" check catches recursive entity
6129 * entity, it must have gone through this code before and
6136 * here with entity->open being TRUE.
6146 if (entity->notation) {
6151 if (! entity->textPtr) {
6157 const XML_Char *textEnd = entity->textPtr + entity->textLen;
6158 entity->open = XML_TRUE;
6160 entityTrackingOnOpen(parser, entity, __LINE__);
6163 isCdata, (const char *)entity->textPtr,
6167 entityTrackingOnClose(parser, entity, __LINE__);
6169 entity->open = XML_FALSE;
6177 * Getting that would require an entity name to contain an
6211 since this would indicate an external entity; therefore we
6235 ENTITY *entity;
6243 entity = (ENTITY *)lookup(parser, &dtd->paramEntities, name, 0);
6245 if (! entity) {
6247 /* cannot report skipped entity here - see comments on
6255 if (entity->open || (entity == parser->m_declEntity)) {
6261 if (entity->systemId) {
6264 entity->open = XML_TRUE;
6265 entityTrackingOnOpen(parser, entity, __LINE__);
6267 parser->m_externalEntityRefHandlerArg, 0, entity->base,
6268 entity->systemId, entity->publicId)) {
6269 entityTrackingOnClose(parser, entity, __LINE__);
6270 entity->open = XML_FALSE;
6274 entityTrackingOnClose(parser, entity, __LINE__);
6275 entity->open = XML_FALSE;
6281 entity->open = XML_TRUE;
6282 entityTrackingOnOpen(parser, entity, __LINE__);
6284 parser, parser->m_internalEncoding, (const char *)entity->textPtr,
6285 (const char *)(entity->textPtr + entity->textLen),
6287 entityTrackingOnClose(parser, entity, __LINE__);
6288 entity->open = XML_FALSE;
6296 within markup declarations, e.g entity values in this case. */
6384 storeSelfEntityValue(XML_Parser parser, ENTITY *entity) {
6385 // This will store "&entity123;" in entity->textPtr
6392 || ! poolAppendString(pool, entity->name)
6398 entity->textPtr = poolStart(pool);
6399 entity->textLen = (int)(poolLength(pool));
6493 * entity, already converted to internal format). This by
7068 /* Copy the entity tables. */
7403 * place to copy the text of a simple general entity. By that
7404 * point, the name of the entity is already stored in the pool, so
7968 entityTrackingReportStats(XML_Parser rootParser, ENTITY *entity,
7977 const char *const entityName = entity->name;
7987 entity->is_param ? "%" : "&", entityName, action, entity->textLen,
7992 entityTrackingOnOpen(XML_Parser originParser, ENTITY *entity, int sourceLine) {
8003 entityTrackingReportStats(rootParser, entity, "OPEN ", sourceLine);
8007 entityTrackingOnClose(XML_Parser originParser, ENTITY *entity, int sourceLine) {
8011 entityTrackingReportStats(rootParser, entity, "CLOSE", sourceLine);