Return to fetchXMLname.c CVS log | Up to [Public] / Amaya / amaya |
1.1 cvs 1: /* 2: * 1.38 cvs 3: * (c) COPYRIGHT MIT and INRIA, 1996-2001 1.1 cvs 4: * Please first read the full copyright statement in file COPYRIGHT. 5: * 6: */ 7: 8: /* 9: * 10: * fetchXMLname 11: * 12: * Author: I. Vatton 13: * 14: */ 15: 16: #define THOT_EXPORT extern 17: #include "amaya.h" 18: #include "parser.h" 1.24 cvs 19: #include "HTMLnames.h" 20: #include "MathMLnames.h" 21: #include "GraphMLnames.h" 22: #include "XLinknames.h" 23: 1.35 cvs 24: /* define some pointers to let other parser functions access the local table */ 1.24 cvs 25: int HTML_ENTRIES = (sizeof(XHTMLElemMappingTable) / sizeof(ElemMapping)); 26: ElemMapping *pHTMLGIMapping = XHTMLElemMappingTable; 27: AttributeMapping *pHTMLAttributeMapping = XHTMLAttributeMappingTable; 1.14 cvs 28: 1.35 cvs 29: XmlEntity *pXhtmlEntityTable = XhtmlEntityTable; 30: XmlEntity *pMathEntityTable = MathEntityTable; 1.1 cvs 31: 32: #include "fetchXMLname_f.h" 33: 1.39 ! cvs 34: /* Global variables used by the entity mapping */ ! 35: static int XHTMLSup = 0; ! 36: static int MathSup = 0; ! 37: 1.1 cvs 38: /*---------------------------------------------------------------------- 1.14 cvs 39: GetXHTMLSSchema returns the XHTML Thot schema for document doc. 40: ----------------------------------------------------------------------*/ 41: SSchema GetXHTMLSSchema (Document doc) 42: 43: { 44: SSchema XHTMLSSchema; 45: 46: XHTMLSSchema = TtaGetSSchema (TEXT("HTML"), doc); 47: if (XHTMLSSchema == NULL) 1.17 cvs 48: XHTMLSSchema = TtaNewNature(doc, TtaGetDocumentSSchema(doc), 1.14 cvs 49: TEXT("HTML"), TEXT("HTMLP")); 50: return (XHTMLSSchema); 51: } 52: 53: /*---------------------------------------------------------------------- 1.1 cvs 54: GetMathMLSSchema returns the MathML Thot schema for document doc. 55: ----------------------------------------------------------------------*/ 56: SSchema GetMathMLSSchema (Document doc) 57: 58: { 59: SSchema MathMLSSchema; 60: 1.13 cvs 61: MathMLSSchema = TtaGetSSchema (TEXT("MathML"), doc); 62: if (MathMLSSchema == NULL) 1.17 cvs 63: MathMLSSchema = TtaNewNature(doc, 64: TtaGetDocumentSSchema(doc), TEXT("MathML"), 1.13 cvs 65: TEXT("MathMLP")); 66: return (MathMLSSchema); 1.1 cvs 67: } 68: 69: /*---------------------------------------------------------------------- 70: GetGraphMLSSchema returns the GraphML Thot schema for document doc. 71: ----------------------------------------------------------------------*/ 72: SSchema GetGraphMLSSchema (Document doc) 73: 74: { 75: SSchema GraphMLSSchema; 76: 1.8 cvs 77: GraphMLSSchema = TtaGetSSchema (TEXT("GraphML"), doc); 1.1 cvs 78: if (GraphMLSSchema == NULL) 1.17 cvs 79: GraphMLSSchema = TtaNewNature(doc, 80: TtaGetDocumentSSchema(doc), TEXT("GraphML"), 1.13 cvs 81: TEXT("GraphMLP")); 1.1 cvs 82: return (GraphMLSSchema); 83: } 84: 85: /*---------------------------------------------------------------------- 1.13 cvs 86: GetXLinkSSchema returns the XLink Thot schema for document doc. 87: ----------------------------------------------------------------------*/ 88: SSchema GetXLinkSSchema (Document doc) 89: 90: { 91: SSchema XLinkSSchema; 92: 93: XLinkSSchema = TtaGetSSchema (TEXT("XLink"), doc); 94: if (XLinkSSchema == NULL) 1.17 cvs 95: XLinkSSchema = TtaNewNature(doc, TtaGetDocumentSSchema(doc), TEXT("XLink"), 1.13 cvs 96: TEXT("XLinkP")); 97: return (XLinkSSchema); 98: } 99: 100: /*---------------------------------------------------------------------- 101: GetXMLSSchema returns the XML Thot schema for document doc. 1.1 cvs 102: ----------------------------------------------------------------------*/ 103: SSchema GetXMLSSchema (int XMLtype, Document doc) 1.38 cvs 104: 1.1 cvs 105: { 1.14 cvs 106: if (XMLtype == XHTML_TYPE) 107: return GetXHTMLSSchema (doc); 108: else if (XMLtype == MATH_TYPE) 1.13 cvs 109: return GetMathMLSSchema (doc); 110: else if (XMLtype == GRAPH_TYPE) 111: return GetGraphMLSSchema (doc); 112: else if (XMLtype == XLINK_TYPE) 1.15 cvs 113: return GetXLinkSSchema (doc); 1.13 cvs 114: else 115: return NULL; 1.1 cvs 116: } 117: 118: 119: /*---------------------------------------------------------------------- 1.22 cvs 120: MapXMLElementType 121: Generic function which searchs in the Element Mapping table, selected 122: by the parameter XMLtype, the entry XMLname and returns the corresponding 123: Thot element type. 1.1 cvs 124: Returns: 1.22 cvs 125: - ElTypeNum and ElSSchema into elType ElTypeNum = 0 if not found. 1.1 cvs 126: - content 127: ----------------------------------------------------------------------*/ 1.32 cvs 128: void MapXMLElementType (int XMLtype, 129: STRING XMLname, 130: ElementType *elType, 131: STRING *mappedName, 132: CHAR_T *content, 133: ThotBool *highEnoughLevel, 134: Document doc) 1.1 cvs 135: { 136: int i; 137: ElemMapping *ptr; 138: 1.32 cvs 139: /* Initialize variables */ 140: *mappedName = NULL; 141: *highEnoughLevel = TRUE; 142: elType->ElTypeNum = 0; 143: 1.1 cvs 144: /* Select the right table */ 1.14 cvs 145: if (XMLtype == XHTML_TYPE) 146: ptr = XHTMLElemMappingTable; 147: else if (XMLtype == MATH_TYPE) 1.31 cvs 148: { 149: if (ParsingLevel[doc] == L_Basic && DocumentTypes[doc] == docHTML) 1.32 cvs 150: { 151: /* Maths are not allowed in this document */ 152: ptr = NULL; 153: *highEnoughLevel = FALSE; 154: } 1.31 cvs 155: else 156: ptr = MathMLElemMappingTable; 157: } 1.1 cvs 158: else if (XMLtype == GRAPH_TYPE) 1.31 cvs 159: { 160: if (ParsingLevel[doc] == L_Basic && DocumentTypes[doc] == docHTML) 1.32 cvs 161: { 162: /* Graphics are not allowed in this document */ 163: ptr = NULL; 164: *highEnoughLevel = FALSE; 165: } 1.31 cvs 166: else 167: ptr = GraphMLElemMappingTable; 168: } 1.1 cvs 169: else 170: ptr = NULL; 1.32 cvs 171: 1.1 cvs 172: if (ptr != NULL) 173: { 174: /* search in the ElemMappingTable */ 175: i = 0; 176: /* look for the first concerned entry in the table */ 1.22 cvs 177: while (ptr[i].XMLname[0] < XMLname[0] && ptr[i].XMLname[0] != WC_EOS) 1.32 cvs 178: i++; 1.1 cvs 179: /* look at all entries starting with the right character */ 180: do 1.32 cvs 181: if (ustrcmp (ptr[i].XMLname, XMLname)) 182: /* it's not the tag */ 1.1 cvs 183: i++; 1.37 cvs 184: else if (ParsingLevel[doc] != L_Other && 185: ptr[i].Level > ParsingLevel[doc]) 1.32 cvs 186: { 187: /* this tag is not valid for the current parsing level */ 188: *highEnoughLevel = FALSE; 189: i++; 190: } 1.1 cvs 191: else 192: { 193: elType->ElTypeNum = ptr[i].ThotType; 194: if (elType->ElSSchema == NULL) 195: elType->ElSSchema = GetXMLSSchema (XMLtype, doc); 196: *mappedName = ptr[i].XMLname; 197: *content = ptr[i].XMLcontents; 198: } 199: while (elType->ElTypeNum <= 0 && ptr[i].XMLname[0] == XMLname[0]); 200: } 201: } 202: 203: 204: /*---------------------------------------------------------------------- 205: GetXMLElementName 1.22 cvs 206: Generic function which searchs in the mapping table the XML name for 207: a given Thot type. 1.1 cvs 208: ----------------------------------------------------------------------*/ 1.25 cvs 209: CHAR_T* GetXMLElementName (ElementType elType, Document doc) 1.1 cvs 210: { 1.27 cvs 211: ElemMapping *ptr; 212: STRING name; 213: int i; 214: ThotBool invalid = FALSE; 215: 216: if (elType.ElTypeNum > 0) 217: { 218: i = 0; 219: /* Select the table which matches with the element schema */ 220: name = TtaGetSSchemaName (elType.ElSSchema); 221: if (ustrcmp (TEXT("MathML"), name) == 0) 222: ptr = MathMLElemMappingTable; 223: else if (ustrcmp (TEXT("GraphML"), name) == 0) 224: ptr = GraphMLElemMappingTable; 225: else 226: ptr = XHTMLElemMappingTable; 227: 228: if (ptr) 229: do 230: { 231: if (ptr[i].ThotType == elType.ElTypeNum) 232: { 1.37 cvs 233: if (doc == 0 || 234: ParsingLevel[doc] == L_Other || 235: ptr[i].Level <= ParsingLevel[doc]) 1.27 cvs 236: return ptr[i].XMLname; 237: else 238: invalid = TRUE; 239: } 240: i++; 241: } 242: while (ptr[i].XMLname[0] != WC_EOS); 243: } 244: if (invalid) 245: return TEXT(""); 246: else 247: return TEXT("???"); 1.22 cvs 248: } 1.25 cvs 249: 250: 1.29 cvs 251: 252: /*---------------------------------------------------------------------- 1.30 cvs 253: IsXMLElementInline 1.29 cvs 254: Generic function which searchs in the mapping table if a given 255: Thot type is an inline character or not 256: ----------------------------------------------------------------------*/ 1.34 cvs 257: ThotBool IsXMLElementInline (ElementType elType) 1.38 cvs 258: 1.29 cvs 259: { 1.34 cvs 260: int i; 261: ThotBool ret = FALSE; 262: STRING name; 263: ElemMapping *ptr; 1.29 cvs 264: 265: if (elType.ElTypeNum > 0) 266: { 267: i = 0; 268: /* Select the table which matches with the element schema */ 269: name = TtaGetSSchemaName (elType.ElSSchema); 270: if (ustrcmp (TEXT("MathML"), name) == 0) 271: ptr = MathMLElemMappingTable; 272: else if (ustrcmp (TEXT("GraphML"), name) == 0) 273: ptr = GraphMLElemMappingTable; 274: else 275: ptr = XHTMLElemMappingTable; 276: 277: if (ptr) 278: { 279: while (ptr[i].XMLname[0] != WC_EOS && 280: ptr[i].ThotType != elType.ElTypeNum) 281: i++; 282: if (ptr[i].ThotType == elType.ElTypeNum) 283: ret = ptr[i].Inline; 284: } 285: } 286: return ret; 287: } 288: 1.22 cvs 289: /*---------------------------------------------------------------------- 1.24 cvs 290: MapXMLAttribute 1.22 cvs 291: Generic function which searchs in the Attribute Mapping Table (table) 292: the entry attrName associated to the element elementName. 1.24 cvs 293: Returns the corresponding entry or -1. 1.22 cvs 294: ----------------------------------------------------------------------*/ 1.33 cvs 295: int MapXMLAttribute (int XMLtype, CHAR_T *attrName, 296: CHAR_T *elementName, ThotBool *highEnoughLevel, 297: Document doc, int *thotType) 1.22 cvs 298: { 1.24 cvs 299: int i; 300: AttributeMapping *ptr; 301: 1.33 cvs 302: /* Initialization */ 303: *highEnoughLevel = TRUE; 304: i = 1; 305: *thotType = 0; 306: 1.24 cvs 307: /* Select the right table */ 308: if (XMLtype == XHTML_TYPE) 309: ptr = XHTMLAttributeMappingTable; 310: else if (XMLtype == MATH_TYPE) 311: ptr = MathMLAttributeMappingTable; 312: else if (XMLtype == GRAPH_TYPE) 313: ptr = GraphMLAttributeMappingTable; 314: else if (XMLtype == XLINK_TYPE) 315: ptr = XLinkAttributeMappingTable; 316: else 317: ptr = NULL; 318: 319: if (ptr == NULL) 320: return -1; 1.22 cvs 321: 322: /* look for the first concerned entry in the table */ 1.33 cvs 323: while (ptr[i].XMLattribute[0] < attrName[0] && 324: ptr[i].XMLattribute[0] != WC_EOS) 1.22 cvs 325: i++; 1.33 cvs 326: 1.24 cvs 327: while (ptr[i].XMLattribute[0] == attrName[0]) 1.22 cvs 328: { 1.33 cvs 329: if (ustrcmp (ptr[i].XMLattribute, attrName) || 330: (ptr[i].XMLelement[0] != WC_EOS && 331: ustrcmp (ptr[i].XMLelement, elementName))) 1.22 cvs 332: i++; 1.33 cvs 333: else if (ptr[i].Level > ParsingLevel[doc]) 334: { 335: *highEnoughLevel = FALSE; 336: i++; 337: } 1.22 cvs 338: else 1.24 cvs 339: { 340: *thotType = ptr[i].ThotAttribute; 341: return (i); 342: } 1.22 cvs 343: } 1.24 cvs 344: return (-1); 1.25 cvs 345: } 346: 347: 348: /*---------------------------------------------------------------------- 1.37 cvs 349: GetXMLAttributeName 1.25 cvs 350: Generic function which searchs in the mapping table the XML name for 351: a given Thot type. 352: ----------------------------------------------------------------------*/ 1.38 cvs 353: CHAR_T* GetXMLAttributeName (AttributeType attrType, 354: ElementType elType, 355: Document doc) 1.25 cvs 356: { 357: AttributeMapping *ptr; 1.28 cvs 358: STRING name, tag; 1.25 cvs 359: int i; 1.27 cvs 360: ThotBool invalid = FALSE; 1.25 cvs 361: 1.27 cvs 362: if (attrType.AttrTypeNum > 0) 363: { 1.28 cvs 364: /* get the specific element tag */ 365: if (elType.ElTypeNum > 0) 366: tag = GetXMLElementName (elType, doc); 367: else 368: tag = TEXT(""); 369: 1.27 cvs 370: i = 0; 371: /* Select the table which matches with the element schema */ 372: name = TtaGetSSchemaName (attrType.AttrSSchema); 373: if (ustrcmp (TEXT("MathML"), name) == 0) 374: ptr = MathMLAttributeMappingTable; 375: else if (ustrcmp (TEXT("GraphML"), name) == 0) 376: ptr = GraphMLAttributeMappingTable; 377: else if (ustrcmp (TEXT("XLink"), name) == 0) 378: ptr = XLinkAttributeMappingTable; 379: else 380: ptr = XHTMLAttributeMappingTable; 381: 382: if (ptr) 383: do 384: { 1.28 cvs 385: if (ptr[i].ThotAttribute == attrType.AttrTypeNum && 386: (ptr[i].XMLelement[0] == WC_EOS || 387: !ustrcmp (ptr[i].XMLelement, tag))) 1.25 cvs 388: { 1.26 cvs 389: if (doc == 0 || ptr[i].Level <= ParsingLevel[doc]) 1.25 cvs 390: return ptr[i].XMLattribute; 391: else 1.27 cvs 392: invalid = TRUE; 1.25 cvs 393: } 394: i++; 1.27 cvs 395: } 396: while (ptr[i].XMLattribute[0] != WC_EOS); 397: } 398: if (invalid) 399: return TEXT(""); 400: else 401: return TEXT("???"); 1.36 cvs 402: } 403: 404: /*---------------------------------------------------------------------- 405: MapXMLEntity 406: Generic function which searchs in the Entity Mapping Table (table) 407: the entry entityName and give the corresponding decimal value. 408: Returns FALSE if entityName is not found. 409: ----------------------------------------------------------------------*/ 410: ThotBool MapXMLEntity (int XMLtype, STRING entityName, int *entityValue) 1.38 cvs 411: 1.36 cvs 412: { 413: XmlEntity *ptr; 414: ThotBool found; 1.38 cvs 415: int inf, sup, med, rescomp; 1.36 cvs 416: 1.38 cvs 417: /* Initialization */ 1.36 cvs 418: found = FALSE; 419: 420: /* Select the right table */ 421: if (XMLtype == XHTML_TYPE) 1.39 ! cvs 422: { ! 423: ptr = XhtmlEntityTable; ! 424: if (XHTMLSup == 0) ! 425: for (XHTMLSup = 0; ptr[XHTMLSup].charCode > 0; XHTMLSup++); ! 426: sup = XHTMLSup; ! 427: } 1.36 cvs 428: else if (XMLtype == MATH_TYPE) 1.39 ! cvs 429: { ! 430: ptr = MathEntityTable; ! 431: if (MathSup == 0) ! 432: for (MathSup = 0; ptr[MathSup].charCode > 0; MathSup++); ! 433: sup = MathSup; ! 434: } 1.36 cvs 435: else 436: ptr = NULL; 437: 438: if (ptr == NULL) 1.38 cvs 439: return found; 440: 441: inf = 0; 442: while (sup >= inf && !found) 443: /* Dichotomic research */ 1.36 cvs 444: { 1.38 cvs 445: med = (sup + inf) / 2; 446: rescomp = ustrcmp (ptr[med].charName, entityName); 447: if (rescomp == 0) 448: { 449: /* entity found */ 450: *entityValue = ptr[med].charCode; 451: found = TRUE; 452: } 453: else 454: { 455: if (rescomp > 0) 456: sup = med - 1; 457: else 458: inf = med + 1; 459: } 1.36 cvs 460: } 1.38 cvs 461: return found; 462: } 1.39 ! cvs 463: ! 464: /*---------------------------------------------------------------------- ! 465: MapEntityByCode ! 466: Generic function which searchs in the Entity Mapping Table (table) ! 467: the entry with code entityValue and give the corresponding name. ! 468: Returns FALSE if entityValue is not found. ! 469: ----------------------------------------------------------------------*/ ! 470: CHAR_T* MapEntityByCode (int XMLtype, int entityValue) ! 471: ! 472: { ! 473: XmlEntity *ptr; ! 474: ThotBool found; ! 475: int i; ! 476: ! 477: /* Select the right table */ ! 478: if (XMLtype == XHTML_TYPE) ! 479: ptr = XhtmlEntityTable; ! 480: else if (XMLtype == MATH_TYPE) ! 481: ptr = MathEntityTable; ! 482: else ! 483: ptr = NULL; ! 484: ! 485: if (ptr == NULL) ! 486: return ptr; ! 487: ! 488: /* look for the first concerned entry in the table */ ! 489: found = FALSE; ! 490: for (i = 0; ptr[i].charCode >= 0 && !found; i++) ! 491: found = (ptr[i].charCode == entityValue); ! 492: ! 493: if (found) ! 494: { ! 495: /* entity value found */ ! 496: i--; ! 497: return ptr[i].charName; ! 498: } ! 499: else ! 500: return NULL; ! 501: }