1.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     1.2 +++ b/.hgignore	Wed Jan 14 06:51:16 2015 +0200
     1.3 @@ -0,0 +1,6 @@
     1.4 +\.o$
     1.5 +\.swp$
     1.6 +\.d$
     1.7 +^Samples/
     1.8 +^Firmware/
     1.9 +^ConfigUtil/

     2.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     2.2 +++ b/3rdParty/EDID/edid.cpp	Wed Jan 14 06:51:16 2015 +0200
     2.3 @@ -0,0 +1,446 @@
     2.4 +/*
     2.5 + * Copyright 2007 Red Hat, Inc.
     2.6 + *
     2.7 + * Permission is hereby granted, free of charge, to any person obtaining a
     2.8 + * copy of this software and associated documentation files (the "Software"),
     2.9 + * to deal in the Software without restriction, including without limitation
    2.10 + * on the rights to use, copy, modify, merge, publish, distribute, sub
    2.11 + * license, and/or sell copies of the Software, and to permit persons to whom
    2.12 + * the Software is furnished to do so, subject to the following conditions:
    2.13 + *
    2.14 + * The above copyright notice and this permission notice (including the next
    2.15 + * paragraph) shall be included in all copies or substantial portions of the
    2.16 + * Software.
    2.17 + *
    2.18 + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    2.19 + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    2.20 + * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
    2.21 + * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
    2.22 + * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
    2.23 + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
    2.24 + */
    2.25 +
    2.26 +/* Author: Soren Sandmann <sandmann@redhat.com> */
    2.27 +#include "edid.h"
    2.28 +#include <stdint.h>
    2.29 +#include <math.h>
    2.30 +#include <memory.h>
    2.31 +#include <X11/Xatom.h>
    2.32 +
    2.33 +
    2.34 +static int get_bit(int in, int bit) {
    2.35 +    return (in & (1 << bit)) >> bit;
    2.36 +}
    2.37 +
    2.38 +static int get_bits(int in, int begin, int end) {
    2.39 +    int mask = (1 << (end - begin + 1)) - 1;
    2.40 +
    2.41 +    return (in >> begin) & mask;
    2.42 +}
    2.43 +
    2.44 +static bool decode_header(const uint8_t *edid) {
    2.45 +    if (memcmp(edid, "\x00\xff\xff\xff\xff\xff\xff\x00", 8) == 0)
    2.46 +        return true;
    2.47 +    return false;
    2.48 +}
    2.49 +
    2.50 +static int decode_vendor_and_product_identification(const uint8_t *edid, MonitorInfo *info) {
    2.51 +
    2.52 +    /* Manufacturer Code */
    2.53 +    info->manufacturer_code[0] = get_bits(edid[0x08], 2, 6);
    2.54 +    info->manufacturer_code[1] = get_bits(edid[0x08], 0, 1) << 3;
    2.55 +    info->manufacturer_code[1] |= get_bits(edid[0x09], 5, 7);
    2.56 +    info->manufacturer_code[2] = get_bits(edid[0x09], 0, 4);
    2.57 +    info->manufacturer_code[3] = '\0';
    2.58 +
    2.59 +    info->manufacturer_code[0] += 'A' - 1;
    2.60 +    info->manufacturer_code[1] += 'A' - 1;
    2.61 +    info->manufacturer_code[2] += 'A' - 1;
    2.62 +
    2.63 +    /* Product Code */
    2.64 +    info->product_code = edid[0x0b] << 8 | edid[0x0a];
    2.65 +
    2.66 +    /* Serial Number */
    2.67 +    info->serial_number = edid[0x0c] | edid[0x0d] << 8 | edid[0x0e] << 16 | edid[0x0f] << 24;
    2.68 +
    2.69 +    /* Week and Year */
    2.70 +    bool is_model_year = false;
    2.71 +    switch (edid[0x10]) {
    2.72 +    case 0x00:
    2.73 +        info->production_week = -1;
    2.74 +        break;
    2.75 +
    2.76 +    case 0xff:
    2.77 +        info->production_week = -1;
    2.78 +        is_model_year = true;
    2.79 +        break;
    2.80 +
    2.81 +    default:
    2.82 +        info->production_week = edid[0x10];
    2.83 +        break;
    2.84 +    }
    2.85 +
    2.86 +    if (is_model_year) {
    2.87 +        info->production_year = -1;
    2.88 +        info->model_year = 1990 + edid[0x11];
    2.89 +    } else {
    2.90 +        info->production_year = 1990 + edid[0x11];
    2.91 +        info->model_year = -1;
    2.92 +    }
    2.93 +
    2.94 +    return true;
    2.95 +}
    2.96 +
    2.97 +static bool decode_edid_version(const uint8_t *edid, MonitorInfo *info) {
    2.98 +    info->major_version = edid[0x12];
    2.99 +    info->minor_version = edid[0x13];
   2.100 +    return true;
   2.101 +}
   2.102 +
   2.103 +static bool decode_display_parameters(const uint8_t *edid, MonitorInfo *info) {
   2.104 +    /* Digital vs Analog */
   2.105 +    info->is_digital = get_bit(edid[0x14], 7);
   2.106 +
   2.107 +    if (info->is_digital) {
   2.108 +        static const int bit_depth[8] = { -1, 6, 8, 10, 12, 14, 16, -1 };
   2.109 +        static const Interface interfaces[6] = { UNDEFINED, DVI, HDMI_A, HDMI_B, MDDI, DISPLAY_PORT };
   2.110 +
   2.111 +        int bits = get_bits(edid[0x14], 4, 6);
   2.112 +        info->connector.digital.bits_per_primary = bit_depth[bits];
   2.113 +
   2.114 +        bits = get_bits(edid[0x14], 0, 3);
   2.115 +        if (bits <= 5)
   2.116 +            info->connector.digital.interface = interfaces[bits];
   2.117 +        else
   2.118 +            info->connector.digital.interface = UNDEFINED;
   2.119 +    } else {
   2.120 +        int bits = get_bits(edid[0x14], 5, 6);
   2.121 +        static const double levels[][3] = { //
   2.122 +                { 0.7, 0.3, 1.0 }, //
   2.123 +                { 0.714, 0.286, 1.0 }, //
   2.124 +                { 1.0, 0.4, 1.4 }, //
   2.125 +                { 0.7, 0.0, 0.7 }, //
   2.126 +                };
   2.127 +
   2.128 +        info->connector.analog.video_signal_level = levels[bits][0];
   2.129 +        info->connector.analog.sync_signal_level = levels[bits][1];
   2.130 +        info->connector.analog.total_signal_level = levels[bits][2];
   2.131 +        info->connector.analog.blank_to_black = get_bit(edid[0x14], 4);
   2.132 +        info->connector.analog.separate_hv_sync = get_bit(edid[0x14], 3);
   2.133 +        info->connector.analog.composite_sync_on_h = get_bit(edid[0x14], 2);
   2.134 +        info->connector.analog.composite_sync_on_green = get_bit(edid[0x14], 1);
   2.135 +        info->connector.analog.serration_on_vsync = get_bit(edid[0x14], 0);
   2.136 +    }
   2.137 +
   2.138 +    /* Screen Size / Aspect Ratio */
   2.139 +    if (edid[0x15] == 0 && edid[0x16] == 0) {
   2.140 +        info->width_mm = -1;
   2.141 +        info->height_mm = -1;
   2.142 +        info->aspect_ratio = -1.0;
   2.143 +    } else if (edid[0x16] == 0) {
   2.144 +        info->width_mm = -1;
   2.145 +        info->height_mm = -1;
   2.146 +        info->aspect_ratio = 100.0 / (edid[0x15] + 99);
   2.147 +    } else if (edid[0x15] == 0) {
   2.148 +        info->width_mm = -1;
   2.149 +        info->height_mm = -1;
   2.150 +        info->aspect_ratio = 100.0 / (edid[0x16] + 99);
   2.151 +        info->aspect_ratio = 1 / info->aspect_ratio; /* portrait */
   2.152 +    } else {
   2.153 +        info->width_mm = 10 * edid[0x15];
   2.154 +        info->height_mm = 10 * edid[0x16];
   2.155 +    }
   2.156 +
   2.157 +    /* Gamma */
   2.158 +    if (edid[0x17] == 0xFF)
   2.159 +        info->gamma = -1.0;
   2.160 +    else
   2.161 +        info->gamma = (edid[0x17] + 100.0) / 100.0;
   2.162 +
   2.163 +    /* Features */
   2.164 +    info->standby = get_bit(edid[0x18], 7);
   2.165 +    info->suspend = get_bit(edid[0x18], 6);
   2.166 +    info->active_off = get_bit(edid[0x18], 5);
   2.167 +
   2.168 +    if (info->is_digital) {
   2.169 +        info->connector.digital.rgb444 = 1;
   2.170 +        if (get_bit(edid[0x18], 3))
   2.171 +            info->connector.digital.ycrcb444 = 1;
   2.172 +        if (get_bit(edid[0x18], 4))
   2.173 +            info->connector.digital.ycrcb422 = 1;
   2.174 +    } else {
   2.175 +        int bits = get_bits(edid[0x18], 3, 4);
   2.176 +        ColorType color_type[4] = { MONOCHROME, RGB, OTHER_COLOR, UNDEFINED_COLOR };
   2.177 +
   2.178 +        info->connector.analog.color_type = color_type[bits];
   2.179 +    }
   2.180 +
   2.181 +    info->srgb_is_standard = get_bit(edid[0x18], 2);
   2.182 +
   2.183 +    /* In 1.3 this is called "has preferred timing" */
   2.184 +    info->preferred_timing_includes_native = get_bit(edid[0x18], 1);
   2.185 +
   2.186 +    /* FIXME: In 1.3 this indicates whether the monitor accepts GTF */
   2.187 +    info->continuous_frequency = get_bit(edid[0x18], 0);
   2.188 +    return true;
   2.189 +}
   2.190 +
   2.191 +static double decode_fraction(int high, int low) {
   2.192 +    double result = 0.0;
   2.193 +    high = (high << 2) | low;
   2.194 +    for (int i = 0; i < 10; ++i)
   2.195 +        result += get_bit(high, i) * pow(2, i - 10);
   2.196 +    return result;
   2.197 +}
   2.198 +
   2.199 +static bool decode_color_characteristics(const uint8_t *edid, MonitorInfo *info) {
   2.200 +    info->red_x = decode_fraction(edid[0x1b], get_bits(edid[0x19], 6, 7));
   2.201 +    info->red_y = decode_fraction(edid[0x1c], get_bits(edid[0x19], 5, 4));
   2.202 +    info->green_x = decode_fraction(edid[0x1d], get_bits(edid[0x19], 2, 3));
   2.203 +    info->green_y = decode_fraction(edid[0x1e], get_bits(edid[0x19], 0, 1));
   2.204 +    info->blue_x = decode_fraction(edid[0x1f], get_bits(edid[0x1a], 6, 7));
   2.205 +    info->blue_y = decode_fraction(edid[0x20], get_bits(edid[0x1a], 4, 5));
   2.206 +    info->white_x = decode_fraction(edid[0x21], get_bits(edid[0x1a], 2, 3));
   2.207 +    info->white_y = decode_fraction(edid[0x22], get_bits(edid[0x1a], 0, 1));
   2.208 +
   2.209 +    return true;
   2.210 +}
   2.211 +
   2.212 +static bool decode_established_timings(const uint8_t *edid, MonitorInfo *info) {
   2.213 +    static const Timing established[][8] = { //
   2.214 +            { { 800, 600, 60 }, { 800, 600, 56 }, //
   2.215 +              { 640, 480, 75 }, { 640, 480, 72 }, //
   2.216 +              { 640, 480, 67 }, { 640, 480, 60 }, //
   2.217 +              { 720, 400, 88 }, { 720, 400, 70 } }, //
   2.218 +            { { 1280, 1024, 75 }, { 1024, 768, 75 }, //
   2.219 +              { 1024, 768, 70 }, { 1024, 768, 60 }, //
   2.220 +              { 1024, 768, 87 }, { 832, 624, 75 }, //
   2.221 +              { 800, 600, 75 }, { 800, 600, 72 } }, //
   2.222 +            { { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, //
   2.223 +              { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, { 1152, 870, 75 } }, //
   2.224 +            };
   2.225 +
   2.226 +    int idx = 0;
   2.227 +    for (int i = 0; i < 3; ++i) {
   2.228 +        for (int j = 0; j < 8; ++j) {
   2.229 +            int byte = edid[0x23 + i];
   2.230 +
   2.231 +            if (get_bit(byte, j) && established[i][j].frequency != 0)
   2.232 +                info->established[idx++] = established[i][j];
   2.233 +        }
   2.234 +    }
   2.235 +    return true;
   2.236 +}
   2.237 +
   2.238 +static bool decode_standard_timings(const uint8_t *edid, MonitorInfo *info) {
   2.239 +    int i;
   2.240 +
   2.241 +    for (i = 0; i < 8; i++) {
   2.242 +        int first = edid[0x26 + 2 * i];
   2.243 +        int second = edid[0x27 + 2 * i];
   2.244 +
   2.245 +        if (first != 0x01 && second != 0x01) {
   2.246 +            int w = 8 * (first + 31);
   2.247 +            int h = 0;
   2.248 +
   2.249 +            switch (get_bits(second, 6, 7)) {
   2.250 +            case 0x00:
   2.251 +                h = (w / 16) * 10;
   2.252 +                break;
   2.253 +            case 0x01:
   2.254 +                h = (w / 4) * 3;
   2.255 +                break;
   2.256 +            case 0x02:
   2.257 +                h = (w / 5) * 4;
   2.258 +                break;
   2.259 +            case 0x03:
   2.260 +                h = (w / 16) * 9;
   2.261 +                break;
   2.262 +            }
   2.263 +
   2.264 +            info->standard[i].width = w;
   2.265 +            info->standard[i].height = h;
   2.266 +            info->standard[i].frequency = get_bits(second, 0, 5) + 60;
   2.267 +        }
   2.268 +    }
   2.269 +
   2.270 +    return true;
   2.271 +}
   2.272 +
   2.273 +static void decode_lf_string(const uint8_t *s, int n_chars, char *result) {
   2.274 +    int i;
   2.275 +    for (i = 0; i < n_chars; ++i) {
   2.276 +        if (s[i] == 0x0a) {
   2.277 +            *result++ = '\0';
   2.278 +            break;
   2.279 +        } else if (s[i] == 0x00) {
   2.280 +            /* Convert embedded 0's to spaces */
   2.281 +            *result++ = ' ';
   2.282 +        } else {
   2.283 +            *result++ = s[i];
   2.284 +        }
   2.285 +    }
   2.286 +}
   2.287 +
   2.288 +static void decode_display_descriptor(const uint8_t *desc, MonitorInfo *info) {
   2.289 +    switch (desc[0x03]) {
   2.290 +    case 0xFC:
   2.291 +        decode_lf_string(desc + 5, 13, info->dsc_product_name);
   2.292 +        break;
   2.293 +    case 0xFF:
   2.294 +        decode_lf_string(desc + 5, 13, info->dsc_serial_number);
   2.295 +        break;
   2.296 +    case 0xFE:
   2.297 +        decode_lf_string(desc + 5, 13, info->dsc_string);
   2.298 +        break;
   2.299 +    case 0xFD:
   2.300 +        /* Range Limits */
   2.301 +        break;
   2.302 +    case 0xFB:
   2.303 +        /* Color Point */
   2.304 +        break;
   2.305 +    case 0xFA:
   2.306 +        /* Timing Identifications */
   2.307 +        break;
   2.308 +    case 0xF9:
   2.309 +        /* Color Management */
   2.310 +        break;
   2.311 +    case 0xF8:
   2.312 +        /* Timing Codes */
   2.313 +        break;
   2.314 +    case 0xF7:
   2.315 +        /* Established Timings */
   2.316 +        break;
   2.317 +    case 0x10:
   2.318 +        break;
   2.319 +    }
   2.320 +}
   2.321 +
   2.322 +static void decode_detailed_timing(const uint8_t *timing, DetailedTiming *detailed) {
   2.323 +    int bits;
   2.324 +    StereoType stereo[] = { //
   2.325 +            NO_STEREO, NO_STEREO, //
   2.326 +            FIELD_RIGHT, FIELD_LEFT, //
   2.327 +            TWO_WAY_RIGHT_ON_EVEN, TWO_WAY_LEFT_ON_EVEN, //
   2.328 +            FOUR_WAY_INTERLEAVED, //
   2.329 +            SIDE_BY_SIDE //
   2.330 +            };
   2.331 +
   2.332 +    detailed->pixel_clock = (timing[0x00] | timing[0x01] << 8) * 10000;
   2.333 +    detailed->h_addr = timing[0x02] | ((timing[0x04] & 0xf0) << 4);
   2.334 +    detailed->h_blank = timing[0x03] | ((timing[0x04] & 0x0f) << 8);
   2.335 +    detailed->v_addr = timing[0x05] | ((timing[0x07] & 0xf0) << 4);
   2.336 +    detailed->v_blank = timing[0x06] | ((timing[0x07] & 0x0f) << 8);
   2.337 +    detailed->h_front_porch = timing[0x08] | get_bits(timing[0x0b], 6, 7) << 8;
   2.338 +    detailed->h_sync = timing[0x09] | get_bits(timing[0x0b], 4, 5) << 8;
   2.339 +    detailed->v_front_porch = get_bits(timing[0x0a], 4, 7) | get_bits(timing[0x0b], 2, 3) << 4;
   2.340 +    detailed->v_sync = get_bits(timing[0x0a], 0, 3) | get_bits(timing[0x0b], 0, 1) << 4;
   2.341 +    detailed->width_mm = timing[0x0c] | get_bits(timing[0x0e], 4, 7) << 8;
   2.342 +    detailed->height_mm = timing[0x0d] | get_bits(timing[0x0e], 0, 3) << 8;
   2.343 +    detailed->right_border = timing[0x0f];
   2.344 +    detailed->top_border = timing[0x10];
   2.345 +    detailed->interlaced = get_bit(timing[0x11], 7);
   2.346 +
   2.347 +    /* Stereo */
   2.348 +    bits = get_bits(timing[0x11], 5, 6) << 1 | get_bit(timing[0x11], 0);
   2.349 +    detailed->stereo = stereo[bits];
   2.350 +
   2.351 +    /* Sync */
   2.352 +    bits = timing[0x11];
   2.353 +
   2.354 +    detailed->digital_sync = get_bit(bits, 4);
   2.355 +    if (detailed->digital_sync) {
   2.356 +        detailed->connector.digital.composite = !get_bit(bits, 3);
   2.357 +        if (detailed->connector.digital.composite) {
   2.358 +            detailed->connector.digital.serrations = get_bit(bits, 2);
   2.359 +            detailed->connector.digital.negative_vsync = 0;
   2.360 +        } else {
   2.361 +            detailed->connector.digital.serrations = 0;
   2.362 +            detailed->connector.digital.negative_vsync = !get_bit(bits, 2);
   2.363 +        }
   2.364 +        detailed->connector.digital.negative_hsync = !get_bit(bits, 0);
   2.365 +    } else {
   2.366 +        detailed->connector.analog.bipolar = get_bit(bits, 3);
   2.367 +        detailed->connector.analog.serrations = get_bit(bits, 2);
   2.368 +        detailed->connector.analog.sync_on_green = !get_bit(bits, 1);
   2.369 +    }
   2.370 +}
   2.371 +
   2.372 +static bool decode_descriptors(const uint8_t *edid, MonitorInfo *info) {
   2.373 +    int timing_idx = 0;
   2.374 +    for (int i = 0; i < 4; ++i) {
   2.375 +        int index = 0x36 + i * 18;
   2.376 +        if (edid[index + 0] == 0x00 && edid[index + 1] == 0x00) {
   2.377 +            decode_display_descriptor(edid + index, info);
   2.378 +        } else {
   2.379 +            decode_detailed_timing(edid + index, &(info->detailed_timings[timing_idx++]));
   2.380 +        }
   2.381 +    }
   2.382 +    info->n_detailed_timings = timing_idx;
   2.383 +    return true;
   2.384 +}
   2.385 +
   2.386 +static void decode_check_sum(const uint8_t *edid, MonitorInfo *info) {
   2.387 +    uint8_t check = 0;
   2.388 +    for (int i = 0; i < 128; ++i)
   2.389 +        check += edid[i];
   2.390 +    info->checksum = check;
   2.391 +}
   2.392 +
   2.393 +MonitorInfo * decode_edid(const uint8_t *edid) {
   2.394 +    MonitorInfo *info = new MonitorInfo();
   2.395 +    decode_check_sum(edid, info);
   2.396 +    if (decode_header(edid) && //
   2.397 +            decode_vendor_and_product_identification(edid, info) && //
   2.398 +            decode_edid_version(edid, info) && //
   2.399 +            decode_display_parameters(edid, info) && //
   2.400 +            decode_color_characteristics(edid, info) && //
   2.401 +            decode_established_timings(edid, info) && //
   2.402 +            decode_standard_timings(edid, info) && //
   2.403 +            decode_descriptors(edid, info)) {
   2.404 +        return info;
   2.405 +    } else {
   2.406 +        delete info;
   2.407 +        return 0;
   2.408 +    }
   2.409 +}
   2.410 +
   2.411 +static uint8_t * get_property(Display *dpy, RROutput output, Atom atom, int *len) {
   2.412 +    unsigned char *prop;
   2.413 +    int actual_format;
   2.414 +    unsigned long nitems, bytes_after;
   2.415 +    Atom actual_type;
   2.416 +    uint8_t *result = NULL;
   2.417 +
   2.418 +    XRRGetOutputProperty(dpy, output, atom, 0, 100, False, False,
   2.419 +    AnyPropertyType, &actual_type, &actual_format, &nitems, &bytes_after, &prop);
   2.420 +
   2.421 +    if (actual_type == XA_INTEGER && actual_format == 8) {
   2.422 +        result = new uint8_t[nitems];
   2.423 +        memcpy(result, prop, nitems);
   2.424 +        if (len)
   2.425 +            *len = nitems;
   2.426 +    }
   2.427 +    XFree(prop);
   2.428 +    return result;
   2.429 +}
   2.430 +
   2.431 +MonitorInfo * read_edid_data(Display * disp, RROutput id) {
   2.432 +    int len;
   2.433 +    Atom edid_atom = XInternAtom(disp, "EDID", false);
   2.434 +    uint8_t *edid = get_property(disp, id, edid_atom, &len);
   2.435 +    if (!edid) {
   2.436 +        edid_atom = XInternAtom(disp, "EDID_DATA", false);
   2.437 +        edid = get_property(disp, id, edid_atom, &len);
   2.438 +    }
   2.439 +
   2.440 +    MonitorInfo * result = 0;
   2.441 +    if (edid) {
   2.442 +        if (len % 128 == 0) {
   2.443 +            result = decode_edid(edid);
   2.444 +        }
   2.445 +        delete[] edid;
   2.446 +    }
   2.447 +
   2.448 +    return result;
   2.449 +}

     3.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     3.2 +++ b/3rdParty/EDID/edid.h	Wed Jan 14 06:51:16 2015 +0200
     3.3 @@ -0,0 +1,174 @@
     3.4 +#include <X11/extensions/Xrandr.h>
     3.5 +#include <X11/Xlib.h>
     3.6 +
     3.7 +/*
     3.8 + * Copyright 2007 Red Hat, Inc.
     3.9 + *
    3.10 + * Permission is hereby granted, free of charge, to any person obtaining a
    3.11 + * copy of this software and associated documentation files (the "Software"),
    3.12 + * to deal in the Software without restriction, including without limitation
    3.13 + * on the rights to use, copy, modify, merge, publish, distribute, sub
    3.14 + * license, and/or sell copies of the Software, and to permit persons to whom
    3.15 + * the Software is furnished to do so, subject to the following conditions:
    3.16 + *
    3.17 + * The above copyright notice and this permission notice (including the next
    3.18 + * paragraph) shall be included in all copies or substantial portions of the
    3.19 + * Software.
    3.20 + *
    3.21 + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    3.22 + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    3.23 + * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
    3.24 + * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
    3.25 + * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
    3.26 + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
    3.27 + */
    3.28 +
    3.29 +/* Author: Soren Sandmann <sandmann@redhat.com> */
    3.30 +
    3.31 +typedef enum {
    3.32 +    UNDEFINED,
    3.33 +    DVI,
    3.34 +    HDMI_A,
    3.35 +    HDMI_B,
    3.36 +    MDDI,
    3.37 +    DISPLAY_PORT
    3.38 +} Interface;
    3.39 +
    3.40 +typedef enum {
    3.41 +    UNDEFINED_COLOR,
    3.42 +    MONOCHROME,
    3.43 +    RGB,
    3.44 +    OTHER_COLOR
    3.45 +} ColorType;
    3.46 +
    3.47 +typedef enum {
    3.48 +    NO_STEREO,
    3.49 +    FIELD_RIGHT,
    3.50 +    FIELD_LEFT,
    3.51 +    TWO_WAY_RIGHT_ON_EVEN,
    3.52 +    TWO_WAY_LEFT_ON_EVEN,
    3.53 +    FOUR_WAY_INTERLEAVED,
    3.54 +    SIDE_BY_SIDE
    3.55 +} StereoType;
    3.56 +
    3.57 +struct Timing {
    3.58 +    int width;
    3.59 +    int height;
    3.60 +    int frequency;
    3.61 +};
    3.62 +
    3.63 +struct DetailedTiming {
    3.64 +    int pixel_clock;
    3.65 +    int h_addr;
    3.66 +    int h_blank;
    3.67 +    int h_sync;
    3.68 +    int h_front_porch;
    3.69 +    int v_addr;
    3.70 +    int v_blank;
    3.71 +    int v_sync;
    3.72 +    int v_front_porch;
    3.73 +    int width_mm;
    3.74 +    int height_mm;
    3.75 +    int right_border;
    3.76 +    int top_border;
    3.77 +    int interlaced;
    3.78 +    StereoType stereo;
    3.79 +
    3.80 +    int digital_sync;
    3.81 +    union {
    3.82 +        struct {
    3.83 +            int bipolar;
    3.84 +            int serrations;
    3.85 +            int sync_on_green;
    3.86 +        } analog;
    3.87 +
    3.88 +        struct {
    3.89 +            int composite;
    3.90 +            int serrations;
    3.91 +            int negative_vsync;
    3.92 +            int negative_hsync;
    3.93 +        } digital;
    3.94 +    } connector;
    3.95 +};
    3.96 +
    3.97 +struct MonitorInfo {
    3.98 +    int checksum;
    3.99 +    char manufacturer_code[4];
   3.100 +    int product_code;
   3.101 +    unsigned int serial_number;
   3.102 +
   3.103 +    int production_week; /* -1 if not specified */
   3.104 +    int production_year; /* -1 if not specified */
   3.105 +    int model_year; /* -1 if not specified */
   3.106 +
   3.107 +    int major_version;
   3.108 +    int minor_version;
   3.109 +
   3.110 +    int is_digital;
   3.111 +
   3.112 +    union {
   3.113 +        struct {
   3.114 +            int bits_per_primary;
   3.115 +            Interface interface;
   3.116 +            int rgb444;
   3.117 +            int ycrcb444;
   3.118 +            int ycrcb422;
   3.119 +        } digital;
   3.120 +
   3.121 +        struct {
   3.122 +            double video_signal_level;
   3.123 +            double sync_signal_level;
   3.124 +            double total_signal_level;
   3.125 +
   3.126 +            int blank_to_black;
   3.127 +
   3.128 +            int separate_hv_sync;
   3.129 +            int composite_sync_on_h;
   3.130 +            int composite_sync_on_green;
   3.131 +            int serration_on_vsync;
   3.132 +            ColorType color_type;
   3.133 +        } analog;
   3.134 +    } connector;
   3.135 +
   3.136 +    int width_mm; /* -1 if not specified */
   3.137 +    int height_mm; /* -1 if not specified */
   3.138 +    double aspect_ratio; /* -1.0 if not specififed */
   3.139 +
   3.140 +    double gamma; /* -1.0 if not specified */
   3.141 +
   3.142 +    int standby;
   3.143 +    int suspend;
   3.144 +    int active_off;
   3.145 +
   3.146 +    int srgb_is_standard;
   3.147 +    int preferred_timing_includes_native;
   3.148 +    int continuous_frequency;
   3.149 +
   3.150 +    double red_x;
   3.151 +    double red_y;
   3.152 +    double green_x;
   3.153 +    double green_y;
   3.154 +    double blue_x;
   3.155 +    double blue_y;
   3.156 +    double white_x;
   3.157 +    double white_y;
   3.158 +
   3.159 +    Timing established[24]; /* Terminated by 0x0x0 */
   3.160 +    Timing standard[8];
   3.161 +
   3.162 +    int n_detailed_timings;
   3.163 +    DetailedTiming detailed_timings[4]; /* If monitor has a preferred
   3.164 +     * mode, it is the first one
   3.165 +     * (whether it has, is
   3.166 +     * determined by the
   3.167 +     * preferred_timing_includes
   3.168 +     * bit.
   3.169 +     */
   3.170 +
   3.171 +    /* Optional product description */
   3.172 +    char dsc_serial_number[14];
   3.173 +    char dsc_product_name[14];
   3.174 +    char dsc_string[14]; /* Unspecified ASCII data */
   3.175 +};
   3.176 +
   3.177 +MonitorInfo * read_edid_data(Display * disp, RROutput id);

     4.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     4.2 +++ b/3rdParty/TinyXml/tinyxml2.cpp	Wed Jan 14 06:51:16 2015 +0200
     4.3 @@ -0,0 +1,2101 @@
     4.4 +/*
     4.5 +Original code by Lee Thomason (www.grinninglizard.com)
     4.6 +
     4.7 +This software is provided 'as-is', without any express or implied
     4.8 +warranty. In no event will the authors be held liable for any
     4.9 +damages arising from the use of this software.
    4.10 +
    4.11 +Permission is granted to anyone to use this software for any
    4.12 +purpose, including commercial applications, and to alter it and
    4.13 +redistribute it freely, subject to the following restrictions:
    4.14 +
    4.15 +1. The origin of this software must not be misrepresented; you must
    4.16 +not claim that you wrote the original software. If you use this
    4.17 +software in a product, an acknowledgment in the product documentation
    4.18 +would be appreciated but is not required.
    4.19 +
    4.20 +2. Altered source versions must be plainly marked as such, and
    4.21 +must not be misrepresented as being the original software.
    4.22 +
    4.23 +3. This notice may not be removed or altered from any source
    4.24 +distribution.
    4.25 +*/
    4.26 +
    4.27 +#include "tinyxml2.h"
    4.28 +
    4.29 +#include <new>		// yes, this one new style header, is in the Android SDK.
    4.30 +#   ifdef ANDROID_NDK
    4.31 +#   include <stddef.h>
    4.32 +#else
    4.33 +#   include <cstddef>
    4.34 +#endif
    4.35 +
    4.36 +static const char LINE_FEED				= (char)0x0a;			// all line endings are normalized to LF
    4.37 +static const char LF = LINE_FEED;
    4.38 +static const char CARRIAGE_RETURN		= (char)0x0d;			// CR gets filtered out
    4.39 +static const char CR = CARRIAGE_RETURN;
    4.40 +static const char SINGLE_QUOTE			= '\'';
    4.41 +static const char DOUBLE_QUOTE			= '\"';
    4.42 +
    4.43 +// Bunch of unicode info at:
    4.44 +//		http://www.unicode.org/faq/utf_bom.html
    4.45 +//	ef bb bf (Microsoft "lead bytes") - designates UTF-8
    4.46 +
    4.47 +static const unsigned char TIXML_UTF_LEAD_0 = 0xefU;
    4.48 +static const unsigned char TIXML_UTF_LEAD_1 = 0xbbU;
    4.49 +static const unsigned char TIXML_UTF_LEAD_2 = 0xbfU;
    4.50 +
    4.51 +
    4.52 +#define DELETE_NODE( node )	{			\
    4.53 +        if ( node ) {						\
    4.54 +            MemPool* pool = node->_memPool;	\
    4.55 +            node->~XMLNode();				\
    4.56 +            pool->Free( node );				\
    4.57 +        }									\
    4.58 +    }
    4.59 +#define DELETE_ATTRIBUTE( attrib ) {		\
    4.60 +        if ( attrib ) {							\
    4.61 +            MemPool* pool = attrib->_memPool;	\
    4.62 +            attrib->~XMLAttribute();			\
    4.63 +            pool->Free( attrib );				\
    4.64 +        }										\
    4.65 +    }
    4.66 +
    4.67 +namespace tinyxml2
    4.68 +{
    4.69 +
    4.70 +struct Entity {
    4.71 +    const char* pattern;
    4.72 +    int length;
    4.73 +    char value;
    4.74 +};
    4.75 +
    4.76 +static const int NUM_ENTITIES = 5;
    4.77 +static const Entity entities[NUM_ENTITIES] = {
    4.78 +    { "quot", 4,	DOUBLE_QUOTE },
    4.79 +    { "amp", 3,		'&'  },
    4.80 +    { "apos", 4,	SINGLE_QUOTE },
    4.81 +    { "lt",	2, 		'<'	 },
    4.82 +    { "gt",	2,		'>'	 }
    4.83 +};
    4.84 +
    4.85 +
    4.86 +StrPair::~StrPair()
    4.87 +{
    4.88 +    Reset();
    4.89 +}
    4.90 +
    4.91 +
    4.92 +void StrPair::Reset()
    4.93 +{
    4.94 +    if ( _flags & NEEDS_DELETE ) {
    4.95 +        delete [] _start;
    4.96 +    }
    4.97 +    _flags = 0;
    4.98 +    _start = 0;
    4.99 +    _end = 0;
   4.100 +}
   4.101 +
   4.102 +
   4.103 +void StrPair::SetStr( const char* str, int flags )
   4.104 +{
   4.105 +    Reset();
   4.106 +    size_t len = strlen( str );
   4.107 +    _start = new char[ len+1 ];
   4.108 +    memcpy( _start, str, len+1 );
   4.109 +    _end = _start + len;
   4.110 +    _flags = flags | NEEDS_DELETE;
   4.111 +}
   4.112 +
   4.113 +
   4.114 +char* StrPair::ParseText( char* p, const char* endTag, int strFlags )
   4.115 +{
   4.116 +    TIXMLASSERT( endTag && *endTag );
   4.117 +
   4.118 +    char* start = p;	// fixme: hides a member
   4.119 +    char  endChar = *endTag;
   4.120 +    size_t length = strlen( endTag );
   4.121 +
   4.122 +    // Inner loop of text parsing.
   4.123 +    while ( *p ) {
   4.124 +        if ( *p == endChar && strncmp( p, endTag, length ) == 0 ) {
   4.125 +            Set( start, p, strFlags );
   4.126 +            return p + length;
   4.127 +        }
   4.128 +        ++p;
   4.129 +    }
   4.130 +    return 0;
   4.131 +}
   4.132 +
   4.133 +
   4.134 +char* StrPair::ParseName( char* p )
   4.135 +{
   4.136 +    char* start = p;
   4.137 +
   4.138 +    if ( !start || !(*start) ) {
   4.139 +        return 0;
   4.140 +    }
   4.141 +
   4.142 +    while( *p && (
   4.143 +                XMLUtil::IsAlphaNum( (unsigned char) *p )
   4.144 +                || *p == '_'
   4.145 +                || *p == ':'
   4.146 +                || (*p == '-' && p>start )		// can be in a name, but not lead it.
   4.147 +                || (*p == '.' && p>start ) )) {	// can be in a name, but not lead it.
   4.148 +        ++p;
   4.149 +    }
   4.150 +
   4.151 +    if ( p > start ) {
   4.152 +        Set( start, p, 0 );
   4.153 +        return p;
   4.154 +    }
   4.155 +    return 0;
   4.156 +}
   4.157 +
   4.158 +
   4.159 +void StrPair::CollapseWhitespace()
   4.160 +{
   4.161 +    // Trim leading space.
   4.162 +    _start = XMLUtil::SkipWhiteSpace( _start );
   4.163 +
   4.164 +    if ( _start && *_start ) {
   4.165 +        char* p = _start;	// the read pointer
   4.166 +        char* q = _start;	// the write pointer
   4.167 +
   4.168 +        while( *p ) {
   4.169 +            if ( XMLUtil::IsWhiteSpace( *p )) {
   4.170 +                p = XMLUtil::SkipWhiteSpace( p );
   4.171 +                if ( *p == 0 ) {
   4.172 +                    break;    // don't write to q; this trims the trailing space.
   4.173 +                }
   4.174 +                *q = ' ';
   4.175 +                ++q;
   4.176 +            }
   4.177 +            *q = *p;
   4.178 +            ++q;
   4.179 +            ++p;
   4.180 +        }
   4.181 +        *q = 0;
   4.182 +    }
   4.183 +}
   4.184 +
   4.185 +
   4.186 +const char* StrPair::GetStr()
   4.187 +{
   4.188 +    if ( _flags & NEEDS_FLUSH ) {
   4.189 +        *_end = 0;
   4.190 +        _flags ^= NEEDS_FLUSH;
   4.191 +
   4.192 +        if ( _flags ) {
   4.193 +            char* p = _start;	// the read pointer
   4.194 +            char* q = _start;	// the write pointer
   4.195 +
   4.196 +            while( p < _end ) {
   4.197 +                if ( (_flags & NEEDS_NEWLINE_NORMALIZATION) && *p == CR ) {
   4.198 +                    // CR-LF pair becomes LF
   4.199 +                    // CR alone becomes LF
   4.200 +                    // LF-CR becomes LF
   4.201 +                    if ( *(p+1) == LF ) {
   4.202 +                        p += 2;
   4.203 +                    }
   4.204 +                    else {
   4.205 +                        ++p;
   4.206 +                    }
   4.207 +                    *q++ = LF;
   4.208 +                }
   4.209 +                else if ( (_flags & NEEDS_NEWLINE_NORMALIZATION) && *p == LF ) {
   4.210 +                    if ( *(p+1) == CR ) {
   4.211 +                        p += 2;
   4.212 +                    }
   4.213 +                    else {
   4.214 +                        ++p;
   4.215 +                    }
   4.216 +                    *q++ = LF;
   4.217 +                }
   4.218 +                else if ( (_flags & NEEDS_ENTITY_PROCESSING) && *p == '&' ) {
   4.219 +                    // Entities handled by tinyXML2:
   4.220 +                    // - special entities in the entity table [in/out]
   4.221 +                    // - numeric character reference [in]
   4.222 +                    //   &#20013; or &#x4e2d;
   4.223 +
   4.224 +                    if ( *(p+1) == '#' ) {
   4.225 +                        char buf[10] = { 0 };
   4.226 +                        int len;
   4.227 +                        p = const_cast<char*>( XMLUtil::GetCharacterRef( p, buf, &len ) );
   4.228 +                        for( int i=0; i<len; ++i ) {
   4.229 +                            *q++ = buf[i];
   4.230 +                        }
   4.231 +                        TIXMLASSERT( q <= p );
   4.232 +                    }
   4.233 +                    else {
   4.234 +                        int i=0;
   4.235 +                        for(; i<NUM_ENTITIES; ++i ) {
   4.236 +                            if (    strncmp( p+1, entities[i].pattern, entities[i].length ) == 0
   4.237 +                                    && *(p+entities[i].length+1) == ';' ) {
   4.238 +                                // Found an entity convert;
   4.239 +                                *q = entities[i].value;
   4.240 +                                ++q;
   4.241 +                                p += entities[i].length + 2;
   4.242 +                                break;
   4.243 +                            }
   4.244 +                        }
   4.245 +                        if ( i == NUM_ENTITIES ) {
   4.246 +                            // fixme: treat as error?
   4.247 +                            ++p;
   4.248 +                            ++q;
   4.249 +                        }
   4.250 +                    }
   4.251 +                }
   4.252 +                else {
   4.253 +                    *q = *p;
   4.254 +                    ++p;
   4.255 +                    ++q;
   4.256 +                }
   4.257 +            }
   4.258 +            *q = 0;
   4.259 +        }
   4.260 +        // The loop below has plenty going on, and this
   4.261 +        // is a less useful mode. Break it out.
   4.262 +        if ( _flags & COLLAPSE_WHITESPACE ) {
   4.263 +            CollapseWhitespace();
   4.264 +        }
   4.265 +        _flags = (_flags & NEEDS_DELETE);
   4.266 +    }
   4.267 +    return _start;
   4.268 +}
   4.269 +
   4.270 +
   4.271 +
   4.272 +
   4.273 +// --------- XMLUtil ----------- //
   4.274 +
   4.275 +const char* XMLUtil::ReadBOM( const char* p, bool* bom )
   4.276 +{
   4.277 +    *bom = false;
   4.278 +    const unsigned char* pu = reinterpret_cast<const unsigned char*>(p);
   4.279 +    // Check for BOM:
   4.280 +    if (    *(pu+0) == TIXML_UTF_LEAD_0
   4.281 +            && *(pu+1) == TIXML_UTF_LEAD_1
   4.282 +            && *(pu+2) == TIXML_UTF_LEAD_2 ) {
   4.283 +        *bom = true;
   4.284 +        p += 3;
   4.285 +    }
   4.286 +    return p;
   4.287 +}
   4.288 +
   4.289 +
   4.290 +void XMLUtil::ConvertUTF32ToUTF8( unsigned long input, char* output, int* length )
   4.291 +{
   4.292 +    const unsigned long BYTE_MASK = 0xBF;
   4.293 +    const unsigned long BYTE_MARK = 0x80;
   4.294 +    const unsigned long FIRST_BYTE_MARK[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
   4.295 +
   4.296 +    if (input < 0x80) {
   4.297 +        *length = 1;
   4.298 +    }
   4.299 +    else if ( input < 0x800 ) {
   4.300 +        *length = 2;
   4.301 +    }
   4.302 +    else if ( input < 0x10000 ) {
   4.303 +        *length = 3;
   4.304 +    }
   4.305 +    else if ( input < 0x200000 ) {
   4.306 +        *length = 4;
   4.307 +    }
   4.308 +    else {
   4.309 +        *length = 0;    // This code won't covert this correctly anyway.
   4.310 +        return;
   4.311 +    }
   4.312 +
   4.313 +    output += *length;
   4.314 +
   4.315 +    // Scary scary fall throughs.
   4.316 +    switch (*length) {
   4.317 +        case 4:
   4.318 +            --output;
   4.319 +            *output = (char)((input | BYTE_MARK) & BYTE_MASK);
   4.320 +            input >>= 6;
   4.321 +        case 3:
   4.322 +            --output;
   4.323 +            *output = (char)((input | BYTE_MARK) & BYTE_MASK);
   4.324 +            input >>= 6;
   4.325 +        case 2:
   4.326 +            --output;
   4.327 +            *output = (char)((input | BYTE_MARK) & BYTE_MASK);
   4.328 +            input >>= 6;
   4.329 +        case 1:
   4.330 +            --output;
   4.331 +            *output = (char)(input | FIRST_BYTE_MARK[*length]);
   4.332 +        default:
   4.333 +            break;
   4.334 +    }
   4.335 +}
   4.336 +
   4.337 +
   4.338 +const char* XMLUtil::GetCharacterRef( const char* p, char* value, int* length )
   4.339 +{
   4.340 +    // Presume an entity, and pull it out.
   4.341 +    *length = 0;
   4.342 +
   4.343 +    if ( *(p+1) == '#' && *(p+2) ) {
   4.344 +        unsigned long ucs = 0;
   4.345 +        ptrdiff_t delta = 0;
   4.346 +        unsigned mult = 1;
   4.347 +
   4.348 +        if ( *(p+2) == 'x' ) {
   4.349 +            // Hexadecimal.
   4.350 +            if ( !*(p+3) ) {
   4.351 +                return 0;
   4.352 +            }
   4.353 +
   4.354 +            const char* q = p+3;
   4.355 +            q = strchr( q, ';' );
   4.356 +
   4.357 +            if ( !q || !*q ) {
   4.358 +                return 0;
   4.359 +            }
   4.360 +
   4.361 +            delta = q-p;
   4.362 +            --q;
   4.363 +
   4.364 +            while ( *q != 'x' ) {
   4.365 +                if ( *q >= '0' && *q <= '9' ) {
   4.366 +                    ucs += mult * (*q - '0');
   4.367 +                }
   4.368 +                else if ( *q >= 'a' && *q <= 'f' ) {
   4.369 +                    ucs += mult * (*q - 'a' + 10);
   4.370 +                }
   4.371 +                else if ( *q >= 'A' && *q <= 'F' ) {
   4.372 +                    ucs += mult * (*q - 'A' + 10 );
   4.373 +                }
   4.374 +                else {
   4.375 +                    return 0;
   4.376 +                }
   4.377 +                mult *= 16;
   4.378 +                --q;
   4.379 +            }
   4.380 +        }
   4.381 +        else {
   4.382 +            // Decimal.
   4.383 +            if ( !*(p+2) ) {
   4.384 +                return 0;
   4.385 +            }
   4.386 +
   4.387 +            const char* q = p+2;
   4.388 +            q = strchr( q, ';' );
   4.389 +
   4.390 +            if ( !q || !*q ) {
   4.391 +                return 0;
   4.392 +            }
   4.393 +
   4.394 +            delta = q-p;
   4.395 +            --q;
   4.396 +
   4.397 +            while ( *q != '#' ) {
   4.398 +                if ( *q >= '0' && *q <= '9' ) {
   4.399 +                    ucs += mult * (*q - '0');
   4.400 +                }
   4.401 +                else {
   4.402 +                    return 0;
   4.403 +                }
   4.404 +                mult *= 10;
   4.405 +                --q;
   4.406 +            }
   4.407 +        }
   4.408 +        // convert the UCS to UTF-8
   4.409 +        ConvertUTF32ToUTF8( ucs, value, length );
   4.410 +        return p + delta + 1;
   4.411 +    }
   4.412 +    return p+1;
   4.413 +}
   4.414 +
   4.415 +
   4.416 +void XMLUtil::ToStr( int v, char* buffer, int bufferSize )
   4.417 +{
   4.418 +    TIXML_SNPRINTF( buffer, bufferSize, "%d", v );
   4.419 +}
   4.420 +
   4.421 +
   4.422 +void XMLUtil::ToStr( unsigned v, char* buffer, int bufferSize )
   4.423 +{
   4.424 +    TIXML_SNPRINTF( buffer, bufferSize, "%u", v );
   4.425 +}
   4.426 +
   4.427 +
   4.428 +void XMLUtil::ToStr( bool v, char* buffer, int bufferSize )
   4.429 +{
   4.430 +    TIXML_SNPRINTF( buffer, bufferSize, "%d", v ? 1 : 0 );
   4.431 +}
   4.432 +
   4.433 +
   4.434 +void XMLUtil::ToStr( float v, char* buffer, int bufferSize )
   4.435 +{
   4.436 +    TIXML_SNPRINTF( buffer, bufferSize, "%g", v );
   4.437 +}
   4.438 +
   4.439 +
   4.440 +void XMLUtil::ToStr( double v, char* buffer, int bufferSize )
   4.441 +{
   4.442 +    TIXML_SNPRINTF( buffer, bufferSize, "%g", v );
   4.443 +}
   4.444 +
   4.445 +
   4.446 +bool XMLUtil::ToInt( const char* str, int* value )
   4.447 +{
   4.448 +    if ( TIXML_SSCANF( str, "%d", value ) == 1 ) {
   4.449 +        return true;
   4.450 +    }
   4.451 +    return false;
   4.452 +}
   4.453 +
   4.454 +bool XMLUtil::ToUnsigned( const char* str, unsigned *value )
   4.455 +{
   4.456 +    if ( TIXML_SSCANF( str, "%u", value ) == 1 ) {
   4.457 +        return true;
   4.458 +    }
   4.459 +    return false;
   4.460 +}
   4.461 +
   4.462 +bool XMLUtil::ToBool( const char* str, bool* value )
   4.463 +{
   4.464 +    int ival = 0;
   4.465 +    if ( ToInt( str, &ival )) {
   4.466 +        *value = (ival==0) ? false : true;
   4.467 +        return true;
   4.468 +    }
   4.469 +    if ( StringEqual( str, "true" ) ) {
   4.470 +        *value = true;
   4.471 +        return true;
   4.472 +    }
   4.473 +    else if ( StringEqual( str, "false" ) ) {
   4.474 +        *value = false;
   4.475 +        return true;
   4.476 +    }
   4.477 +    return false;
   4.478 +}
   4.479 +
   4.480 +
   4.481 +bool XMLUtil::ToFloat( const char* str, float* value )
   4.482 +{
   4.483 +    if ( TIXML_SSCANF( str, "%f", value ) == 1 ) {
   4.484 +        return true;
   4.485 +    }
   4.486 +    return false;
   4.487 +}
   4.488 +
   4.489 +bool XMLUtil::ToDouble( const char* str, double* value )
   4.490 +{
   4.491 +    if ( TIXML_SSCANF( str, "%lf", value ) == 1 ) {
   4.492 +        return true;
   4.493 +    }
   4.494 +    return false;
   4.495 +}
   4.496 +
   4.497 +
   4.498 +char* XMLDocument::Identify( char* p, XMLNode** node )
   4.499 +{
   4.500 +    XMLNode* returnNode = 0;
   4.501 +    char* start = p;
   4.502 +    p = XMLUtil::SkipWhiteSpace( p );
   4.503 +    if( !p || !*p ) {
   4.504 +        return p;
   4.505 +    }
   4.506 +
   4.507 +    // What is this thing?
   4.508 +    // - Elements start with a letter or underscore, but xml is reserved.
   4.509 +    // - Comments: <!--
   4.510 +    // - Decleration: <?
   4.511 +    // - Everthing else is unknown to tinyxml.
   4.512 +    //
   4.513 +
   4.514 +    static const char* xmlHeader		= { "<?" };
   4.515 +    static const char* commentHeader	= { "<!--" };
   4.516 +    static const char* dtdHeader		= { "<!" };
   4.517 +    static const char* cdataHeader		= { "<![CDATA[" };
   4.518 +    static const char* elementHeader	= { "<" };	// and a header for everything else; check last.
   4.519 +
   4.520 +    static const int xmlHeaderLen		= 2;
   4.521 +    static const int commentHeaderLen	= 4;
   4.522 +    static const int dtdHeaderLen		= 2;
   4.523 +    static const int cdataHeaderLen		= 9;
   4.524 +    static const int elementHeaderLen	= 1;
   4.525 +
   4.526 +#if defined(_MSC_VER)
   4.527 +#pragma warning ( push )
   4.528 +#pragma warning ( disable : 4127 )
   4.529 +#endif
   4.530 +    TIXMLASSERT( sizeof( XMLComment ) == sizeof( XMLUnknown ) );		// use same memory pool
   4.531 +    TIXMLASSERT( sizeof( XMLComment ) == sizeof( XMLDeclaration ) );	// use same memory pool
   4.532 +#if defined(_MSC_VER)
   4.533 +#pragma warning (pop)
   4.534 +#endif
   4.535 +    if ( XMLUtil::StringEqual( p, xmlHeader, xmlHeaderLen ) ) {
   4.536 +        returnNode = new (_commentPool.Alloc()) XMLDeclaration( this );
   4.537 +        returnNode->_memPool = &_commentPool;
   4.538 +        p += xmlHeaderLen;
   4.539 +    }
   4.540 +    else if ( XMLUtil::StringEqual( p, commentHeader, commentHeaderLen ) ) {
   4.541 +        returnNode = new (_commentPool.Alloc()) XMLComment( this );
   4.542 +        returnNode->_memPool = &_commentPool;
   4.543 +        p += commentHeaderLen;
   4.544 +    }
   4.545 +    else if ( XMLUtil::StringEqual( p, cdataHeader, cdataHeaderLen ) ) {
   4.546 +        XMLText* text = new (_textPool.Alloc()) XMLText( this );
   4.547 +        returnNode = text;
   4.548 +        returnNode->_memPool = &_textPool;
   4.549 +        p += cdataHeaderLen;
   4.550 +        text->SetCData( true );
   4.551 +    }
   4.552 +    else if ( XMLUtil::StringEqual( p, dtdHeader, dtdHeaderLen ) ) {
   4.553 +        returnNode = new (_commentPool.Alloc()) XMLUnknown( this );
   4.554 +        returnNode->_memPool = &_commentPool;
   4.555 +        p += dtdHeaderLen;
   4.556 +    }
   4.557 +    else if ( XMLUtil::StringEqual( p, elementHeader, elementHeaderLen ) ) {
   4.558 +        returnNode = new (_elementPool.Alloc()) XMLElement( this );
   4.559 +        returnNode->_memPool = &_elementPool;
   4.560 +        p += elementHeaderLen;
   4.561 +    }
   4.562 +    else {
   4.563 +        returnNode = new (_textPool.Alloc()) XMLText( this );
   4.564 +        returnNode->_memPool = &_textPool;
   4.565 +        p = start;	// Back it up, all the text counts.
   4.566 +    }
   4.567 +
   4.568 +    *node = returnNode;
   4.569 +    return p;
   4.570 +}
   4.571 +
   4.572 +
   4.573 +bool XMLDocument::Accept( XMLVisitor* visitor ) const
   4.574 +{
   4.575 +    if ( visitor->VisitEnter( *this ) ) {
   4.576 +        for ( const XMLNode* node=FirstChild(); node; node=node->NextSibling() ) {
   4.577 +            if ( !node->Accept( visitor ) ) {
   4.578 +                break;
   4.579 +            }
   4.580 +        }
   4.581 +    }
   4.582 +    return visitor->VisitExit( *this );
   4.583 +}
   4.584 +
   4.585 +
   4.586 +// --------- XMLNode ----------- //
   4.587 +
   4.588 +XMLNode::XMLNode( XMLDocument* doc ) :
   4.589 +    _document( doc ),
   4.590 +    _parent( 0 ),
   4.591 +    _firstChild( 0 ), _lastChild( 0 ),
   4.592 +    _prev( 0 ), _next( 0 )
   4.593 +{
   4.594 +}
   4.595 +
   4.596 +
   4.597 +XMLNode::~XMLNode()
   4.598 +{
   4.599 +    DeleteChildren();
   4.600 +    if ( _parent ) {
   4.601 +        _parent->Unlink( this );
   4.602 +    }
   4.603 +}
   4.604 +
   4.605 +
   4.606 +void XMLNode::SetValue( const char* str, bool staticMem )
   4.607 +{
   4.608 +    if ( staticMem ) {
   4.609 +        _value.SetInternedStr( str );
   4.610 +    }
   4.611 +    else {
   4.612 +        _value.SetStr( str );
   4.613 +    }
   4.614 +}
   4.615 +
   4.616 +
   4.617 +void XMLNode::DeleteChildren()
   4.618 +{
   4.619 +    while( _firstChild ) {
   4.620 +        XMLNode* node = _firstChild;
   4.621 +        Unlink( node );
   4.622 +
   4.623 +        DELETE_NODE( node );
   4.624 +    }
   4.625 +    _firstChild = _lastChild = 0;
   4.626 +}
   4.627 +
   4.628 +
   4.629 +void XMLNode::Unlink( XMLNode* child )
   4.630 +{
   4.631 +    TIXMLASSERT( child->_parent == this );
   4.632 +    if ( child == _firstChild ) {
   4.633 +        _firstChild = _firstChild->_next;
   4.634 +    }
   4.635 +    if ( child == _lastChild ) {
   4.636 +        _lastChild = _lastChild->_prev;
   4.637 +    }
   4.638 +
   4.639 +    if ( child->_prev ) {
   4.640 +        child->_prev->_next = child->_next;
   4.641 +    }
   4.642 +    if ( child->_next ) {
   4.643 +        child->_next->_prev = child->_prev;
   4.644 +    }
   4.645 +    child->_parent = 0;
   4.646 +}
   4.647 +
   4.648 +
   4.649 +void XMLNode::DeleteChild( XMLNode* node )
   4.650 +{
   4.651 +    TIXMLASSERT( node->_parent == this );
   4.652 +    DELETE_NODE( node );
   4.653 +}
   4.654 +
   4.655 +
   4.656 +XMLNode* XMLNode::InsertEndChild( XMLNode* addThis )
   4.657 +{
   4.658 +    if ( _lastChild ) {
   4.659 +        TIXMLASSERT( _firstChild );
   4.660 +        TIXMLASSERT( _lastChild->_next == 0 );
   4.661 +        _lastChild->_next = addThis;
   4.662 +        addThis->_prev = _lastChild;
   4.663 +        _lastChild = addThis;
   4.664 +
   4.665 +        addThis->_next = 0;
   4.666 +    }
   4.667 +    else {
   4.668 +        TIXMLASSERT( _firstChild == 0 );
   4.669 +        _firstChild = _lastChild = addThis;
   4.670 +
   4.671 +        addThis->_prev = 0;
   4.672 +        addThis->_next = 0;
   4.673 +    }
   4.674 +    addThis->_parent = this;
   4.675 +    addThis->_memPool->SetTracked();
   4.676 +    return addThis;
   4.677 +}
   4.678 +
   4.679 +
   4.680 +XMLNode* XMLNode::InsertFirstChild( XMLNode* addThis )
   4.681 +{
   4.682 +    if ( _firstChild ) {
   4.683 +        TIXMLASSERT( _lastChild );
   4.684 +        TIXMLASSERT( _firstChild->_prev == 0 );
   4.685 +
   4.686 +        _firstChild->_prev = addThis;
   4.687 +        addThis->_next = _firstChild;
   4.688 +        _firstChild = addThis;
   4.689 +
   4.690 +        addThis->_prev = 0;
   4.691 +    }
   4.692 +    else {
   4.693 +        TIXMLASSERT( _lastChild == 0 );
   4.694 +        _firstChild = _lastChild = addThis;
   4.695 +
   4.696 +        addThis->_prev = 0;
   4.697 +        addThis->_next = 0;
   4.698 +    }
   4.699 +    addThis->_parent = this;
   4.700 +    addThis->_memPool->SetTracked();
   4.701 +    return addThis;
   4.702 +}
   4.703 +
   4.704 +
   4.705 +XMLNode* XMLNode::InsertAfterChild( XMLNode* afterThis, XMLNode* addThis )
   4.706 +{
   4.707 +    TIXMLASSERT( afterThis->_parent == this );
   4.708 +    if ( afterThis->_parent != this ) {
   4.709 +        return 0;
   4.710 +    }
   4.711 +
   4.712 +    if ( afterThis->_next == 0 ) {
   4.713 +        // The last node or the only node.
   4.714 +        return InsertEndChild( addThis );
   4.715 +    }
   4.716 +    addThis->_prev = afterThis;
   4.717 +    addThis->_next = afterThis->_next;
   4.718 +    afterThis->_next->_prev = addThis;
   4.719 +    afterThis->_next = addThis;
   4.720 +    addThis->_parent = this;
   4.721 +    addThis->_memPool->SetTracked();
   4.722 +    return addThis;
   4.723 +}
   4.724 +
   4.725 +
   4.726 +
   4.727 +
   4.728 +const XMLElement* XMLNode::FirstChildElement( const char* value ) const
   4.729 +{
   4.730 +    for( XMLNode* node=_firstChild; node; node=node->_next ) {
   4.731 +        XMLElement* element = node->ToElement();
   4.732 +        if ( element ) {
   4.733 +            if ( !value || XMLUtil::StringEqual( element->Name(), value ) ) {
   4.734 +                return element;
   4.735 +            }
   4.736 +        }
   4.737 +    }
   4.738 +    return 0;
   4.739 +}
   4.740 +
   4.741 +
   4.742 +const XMLElement* XMLNode::LastChildElement( const char* value ) const
   4.743 +{
   4.744 +    for( XMLNode* node=_lastChild; node; node=node->_prev ) {
   4.745 +        XMLElement* element = node->ToElement();
   4.746 +        if ( element ) {
   4.747 +            if ( !value || XMLUtil::StringEqual( element->Name(), value ) ) {
   4.748 +                return element;
   4.749 +            }
   4.750 +        }
   4.751 +    }
   4.752 +    return 0;
   4.753 +}
   4.754 +
   4.755 +
   4.756 +const XMLElement* XMLNode::NextSiblingElement( const char* value ) const
   4.757 +{
   4.758 +    for( XMLNode* element=this->_next; element; element = element->_next ) {
   4.759 +        if (    element->ToElement()
   4.760 +                && (!value || XMLUtil::StringEqual( value, element->Value() ))) {
   4.761 +            return element->ToElement();
   4.762 +        }
   4.763 +    }
   4.764 +    return 0;
   4.765 +}
   4.766 +
   4.767 +
   4.768 +const XMLElement* XMLNode::PreviousSiblingElement( const char* value ) const
   4.769 +{
   4.770 +    for( XMLNode* element=_prev; element; element = element->_prev ) {
   4.771 +        if (    element->ToElement()
   4.772 +                && (!value || XMLUtil::StringEqual( value, element->Value() ))) {
   4.773 +            return element->ToElement();
   4.774 +        }
   4.775 +    }
   4.776 +    return 0;
   4.777 +}
   4.778 +
   4.779 +
   4.780 +char* XMLNode::ParseDeep( char* p, StrPair* parentEnd )
   4.781 +{
   4.782 +    // This is a recursive method, but thinking about it "at the current level"
   4.783 +    // it is a pretty simple flat list:
   4.784 +    //		<foo/>
   4.785 +    //		<!-- comment -->
   4.786 +    //
   4.787 +    // With a special case:
   4.788 +    //		<foo>
   4.789 +    //		</foo>
   4.790 +    //		<!-- comment -->
   4.791 +    //
   4.792 +    // Where the closing element (/foo) *must* be the next thing after the opening
   4.793 +    // element, and the names must match. BUT the tricky bit is that the closing
   4.794 +    // element will be read by the child.
   4.795 +    //
   4.796 +    // 'endTag' is the end tag for this node, it is returned by a call to a child.
   4.797 +    // 'parentEnd' is the end tag for the parent, which is filled in and returned.
   4.798 +
   4.799 +    while( p && *p ) {
   4.800 +        XMLNode* node = 0;
   4.801 +
   4.802 +        p = _document->Identify( p, &node );
   4.803 +        if ( p == 0 || node == 0 ) {
   4.804 +            break;
   4.805 +        }
   4.806 +
   4.807 +        StrPair endTag;
   4.808 +        p = node->ParseDeep( p, &endTag );
   4.809 +        if ( !p ) {
   4.810 +            DELETE_NODE( node );
   4.811 +            node = 0;
   4.812 +            if ( !_document->Error() ) {
   4.813 +                _document->SetError( XML_ERROR_PARSING, 0, 0 );
   4.814 +            }
   4.815 +            break;
   4.816 +        }
   4.817 +
   4.818 +        // We read the end tag. Return it to the parent.
   4.819 +        if ( node->ToElement() && node->ToElement()->ClosingType() == XMLElement::CLOSING ) {
   4.820 +            if ( parentEnd ) {
   4.821 +                *parentEnd = static_cast<XMLElement*>(node)->_value;
   4.822 +            }
   4.823 +			node->_memPool->SetTracked();	// created and then immediately deleted.
   4.824 +            DELETE_NODE( node );
   4.825 +            return p;
   4.826 +        }
   4.827 +
   4.828 +        // Handle an end tag returned to this level.
   4.829 +        // And handle a bunch of annoying errors.
   4.830 +        XMLElement* ele = node->ToElement();
   4.831 +        if ( ele ) {
   4.832 +            if ( endTag.Empty() && ele->ClosingType() == XMLElement::OPEN ) {
   4.833 +                _document->SetError( XML_ERROR_MISMATCHED_ELEMENT, node->Value(), 0 );
   4.834 +                p = 0;
   4.835 +            }
   4.836 +            else if ( !endTag.Empty() && ele->ClosingType() != XMLElement::OPEN ) {
   4.837 +                _document->SetError( XML_ERROR_MISMATCHED_ELEMENT, node->Value(), 0 );
   4.838 +                p = 0;
   4.839 +            }
   4.840 +            else if ( !endTag.Empty() ) {
   4.841 +                if ( !XMLUtil::StringEqual( endTag.GetStr(), node->Value() )) {
   4.842 +                    _document->SetError( XML_ERROR_MISMATCHED_ELEMENT, node->Value(), 0 );
   4.843 +                    p = 0;
   4.844 +                }
   4.845 +            }
   4.846 +        }
   4.847 +        if ( p == 0 ) {
   4.848 +            DELETE_NODE( node );
   4.849 +            node = 0;
   4.850 +        }
   4.851 +        if ( node ) {
   4.852 +            this->InsertEndChild( node );
   4.853 +        }
   4.854 +    }
   4.855 +    return 0;
   4.856 +}
   4.857 +
   4.858 +// --------- XMLText ---------- //
   4.859 +char* XMLText::ParseDeep( char* p, StrPair* )
   4.860 +{
   4.861 +    const char* start = p;
   4.862 +    if ( this->CData() ) {
   4.863 +        p = _value.ParseText( p, "]]>", StrPair::NEEDS_NEWLINE_NORMALIZATION );
   4.864 +        if ( !p ) {
   4.865 +            _document->SetError( XML_ERROR_PARSING_CDATA, start, 0 );
   4.866 +        }
   4.867 +        return p;
   4.868 +    }
   4.869 +    else {
   4.870 +        int flags = _document->ProcessEntities() ? StrPair::TEXT_ELEMENT : StrPair::TEXT_ELEMENT_LEAVE_ENTITIES;
   4.871 +        if ( _document->WhitespaceMode() == COLLAPSE_WHITESPACE ) {
   4.872 +            flags |= StrPair::COLLAPSE_WHITESPACE;
   4.873 +        }
   4.874 +
   4.875 +        p = _value.ParseText( p, "<", flags );
   4.876 +        if ( !p ) {
   4.877 +            _document->SetError( XML_ERROR_PARSING_TEXT, start, 0 );
   4.878 +        }
   4.879 +        if ( p && *p ) {
   4.880 +            return p-1;
   4.881 +        }
   4.882 +    }
   4.883 +    return 0;
   4.884 +}
   4.885 +
   4.886 +
   4.887 +XMLNode* XMLText::ShallowClone( XMLDocument* doc ) const
   4.888 +{
   4.889 +    if ( !doc ) {
   4.890 +        doc = _document;
   4.891 +    }
   4.892 +    XMLText* text = doc->NewText( Value() );	// fixme: this will always allocate memory. Intern?
   4.893 +    text->SetCData( this->CData() );
   4.894 +    return text;
   4.895 +}
   4.896 +
   4.897 +
   4.898 +bool XMLText::ShallowEqual( const XMLNode* compare ) const
   4.899 +{
   4.900 +    return ( compare->ToText() && XMLUtil::StringEqual( compare->ToText()->Value(), Value() ));
   4.901 +}
   4.902 +
   4.903 +
   4.904 +bool XMLText::Accept( XMLVisitor* visitor ) const
   4.905 +{
   4.906 +    return visitor->Visit( *this );
   4.907 +}
   4.908 +
   4.909 +
   4.910 +// --------- XMLComment ---------- //
   4.911 +
   4.912 +XMLComment::XMLComment( XMLDocument* doc ) : XMLNode( doc )
   4.913 +{
   4.914 +}
   4.915 +
   4.916 +
   4.917 +XMLComment::~XMLComment()
   4.918 +{
   4.919 +}
   4.920 +
   4.921 +
   4.922 +char* XMLComment::ParseDeep( char* p, StrPair* )
   4.923 +{
   4.924 +    // Comment parses as text.
   4.925 +    const char* start = p;
   4.926 +    p = _value.ParseText( p, "-->", StrPair::COMMENT );
   4.927 +    if ( p == 0 ) {
   4.928 +        _document->SetError( XML_ERROR_PARSING_COMMENT, start, 0 );
   4.929 +    }
   4.930 +    return p;
   4.931 +}
   4.932 +
   4.933 +
   4.934 +XMLNode* XMLComment::ShallowClone( XMLDocument* doc ) const
   4.935 +{
   4.936 +    if ( !doc ) {
   4.937 +        doc = _document;
   4.938 +    }
   4.939 +    XMLComment* comment = doc->NewComment( Value() );	// fixme: this will always allocate memory. Intern?
   4.940 +    return comment;
   4.941 +}
   4.942 +
   4.943 +
   4.944 +bool XMLComment::ShallowEqual( const XMLNode* compare ) const
   4.945 +{
   4.946 +    return ( compare->ToComment() && XMLUtil::StringEqual( compare->ToComment()->Value(), Value() ));
   4.947 +}
   4.948 +
   4.949 +
   4.950 +bool XMLComment::Accept( XMLVisitor* visitor ) const
   4.951 +{
   4.952 +    return visitor->Visit( *this );
   4.953 +}
   4.954 +
   4.955 +
   4.956 +// --------- XMLDeclaration ---------- //
   4.957 +
   4.958 +XMLDeclaration::XMLDeclaration( XMLDocument* doc ) : XMLNode( doc )
   4.959 +{
   4.960 +}
   4.961 +
   4.962 +
   4.963 +XMLDeclaration::~XMLDeclaration()
   4.964 +{
   4.965 +    //printf( "~XMLDeclaration\n" );
   4.966 +}
   4.967 +
   4.968 +
   4.969 +char* XMLDeclaration::ParseDeep( char* p, StrPair* )
   4.970 +{
   4.971 +    // Declaration parses as text.
   4.972 +    const char* start = p;
   4.973 +    p = _value.ParseText( p, "?>", StrPair::NEEDS_NEWLINE_NORMALIZATION );
   4.974 +    if ( p == 0 ) {
   4.975 +        _document->SetError( XML_ERROR_PARSING_DECLARATION, start, 0 );
   4.976 +    }
   4.977 +    return p;
   4.978 +}
   4.979 +
   4.980 +
   4.981 +XMLNode* XMLDeclaration::ShallowClone( XMLDocument* doc ) const
   4.982 +{
   4.983 +    if ( !doc ) {
   4.984 +        doc = _document;
   4.985 +    }
   4.986 +    XMLDeclaration* dec = doc->NewDeclaration( Value() );	// fixme: this will always allocate memory. Intern?
   4.987 +    return dec;
   4.988 +}
   4.989 +
   4.990 +
   4.991 +bool XMLDeclaration::ShallowEqual( const XMLNode* compare ) const
   4.992 +{
   4.993 +    return ( compare->ToDeclaration() && XMLUtil::StringEqual( compare->ToDeclaration()->Value(), Value() ));
   4.994 +}
   4.995 +
   4.996 +
   4.997 +
   4.998 +bool XMLDeclaration::Accept( XMLVisitor* visitor ) const
   4.999 +{
  4.1000 +    return visitor->Visit( *this );
  4.1001 +}
  4.1002 +
  4.1003 +// --------- XMLUnknown ---------- //
  4.1004 +
  4.1005 +XMLUnknown::XMLUnknown( XMLDocument* doc ) : XMLNode( doc )
  4.1006 +{
  4.1007 +}
  4.1008 +
  4.1009 +
  4.1010 +XMLUnknown::~XMLUnknown()
  4.1011 +{
  4.1012 +}
  4.1013 +
  4.1014 +
  4.1015 +char* XMLUnknown::ParseDeep( char* p, StrPair* )
  4.1016 +{
  4.1017 +    // Unknown parses as text.
  4.1018 +    const char* start = p;
  4.1019 +
  4.1020 +    p = _value.ParseText( p, ">", StrPair::NEEDS_NEWLINE_NORMALIZATION );
  4.1021 +    if ( !p ) {
  4.1022 +        _document->SetError( XML_ERROR_PARSING_UNKNOWN, start, 0 );
  4.1023 +    }
  4.1024 +    return p;
  4.1025 +}
  4.1026 +
  4.1027 +
  4.1028 +XMLNode* XMLUnknown::ShallowClone( XMLDocument* doc ) const
  4.1029 +{
  4.1030 +    if ( !doc ) {
  4.1031 +        doc = _document;
  4.1032 +    }
  4.1033 +    XMLUnknown* text = doc->NewUnknown( Value() );	// fixme: this will always allocate memory. Intern?
  4.1034 +    return text;
  4.1035 +}
  4.1036 +
  4.1037 +
  4.1038 +bool XMLUnknown::ShallowEqual( const XMLNode* compare ) const
  4.1039 +{
  4.1040 +    return ( compare->ToUnknown() && XMLUtil::StringEqual( compare->ToUnknown()->Value(), Value() ));
  4.1041 +}
  4.1042 +
  4.1043 +
  4.1044 +bool XMLUnknown::Accept( XMLVisitor* visitor ) const
  4.1045 +{
  4.1046 +    return visitor->Visit( *this );
  4.1047 +}
  4.1048 +
  4.1049 +// --------- XMLAttribute ---------- //
  4.1050 +char* XMLAttribute::ParseDeep( char* p, bool processEntities )
  4.1051 +{
  4.1052 +    // Parse using the name rules: bug fix, was using ParseText before
  4.1053 +    p = _name.ParseName( p );
  4.1054 +    if ( !p || !*p ) {
  4.1055 +        return 0;
  4.1056 +    }
  4.1057 +
  4.1058 +    // Skip white space before =
  4.1059 +    p = XMLUtil::SkipWhiteSpace( p );
  4.1060 +    if ( !p || *p != '=' ) {
  4.1061 +        return 0;
  4.1062 +    }
  4.1063 +
  4.1064 +    ++p;	// move up to opening quote
  4.1065 +    p = XMLUtil::SkipWhiteSpace( p );
  4.1066 +    if ( *p != '\"' && *p != '\'' ) {
  4.1067 +        return 0;
  4.1068 +    }
  4.1069 +
  4.1070 +    char endTag[2] = { *p, 0 };
  4.1071 +    ++p;	// move past opening quote
  4.1072 +
  4.1073 +    p = _value.ParseText( p, endTag, processEntities ? StrPair::ATTRIBUTE_VALUE : StrPair::ATTRIBUTE_VALUE_LEAVE_ENTITIES );
  4.1074 +    return p;
  4.1075 +}
  4.1076 +
  4.1077 +
  4.1078 +void XMLAttribute::SetName( const char* n )
  4.1079 +{
  4.1080 +    _name.SetStr( n );
  4.1081 +}
  4.1082 +
  4.1083 +
  4.1084 +XMLError XMLAttribute::QueryIntValue( int* value ) const
  4.1085 +{
  4.1086 +    if ( XMLUtil::ToInt( Value(), value )) {
  4.1087 +        return XML_NO_ERROR;
  4.1088 +    }
  4.1089 +    return XML_WRONG_ATTRIBUTE_TYPE;
  4.1090 +}
  4.1091 +
  4.1092 +
  4.1093 +XMLError XMLAttribute::QueryUnsignedValue( unsigned int* value ) const
  4.1094 +{
  4.1095 +    if ( XMLUtil::ToUnsigned( Value(), value )) {
  4.1096 +        return XML_NO_ERROR;
  4.1097 +    }
  4.1098 +    return XML_WRONG_ATTRIBUTE_TYPE;
  4.1099 +}
  4.1100 +
  4.1101 +
  4.1102 +XMLError XMLAttribute::QueryBoolValue( bool* value ) const
  4.1103 +{
  4.1104 +    if ( XMLUtil::ToBool( Value(), value )) {
  4.1105 +        return XML_NO_ERROR;
  4.1106 +    }
  4.1107 +    return XML_WRONG_ATTRIBUTE_TYPE;
  4.1108 +}
  4.1109 +
  4.1110 +
  4.1111 +XMLError XMLAttribute::QueryFloatValue( float* value ) const
  4.1112 +{
  4.1113 +    if ( XMLUtil::ToFloat( Value(), value )) {
  4.1114 +        return XML_NO_ERROR;
  4.1115 +    }
  4.1116 +    return XML_WRONG_ATTRIBUTE_TYPE;
  4.1117 +}
  4.1118 +
  4.1119 +
  4.1120 +XMLError XMLAttribute::QueryDoubleValue( double* value ) const
  4.1121 +{
  4.1122 +    if ( XMLUtil::ToDouble( Value(), value )) {
  4.1123 +        return XML_NO_ERROR;
  4.1124 +    }
  4.1125 +    return XML_WRONG_ATTRIBUTE_TYPE;
  4.1126 +}
  4.1127 +
  4.1128 +
  4.1129 +void XMLAttribute::SetAttribute( const char* v )
  4.1130 +{
  4.1131 +    _value.SetStr( v );
  4.1132 +}
  4.1133 +
  4.1134 +
  4.1135 +void XMLAttribute::SetAttribute( int v )
  4.1136 +{
  4.1137 +    char buf[BUF_SIZE];
  4.1138 +    XMLUtil::ToStr( v, buf, BUF_SIZE );
  4.1139 +    _value.SetStr( buf );
  4.1140 +}
  4.1141 +
  4.1142 +
  4.1143 +void XMLAttribute::SetAttribute( unsigned v )
  4.1144 +{
  4.1145 +    char buf[BUF_SIZE];
  4.1146 +    XMLUtil::ToStr( v, buf, BUF_SIZE );
  4.1147 +    _value.SetStr( buf );
  4.1148 +}
  4.1149 +
  4.1150 +
  4.1151 +void XMLAttribute::SetAttribute( bool v )
  4.1152 +{
  4.1153 +    char buf[BUF_SIZE];
  4.1154 +    XMLUtil::ToStr( v, buf, BUF_SIZE );
  4.1155 +    _value.SetStr( buf );
  4.1156 +}
  4.1157 +
  4.1158 +void XMLAttribute::SetAttribute( double v )
  4.1159 +{
  4.1160 +    char buf[BUF_SIZE];
  4.1161 +    XMLUtil::ToStr( v, buf, BUF_SIZE );
  4.1162 +    _value.SetStr( buf );
  4.1163 +}
  4.1164 +
  4.1165 +void XMLAttribute::SetAttribute( float v )
  4.1166 +{
  4.1167 +    char buf[BUF_SIZE];
  4.1168 +    XMLUtil::ToStr( v, buf, BUF_SIZE );
  4.1169 +    _value.SetStr( buf );
  4.1170 +}
  4.1171 +
  4.1172 +
  4.1173 +// --------- XMLElement ---------- //
  4.1174 +XMLElement::XMLElement( XMLDocument* doc ) : XMLNode( doc ),
  4.1175 +    _closingType( 0 ),
  4.1176 +    _rootAttribute( 0 )
  4.1177 +{
  4.1178 +}
  4.1179 +
  4.1180 +
  4.1181 +XMLElement::~XMLElement()
  4.1182 +{
  4.1183 +    while( _rootAttribute ) {
  4.1184 +        XMLAttribute* next = _rootAttribute->_next;
  4.1185 +        DELETE_ATTRIBUTE( _rootAttribute );
  4.1186 +        _rootAttribute = next;
  4.1187 +    }
  4.1188 +}
  4.1189 +
  4.1190 +
  4.1191 +XMLAttribute* XMLElement::FindAttribute( const char* name )
  4.1192 +{
  4.1193 +    XMLAttribute* a = 0;
  4.1194 +    for( a=_rootAttribute; a; a = a->_next ) {
  4.1195 +        if ( XMLUtil::StringEqual( a->Name(), name ) ) {
  4.1196 +            return a;
  4.1197 +        }
  4.1198 +    }
  4.1199 +    return 0;
  4.1200 +}
  4.1201 +
  4.1202 +
  4.1203 +const XMLAttribute* XMLElement::FindAttribute( const char* name ) const
  4.1204 +{
  4.1205 +    XMLAttribute* a = 0;
  4.1206 +    for( a=_rootAttribute; a; a = a->_next ) {
  4.1207 +        if ( XMLUtil::StringEqual( a->Name(), name ) ) {
  4.1208 +            return a;
  4.1209 +        }
  4.1210 +    }
  4.1211 +    return 0;
  4.1212 +}
  4.1213 +
  4.1214 +
  4.1215 +const char* XMLElement::Attribute( const char* name, const char* value ) const
  4.1216 +{
  4.1217 +    const XMLAttribute* a = FindAttribute( name );
  4.1218 +    if ( !a ) {
  4.1219 +        return 0;
  4.1220 +    }
  4.1221 +    if ( !value || XMLUtil::StringEqual( a->Value(), value )) {
  4.1222 +        return a->Value();
  4.1223 +    }
  4.1224 +    return 0;
  4.1225 +}
  4.1226 +
  4.1227 +
  4.1228 +const char* XMLElement::GetText() const
  4.1229 +{
  4.1230 +    if ( FirstChild() && FirstChild()->ToText() ) {
  4.1231 +        return FirstChild()->ToText()->Value();
  4.1232 +    }
  4.1233 +    return 0;
  4.1234 +}
  4.1235 +
  4.1236 +
  4.1237 +XMLError XMLElement::QueryIntText( int* ival ) const
  4.1238 +{
  4.1239 +    if ( FirstChild() && FirstChild()->ToText() ) {
  4.1240 +        const char* t = FirstChild()->ToText()->Value();
  4.1241 +        if ( XMLUtil::ToInt( t, ival ) ) {
  4.1242 +            return XML_SUCCESS;
  4.1243 +        }
  4.1244 +        return XML_CAN_NOT_CONVERT_TEXT;
  4.1245 +    }
  4.1246 +    return XML_NO_TEXT_NODE;
  4.1247 +}
  4.1248 +
  4.1249 +
  4.1250 +XMLError XMLElement::QueryUnsignedText( unsigned* uval ) const
  4.1251 +{
  4.1252 +    if ( FirstChild() && FirstChild()->ToText() ) {
  4.1253 +        const char* t = FirstChild()->ToText()->Value();
  4.1254 +        if ( XMLUtil::ToUnsigned( t, uval ) ) {
  4.1255 +            return XML_SUCCESS;
  4.1256 +        }
  4.1257 +        return XML_CAN_NOT_CONVERT_TEXT;
  4.1258 +    }
  4.1259 +    return XML_NO_TEXT_NODE;
  4.1260 +}
  4.1261 +
  4.1262 +
  4.1263 +XMLError XMLElement::QueryBoolText( bool* bval ) const
  4.1264 +{
  4.1265 +    if ( FirstChild() && FirstChild()->ToText() ) {
  4.1266 +        const char* t = FirstChild()->ToText()->Value();
  4.1267 +        if ( XMLUtil::ToBool( t, bval ) ) {
  4.1268 +            return XML_SUCCESS;
  4.1269 +        }
  4.1270 +        return XML_CAN_NOT_CONVERT_TEXT;
  4.1271 +    }
  4.1272 +    return XML_NO_TEXT_NODE;
  4.1273 +}
  4.1274 +
  4.1275 +
  4.1276 +XMLError XMLElement::QueryDoubleText( double* dval ) const
  4.1277 +{
  4.1278 +    if ( FirstChild() && FirstChild()->ToText() ) {
  4.1279 +        const char* t = FirstChild()->ToText()->Value();
  4.1280 +        if ( XMLUtil::ToDouble( t, dval ) ) {
  4.1281 +            return XML_SUCCESS;
  4.1282 +        }
  4.1283 +        return XML_CAN_NOT_CONVERT_TEXT;
  4.1284 +    }
  4.1285 +    return XML_NO_TEXT_NODE;
  4.1286 +}
  4.1287 +
  4.1288 +
  4.1289 +XMLError XMLElement::QueryFloatText( float* fval ) const
  4.1290 +{
  4.1291 +    if ( FirstChild() && FirstChild()->ToText() ) {
  4.1292 +        const char* t = FirstChild()->ToText()->Value();
  4.1293 +        if ( XMLUtil::ToFloat( t, fval ) ) {
  4.1294 +            return XML_SUCCESS;
  4.1295 +        }
  4.1296 +        return XML_CAN_NOT_CONVERT_TEXT;
  4.1297 +    }
  4.1298 +    return XML_NO_TEXT_NODE;
  4.1299 +}
  4.1300 +
  4.1301 +
  4.1302 +
  4.1303 +XMLAttribute* XMLElement::FindOrCreateAttribute( const char* name )
  4.1304 +{
  4.1305 +    XMLAttribute* last = 0;
  4.1306 +    XMLAttribute* attrib = 0;
  4.1307 +    for( attrib = _rootAttribute;
  4.1308 +            attrib;
  4.1309 +            last = attrib, attrib = attrib->_next ) {
  4.1310 +        if ( XMLUtil::StringEqual( attrib->Name(), name ) ) {
  4.1311 +            break;
  4.1312 +        }
  4.1313 +    }
  4.1314 +    if ( !attrib ) {
  4.1315 +        attrib = new (_document->_attributePool.Alloc() ) XMLAttribute();
  4.1316 +        attrib->_memPool = &_document->_attributePool;
  4.1317 +        if ( last ) {
  4.1318 +            last->_next = attrib;
  4.1319 +        }
  4.1320 +        else {
  4.1321 +            _rootAttribute = attrib;
  4.1322 +        }
  4.1323 +        attrib->SetName( name );
  4.1324 +        attrib->_memPool->SetTracked(); // always created and linked.
  4.1325 +    }
  4.1326 +    return attrib;
  4.1327 +}
  4.1328 +
  4.1329 +
  4.1330 +void XMLElement::DeleteAttribute( const char* name )
  4.1331 +{
  4.1332 +    XMLAttribute* prev = 0;
  4.1333 +    for( XMLAttribute* a=_rootAttribute; a; a=a->_next ) {
  4.1334 +        if ( XMLUtil::StringEqual( name, a->Name() ) ) {
  4.1335 +            if ( prev ) {
  4.1336 +                prev->_next = a->_next;
  4.1337 +            }
  4.1338 +            else {
  4.1339 +                _rootAttribute = a->_next;
  4.1340 +            }
  4.1341 +            DELETE_ATTRIBUTE( a );
  4.1342 +            break;
  4.1343 +        }
  4.1344 +        prev = a;
  4.1345 +    }
  4.1346 +}
  4.1347 +
  4.1348 +
  4.1349 +char* XMLElement::ParseAttributes( char* p )
  4.1350 +{
  4.1351 +    const char* start = p;
  4.1352 +    XMLAttribute* prevAttribute = 0;
  4.1353 +
  4.1354 +    // Read the attributes.
  4.1355 +    while( p ) {
  4.1356 +        p = XMLUtil::SkipWhiteSpace( p );
  4.1357 +        if ( !p || !(*p) ) {
  4.1358 +            _document->SetError( XML_ERROR_PARSING_ELEMENT, start, Name() );
  4.1359 +            return 0;
  4.1360 +        }
  4.1361 +
  4.1362 +        // attribute.
  4.1363 +        if ( XMLUtil::IsAlpha( *p ) ) {
  4.1364 +            XMLAttribute* attrib = new (_document->_attributePool.Alloc() ) XMLAttribute();
  4.1365 +            attrib->_memPool = &_document->_attributePool;
  4.1366 +			attrib->_memPool->SetTracked();
  4.1367 +
  4.1368 +            p = attrib->ParseDeep( p, _document->ProcessEntities() );
  4.1369 +            if ( !p || Attribute( attrib->Name() ) ) {
  4.1370 +                DELETE_ATTRIBUTE( attrib );
  4.1371 +                _document->SetError( XML_ERROR_PARSING_ATTRIBUTE, start, p );
  4.1372 +                return 0;
  4.1373 +            }
  4.1374 +            // There is a minor bug here: if the attribute in the source xml
  4.1375 +            // document is duplicated, it will not be detected and the
  4.1376 +            // attribute will be doubly added. However, tracking the 'prevAttribute'
  4.1377 +            // avoids re-scanning the attribute list. Preferring performance for
  4.1378 +            // now, may reconsider in the future.
  4.1379 +            if ( prevAttribute ) {
  4.1380 +                prevAttribute->_next = attrib;
  4.1381 +            }
  4.1382 +            else {
  4.1383 +                _rootAttribute = attrib;
  4.1384 +            }
  4.1385 +            prevAttribute = attrib;
  4.1386 +        }
  4.1387 +        // end of the tag
  4.1388 +        else if ( *p == '/' && *(p+1) == '>' ) {
  4.1389 +            _closingType = CLOSED;
  4.1390 +            return p+2;	// done; sealed element.
  4.1391 +        }
  4.1392 +        // end of the tag
  4.1393 +        else if ( *p == '>' ) {
  4.1394 +            ++p;
  4.1395 +            break;
  4.1396 +        }
  4.1397 +        else {
  4.1398 +            _document->SetError( XML_ERROR_PARSING_ELEMENT, start, p );
  4.1399 +            return 0;
  4.1400 +        }
  4.1401 +    }
  4.1402 +    return p;
  4.1403 +}
  4.1404 +
  4.1405 +
  4.1406 +//
  4.1407 +//	<ele></ele>
  4.1408 +//	<ele>foo<b>bar</b></ele>
  4.1409 +//
  4.1410 +char* XMLElement::ParseDeep( char* p, StrPair* strPair )
  4.1411 +{
  4.1412 +    // Read the element name.
  4.1413 +    p = XMLUtil::SkipWhiteSpace( p );
  4.1414 +    if ( !p ) {
  4.1415 +        return 0;
  4.1416 +    }
  4.1417 +
  4.1418 +    // The closing element is the </element> form. It is
  4.1419 +    // parsed just like a regular element then deleted from
  4.1420 +    // the DOM.
  4.1421 +    if ( *p == '/' ) {
  4.1422 +        _closingType = CLOSING;
  4.1423 +        ++p;
  4.1424 +    }
  4.1425 +
  4.1426 +    p = _value.ParseName( p );
  4.1427 +    if ( _value.Empty() ) {
  4.1428 +        return 0;
  4.1429 +    }
  4.1430 +
  4.1431 +    p = ParseAttributes( p );
  4.1432 +    if ( !p || !*p || _closingType ) {
  4.1433 +        return p;
  4.1434 +    }
  4.1435 +
  4.1436 +    p = XMLNode::ParseDeep( p, strPair );
  4.1437 +    return p;
  4.1438 +}
  4.1439 +
  4.1440 +
  4.1441 +
  4.1442 +XMLNode* XMLElement::ShallowClone( XMLDocument* doc ) const
  4.1443 +{
  4.1444 +    if ( !doc ) {
  4.1445 +        doc = _document;
  4.1446 +    }
  4.1447 +    XMLElement* element = doc->NewElement( Value() );					// fixme: this will always allocate memory. Intern?
  4.1448 +    for( const XMLAttribute* a=FirstAttribute(); a; a=a->Next() ) {
  4.1449 +        element->SetAttribute( a->Name(), a->Value() );					// fixme: this will always allocate memory. Intern?
  4.1450 +    }
  4.1451 +    return element;
  4.1452 +}
  4.1453 +
  4.1454 +
  4.1455 +bool XMLElement::ShallowEqual( const XMLNode* compare ) const
  4.1456 +{
  4.1457 +    const XMLElement* other = compare->ToElement();
  4.1458 +    if ( other && XMLUtil::StringEqual( other->Value(), Value() )) {
  4.1459 +
  4.1460 +        const XMLAttribute* a=FirstAttribute();
  4.1461 +        const XMLAttribute* b=other->FirstAttribute();
  4.1462 +
  4.1463 +        while ( a && b ) {
  4.1464 +            if ( !XMLUtil::StringEqual( a->Value(), b->Value() ) ) {
  4.1465 +                return false;
  4.1466 +            }
  4.1467 +            a = a->Next();
  4.1468 +            b = b->Next();
  4.1469 +        }
  4.1470 +        if ( a || b ) {
  4.1471 +            // different count
  4.1472 +            return false;
  4.1473 +        }
  4.1474 +        return true;
  4.1475 +    }
  4.1476 +    return false;
  4.1477 +}
  4.1478 +
  4.1479 +
  4.1480 +bool XMLElement::Accept( XMLVisitor* visitor ) const
  4.1481 +{
  4.1482 +    if ( visitor->VisitEnter( *this, _rootAttribute ) ) {
  4.1483 +        for ( const XMLNode* node=FirstChild(); node; node=node->NextSibling() ) {
  4.1484 +            if ( !node->Accept( visitor ) ) {
  4.1485 +                break;
  4.1486 +            }
  4.1487 +        }
  4.1488 +    }
  4.1489 +    return visitor->VisitExit( *this );
  4.1490 +}
  4.1491 +
  4.1492 +
  4.1493 +// --------- XMLDocument ----------- //
  4.1494 +XMLDocument::XMLDocument( bool processEntities, Whitespace whitespace ) :
  4.1495 +    XMLNode( 0 ),
  4.1496 +    _writeBOM( false ),
  4.1497 +    _processEntities( processEntities ),
  4.1498 +    _errorID( XML_NO_ERROR ),
  4.1499 +    _whitespace( whitespace ),
  4.1500 +    _errorStr1( 0 ),
  4.1501 +    _errorStr2( 0 ),
  4.1502 +    _charBuffer( 0 )
  4.1503 +{
  4.1504 +    _document = this;	// avoid warning about 'this' in initializer list
  4.1505 +}
  4.1506 +
  4.1507 +
  4.1508 +XMLDocument::~XMLDocument()
  4.1509 +{
  4.1510 +    DeleteChildren();
  4.1511 +    delete [] _charBuffer;
  4.1512 +
  4.1513 +#if 0
  4.1514 +    textPool.Trace( "text" );
  4.1515 +    elementPool.Trace( "element" );
  4.1516 +    commentPool.Trace( "comment" );
  4.1517 +    attributePool.Trace( "attribute" );
  4.1518 +#endif
  4.1519 +
  4.1520 +#ifdef DEBUG
  4.1521 +	if ( Error() == false ) {
  4.1522 +		TIXMLASSERT( _elementPool.CurrentAllocs()   == _elementPool.Untracked() );
  4.1523 +		TIXMLASSERT( _attributePool.CurrentAllocs() == _attributePool.Untracked() );
  4.1524 +		TIXMLASSERT( _textPool.CurrentAllocs()      == _textPool.Untracked() );
  4.1525 +		TIXMLASSERT( _commentPool.CurrentAllocs()   == _commentPool.Untracked() );
  4.1526 +	}
  4.1527 +#endif
  4.1528 +}
  4.1529 +
  4.1530 +
  4.1531 +void XMLDocument::InitDocument()
  4.1532 +{
  4.1533 +    _errorID = XML_NO_ERROR;
  4.1534 +    _errorStr1 = 0;
  4.1535 +    _errorStr2 = 0;
  4.1536 +
  4.1537 +    delete [] _charBuffer;
  4.1538 +    _charBuffer = 0;
  4.1539 +}
  4.1540 +
  4.1541 +
  4.1542 +XMLElement* XMLDocument::NewElement( const char* name )
  4.1543 +{
  4.1544 +    XMLElement* ele = new (_elementPool.Alloc()) XMLElement( this );
  4.1545 +    ele->_memPool = &_elementPool;
  4.1546 +    ele->SetName( name );
  4.1547 +    return ele;
  4.1548 +}
  4.1549 +
  4.1550 +
  4.1551 +XMLComment* XMLDocument::NewComment( const char* str )
  4.1552 +{
  4.1553 +    XMLComment* comment = new (_commentPool.Alloc()) XMLComment( this );
  4.1554 +    comment->_memPool = &_commentPool;
  4.1555 +    comment->SetValue( str );
  4.1556 +    return comment;
  4.1557 +}
  4.1558 +
  4.1559 +
  4.1560 +XMLText* XMLDocument::NewText( const char* str )
  4.1561 +{
  4.1562 +    XMLText* text = new (_textPool.Alloc()) XMLText( this );
  4.1563 +    text->_memPool = &_textPool;
  4.1564 +    text->SetValue( str );
  4.1565 +    return text;
  4.1566 +}
  4.1567 +
  4.1568 +
  4.1569 +XMLDeclaration* XMLDocument::NewDeclaration( const char* str )
  4.1570 +{
  4.1571 +    XMLDeclaration* dec = new (_commentPool.Alloc()) XMLDeclaration( this );
  4.1572 +    dec->_memPool = &_commentPool;
  4.1573 +    dec->SetValue( str ? str : "xml version=\"1.0\" encoding=\"UTF-8\"" );
  4.1574 +    return dec;
  4.1575 +}
  4.1576 +
  4.1577 +
  4.1578 +XMLUnknown* XMLDocument::NewUnknown( const char* str )
  4.1579 +{
  4.1580 +    XMLUnknown* unk = new (_commentPool.Alloc()) XMLUnknown( this );
  4.1581 +    unk->_memPool = &_commentPool;
  4.1582 +    unk->SetValue( str );
  4.1583 +    return unk;
  4.1584 +}
  4.1585 +
  4.1586 +
  4.1587 +XMLError XMLDocument::LoadFile( const char* filename )
  4.1588 +{
  4.1589 +    DeleteChildren();
  4.1590 +    InitDocument();
  4.1591 +    FILE* fp = 0;
  4.1592 +
  4.1593 +#if defined(_MSC_VER) && (_MSC_VER >= 1400 )
  4.1594 +    errno_t err = fopen_s(&fp, filename, "rb" );
  4.1595 +    if ( !fp || err) {
  4.1596 +#else
  4.1597 +    fp = fopen( filename, "rb" );
  4.1598 +    if ( !fp) {
  4.1599 +#endif
  4.1600 +        SetError( XML_ERROR_FILE_NOT_FOUND, filename, 0 );
  4.1601 +        return _errorID;
  4.1602 +    }
  4.1603 +    LoadFile( fp );
  4.1604 +    fclose( fp );
  4.1605 +    return _errorID;
  4.1606 +}
  4.1607 +
  4.1608 +
  4.1609 +XMLError XMLDocument::LoadFile( FILE* fp )
  4.1610 +{
  4.1611 +    DeleteChildren();
  4.1612 +    InitDocument();
  4.1613 +
  4.1614 +    fseek( fp, 0, SEEK_END );
  4.1615 +    size_t size = ftell( fp );
  4.1616 +    fseek( fp, 0, SEEK_SET );
  4.1617 +
  4.1618 +    if ( size == 0 ) {
  4.1619 +        return _errorID;
  4.1620 +    }
  4.1621 +
  4.1622 +    _charBuffer = new char[size+1];
  4.1623 +    size_t read = fread( _charBuffer, 1, size, fp );
  4.1624 +    if ( read != size ) {
  4.1625 +        SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );
  4.1626 +        return _errorID;
  4.1627 +    }
  4.1628 +
  4.1629 +    _charBuffer[size] = 0;
  4.1630 +
  4.1631 +    const char* p = _charBuffer;
  4.1632 +    p = XMLUtil::SkipWhiteSpace( p );
  4.1633 +    p = XMLUtil::ReadBOM( p, &_writeBOM );
  4.1634 +    if ( !p || !*p ) {
  4.1635 +        SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );
  4.1636 +        return _errorID;
  4.1637 +    }
  4.1638 +
  4.1639 +    ParseDeep( _charBuffer + (p-_charBuffer), 0 );
  4.1640 +    return _errorID;
  4.1641 +}
  4.1642 +
  4.1643 +
  4.1644 +XMLError XMLDocument::SaveFile( const char* filename, bool compact )
  4.1645 +{
  4.1646 +    FILE* fp = 0;
  4.1647 +#if defined(_MSC_VER) && (_MSC_VER >= 1400 )
  4.1648 +    errno_t err = fopen_s(&fp, filename, "w" );
  4.1649 +    if ( !fp || err) {
  4.1650 +#else
  4.1651 +    fp = fopen( filename, "w" );
  4.1652 +    if ( !fp) {
  4.1653 +#endif
  4.1654 +        SetError( XML_ERROR_FILE_COULD_NOT_BE_OPENED, filename, 0 );
  4.1655 +        return _errorID;
  4.1656 +    }
  4.1657 +    SaveFile(fp, compact);
  4.1658 +    fclose( fp );
  4.1659 +    return _errorID;
  4.1660 +}
  4.1661 +
  4.1662 +
  4.1663 +XMLError XMLDocument::SaveFile( FILE* fp, bool compact )
  4.1664 +{
  4.1665 +    XMLPrinter stream( fp, compact );
  4.1666 +    Print( &stream );
  4.1667 +    return _errorID;
  4.1668 +}
  4.1669 +
  4.1670 +
  4.1671 +XMLError XMLDocument::Parse( const char* p, size_t len )
  4.1672 +{
  4.1673 +    DeleteChildren();
  4.1674 +    InitDocument();
  4.1675 +
  4.1676 +    if ( !p || !*p ) {
  4.1677 +        SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );
  4.1678 +        return _errorID;
  4.1679 +    }
  4.1680 +    if ( len == (size_t)(-1) ) {
  4.1681 +        len = strlen( p );
  4.1682 +    }
  4.1683 +    _charBuffer = new char[ len+1 ];
  4.1684 +    memcpy( _charBuffer, p, len );
  4.1685 +    _charBuffer[len] = 0;
  4.1686 +
  4.1687 +    p = XMLUtil::SkipWhiteSpace( p );
  4.1688 +    p = XMLUtil::ReadBOM( p, &_writeBOM );
  4.1689 +    if ( !p || !*p ) {
  4.1690 +        SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );
  4.1691 +        return _errorID;
  4.1692 +    }
  4.1693 +
  4.1694 +    ParseDeep( _charBuffer, 0 );
  4.1695 +    return _errorID;
  4.1696 +}
  4.1697 +
  4.1698 +
  4.1699 +void XMLDocument::Print( XMLPrinter* streamer )
  4.1700 +{
  4.1701 +    XMLPrinter stdStreamer( stdout );
  4.1702 +    if ( !streamer ) {
  4.1703 +        streamer = &stdStreamer;
  4.1704 +    }
  4.1705 +    Accept( streamer );
  4.1706 +}
  4.1707 +
  4.1708 +
  4.1709 +void XMLDocument::SetError( XMLError error, const char* str1, const char* str2 )
  4.1710 +{
  4.1711 +    _errorID = error;
  4.1712 +    _errorStr1 = str1;
  4.1713 +    _errorStr2 = str2;
  4.1714 +}
  4.1715 +
  4.1716 +
  4.1717 +void XMLDocument::PrintError() const
  4.1718 +{
  4.1719 +    if ( _errorID ) {
  4.1720 +        static const int LEN = 20;
  4.1721 +        char buf1[LEN] = { 0 };
  4.1722 +        char buf2[LEN] = { 0 };
  4.1723 +
  4.1724 +        if ( _errorStr1 ) {
  4.1725 +            TIXML_SNPRINTF( buf1, LEN, "%s", _errorStr1 );
  4.1726 +        }
  4.1727 +        if ( _errorStr2 ) {
  4.1728 +            TIXML_SNPRINTF( buf2, LEN, "%s", _errorStr2 );
  4.1729 +        }
  4.1730 +
  4.1731 +        printf( "XMLDocument error id=%d str1=%s str2=%s\n",
  4.1732 +                _errorID, buf1, buf2 );
  4.1733 +    }
  4.1734 +}
  4.1735 +
  4.1736 +
  4.1737 +XMLPrinter::XMLPrinter( FILE* file, bool compact ) :
  4.1738 +    _elementJustOpened( false ),
  4.1739 +    _firstElement( true ),
  4.1740 +    _fp( file ),
  4.1741 +    _depth( 0 ),
  4.1742 +    _textDepth( -1 ),
  4.1743 +    _processEntities( true ),
  4.1744 +    _compactMode( compact )
  4.1745 +{
  4.1746 +    for( int i=0; i<ENTITY_RANGE; ++i ) {
  4.1747 +        _entityFlag[i] = false;
  4.1748 +        _restrictedEntityFlag[i] = false;
  4.1749 +    }
  4.1750 +    for( int i=0; i<NUM_ENTITIES; ++i ) {
  4.1751 +        TIXMLASSERT( entities[i].value < ENTITY_RANGE );
  4.1752 +        if ( entities[i].value < ENTITY_RANGE ) {
  4.1753 +            _entityFlag[ (int)entities[i].value ] = true;
  4.1754 +        }
  4.1755 +    }
  4.1756 +    _restrictedEntityFlag[(int)'&'] = true;
  4.1757 +    _restrictedEntityFlag[(int)'<'] = true;
  4.1758 +    _restrictedEntityFlag[(int)'>'] = true;	// not required, but consistency is nice
  4.1759 +    _buffer.Push( 0 );
  4.1760 +}
  4.1761 +
  4.1762 +
  4.1763 +void XMLPrinter::Print( const char* format, ... )
  4.1764 +{
  4.1765 +    va_list     va;
  4.1766 +    va_start( va, format );
  4.1767 +
  4.1768 +    if ( _fp ) {
  4.1769 +        vfprintf( _fp, format, va );
  4.1770 +    }
  4.1771 +    else {
  4.1772 +        // This seems brutally complex. Haven't figured out a better
  4.1773 +        // way on windows.
  4.1774 +#ifdef _MSC_VER
  4.1775 +        int len = -1;
  4.1776 +        int expand = 1000;
  4.1777 +        while ( len < 0 ) {
  4.1778 +            len = vsnprintf_s( _accumulator.Mem(), _accumulator.Capacity(), _TRUNCATE, format, va );
  4.1779 +            if ( len < 0 ) {
  4.1780 +                expand *= 3/2;
  4.1781 +                _accumulator.PushArr( expand );
  4.1782 +            }
  4.1783 +        }
  4.1784 +        char* p = _buffer.PushArr( len ) - 1;
  4.1785 +        memcpy( p, _accumulator.Mem(), len+1 );
  4.1786 +#else
  4.1787 +        int len = vsnprintf( 0, 0, format, va );
  4.1788 +        // Close out and re-start the va-args
  4.1789 +        va_end( va );
  4.1790 +        va_start( va, format );
  4.1791 +        char* p = _buffer.PushArr( len ) - 1;
  4.1792 +        vsnprintf( p, len+1, format, va );
  4.1793 +#endif
  4.1794 +    }
  4.1795 +    va_end( va );
  4.1796 +}
  4.1797 +
  4.1798 +
  4.1799 +void XMLPrinter::PrintSpace( int depth )
  4.1800 +{
  4.1801 +    for( int i=0; i<depth; ++i ) {
  4.1802 +        Print( "    " );
  4.1803 +    }
  4.1804 +}
  4.1805 +
  4.1806 +
  4.1807 +void XMLPrinter::PrintString( const char* p, bool restricted )
  4.1808 +{
  4.1809 +    // Look for runs of bytes between entities to print.
  4.1810 +    const char* q = p;
  4.1811 +    const bool* flag = restricted ? _restrictedEntityFlag : _entityFlag;
  4.1812 +
  4.1813 +    if ( _processEntities ) {
  4.1814 +        while ( *q ) {
  4.1815 +            // Remember, char is sometimes signed. (How many times has that bitten me?)
  4.1816 +            if ( *q > 0 && *q < ENTITY_RANGE ) {
  4.1817 +                // Check for entities. If one is found, flush
  4.1818 +                // the stream up until the entity, write the
  4.1819 +                // entity, and keep looking.
  4.1820 +                if ( flag[(unsigned)(*q)] ) {
  4.1821 +                    while ( p < q ) {
  4.1822 +                        Print( "%c", *p );
  4.1823 +                        ++p;
  4.1824 +                    }
  4.1825 +                    for( int i=0; i<NUM_ENTITIES; ++i ) {
  4.1826 +                        if ( entities[i].value == *q ) {
  4.1827 +                            Print( "&%s;", entities[i].pattern );
  4.1828 +                            break;
  4.1829 +                        }
  4.1830 +                    }
  4.1831 +                    ++p;
  4.1832 +                }
  4.1833 +            }
  4.1834 +            ++q;
  4.1835 +        }
  4.1836 +    }
  4.1837 +    // Flush the remaining string. This will be the entire
  4.1838 +    // string if an entity wasn't found.
  4.1839 +    if ( !_processEntities || (q-p > 0) ) {
  4.1840 +        Print( "%s", p );
  4.1841 +    }
  4.1842 +}
  4.1843 +
  4.1844 +
  4.1845 +void XMLPrinter::PushHeader( bool writeBOM, bool writeDec )
  4.1846 +{
  4.1847 +    static const unsigned char bom[] = { TIXML_UTF_LEAD_0, TIXML_UTF_LEAD_1, TIXML_UTF_LEAD_2, 0 };
  4.1848 +    if ( writeBOM ) {
  4.1849 +        Print( "%s", bom );
  4.1850 +    }
  4.1851 +    if ( writeDec ) {
  4.1852 +        PushDeclaration( "xml version=\"1.0\"" );
  4.1853 +    }
  4.1854 +}
  4.1855 +
  4.1856 +
  4.1857 +void XMLPrinter::OpenElement( const char* name )
  4.1858 +{
  4.1859 +    if ( _elementJustOpened ) {
  4.1860 +        SealElement();
  4.1861 +    }
  4.1862 +    _stack.Push( name );
  4.1863 +
  4.1864 +    if ( _textDepth < 0 && !_firstElement && !_compactMode ) {
  4.1865 +        Print( "\n" );
  4.1866 +        PrintSpace( _depth );
  4.1867 +    }
  4.1868 +
  4.1869 +    Print( "<%s", name );
  4.1870 +    _elementJustOpened = true;
  4.1871 +    _firstElement = false;
  4.1872 +    ++_depth;
  4.1873 +}
  4.1874 +
  4.1875 +
  4.1876 +void XMLPrinter::PushAttribute( const char* name, const char* value )
  4.1877 +{
  4.1878 +    TIXMLASSERT( _elementJustOpened );
  4.1879 +    Print( " %s=\"", name );
  4.1880 +    PrintString( value, false );
  4.1881 +    Print( "\"" );
  4.1882 +}
  4.1883 +
  4.1884 +
  4.1885 +void XMLPrinter::PushAttribute( const char* name, int v )
  4.1886 +{
  4.1887 +    char buf[BUF_SIZE];
  4.1888 +    XMLUtil::ToStr( v, buf, BUF_SIZE );
  4.1889 +    PushAttribute( name, buf );
  4.1890 +}
  4.1891 +
  4.1892 +
  4.1893 +void XMLPrinter::PushAttribute( const char* name, unsigned v )
  4.1894 +{
  4.1895 +    char buf[BUF_SIZE];
  4.1896 +    XMLUtil::ToStr( v, buf, BUF_SIZE );
  4.1897 +    PushAttribute( name, buf );
  4.1898 +}
  4.1899 +
  4.1900 +
  4.1901 +void XMLPrinter::PushAttribute( const char* name, bool v )
  4.1902 +{
  4.1903 +    char buf[BUF_SIZE];
  4.1904 +    XMLUtil::ToStr( v, buf, BUF_SIZE );
  4.1905 +    PushAttribute( name, buf );
  4.1906 +}
  4.1907 +
  4.1908 +
  4.1909 +void XMLPrinter::PushAttribute( const char* name, double v )
  4.1910 +{
  4.1911 +    char buf[BUF_SIZE];
  4.1912 +    XMLUtil::ToStr( v, buf, BUF_SIZE );
  4.1913 +    PushAttribute( name, buf );
  4.1914 +}
  4.1915 +
  4.1916 +
  4.1917 +void XMLPrinter::CloseElement()
  4.1918 +{
  4.1919 +    --_depth;
  4.1920 +    const char* name = _stack.Pop();
  4.1921 +
  4.1922 +    if ( _elementJustOpened ) {
  4.1923 +        Print( "/>" );
  4.1924 +    }
  4.1925 +    else {
  4.1926 +        if ( _textDepth < 0 && !_compactMode) {
  4.1927 +            Print( "\n" );
  4.1928 +            PrintSpace( _depth );
  4.1929 +        }
  4.1930 +        Print( "</%s>", name );
  4.1931 +    }
  4.1932 +
  4.1933 +    if ( _textDepth == _depth ) {
  4.1934 +        _textDepth = -1;
  4.1935 +    }
  4.1936 +    if ( _depth == 0 && !_compactMode) {
  4.1937 +        Print( "\n" );
  4.1938 +    }
  4.1939 +    _elementJustOpened = false;
  4.1940 +}
  4.1941 +
  4.1942 +
  4.1943 +void XMLPrinter::SealElement()
  4.1944 +{
  4.1945 +    _elementJustOpened = false;
  4.1946 +    Print( ">" );
  4.1947 +}
  4.1948 +
  4.1949 +
  4.1950 +void XMLPrinter::PushText( const char* text, bool cdata )
  4.1951 +{
  4.1952 +    _textDepth = _depth-1;
  4.1953 +
  4.1954 +    if ( _elementJustOpened ) {
  4.1955 +        SealElement();
  4.1956 +    }
  4.1957 +    if ( cdata ) {
  4.1958 +        Print( "<![CDATA[" );
  4.1959 +        Print( "%s", text );
  4.1960 +        Print( "]]>" );
  4.1961 +    }
  4.1962 +    else {
  4.1963 +        PrintString( text, true );
  4.1964 +    }
  4.1965 +}
  4.1966 +
  4.1967 +void XMLPrinter::PushText( int value )
  4.1968 +{
  4.1969 +    char buf[BUF_SIZE];
  4.1970 +    XMLUtil::ToStr( value, buf, BUF_SIZE );
  4.1971 +    PushText( buf, false );
  4.1972 +}
  4.1973 +
  4.1974 +
  4.1975 +void XMLPrinter::PushText( unsigned value )
  4.1976 +{
  4.1977 +    char buf[BUF_SIZE];
  4.1978 +    XMLUtil::ToStr( value, buf, BUF_SIZE );
  4.1979 +    PushText( buf, false );
  4.1980 +}
  4.1981 +
  4.1982 +
  4.1983 +void XMLPrinter::PushText( bool value )
  4.1984 +{
  4.1985 +    char buf[BUF_SIZE];
  4.1986 +    XMLUtil::ToStr( value, buf, BUF_SIZE );
  4.1987 +    PushText( buf, false );
  4.1988 +}
  4.1989 +
  4.1990 +
  4.1991 +void XMLPrinter::PushText( float value )
  4.1992 +{
  4.1993 +    char buf[BUF_SIZE];
  4.1994 +    XMLUtil::ToStr( value, buf, BUF_SIZE );
  4.1995 +    PushText( buf, false );
  4.1996 +}
  4.1997 +
  4.1998 +
  4.1999 +void XMLPrinter::PushText( double value )
  4.2000 +{
  4.2001 +    char buf[BUF_SIZE];
  4.2002 +    XMLUtil::ToStr( value, buf, BUF_SIZE );
  4.2003 +    PushText( buf, false );
  4.2004 +}
  4.2005 +
  4.2006 +
  4.2007 +void XMLPrinter::PushComment( const char* comment )
  4.2008 +{
  4.2009 +    if ( _elementJustOpened ) {
  4.2010 +        SealElement();
  4.2011 +    }
  4.2012 +    if ( _textDepth < 0 && !_firstElement && !_compactMode) {
  4.2013 +        Print( "\n" );
  4.2014 +        PrintSpace( _depth );
  4.2015 +    }
  4.2016 +    _firstElement = false;
  4.2017 +    Print( "<!--%s-->", comment );
  4.2018 +}
  4.2019 +
  4.2020 +
  4.2021 +void XMLPrinter::PushDeclaration( const char* value )
  4.2022 +{
  4.2023 +    if ( _elementJustOpened ) {
  4.2024 +        SealElement();
  4.2025 +    }
  4.2026 +    if ( _textDepth < 0 && !_firstElement && !_compactMode) {
  4.2027 +        Print( "\n" );
  4.2028 +        PrintSpace( _depth );
  4.2029 +    }
  4.2030 +    _firstElement = false;
  4.2031 +    Print( "<?%s?>", value );
  4.2032 +}
  4.2033 +
  4.2034 +
  4.2035 +void XMLPrinter::PushUnknown( const char* value )
  4.2036 +{
  4.2037 +    if ( _elementJustOpened ) {
  4.2038 +        SealElement();
  4.2039 +    }
  4.2040 +    if ( _textDepth < 0 && !_firstElement && !_compactMode) {
  4.2041 +        Print( "\n" );
  4.2042 +        PrintSpace( _depth );
  4.2043 +    }
  4.2044 +    _firstElement = false;
  4.2045 +    Print( "<!%s>", value );
  4.2046 +}
  4.2047 +
  4.2048 +
  4.2049 +bool XMLPrinter::VisitEnter( const XMLDocument& doc )
  4.2050 +{
  4.2051 +    _processEntities = doc.ProcessEntities();
  4.2052 +    if ( doc.HasBOM() ) {
  4.2053 +        PushHeader( true, false );
  4.2054 +    }
  4.2055 +    return true;
  4.2056 +}
  4.2057 +
  4.2058 +
  4.2059 +bool XMLPrinter::VisitEnter( const XMLElement& element, const XMLAttribute* attribute )
  4.2060 +{
  4.2061 +    OpenElement( element.Name() );
  4.2062 +    while ( attribute ) {
  4.2063 +        PushAttribute( attribute->Name(), attribute->Value() );
  4.2064 +        attribute = attribute->Next();
  4.2065 +    }
  4.2066 +    return true;
  4.2067 +}
  4.2068 +
  4.2069 +
  4.2070 +bool XMLPrinter::VisitExit( const XMLElement& )
  4.2071 +{
  4.2072 +    CloseElement();
  4.2073 +    return true;
  4.2074 +}
  4.2075 +
  4.2076 +
  4.2077 +bool XMLPrinter::Visit( const XMLText& text )
  4.2078 +{
  4.2079 +    PushText( text.Value(), text.CData() );
  4.2080 +    return true;
  4.2081 +}
  4.2082 +
  4.2083 +
  4.2084 +bool XMLPrinter::Visit( const XMLComment& comment )
  4.2085 +{
  4.2086 +    PushComment( comment.Value() );
  4.2087 +    return true;
  4.2088 +}
  4.2089 +
  4.2090 +bool XMLPrinter::Visit( const XMLDeclaration& declaration )
  4.2091 +{
  4.2092 +    PushDeclaration( declaration.Value() );
  4.2093 +    return true;
  4.2094 +}
  4.2095 +
  4.2096 +
  4.2097 +bool XMLPrinter::Visit( const XMLUnknown& unknown )
  4.2098 +{
  4.2099 +    PushUnknown( unknown.Value() );
  4.2100 +    return true;
  4.2101 +}
  4.2102 +
  4.2103 +}   // namespace tinyxml2
  4.2104 +

     5.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     5.2 +++ b/3rdParty/TinyXml/tinyxml2.h	Wed Jan 14 06:51:16 2015 +0200
     5.3 @@ -0,0 +1,1911 @@
     5.4 +/*
     5.5 +Original code by Lee Thomason (www.grinninglizard.com)
     5.6 +
     5.7 +This software is provided 'as-is', without any express or implied
     5.8 +warranty. In no event will the authors be held liable for any
     5.9 +damages arising from the use of this software.
    5.10 +
    5.11 +Permission is granted to anyone to use this software for any
    5.12 +purpose, including commercial applications, and to alter it and
    5.13 +redistribute it freely, subject to the following restrictions:
    5.14 +
    5.15 +1. The origin of this software must not be misrepresented; you must
    5.16 +not claim that you wrote the original software. If you use this
    5.17 +software in a product, an acknowledgment in the product documentation
    5.18 +would be appreciated but is not required.
    5.19 +
    5.20 +2. Altered source versions must be plainly marked as such, and
    5.21 +must not be misrepresented as being the original software.
    5.22 +
    5.23 +3. This notice may not be removed or altered from any source
    5.24 +distribution.
    5.25 +*/
    5.26 +
    5.27 +#ifndef TINYXML2_INCLUDED
    5.28 +#define TINYXML2_INCLUDED
    5.29 +
    5.30 +#if defined(ANDROID_NDK) || defined(__BORLANDC__)
    5.31 +#   include <ctype.h>
    5.32 +#   include <limits.h>
    5.33 +#   include <stdio.h>
    5.34 +#   include <stdlib.h>
    5.35 +#   include <string.h>
    5.36 +#   include <stdarg.h>
    5.37 +#else
    5.38 +#   include <cctype>
    5.39 +#   include <climits>
    5.40 +#   include <cstdio>
    5.41 +#   include <cstdlib>
    5.42 +#   include <cstring>
    5.43 +#   include <cstdarg>
    5.44 +#endif
    5.45 +
    5.46 +/*
    5.47 +   TODO: intern strings instead of allocation.
    5.48 +*/
    5.49 +/*
    5.50 +	gcc:
    5.51 +        g++ -Wall -DDEBUG tinyxml2.cpp xmltest.cpp -o gccxmltest.exe
    5.52 +
    5.53 +    Formatting, Artistic Style:
    5.54 +        AStyle.exe --style=1tbs --indent-switches --break-closing-brackets --indent-preprocessor tinyxml2.cpp tinyxml2.h
    5.55 +*/
    5.56 +
    5.57 +#if defined( _DEBUG ) || defined( DEBUG ) || defined (__DEBUG__)
    5.58 +#   ifndef DEBUG
    5.59 +#       define DEBUG
    5.60 +#   endif
    5.61 +#endif
    5.62 +
    5.63 +
    5.64 +#if defined(DEBUG)
    5.65 +#   if defined(_MSC_VER)
    5.66 +#       define TIXMLASSERT( x )           if ( !(x)) { __debugbreak(); } //if ( !(x)) WinDebugBreak()
    5.67 +#   elif defined (ANDROID_NDK)
    5.68 +#       include <android/log.h>
    5.69 +#       define TIXMLASSERT( x )           if ( !(x)) { __android_log_assert( "assert", "grinliz", "ASSERT in '%s' at %d.", __FILE__, __LINE__ ); }
    5.70 +#   else
    5.71 +#       include <assert.h>
    5.72 +#       define TIXMLASSERT                assert
    5.73 +#   endif
    5.74 +#   else
    5.75 +#       define TIXMLASSERT( x )           {}
    5.76 +#endif
    5.77 +
    5.78 +
    5.79 +#if defined(_MSC_VER) && (_MSC_VER >= 1400 )
    5.80 +// Microsoft visual studio, version 2005 and higher.
    5.81 +/*int _snprintf_s(
    5.82 +   char *buffer,
    5.83 +   size_t sizeOfBuffer,
    5.84 +   size_t count,
    5.85 +   const char *format [,
    5.86 +	  argument] ...
    5.87 +);*/
    5.88 +inline int TIXML_SNPRINTF( char* buffer, size_t size, const char* format, ... )
    5.89 +{
    5.90 +    va_list va;
    5.91 +    va_start( va, format );
    5.92 +    int result = vsnprintf_s( buffer, size, _TRUNCATE, format, va );
    5.93 +    va_end( va );
    5.94 +    return result;
    5.95 +}
    5.96 +#define TIXML_SSCANF   sscanf_s
    5.97 +#else
    5.98 +// GCC version 3 and higher
    5.99 +//#warning( "Using sn* functions." )
   5.100 +#define TIXML_SNPRINTF snprintf
   5.101 +#define TIXML_SSCANF   sscanf
   5.102 +#endif
   5.103 +
   5.104 +static const int TIXML2_MAJOR_VERSION = 1;
   5.105 +static const int TIXML2_MINOR_VERSION = 0;
   5.106 +static const int TIXML2_PATCH_VERSION = 9;
   5.107 +
   5.108 +namespace tinyxml2
   5.109 +{
   5.110 +class XMLDocument;
   5.111 +class XMLElement;
   5.112 +class XMLAttribute;
   5.113 +class XMLComment;
   5.114 +class XMLNode;
   5.115 +class XMLText;
   5.116 +class XMLDeclaration;
   5.117 +class XMLUnknown;
   5.118 +
   5.119 +class XMLPrinter;
   5.120 +
   5.121 +/*
   5.122 +	A class that wraps strings. Normally stores the start and end
   5.123 +	pointers into the XML file itself, and will apply normalization
   5.124 +	and entity translation if actually read. Can also store (and memory
   5.125 +	manage) a traditional char[]
   5.126 +*/
   5.127 +class StrPair
   5.128 +{
   5.129 +public:
   5.130 +    enum {
   5.131 +        NEEDS_ENTITY_PROCESSING			= 0x01,
   5.132 +        NEEDS_NEWLINE_NORMALIZATION		= 0x02,
   5.133 +        COLLAPSE_WHITESPACE				= 0x04,
   5.134 +
   5.135 +        TEXT_ELEMENT		            = NEEDS_ENTITY_PROCESSING | NEEDS_NEWLINE_NORMALIZATION,
   5.136 +        TEXT_ELEMENT_LEAVE_ENTITIES		= NEEDS_NEWLINE_NORMALIZATION,
   5.137 +        ATTRIBUTE_NAME		            = 0,
   5.138 +        ATTRIBUTE_VALUE		            = NEEDS_ENTITY_PROCESSING | NEEDS_NEWLINE_NORMALIZATION,
   5.139 +        ATTRIBUTE_VALUE_LEAVE_ENTITIES  = NEEDS_NEWLINE_NORMALIZATION,
   5.140 +        COMMENT				            = NEEDS_NEWLINE_NORMALIZATION
   5.141 +    };
   5.142 +
   5.143 +    StrPair() : _flags( 0 ), _start( 0 ), _end( 0 ) {}
   5.144 +    ~StrPair();
   5.145 +
   5.146 +    void Set( char* start, char* end, int flags ) {
   5.147 +        Reset();
   5.148 +        _start  = start;
   5.149 +        _end    = end;
   5.150 +        _flags  = flags | NEEDS_FLUSH;
   5.151 +    }
   5.152 +
   5.153 +    const char* GetStr();
   5.154 +
   5.155 +    bool Empty() const {
   5.156 +        return _start == _end;
   5.157 +    }
   5.158 +
   5.159 +    void SetInternedStr( const char* str ) {
   5.160 +        Reset();
   5.161 +        _start = const_cast<char*>(str);
   5.162 +    }
   5.163 +
   5.164 +    void SetStr( const char* str, int flags=0 );
   5.165 +
   5.166 +    char* ParseText( char* in, const char* endTag, int strFlags );
   5.167 +    char* ParseName( char* in );
   5.168 +
   5.169 +private:
   5.170 +    void Reset();
   5.171 +    void CollapseWhitespace();
   5.172 +
   5.173 +    enum {
   5.174 +        NEEDS_FLUSH = 0x100,
   5.175 +        NEEDS_DELETE = 0x200
   5.176 +    };
   5.177 +
   5.178 +    // After parsing, if *end != 0, it can be set to zero.
   5.179 +    int     _flags;
   5.180 +    char*   _start;
   5.181 +    char*   _end;
   5.182 +};
   5.183 +
   5.184 +
   5.185 +/*
   5.186 +	A dynamic array of Plain Old Data. Doesn't support constructors, etc.
   5.187 +	Has a small initial memory pool, so that low or no usage will not
   5.188 +	cause a call to new/delete
   5.189 +*/
   5.190 +template <class T, int INIT>
   5.191 +class DynArray
   5.192 +{
   5.193 +public:
   5.194 +    DynArray< T, INIT >() {
   5.195 +        _mem = _pool;
   5.196 +        _allocated = INIT;
   5.197 +        _size = 0;
   5.198 +    }
   5.199 +
   5.200 +    ~DynArray() {
   5.201 +        if ( _mem != _pool ) {
   5.202 +            delete [] _mem;
   5.203 +        }
   5.204 +    }
   5.205 +
   5.206 +    void Push( T t ) {
   5.207 +        EnsureCapacity( _size+1 );
   5.208 +        _mem[_size++] = t;
   5.209 +    }
   5.210 +
   5.211 +    T* PushArr( int count ) {
   5.212 +        EnsureCapacity( _size+count );
   5.213 +        T* ret = &_mem[_size];
   5.214 +        _size += count;
   5.215 +        return ret;
   5.216 +    }
   5.217 +
   5.218 +    T Pop() {
   5.219 +        return _mem[--_size];
   5.220 +    }
   5.221 +
   5.222 +    void PopArr( int count ) {
   5.223 +        TIXMLASSERT( _size >= count );
   5.224 +        _size -= count;
   5.225 +    }
   5.226 +
   5.227 +    bool Empty() const					{
   5.228 +        return _size == 0;
   5.229 +    }
   5.230 +
   5.231 +    T& operator[](int i)				{
   5.232 +        TIXMLASSERT( i>= 0 && i < _size );
   5.233 +        return _mem[i];
   5.234 +    }
   5.235 +
   5.236 +    const T& operator[](int i) const	{
   5.237 +        TIXMLASSERT( i>= 0 && i < _size );
   5.238 +        return _mem[i];
   5.239 +    }
   5.240 +
   5.241 +    int Size() const					{
   5.242 +        return _size;
   5.243 +    }
   5.244 +
   5.245 +    int Capacity() const				{
   5.246 +        return _allocated;
   5.247 +    }
   5.248 +
   5.249 +    const T* Mem() const				{
   5.250 +        return _mem;
   5.251 +    }
   5.252 +
   5.253 +    T* Mem()							{
   5.254 +        return _mem;
   5.255 +    }
   5.256 +
   5.257 +private:
   5.258 +    void EnsureCapacity( int cap ) {
   5.259 +        if ( cap > _allocated ) {
   5.260 +            int newAllocated = cap * 2;
   5.261 +            T* newMem = new T[newAllocated];
   5.262 +            memcpy( newMem, _mem, sizeof(T)*_size );	// warning: not using constructors, only works for PODs
   5.263 +            if ( _mem != _pool ) {
   5.264 +                delete [] _mem;
   5.265 +            }
   5.266 +            _mem = newMem;
   5.267 +            _allocated = newAllocated;
   5.268 +        }
   5.269 +    }
   5.270 +
   5.271 +    T*  _mem;
   5.272 +    T   _pool[INIT];
   5.273 +    int _allocated;		// objects allocated
   5.274 +    int _size;			// number objects in use
   5.275 +};
   5.276 +
   5.277 +
   5.278 +/*
   5.279 +	Parent virtual class of a pool for fast allocation
   5.280 +	and deallocation of objects.
   5.281 +*/
   5.282 +class MemPool
   5.283 +{
   5.284 +public:
   5.285 +    MemPool() {}
   5.286 +    virtual ~MemPool() {}
   5.287 +
   5.288 +    virtual int ItemSize() const = 0;
   5.289 +    virtual void* Alloc() = 0;
   5.290 +    virtual void Free( void* ) = 0;
   5.291 +    virtual void SetTracked() = 0;
   5.292 +};
   5.293 +
   5.294 +
   5.295 +/*
   5.296 +	Template child class to create pools of the correct type.
   5.297 +*/
   5.298 +template< int SIZE >
   5.299 +class MemPoolT : public MemPool
   5.300 +{
   5.301 +public:
   5.302 +    MemPoolT() : _root(0), _currentAllocs(0), _nAllocs(0), _maxAllocs(0), _nUntracked(0)	{}
   5.303 +    ~MemPoolT() {
   5.304 +        // Delete the blocks.
   5.305 +        for( int i=0; i<_blockPtrs.Size(); ++i ) {
   5.306 +            delete _blockPtrs[i];
   5.307 +        }
   5.308 +    }
   5.309 +
   5.310 +    virtual int ItemSize() const	{
   5.311 +        return SIZE;
   5.312 +    }
   5.313 +    int CurrentAllocs() const		{
   5.314 +        return _currentAllocs;
   5.315 +    }
   5.316 +
   5.317 +    virtual void* Alloc() {
   5.318 +        if ( !_root ) {
   5.319 +            // Need a new block.
   5.320 +            Block* block = new Block();
   5.321 +            _blockPtrs.Push( block );
   5.322 +
   5.323 +            for( int i=0; i<COUNT-1; ++i ) {
   5.324 +                block->chunk[i].next = &block->chunk[i+1];
   5.325 +            }
   5.326 +            block->chunk[COUNT-1].next = 0;
   5.327 +            _root = block->chunk;
   5.328 +        }
   5.329 +        void* result = _root;
   5.330 +        _root = _root->next;
   5.331 +
   5.332 +        ++_currentAllocs;
   5.333 +        if ( _currentAllocs > _maxAllocs ) {
   5.334 +            _maxAllocs = _currentAllocs;
   5.335 +        }
   5.336 +        _nAllocs++;
   5.337 +        _nUntracked++;
   5.338 +        return result;
   5.339 +    }
   5.340 +    virtual void Free( void* mem ) {
   5.341 +        if ( !mem ) {
   5.342 +            return;
   5.343 +        }
   5.344 +        --_currentAllocs;
   5.345 +        Chunk* chunk = (Chunk*)mem;
   5.346 +#ifdef DEBUG
   5.347 +        memset( chunk, 0xfe, sizeof(Chunk) );
   5.348 +#endif
   5.349 +        chunk->next = _root;
   5.350 +        _root = chunk;
   5.351 +    }
   5.352 +    void Trace( const char* name ) {
   5.353 +        printf( "Mempool %s watermark=%d [%dk] current=%d size=%d nAlloc=%d blocks=%d\n",
   5.354 +                name, _maxAllocs, _maxAllocs*SIZE/1024, _currentAllocs, SIZE, _nAllocs, _blockPtrs.Size() );
   5.355 +    }
   5.356 +
   5.357 +    void SetTracked() {
   5.358 +        _nUntracked--;
   5.359 +    }
   5.360 +
   5.361 +    int Untracked() const {
   5.362 +        return _nUntracked;
   5.363 +    }
   5.364 +
   5.365 +    enum { COUNT = 1024/SIZE }; // Some compilers do not accept to use COUNT in private part if COUNT is private
   5.366 +
   5.367 +private:
   5.368 +    union Chunk {
   5.369 +        Chunk*  next;
   5.370 +        char    mem[SIZE];
   5.371 +    };
   5.372 +    struct Block {
   5.373 +        Chunk chunk[COUNT];
   5.374 +    };
   5.375 +    DynArray< Block*, 10 > _blockPtrs;
   5.376 +    Chunk* _root;
   5.377 +
   5.378 +    int _currentAllocs;
   5.379 +    int _nAllocs;
   5.380 +    int _maxAllocs;
   5.381 +    int _nUntracked;
   5.382 +};
   5.383 +
   5.384 +
   5.385 +
   5.386 +/**
   5.387 +	Implements the interface to the "Visitor pattern" (see the Accept() method.)
   5.388 +	If you call the Accept() method, it requires being passed a XMLVisitor
   5.389 +	class to handle callbacks. For nodes that contain other nodes (Document, Element)
   5.390 +	you will get called with a VisitEnter/VisitExit pair. Nodes that are always leafs
   5.391 +	are simply called with Visit().
   5.392 +
   5.393 +	If you return 'true' from a Visit method, recursive parsing will continue. If you return
   5.394 +	false, <b>no children of this node or its sibilings</b> will be visited.
   5.395 +
   5.396 +	All flavors of Visit methods have a default implementation that returns 'true' (continue
   5.397 +	visiting). You need to only override methods that are interesting to you.
   5.398 +
   5.399 +	Generally Accept() is called on the TiXmlDocument, although all nodes support visiting.
   5.400 +
   5.401 +	You should never change the document from a callback.
   5.402 +
   5.403 +	@sa XMLNode::Accept()
   5.404 +*/
   5.405 +class XMLVisitor
   5.406 +{
   5.407 +public:
   5.408 +    virtual ~XMLVisitor() {}
   5.409 +
   5.410 +    /// Visit a document.
   5.411 +    virtual bool VisitEnter( const XMLDocument& /*doc*/ )			{
   5.412 +        return true;
   5.413 +    }
   5.414 +    /// Visit a document.
   5.415 +    virtual bool VisitExit( const XMLDocument& /*doc*/ )			{
   5.416 +        return true;
   5.417 +    }
   5.418 +
   5.419 +    /// Visit an element.
   5.420 +    virtual bool VisitEnter( const XMLElement& /*element*/, const XMLAttribute* /*firstAttribute*/ )	{
   5.421 +        return true;
   5.422 +    }
   5.423 +    /// Visit an element.
   5.424 +    virtual bool VisitExit( const XMLElement& /*element*/ )			{
   5.425 +        return true;
   5.426 +    }
   5.427 +
   5.428 +    /// Visit a declaration.
   5.429 +    virtual bool Visit( const XMLDeclaration& /*declaration*/ )		{
   5.430 +        return true;
   5.431 +    }
   5.432 +    /// Visit a text node.
   5.433 +    virtual bool Visit( const XMLText& /*text*/ )					{
   5.434 +        return true;
   5.435 +    }
   5.436 +    /// Visit a comment node.
   5.437 +    virtual bool Visit( const XMLComment& /*comment*/ )				{
   5.438 +        return true;
   5.439 +    }
   5.440 +    /// Visit an unknown node.
   5.441 +    virtual bool Visit( const XMLUnknown& /*unknown*/ )				{
   5.442 +        return true;
   5.443 +    }
   5.444 +};
   5.445 +
   5.446 +
   5.447 +/*
   5.448 +	Utility functionality.
   5.449 +*/
   5.450 +class XMLUtil
   5.451 +{
   5.452 +public:
   5.453 +    // Anything in the high order range of UTF-8 is assumed to not be whitespace. This isn't
   5.454 +    // correct, but simple, and usually works.
   5.455 +    static const char* SkipWhiteSpace( const char* p )	{
   5.456 +        while( !IsUTF8Continuation(*p) && isspace( *reinterpret_cast<const unsigned char*>(p) ) ) {
   5.457 +            ++p;
   5.458 +        }
   5.459 +        return p;
   5.460 +    }
   5.461 +    static char* SkipWhiteSpace( char* p )				{
   5.462 +        while( !IsUTF8Continuation(*p) && isspace( *reinterpret_cast<unsigned char*>(p) ) )		{
   5.463 +            ++p;
   5.464 +        }
   5.465 +        return p;
   5.466 +    }
   5.467 +    static bool IsWhiteSpace( char p )					{
   5.468 +        return !IsUTF8Continuation(p) && isspace( static_cast<unsigned char>(p) );
   5.469 +    }
   5.470 +
   5.471 +    inline static bool StringEqual( const char* p, const char* q, int nChar=INT_MAX )  {
   5.472 +        int n = 0;
   5.473 +        if ( p == q ) {
   5.474 +            return true;
   5.475 +        }
   5.476 +        while( *p && *q && *p == *q && n<nChar ) {
   5.477 +            ++p;
   5.478 +            ++q;
   5.479 +            ++n;
   5.480 +        }
   5.481 +        if ( (n == nChar) || ( *p == 0 && *q == 0 ) ) {
   5.482 +            return true;
   5.483 +        }
   5.484 +        return false;
   5.485 +    }
   5.486 +    inline static int IsUTF8Continuation( const char p ) {
   5.487 +        return p & 0x80;
   5.488 +    }
   5.489 +    inline static int IsAlphaNum( unsigned char anyByte )	{
   5.490 +        return ( anyByte < 128 ) ? isalnum( anyByte ) : 1;
   5.491 +    }
   5.492 +    inline static int IsAlpha( unsigned char anyByte )		{
   5.493 +        return ( anyByte < 128 ) ? isalpha( anyByte ) : 1;
   5.494 +    }
   5.495 +
   5.496 +    static const char* ReadBOM( const char* p, bool* hasBOM );
   5.497 +    // p is the starting location,
   5.498 +    // the UTF-8 value of the entity will be placed in value, and length filled in.
   5.499 +    static const char* GetCharacterRef( const char* p, char* value, int* length );
   5.500 +    static void ConvertUTF32ToUTF8( unsigned long input, char* output, int* length );
   5.501 +
   5.502 +    // converts primitive types to strings
   5.503 +    static void ToStr( int v, char* buffer, int bufferSize );
   5.504 +    static void ToStr( unsigned v, char* buffer, int bufferSize );
   5.505 +    static void ToStr( bool v, char* buffer, int bufferSize );
   5.506 +    static void ToStr( float v, char* buffer, int bufferSize );
   5.507 +    static void ToStr( double v, char* buffer, int bufferSize );
   5.508 +
   5.509 +    // converts strings to primitive types
   5.510 +    static bool	ToInt( const char* str, int* value );
   5.511 +    static bool ToUnsigned( const char* str, unsigned* value );
   5.512 +    static bool	ToBool( const char* str, bool* value );
   5.513 +    static bool	ToFloat( const char* str, float* value );
   5.514 +    static bool ToDouble( const char* str, double* value );
   5.515 +};
   5.516 +
   5.517 +
   5.518 +/** XMLNode is a base class for every object that is in the
   5.519 +	XML Document Object Model (DOM), except XMLAttributes.
   5.520 +	Nodes have siblings, a parent, and children which can
   5.521 +	be navigated. A node is always in a XMLDocument.
   5.522 +	The type of a XMLNode can be queried, and it can
   5.523 +	be cast to its more defined type.
   5.524 +
   5.525 +	A XMLDocument allocates memory for all its Nodes.
   5.526 +	When the XMLDocument gets deleted, all its Nodes
   5.527 +	will also be deleted.
   5.528 +
   5.529 +	@verbatim
   5.530 +	A Document can contain:	Element	(container or leaf)
   5.531 +							Comment (leaf)
   5.532 +							Unknown (leaf)
   5.533 +							Declaration( leaf )
   5.534 +
   5.535 +	An Element can contain:	Element (container or leaf)
   5.536 +							Text	(leaf)
   5.537 +							Attributes (not on tree)
   5.538 +							Comment (leaf)
   5.539 +							Unknown (leaf)
   5.540 +
   5.541 +	@endverbatim
   5.542 +*/
   5.543 +class XMLNode
   5.544 +{
   5.545 +    friend class XMLDocument;
   5.546 +    friend class XMLElement;
   5.547 +public:
   5.548 +
   5.549 +    /// Get the XMLDocument that owns this XMLNode.
   5.550 +    const XMLDocument* GetDocument() const	{
   5.551 +        return _document;
   5.552 +    }
   5.553 +    /// Get the XMLDocument that owns this XMLNode.
   5.554 +    XMLDocument* GetDocument()				{
   5.555 +        return _document;
   5.556 +    }
   5.557 +
   5.558 +    /// Safely cast to an Element, or null.
   5.559 +    virtual XMLElement*		ToElement()		{
   5.560 +        return 0;
   5.561 +    }
   5.562 +    /// Safely cast to Text, or null.
   5.563 +    virtual XMLText*		ToText()		{
   5.564 +        return 0;
   5.565 +    }
   5.566 +    /// Safely cast to a Comment, or null.
   5.567 +    virtual XMLComment*		ToComment()		{
   5.568 +        return 0;
   5.569 +    }
   5.570 +    /// Safely cast to a Document, or null.
   5.571 +    virtual XMLDocument*	ToDocument()	{
   5.572 +        return 0;
   5.573 +    }
   5.574 +    /// Safely cast to a Declaration, or null.
   5.575 +    virtual XMLDeclaration*	ToDeclaration()	{
   5.576 +        return 0;
   5.577 +    }
   5.578 +    /// Safely cast to an Unknown, or null.
   5.579 +    virtual XMLUnknown*		ToUnknown()		{
   5.580 +        return 0;
   5.581 +    }
   5.582 +
   5.583 +    virtual const XMLElement*		ToElement() const		{
   5.584 +        return 0;
   5.585 +    }
   5.586 +    virtual const XMLText*			ToText() const			{
   5.587 +        return 0;
   5.588 +    }
   5.589 +    virtual const XMLComment*		ToComment() const		{
   5.590 +        return 0;
   5.591 +    }
   5.592 +    virtual const XMLDocument*		ToDocument() const		{
   5.593 +        return 0;
   5.594 +    }
   5.595 +    virtual const XMLDeclaration*	ToDeclaration() const	{
   5.596 +        return 0;
   5.597 +    }
   5.598 +    virtual const XMLUnknown*		ToUnknown() const		{
   5.599 +        return 0;
   5.600 +    }
   5.601 +
   5.602 +    /** The meaning of 'value' changes for the specific type.
   5.603 +    	@verbatim
   5.604 +    	Document:	empty
   5.605 +    	Element:	name of the element
   5.606 +    	Comment:	the comment text
   5.607 +    	Unknown:	the tag contents
   5.608 +    	Text:		the text string
   5.609 +    	@endverbatim
   5.610 +    */
   5.611 +    const char* Value() const			{
   5.612 +        return _value.GetStr();
   5.613 +    }
   5.614 +
   5.615 +    /** Set the Value of an XML node.
   5.616 +    	@sa Value()
   5.617 +    */
   5.618 +    void SetValue( const char* val, bool staticMem=false );
   5.619 +
   5.620 +    /// Get the parent of this node on the DOM.
   5.621 +    const XMLNode*	Parent() const			{
   5.622 +        return _parent;
   5.623 +    }
   5.624 +
   5.625 +    XMLNode* Parent()						{
   5.626 +        return _parent;
   5.627 +    }
   5.628 +
   5.629 +    /// Returns true if this node has no children.
   5.630 +    bool NoChildren() const					{
   5.631 +        return !_firstChild;
   5.632 +    }
   5.633 +
   5.634 +    /// Get the first child node, or null if none exists.
   5.635 +    const XMLNode*  FirstChild() const		{
   5.636 +        return _firstChild;
   5.637 +    }
   5.638 +
   5.639 +    XMLNode*		FirstChild()			{
   5.640 +        return _firstChild;
   5.641 +    }
   5.642 +
   5.643 +    /** Get the first child element, or optionally the first child
   5.644 +        element with the specified name.
   5.645 +    */
   5.646 +    const XMLElement* FirstChildElement( const char* value=0 ) const;
   5.647 +
   5.648 +    XMLElement* FirstChildElement( const char* value=0 )	{
   5.649 +        return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->FirstChildElement( value ));
   5.650 +    }
   5.651 +
   5.652 +    /// Get the last child node, or null if none exists.
   5.653 +    const XMLNode*	LastChild() const						{
   5.654 +        return _lastChild;
   5.655 +    }
   5.656 +
   5.657 +    XMLNode*		LastChild()								{
   5.658 +        return const_cast<XMLNode*>(const_cast<const XMLNode*>(this)->LastChild() );
   5.659 +    }
   5.660 +
   5.661 +    /** Get the last child element or optionally the last child
   5.662 +        element with the specified name.
   5.663 +    */
   5.664 +    const XMLElement* LastChildElement( const char* value=0 ) const;
   5.665 +
   5.666 +    XMLElement* LastChildElement( const char* value=0 )	{
   5.667 +        return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->LastChildElement(value) );
   5.668 +    }
   5.669 +
   5.670 +    /// Get the previous (left) sibling node of this node.
   5.671 +    const XMLNode*	PreviousSibling() const					{
   5.672 +        return _prev;
   5.673 +    }
   5.674 +
   5.675 +    XMLNode*	PreviousSibling()							{
   5.676 +        return _prev;
   5.677 +    }
   5.678 +
   5.679 +    /// Get the previous (left) sibling element of this node, with an opitionally supplied name.
   5.680 +    const XMLElement*	PreviousSiblingElement( const char* value=0 ) const ;
   5.681 +
   5.682 +    XMLElement*	PreviousSiblingElement( const char* value=0 ) {
   5.683 +        return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->PreviousSiblingElement( value ) );
   5.684 +    }
   5.685 +
   5.686 +    /// Get the next (right) sibling node of this node.
   5.687 +    const XMLNode*	NextSibling() const						{
   5.688 +        return _next;
   5.689 +    }
   5.690 +
   5.691 +    XMLNode*	NextSibling()								{
   5.692 +        return _next;
   5.693 +    }
   5.694 +
   5.695 +    /// Get the next (right) sibling element of this node, with an opitionally supplied name.
   5.696 +    const XMLElement*	NextSiblingElement( const char* value=0 ) const;
   5.697 +
   5.698 +    XMLElement*	NextSiblingElement( const char* value=0 )	{
   5.699 +        return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->NextSiblingElement( value ) );
   5.700 +    }
   5.701 +
   5.702 +    /**
   5.703 +    	Add a child node as the last (right) child.
   5.704 +    */
   5.705 +    XMLNode* InsertEndChild( XMLNode* addThis );
   5.706 +
   5.707 +    XMLNode* LinkEndChild( XMLNode* addThis )	{
   5.708 +        return InsertEndChild( addThis );
   5.709 +    }
   5.710 +    /**
   5.711 +    	Add a child node as the first (left) child.
   5.712 +    */
   5.713 +    XMLNode* InsertFirstChild( XMLNode* addThis );
   5.714 +    /**
   5.715 +    	Add a node after the specified child node.
   5.716 +    */
   5.717 +    XMLNode* InsertAfterChild( XMLNode* afterThis, XMLNode* addThis );
   5.718 +
   5.719 +    /**
   5.720 +    	Delete all the children of this node.
   5.721 +    */
   5.722 +    void DeleteChildren();
   5.723 +
   5.724 +    /**
   5.725 +    	Delete a child of this node.
   5.726 +    */
   5.727 +    void DeleteChild( XMLNode* node );
   5.728 +
   5.729 +    /**
   5.730 +    	Make a copy of this node, but not its children.
   5.731 +    	You may pass in a Document pointer that will be
   5.732 +    	the owner of the new Node. If the 'document' is
   5.733 +    	null, then the node returned will be allocated
   5.734 +    	from the current Document. (this->GetDocument())
   5.735 +
   5.736 +    	Note: if called on a XMLDocument, this will return null.
   5.737 +    */
   5.738 +    virtual XMLNode* ShallowClone( XMLDocument* document ) const = 0;
   5.739 +
   5.740 +    /**
   5.741 +    	Test if 2 nodes are the same, but don't test children.
   5.742 +    	The 2 nodes do not need to be in the same Document.
   5.743 +
   5.744 +    	Note: if called on a XMLDocument, this will return false.
   5.745 +    */
   5.746 +    virtual bool ShallowEqual( const XMLNode* compare ) const = 0;
   5.747 +
   5.748 +    /** Accept a hierarchical visit of the nodes in the TinyXML DOM. Every node in the
   5.749 +    	XML tree will be conditionally visited and the host will be called back
   5.750 +    	via the TiXmlVisitor interface.
   5.751 +
   5.752 +    	This is essentially a SAX interface for TinyXML. (Note however it doesn't re-parse
   5.753 +    	the XML for the callbacks, so the performance of TinyXML is unchanged by using this
   5.754 +    	interface versus any other.)
   5.755 +
   5.756 +    	The interface has been based on ideas from:
   5.757 +
   5.758 +    	- http://www.saxproject.org/
   5.759 +    	- http://c2.com/cgi/wiki?HierarchicalVisitorPattern
   5.760 +
   5.761 +    	Which are both good references for "visiting".
   5.762 +
   5.763 +    	An example of using Accept():
   5.764 +    	@verbatim
   5.765 +    	TiXmlPrinter printer;
   5.766 +    	tinyxmlDoc.Accept( &printer );
   5.767 +    	const char* xmlcstr = printer.CStr();
   5.768 +    	@endverbatim
   5.769 +    */
   5.770 +    virtual bool Accept( XMLVisitor* visitor ) const = 0;
   5.771 +
   5.772 +    // internal
   5.773 +    virtual char* ParseDeep( char*, StrPair* );
   5.774 +
   5.775 +protected:
   5.776 +    XMLNode( XMLDocument* );
   5.777 +    virtual ~XMLNode();
   5.778 +    XMLNode( const XMLNode& );	// not supported
   5.779 +    XMLNode& operator=( const XMLNode& );	// not supported
   5.780 +
   5.781 +    XMLDocument*	_document;
   5.782 +    XMLNode*		_parent;
   5.783 +    mutable StrPair	_value;
   5.784 +
   5.785 +    XMLNode*		_firstChild;
   5.786 +    XMLNode*		_lastChild;
   5.787 +
   5.788 +    XMLNode*		_prev;
   5.789 +    XMLNode*		_next;
   5.790 +
   5.791 +private:
   5.792 +    MemPool*		_memPool;
   5.793 +    void Unlink( XMLNode* child );
   5.794 +};
   5.795 +
   5.796 +
   5.797 +/** XML text.
   5.798 +
   5.799 +	Note that a text node can have child element nodes, for example:
   5.800 +	@verbatim
   5.801 +	<root>This is <b>bold</b></root>
   5.802 +	@endverbatim
   5.803 +
   5.804 +	A text node can have 2 ways to output the next. "normal" output
   5.805 +	and CDATA. It will default to the mode it was parsed from the XML file and
   5.806 +	you generally want to leave it alone, but you can change the output mode with
   5.807 +	SetCDATA() and query it with CDATA().
   5.808 +*/
   5.809 +class XMLText : public XMLNode
   5.810 +{
   5.811 +    friend class XMLBase;
   5.812 +    friend class XMLDocument;
   5.813 +public:
   5.814 +    virtual bool Accept( XMLVisitor* visitor ) const;
   5.815 +
   5.816 +    virtual XMLText* ToText()			{
   5.817 +        return this;
   5.818 +    }
   5.819 +    virtual const XMLText* ToText() const	{
   5.820 +        return this;
   5.821 +    }
   5.822 +
   5.823 +    /// Declare whether this should be CDATA or standard text.
   5.824 +    void SetCData( bool isCData )			{
   5.825 +        _isCData = isCData;
   5.826 +    }
   5.827 +    /// Returns true if this is a CDATA text element.
   5.828 +    bool CData() const						{
   5.829 +        return _isCData;
   5.830 +    }
   5.831 +
   5.832 +    char* ParseDeep( char*, StrPair* endTag );
   5.833 +    virtual XMLNode* ShallowClone( XMLDocument* document ) const;
   5.834 +    virtual bool ShallowEqual( const XMLNode* compare ) const;
   5.835 +
   5.836 +protected:
   5.837 +    XMLText( XMLDocument* doc )	: XMLNode( doc ), _isCData( false )	{}
   5.838 +    virtual ~XMLText()												{}
   5.839 +    XMLText( const XMLText& );	// not supported
   5.840 +    XMLText& operator=( const XMLText& );	// not supported
   5.841 +
   5.842 +private:
   5.843 +    bool _isCData;
   5.844 +};
   5.845 +
   5.846 +
   5.847 +/** An XML Comment. */
   5.848 +class XMLComment : public XMLNode
   5.849 +{
   5.850 +    friend class XMLDocument;
   5.851 +public:
   5.852 +    virtual XMLComment*	ToComment()					{
   5.853 +        return this;
   5.854 +    }
   5.855 +    virtual const XMLComment* ToComment() const		{
   5.856 +        return this;
   5.857 +    }
   5.858 +
   5.859 +    virtual bool Accept( XMLVisitor* visitor ) const;
   5.860 +
   5.861 +    char* ParseDeep( char*, StrPair* endTag );
   5.862 +    virtual XMLNode* ShallowClone( XMLDocument* document ) const;
   5.863 +    virtual bool ShallowEqual( const XMLNode* compare ) const;
   5.864 +
   5.865 +protected:
   5.866 +    XMLComment( XMLDocument* doc );
   5.867 +    virtual ~XMLComment();
   5.868 +    XMLComment( const XMLComment& );	// not supported
   5.869 +    XMLComment& operator=( const XMLComment& );	// not supported
   5.870 +
   5.871 +private:
   5.872 +};
   5.873 +
   5.874 +
   5.875 +/** In correct XML the declaration is the first entry in the file.
   5.876 +	@verbatim
   5.877 +		<?xml version="1.0" standalone="yes"?>
   5.878 +	@endverbatim
   5.879 +
   5.880 +	TinyXML2 will happily read or write files without a declaration,
   5.881 +	however.
   5.882 +
   5.883 +	The text of the declaration isn't interpreted. It is parsed
   5.884 +	and written as a string.
   5.885 +*/
   5.886 +class XMLDeclaration : public XMLNode
   5.887 +{
   5.888 +    friend class XMLDocument;
   5.889 +public:
   5.890 +    virtual XMLDeclaration*	ToDeclaration()					{
   5.891 +        return this;
   5.892 +    }
   5.893 +    virtual const XMLDeclaration* ToDeclaration() const		{
   5.894 +        return this;
   5.895 +    }
   5.896 +
   5.897 +    virtual bool Accept( XMLVisitor* visitor ) const;
   5.898 +
   5.899 +    char* ParseDeep( char*, StrPair* endTag );
   5.900 +    virtual XMLNode* ShallowClone( XMLDocument* document ) const;
   5.901 +    virtual bool ShallowEqual( const XMLNode* compare ) const;
   5.902 +
   5.903 +protected:
   5.904 +    XMLDeclaration( XMLDocument* doc );
   5.905 +    virtual ~XMLDeclaration();
   5.906 +    XMLDeclaration( const XMLDeclaration& );	// not supported
   5.907 +    XMLDeclaration& operator=( const XMLDeclaration& );	// not supported
   5.908 +};
   5.909 +
   5.910 +
   5.911 +/** Any tag that tinyXml doesn't recognize is saved as an
   5.912 +	unknown. It is a tag of text, but should not be modified.
   5.913 +	It will be written back to the XML, unchanged, when the file
   5.914 +	is saved.
   5.915 +
   5.916 +	DTD tags get thrown into TiXmlUnknowns.
   5.917 +*/
   5.918 +class XMLUnknown : public XMLNode
   5.919 +{
   5.920 +    friend class XMLDocument;
   5.921 +public:
   5.922 +    virtual XMLUnknown*	ToUnknown()					{
   5.923 +        return this;
   5.924 +    }
   5.925 +    virtual const XMLUnknown* ToUnknown() const		{
   5.926 +        return this;
   5.927 +    }
   5.928 +
   5.929 +    virtual bool Accept( XMLVisitor* visitor ) const;
   5.930 +
   5.931 +    char* ParseDeep( char*, StrPair* endTag );
   5.932 +    virtual XMLNode* ShallowClone( XMLDocument* document ) const;
   5.933 +    virtual bool ShallowEqual( const XMLNode* compare ) const;
   5.934 +
   5.935 +protected:
   5.936 +    XMLUnknown( XMLDocument* doc );
   5.937 +    virtual ~XMLUnknown();
   5.938 +    XMLUnknown( const XMLUnknown& );	// not supported
   5.939 +    XMLUnknown& operator=( const XMLUnknown& );	// not supported
   5.940 +};
   5.941 +
   5.942 +
   5.943 +enum XMLError {
   5.944 +    XML_NO_ERROR = 0,
   5.945 +    XML_SUCCESS = 0,
   5.946 +
   5.947 +    XML_NO_ATTRIBUTE,
   5.948 +    XML_WRONG_ATTRIBUTE_TYPE,
   5.949 +
   5.950 +    XML_ERROR_FILE_NOT_FOUND,
   5.951 +    XML_ERROR_FILE_COULD_NOT_BE_OPENED,
   5.952 +    XML_ERROR_FILE_READ_ERROR,
   5.953 +    XML_ERROR_ELEMENT_MISMATCH,
   5.954 +    XML_ERROR_PARSING_ELEMENT,
   5.955 +    XML_ERROR_PARSING_ATTRIBUTE,
   5.956 +    XML_ERROR_IDENTIFYING_TAG,
   5.957 +    XML_ERROR_PARSING_TEXT,
   5.958 +    XML_ERROR_PARSING_CDATA,
   5.959 +    XML_ERROR_PARSING_COMMENT,
   5.960 +    XML_ERROR_PARSING_DECLARATION,
   5.961 +    XML_ERROR_PARSING_UNKNOWN,
   5.962 +    XML_ERROR_EMPTY_DOCUMENT,
   5.963 +    XML_ERROR_MISMATCHED_ELEMENT,
   5.964 +    XML_ERROR_PARSING,
   5.965 +
   5.966 +    XML_CAN_NOT_CONVERT_TEXT,
   5.967 +    XML_NO_TEXT_NODE
   5.968 +};
   5.969 +
   5.970 +
   5.971 +/** An attribute is a name-value pair. Elements have an arbitrary
   5.972 +	number of attributes, each with a unique name.
   5.973 +
   5.974 +	@note The attributes are not XMLNodes. You may only query the
   5.975 +	Next() attribute in a list.
   5.976 +*/
   5.977 +class XMLAttribute
   5.978 +{
   5.979 +    friend class XMLElement;
   5.980 +public:
   5.981 +    /// The name of the attribute.
   5.982 +    const char* Name() const {
   5.983 +        return _name.GetStr();
   5.984 +    }
   5.985 +    /// The value of the attribute.
   5.986 +    const char* Value() const {
   5.987 +        return _value.GetStr();
   5.988 +    }
   5.989 +    /// The next attribute in the list.
   5.990 +    const XMLAttribute* Next() const {
   5.991 +        return _next;
   5.992 +    }
   5.993 +
   5.994 +    /** IntAttribute interprets the attribute as an integer, and returns the value.
   5.995 +        If the value isn't an integer, 0 will be returned. There is no error checking;
   5.996 +    	use QueryIntAttribute() if you need error checking.
   5.997 +    */
   5.998 +    int		 IntValue() const				{
   5.999 +        int i=0;
  5.1000 +        QueryIntValue( &i );
  5.1001 +        return i;
  5.1002 +    }
  5.1003 +    /// Query as an unsigned integer. See IntAttribute()
  5.1004 +    unsigned UnsignedValue() const			{
  5.1005 +        unsigned i=0;
  5.1006 +        QueryUnsignedValue( &i );
  5.1007 +        return i;
  5.1008 +    }
  5.1009 +    /// Query as a boolean. See IntAttribute()
  5.1010 +    bool	 BoolValue() const				{
  5.1011 +        bool b=false;
  5.1012 +        QueryBoolValue( &b );
  5.1013 +        return b;
  5.1014 +    }
  5.1015 +    /// Query as a double. See IntAttribute()
  5.1016 +    double 	 DoubleValue() const			{
  5.1017 +        double d=0;
  5.1018 +        QueryDoubleValue( &d );
  5.1019 +        return d;
  5.1020 +    }
  5.1021 +    /// Query as a float. See IntAttribute()
  5.1022 +    float	 FloatValue() const				{
  5.1023 +        float f=0;
  5.1024 +        QueryFloatValue( &f );
  5.1025 +        return f;
  5.1026 +    }
  5.1027 +
  5.1028 +    /** QueryIntAttribute interprets the attribute as an integer, and returns the value
  5.1029 +    	in the provided paremeter. The function will return XML_NO_ERROR on success,
  5.1030 +    	and XML_WRONG_ATTRIBUTE_TYPE if the conversion is not successful.
  5.1031 +    */
  5.1032 +    XMLError QueryIntValue( int* value ) const;
  5.1033 +    /// See QueryIntAttribute
  5.1034 +    XMLError QueryUnsignedValue( unsigned int* value ) const;
  5.1035 +    /// See QueryIntAttribute
  5.1036 +    XMLError QueryBoolValue( bool* value ) const;
  5.1037 +    /// See QueryIntAttribute
  5.1038 +    XMLError QueryDoubleValue( double* value ) const;
  5.1039 +    /// See QueryIntAttribute
  5.1040 +    XMLError QueryFloatValue( float* value ) const;
  5.1041 +
  5.1042 +    /// Set the attribute to a string value.
  5.1043 +    void SetAttribute( const char* value );
  5.1044 +    /// Set the attribute to value.
  5.1045 +    void SetAttribute( int value );
  5.1046 +    /// Set the attribute to value.
  5.1047 +    void SetAttribute( unsigned value );
  5.1048 +    /// Set the attribute to value.
  5.1049 +    void SetAttribute( bool value );
  5.1050 +    /// Set the attribute to value.
  5.1051 +    void SetAttribute( double value );
  5.1052 +    /// Set the attribute to value.
  5.1053 +    void SetAttribute( float value );
  5.1054 +
  5.1055 +private:
  5.1056 +    enum { BUF_SIZE = 200 };
  5.1057 +
  5.1058 +    XMLAttribute() : _next( 0 ) {}
  5.1059 +    virtual ~XMLAttribute()	{}
  5.1060 +
  5.1061 +    XMLAttribute( const XMLAttribute& );	// not supported
  5.1062 +    void operator=( const XMLAttribute& );	// not supported
  5.1063 +    void SetName( const char* name );
  5.1064 +
  5.1065 +    char* ParseDeep( char* p, bool processEntities );
  5.1066 +
  5.1067 +    mutable StrPair _name;
  5.1068 +    mutable StrPair _value;
  5.1069 +    XMLAttribute*   _next;
  5.1070 +    MemPool*        _memPool;
  5.1071 +};
  5.1072 +
  5.1073 +
  5.1074 +/** The element is a container class. It has a value, the element name,
  5.1075 +	and can contain other elements, text, comments, and unknowns.
  5.1076 +	Elements also contain an arbitrary number of attributes.
  5.1077 +*/
  5.1078 +class XMLElement : public XMLNode
  5.1079 +{
  5.1080 +    friend class XMLBase;
  5.1081 +    friend class XMLDocument;
  5.1082 +public:
  5.1083 +    /// Get the name of an element (which is the Value() of the node.)
  5.1084 +    const char* Name() const		{
  5.1085 +        return Value();
  5.1086 +    }
  5.1087 +    /// Set the name of the element.
  5.1088 +    void SetName( const char* str, bool staticMem=false )	{
  5.1089 +        SetValue( str, staticMem );
  5.1090 +    }
  5.1091 +
  5.1092 +    virtual XMLElement* ToElement()				{
  5.1093 +        return this;
  5.1094 +    }
  5.1095 +    virtual const XMLElement* ToElement() const {
  5.1096 +        return this;
  5.1097 +    }
  5.1098 +    virtual bool Accept( XMLVisitor* visitor ) const;
  5.1099 +
  5.1100 +    /** Given an attribute name, Attribute() returns the value
  5.1101 +    	for the attribute of that name, or null if none
  5.1102 +    	exists. For example:
  5.1103 +
  5.1104 +    	@verbatim
  5.1105 +    	const char* value = ele->Attribute( "foo" );
  5.1106 +    	@endverbatim
  5.1107 +
  5.1108 +    	The 'value' parameter is normally null. However, if specified,
  5.1109 +    	the attribute will only be returned if the 'name' and 'value'
  5.1110 +    	match. This allow you to write code:
  5.1111 +
  5.1112 +    	@verbatim
  5.1113 +    	if ( ele->Attribute( "foo", "bar" ) ) callFooIsBar();
  5.1114 +    	@endverbatim
  5.1115 +
  5.1116 +    	rather than:
  5.1117 +    	@verbatim
  5.1118 +    	if ( ele->Attribute( "foo" ) ) {
  5.1119 +    		if ( strcmp( ele->Attribute( "foo" ), "bar" ) == 0 ) callFooIsBar();
  5.1120 +    	}
  5.1121 +    	@endverbatim
  5.1122 +    */
  5.1123 +    const char* Attribute( const char* name, const char* value=0 ) const;
  5.1124 +
  5.1125 +    /** Given an attribute name, IntAttribute() returns the value
  5.1126 +    	of the attribute interpreted as an integer. 0 will be
  5.1127 +    	returned if there is an error. For a method with error
  5.1128 +    	checking, see QueryIntAttribute()
  5.1129 +    */
  5.1130 +    int		 IntAttribute( const char* name ) const		{
  5.1131 +        int i=0;
  5.1132 +        QueryIntAttribute( name, &i );
  5.1133 +        return i;
  5.1134 +    }
  5.1135 +    /// See IntAttribute()
  5.1136 +    unsigned UnsignedAttribute( const char* name ) const {
  5.1137 +        unsigned i=0;
  5.1138 +        QueryUnsignedAttribute( name, &i );
  5.1139 +        return i;
  5.1140 +    }
  5.1141 +    /// See IntAttribute()
  5.1142 +    bool	 BoolAttribute( const char* name ) const	{
  5.1143 +        bool b=false;
  5.1144 +        QueryBoolAttribute( name, &b );
  5.1145 +        return b;
  5.1146 +    }
  5.1147 +    /// See IntAttribute()
  5.1148 +    double 	 DoubleAttribute( const char* name ) const	{
  5.1149 +        double d=0;
  5.1150 +        QueryDoubleAttribute( name, &d );
  5.1151 +        return d;
  5.1152 +    }
  5.1153 +    /// See IntAttribute()
  5.1154 +    float	 FloatAttribute( const char* name ) const	{
  5.1155 +        float f=0;
  5.1156 +        QueryFloatAttribute( name, &f );
  5.1157 +        return f;
  5.1158 +    }
  5.1159 +
  5.1160 +    /** Given an attribute name, QueryIntAttribute() returns
  5.1161 +    	XML_NO_ERROR, XML_WRONG_ATTRIBUTE_TYPE if the conversion
  5.1162 +    	can't be performed, or XML_NO_ATTRIBUTE if the attribute
  5.1163 +    	doesn't exist. If successful, the result of the conversion
  5.1164 +    	will be written to 'value'. If not successful, nothing will
  5.1165 +    	be written to 'value'. This allows you to provide default
  5.1166 +    	value:
  5.1167 +
  5.1168 +    	@verbatim
  5.1169 +    	int value = 10;
  5.1170 +    	QueryIntAttribute( "foo", &value );		// if "foo" isn't found, value will still be 10
  5.1171 +    	@endverbatim
  5.1172 +    */
  5.1173 +    XMLError QueryIntAttribute( const char* name, int* value ) const				{
  5.1174 +        const XMLAttribute* a = FindAttribute( name );
  5.1175 +        if ( !a ) {
  5.1176 +            return XML_NO_ATTRIBUTE;
  5.1177 +        }
  5.1178 +        return a->QueryIntValue( value );
  5.1179 +    }
  5.1180 +    /// See QueryIntAttribute()
  5.1181 +    XMLError QueryUnsignedAttribute( const char* name, unsigned int* value ) const	{
  5.1182 +        const XMLAttribute* a = FindAttribute( name );
  5.1183 +        if ( !a ) {
  5.1184 +            return XML_NO_ATTRIBUTE;
  5.1185 +        }
  5.1186 +        return a->QueryUnsignedValue( value );
  5.1187 +    }
  5.1188 +    /// See QueryIntAttribute()
  5.1189 +    XMLError QueryBoolAttribute( const char* name, bool* value ) const				{
  5.1190 +        const XMLAttribute* a = FindAttribute( name );
  5.1191 +        if ( !a ) {
  5.1192 +            return XML_NO_ATTRIBUTE;
  5.1193 +        }
  5.1194 +        return a->QueryBoolValue( value );
  5.1195 +    }
  5.1196 +    /// See QueryIntAttribute()
  5.1197 +    XMLError QueryDoubleAttribute( const char* name, double* value ) const			{
  5.1198 +        const XMLAttribute* a = FindAttribute( name );
  5.1199 +        if ( !a ) {
  5.1200 +            return XML_NO_ATTRIBUTE;
  5.1201 +        }
  5.1202 +        return a->QueryDoubleValue( value );
  5.1203 +    }
  5.1204 +    /// See QueryIntAttribute()
  5.1205 +    XMLError QueryFloatAttribute( const char* name, float* value ) const			{
  5.1206 +        const XMLAttribute* a = FindAttribute( name );
  5.1207 +        if ( !a ) {
  5.1208 +            return XML_NO_ATTRIBUTE;
  5.1209 +        }
  5.1210 +        return a->QueryFloatValue( value );
  5.1211 +    }
  5.1212 +
  5.1213 +    /// Sets the named attribute to value.
  5.1214 +    void SetAttribute( const char* name, const char* value )	{
  5.1215 +        XMLAttribute* a = FindOrCreateAttribute( name );
  5.1216 +        a->SetAttribute( value );
  5.1217 +    }
  5.1218 +    /// Sets the named attribute to value.
  5.1219 +    void SetAttribute( const char* name, int value )			{
  5.1220 +        XMLAttribute* a = FindOrCreateAttribute( name );
  5.1221 +        a->SetAttribute( value );
  5.1222 +    }
  5.1223 +    /// Sets the named attribute to value.
  5.1224 +    void SetAttribute( const char* name, unsigned value )		{
  5.1225 +        XMLAttribute* a = FindOrCreateAttribute( name );
  5.1226 +        a->SetAttribute( value );
  5.1227 +    }
  5.1228 +    /// Sets the named attribute to value.
  5.1229 +    void SetAttribute( const char* name, bool value )			{
  5.1230 +        XMLAttribute* a = FindOrCreateAttribute( name );
  5.1231 +        a->SetAttribute( value );
  5.1232 +    }
  5.1233 +    /// Sets the named attribute to value.
  5.1234 +    void SetAttribute( const char* name, double value )		{
  5.1235 +        XMLAttribute* a = FindOrCreateAttribute( name );
  5.1236 +        a->SetAttribute( value );
  5.1237 +    }
  5.1238 +
  5.1239 +    /**
  5.1240 +    	Delete an attribute.
  5.1241 +    */
  5.1242 +    void DeleteAttribute( const char* name );
  5.1243 +
  5.1244 +    /// Return the first attribute in the list.
  5.1245 +    const XMLAttribute* FirstAttribute() const {
  5.1246 +        return _rootAttribute;
  5.1247 +    }
  5.1248 +    /// Query a specific attribute in the list.
  5.1249 +    const XMLAttribute* FindAttribute( const char* name ) const;
  5.1250 +
  5.1251 +    /** Convenience function for easy access to the text inside an element. Although easy
  5.1252 +    	and concise, GetText() is limited compared to getting the TiXmlText child
  5.1253 +    	and accessing it directly.
  5.1254 +
  5.1255 +    	If the first child of 'this' is a TiXmlText, the GetText()
  5.1256 +    	returns the character string of the Text node, else null is returned.
  5.1257 +
  5.1258 +    	This is a convenient method for getting the text of simple contained text:
  5.1259 +    	@verbatim
  5.1260 +    	<foo>This is text</foo>
  5.1261 +    		const char* str = fooElement->GetText();
  5.1262 +    	@endverbatim
  5.1263 +
  5.1264 +    	'str' will be a pointer to "This is text".
  5.1265 +
  5.1266 +    	Note that this function can be misleading. If the element foo was created from
  5.1267 +    	this XML:
  5.1268 +    	@verbatim
  5.1269 +    		<foo><b>This is text</b></foo>
  5.1270 +    	@endverbatim
  5.1271 +
  5.1272 +    	then the value of str would be null. The first child node isn't a text node, it is
  5.1273 +    	another element. From this XML:
  5.1274 +    	@verbatim
  5.1275 +    		<foo>This is <b>text</b></foo>
  5.1276 +    	@endverbatim
  5.1277 +    	GetText() will return "This is ".
  5.1278 +    */
  5.1279 +    const char* GetText() const;
  5.1280 +
  5.1281 +    /**
  5.1282 +    	Convenience method to query the value of a child text node. This is probably best
  5.1283 +    	shown by example. Given you have a document is this form:
  5.1284 +    	@verbatim
  5.1285 +    		<point>
  5.1286 +    			<x>1</x>
  5.1287 +    			<y>1.4</y>
  5.1288 +    		</point>
  5.1289 +    	@endverbatim
  5.1290 +
  5.1291 +    	The QueryIntText() and similar functions provide a safe and easier way to get to the
  5.1292 +    	"value" of x and y.
  5.1293 +
  5.1294 +    	@verbatim
  5.1295 +    		int x = 0;
  5.1296 +    		float y = 0;	// types of x and y are contrived for example
  5.1297 +    		const XMLElement* xElement = pointElement->FirstChildElement( "x" );
  5.1298 +    		const XMLElement* yElement = pointElement->FirstChildElement( "y" );
  5.1299 +    		xElement->QueryIntText( &x );
  5.1300 +    		yElement->QueryFloatText( &y );
  5.1301 +    	@endverbatim
  5.1302 +
  5.1303 +    	@returns XML_SUCCESS (0) on success, XML_CAN_NOT_CONVERT_TEXT if the text cannot be converted
  5.1304 +    			 to the requested type, and XML_NO_TEXT_NODE if there is no child text to query.
  5.1305 +
  5.1306 +    */
  5.1307 +    XMLError QueryIntText( int* ival ) const;
  5.1308 +    /// See QueryIntText()
  5.1309 +    XMLError QueryUnsignedText( unsigned* uval ) const;
  5.1310 +    /// See QueryIntText()
  5.1311 +    XMLError QueryBoolText( bool* bval ) const;
  5.1312 +    /// See QueryIntText()
  5.1313 +    XMLError QueryDoubleText( double* dval ) const;
  5.1314 +    /// See QueryIntText()
  5.1315 +    XMLError QueryFloatText( float* fval ) const;
  5.1316 +
  5.1317 +    // internal:
  5.1318 +    enum {
  5.1319 +        OPEN,		// <foo>
  5.1320 +        CLOSED,		// <foo/>
  5.1321 +        CLOSING		// </foo>
  5.1322 +    };
  5.1323 +    int ClosingType() const {
  5.1324 +        return _closingType;
  5.1325 +    }
  5.1326 +    char* ParseDeep( char* p, StrPair* endTag );
  5.1327 +    virtual XMLNode* ShallowClone( XMLDocument* document ) const;
  5.1328 +    virtual bool ShallowEqual( const XMLNode* compare ) const;
  5.1329 +
  5.1330 +private:
  5.1331 +    XMLElement( XMLDocument* doc );
  5.1332 +    virtual ~XMLElement();
  5.1333 +    XMLElement( const XMLElement& );	// not supported
  5.1334 +    void operator=( const XMLElement& );	// not supported
  5.1335 +
  5.1336 +    XMLAttribute* FindAttribute( const char* name );
  5.1337 +    XMLAttribute* FindOrCreateAttribute( const char* name );
  5.1338 +    //void LinkAttribute( XMLAttribute* attrib );
  5.1339 +    char* ParseAttributes( char* p );
  5.1340 +
  5.1341 +    int _closingType;
  5.1342 +    // The attribute list is ordered; there is no 'lastAttribute'
  5.1343 +    // because the list needs to be scanned for dupes before adding
  5.1344 +    // a new attribute.
  5.1345 +    XMLAttribute* _rootAttribute;
  5.1346 +};
  5.1347 +
  5.1348 +
  5.1349 +enum Whitespace {
  5.1350 +    PRESERVE_WHITESPACE,
  5.1351 +    COLLAPSE_WHITESPACE
  5.1352 +};
  5.1353 +
  5.1354 +
  5.1355 +/** A Document binds together all the functionality.
  5.1356 +	It can be saved, loaded, and printed to the screen.
  5.1357 +	All Nodes are connected and allocated to a Document.
  5.1358 +	If the Document is deleted, all its Nodes are also deleted.
  5.1359 +*/
  5.1360 +class XMLDocument : public XMLNode
  5.1361 +{
  5.1362 +    friend class XMLElement;
  5.1363 +public:
  5.1364 +    /// constructor
  5.1365 +    XMLDocument( bool processEntities = true, Whitespace = PRESERVE_WHITESPACE );
  5.1366 +    ~XMLDocument();
  5.1367 +
  5.1368 +    virtual XMLDocument* ToDocument()				{
  5.1369 +        return this;
  5.1370 +    }
  5.1371 +    virtual const XMLDocument* ToDocument() const	{
  5.1372 +        return this;
  5.1373 +    }
  5.1374 +
  5.1375 +    /**
  5.1376 +    	Parse an XML file from a character string.
  5.1377 +    	Returns XML_NO_ERROR (0) on success, or
  5.1378 +    	an errorID.
  5.1379 +
  5.1380 +    	You may optionally pass in the 'nBytes', which is
  5.1381 +    	the number of bytes which will be parsed. If not
  5.1382 +    	specified, TinyXML will assume 'xml' points to a
  5.1383 +    	null terminated string.
  5.1384 +    */
  5.1385 +    XMLError Parse( const char* xml, size_t nBytes=(size_t)(-1) );
  5.1386 +
  5.1387 +    /**
  5.1388 +    	Load an XML file from disk.
  5.1389 +    	Returns XML_NO_ERROR (0) on success, or
  5.1390 +    	an errorID.
  5.1391 +    */
  5.1392 +    XMLError LoadFile( const char* filename );
  5.1393 +
  5.1394 +    /**
  5.1395 +    	Load an XML file from disk. You are responsible
  5.1396 +    	for providing and closing the FILE*.
  5.1397 +
  5.1398 +    	Returns XML_NO_ERROR (0) on success, or
  5.1399 +    	an errorID.
  5.1400 +    */
  5.1401 +    XMLError LoadFile( FILE* );
  5.1402 +
  5.1403 +    /**
  5.1404 +    	Save the XML file to disk.
  5.1405 +    	Returns XML_NO_ERROR (0) on success, or
  5.1406 +    	an errorID.
  5.1407 +    */
  5.1408 +    XMLError SaveFile( const char* filename, bool compact = false );
  5.1409 +
  5.1410 +    /**
  5.1411 +    	Save the XML file to disk. You are responsible
  5.1412 +    	for providing and closing the FILE*.
  5.1413 +
  5.1414 +    	Returns XML_NO_ERROR (0) on success, or
  5.1415 +    	an errorID.
  5.1416 +    */
  5.1417 +    XMLError SaveFile( FILE* fp, bool compact = false );
  5.1418 +
  5.1419 +    bool ProcessEntities() const		{
  5.1420 +        return _processEntities;
  5.1421 +    }
  5.1422 +    Whitespace WhitespaceMode() const	{
  5.1423 +        return _whitespace;
  5.1424 +    }
  5.1425 +
  5.1426 +    /**
  5.1427 +    	Returns true if this document has a leading Byte Order Mark of UTF8.
  5.1428 +    */
  5.1429 +    bool HasBOM() const {
  5.1430 +        return _writeBOM;
  5.1431 +    }
  5.1432 +    /** Sets whether to write the BOM when writing the file.
  5.1433 +    */
  5.1434 +    void SetBOM( bool useBOM ) {
  5.1435 +        _writeBOM = useBOM;
  5.1436 +    }
  5.1437 +
  5.1438 +    /** Return the root element of DOM. Equivalent to FirstChildElement().
  5.1439 +        To get the first node, use FirstChild().
  5.1440 +    */
  5.1441 +    XMLElement* RootElement()				{
  5.1442 +        return FirstChildElement();
  5.1443 +    }
  5.1444 +    const XMLElement* RootElement() const	{
  5.1445 +        return FirstChildElement();
  5.1446 +    }
  5.1447 +
  5.1448 +    /** Print the Document. If the Printer is not provided, it will
  5.1449 +        print to stdout. If you provide Printer, this can print to a file:
  5.1450 +    	@verbatim
  5.1451 +    	XMLPrinter printer( fp );
  5.1452 +    	doc.Print( &printer );
  5.1453 +    	@endverbatim
  5.1454 +
  5.1455 +    	Or you can use a printer to print to memory:
  5.1456 +    	@verbatim
  5.1457 +    	XMLPrinter printer;
  5.1458 +    	doc->Print( &printer );
  5.1459 +    	// printer.CStr() has a const char* to the XML
  5.1460 +    	@endverbatim
  5.1461 +    */
  5.1462 +    void Print( XMLPrinter* streamer=0 );
  5.1463 +    virtual bool Accept( XMLVisitor* visitor ) const;
  5.1464 +
  5.1465 +    /**
  5.1466 +    	Create a new Element associated with
  5.1467 +    	this Document. The memory for the Element
  5.1468 +    	is managed by the Document.
  5.1469 +    */
  5.1470 +    XMLElement* NewElement( const char* name );
  5.1471 +    /**
  5.1472 +    	Create a new Comment associated with
  5.1473 +    	this Document. The memory for the Comment
  5.1474 +    	is managed by the Document.
  5.1475 +    */
  5.1476 +    XMLComment* NewComment( const char* comment );
  5.1477 +    /**
  5.1478 +    	Create a new Text associated with
  5.1479 +    	this Document. The memory for the Text
  5.1480 +    	is managed by the Document.
  5.1481 +    */
  5.1482 +    XMLText* NewText( const char* text );
  5.1483 +    /**
  5.1484 +    	Create a new Declaration associated with
  5.1485 +    	this Document. The memory for the object
  5.1486 +    	is managed by the Document.
  5.1487 +
  5.1488 +    	If the 'text' param is null, the standard
  5.1489 +    	declaration is used.:
  5.1490 +    	@verbatim
  5.1491 +    		<?xml version="1.0" encoding="UTF-8"?>
  5.1492 +    	@endverbatim
  5.1493 +    */
  5.1494 +    XMLDeclaration* NewDeclaration( const char* text=0 );
  5.1495 +    /**
  5.1496 +    	Create a new Unknown associated with
  5.1497 +    	this Document. The memory forthe object
  5.1498 +    	is managed by the Document.
  5.1499 +    */
  5.1500 +    XMLUnknown* NewUnknown( const char* text );
  5.1501 +
  5.1502 +    /**
  5.1503 +    	Delete a node associated with this document.
  5.1504 +    	It will be unlinked from the DOM.
  5.1505 +    */
  5.1506 +    void DeleteNode( XMLNode* node )	{
  5.1507 +        node->_parent->DeleteChild( node );
  5.1508 +    }
  5.1509 +
  5.1510 +    void SetError( XMLError error, const char* str1, const char* str2 );
  5.1511 +
  5.1512 +    /// Return true if there was an error parsing the document.
  5.1513 +    bool Error() const {
  5.1514 +        return _errorID != XML_NO_ERROR;
  5.1515 +    }
  5.1516 +    /// Return the errorID.
  5.1517 +    XMLError  ErrorID() const {
  5.1518 +        return _errorID;
  5.1519 +    }
  5.1520 +    /// Return a possibly helpful diagnostic location or string.
  5.1521 +    const char* GetErrorStr1() const {
  5.1522 +        return _errorStr1;
  5.1523 +    }
  5.1524 +    /// Return a possibly helpful secondary diagnostic location or string.
  5.1525 +    const char* GetErrorStr2() const {
  5.1526 +        return _errorStr2;
  5.1527 +    }
  5.1528 +    /// If there is an error, print it to stdout.
  5.1529 +    void PrintError() const;
  5.1530 +
  5.1531 +    // internal
  5.1532 +    char* Identify( char* p, XMLNode** node );
  5.1533 +
  5.1534 +    virtual XMLNode* ShallowClone( XMLDocument* /*document*/ ) const	{
  5.1535 +        return 0;
  5.1536 +    }
  5.1537 +    virtual bool ShallowEqual( const XMLNode* /*compare*/ ) const	{
  5.1538 +        return false;
  5.1539 +    }
  5.1540 +
  5.1541 +private:
  5.1542 +    XMLDocument( const XMLDocument& );	// not supported
  5.1543 +    void operator=( const XMLDocument& );	// not supported
  5.1544 +    void InitDocument();
  5.1545 +
  5.1546 +    bool        _writeBOM;
  5.1547 +    bool        _processEntities;
  5.1548 +    XMLError    _errorID;
  5.1549 +    Whitespace  _whitespace;
  5.1550 +    const char* _errorStr1;
  5.1551 +    const char* _errorStr2;
  5.1552 +    char*       _charBuffer;
  5.1553 +
  5.1554 +    MemPoolT< sizeof(XMLElement) >	 _elementPool;
  5.1555 +    MemPoolT< sizeof(XMLAttribute) > _attributePool;
  5.1556 +    MemPoolT< sizeof(XMLText) >		 _textPool;
  5.1557 +    MemPoolT< sizeof(XMLComment) >	 _commentPool;
  5.1558 +};
  5.1559 +
  5.1560 +
  5.1561 +/**
  5.1562 +	A XMLHandle is a class that wraps a node pointer with null checks; this is
  5.1563 +	an incredibly useful thing. Note that XMLHandle is not part of the TinyXML
  5.1564 +	DOM structure. It is a separate utility class.
  5.1565 +
  5.1566 +	Take an example:
  5.1567 +	@verbatim
  5.1568 +	<Document>
  5.1569 +		<Element attributeA = "valueA">
  5.1570 +			<Child attributeB = "value1" />
  5.1571 +			<Child attributeB = "value2" />
  5.1572 +		</Element>
  5.1573 +	</Document>
  5.1574 +	@endverbatim
  5.1575 +
  5.1576 +	Assuming you want the value of "attributeB" in the 2nd "Child" element, it's very
  5.1577 +	easy to write a *lot* of code that looks like:
  5.1578 +
  5.1579 +	@verbatim
  5.1580 +	XMLElement* root = document.FirstChildElement( "Document" );
  5.1581 +	if ( root )
  5.1582 +	{
  5.1583 +		XMLElement* element = root->FirstChildElement( "Element" );
  5.1584 +		if ( element )
  5.1585 +		{
  5.1586 +			XMLElement* child = element->FirstChildElement( "Child" );
  5.1587 +			if ( child )
  5.1588 +			{
  5.1589 +				XMLElement* child2 = child->NextSiblingElement( "Child" );
  5.1590 +				if ( child2 )
  5.1591 +				{
  5.1592 +					// Finally do something useful.
  5.1593 +	@endverbatim
  5.1594 +
  5.1595 +	And that doesn't even cover "else" cases. XMLHandle addresses the verbosity
  5.1596 +	of such code. A XMLHandle checks for null pointers so it is perfectly safe
  5.1597 +	and correct to use:
  5.1598 +
  5.1599 +	@verbatim
  5.1600 +	XMLHandle docHandle( &document );
  5.1601 +	XMLElement* child2 = docHandle.FirstChild( "Document" ).FirstChild( "Element" ).FirstChild().NextSibling().ToElement();
  5.1602 +	if ( child2 )
  5.1603 +	{
  5.1604 +		// do something useful
  5.1605 +	@endverbatim
  5.1606 +
  5.1607 +	Which is MUCH more concise and useful.
  5.1608 +
  5.1609 +	It is also safe to copy handles - internally they are nothing more than node pointers.
  5.1610 +	@verbatim
  5.1611 +	XMLHandle handleCopy = handle;
  5.1612 +	@endverbatim
  5.1613 +
  5.1614 +	See also XMLConstHandle, which is the same as XMLHandle, but operates on const objects.
  5.1615 +*/
  5.1616 +class XMLHandle
  5.1617 +{
  5.1618 +public:
  5.1619 +    /// Create a handle from any node (at any depth of the tree.) This can be a null pointer.
  5.1620 +    XMLHandle( XMLNode* node )												{
  5.1621 +        _node = node;
  5.1622 +    }
  5.1623 +    /// Create a handle from a node.
  5.1624 +    XMLHandle( XMLNode& node )												{
  5.1625 +        _node = &node;
  5.1626 +    }
  5.1627 +    /// Copy constructor
  5.1628 +    XMLHandle( const XMLHandle& ref )										{
  5.1629 +        _node = ref._node;
  5.1630 +    }
  5.1631 +    /// Assignment
  5.1632 +    XMLHandle& operator=( const XMLHandle& ref )							{
  5.1633 +        _node = ref._node;
  5.1634 +        return *this;
  5.1635 +    }
  5.1636 +
  5.1637 +    /// Get the first child of this handle.
  5.1638 +    XMLHandle FirstChild() 													{
  5.1639 +        return XMLHandle( _node ? _node->FirstChild() : 0 );
  5.1640 +    }
  5.1641 +    /// Get the first child element of this handle.
  5.1642 +    XMLHandle FirstChildElement( const char* value=0 )						{
  5.1643 +        return XMLHandle( _node ? _node->FirstChildElement( value ) : 0 );
  5.1644 +    }
  5.1645 +    /// Get the last child of this handle.
  5.1646 +    XMLHandle LastChild()													{
  5.1647 +        return XMLHandle( _node ? _node->LastChild() : 0 );
  5.1648 +    }
  5.1649 +    /// Get the last child element of this handle.
  5.1650 +    XMLHandle LastChildElement( const char* _value=0 )						{
  5.1651 +        return XMLHandle( _node ? _node->LastChildElement( _value ) : 0 );
  5.1652 +    }
  5.1653 +    /// Get the previous sibling of this handle.
  5.1654 +    XMLHandle PreviousSibling()												{
  5.1655 +        return XMLHandle( _node ? _node->PreviousSibling() : 0 );
  5.1656 +    }
  5.1657 +    /// Get the previous sibling element of this handle.
  5.1658 +    XMLHandle PreviousSiblingElement( const char* _value=0 )				{
  5.1659 +        return XMLHandle( _node ? _node->PreviousSiblingElement( _value ) : 0 );
  5.1660 +    }
  5.1661 +    /// Get the next sibling of this handle.
  5.1662 +    XMLHandle NextSibling()													{
  5.1663 +        return XMLHandle( _node ? _node->NextSibling() : 0 );
  5.1664 +    }
  5.1665 +    /// Get the next sibling element of this handle.
  5.1666 +    XMLHandle NextSiblingElement( const char* _value=0 )					{
  5.1667 +        return XMLHandle( _node ? _node->NextSiblingElement( _value ) : 0 );
  5.1668 +    }
  5.1669 +
  5.1670 +    /// Safe cast to XMLNode. This can return null.
  5.1671 +    XMLNode* ToNode()							{
  5.1672 +        return _node;
  5.1673 +    }
  5.1674 +    /// Safe cast to XMLElement. This can return null.
  5.1675 +    XMLElement* ToElement() 					{
  5.1676 +        return ( ( _node && _node->ToElement() ) ? _node->ToElement() : 0 );
  5.1677 +    }
  5.1678 +    /// Safe cast to XMLText. This can return null.
  5.1679 +    XMLText* ToText() 							{
  5.1680 +        return ( ( _node && _node->ToText() ) ? _node->ToText() : 0 );
  5.1681 +    }
  5.1682 +    /// Safe cast to XMLUnknown. This can return null.
  5.1683 +    XMLUnknown* ToUnknown() 					{
  5.1684 +        return ( ( _node && _node->ToUnknown() ) ? _node->ToUnknown() : 0 );
  5.1685 +    }
  5.1686 +    /// Safe cast to XMLDeclaration. This can return null.
  5.1687 +    XMLDeclaration* ToDeclaration() 			{
  5.1688 +        return ( ( _node && _node->ToDeclaration() ) ? _node->ToDeclaration() : 0 );
  5.1689 +    }
  5.1690 +
  5.1691 +private:
  5.1692 +    XMLNode* _node;
  5.1693 +};
  5.1694 +
  5.1695 +
  5.1696 +/**
  5.1697 +	A variant of the XMLHandle class for working with const XMLNodes and Documents. It is the
  5.1698 +	same in all regards, except for the 'const' qualifiers. See XMLHandle for API.
  5.1699 +*/
  5.1700 +class XMLConstHandle
  5.1701 +{
  5.1702 +public:
  5.1703 +    XMLConstHandle( const XMLNode* node )											{
  5.1704 +        _node = node;
  5.1705 +    }
  5.1706 +    XMLConstHandle( const XMLNode& node )											{
  5.1707 +        _node = &node;
  5.1708 +    }
  5.1709 +    XMLConstHandle( const XMLConstHandle& ref )										{
  5.1710 +        _node = ref._node;
  5.1711 +    }
  5.1712 +
  5.1713 +    XMLConstHandle& operator=( const XMLConstHandle& ref )							{
  5.1714 +        _node = ref._node;
  5.1715 +        return *this;
  5.1716 +    }
  5.1717 +
  5.1718 +    const XMLConstHandle FirstChild() const											{
  5.1719 +        return XMLConstHandle( _node ? _node->FirstChild() : 0 );
  5.1720 +    }
  5.1721 +    const XMLConstHandle FirstChildElement( const char* value=0 ) const				{
  5.1722 +        return XMLConstHandle( _node ? _node->FirstChildElement( value ) : 0 );
  5.1723 +    }
  5.1724 +    const XMLConstHandle LastChild()	const										{
  5.1725 +        return XMLConstHandle( _node ? _node->LastChild() : 0 );
  5.1726 +    }
  5.1727 +    const XMLConstHandle LastChildElement( const char* _value=0 ) const				{
  5.1728 +        return XMLConstHandle( _node ? _node->LastChildElement( _value ) : 0 );
  5.1729 +    }
  5.1730 +    const XMLConstHandle PreviousSibling() const									{
  5.1731 +        return XMLConstHandle( _node ? _node->PreviousSibling() : 0 );
  5.1732 +    }
  5.1733 +    const XMLConstHandle PreviousSiblingElement( const char* _value=0 ) const		{
  5.1734 +        return XMLConstHandle( _node ? _node->PreviousSiblingElement( _value ) : 0 );
  5.1735 +    }
  5.1736 +    const XMLConstHandle NextSibling() const										{
  5.1737 +        return XMLConstHandle( _node ? _node->NextSibling() : 0 );
  5.1738 +    }
  5.1739 +    const XMLConstHandle NextSiblingElement( const char* _value=0 ) const			{
  5.1740 +        return XMLConstHandle( _node ? _node->NextSiblingElement( _value ) : 0 );
  5.1741 +    }
  5.1742 +
  5.1743 +
  5.1744 +    const XMLNode* ToNode() const				{
  5.1745 +        return _node;
  5.1746 +    }
  5.1747 +    const XMLElement* ToElement() const			{
  5.1748 +        return ( ( _node && _node->ToElement() ) ? _node->ToElement() : 0 );
  5.1749 +    }
  5.1750 +    const XMLText* ToText() const				{
  5.1751 +        return ( ( _node && _node->ToText() ) ? _node->ToText() : 0 );
  5.1752 +    }
  5.1753 +    const XMLUnknown* ToUnknown() const			{
  5.1754 +        return ( ( _node && _node->ToUnknown() ) ? _node->ToUnknown() : 0 );
  5.1755 +    }
  5.1756 +    const XMLDeclaration* ToDeclaration() const	{
  5.1757 +        return ( ( _node && _node->ToDeclaration() ) ? _node->ToDeclaration() : 0 );
  5.1758 +    }
  5.1759 +
  5.1760 +private:
  5.1761 +    const XMLNode* _node;
  5.1762 +};
  5.1763 +
  5.1764 +
  5.1765 +/**
  5.1766 +	Printing functionality. The XMLPrinter gives you more
  5.1767 +	options than the XMLDocument::Print() method.
  5.1768 +
  5.1769 +	It can:
  5.1770 +	-# Print to memory.
  5.1771 +	-# Print to a file you provide.
  5.1772 +	-# Print XML without a XMLDocument.
  5.1773 +
  5.1774 +	Print to Memory
  5.1775 +
  5.1776 +	@verbatim
  5.1777 +	XMLPrinter printer;
  5.1778 +	doc->Print( &printer );
  5.1779 +	SomeFunction( printer.CStr() );
  5.1780 +	@endverbatim
  5.1781 +
  5.1782 +	Print to a File
  5.1783 +
  5.1784 +	You provide the file pointer.
  5.1785 +	@verbatim
  5.1786 +	XMLPrinter printer( fp );
  5.1787 +	doc.Print( &printer );
  5.1788 +	@endverbatim
  5.1789 +
  5.1790 +	Print without a XMLDocument
  5.1791 +
  5.1792 +	When loading, an XML parser is very useful. However, sometimes
  5.1793 +	when saving, it just gets in the way. The code is often set up
  5.1794 +	for streaming, and constructing the DOM is just overhead.
  5.1795 +
  5.1796 +	The Printer supports the streaming case. The following code
  5.1797 +	prints out a trivially simple XML file without ever creating
  5.1798 +	an XML document.
  5.1799 +
  5.1800 +	@verbatim
  5.1801 +	XMLPrinter printer( fp );
  5.1802 +	printer.OpenElement( "foo" );
  5.1803 +	printer.PushAttribute( "foo", "bar" );
  5.1804 +	printer.CloseElement();
  5.1805 +	@endverbatim
  5.1806 +*/
  5.1807 +class XMLPrinter : public XMLVisitor
  5.1808 +{
  5.1809 +public:
  5.1810 +    /** Construct the printer. If the FILE* is specified,
  5.1811 +    	this will print to the FILE. Else it will print
  5.1812 +    	to memory, and the result is available in CStr().
  5.1813 +    	If 'compact' is set to true, then output is created
  5.1814 +    	with only required whitespace and newlines.
  5.1815 +    */
  5.1816 +    XMLPrinter( FILE* file=0, bool compact = false );
  5.1817 +    ~XMLPrinter()	{}
  5.1818 +
  5.1819 +    /** If streaming, write the BOM and declaration. */
  5.1820 +    void PushHeader( bool writeBOM, bool writeDeclaration );
  5.1821 +    /** If streaming, start writing an element.
  5.1822 +        The element must be closed with CloseElement()
  5.1823 +    */
  5.1824 +    void OpenElement( const char* name );
  5.1825 +    /// If streaming, add an attribute to an open element.
  5.1826 +    void PushAttribute( const char* name, const char* value );
  5.1827 +    void PushAttribute( const char* name, int value );
  5.1828 +    void PushAttribute( const char* name, unsigned value );
  5.1829 +    void PushAttribute( const char* name, bool value );
  5.1830 +    void PushAttribute( const char* name, double value );
  5.1831 +    /// If streaming, close the Element.
  5.1832 +    void CloseElement();
  5.1833 +
  5.1834 +    /// Add a text node.
  5.1835 +    void PushText( const char* text, bool cdata=false );
  5.1836 +    /// Add a text node from an integer.
  5.1837 +    void PushText( int value );
  5.1838 +    /// Add a text node from an unsigned.
  5.1839 +    void PushText( unsigned value );
  5.1840 +    /// Add a text node from a bool.
  5.1841 +    void PushText( bool value );
  5.1842 +    /// Add a text node from a float.
  5.1843 +    void PushText( float value );
  5.1844 +    /// Add a text node from a double.
  5.1845 +    void PushText( double value );
  5.1846 +
  5.1847 +    /// Add a comment
  5.1848 +    void PushComment( const char* comment );
  5.1849 +
  5.1850 +    void PushDeclaration( const char* value );
  5.1851 +    void PushUnknown( const char* value );
  5.1852 +
  5.1853 +    virtual bool VisitEnter( const XMLDocument& /*doc*/ );
  5.1854 +    virtual bool VisitExit( const XMLDocument& /*doc*/ )			{
  5.1855 +        return true;
  5.1856 +    }
  5.1857 +
  5.1858 +    virtual bool VisitEnter( const XMLElement& element, const XMLAttribute* attribute );
  5.1859 +    virtual bool VisitExit( const XMLElement& element );
  5.1860 +
  5.1861 +    virtual bool Visit( const XMLText& text );
  5.1862 +    virtual bool Visit( const XMLComment& comment );
  5.1863 +    virtual bool Visit( const XMLDeclaration& declaration );
  5.1864 +    virtual bool Visit( const XMLUnknown& unknown );
  5.1865 +
  5.1866 +    /**
  5.1867 +    	If in print to memory mode, return a pointer to
  5.1868 +    	the XML file in memory.
  5.1869 +    */
  5.1870 +    const char* CStr() const {
  5.1871 +        return _buffer.Mem();
  5.1872 +    }
  5.1873 +    /**
  5.1874 +    	If in print to memory mode, return the size
  5.1875 +    	of the XML file in memory. (Note the size returned
  5.1876 +    	includes the terminating null.)
  5.1877 +    */
  5.1878 +    int CStrSize() const {
  5.1879 +        return _buffer.Size();
  5.1880 +    }
  5.1881 +
  5.1882 +private:
  5.1883 +    void SealElement();
  5.1884 +    void PrintSpace( int depth );
  5.1885 +    void PrintString( const char*, bool restrictedEntitySet );	// prints out, after detecting entities.
  5.1886 +    void Print( const char* format, ... );
  5.1887 +
  5.1888 +    bool _elementJustOpened;
  5.1889 +    bool _firstElement;
  5.1890 +    FILE* _fp;
  5.1891 +    int _depth;
  5.1892 +    int _textDepth;
  5.1893 +    bool _processEntities;
  5.1894 +    bool _compactMode;
  5.1895 +
  5.1896 +    enum {
  5.1897 +        ENTITY_RANGE = 64,
  5.1898 +        BUF_SIZE = 200
  5.1899 +    };
  5.1900 +    bool _entityFlag[ENTITY_RANGE];
  5.1901 +    bool _restrictedEntityFlag[ENTITY_RANGE];
  5.1902 +
  5.1903 +    DynArray< const char*, 10 > _stack;
  5.1904 +    DynArray< char, 20 > _buffer;
  5.1905 +#ifdef _MSC_VER
  5.1906 +    DynArray< char, 20 > _accumulator;
  5.1907 +#endif
  5.1908 +};
  5.1909 +
  5.1910 +
  5.1911 +}	// tinyxml2
  5.1912 +
  5.1913 +
  5.1914 +#endif // TINYXML2_INCLUDED