Many hyperlinks are disabled.
Use anonymous login
to enable hyperlinks.
Changes In Branch wip Excluding Merge-Ins
This is equivalent to a diff from 4abf418fab to b3b0b78e14
|
2024-10-09
| ||
| 22:54 | First round of build tests on a couple of platforms and OS. check-in: d4df8c0072 user: rolf tags: trunk | |
| 22:47 | Simplest (*)printf d modifier limbo I could find. Closed-Leaf check-in: b3b0b78e14 user: rolf tags: wip | |
| 00:40 | More casts. check-in: cb3dba8a81 user: rolf tags: wip | |
|
2024-10-03
| ||
| 14:33 | wip check-in: 5c33cee20e user: rolf tags: wip | |
|
2024-10-02
| ||
| 00:12 | Merge trunk. check-in: e1154f061d user: rolf tags: prepare-release | |
|
2024-10-01
| ||
| 23:16 | Adapted test to the changed error message. check-in: 4abf418fab user: rolf tags: trunk | |
| 22:58 | Attempt to clean up the fall out of the recent type changes. check-in: 908f9bb47d user: rolf tags: trunk | |
Changes to configure.
615 615 # include <stdint.h> 616 616 #endif 617 617 #ifdef HAVE_UNISTD_H 618 618 # include <unistd.h> 619 619 #endif" 620 620 621 621 ac_subst_vars='LTLIBOBJS 622 -PKG_STUB_LIB_PATH 623 -PKG_BUILD_STUB_LIB_PATH 624 -PKG_STUB_LIB_SPEC 625 -PKG_BUILD_STUB_LIB_SPEC 622 +PATCHLEVEL 623 +MINOR_VERSION 624 +MAJOR_VERSION 625 +tdom_STUB_LIB_PATH 626 +tdom_BUILD_STUB_LIB_PATH 627 +tdom_STUB_LIB_SPEC 628 +tdom_BUILD_STUB_LIB_SPEC 629 +tdom_LIB_SPEC 630 +tdom_BUILD_LIB_SPEC 626 631 TDOMSHELL 627 632 TCLSH_PROG 628 633 VC_MANIFEST_EMBED_EXE 629 634 VC_MANIFEST_EMBED_DLL 630 635 RANLIB_STUB 631 636 PKG_STUB_LIB_FILE 632 637 MAKE_STUB_LIB ................................................................................ 9076 9081 9077 9082 9078 9083 TDOMSHELL=tcldomsh 9079 9084 9080 9085 9081 9086 9082 9087 #-------------------------------------------------------------------- 9083 - # These are for ${PACKAGE_NAME}Config.sh 9088 + # These are for tdomConfig.sh 9084 9089 #-------------------------------------------------------------------- 9085 9090 9086 9091 # pkglibdir must be a fully qualified path and (not ${exec_prefix}/lib) 9087 - eval pkglibdir="${libdir}/${PACKAGE_NAME}${PACKAGE_VERSION}" 9092 + eval pkglibdir="${libdir}/tdom${PACKAGE_VERSION}" 9088 9093 if test "${TCL_LIB_VERSIONS_OK}" = "ok"; then 9089 - eval PKG_STUB_LIB_FLAG="-l${PACKAGE_NAME}stub${PACKAGE_VERSION}" 9094 + eval tdom_LIB_FLAG="-ltdom${PACKAGE_VERSION}" 9095 + eval tdom_STUB_LIB_FLAG="-ltdomstub${PACKAGE_VERSION}" 9090 9096 else 9091 - eval PKG_STUB_LIB_FLAG="-l${PACKAGE_NAME}stub`echo ${PACKAGE_VERSION} | tr -d .`" 9097 + eval tdom_LIB_FLAG="-ltdom`echo ${PACKAGE_VERSION} | tr -d .`" 9098 + eval tdom_STUB_LIB_FLAG="-ltdomstub`echo ${PACKAGE_VERSION} | tr -d .`" 9099 + fi 9100 + if test "${TCL_MAJOR_VERSION}" -gt 8 -a x"${with_tcl8}" = x; then 9101 + eval tdom_STUB_LIB_FLAG="-ltdomstub" 9092 9102 fi 9093 - PKG_BUILD_STUB_LIB_SPEC="-L`pwd` ${PKG_STUB_LIB_FLAG}" 9094 - PKG_STUB_LIB_SPEC="-L${pkglibdir} ${PKG_STUB_LIB_FLAG}" 9095 - PKG_BUILD_STUB_LIB_PATH="`pwd`/${PKG_STUB_LIB_FILE}" 9096 - PKG_STUB_LIB_PATH="${pkglibdir}/${PKG_STUB_LIB_FILE}" 9103 + 9104 + tdom_BUILD_LIB_SPEC="-L`$CYGPATH $(pwd)` ${tdom_LIB_FLAG}" 9105 + tdom_LIB_SPEC="-L`$CYGPATH ${pkglibdir}` ${tdom_LIB_FLAG}" 9106 + tdom_BUILD_STUB_LIB_SPEC="-L`$CYGPATH $(pwd)` ${tdom_STUB_LIB_FLAG}" 9107 + tdom_STUB_LIB_SPEC="-L`$CYGPATH ${pkglibdir}` ${tdom_STUB_LIB_FLAG}" 9108 + tdom_BUILD_STUB_LIB_PATH="`$CYGPATH $(pwd)`/${PKG_STUB_LIB_FILE}" 9109 + tdom_STUB_LIB_PATH="`$CYGPATH ${pkglibdir}`/${PKG_STUB_LIB_FILE}" 9110 + 9111 + 9112 + 9113 + 9114 + 9115 + 9097 9116 9098 9117 9099 9118 9100 9119 9101 9120 9102 9121 9103 9122
Changes to configure.ac.
249 249 TDOM_ENABLE_TDOMALLOC 250 250 TDOM_ENABLE_LESS_NS 251 251 TDOM_ENABLE_SCHEMA 252 252 253 253 TDOMSHELL=tcldomsh 254 254 AC_SUBST(TDOMSHELL) 255 255 256 -TDOM_EXPORT_CONFIG 256 +TEA_EXPORT_CONFIG([tdom]) 257 257 258 258 #-------------------------------------------------------------------- 259 259 # Finally, substitute all of the various values into the Makefile. 260 260 # You may alternatively have a special pkgIndex.tcl.in or other files 261 261 # which require substituting the AC variables in. Include these here. 262 262 #-------------------------------------------------------------------- 263 263 264 264 AC_CONFIG_FILES([Makefile pkgIndex.tcl tdomConfig.sh]) 265 265 AC_OUTPUT
Changes to generic/dom.c.
459 459 break; 460 460 } 461 461 p += clen; 462 462 } 463 463 if (!*changed) { 464 464 return; 465 465 } 466 - Tcl_DStringAppend (clearedstr, str, p-str); 466 + Tcl_DStringAppend (clearedstr, str, (domLength)(p-str)); 467 467 if (repllen) { 468 468 Tcl_DStringAppend (clearedstr, replacement, repllen); 469 469 } 470 470 if (clen) { 471 471 p += clen; 472 472 } else { 473 473 /* If it isn't a UTF-8 encoded character what is it? And how ................................................................................ 474 474 * many of whatever it is? */ 475 475 p++; 476 476 } 477 477 s = p; 478 478 while (*p) { 479 479 clen = UTF8_CHAR_LEN(*p); 480 480 if (!clen || !UTF8_XMLCHAR((unsigned const char*)p,clen)) { 481 - Tcl_DStringAppend (clearedstr, s, p-s); 481 + Tcl_DStringAppend (clearedstr, s, (domLength)(p-s)); 482 482 if (repllen) { 483 483 Tcl_DStringAppend (clearedstr, replacement, repllen); 484 484 } 485 485 if (clen) { 486 486 p += clen; 487 487 } else { 488 488 p++; 489 489 } 490 490 s = p; 491 491 } else { 492 492 p += clen; 493 493 } 494 494 } 495 - Tcl_DStringAppend (clearedstr, s, p-s); 495 + Tcl_DStringAppend (clearedstr, s, (domLength)(p-s)); 496 496 } 497 497 498 498 /*--------------------------------------------------------------------------- 499 499 | domIsBMPChar 500 500 | 501 501 \--------------------------------------------------------------------------*/ 502 502 int ................................................................................ 525 525 const char *str 526 526 ) 527 527 { 528 528 const char *p; 529 529 domLength len, i = 0; 530 530 531 531 p = str; 532 - len = strlen (str); 532 + len = (domLength)strlen (str); 533 533 while (i < len) { 534 534 if (*p == '-') { 535 535 if (i == len - 1) return 0; 536 536 p++; i++; 537 537 if (*p == '-') return 0; 538 538 } 539 539 p++; i++; ................................................................................ 550 550 const char *str 551 551 ) 552 552 { 553 553 const char *p; 554 554 domLength len, i = 0; 555 555 556 556 p = str; 557 - len = strlen (str); 557 + len = (domLength)strlen (str); 558 558 while (i < len - 2) { 559 559 if ( *p == ']' 560 560 && p[1] == ']' 561 561 && p[2] == '>') return 0; 562 562 p++; i++; 563 563 } 564 564 return domIsChar (str); ................................................................................ 573 573 const char *str 574 574 ) 575 575 { 576 576 const char *p; 577 577 domLength len, i = 0; 578 578 579 579 p = str; 580 - len = strlen (str); 580 + len = (domLength)strlen (str); 581 581 while (i < len - 1) { 582 582 if (*p == '?' && p[1] == '>') return 0; 583 583 p++; i++; 584 584 } 585 585 return domIsChar (str); 586 586 } 587 587 ................................................................................ 1369 1369 memset(attrnode, 0, sizeof(domAttrNode)); 1370 1370 attrnode->nodeType = ATTRIBUTE_NODE; 1371 1371 attrnode->nodeFlags = IS_NS_NODE; 1372 1372 attrnode->namespace = ns->index; 1373 1373 attrnode->nodeName = (char *)&(h->key); 1374 1374 attrnode->parentNode = node; 1375 1375 len = strlen(atPtr[1]); 1376 - attrnode->valueLength = len; 1376 + attrnode->valueLength = (domLength)len; 1377 1377 attrnode->nodeValue = (char*)MALLOC(len+1); 1378 1378 strcpy(attrnode->nodeValue, atPtr[1]); 1379 1379 if (node->firstAttr) { 1380 1380 lastAttr->nextSibling = attrnode; 1381 1381 } else { 1382 1382 node->firstAttr = attrnode; 1383 1383 } ................................................................................ 1471 1471 attrnode->nodeType = ATTRIBUTE_NODE; 1472 1472 if (atPtr == idAttPtr) { 1473 1473 attrnode->nodeFlags |= IS_ID_ATTRIBUTE; 1474 1474 } 1475 1475 attrnode->nodeName = (char *)&(h->key); 1476 1476 attrnode->parentNode = node; 1477 1477 len = strlen(atPtr[1]); 1478 - attrnode->valueLength = len; 1478 + attrnode->valueLength = (domLength)len; 1479 1479 attrnode->nodeValue = (char*)MALLOC(len+1); 1480 1480 strcpy(attrnode->nodeValue, (char *)atPtr[1]); 1481 1481 1482 1482 if (node->firstAttr) { 1483 1483 lastAttr->nextSibling = attrnode; 1484 1484 } else { 1485 1485 node->firstAttr = attrnode; ................................................................................ 1598 1598 domReadInfo *info = userData; 1599 1599 1600 1600 Tcl_DStringAppend (info->cdata, s, len); 1601 1601 if (info->storeLineColumn) { 1602 1602 /* This works because the result of XML_GetCurrentLineNumber() 1603 1603 * is always at least 1 */ 1604 1604 if (!info->textStartLine) { 1605 - info->textStartLine = XML_GetCurrentLineNumber (info->parser); 1606 - info->textStartColumn = XML_GetCurrentColumnNumber (info->parser); 1607 - info->textStartByteIndex = XML_GetCurrentByteIndex (info->parser); 1605 + info->textStartLine = (domLength)XML_GetCurrentLineNumber (info->parser); 1606 + info->textStartColumn = (domLength)XML_GetCurrentColumnNumber (info->parser); 1607 + info->textStartByteIndex = (domLength)XML_GetCurrentByteIndex (info->parser); 1608 1608 } 1609 1609 } 1610 1610 1611 1611 return; 1612 1612 1613 1613 } 1614 1614 ................................................................................ 1623 1623 { 1624 1624 domReadInfo *info = userData; 1625 1625 1626 1626 DispatchPCDATA (info); 1627 1627 info->cdataSection = 1; 1628 1628 if (info->storeLineColumn) { 1629 1629 if (!info->textStartLine) { 1630 - info->textStartLine = XML_GetCurrentLineNumber (info->parser); 1631 - info->textStartColumn = XML_GetCurrentColumnNumber (info->parser); 1632 - info->textStartByteIndex = XML_GetCurrentByteIndex (info->parser); 1630 + info->textStartLine = (domLength)XML_GetCurrentLineNumber (info->parser); 1631 + info->textStartColumn = (domLength)XML_GetCurrentColumnNumber (info->parser); 1632 + info->textStartByteIndex = (domLength)XML_GetCurrentByteIndex (info->parser); 1633 1633 } 1634 1634 } 1635 1635 } 1636 1636 1637 1637 /*--------------------------------------------------------------------------- 1638 1638 | endCDATA 1639 1639 | ................................................................................ 1813 1813 + sizeof(domLineColumn)); 1814 1814 } else { 1815 1815 node = (domTextNode*) domAlloc(sizeof(domTextNode)); 1816 1816 } 1817 1817 memset(node, 0, sizeof(domTextNode)); 1818 1818 node->nodeType = COMMENT_NODE; 1819 1819 node->nodeNumber = NODE_NO(info->document); 1820 - node->valueLength = len; 1820 + node->valueLength = (domLength)len; 1821 1821 node->nodeValue = (char*)MALLOC(len); 1822 1822 memmove(node->nodeValue, s, len); 1823 1823 1824 1824 node->ownerDocument = info->document; 1825 1825 node->parentNode = parentNode; 1826 1826 if (parentNode == NULL) { 1827 1827 if (info->document->rootNode->lastChild) { ................................................................................ 1907 1907 (char*) node, 1908 1908 &hnew); 1909 1909 Tcl_SetHashValue (h, tdomstrdup (XML_GetBase (info->parser))); 1910 1910 node->nodeFlags |= HAS_BASEURI; 1911 1911 } 1912 1912 1913 1913 len = strlen(target); 1914 - node->targetLength = len; 1914 + node->targetLength = (domLength)len; 1915 1915 node->targetValue = (char*)MALLOC(len); 1916 1916 memmove(node->targetValue, target, len); 1917 1917 1918 1918 len = strlen(data); 1919 - node->dataLength = len; 1919 + node->dataLength = (domLength)len; 1920 1920 node->dataValue = (char*)MALLOC(len); 1921 1921 memmove(node->dataValue, data, len); 1922 1922 1923 1923 node->ownerDocument = info->document; 1924 1924 node->parentNode = parentNode; 1925 1925 if (parentNode == NULL) { 1926 1926 if (info->document->rootNode->lastChild) { ................................................................................ 2023 2023 * Take a copy of the callback script so that arguments may be appended. 2024 2024 */ 2025 2025 cmdPtr = Tcl_NewStringObj(info->document->extResolver, -1); 2026 2026 Tcl_IncrRefCount(cmdPtr); 2027 2027 2028 2028 if (base) { 2029 2029 Tcl_ListObjAppendElement(info->interp, cmdPtr, 2030 - Tcl_NewStringObj(base, strlen(base))); 2030 + Tcl_NewStringObj(base, (domLength)strlen(base))); 2031 2031 } else { 2032 2032 Tcl_ListObjAppendElement(info->interp, cmdPtr, 2033 2033 Tcl_NewObj()); 2034 2034 } 2035 2035 2036 2036 /* For a document with doctype declaration, the systemId is always 2037 2037 != NULL. But if the document doesn't have a doctype declaration 2038 2038 and the user uses -useForeignDTD 1, the externalEntityRefHandler 2039 2039 will be called with a systemId (and publicId and openEntityNames) 2040 2040 == NULL. */ 2041 2041 if (systemId) { 2042 2042 Tcl_ListObjAppendElement(info->interp, cmdPtr, 2043 - Tcl_NewStringObj(systemId, strlen(systemId))); 2043 + Tcl_NewStringObj(systemId, (domLength)strlen(systemId))); 2044 2044 } else { 2045 2045 Tcl_ListObjAppendElement(info->interp, cmdPtr, 2046 2046 Tcl_NewObj()); 2047 2047 } 2048 2048 2049 2049 if (publicId) { 2050 2050 Tcl_ListObjAppendElement(info->interp, cmdPtr, 2051 - Tcl_NewStringObj(publicId, strlen(publicId))); 2051 + Tcl_NewStringObj(publicId, (domLength)strlen(publicId))); 2052 2052 } else { 2053 2053 Tcl_ListObjAppendElement(info->interp, cmdPtr, 2054 2054 Tcl_NewObj()); 2055 2055 } 2056 2056 2057 2057 2058 2058 result = Tcl_EvalObjEx (info->interp, cmdPtr, ................................................................................ 2145 2145 tcldom_reportErrorLocation ( 2146 2146 info->interp, 20, 40, XML_GetCurrentLineNumber(extparser), 2147 2147 XML_GetCurrentColumnNumber(extparser), xmlstringstart, 2148 2148 systemId, XML_GetCurrentByteIndex(extparser), 2149 2149 XML_ErrorString(XML_GetErrorCode(extparser)) 2150 2150 ); 2151 2151 } else { 2152 - sprintf(s, "%" TCL_LL_MODIFIER "d", 2152 + sprintf(s, "%" TDOM_LS_MODIFIER "d", 2153 2153 XML_GetCurrentLineNumber(extparser)); 2154 2154 Tcl_AppendResult(info->interp, ", referenced in entity \"", 2155 2155 systemId, 2156 2156 "\" at line ", s, " character ", NULL); 2157 - sprintf(s, "%" TCL_LL_MODIFIER "d", 2157 + sprintf(s, "%" TDOM_LS_MODIFIER "d", 2158 2158 XML_GetCurrentColumnNumber(extparser)); 2159 2159 Tcl_AppendResult(info->interp, s, NULL); 2160 2160 } 2161 2161 keepresult = 1; 2162 2162 result = 0; 2163 2163 break; 2164 2164 case XML_STATUS_SUSPENDED: ................................................................................ 2172 2172 do { 2173 2173 len = Tcl_Read (chan, buf, sizeof(buf)); 2174 2174 done = len < sizeof(buf); 2175 2175 status = XML_Parse (extparser, buf, (int)len, done); 2176 2176 switch (status) { 2177 2177 case XML_STATUS_ERROR: 2178 2178 interpResult = Tcl_GetStringResult(info->interp); 2179 - sprintf(s, "%" TCL_LL_MODIFIER "d", 2179 + sprintf(s, "%" TDOM_LS_MODIFIER "d", 2180 2180 XML_GetCurrentLineNumber(extparser)); 2181 2181 if (interpResult[0] == '\0') { 2182 2182 Tcl_ResetResult (info->interp); 2183 2183 Tcl_AppendResult(info->interp, "error \"", 2184 2184 XML_ErrorString(XML_GetErrorCode(extparser)), 2185 2185 "\" in entity \"", systemId, 2186 2186 "\" at line ", s, " character ", NULL); 2187 - sprintf(s, "%" TCL_LL_MODIFIER "d", 2187 + sprintf(s, "%" TDOM_LS_MODIFIER "d", 2188 2188 XML_GetCurrentColumnNumber(extparser)); 2189 2189 Tcl_AppendResult(info->interp, s, NULL); 2190 2190 } else { 2191 2191 Tcl_AppendResult(info->interp, ", referenced in entity \"", 2192 2192 systemId, 2193 2193 "\" at line ", s, " character ", NULL); 2194 - sprintf(s, "%" TCL_LL_MODIFIER "d", 2194 + sprintf(s, "%" TDOM_LS_MODIFIER "d", 2195 2195 XML_GetCurrentColumnNumber(extparser)); 2196 2196 Tcl_AppendResult(info->interp, s, NULL); 2197 2197 } 2198 2198 result = 0; 2199 2199 keepresult = 1; 2200 2200 done = 1; 2201 2201 break; ................................................................................ 2499 2499 /*--------------------------------------------------------------------------- 2500 2500 | domGetLineColumn 2501 2501 | 2502 2502 \--------------------------------------------------------------------------*/ 2503 2503 int 2504 2504 domGetLineColumn ( 2505 2505 domNode *node, 2506 - Tcl_WideInt *line, 2507 - Tcl_WideInt *column, 2508 - Tcl_WideInt *byteIndex 2506 + XML_Size *line, 2507 + XML_Size *column, 2508 + XML_Index *byteIndex 2509 2509 ) 2510 2510 { 2511 2511 char *v; 2512 2512 domLineColumn *lc; 2513 2513 2514 2514 *line = -1; 2515 2515 *column = -1; ................................................................................ 2560 2560 "xmlns:xml", &hnew); 2561 2561 ns = domNewNamespace (parent->ownerDocument, "xml", XML_NAMESPACE); 2562 2562 attr->nodeType = ATTRIBUTE_NODE; 2563 2563 attr->nodeFlags = IS_NS_NODE; 2564 2564 attr->namespace = ns->index; 2565 2565 attr->nodeName = (char *)&(h->key); 2566 2566 attr->parentNode = parent; 2567 - attr->valueLength = strlen (XML_NAMESPACE); 2567 + attr->valueLength = (domLength)strlen (XML_NAMESPACE); 2568 2568 attr->nodeValue = tdomstrdup (XML_NAMESPACE); 2569 2569 return attr; 2570 2570 } 2571 2571 2572 2572 2573 2573 /* 2574 2574 *---------------------------------------------------------------------- ................................................................................ 3106 3106 h = Tcl_CreateHashEntry (node->ownerDocument->ids, 3107 3107 attributeValue, &hnew); 3108 3108 /* XXX what to do, if hnew = 0 ??? */ 3109 3109 Tcl_SetHashValue (h, node); 3110 3110 } 3111 3111 } 3112 3112 FREE (attr->nodeValue); 3113 - attr->valueLength = strlen(attributeValue); 3113 + attr->valueLength = (domLength)strlen(attributeValue); 3114 3114 attr->nodeValue = (char*)MALLOC(attr->valueLength+1); 3115 3115 strcpy(attr->nodeValue, attributeValue); 3116 3116 } else { 3117 3117 /*----------------------------------------------- 3118 3118 | add a complete new attribute node 3119 3119 \----------------------------------------------*/ 3120 3120 attr = (domAttrNode*) domAlloc(sizeof(domAttrNode)); ................................................................................ 3122 3122 h = Tcl_CreateHashEntry(&HASHTAB(node->ownerDocument,tdom_attrNames), 3123 3123 attributeName, &hnew); 3124 3124 attr->nodeType = ATTRIBUTE_NODE; 3125 3125 attr->nodeFlags = 0; 3126 3126 attr->namespace = 0; 3127 3127 attr->nodeName = (char *)&(h->key); 3128 3128 attr->parentNode = node; 3129 - attr->valueLength = strlen(attributeValue); 3129 + attr->valueLength = (domLength)strlen(attributeValue); 3130 3130 attr->nodeValue = (char*)MALLOC(attr->valueLength+1); 3131 3131 strcpy(attr->nodeValue, attributeValue); 3132 3132 3133 3133 if (node->firstAttr) { 3134 3134 lastAttr = node->firstAttr; 3135 3135 /* move to the end of the attribute list */ 3136 3136 while (lastAttr->nextSibling) lastAttr = lastAttr->nextSibling; ................................................................................ 3238 3238 Tcl_DeleteHashEntry (h); 3239 3239 h = Tcl_CreateHashEntry (node->ownerDocument->ids, 3240 3240 attributeValue, &hnew); 3241 3241 Tcl_SetHashValue (h, node); 3242 3242 } 3243 3243 } 3244 3244 FREE (attr->nodeValue); 3245 - attr->valueLength = strlen(attributeValue); 3245 + attr->valueLength = (domLength)strlen(attributeValue); 3246 3246 attr->nodeValue = (char*)MALLOC(attr->valueLength+1); 3247 3247 strcpy(attr->nodeValue, attributeValue); 3248 3248 } else { 3249 3249 /*-------------------------------------------------------- 3250 3250 | add a complete new attribute node 3251 3251 \-------------------------------------------------------*/ 3252 3252 attr = (domAttrNode*) domAlloc(sizeof(domAttrNode)); ................................................................................ 3290 3290 attr->namespace = ns->index; 3291 3291 if (isNSAttr) { 3292 3292 attr->nodeFlags = IS_NS_NODE; 3293 3293 } 3294 3294 } 3295 3295 attr->nodeName = (char *)&(h->key); 3296 3296 attr->parentNode = node; 3297 - attr->valueLength = strlen(attributeValue); 3297 + attr->valueLength = (domLength)strlen(attributeValue); 3298 3298 attr->nodeValue = (char*)MALLOC(attr->valueLength+1); 3299 3299 strcpy(attr->nodeValue, attributeValue); 3300 3300 3301 3301 if (isNSAttr) { 3302 3302 if (node->firstAttr && (node->firstAttr->nodeFlags & IS_NS_NODE)) { 3303 3303 lastAttr = node->firstAttr; 3304 3304 while (lastAttr->nextSibling ................................................................................ 4544 4544 h = Tcl_CreateHashEntry(&HASHTAB(node->ownerDocument,tdom_attrNames), 4545 4545 Tcl_DStringValue(&dStr), &hnew); 4546 4546 attr->nodeType = ATTRIBUTE_NODE; 4547 4547 attr->nodeFlags = IS_NS_NODE; 4548 4548 attr->namespace = ns->index; 4549 4549 attr->nodeName = (char *)&(h->key); 4550 4550 attr->parentNode = node; 4551 - attr->valueLength = strlen(nsToAdd->uri); 4551 + attr->valueLength = (domLength)strlen(nsToAdd->uri); 4552 4552 attr->nodeValue = (char*)MALLOC(attr->valueLength+1); 4553 4553 strcpy(attr->nodeValue, nsToAdd->uri); 4554 4554 4555 4555 lastNSAttr = NULL; 4556 4556 if (node->firstAttr && (node->firstAttr->nodeFlags & IS_NS_NODE)) { 4557 4557 lastNSAttr = node->firstAttr; 4558 4558 while (lastNSAttr->nextSibling ................................................................................ 5328 5328 int storeLineColumn; 5329 5329 domLength textStartLine; 5330 5330 domLength textStartColumn; 5331 5331 domLength textStartByteIndex; 5332 5332 int ignorexmlns; 5333 5333 int feedbackAfter; 5334 5334 Tcl_Obj *feedbackCmd; 5335 - int nextFeedbackPosition; 5335 + XML_Index nextFeedbackPosition; 5336 5336 Tcl_Interp *interp; 5337 5337 int activeNSsize; 5338 5338 int activeNSpos; 5339 5339 domActiveNS *activeNS; 5340 5340 int baseURIstackSize; 5341 5341 int baseURIstackPos; 5342 5342 domActiveBaseURI *baseURIstack; ................................................................................ 5472 5472 ) 5473 5473 { 5474 5474 tdomCmdReadInfo *info = (tdomCmdReadInfo *) userData; 5475 5475 5476 5476 DispatchPCDATA ((domReadInfo*) info); 5477 5477 info->cdataSection = 1; 5478 5478 if (info->storeLineColumn) { 5479 - info->textStartLine = XML_GetCurrentLineNumber (info->parser); 5480 - info->textStartColumn = XML_GetCurrentColumnNumber (info->parser); 5481 - info->textStartByteIndex = XML_GetCurrentByteIndex (info->parser); 5479 + info->textStartLine = (domLength)XML_GetCurrentLineNumber (info->parser); 5480 + info->textStartColumn = (domLength)XML_GetCurrentColumnNumber (info->parser); 5481 + info->textStartByteIndex = (domLength)XML_GetCurrentByteIndex (info->parser); 5482 5482 } 5483 5483 } 5484 5484 5485 5485 int 5486 5486 TclTdomObjCmd ( 5487 5487 ClientData UNUSED(dummy), 5488 5488 Tcl_Interp *interp,
Changes to generic/dom.h.
31 31 \--------------------------------------------------------------------------*/ 32 32 33 33 #ifndef __DOM_H__ 34 34 #define __DOM_H__ 35 35 36 36 #include <tcl.h> 37 37 #include <stdlib.h> 38 +#include <stdint.h> 38 39 #include <string.h> 39 40 #include <ctype.h> 40 41 #include <expat.h> 41 42 #include <domalloc.h> 42 43 #include <limits.h> 43 44 44 45 /* ................................................................................ 106 107 #else 107 108 # define domLength int 108 109 # define Tcl_SetDomLengthObj Tcl_SetIntObj 109 110 # define domLengthConversion "%d" 110 111 # define TCL_SIZE_MODIFIER "" 111 112 # define Tcl_GetSizeIntFromObj Tcl_GetIntFromObj 112 113 #endif 114 + 115 +#ifndef TDOM_LS_MODIFIER 116 +# ifdef _WIN32 117 +# define TDOM_LS_MODIFIER "I64" 118 +# else 119 +# define TDOM_LS_MODIFIER "ll" 120 +# endif 121 +#endif 113 122 114 123 /* Since the len argument of XML_Parse() is of type int, parsing of 115 124 * strings has to be done in chunks anyway for Tcl 9 with its strings 116 125 * potentially longer than 2 GByte. Because of internal changes in 117 126 * exapt a chunk size of INT_MAX led to out of memory errors. 118 127 * (TDOM_PCS = TDOM_PARSE_CHUNK_SIZE) */ 119 128 ................................................................................ 169 178 # define NODE_NO(doc) ++domUniqueNodeNr 170 179 # define DOC_NO(doc) ++domUniqueDocNr 171 180 #else 172 181 # define TDomNotThreaded(x) 173 182 # define TDomThreaded(x) x 174 183 # define HASHTAB(doc,tab) (doc)->tab 175 184 # define NODE_NO(doc) ((doc)->nodeCounter)++ 176 -# ifdef _WIN32 177 -# define DOC_NO(doc) (unsigned long long)(doc) 178 -# else 179 -# define DOC_NO(doc) (unsigned long)(doc) 180 -# endif 185 +# define DOC_NO(doc) (uintptr_t)(doc) 181 186 #endif /* TCL_THREADS */ 182 187 183 188 #define DOC_CMD(s,doc) sprintf((s), "domDoc%p", (void *)(doc)) 184 189 #define NODE_CMD(s,node) sprintf((s), "domNode%p", (void *)(node)) 185 190 #define XSLT_CMD(s,doc) sprintf((s), "XSLTcmd%p", (void *)(doc)) 186 191 187 192 #define XML_NAMESPACE "http://www.w3.org/XML/1998/namespace" ................................................................................ 540 545 | 541 546 \-------------------------------------------------------------------------*/ 542 547 typedef struct domDocument { 543 548 544 549 domNodeType nodeType : 8; 545 550 domDocFlags nodeFlags : 8; 546 551 domNameSpaceIndex dummy : 16; 547 -#ifdef _WIN32 548 - unsigned long long documentNumber; 549 -#else 550 - unsigned long documentNumber; 551 -#endif 552 + uintptr_t documentNumber; 552 553 struct domNode *documentElement; 553 554 struct domNode *fragments; 554 555 #ifdef TCL_THREADS 555 556 struct domNode *deletedNodes; 556 557 #endif 557 558 struct domNS **namespaces; 558 559 int nsptr; ................................................................................ 631 632 632 633 /*-------------------------------------------------------------------------- 633 634 | domLineColumn 634 635 | 635 636 \-------------------------------------------------------------------------*/ 636 637 typedef struct domLineColumn { 637 638 638 - Tcl_WideInt line; 639 - Tcl_WideInt column; 640 - Tcl_WideInt byteIndex; 639 + XML_Size line; 640 + XML_Size column; 641 + XML_Index byteIndex; 641 642 642 643 } domLineColumn; 643 644 644 645 typedef struct { 645 646 int errorCode; 646 - Tcl_WideInt errorLine; 647 - Tcl_WideInt errorColumn; 648 - Tcl_WideInt byteIndex; 647 + XML_Size errorLine; 648 + XML_Size errorColumn; 649 + XML_Index byteIndex; 649 650 } domParseForestErrorData; 650 651 651 652 652 653 /*-------------------------------------------------------------------------- 653 654 | domNode 654 655 | 655 656 \-------------------------------------------------------------------------*/ ................................................................................ 888 889 const char *prefix, const char *namespaceURI); 889 890 const char * domLookupPrefixWithMappings (domNode *node, const char *prefix, 890 891 char **prefixMappings); 891 892 domNS * domLookupURI (domNode *node, char *uri); 892 893 domNS * domGetNamespaceByIndex (domDocument *doc, unsigned int nsIndex); 893 894 domNS * domNewNamespace (domDocument *doc, const char *prefix, 894 895 const char *namespaceURI); 895 -int domGetLineColumn (domNode *node, Tcl_WideInt *line, 896 - Tcl_WideInt *column, Tcl_WideInt *byteIndex); 896 +int domGetLineColumn (domNode *node, XML_Size *line, 897 + XML_Size *column, XML_Index *byteIndex); 897 898 898 899 int domXPointerChild (domNode * node, int all, int instance, domNodeType type, 899 900 char *element, char *attrName, char *attrValue, 900 901 domLength attrLen, domAddCallback addCallback, 901 902 void * clientData); 902 903 903 904 int domXPointerDescendant (domNode * node, int all, int instance,
Changes to generic/domhtml.c.
2602 2602 | allocate new TEXT node 2603 2603 \-------------------------------------------------------*/ 2604 2604 tnode = (domTextNode*) domAlloc(sizeof(domTextNode)); 2605 2605 memset(tnode, 0, sizeof(domTextNode)); 2606 2606 tnode->nodeType = TEXT_NODE; 2607 2607 tnode->ownerDocument = doc; 2608 2608 tnode->nodeNumber = NODE_NO(doc); 2609 - tnode->valueLength = (x - start); 2609 + tnode->valueLength = (domLength)(x - start); 2610 2610 tnode->nodeValue = (char*)MALLOC((x - start)+1); 2611 2611 memmove(tnode->nodeValue, start, (x - start)); 2612 2612 *(tnode->nodeValue + (x - start)) = 0; 2613 2613 DBG(fprintf(stderr, "New text node: '%s'\n", tnode->nodeValue);) 2614 2614 if (ampersandSeen) { 2615 2615 TranslateEntityRefs (tnode); 2616 2616 } ................................................................................ 2631 2631 \-----------------------------------------------------------*/ 2632 2632 x += 2; 2633 2633 while ((c=*x)!=0 && c!='>' && c!='<' && !SPACE(c) ) { 2634 2634 *x = tolower(c); 2635 2635 x++; 2636 2636 } 2637 2637 if (c==0) { 2638 - RetError("Missing \">\"",(start-html) ); 2638 + RetError("Missing \">\"",(domLength)(start-html) ); 2639 2639 } 2640 2640 if ( (x-start)==2) { 2641 - RetError("Null markup name",(start-html) ); 2641 + RetError("Null markup name",(domLength)(start-html) ); 2642 2642 } 2643 2643 *x = '\0'; /* temporarily terminate the string */ 2644 2644 2645 2645 2646 2646 /*---------------------------------------------------------------------- 2647 2647 | check for tags which could optional be close 2648 2648 | like <option>...</option> ................................................................................ 2755 2755 parent_node = node->parentNode; 2756 2756 pn = (char*)node->nodeName; 2757 2757 break; 2758 2758 } 2759 2759 } 2760 2760 sprintf(tmp, "Unterminated element '%s' (within '%s')", start+2, pn); 2761 2761 *x = c; /* remove temporarily termination */ 2762 - RetError(tmp,(x - html)); 2762 + RetError(tmp,(domLength)(x - html)); 2763 2763 } 2764 2764 break; 2765 2765 } 2766 2766 2767 2767 /* move up */ 2768 2768 node = parent_node; 2769 2769 parent_node = NULL; ................................................................................ 2777 2777 } 2778 2778 if (*x=='>') { 2779 2779 x++; 2780 2780 } else { 2781 2781 if (*x == '<') { 2782 2782 /* start of new tag, ends closing tag */ 2783 2783 } else { 2784 - RetError("Missing \">\"",(x - html)-1); 2784 + RetError("Missing \">\"",(domLength)(x - html)-1); 2785 2785 } 2786 2786 } 2787 2787 if (parent_node == NULL) { 2788 2788 /* we return to main node and so finished parsing */ 2789 2789 return TCL_OK; 2790 2790 } 2791 2791 continue; ................................................................................ 2809 2809 \---------------------------------------------------*/ 2810 2810 tnode = (domTextNode*) domAlloc(sizeof(domTextNode)); 2811 2811 memset(tnode, 0, sizeof(domTextNode)); 2812 2812 tnode->nodeType = COMMENT_NODE; 2813 2813 tnode->ownerDocument = doc; 2814 2814 tnode->nodeNumber = NODE_NO(doc); 2815 2815 tnode->parentNode = parent_node; 2816 - tnode->valueLength = x - start - 4; 2816 + tnode->valueLength = (domLength)(x - start - 4); 2817 2817 tnode->nodeValue = (char*)MALLOC(tnode->valueLength+1); 2818 2818 memmove(tnode->nodeValue, start+4, tnode->valueLength); 2819 2819 *(tnode->nodeValue + tnode->valueLength) = 0; 2820 2820 if (parent_node == NULL) { 2821 2821 if (doc->rootNode->lastChild) { 2822 2822 tnode->previousSibling = 2823 2823 doc->rootNode->lastChild; ................................................................................ 2834 2834 parent_node->lastChild = (domNode*)tnode; 2835 2835 } else { 2836 2836 parent_node->firstChild = parent_node->lastChild = (domNode*)tnode; 2837 2837 } 2838 2838 } 2839 2839 x += 3; 2840 2840 } else { 2841 - RetError("Unterminated comment",(start-html)); 2841 + RetError("Unterminated comment",(domLength)(start-html)); 2842 2842 } 2843 2843 continue; 2844 2844 2845 2845 } else if (TU(x[1])=='D' && TU(x[2])=='O' && 2846 2846 TU(x[3])=='C' && TU(x[4])=='T' && 2847 2847 TU(x[5])=='Y' && TU(x[6])=='P' && TU(x[7])=='E' ) { 2848 2848 /*-------------------------------------------------------- ................................................................................ 2860 2860 } else { 2861 2861 x++; 2862 2862 } 2863 2863 } 2864 2864 if (*x) { 2865 2865 x++; 2866 2866 } else { 2867 - RetError("Unterminated DOCTYPE definition",(start-html)); 2867 + RetError("Unterminated DOCTYPE definition",(domLength)(start-html)); 2868 2868 } 2869 2869 continue; 2870 2870 2871 2871 } else if (x[1]=='[' && x[2]=='C' && 2872 2872 x[3]=='D' && x[4]=='A' && 2873 2873 x[5]=='T' && x[6]=='A' && x[7]=='[' ) { 2874 2874 /*-------------------------------------------------------- ................................................................................ 2887 2887 \---------------------------------------------------*/ 2888 2888 tnode = (domTextNode*) domAlloc(sizeof(domTextNode)); 2889 2889 memset(tnode, 0, sizeof(domTextNode)); 2890 2890 tnode->nodeType = TEXT_NODE; 2891 2891 tnode->ownerDocument = doc; 2892 2892 tnode->nodeNumber = NODE_NO(doc); 2893 2893 tnode->parentNode = parent_node; 2894 - tnode->valueLength = (x - start); 2894 + tnode->valueLength = (domLength)(x - start); 2895 2895 tnode->nodeValue = (char*)MALLOC((x - start)+1); 2896 2896 memmove(tnode->nodeValue, start, (x - start)); 2897 2897 *(tnode->nodeValue + (x - start)) = 0; 2898 2898 if (parent_node->firstChild) { 2899 2899 parent_node->lastChild->nextSibling = (domNode*)tnode; 2900 2900 tnode->previousSibling = parent_node->lastChild; 2901 2901 parent_node->lastChild = (domNode*)tnode; 2902 2902 } else { 2903 2903 parent_node->firstChild = parent_node->lastChild = (domNode*)tnode; 2904 2904 } 2905 2905 } 2906 2906 x += 3; 2907 2907 } else { 2908 - RetError("Unterminated CDATA definition",(start-html) ); 2908 + RetError("Unterminated CDATA definition",(domLength)(start-html) ); 2909 2909 } 2910 2910 continue; 2911 2911 } else { 2912 - RetError("Incorrect <!... tag",(start-html) ); 2912 + RetError("Incorrect <!... tag",(domLength)(start-html) ); 2913 2913 } 2914 2914 2915 2915 } else if (*x=='?') { 2916 2916 /*-------------------------------------------------------- 2917 2917 | read over a processing instructions(PI) / XMLDecl 2918 2918 \-------------------------------------------------------*/ 2919 2919 x++; ................................................................................ 2940 2940 piSep = start; 2941 2941 while ( (c=*piSep)!=0 && !SPACE(c) && 2942 2942 (c!='?' || piSep[1]!='>')) { 2943 2943 piSep++; 2944 2944 } 2945 2945 *piSep = '\0'; /* temporarily terminate the string */ 2946 2946 2947 - pinode->targetLength = strlen(start); 2947 + pinode->targetLength = (domLength)strlen(start); 2948 2948 pinode->targetValue = (char*)MALLOC(pinode->targetLength); 2949 2949 memmove(pinode->targetValue, start, pinode->targetLength); 2950 2950 2951 2951 *piSep = c; /* remove temporarily termination */ 2952 2952 2953 2953 /*------------------------------------------------- 2954 2954 | extract PI data 2955 2955 \------------------------------------------------*/ 2956 2956 while (SPACE(*piSep)) { 2957 2957 piSep++; 2958 2958 } 2959 - pinode->dataLength = x - piSep; 2959 + pinode->dataLength = (domLength)(x - piSep); 2960 2960 pinode->dataValue = (char*)MALLOC(pinode->dataLength); 2961 2961 memmove(pinode->dataValue, piSep, pinode->dataLength); 2962 2962 2963 2963 if (parent_node == NULL) { 2964 2964 if (doc->rootNode->lastChild) { 2965 2965 pinode->previousSibling = doc->rootNode->lastChild; 2966 2966 doc->rootNode->lastChild->nextSibling ................................................................................ 2976 2976 parent_node->lastChild = (domNode*)pinode; 2977 2977 } else { 2978 2978 parent_node->firstChild = parent_node->lastChild = (domNode*)pinode; 2979 2979 } 2980 2980 } 2981 2981 x += 2; 2982 2982 } else { 2983 - RetError("Unterminated processing instruction(PI)",(start-html) ); 2983 + RetError("Unterminated processing instruction(PI)",(domLength)(start-html)); 2984 2984 } 2985 2985 continue; 2986 2986 } 2987 2987 2988 2988 2989 2989 /*---------------------------------------------------------------- 2990 2990 | new tag/element ................................................................................ 3011 3011 *x = c; 3012 3012 if (!rc) { 3013 3013 goto readText; 3014 3014 } 3015 3015 } 3016 3016 hasContent = 1; 3017 3017 if (c==0) { 3018 - RetError("Missing \">\"",(start-html) ); 3018 + RetError("Missing \">\"",(domLength)(start-html)); 3019 3019 } 3020 3020 if ( (x-start)==1) { 3021 - RetError("Null markup name",(start-html) ); 3021 + RetError("Null markup name",(domLength)(start-html)); 3022 3022 } 3023 3023 DBG(fprintf(stderr, "\nnew tag '%70.70s...' \n", start);) 3024 3024 *x = '\0'; /* temporarily terminate the string */ 3025 3025 3026 3026 3027 3027 /*----------------------------------------------------------- 3028 3028 | check, whether new starting element close another ................................................................................ 3111 3111 char *ArgVal = NULL; 3112 3112 domLength nArgVal = 0; 3113 3113 3114 3114 while ((c=*x)!=0 && c!='=' && c!='>' && !SPACE(c) ) { 3115 3115 *x = tolower(c); 3116 3116 x++; 3117 3117 } 3118 - nArgName = x - ArgName; 3118 + nArgName = (domLength)(x - ArgName); 3119 3119 while (SPACE(*x)) { 3120 3120 x++; 3121 3121 } 3122 3122 if (*x == '=') { 3123 3123 3124 3124 /* attribute with value, like width="1234" */ 3125 3125 ................................................................................ 3138 3138 x++; 3139 3139 ArgVal = x; 3140 3140 ampersandSeen = 0; 3141 3141 while ((c=*x)!=0 && c!=cDelim) { 3142 3142 if (c=='&') ampersandSeen = 1; 3143 3143 x++; 3144 3144 } 3145 - nArgVal = x - ArgVal; 3145 + nArgVal = (domLength)(x - ArgVal); 3146 3146 if (c==0) { 3147 - RetError("Unterminated string",(ArgVal - html - 1) ); 3147 + RetError("Unterminated string",(domLength)(ArgVal - html - 1)); 3148 3148 } else { 3149 3149 x++; 3150 3150 } 3151 3151 } else if (c!=0 && c!='>') { 3152 3152 ArgVal = x; 3153 3153 while ((c=*x)!=0 && c!='>' && !SPACE(c)) { 3154 3154 if (c=='&') ampersandSeen = 1; 3155 3155 x++; 3156 3156 } 3157 3157 if (c==0) { 3158 - RetError("Missing \">\"",(start-html)); 3158 + RetError("Missing \">\"",(domLength)(start-html)); 3159 3159 } 3160 - nArgVal = x - ArgVal; 3160 + nArgVal = (domLength)(x - ArgVal); 3161 3161 } 3162 3162 } else { 3163 3163 /* attribute without value, like 'nowrap' */ 3164 3164 savedChar = *(ArgName + nArgName); 3165 3165 *(ArgName + nArgName) = '\0'; /* terminate arg name */ 3166 3166 ArgVal = ArgName; 3167 3167 nArgVal = nArgName; ................................................................................ 3236 3236 !strcmp(node->nodeName,"source")) {hasContent = 0;} break; /*html5*/ 3237 3237 } 3238 3238 3239 3239 if (*x=='/') { 3240 3240 hasContent = 0; 3241 3241 x++; 3242 3242 if (*x!='>') { 3243 - RetError("Syntax Error",(x - html - 1) ); 3243 + RetError("Syntax Error",(domLength)(x - html - 1)); 3244 3244 } 3245 3245 } 3246 3246 if (*x=='>') { 3247 3247 x++; 3248 3248 } 3249 3249 DBG(fprintf(stderr, "%d: new node '%s' hasContent=%d \n", getDeep(node), node->nodeName, hasContent);) 3250 3250 ................................................................................ 3283 3283 \---------------------------------------------------*/ 3284 3284 tnode = (domTextNode*) domAlloc(sizeof(domTextNode)); 3285 3285 memset(tnode, 0, sizeof(domTextNode)); 3286 3286 tnode->nodeType = TEXT_NODE; 3287 3287 tnode->ownerDocument = doc; 3288 3288 tnode->nodeNumber = NODE_NO(doc); 3289 3289 tnode->parentNode = node; 3290 - tnode->valueLength = (x - start); 3290 + tnode->valueLength = (domLength)(x - start); 3291 3291 tnode->nodeValue = (char*)MALLOC((x - start)+1); 3292 3292 memmove(tnode->nodeValue, start, (x - start)); 3293 3293 *(tnode->nodeValue + (x - start)) = 0; 3294 3294 if (node->firstChild) { 3295 3295 node->lastChild->nextSibling = (domNode*)tnode; 3296 3296 tnode->previousSibling = node->lastChild; 3297 3297 node->lastChild = (domNode*)tnode; ................................................................................ 3343 3343 if (parent_node == NULL) { 3344 3344 /* we return to main node and so finished parsing */ 3345 3345 return TCL_OK; 3346 3346 } 3347 3347 if (forest && parent_node == parent) { 3348 3348 return TCL_OK; 3349 3349 } 3350 - RetError("Unexpected end",(x - html) ); 3350 + RetError("Unexpected end",(domLength)(x - html)); 3351 3351 3352 3352 } /* HTML_SimpleParse */ 3353 3353 3354 3354 3355 3355 /*---------------------------------------------------------------------------- 3356 3356 | HTML_SimpleParseDocument 3357 3357 |
Changes to generic/domjson.c.
371 371 } else if (c == '"') { 372 372 /* Parse string */ 373 373 j = jsonParseString (json, i, jparse); 374 374 rc(j); 375 375 if (jparse->len && jparse->buf[0]) { 376 376 DBG(fprintf(stderr, "New unescaped text node '%s'\n", jparse->buf)); 377 377 newTextNode = domNewTextNode (parent->ownerDocument, 378 - jparse->buf, strlen(jparse->buf), 378 + jparse->buf, (domLength)strlen(jparse->buf), 379 379 TEXT_NODE); 380 380 domAppendChild (parent, (domNode *) newTextNode); 381 381 } else { 382 382 DBG(save = json[j];json[j] = '\0';fprintf(stderr, "New text node '%s'\n", &json[i+1]);json[j] = save;); 383 383 newTextNode = domNewTextNode (parent->ownerDocument, 384 384 &json[i+1], j-i-1, TEXT_NODE); 385 385 domAppendChild (parent, (domNode *) newTextNode);
Changes to generic/domxpath.c.
417 417 rs->type = BoolResult; 418 418 rs->intvalue = (i ? 1 : 0); 419 419 } 420 420 void rsSetString ( xpathResultSet *rs, const char *s) { 421 421 rs->type = StringResult; 422 422 if (s) { 423 423 rs->string = tdomstrdup(s); 424 - rs->string_len = strlen(s); 424 + rs->string_len = (domLength)strlen(s); 425 425 } else { 426 426 rs->string = tdomstrdup(""); 427 427 rs->string_len = 0; 428 428 } 429 429 rs->nr_nodes = 0; 430 430 } 431 431 ................................................................................ 2792 2792 if (IS_NAN (rs->realvalue)) return tdomstrdup ("NaN"); 2793 2793 else if (IS_INF (rs->realvalue)) { 2794 2794 if (IS_INF (rs->realvalue) == 1) return tdomstrdup ("Infinity"); 2795 2795 else return tdomstrdup ("-Infinity"); 2796 2796 } 2797 2797 sprintf(tmp, "%g", rs->realvalue); 2798 2798 /* strip trailing 0 and . */ 2799 - len = strlen(tmp); 2799 + len = (domLength)strlen(tmp); 2800 2800 for (; (len > 0) && (tmp[len-1] == '0'); len--) tmp[len-1] = '\0'; 2801 2801 if ((len > 0) && (tmp[len-1] == '.')) tmp[len-1] = '\0'; 2802 2802 return (tdomstrdup(tmp)); 2803 2803 2804 2804 case NaNResult: 2805 2805 return tdomstrdup ("NaN"); 2806 2806 ................................................................................ 3383 3383 if (pfrom != NULL) { 3384 3384 rsSetString (result, pfrom + strlen (rightStr)); 3385 3385 } else { 3386 3386 rsSetString (result, ""); 3387 3387 } 3388 3388 } else { 3389 3389 /* starts-with */ 3390 - i = strlen(rightStr); 3390 + i = (domLength)strlen(rightStr); 3391 3391 if(strncmp(leftStr, rightStr, i)==0) { 3392 3392 rsSetBool (result, 1); 3393 3393 } else { 3394 3394 rsSetBool (result, 0); 3395 3395 } 3396 3396 } 3397 3397 xpathRSFree (&leftResult); ................................................................................ 3419 3419 return rc; 3420 3420 } 3421 3421 *docOrder = savedDocOrder; 3422 3422 3423 3423 leftStr = xpathFuncString( &leftResult ); 3424 3424 pto = (char*)REALLOC(pto, 1+len+strlen(leftStr)); 3425 3425 memmove(pto + len, leftStr, strlen(leftStr)); 3426 - len += strlen(leftStr); 3426 + len += (domLength)strlen(leftStr); 3427 3427 *(pto + len) = '\0'; 3428 3428 xpathRSFree( &leftResult ); 3429 3429 FREE(leftStr); 3430 3430 nextStep = nextStep->next; 3431 3431 } 3432 3432 rsSetString (result, pto); 3433 3433 FREE(pto); ................................................................................ 5994 5994 sprintf(step, "/%s[%d]", nTest, nodeIndex); 5995 5995 } 5996 5996 break; 5997 5997 5998 5998 default: 5999 5999 break; 6000 6000 } 6001 - len = strlen(step); 6001 + len = (domLength)strlen(step); 6002 6002 if ( (len + *xpathLen) > *xpathAllocated ) { 6003 6003 *xpathAllocated = *xpathAllocated * 2; 6004 6004 *xpath = REALLOC(*xpath, *xpathAllocated + 1); 6005 6005 } 6006 6006 strcpy( *xpath + *xpathLen, step); 6007 6007 *xpathLen += len; 6008 6008
Changes to generic/domxslt.c.
538 538 domNode * node, 539 539 char * str, 540 540 char ** errMsg) 541 541 { 542 542 Tcl_DString dStr; 543 543 char buffer[1024]; 544 544 const char *baseURI; 545 - Tcl_WideInt line, column, byteIndex; 545 + XML_Size line, column; 546 + XML_Index byteIndex; 546 547 547 548 Tcl_DStringInit (&dStr); 548 549 baseURI = findBaseURI (node); 549 550 if (baseURI) { 550 551 Tcl_DStringAppend (&dStr, "In entity ", 10); 551 552 Tcl_DStringAppend (&dStr, baseURI, -1); 552 553 } 553 554 if (node->nodeFlags & HAS_LINE_COLUMN) { 554 555 domGetLineColumn (node, &line, &column, &byteIndex); 555 - sprintf (buffer, " at line %" TCL_LL_MODIFIER "d, column %" 556 - TCL_LL_MODIFIER "d:\n", line, column); 556 + sprintf (buffer, " at line %" TDOM_LS_MODIFIER "d, column %" 557 + TDOM_LS_MODIFIER "d:\n", line, column); 557 558 Tcl_DStringAppend (&dStr, buffer, -1); 558 559 Tcl_DStringAppend (&dStr, str, -1); 559 560 } else { 560 561 if (baseURI) Tcl_DStringAppend (&dStr, ": ", 2); 561 562 Tcl_DStringAppend (&dStr, str, -1); 562 563 } 563 564 if (*errMsg) FREE (*errMsg); ................................................................................ 948 949 { "IV", "iv", 4, }, 949 950 { "I" , "i" , 1 } 950 951 }; 951 952 952 953 switch (f->tokens[*useFormatToken].type) { 953 954 case latin_number: 954 955 sprintf (tmp, "%" TCL_SIZE_MODIFIER "d", value); 955 - fulllen = len = strlen (tmp); 956 + fulllen = len = (domLength)strlen (tmp); 956 957 if (f->tokens[*useFormatToken].minlength > fulllen) { 957 958 fulllen = f->tokens[*useFormatToken].minlength; 958 959 } 959 960 if (groupingSeparator) { 960 - gslen = strlen (groupingSeparator); 961 + gslen = (domLength)strlen (groupingSeparator); 961 962 Tcl_DStringInit (&tmp1); 962 963 if (len < f->tokens[*useFormatToken].minlength) { 963 964 for (i = 0; i < f->tokens[*useFormatToken].minlength - len; i++) { 964 965 Tcl_DStringAppend (&tmp1, "0", 1); 965 966 } 966 967 } 967 968 Tcl_DStringAppend (&tmp1, tmp, len); ................................................................................ 1068 1069 } 1069 1070 break; 1070 1071 1071 1072 default: 1072 1073 sprintf (tmp, "%" TCL_SIZE_MODIFIER "d", value); 1073 1074 break; 1074 1075 } 1075 - len = strlen (tmp); 1076 + len = (domLength)strlen (tmp); 1076 1077 Tcl_DStringAppend (str, tmp, len); 1077 1078 appendSeperator: 1078 1079 if (addSeparater) { 1079 1080 if (f->tokens[*useFormatToken].sepStart) { 1080 1081 Tcl_DStringAppend (str, f->tokens[*useFormatToken].sepStart, 1081 1082 f->tokens[*useFormatToken].sepLen); 1082 1083 *useFormatToken += 1; ................................................................................ 1388 1389 } 1389 1390 } 1390 1391 1391 1392 DBG(fprintf(stderr,"normal part nZero=%d i=%d glen=%d\n", nZero, i, gLen);) 1392 1393 /* fill in grouping char */ 1393 1394 if (gLen > 0) { 1394 1395 sprintf(stmp,"%0*d", nZero, i); 1395 - l = strlen (stmp); 1396 + l = (domLength)strlen (stmp); 1396 1397 for (j = 0; j < l; j++) { 1397 1398 t = df->zeroDigit + stmp[j] - 48; 1398 1399 Tcl_DStringAppend (&s, (char*)&t, sizeof (Tcl_UniChar)); 1399 1400 } 1400 1401 DBG( 1401 1402 Tcl_DStringInit(&dbStr); 1402 1403 fprintf (stderr, "'%s' ---> ..\n", stmp); ................................................................................ 1433 1434 Tcl_DStringInit (&dbStr); 1434 1435 fprintf(stderr,"n='%s'\n", 1435 1436 Tcl_UniCharToUtfDString (n, Tcl_UniCharLen (n), &dbStr)); 1436 1437 Tcl_DStringFree (&dbStr); 1437 1438 ) 1438 1439 } else { 1439 1440 sprintf(stmp,"%0*d", nZero, i); 1440 - l = strlen (stmp); 1441 + l = (domLength)strlen (stmp); 1441 1442 for (j = 0; j < l; j++) { 1442 1443 n[j] = df->zeroDigit + (int) stmp[j] - 48; 1443 1444 } 1444 1445 n[l] = '\0'; 1445 1446 DBG( 1446 1447 Tcl_DStringInit (&dbStr); 1447 1448 fprintf(stderr,"n='%s'\n", ................................................................................ 1448 1449 Tcl_UniCharToUtfDString(n, Tcl_UniCharLen (n), &dbStr)); 1449 1450 Tcl_DStringFree (&dbStr); 1450 1451 ) 1451 1452 } 1452 1453 DBG(fprintf(stderr, "number=%f fHash=%d fZero=%d \n", number, fHash, 1453 1454 fZero);) 1454 1455 if ((fHash+fZero) > 0) { 1455 - l = strlen(ftmp); 1456 + l = (domLength)strlen(ftmp); 1456 1457 while (l>0 && fHash>0) { /* strip not need 0's */ 1457 1458 if (ftmp[l-1] == '0') { 1458 1459 ftmp[l-1]='\0'; l--; fHash--; 1459 1460 } else { 1460 1461 break; 1461 1462 } 1462 1463 } ................................................................................ 1514 1515 tstr = Tcl_UniCharToUtfDString( 1515 1516 (Tcl_UniChar*)Tcl_DStringValue (&s), 1516 1517 Tcl_UniCharLen((Tcl_UniChar*)Tcl_DStringValue(&s)), &dStr 1517 1518 ); 1518 1519 *resultStr = tdomstrdup(tstr); 1519 1520 Tcl_DStringFree (&dStr); 1520 1521 Tcl_DStringFree (&s); 1521 - *resultLen = strlen(*resultStr); 1522 + *resultLen = (domLength)strlen(*resultStr); 1522 1523 return 0; 1523 1524 1524 1525 xsltFormatNumberError: 1525 1526 Tcl_DStringFree (&dStr); 1526 1527 Tcl_DStringFree (&s); 1527 1528 return -1; 1528 1529 } ................................................................................ 4418 4419 domCopyTo (rs.nodes[i], xs->lastNode, 1); 4419 4420 } 4420 4421 } 4421 4422 } 4422 4423 } else { 4423 4424 str = xpathFuncString( &rs ); 4424 4425 TRACE1("copyOf: xpathString='%s' \n", str); 4425 - domAppendNewTextNode(xs->lastNode, str, strlen(str), 4426 + domAppendNewTextNode(xs->lastNode, str, (domLength)strlen(str), 4426 4427 TEXT_NODE, 0); 4427 4428 FREE(str); 4428 4429 } 4429 4430 xpathRSFree( &rs ); 4430 4431 break; 4431 4432 4432 4433 case decimalFormat: ................................................................................ 4757 4758 FREE(str); 4758 4759 FREE(str2); 4759 4760 return -1; 4760 4761 } 4761 4762 xs->lastNode = savedLastNode; 4762 4763 4763 4764 n = (domNode*)domNewProcessingInstructionNode( 4764 - xs->resultDoc, str2, strlen(str2), str, len); 4765 + xs->resultDoc, str2, (domLength)strlen(str2), str, len); 4765 4766 domAppendChild(xs->lastNode, n); 4766 4767 domDeleteNode (fragmentNode, NULL, NULL); 4767 4768 FREE(str2); 4768 4769 FREE(str); 4769 4770 break; 4770 4771 4771 4772 case sort: ................................................................................ 4804 4805 TRACE1("valueOf: str='%s' \n", str); 4805 4806 rc = evalXPath(xs, context, currentNode, currentPos, str, 4806 4807 &rs, errMsg); 4807 4808 CHECK_RC; 4808 4809 DBG(rsPrint(&rs)); 4809 4810 str = xpathFuncString( &rs ); 4810 4811 TRACE1("valueOf: xpathString='%s' \n", str); 4811 - domAppendNewTextNode(xs->lastNode, str, strlen(str), 4812 + domAppendNewTextNode(xs->lastNode, str, (domLength)strlen(str), 4812 4813 TEXT_NODE, disableEsc); 4813 4814 xpathRSFree( &rs ); 4814 4815 FREE(str); 4815 4816 } else { 4816 4817 reportError (actionNode, "xsl:value-of must have a" 4817 4818 " \"select\" attribute!", errMsg); 4818 4819 return -1; ................................................................................ 5716 5717 ) 5717 5718 5718 5719 cmdPtr = Tcl_NewStringObj (xsltDoc->extResolver, -1); 5719 5720 Tcl_IncrRefCount (cmdPtr); 5720 5721 if (baseURI) { 5721 5722 Tcl_ListObjAppendElement(interp, cmdPtr, 5722 5723 Tcl_NewStringObj (baseURI, 5723 - strlen(baseURI))); 5724 + (domLength)strlen(baseURI))); 5724 5725 } else { 5725 5726 Tcl_ListObjAppendElement(interp, cmdPtr, 5726 5727 Tcl_NewStringObj ("", 0)); 5727 5728 } 5728 5729 Tcl_ListObjAppendElement (interp, cmdPtr, (href ? 5729 - Tcl_NewStringObj (href, strlen (href)) 5730 + Tcl_NewStringObj (href, (domLength)strlen (href)) 5730 5731 : Tcl_NewStringObj ("", 0))); 5731 5732 Tcl_ListObjAppendElement (interp, cmdPtr, 5732 5733 Tcl_NewStringObj ("", 0)); 5733 5734 5734 5735 result = Tcl_EvalObjEx (interp, cmdPtr, TCL_EVAL_DIRECT | TCL_EVAL_GLOBAL); 5735 5736 5736 5737 Tcl_DecrRefCount (cmdPtr); ................................................................................ 5823 5824 Tcl_DStringAppend (&dStr, "Error while processing external entity \"", 5824 5825 -1); 5825 5826 Tcl_DStringAppend (&dStr, href, -1); 5826 5827 Tcl_DStringAppend (&dStr, "\":\n", -1); 5827 5828 str = Tcl_GetStringResult (interp); 5828 5829 if (str[0] == '\0') { 5829 5830 Tcl_DStringAppend (&dStr, "At line ", -1); 5830 - sprintf (s, "%" TCL_LL_MODIFIER "d", 5831 + sprintf (s, "%" TDOM_LS_MODIFIER "d", 5831 5832 XML_GetCurrentLineNumber (parser)); 5832 5833 Tcl_DStringAppend (&dStr, s, -1); 5833 5834 Tcl_DStringAppend (&dStr, " character ", -1); 5834 - sprintf (s, "%" TCL_LL_MODIFIER "d", 5835 + sprintf (s, "%" TDOM_LS_MODIFIER "d", 5835 5836 XML_GetCurrentColumnNumber (parser)); 5836 5837 Tcl_DStringAppend (&dStr, s, -1); 5837 5838 Tcl_DStringAppend (&dStr, ": ", 2); 5838 5839 Tcl_DStringAppend (&dStr, 5839 5840 XML_ErrorString (XML_GetErrorCode(parser)), -1); 5840 5841 } else { 5841 5842 Tcl_DStringAppend (&dStr, str, -1);
Changes to generic/nodecmd.c.
490 490 } 491 491 break; 492 492 } 493 493 494 494 if (type < 0 && newNode != NULL) { 495 495 char buf[64]; 496 496 tcldom_createNodeObj(interp, newNode, buf); 497 - Tcl_SetObjResult(interp, Tcl_NewStringObj(buf, strlen(buf))); 497 + Tcl_SetObjResult(interp, Tcl_NewStringObj(buf, (domLength)strlen(buf))); 498 498 } 499 499 500 500 if (ret == TCL_OK) doc->nodeFlags |= NEEDS_RENUMBERING; 501 501 return ret; 502 502 } 503 503 504 504 /*----------------------------------------------------------------------------
Changes to generic/schema.c.
3368 3368 if (kc->flags & DKC_FLAG_IGNORE_EMPTY_FIELD_SET) { 3369 3369 continue; 3370 3370 } 3371 3371 if (kc->emptyFieldSetValue) { 3372 3372 if (first) first = 0; 3373 3373 else Tcl_DStringAppend (&dStr, ":", 1); 3374 3374 Tcl_DStringAppend (&dStr, kc->emptyFieldSetValue, 3375 - kc->efsv_len); 3375 + (domLength)kc->efsv_len); 3376 3376 } else { 3377 3377 if (first) first = 0; 3378 3378 else Tcl_DStringAppend (&dStr, ":", 1); 3379 3379 } 3380 3380 continue; 3381 3381 } 3382 3382 if (frs.nr_nodes != 1) { ................................................................................ 3923 3923 repoolStackElement (sdata, se1); 3924 3924 if (!probeMayskip) { 3925 3925 expectedFlags &= ~EXPECTED_PROBE_MAYSKIP; 3926 3926 } 3927 3927 if (mayskip) break; 3928 3928 } 3929 3929 if (probeMayskip) break; 3930 - Tcl_CreateHashEntry (seenCPs, ic, &hnew); 3930 + Tcl_CreateHashEntry (seenCPs, (char *)ic, &hnew); 3931 3931 if (hnew) { 3932 3932 se1 = getStackElement (sdata, ic); 3933 3933 mayskip = getNextExpectedWorker (sdata, se1, interp, 3934 3934 seenCPs, rObj, 3935 3935 expectedFlags); 3936 3936 repoolStackElement (sdata, se1); 3937 3937 } ................................................................................ 4012 4012 break; 4013 4013 case SCHEMA_CTYPE_PATTERN: 4014 4014 if (recursivePattern (se, jc)) { 4015 4015 break; 4016 4016 } 4017 4017 /* fall through */ 4018 4018 case SCHEMA_CTYPE_INTERLEAVE: 4019 - Tcl_CreateHashEntry (seenCPs, jc, &hnew); 4019 + Tcl_CreateHashEntry (seenCPs, (char *)jc, &hnew); 4020 4020 if (hnew) { 4021 4021 se1 = getStackElement (sdata, jc); 4022 4022 mayskip = getNextExpectedWorker ( 4023 4023 sdata, se1, interp, seenCPs, rObj, 4024 4024 expectedFlags 4025 4025 ); 4026 4026 repoolStackElement (sdata, se1); ................................................................................ 4198 4198 SchemaData *sdata, 4199 4199 Tcl_Interp *interp, 4200 4200 int objc, 4201 4201 Tcl_Obj *const objv[] 4202 4202 ) 4203 4203 { 4204 4204 int methodIndex, expectedFlags; 4205 - Tcl_WideInt line, column, byteIndex; 4205 + XML_Size line, column; 4206 + XML_Index byteIndex; 4206 4207 Tcl_HashEntry *h; 4207 4208 SchemaCP *cp; 4208 4209 SchemaValidationStack *se; 4209 4210 void *ns; 4210 4211 Tcl_Obj *rObj; 4211 4212 4212 4213 static const char *schemaInstanceInfoMethods[] = { ................................................................................ 4535 4536 break; 4536 4537 } 4537 4538 break; 4538 4539 4539 4540 case m_line: 4540 4541 if (!sdata->parser && !sdata->node) break; 4541 4542 if (sdata->parser) { 4542 - SetLongResult (XML_GetCurrentLineNumber (sdata->parser)); 4543 + SetLongResult ((domLength)XML_GetCurrentLineNumber (sdata->parser)); 4543 4544 break; 4544 4545 } 4545 4546 if (domGetLineColumn(sdata->node, &line, &column, &byteIndex) < 0) 4546 4547 break; 4547 - SetLongResult (line); 4548 + SetLongResult ((domLength)line); 4548 4549 break; 4549 4550 4550 4551 case m_column: 4551 4552 if (!sdata->parser && !sdata->node) break; 4552 4553 if (sdata->parser) { 4553 - SetLongResult (XML_GetCurrentColumnNumber (sdata->parser)); 4554 + SetLongResult ((domLength)XML_GetCurrentColumnNumber (sdata->parser)); 4554 4555 break; 4555 4556 } 4556 4557 if (domGetLineColumn(sdata->node, &line, &column, &byteIndex) < 0) 4557 4558 break; 4558 - SetLongResult (column); 4559 + SetLongResult ((domLength)column); 4559 4560 break; 4560 4561 4561 4562 case m_byteIndex: 4562 4563 if (!sdata->parser && !sdata->node) break; 4563 4564 if (sdata->parser) { 4564 - SetLongResult (XML_GetCurrentByteIndex (sdata->parser)); 4565 + SetLongResult ((domLength)XML_GetCurrentByteIndex (sdata->parser)); 4565 4566 break; 4566 4567 } 4567 4568 if (domGetLineColumn(sdata->node, &line, &column, &byteIndex) < 0) 4568 4569 break; 4569 - SetLongResult (byteIndex); 4570 + SetLongResult ((domLength)byteIndex); 4570 4571 break; 4571 4572 4572 4573 case m_domNode: 4573 4574 if (!sdata->node) break; 4574 4575 /* We distinguish between calls from reportCmd and others 4575 4576 * (from scripts called with the tcl cmd). */ 4576 4577 if (sdata->vaction) { ................................................................................ 4628 4629 XML_Parser parser 4629 4630 ) 4630 4631 { 4631 4632 Tcl_Obj *resultObj; 4632 4633 char sl[50], sc[50]; 4633 4634 4634 4635 resultObj = Tcl_NewObj (); 4635 - sprintf(sl, "%" TCL_LL_MODIFIER "d", XML_GetCurrentLineNumber(parser)); 4636 - sprintf(sc, "%" TCL_LL_MODIFIER "d", XML_GetCurrentColumnNumber(parser)); 4636 + sprintf(sl, "%" TDOM_LS_MODIFIER "d", XML_GetCurrentLineNumber(parser)); 4637 + sprintf(sc, "%" TDOM_LS_MODIFIER "d", XML_GetCurrentColumnNumber(parser)); 4637 4638 if (sdata->validationState == VALIDATION_ERROR) { 4638 4639 Tcl_AppendStringsToObj (resultObj, "error \"", 4639 4640 Tcl_GetStringResult (interp), 4640 4641 "\" at line ", sl, " character ", sc, NULL); 4641 4642 } else { 4642 4643 Tcl_AppendStringsToObj (resultObj, "error \"", 4643 4644 XML_ErrorString(XML_GetErrorCode(parser)), ................................................................................ 4676 4677 } 4677 4678 4678 4679 cmdPtr = Tcl_NewStringObj(Tcl_GetString(vdata->externalentitycommandObj), -1); 4679 4680 Tcl_IncrRefCount(cmdPtr); 4680 4681 4681 4682 if (base) { 4682 4683 Tcl_ListObjAppendElement(vdata->interp, cmdPtr, 4683 - Tcl_NewStringObj(base, strlen(base))); 4684 + Tcl_NewStringObj(base, (domLength)strlen(base))); 4684 4685 } else { 4685 4686 Tcl_ListObjAppendElement(vdata->interp, cmdPtr, 4686 4687 Tcl_NewObj()); 4687 4688 } 4688 4689 4689 4690 /* For a document with doctype declaration, the systemId is always 4690 4691 != NULL. But if the document doesn't have a doctype declaration 4691 4692 and the user uses -useForeignDTD 1, the externalEntityRefHandler 4692 4693 will be called with a systemId (and publicId and openEntityNames) 4693 4694 == NULL. */ 4694 4695 if (systemId) { 4695 4696 Tcl_ListObjAppendElement(vdata->interp, cmdPtr, 4696 - Tcl_NewStringObj(systemId, strlen(systemId))); 4697 + Tcl_NewStringObj(systemId, (domLength)strlen(systemId))); 4697 4698 } else { 4698 4699 Tcl_ListObjAppendElement(vdata->interp, cmdPtr, 4699 4700 Tcl_NewObj()); 4700 4701 } 4701 4702 4702 4703 if (publicId) { 4703 4704 Tcl_ListObjAppendElement(vdata->interp, cmdPtr, 4704 - Tcl_NewStringObj(publicId, strlen(publicId))); 4705 + Tcl_NewStringObj(publicId, (domLength)strlen(publicId))); 4705 4706 } else { 4706 4707 Tcl_ListObjAppendElement(vdata->interp, cmdPtr, 4707 4708 Tcl_NewObj()); 4708 4709 } 4709 4710 4710 4711 4711 4712 result = Tcl_EvalObjEx (vdata->interp, cmdPtr, ................................................................................ 4794 4795 if (interpResult[0] == '\0') { 4795 4796 tcldom_reportErrorLocation ( 4796 4797 vdata->interp, 20, 40, XML_GetCurrentLineNumber(extparser), 4797 4798 XML_GetCurrentColumnNumber(extparser), xmlstringstart, 4798 4799 systemId, XML_GetCurrentByteIndex(extparser), 4799 4800 XML_ErrorString(XML_GetErrorCode(extparser))); 4800 4801 } else { 4801 - sprintf(s, "%" TCL_LL_MODIFIER "d", 4802 + sprintf(s, "%" TDOM_LS_MODIFIER "d", 4802 4803 XML_GetCurrentLineNumber(extparser)); 4803 4804 Tcl_AppendResult(vdata->interp, ", referenced in entity \"", 4804 4805 systemId, 4805 4806 "\" at line ", s, " character ", NULL); 4806 - sprintf(s, "%" TCL_LL_MODIFIER "d", 4807 + sprintf(s, "%" TDOM_LS_MODIFIER "d", 4807 4808 XML_GetCurrentColumnNumber(extparser)); 4808 4809 Tcl_AppendResult(vdata->interp, s, NULL); 4809 4810 } 4810 4811 keepresult = 1; 4811 4812 result = 0; 4812 4813 break; 4813 4814 case XML_STATUS_SUSPENDED: ................................................................................ 4821 4822 do { 4822 4823 len = Tcl_Read (chan, buf, sizeof(buf)); 4823 4824 done = len < sizeof(buf); 4824 4825 status = XML_Parse (extparser, buf, (int)len, done); 4825 4826 switch (status) { 4826 4827 case XML_STATUS_ERROR: 4827 4828 interpResult = Tcl_GetStringResult(vdata->interp); 4828 - sprintf(s, "%" TCL_LL_MODIFIER "d", 4829 + sprintf(s, "%" TDOM_LS_MODIFIER "d", 4829 4830 XML_GetCurrentLineNumber(extparser)); 4830 4831 if (interpResult[0] == '\0') { 4831 4832 Tcl_ResetResult (vdata->interp); 4832 4833 Tcl_AppendResult( 4833 4834 vdata->interp, "error \"", 4834 4835 XML_ErrorString(XML_GetErrorCode(extparser)), 4835 4836 "\" in entity \"", systemId, "\" at line ", s, 4836 4837 " character ", NULL 4837 4838 ); 4838 - sprintf(s, "%" TCL_LL_MODIFIER "d", 4839 + sprintf(s, "%" TDOM_LS_MODIFIER "d", 4839 4840 XML_GetCurrentColumnNumber(extparser)); 4840 4841 Tcl_AppendResult(vdata->interp, s, NULL); 4841 4842 } else { 4842 4843 Tcl_AppendResult( 4843 4844 vdata->interp, ", referenced in entity \"", systemId, 4844 4845 "\" at line ", s, " character ", NULL 4845 4846 ); 4846 - sprintf(s, "%" TCL_LL_MODIFIER "d", 4847 + sprintf(s, "%" TDOM_LS_MODIFIER "d", 4847 4848 XML_GetCurrentColumnNumber(extparser)); 4848 4849 Tcl_AppendResult(vdata->interp, s, NULL); 4849 4850 } 4850 4851 result = 0; 4851 4852 keepresult = 1; 4852 4853 done = 1; 4853 4854 break;
Changes to generic/tcldom.c.
216 216 Tcl_Obj * msgcmd; 217 217 } XsltMsgCBInfo; 218 218 219 219 220 220 static void UpdateStringOfTdomNode(Tcl_Obj *objPtr); 221 221 static int SetTdomNodeFromAny(Tcl_Interp *interp, Tcl_Obj *objPtr); 222 222 223 -const Tcl_ObjType tdomNodeType = { 223 +Tcl_ObjType tdomNodeType = { 224 224 "tdom-node", 225 225 NULL, 226 226 NULL, 227 227 UpdateStringOfTdomNode, 228 228 SetTdomNodeFromAny 229 229 }; 230 230 ................................................................................ 436 436 UpdateStringOfTdomNode( 437 437 Tcl_Obj *objPtr) 438 438 { 439 439 char nodeName[80]; 440 440 domLength len; 441 441 442 442 NODE_CMD(nodeName, objPtr->internalRep.otherValuePtr); 443 - len = strlen(nodeName); 443 + len = (domLength)strlen(nodeName); 444 444 objPtr->bytes = (ckalloc((unsigned char) len+1)); 445 445 memcpy(objPtr->bytes, nodeName, len+1); 446 446 objPtr->length = len; 447 447 } 448 448 449 449 /*---------------------------------------------------------------------------- 450 450 | SetTdomNodeFromAny ................................................................................ 1470 1470 const char *varValue; 1471 1471 const char *termPtr; 1472 1472 Tcl_Interp *interp = (Tcl_Interp *) clientData; 1473 1473 1474 1474 *offset = 0; 1475 1475 varValue = Tcl_ParseVar(interp, strToParse, &termPtr); 1476 1476 if (varValue) { 1477 - *offset = termPtr - strToParse; 1477 + *offset = (domLength)(termPtr - strToParse); 1478 1478 /* If strToParse start with a single '$' without a following 1479 1479 * var name (according to Tcl var name rules), Tcl_ParseVar() 1480 1480 * doesn't report a parsing error but returns just a pointer 1481 1481 * to a static string "$". */ 1482 1482 if (*offset == 1) { 1483 1483 *errMsg = tdomstrdup ("Missing var name after '$'."); 1484 1484 varValue = NULL; ................................................................................ 2352 2352 } 2353 2353 } else { 2354 2354 AP(*pc); 2355 2355 } 2356 2356 } 2357 2357 } 2358 2358 if (b >= bLimit) { 2359 - writeChars(xmlString, chan, buf, b - buf); 2359 + writeChars(xmlString, chan, buf, (domLength)(b - buf)); 2360 2360 b = buf; 2361 2361 } 2362 2362 pc++; 2363 2363 } 2364 2364 if (b > buf) { 2365 - writeChars(xmlString, chan, buf, b - buf); 2365 + writeChars(xmlString, chan, buf, (domLength)(b - buf)); 2366 2366 } 2367 2367 } 2368 2368 2369 2369 /*---------------------------------------------------------------------------- 2370 2370 | tcldom_tolower 2371 2371 | 2372 2372 \---------------------------------------------------------------------------*/ ................................................................................ 2677 2677 if (*p == ']') { 2678 2678 p++; i++; 2679 2679 if (i >= ((domTextNode*)node)->valueLength) break; 2680 2680 if (*p == ']') { 2681 2681 p++; i++; 2682 2682 if (i >= ((domTextNode*)node)->valueLength) break; 2683 2683 if (*p == '>') { 2684 - writeChars(xmlString, chan, start, p-start); 2684 + writeChars(xmlString, chan, start, (domLength)(p-start)); 2685 2685 writeChars(xmlString, chan, "]]><![CDATA[>", 13); 2686 2686 start = p+1; 2687 2687 } 2688 2688 } 2689 2689 } 2690 2690 p++; i++; 2691 2691 } 2692 - writeChars(xmlString, chan, start, p-start); 2692 + writeChars(xmlString, chan, start, (domLength)(p-start)); 2693 2693 writeChars(xmlString, chan, "]]>", 3); 2694 2694 } else { 2695 2695 if (node->nodeFlags & DISABLE_OUTPUT_ESCAPING) { 2696 2696 writeChars(xmlString, chan, ((domTextNode*)node)->nodeValue, 2697 2697 ((domTextNode*)node)->valueLength); 2698 2698 } else { 2699 2699 tcldom_AppendEscaped(xmlString, chan, ................................................................................ 2942 2942 for (i = 0; i < clen; i++) { 2943 2943 AP(*pc); 2944 2944 pc++; 2945 2945 } 2946 2946 } 2947 2947 } 2948 2948 if (b >= bLimit) { 2949 - writeChars(jstring, chan, buf, b - buf); 2949 + writeChars(jstring, chan, buf, (domLength)(b - buf)); 2950 2950 b = buf; 2951 2951 } 2952 2952 } 2953 2953 AP('"'); 2954 - writeChars(jstring, chan, buf, b - buf); 2954 + writeChars(jstring, chan, buf, (domLength)(b - buf)); 2955 2955 } 2956 2956 2957 2957 static 2958 2958 void tcldom_childrenAsJSON ( 2959 2959 Tcl_Obj *jstring, 2960 2960 domNode *node, /* Must be an ELEMENT_NODE */ 2961 2961 Tcl_Channel channel, ................................................................................ 4889 4889 domAttrNode *attrs; 4890 4890 domException exception; 4891 4891 char tmp[200], prefix[MAX_PREFIX_LEN], *method, *nodeName, 4892 4892 *str, *attr_name, *attr_val, *filter; 4893 4893 const char *localName, *uri, *nsStr; 4894 4894 int result, methodIndex, i; 4895 4895 domLength length; 4896 - Tcl_WideInt line, column, byteIndex; 4896 + XML_Size line, column; 4897 + XML_Index byteIndex; 4897 4898 int nsIndex, bool, hnew, legacy, jsonType; 4898 4899 Tcl_Obj *namePtr, *resultPtr; 4899 4900 Tcl_Obj *mobjv[MAX_REWRITE_ARGS], *storedErrMsg; 4900 4901 Tcl_CmdInfo cmdInfo; 4901 4902 Tcl_HashEntry *h; 4902 4903 4903 4904 static const char *nodeMethods[] = { ................................................................................ 5847 5848 5848 5849 case m_getLine: 5849 5850 CheckArgs(2,2,2,""); 5850 5851 if (domGetLineColumn(node, &line, &column, &byteIndex) < 0) { 5851 5852 SetResult("no line/column information available!"); 5852 5853 return TCL_ERROR; 5853 5854 } 5854 - SetLongResult(line); 5855 + SetLongResult((domLength)line); 5855 5856 break; 5856 5857 5857 5858 case m_getColumn: 5858 5859 CheckArgs(2,2,2,""); 5859 5860 if (domGetLineColumn (node, &line, &column, &byteIndex) < 0) { 5860 5861 SetResult("no line/column information available!"); 5861 5862 return TCL_ERROR; 5862 5863 } 5863 - SetLongResult(column); 5864 + SetLongResult((domLength)column); 5864 5865 break; 5865 5866 5866 5867 case m_getByteIndex: 5867 5868 CheckArgs(2,2,2,""); 5868 5869 if (domGetLineColumn (node, &line, &column, &byteIndex) < 0) { 5869 5870 SetResult("no position information available!"); 5870 5871 return TCL_ERROR; 5871 5872 } 5872 - SetLongResult(byteIndex); 5873 + SetLongResult((domLength)byteIndex); 5873 5874 break; 5874 5875 5875 5876 case m_getBaseURI: 5876 5877 CheckArgs(2,2,2,""); 5877 5878 /* fall through */ 5878 5879 5879 5880 case m_baseURI: ................................................................................ 6915 6916 /* Helper function to build up the error string message in a central 6916 6917 * place. Caller must provide byteIndex; line is expected to be > 0 if 6917 6918 * line/column information is given. */ 6918 6919 void tcldom_reportErrorLocation ( 6919 6920 Tcl_Interp *interp, 6920 6921 int before, 6921 6922 int after, 6922 - domLength line, 6923 - domLength column, 6923 + XML_Size line, 6924 + XML_Size column, 6924 6925 char *xmlstring, 6925 6926 const char *entity, 6926 - domLength byteIndex, 6927 + XML_Index byteIndex, 6927 6928 const char *errStr 6928 6929 ) 6929 6930 { 6930 6931 char s[200], sb[25], sl[25], sc[25]; 6931 6932 char *d = NULL, *buf; 6932 6933 domLength i, ind; 6933 6934 ................................................................................ 6939 6940 } 6940 6941 Tcl_ResetResult(interp); 6941 6942 Tcl_AppendResult (interp, "error \"", errStr, "\"", NULL); 6942 6943 if (entity) { 6943 6944 Tcl_AppendResult (interp, " in entity \"", entity, "\"", NULL); 6944 6945 } 6945 6946 if (line) { 6946 - sprintf(sl, "%" TCL_SIZE_MODIFIER "d", line); 6947 - sprintf(sc, domLengthConversion, column); 6947 + sprintf(sl, "%" TDOM_LS_MODIFIER "d", line); 6948 + sprintf(sc, "%" TDOM_LS_MODIFIER "d", column); 6948 6949 Tcl_AppendResult (interp, " at line ", sl, " character ", sc, NULL); 6949 6950 6950 6951 } else { 6951 - sprintf(sb, domLengthConversion, byteIndex); 6952 + sprintf(sb, "%" TDOM_LS_MODIFIER "d", byteIndex); 6952 6953 Tcl_AppendResult (interp, " at position ", sb, NULL); 6953 6954 } 6954 6955 if (xmlstring) { 6955 6956 Tcl_AppendResult (interp, "\n\"", NULL); 6956 6957 ind = 0; 6957 6958 buf[0] = '\0'; 6958 - for (i = (byteIndex < before ? 0 : byteIndex - before); 6959 + for (i = (byteIndex < before ? 0 : (domLength)(byteIndex - before)); 6959 6960 i <= byteIndex; 6960 6961 i++) { 6961 6962 buf[ind] = xmlstring[i]; 6962 6963 ind++; 6963 6964 } 6964 6965 buf[ind] = '\0'; 6965 6966 Tcl_AppendResult(interp, buf, " <--Error-- ", NULL); 6966 6967 ind = 0; 6967 6968 buf[0] = '\0'; 6968 6969 if (xmlstring[byteIndex]) { 6969 - for (i = byteIndex + 1; i < byteIndex + after; i++) { 6970 + for (i = (domLength)(byteIndex + 1); i < (domLength)(byteIndex + after); i++) { 6970 6971 if (!xmlstring[i]) { 6971 6972 break; 6972 6973 } 6973 6974 buf[ind] = xmlstring[i]; 6974 6975 ind++; 6975 6976 } 6976 6977 buf[ind] = '\0'; ................................................................................ 7569 7570 * feedback callback) we leave the error msg in 7570 7571 * the interpreter alone. If there wasn't a Tcl 7571 7572 * error, there was a parsing error. Because the 7572 7573 * interp has already an error msg, that parsing 7573 7574 * error was in an external entity. Therefore, we 7574 7575 * just add the place of the referencing entity in 7575 7576 * the main document.*/ 7576 - sprintf(sl, "%" TCL_LL_MODIFIER "d", 7577 + sprintf(sl, "%" TDOM_LS_MODIFIER "d", 7577 7578 XML_GetCurrentLineNumber(parser)); 7578 7579 Tcl_AppendResult(interp, ", referenced at line ", sl, 7579 7580 NULL); 7580 - sprintf(sc, "%" TCL_LL_MODIFIER "d", 7581 + sprintf(sc, "%" TDOM_LS_MODIFIER "d", 7581 7582 XML_GetCurrentColumnNumber(parser)); 7582 7583 Tcl_AppendResult(interp, " character ", sc, NULL); 7583 7584 } 7584 7585 } 7585 7586 XML_ParserFree(parser); 7586 7587 return TCL_ERROR; 7587 7588 }
Changes to generic/tcldom.h.
82 82 int objc, 83 83 Tcl_Obj *const objv[]); 84 84 85 85 void tcldom_reportErrorLocation ( 86 86 Tcl_Interp *interp, 87 87 int before, 88 88 int after, 89 - domLength line, 90 - domLength column, 89 + XML_Size line, 90 + XML_Size column, 91 91 char *xmlstring, 92 92 const char *entity, 93 - domLength byteIndex, 93 + XML_Index byteIndex, 94 94 const char *errStr 95 95 ); 96 96 97 97 #ifdef __cplusplus 98 98 } 99 99 #endif 100 100
Changes to generic/tclexpat.c.
1120 1120 1121 1121 if (!result) { 1122 1122 if (expat->status == ERROR_IN_EXTREFHANDLER) { 1123 1123 Tcl_SetObjResult (interp, expat->result); 1124 1124 } 1125 1125 else { 1126 1126 Tcl_ResetResult(interp); 1127 - sprintf(s, "%" TCL_LL_MODIFIER "d", 1127 + sprintf(s, "%" TDOM_LS_MODIFIER "d", 1128 1128 XML_GetCurrentLineNumber(expat->parser)); 1129 1129 Tcl_AppendResult(interp, "error \"", 1130 1130 XML_ErrorString(XML_GetErrorCode(expat->parser)), 1131 1131 "\" at line ", s, " character ", NULL); 1132 - sprintf(s, "%" TCL_LL_MODIFIER "d", 1132 + sprintf(s, "%" TDOM_LS_MODIFIER "d", 1133 1133 XML_GetCurrentColumnNumber(expat->parser)); 1134 1134 Tcl_AppendResult(interp, s, NULL); 1135 1135 } 1136 1136 if (bufObj) { 1137 1137 Tcl_DecrRefCount (bufObj); 1138 1138 } 1139 1139 return TCL_ERROR; ................................................................................ 2520 2520 * Convert the attribute list into a Tcl key-value paired list. 2521 2521 */ 2522 2522 2523 2523 if (atList == NULL) { 2524 2524 atList = Tcl_NewListObj(0, NULL); 2525 2525 Tcl_IncrRefCount (atList); 2526 2526 for (atPtr = atts; atPtr[0] && atPtr[1]; atPtr += 2) { 2527 - Tcl_ListObjAppendElement(expat->interp, atList, Tcl_NewStringObj((char *)atPtr[0], strlen(atPtr[0]))); 2528 - Tcl_ListObjAppendElement(expat->interp, atList, Tcl_NewStringObj((char *)atPtr[1], strlen(atPtr[1]))); 2527 + Tcl_ListObjAppendElement(expat->interp, atList, Tcl_NewStringObj((char *)atPtr[0], (domLength)strlen(atPtr[0]))); 2528 + Tcl_ListObjAppendElement(expat->interp, atList, Tcl_NewStringObj((char *)atPtr[1], (domLength)strlen(atPtr[1]))); 2529 2529 } 2530 2530 vector[2] = atList; 2531 2531 } 2532 2532 2533 2533 if (activeTclHandlerSet->elementstartObjProc != NULL) { 2534 2534 vector[0] = activeTclHandlerSet->elementstartcommand; 2535 2535 Tcl_IncrRefCount (vector[0]); ................................................................................ 2947 2947 } 2948 2948 2949 2949 if (!expat->cdata) { 2950 2950 expat->cdata = Tcl_NewObj(); 2951 2951 Tcl_IncrRefCount (expat->cdata); 2952 2952 if (expat->keepTextStart) { 2953 2953 if (!expat->cdataStartLine) { 2954 - expat->cdataStartLine = XML_GetCurrentLineNumber (expat->parser); 2955 - expat->cdataStartColumn = XML_GetCurrentColumnNumber (expat->parser); 2956 - expat->cdataStartByteIndex = XML_GetCurrentByteIndex (expat->parser); 2954 + expat->cdataStartLine = (domLength)XML_GetCurrentLineNumber (expat->parser); 2955 + expat->cdataStartColumn = (domLength)XML_GetCurrentColumnNumber (expat->parser); 2956 + expat->cdataStartByteIndex = (domLength)XML_GetCurrentByteIndex (expat->parser); 2957 2957 } 2958 2958 } 2959 2959 } 2960 2960 Tcl_AppendToObj (expat->cdata, s, len); 2961 2961 return; 2962 2962 } 2963 2963 ................................................................................ 3141 3141 * Take a copy of the callback script so that arguments may be appended. 3142 3142 */ 3143 3143 3144 3144 cmdPtr = Tcl_DuplicateObj(activeTclHandlerSet->picommand); 3145 3145 Tcl_IncrRefCount(cmdPtr); 3146 3146 Tcl_Preserve((ClientData) expat->interp); 3147 3147 3148 - Tcl_ListObjAppendElement(expat->interp, cmdPtr, Tcl_NewStringObj((char *)target, strlen(target))); 3149 - Tcl_ListObjAppendElement(expat->interp, cmdPtr, Tcl_NewStringObj((char *)data, strlen(data))); 3148 + Tcl_ListObjAppendElement(expat->interp, cmdPtr, Tcl_NewStringObj((char *)target, (domLength)strlen(target))); 3149 + Tcl_ListObjAppendElement(expat->interp, cmdPtr, Tcl_NewStringObj((char *)data, (domLength)strlen(data))); 3150 3150 result = Tcl_EvalObjEx(expat->interp, cmdPtr, 3151 3151 TCL_EVAL_GLOBAL | TCL_EVAL_DIRECT); 3152 3152 3153 3153 Tcl_DecrRefCount(cmdPtr); 3154 3154 Tcl_Release((ClientData) expat->interp); 3155 3155 3156 3156 TclExpatHandlerResult(expat, activeTclHandlerSet, result); ................................................................................ 3311 3311 * Take a copy of the callback script so that arguments may be appended. 3312 3312 */ 3313 3313 3314 3314 cmdPtr = Tcl_DuplicateObj(activeTclHandlerSet->entityDeclCommand); 3315 3315 Tcl_IncrRefCount(cmdPtr); 3316 3316 Tcl_Preserve((ClientData) expat->interp); 3317 3317 3318 - Tcl_ListObjAppendElement(expat->interp, cmdPtr, Tcl_NewStringObj((char *)entityname, strlen(entityname))); 3318 + Tcl_ListObjAppendElement(expat->interp, cmdPtr, Tcl_NewStringObj((char *)entityname, (domLength)strlen(entityname))); 3319 3319 Tcl_ListObjAppendElement (expat->interp, cmdPtr, Tcl_NewIntObj (is_param)); 3320 3320 if (value == NULL) { 3321 3321 Tcl_ListObjAppendElement (expat->interp, cmdPtr, Tcl_NewListObj (0, NULL)); 3322 3322 } 3323 3323 else { 3324 3324 Tcl_ListObjAppendElement (expat->interp, cmdPtr, Tcl_NewStringObj ((char *) value, length)); 3325 3325 } 3326 3326 if (base == NULL) { 3327 3327 Tcl_ListObjAppendElement (expat->interp, cmdPtr, Tcl_NewListObj (0, NULL)); 3328 3328 } 3329 3329 else { 3330 - Tcl_ListObjAppendElement(expat->interp, cmdPtr, Tcl_NewStringObj((char *)base, strlen(base))); 3330 + Tcl_ListObjAppendElement(expat->interp, cmdPtr, Tcl_NewStringObj((char *)base, (domLength)strlen(base))); 3331 3331 } 3332 3332 if (systemId == NULL) { 3333 3333 Tcl_ListObjAppendElement (expat->interp, cmdPtr, Tcl_NewListObj (0, NULL)); 3334 3334 } else { 3335 - Tcl_ListObjAppendElement(expat->interp, cmdPtr, Tcl_NewStringObj((char *)systemId, strlen(systemId))); 3335 + Tcl_ListObjAppendElement(expat->interp, cmdPtr, Tcl_NewStringObj((char *)systemId, (domLength)strlen(systemId))); 3336 3336 } 3337 3337 if (publicId == NULL) { 3338 3338 Tcl_ListObjAppendElement(expat->interp, cmdPtr, Tcl_NewListObj(0, NULL)); 3339 3339 } else { 3340 - Tcl_ListObjAppendElement(expat->interp, cmdPtr, Tcl_NewStringObj((char *)publicId, strlen(publicId))); 3340 + Tcl_ListObjAppendElement(expat->interp, cmdPtr, Tcl_NewStringObj((char *)publicId, (domLength)strlen(publicId))); 3341 3341 } 3342 3342 if (notationName == NULL) { 3343 3343 Tcl_ListObjAppendElement(expat->interp, cmdPtr, Tcl_NewListObj(0, NULL)); 3344 3344 } else { 3345 - Tcl_ListObjAppendElement(expat->interp, cmdPtr, Tcl_NewStringObj((char *)notationName, strlen(notationName))); 3345 + Tcl_ListObjAppendElement(expat->interp, cmdPtr, Tcl_NewStringObj((char *)notationName, (domLength)strlen(notationName))); 3346 3346 } 3347 3347 result = Tcl_EvalObjEx(expat->interp, cmdPtr, 3348 3348 TCL_EVAL_GLOBAL | TCL_EVAL_DIRECT); 3349 3349 3350 3350 Tcl_DecrRefCount(cmdPtr); 3351 3351 Tcl_Release((ClientData) expat->interp); 3352 3352 ................................................................................ 3423 3423 * Take a copy of the callback script so that arguments may be appended. 3424 3424 */ 3425 3425 3426 3426 cmdPtr = Tcl_DuplicateObj(activeTclHandlerSet->notationcommand); 3427 3427 Tcl_IncrRefCount(cmdPtr); 3428 3428 Tcl_Preserve((ClientData) expat->interp); 3429 3429 3430 - Tcl_ListObjAppendElement(expat->interp, cmdPtr, Tcl_NewStringObj((char *)notationName, strlen(notationName))); 3431 - Tcl_ListObjAppendElement(expat->interp, cmdPtr, Tcl_NewStringObj((char *)base, strlen(base))); 3430 + Tcl_ListObjAppendElement(expat->interp, cmdPtr, Tcl_NewStringObj((char *)notationName, (domLength)strlen(notationName))); 3431 + Tcl_ListObjAppendElement(expat->interp, cmdPtr, Tcl_NewStringObj((char *)base, (domLength)strlen(base))); 3432 3432 if (systemId == NULL) { 3433 3433 Tcl_ListObjAppendElement(expat->interp, cmdPtr, Tcl_NewListObj(0, NULL)); 3434 3434 } else { 3435 - Tcl_ListObjAppendElement(expat->interp, cmdPtr, Tcl_NewStringObj((char *)systemId, strlen(systemId))); 3435 + Tcl_ListObjAppendElement(expat->interp, cmdPtr, Tcl_NewStringObj((char *)systemId, (domLength)strlen(systemId))); 3436 3436 } 3437 3437 if (publicId == NULL) { 3438 3438 Tcl_ListObjAppendElement(expat->interp, cmdPtr, Tcl_NewListObj(0, NULL)); 3439 3439 } else { 3440 - Tcl_ListObjAppendElement(expat->interp, cmdPtr, Tcl_NewStringObj((char *)publicId, strlen(publicId))); 3440 + Tcl_ListObjAppendElement(expat->interp, cmdPtr, Tcl_NewStringObj((char *)publicId, (domLength)strlen(publicId))); 3441 3441 } 3442 3442 result = Tcl_EvalObjEx(expat->interp, cmdPtr, 3443 3443 TCL_EVAL_GLOBAL | TCL_EVAL_DIRECT); 3444 3444 3445 3445 Tcl_DecrRefCount(cmdPtr); 3446 3446 Tcl_Release((ClientData) expat->interp); 3447 3447 ................................................................................ 3573 3573 3574 3574 cmdPtr = Tcl_DuplicateObj(activeTclHandlerSet->externalentitycommand); 3575 3575 Tcl_IncrRefCount(cmdPtr); 3576 3576 Tcl_Preserve((ClientData) expat->interp); 3577 3577 3578 3578 if (base) { 3579 3579 Tcl_ListObjAppendElement(expat->interp, cmdPtr, 3580 - Tcl_NewStringObj((char *)base, strlen(base))); 3580 + Tcl_NewStringObj((char *)base, (domLength)strlen(base))); 3581 3581 } else { 3582 3582 Tcl_ListObjAppendElement(expat->interp, cmdPtr, 3583 3583 Tcl_NewStringObj("", 0)); 3584 3584 } 3585 3585 3586 3586 if (systemId) { 3587 3587 Tcl_ListObjAppendElement(expat->interp, cmdPtr, 3588 - Tcl_NewStringObj((char *)systemId, strlen(systemId))); 3588 + Tcl_NewStringObj((char *)systemId, (domLength)strlen(systemId))); 3589 3589 } else { 3590 3590 Tcl_ListObjAppendElement(expat->interp, cmdPtr, 3591 3591 Tcl_NewStringObj("", 0)); 3592 3592 } 3593 3593 3594 3594 if (publicId) { 3595 3595 Tcl_ListObjAppendElement(expat->interp, cmdPtr, 3596 - Tcl_NewStringObj((char *)publicId, strlen(publicId))); 3596 + Tcl_NewStringObj((char *)publicId, (domLength)strlen(publicId))); 3597 3597 } else { 3598 3598 Tcl_ListObjAppendElement(expat->interp, cmdPtr, 3599 3599 Tcl_NewStringObj("", 0)); 3600 3600 } 3601 3601 3602 3602 result = Tcl_EvalObjEx(expat->interp, cmdPtr, 3603 3603 TCL_EVAL_GLOBAL | TCL_EVAL_DIRECT); ................................................................................ 3764 3764 } 3765 3765 break; 3766 3766 } 3767 3767 3768 3768 Tcl_DecrRefCount (resultObj); 3769 3769 if (!result) { 3770 3770 Tcl_ResetResult (expat->interp); 3771 - sprintf(s, "%" TCL_LL_MODIFIER "d", 3771 + sprintf(s, "%" TDOM_LS_MODIFIER "d", 3772 3772 XML_GetCurrentLineNumber(extparser)); 3773 3773 Tcl_AppendResult(expat->interp, "Not wellformed error \"", 3774 3774 XML_ErrorString(XML_GetErrorCode(extparser)), 3775 3775 "\" while parsing external entity: \n\t", 3776 3776 systemId, "\nat line ", s, " character ", NULL); 3777 - sprintf(s, "%" TCL_LL_MODIFIER "d", 3777 + sprintf(s, "%" TDOM_LS_MODIFIER "d", 3778 3778 XML_GetCurrentColumnNumber(extparser)); 3779 3779 Tcl_AppendResult(expat->interp, s, NULL); 3780 3780 XML_ParserFree (extparser); 3781 3781 expat->parser = oldparser; 3782 3782 TclExpatHandlerResult(expat, activeTclHandlerSet, 3783 3783 ERROR_IN_EXTREFHANDLER); 3784 3784 return 0; ................................................................................ 3889 3889 } 3890 3890 3891 3891 cmdPtr = Tcl_DuplicateObj(activeTclHandlerSet->commentCommand); 3892 3892 Tcl_IncrRefCount(cmdPtr); 3893 3893 Tcl_Preserve((ClientData) expat->interp); 3894 3894 3895 3895 Tcl_ListObjAppendElement(expat->interp, cmdPtr, 3896 - Tcl_NewStringObj((char *)data, strlen(data))); 3896 + Tcl_NewStringObj((char *)data, (domLength)strlen(data))); 3897 3897 3898 3898 result = Tcl_EvalObjEx(expat->interp, cmdPtr, 3899 3899 TCL_EVAL_GLOBAL | TCL_EVAL_DIRECT); 3900 3900 3901 3901 Tcl_DecrRefCount(cmdPtr); 3902 3902 Tcl_Release((ClientData) expat->interp); 3903 3903 ................................................................................ 4264 4264 if (activeTclHandlerSet->elementDeclCommand == NULL) { 4265 4265 goto nextTcl; 4266 4266 } 4267 4267 4268 4268 cmdPtr = Tcl_DuplicateObj(activeTclHandlerSet->elementDeclCommand); 4269 4269 Tcl_IncrRefCount(cmdPtr); 4270 4270 Tcl_ListObjAppendElement(expat->interp, cmdPtr, 4271 - Tcl_NewStringObj((char *)name, strlen(name))); 4271 + Tcl_NewStringObj((char *)name, (domLength)strlen(name))); 4272 4272 4273 4273 4274 4274 content = Tcl_NewListObj (0, NULL); 4275 4275 generateModel (expat->interp, content, model); 4276 4276 4277 4277 Tcl_ListObjAppendElement(expat->interp, cmdPtr, content); 4278 4278 ................................................................................ 4353 4353 } 4354 4354 4355 4355 cmdPtr = Tcl_DuplicateObj(activeTclHandlerSet->attlistDeclCommand); 4356 4356 Tcl_IncrRefCount(cmdPtr); 4357 4357 Tcl_Preserve((ClientData) expat->interp); 4358 4358 4359 4359 Tcl_ListObjAppendElement(expat->interp, cmdPtr, 4360 - Tcl_NewStringObj((char *)elname, strlen (elname))); 4360 + Tcl_NewStringObj((char *)elname, (domLength)strlen (elname))); 4361 4361 Tcl_ListObjAppendElement(expat->interp, cmdPtr, 4362 - Tcl_NewStringObj((char *)name, strlen (name))); 4362 + Tcl_NewStringObj((char *)name, (domLength)strlen (name))); 4363 4363 Tcl_ListObjAppendElement(expat->interp, cmdPtr, 4364 - Tcl_NewStringObj((char *)type, strlen (type))); 4364 + Tcl_NewStringObj((char *)type, (domLength)strlen (type))); 4365 4365 if (!dflt) { 4366 4366 Tcl_ListObjAppendElement (expat->interp, cmdPtr, 4367 4367 Tcl_NewStringObj ("", 0)); 4368 4368 } 4369 4369 else { 4370 4370 Tcl_ListObjAppendElement (expat->interp, cmdPtr, 4371 - Tcl_NewStringObj ((char*)dflt, strlen (dflt))); 4371 + Tcl_NewStringObj ((char*)dflt, (domLength)strlen (dflt))); 4372 4372 } 4373 4373 Tcl_ListObjAppendElement (expat->interp, cmdPtr, 4374 4374 Tcl_NewIntObj (isrequired)); 4375 4375 4376 4376 result = Tcl_EvalObjEx(expat->interp, cmdPtr, 4377 4377 TCL_EVAL_GLOBAL | TCL_EVAL_DIRECT); 4378 4378 ................................................................................ 4450 4450 } 4451 4451 4452 4452 cmdPtr = Tcl_DuplicateObj(activeTclHandlerSet->startDoctypeDeclCommand); 4453 4453 Tcl_IncrRefCount(cmdPtr); 4454 4454 Tcl_Preserve((ClientData) expat->interp); 4455 4455 4456 4456 Tcl_ListObjAppendElement(expat->interp, cmdPtr, 4457 - Tcl_NewStringObj((char *)doctypeName, strlen(doctypeName))); 4457 + Tcl_NewStringObj((char *)doctypeName, (domLength)strlen(doctypeName))); 4458 4458 if (sysid != NULL) { 4459 4459 Tcl_ListObjAppendElement(expat->interp, cmdPtr, 4460 - Tcl_NewStringObj((char *)sysid, strlen(sysid))); 4460 + Tcl_NewStringObj((char *)sysid, (domLength)strlen(sysid))); 4461 4461 } else { 4462 4462 Tcl_ListObjAppendElement(expat->interp, cmdPtr, 4463 4463 Tcl_NewStringObj("NULL", 4)); 4464 4464 } 4465 4465 if (pubid != NULL) { 4466 4466 Tcl_ListObjAppendElement(expat->interp, cmdPtr, 4467 - Tcl_NewStringObj((char *)pubid, strlen(sysid))); 4467 + Tcl_NewStringObj((char *)pubid, (domLength)strlen(sysid))); 4468 4468 } else { 4469 4469 Tcl_ListObjAppendElement(expat->interp, cmdPtr, 4470 4470 Tcl_NewStringObj("NULL", 4)); 4471 4471 } 4472 4472 Tcl_ListObjAppendElement(expat->interp, cmdPtr, 4473 4473 Tcl_NewIntObj(has_internal_subset)); 4474 4474
Changes to generic/tclpull.c.
372 372 Tcl_Interp *interp, 373 373 tDOM_PullParserInfo *pullInfo 374 374 ) 375 375 { 376 376 char s[255]; 377 377 378 378 Tcl_ResetResult (interp); 379 - sprintf(s, "%" TCL_LL_MODIFIER "d", 379 + sprintf(s, "%" TDOM_LS_MODIFIER "d", 380 380 XML_GetCurrentLineNumber(pullInfo->parser)); 381 381 Tcl_AppendResult(interp, "error \"", 382 382 XML_ErrorString( 383 383 XML_GetErrorCode(pullInfo->parser)), 384 384 "\" at line ", s, " column ", NULL); 385 - sprintf(s, "%" TCL_LL_MODIFIER "d", 385 + sprintf(s, "%" TDOM_LS_MODIFIER "d", 386 386 XML_GetCurrentColumnNumber(pullInfo->parser)); 387 387 Tcl_AppendResult(interp, s, NULL); 388 388 } 389 389 390 390 static void 391 391 tDOM_CleanupInputSource ( 392 392 tDOM_PullParserInfo *pullInfo
Changes to generic/xmlsimple.c.
399 399 * text nodes */ 400 400 tnode = (domTextNode*)parent_node->lastChild; 401 401 tnode->nodeValue = REALLOC(tnode->nodeValue, 402 402 tnode->valueLength + x - start + 1); 403 403 memmove(tnode->nodeValue + tnode->valueLength, 404 404 start, x - start); 405 405 saved = tnode->valueLength; 406 - tnode->valueLength += (x - start); 406 + tnode->valueLength += (domLength)(x - start); 407 407 *(tnode->nodeValue + tnode->valueLength) = 0; 408 408 if (ampersandSeen) { 409 409 if (!TranslateEntityRefs(tnode->nodeValue + saved, 410 410 &(tnode->valueLength) )) { 411 - RetError("Entity parsing error", (x - xml)); 411 + RetError("Entity parsing error", (domLength)(x - xml)); 412 412 } 413 413 tnode->valueLength += saved; 414 414 } 415 415 } else { 416 416 /*-------------------------------------------------------- 417 417 | allocate new TEXT node 418 418 \-------------------------------------------------------*/ 419 419 tnode = (domTextNode*) domAlloc(sizeof(domTextNode)); 420 420 memset(tnode, 0, sizeof(domTextNode)); 421 421 tnode->nodeType = TEXT_NODE; 422 422 tnode->ownerDocument = doc; 423 423 tnode->nodeNumber = NODE_NO(doc); 424 - tnode->valueLength = (x - start); 424 + tnode->valueLength = (domLength)(x - start); 425 425 tnode->nodeValue = (char*)MALLOC((x - start)+1); 426 426 memmove(tnode->nodeValue, start, (x - start)); 427 427 *(tnode->nodeValue + (x - start)) = 0; 428 428 tnode->parentNode = parent_node; 429 429 if (parent_node->firstChild) { 430 430 parent_node->lastChild->nextSibling = (domNode*)tnode; 431 431 tnode->previousSibling = parent_node->lastChild; ................................................................................ 433 433 } else { 434 434 parent_node->firstChild = parent_node->lastChild = 435 435 (domNode*)tnode; 436 436 } 437 437 if (ampersandSeen) { 438 438 if (!TranslateEntityRefs(tnode->nodeValue, 439 439 &(tnode->valueLength) )) { 440 - RetError("Entity parsing error", (x - xml)); 440 + RetError("Entity parsing error", (domLength)(x - xml)); 441 441 } 442 442 } 443 443 } 444 444 } 445 445 446 446 } else if (x[1]=='/') { 447 447 /*------------------------------------------------------------ 448 448 | read and check closing tag 449 449 \-----------------------------------------------------------*/ 450 450 node = parent_node; 451 451 if (!parent_node) { 452 - RetError("Syntax error",(x - xml)); 452 + RetError("Syntax error", (domLength)(x - xml)); 453 453 } 454 454 parent_node = node->parentNode; 455 455 pn = (char*)node->nodeName; 456 456 457 457 x += 2; 458 458 while (*x == *pn) { x++; pn++; } 459 459 if ( *pn || (*x!='>' && !SPACE(*x) ) ) { 460 - RetError("Unterminated element",(x - xml)); 460 + RetError("Unterminated element", (domLength)(x - xml)); 461 461 } 462 462 while (SPACE(*x)) { 463 463 x++; 464 464 } 465 465 if (*x=='>') { 466 466 x++; 467 467 } else { 468 - RetError("Missing \">\"",(x - xml)-1); 468 + RetError("Missing \">\"",((domLength)(x - xml))-1); 469 469 } 470 470 #ifdef TDOM_NS 471 471 depth--; 472 472 /* pop active namespaces */ 473 473 while ( (activeNSpos >= 0) && 474 474 (activeNS[activeNSpos].depth == depth) ) 475 475 { ................................................................................ 504 504 \---------------------------------------------------*/ 505 505 tnode = (domTextNode*) domAlloc(sizeof(domTextNode)); 506 506 memset(tnode, 0, sizeof(domTextNode)); 507 507 tnode->nodeType = COMMENT_NODE; 508 508 tnode->ownerDocument = doc; 509 509 tnode->nodeNumber = NODE_NO(doc); 510 510 tnode->parentNode = parent_node; 511 - tnode->valueLength = x - start - 4; 511 + tnode->valueLength = (domLength)(x - start - 4); 512 512 tnode->nodeValue = (char*)MALLOC(tnode->valueLength+1); 513 513 memmove(tnode->nodeValue, start+4, tnode->valueLength); 514 514 *(tnode->nodeValue + tnode->valueLength) = 0; 515 515 if (parent_node == NULL) { 516 516 if (doc->rootNode->lastChild) { 517 517 tnode->previousSibling = 518 518 doc->rootNode->lastChild; ................................................................................ 529 529 parent_node->lastChild = (domNode*)tnode; 530 530 } else { 531 531 parent_node->firstChild = parent_node->lastChild = (domNode*)tnode; 532 532 } 533 533 } 534 534 x += 3; 535 535 } else { 536 - RetError("Unterminated comment",(start-xml)); 536 + RetError("Unterminated comment",(domLength)(start-xml)); 537 537 } 538 538 continue; 539 539 540 540 } else if (x[1]=='D' && x[2]=='O' && 541 541 x[3]=='C' && x[4]=='T' && 542 542 x[5]=='Y' && x[6]=='P' && x[7]=='E' ) { 543 543 /*-------------------------------------------------------- ................................................................................ 555 555 } else { 556 556 x++; 557 557 } 558 558 } 559 559 if (*x) { 560 560 x++; 561 561 } else { 562 - RetError("Unterminated DOCTYPE definition",(start-xml)); 562 + RetError("Unterminated DOCTYPE definition", 563 + (domLength)(start-xml)); 563 564 } 564 565 continue; 565 566 566 567 } else if (x[1]=='[' && x[2]=='C' && 567 568 x[3]=='D' && x[4]=='A' && 568 569 x[5]=='T' && x[6]=='A' && x[7]=='[' ) { 569 570 /*-------------------------------------------------------- ................................................................................ 592 593 /* normalize text node, i.e. there 593 594 * are no adjacent text nodes */ 594 595 tnode = (domTextNode*)parent_node->lastChild; 595 596 tnode->nodeValue = 596 597 REALLOC(tnode->nodeValue, 597 598 tnode->valueLength + x - start + 1); 598 599 memmove(tnode->nodeValue + tnode->valueLength, 599 - start, x - start); 600 - tnode->valueLength += (x - start); 600 + start, (x - start)); 601 + tnode->valueLength += (domLength)(x - start); 601 602 *(tnode->nodeValue + tnode->valueLength) = 0; 602 603 } 603 604 } else { 604 605 if (!(only_whites && ignoreWhiteSpaces) 605 606 && ((x - start) || keepCDATA)) { 606 607 /*---------------------------------------------------- 607 608 | allocate new node for CDATA section data ................................................................................ 611 612 if (keepCDATA) 612 613 tnode->nodeType = CDATA_SECTION_NODE; 613 614 else 614 615 tnode->nodeType = TEXT_NODE; 615 616 tnode->ownerDocument = doc; 616 617 tnode->nodeNumber = NODE_NO(doc); 617 618 tnode->parentNode = parent_node; 618 - tnode->valueLength = (x - start); 619 + tnode->valueLength = (domLength)(x - start); 619 620 tnode->nodeValue = (char*)MALLOC((x - start)+1); 620 621 memmove(tnode->nodeValue, start, (x - start)); 621 622 *(tnode->nodeValue + (x - start)) = 0; 622 623 if (parent_node->firstChild) { 623 624 parent_node->lastChild->nextSibling = (domNode*)tnode; 624 625 tnode->previousSibling = parent_node->lastChild; 625 626 parent_node->lastChild = (domNode*)tnode; ................................................................................ 627 628 parent_node->firstChild = parent_node->lastChild = (domNode*)tnode; 628 629 } 629 630 } 630 631 } 631 632 } 632 633 x += 3; 633 634 } else { 634 - RetError("Unterminated CDATA definition",(start-xml) ); 635 + RetError("Unterminated CDATA definition",(domLength)(start-xml) ); 635 636 } 636 637 continue; 637 638 } else { 638 - RetError("Incorrect <!... tag",(start-xml) ); 639 + RetError("Incorrect <!... tag",(domLength)(start-xml)); 639 640 } 640 641 641 642 } else if (*x=='?') { 642 643 /*-------------------------------------------------------- 643 644 | read over a processing instructions(PI) / XMLDecl 644 645 \-------------------------------------------------------*/ 645 646 x++; ................................................................................ 666 667 piSep = start; 667 668 while ( (c=*piSep)!=0 && !SPACE(c) && 668 669 (c!='?' || piSep[1]!='>')) { 669 670 piSep++; 670 671 } 671 672 *piSep = '\0'; /* temporarily terminate the string */ 672 673 673 - pinode->targetLength = strlen(start); 674 + pinode->targetLength = (domLength)strlen(start); 674 675 pinode->targetValue = (char*)MALLOC(pinode->targetLength); 675 676 memmove(pinode->targetValue, start, pinode->targetLength); 676 677 677 678 *piSep = c; /* remove temporarily termination */ 678 679 679 680 /*------------------------------------------------- 680 681 | extract PI data 681 682 \------------------------------------------------*/ 682 683 while (SPACE(*piSep)) { 683 684 piSep++; 684 685 } 685 - pinode->dataLength = x - piSep; 686 + pinode->dataLength = (domLength)(x - piSep); 686 687 pinode->dataValue = (char*)MALLOC(pinode->dataLength); 687 688 memmove(pinode->dataValue, piSep, pinode->dataLength); 688 689 689 690 if (parent_node == NULL) { 690 691 if (doc->rootNode->lastChild) { 691 692 pinode->previousSibling = doc->rootNode->lastChild; 692 693 doc->rootNode->lastChild->nextSibling ................................................................................ 702 703 parent_node->lastChild = (domNode*)pinode; 703 704 } else { 704 705 parent_node->firstChild = parent_node->lastChild = (domNode*)pinode; 705 706 } 706 707 } 707 708 x += 2; 708 709 } else { 709 - RetError("Unterminated processing instruction(PI)",(start-xml) ); 710 + RetError("Unterminated processing instruction(PI)",(domLength)(start-xml) ); 710 711 } 711 712 continue; 712 713 } 713 714 714 715 /*---------------------------------------------------------------- 715 716 | new tag/element 716 717 | 717 718 \---------------------------------------------------------------*/ 718 719 hasContent = 1; 719 720 while ((c=*x)!=0 && c!='/' && c!='>' && !SPACE(c) ) { 720 721 x++; 721 722 } 722 723 if (c==0) { 723 - RetError("Missing \">\"",(start-xml) ); 724 + RetError("Missing \">\"",(domLength)(start-xml) ); 724 725 } 725 726 if ( (x-start)==1) { 726 - RetError("Null markup name",(start-xml) ); 727 + RetError("Null markup name",(domLength)(start-xml) ); 727 728 } 728 729 *x = '\0'; /* temporarily terminate the string */ 729 730 730 731 /*------------------------------------------------------ 731 732 | create new DOM element node 732 733 \-----------------------------------------------------*/ 733 734 h = Tcl_CreateHashEntry(&HASHTAB(doc,tdom_tagNames), start+1, ................................................................................ 778 779 domLength nArgName; 779 780 char *ArgVal = NULL; 780 781 domLength nArgVal = 0; 781 782 782 783 while ((c=*x)!=0 && c!='=' && c!='>' && !SPACE(c) ) { 783 784 x++; 784 785 } 785 - nArgName = x - ArgName; 786 + nArgName = (domLength)(x - ArgName); 786 787 while (SPACE(*x)) { 787 788 x++; 788 789 } 789 790 if (*x=='=') { 790 791 x++; 791 792 } 792 793 savedChar = *(ArgName + nArgName); ................................................................................ 805 806 ampersandSeen = 0; 806 807 while ((c=*x)!=0 && c!=cDelim) { 807 808 if (c=='&') { 808 809 ampersandSeen = 1; 809 810 } 810 811 x++; 811 812 } 812 - nArgVal = x - ArgVal; 813 + nArgVal = (domLength)(x - ArgVal); 813 814 if (c==0) { 814 - RetError("Unterminated string",(ArgVal - xml - 1) ); 815 + RetError("Unterminated string",(domLength)(ArgVal - xml - 1)); 815 816 } else { 816 817 x++; 817 818 } 818 819 } else if (c!=0 && c!='>') { 819 820 ArgVal = x; 820 821 while ((c=*x)!=0 && c!='>' && !SPACE(c)) { 821 822 if (c=='&') { 822 823 ampersandSeen = 1; 823 824 } 824 825 x++; 825 826 } 826 827 if (c==0) { 827 - RetError("Missing \">\"",(start-xml)); 828 + RetError("Missing \">\"",(domLength)(start-xml)); 828 829 } 829 - nArgVal = x - ArgVal; 830 + nArgVal = (domLength)(x - ArgVal); 830 831 } 831 832 832 833 833 834 #ifdef TDOM_NS 834 835 /*------------------------------------------------------------ 835 836 | handle namespace attributes or normal ones 836 837 \------------------------------------------------------------*/ ................................................................................ 849 850 attrnode->nodeValue = (char*)MALLOC(nArgVal+1); 850 851 attrnode->valueLength = nArgVal; 851 852 memmove(attrnode->nodeValue, ArgVal, nArgVal); 852 853 *(attrnode->nodeValue + nArgVal) = 0; 853 854 if (ampersandSeen) { 854 855 if (!TranslateEntityRefs(attrnode->nodeValue, 855 856 &(attrnode->valueLength) )) { 856 - RetError("Entity parsing error",(start-xml)); 857 + RetError("Entity parsing error",(domLength)(start-xml)); 857 858 } 858 859 } 859 860 860 861 if (xmlns[5] == ':') { 861 862 if (domIsNamespaceInScope (activeNS, activeNSpos, 862 863 &(xmlns[6]), 863 864 (char*)attrnode->nodeValue)) ................................................................................ 910 911 attrnode->nodeValue = (char*)MALLOC(nArgVal+1); 911 912 attrnode->valueLength = nArgVal; 912 913 memmove(attrnode->nodeValue, ArgVal, nArgVal); 913 914 *(attrnode->nodeValue + nArgVal) = 0; 914 915 if (ampersandSeen) { 915 916 if (!TranslateEntityRefs(attrnode->nodeValue, 916 917 &(attrnode->valueLength) )) { 917 - RetError("Entity parsing error", (start - xml)); 918 + RetError("Entity parsing error", (domLength)(start - xml)); 918 919 } 919 920 } 920 921 if (attrList) { 921 922 lastAttr->nextSibling = attrnode; 922 923 } else { 923 924 attrList = attrnode; 924 925 } ................................................................................ 994 995 node->firstAttr = attrList; 995 996 996 997 #endif 997 998 if (*x=='/') { 998 999 hasContent = 0; 999 1000 x++; 1000 1001 if (*x!='>') { 1001 - RetError("Syntax Error",(x - xml - 1) ); 1002 + RetError("Syntax Error",(domLength)(x - xml - 1)); 1002 1003 } 1003 1004 #ifdef TDOM_NS 1004 1005 /* pop active namespaces */ 1005 1006 while ( (activeNSpos >= 0) && 1006 1007 (activeNS[activeNSpos].depth == depth) ) 1007 1008 { 1008 1009 activeNSpos--; ................................................................................ 1029 1030 } 1030 1031 } 1031 1032 } 1032 1033 if (forest && parent_node == parent) { 1033 1034 FREE ((char *) activeNS); 1034 1035 return TCL_OK; 1035 1036 } 1036 - RetError("Unexpected end",(x - xml) ); 1037 + RetError("Unexpected end",(domLength)(x - xml)); 1037 1038 1038 1039 } /* XML_SimpleParse */ 1039 1040 1040 1041 1041 1042 1042 1043 /*---------------------------------------------------------------------------- 1043 1044 | XML_SimpleParseDocument
Changes to tdom.m4.
709 709 TDOM_STUB_LIB_SPEC=${TDOM_BUILD_STUB_LIB_SPEC} 710 710 fi 711 711 AC_SUBST(TDOM_VERSION) 712 712 AC_SUBST(TDOM_STUB_LIB_SPEC) 713 713 AC_SUBST(TDOM_SRC_DIR) 714 714 ]) 715 715 716 -#------------------------------------------------------------------------ 717 -# TDOM_EXPORT_CONFIG -- 718 -# 719 -# Define the data to insert into the ${PACKAGE_NAME}Config.sh file 720 -# 721 -# Arguments: 722 -# None 723 -# 724 -# Results: 725 -# Subst the following vars: 726 -# 727 -#------------------------------------------------------------------------ 728 - 729 -AC_DEFUN(TDOM_EXPORT_CONFIG, [ 730 - #-------------------------------------------------------------------- 731 - # These are for ${PACKAGE_NAME}Config.sh 732 - #-------------------------------------------------------------------- 733 - 734 - # pkglibdir must be a fully qualified path and (not ${exec_prefix}/lib) 735 - eval pkglibdir="[$]{libdir}/${PACKAGE_NAME}${PACKAGE_VERSION}" 736 - if test "${TCL_LIB_VERSIONS_OK}" = "ok"; then 737 - eval PKG_STUB_LIB_FLAG="-l${PACKAGE_NAME}stub${PACKAGE_VERSION}" 738 - else 739 - eval PKG_STUB_LIB_FLAG="-l${PACKAGE_NAME}stub`echo ${PACKAGE_VERSION} | tr -d .`" 740 - fi 741 - PKG_BUILD_STUB_LIB_SPEC="-L`pwd` ${PKG_STUB_LIB_FLAG}" 742 - PKG_STUB_LIB_SPEC="-L${pkglibdir} ${PKG_STUB_LIB_FLAG}" 743 - PKG_BUILD_STUB_LIB_PATH="`pwd`/[$]{PKG_STUB_LIB_FILE}" 744 - PKG_STUB_LIB_PATH="${pkglibdir}/[$]{PKG_STUB_LIB_FILE}" 745 - 746 - AC_SUBST(PKG_BUILD_STUB_LIB_SPEC) 747 - AC_SUBST(PKG_STUB_LIB_SPEC) 748 - AC_SUBST(PKG_BUILD_STUB_LIB_PATH) 749 - AC_SUBST(PKG_STUB_LIB_PATH) 750 -]) 751 - 752 716 # Local Variables: 753 717 # mode: autoconf 754 718 # End: 755 719 # EOF
Changes to tdomConfig.sh.in.
29 29 # 30 30 TDOM_STUB_LIB_FILE=@PKG_STUB_LIB_FILE@ 31 31 32 32 # 33 33 # String to pass to linker to pick up the tDOM library from 34 34 # its build directory. 35 35 # 36 -TDOM_BUILD_STUB_LIB_SPEC='@PKG_BUILD_STUB_LIB_SPEC@' 36 +TDOM_BUILD_STUB_LIB_SPEC='@tdom_BUILD_STUB_LIB_SPEC@' 37 37 38 38 # 39 39 # String to pass to linker to pick up the tDOM library from 40 40 # its installed directory. 41 41 # 42 -TDOM_STUB_LIB_SPEC='@PKG_STUB_LIB_SPEC@' 42 +TDOM_STUB_LIB_SPEC='@tdom_STUB_LIB_SPEC@' 43 43 44 44 # String to pass to linker to pick up the TDOM stub library from its 45 45 # build directory. 46 46 # 47 -TDOM_BUILD_STUB_LIB_PATH='@PKG_BUILD_STUB_LIB_PATH@' 47 +TDOM_BUILD_STUB_LIB_PATH='@tdom_BUILD_STUB_LIB_PATH@' 48 48 49 49 # String to pass to linker to pick up the TDOM stub library from its 50 50 # installed directory. 51 51 # 52 -TDOM_STUB_LIB_PATH='@PKG_STUB_LIB_PATH@' 52 +TDOM_STUB_LIB_PATH='@tdom_STUB_LIB_PATH@' 53 53 54 54 # 55 55 # Location of the top-level source directories from which tDOM 56 56 # was built. This is the directory that contains generic, unix, 57 57 # win etc. If tDOM was compiled in a different place than the 58 58 # directory containing the source files, this points to the 59 59 # location of the sources, not the location where tDOM was compiled. 60 60 # 61 61 TDOM_SRC_DIR='@srcdir@' 62 62 63 63 # EOF