Index: encoding.c =================================================================== RCS file: /sources/public/XML/encoding.c,v retrieving revision 1.50 diff -p -r1.50 encoding.c *** encoding.c 2000/08/04 17:51:27 1.50 --- encoding.c 2000/08/23 13:21:52 *************** *** 50,55 **** --- 50,66 ---- xmlCharEncodingHandlerPtr xmlUTF16LEHandler = NULL; xmlCharEncodingHandlerPtr xmlUTF16BEHandler = NULL; + typedef struct _xmlCharEncodingAlias xmlCharEncodingAlias; + typedef xmlCharEncodingAlias *xmlCharEncodingAliasPtr; + struct _xmlCharEncodingAlias { + const char *name; + const char *alias; + }; + + static xmlCharEncodingAliasPtr xmlCharEncodingAliases = NULL; + static int xmlCharEncodingAliasesNb = 0; + static int xmlCharEncodingAliasesMax = 0; + #ifdef LIBXML_ICONV_ENABLED #if 0 #define DEBUG_ENCODING /* Define this to get encoding traces */ *************** xmlDetectCharEncoding(const unsigned cha *** 906,911 **** --- 917,1073 ---- } /** + * xmlCleanupEncodingAliases: + * + * Unregisters all aliases + */ + void + xmlCleanupEncodingAliases(void) { + int i; + + if (xmlCharEncodingAliases == NULL) + return; + + for (i = 0;i < xmlCharEncodingAliasesNb;i++) { + if (xmlCharEncodingAliases[i].name != NULL) + xmlFree((char *) xmlCharEncodingAliases[i].name); + if (xmlCharEncodingAliases[i].alias != NULL) + xmlFree((char *) xmlCharEncodingAliases[i].alias); + } + xmlCharEncodingAliasesNb = 0; + xmlCharEncodingAliasesMax = 0; + xmlFree(xmlCharEncodingAliases); + } + + /** + * xmlGetEncodingAlias: + * @alias: the alias name as parsed, in UTF-8 format (ASCII actually) + * + * Lookup an encoding name for the given alias. + * + * Returns NULL if not found the original name otherwise + */ + const char * + xmlGetEncodingAlias(const char *alias) { + int i; + char upper[100]; + + if (alias == NULL) + return(NULL); + + if (xmlCharEncodingAliases == NULL) + return(NULL); + + for (i = 0;i < 99;i++) { + upper[i] = toupper(alias[i]); + if (upper[i] == 0) break; + } + upper[i] = 0; + + /* + * Walk down the list looking for a definition of the alias + */ + for (i = 0;i < xmlCharEncodingAliasesNb;i++) { + if (!strcmp(xmlCharEncodingAliases[i].alias, upper)) { + return(xmlCharEncodingAliases[i].name); + } + } + return(NULL); + } + + /** + * xmlAddEncodingAlias: + * @name: the encoding name as parsed, in UTF-8 format (ASCII actually) + * @alias: the alias name as parsed, in UTF-8 format (ASCII actually) + * + * Registers and alias @alias for an encoding named @name. Existing alias + * will be overwritten. + * + * Returns 0 in case of success, -1 in case of error + */ + int + xmlAddEncodingAlias(const char *name, const char *alias) { + int i; + char upper[100]; + + if ((name == NULL) || (alias == NULL)) + return(-1); + + for (i = 0;i < 99;i++) { + upper[i] = toupper(alias[i]); + if (upper[i] == 0) break; + } + upper[i] = 0; + + if (xmlCharEncodingAliases == NULL) { + xmlCharEncodingAliasesNb = 0; + xmlCharEncodingAliasesMax = 20; + xmlCharEncodingAliases = (xmlCharEncodingAliasPtr) + xmlMalloc(xmlCharEncodingAliasesMax * sizeof(xmlCharEncodingAlias)); + if (xmlCharEncodingAliases == NULL) + return(-1); + } else if (xmlCharEncodingAliasesNb >= xmlCharEncodingAliasesMax) { + xmlCharEncodingAliasesMax *= 2; + xmlCharEncodingAliases = (xmlCharEncodingAliasPtr) + xmlRealloc(xmlCharEncodingAliases, + xmlCharEncodingAliasesMax * sizeof(xmlCharEncodingAlias)); + } + /* + * Walk down the list looking for a definition of the alias + */ + for (i = 0;i < xmlCharEncodingAliasesNb;i++) { + if (!strcmp(xmlCharEncodingAliases[i].alias, upper)) { + /* + * Replace the definition. + */ + xmlFree((char *) xmlCharEncodingAliases[i].name); + xmlCharEncodingAliases[i].name = xmlMemStrdup(name); + return(0); + } + } + /* + * Add the definition + */ + xmlCharEncodingAliases[xmlCharEncodingAliasesNb].name = xmlMemStrdup(name); + xmlCharEncodingAliases[xmlCharEncodingAliasesNb].alias = xmlMemStrdup(upper); + xmlCharEncodingAliasesNb++; + return(0); + } + + /** + * xmlDelEncodingAlias: + * @alias: the alias name as parsed, in UTF-8 format (ASCII actually) + * + * Unregisters an encoding alias @alias + * + * Returns 0 in case of success, -1 in case of error + */ + int + xmlDelEncodingAlias(const char *alias) { + int i; + + if (alias == NULL) + return(-1); + + if (xmlCharEncodingAliases == NULL) + return(-1); + /* + * Walk down the list looking for a definition of the alias + */ + for (i = 0;i < xmlCharEncodingAliasesNb;i++) { + if (!strcmp(xmlCharEncodingAliases[i].alias, alias)) { + xmlFree((char *) xmlCharEncodingAliases[i].name); + xmlFree((char *) xmlCharEncodingAliases[i].alias); + xmlCharEncodingAliasesNb--; + memmove(&xmlCharEncodingAliases[i], &xmlCharEncodingAliases[i + 1], + sizeof(xmlCharEncodingAlias) * (xmlCharEncodingAliasesNb - i)); + return(0); + } + } + return(-1); + } + + /** * xmlParseCharEncoding: * @name: the encoding name as parsed, in UTF-8 format (ASCII actually) * *************** xmlDetectCharEncoding(const unsigned cha *** 919,927 **** --- 1081,1100 ---- xmlCharEncoding xmlParseCharEncoding(const char* name) { + const char *alias; char upper[500]; int i; + if (name == NULL) + return(XML_CHAR_ENCODING_NONE); + + /* + * Do the alias resolution + */ + alias = xmlGetEncodingAlias(name); + if (alias != NULL) + name = alias; + for (i = 0;i < 499;i++) { upper[i] = toupper(name[i]); if (upper[i] == 0) break; *************** xmlNewCharEncodingHandler(const char *na *** 1076,1086 **** --- 1249,1267 ---- xmlCharEncodingInputFunc input, xmlCharEncodingOutputFunc output) { xmlCharEncodingHandlerPtr handler; + const char *alias; char upper[500]; int i; char *up = 0; /* + * Do the alias resolution + */ + alias = xmlGetEncodingAlias(name); + if (alias != NULL) + name = alias; + + /* * Keep only the uppercase version of the encoding. */ if (name == NULL) { *************** xmlInitCharEncodingHandlers(void) { *** 1168,1177 **** * xmlCleanupCharEncodingHandlers: * * Cleanup the memory allocated for the char encoding support, it ! * unregisters all the encoding handlers. */ void xmlCleanupCharEncodingHandlers(void) { if (handlers == NULL) return; for (;nbCharEncodingHandler > 0;) { --- 1349,1360 ---- * xmlCleanupCharEncodingHandlers: * * Cleanup the memory allocated for the char encoding support, it ! * unregisters all the encoding handlers and the aliases. */ void xmlCleanupCharEncodingHandlers(void) { + xmlCleanupEncodingAliases(); + if (handlers == NULL) return; for (;nbCharEncodingHandler > 0;) { *************** xmlGetCharEncodingHandler(xmlCharEncodin *** 1350,1355 **** --- 1533,1540 ---- */ xmlCharEncodingHandlerPtr xmlFindCharEncodingHandler(const char *name) { + const char *nalias; + const char *norig; xmlCharEncoding alias; #ifdef LIBXML_ICONV_ENABLED xmlCharEncodingHandlerPtr enc; *************** xmlFindCharEncodingHandler(const char *n *** 1363,1368 **** --- 1548,1561 ---- if (name[0] == 0) return(xmlDefaultCharEncodingHandler); /* + * Do the alias resolution + */ + norig = name; + nalias = xmlGetEncodingAlias(name); + if (nalias != NULL) + name = nalias; + + /* * Check first for directly registered encoding names */ for (i = 0;i < 99;i++) { *************** xmlFindCharEncodingHandler(const char *n *** 1412,1418 **** /* * Fallback using the canonical names */ ! alias = xmlParseCharEncoding(name); if (alias != XML_CHAR_ENCODING_ERROR) { const char* canon; canon = xmlGetCharEncodingName(alias); --- 1605,1611 ---- /* * Fallback using the canonical names */ ! alias = xmlParseCharEncoding(norig); if (alias != XML_CHAR_ENCODING_ERROR) { const char* canon; canon = xmlGetCharEncodingName(alias); Index: encoding.h =================================================================== RCS file: /sources/public/XML/encoding.h,v retrieving revision 1.21 diff -p -r1.21 encoding.h *** encoding.h 2000/07/12 17:52:40 1.21 --- encoding.h 2000/08/23 13:21:52 *************** struct _xmlCharEncodingHandler { *** 133,147 **** #endif /* LIBXML_ICONV_ENABLED */ }; void xmlInitCharEncodingHandlers (void); void xmlCleanupCharEncodingHandlers (void); void xmlRegisterCharEncodingHandler (xmlCharEncodingHandlerPtr handler); ! xmlCharEncoding xmlDetectCharEncoding (const unsigned char* in, int len); ! xmlCharEncoding xmlParseCharEncoding (const char* name); ! const char* xmlGetCharEncodingName (xmlCharEncoding enc); ! xmlCharEncodingHandlerPtr xmlGetCharEncodingHandler(xmlCharEncoding enc); ! xmlCharEncodingHandlerPtr xmlFindCharEncodingHandler(const char *name); int xmlCheckUTF8 (const unsigned char *utf); int xmlCharEncOutFunc (xmlCharEncodingHandler *handler, --- 133,171 ---- #endif /* LIBXML_ICONV_ENABLED */ }; + /* + * Interfaces for encoding handlers + */ void xmlInitCharEncodingHandlers (void); void xmlCleanupCharEncodingHandlers (void); void xmlRegisterCharEncodingHandler (xmlCharEncodingHandlerPtr handler); ! xmlCharEncodingHandlerPtr ! xmlGetCharEncodingHandler (xmlCharEncoding enc); ! xmlCharEncodingHandlerPtr ! xmlFindCharEncodingHandler (const char *name); ! ! ! /* ! * Interfaces for encoding names and aliases ! */ ! int xmlAddEncodingAlias (const char *name, ! const char *alias); ! int xmlDelEncodingAlias (const char *alias); ! const char * ! xmlGetEncodingAlias (const char *alias); ! void xmlCleanupEncodingAliases (void); ! xmlCharEncoding ! xmlParseCharEncoding (const char* name); ! const char* ! xmlGetCharEncodingName (xmlCharEncoding enc); ! ! /* ! * Interfaces directly used by the parsers. ! */ ! xmlCharEncoding ! xmlDetectCharEncoding (const unsigned char* in, int len); ! int xmlCheckUTF8 (const unsigned char *utf); int xmlCharEncOutFunc (xmlCharEncodingHandler *handler,