Index: code/trunk/bin/levels/sp_level_moonstation.oxw
===================================================================
--- code/trunk/bin/levels/sp_level_moonstation.oxw	(revision 164)
+++ code/trunk/bin/levels/sp_level_moonstation.oxw	(revision 164)
@@ -0,0 +1,596 @@
+<WorldDataFile>
+	<name>Moon Station</name>
+	<description>The central moonstation, where the player will 'land'.</description>
+	<image>textures/menu/moonstation_512x512.jpg</image>
+
+	<LoadScreen>
+		<BackgroundImage>textures/load_screens/ambush.png</BackgroundImage>
+		<ElementCount>16</ElementCount>
+		<BackgroundPS>0,0,1.0,1</BackgroundPS>
+		<BarPS>.65,.87,.3,.05</BarPS>
+		<BarImage>textures/load_screens/ambush-loadbar.png</BarImage>
+	</LoadScreen>
+	
+	<clip-region>1, 100000</clip-region>
+	
+	<WorldEntities>
+
+
+
+	<ModelEntity>
+		<name>surface</name>
+		<abs-coor>-250, 100, -100</abs-coor>
+		<abs-dir>1.57, 0, 1, 0</abs-dir>
+		<model>models/decoration/moonsurface_1730.obj, 3000</model>
+	</ModelEntity>
+		
+	<Planet>
+		<name>Earth</name>
+		<texture>textures/planets/earth_no_clouds.jpg</texture>
+		<size>250</size>
+		<abs-coor>-1685.414917, 1228.985352, 1216.223511</abs-coor>
+		<abs-dir>3.1412, 0,0,1</abs-dir>
+	</Planet>
+
+	<BspEntity>
+		<Name>levels/maps/moonstation/moonstation.bsp</Name>
+	</BspEntity>
+	
+	<SkyBox>
+		<name>Sky</name>
+		<Materialset>textures/sky/simple_space</Materialset>
+		<Size>7520</Size>
+	</SkyBox>
+	
+	<FPSPlayer>
+		<name>Player</name>
+		<damageable>true</damageable>
+		<model>models/creatures/doom_male/male.md2, 9</model>
+		<loadShield>10,10,0,0</loadShield>
+		<abs-coor>630,21,-20</abs-coor>
+		<list>group01</list>
+		<!-- <abs-coor>208.740707, -781.369263, -268.533173</abs-coor> underground -->
+	</FPSPlayer>
+	
+<!-- Bridge ------------------------------------------------------------------------ -->
+
+	<AdmTurret>
+		<model>models/guns/turret/turret_body.obj,10</model>
+		<list>group00</list>
+		<type>ceil</type>
+		<damageable>true</damageable>
+		<target>Player</target>
+		<abs-coor>356, 588, -160</abs-coor>
+		<Cannons>
+			<model>models/guns/turret/turret_riffle.obj,10</model>
+			<rel-coor>0, 47, 0</rel-coor>
+		</Cannons>
+
+		<Sensor>
+			<model>models/guns/turret/turret_radar.obj,10</model>
+			<rel-coor>0, 32.5, 0</rel-coor>
+		</Sensor>
+		<Weapon>
+			<Range>400</Range>
+			<SetDamage>10</SetDamage>
+			<FireRate>1</FireRate>
+			<AlwaysHits>false</AlwaysHits>
+			<addPoint>-30,1,11</addPoint>
+			<addPoint>-30,1,-11</addPoint>
+		</Weapon>
+	</AdmTurret>
+
+	<Planet>
+		<name>Earth</name>
+		<texture>textures/planets/earth_no_clouds.jpg</texture>
+		<size>50</size>
+		<abs-coor>458.725555, 505.465271, -164.975540</abs-coor>
+		<abs-dir>3.1412, 0,0,1</abs-dir>
+		<planet-rotation-speed>-0.3</planet-rotation-speed>
+		<planet-rotation-axis>0,1,0</planet-rotation-axis>
+	</Planet>
+	
+	<Planet>
+		<name>Moon</name>
+		<texture>textures/planets/pluto.png</texture>
+		<size>10</size>
+		<abs-coor>543.408203, 505.465271, -158.724747</abs-coor>
+		<abs-dir>3.1412, 0,0,0</abs-dir>
+	</Planet>
+	
+	<Building>
+		<name>zhara</name>
+		<model>models/space_stations/ZHARA_Space_Station.obj, 1</model>
+		<mountpoints>models/space_stations/ZHARA_Space_Station.oif</mountpoints>
+		<abs-coor>500.981537, 507.057343, -179.489685</abs-coor>
+		<abs-dir>3.1412, 0,1,0</abs-dir>
+	</Building>
+
+<!-- Air cleaning/lager room ------------------------------------------------ -->
+	
+	<AdmTurret>
+		<model>models/guns/turret/turret_body.obj,10</model>
+		<list>group00</list>
+		<target>Player</target>
+		<abs-coor>-119, 123, 25</abs-coor>
+		<damageable>true</damageable>
+		<Cannons>
+			<model>models/guns/turret/turret_riffle.obj,10</model>
+			<rel-coor>0, 47, 0</rel-coor>
+		</Cannons>
+
+		<Sensor>
+			<model>models/guns/turret/turret_radar.obj,10</model>
+			<rel-coor>0, 32.5, 0</rel-coor>
+		</Sensor>
+		<Weapon>
+			<Range>40000</Range>
+			<SetDamage>10</SetDamage>
+			<FireRate>1</FireRate>
+			<AlwaysHits>false</AlwaysHits>
+			<addPoint>-30,1,11</addPoint>
+			<addPoint>-30,1,-11</addPoint>
+		</Weapon>
+	</AdmTurret>
+	
+	<Mover>
+		<name>door_aircleaning</name>
+		<bReopen>1</bReopen>
+		<bReclose>1</bReclose>
+		<model>models/doors/door_small_b.obj, 6.7</model><!-- modelpath, size -->
+		<abs-dir>3.141, 0, 1, 0</abs-dir><!-- Pi,,Y-Axis-Rotation, -->
+		<abs-coor>120, 160, 320</abs-coor>
+		<triggers>
+			<ApproachTrigger>
+				<radius>50</radius>
+			</ApproachTrigger>
+		</triggers>
+		<stations>
+			<MoverStation>
+				<moving-time>0.6</moving-time>
+				<rel-target-coor>0, 0, -45</rel-target-coor>
+				<opening-sound>sounds/doors/door_opening2.wav</opening-sound>
+				<closing-sound>sounds/doors/door_opening2.wav</closing-sound>
+			</MoverStation>
+		</stations>
+	</Mover>
+		
+	<Mover>
+		<name>door_lager</name>
+		<bReopen>1</bReopen>
+		<bReclose>1</bReclose>
+		<model>models/doors/door_blue_big.obj, 19</model><!-- modelpath, size -->
+		<abs-dir>1.57, 0, 1, 0</abs-dir><!-- Pi,,Y-Axis-Rotation, -->
+		<abs-coor>-65, 128, -161.1</abs-coor>
+		<triggers>
+			<ApproachTrigger>
+				<radius>130</radius>
+			</ApproachTrigger>
+		</triggers>
+		<stations>
+			<MoverStation>
+				<moving-time>1.2</moving-time>
+				<rel-target-coor>0, 92.5, 0</rel-target-coor>
+				<opening-sound>sounds/doors/door_opening2.wav</opening-sound>
+				<closing-sound>sounds/doors/door_opening2.wav</closing-sound>
+				<closed-sound>sounds/doors/door_closed2.wav</closed-sound>
+			</MoverStation>
+		</stations>
+	</Mover>		
+		
+	<Rotor>
+		<name>rotor_aircleaning</name>
+		<model>models/decoration/rotor1_hack.obj, 5</model>
+		<abs-coor>52,167,241</abs-coor>
+		<abs-dir>0, 0, 0, 0</abs-dir>
+		<rotation>8,0,0</rotation>
+	</Rotor>
+	<Rotor>
+		<name>rotor_aircleaning</name>
+		<model>models/decoration/rotor1_hack.obj, 5</model>
+		<abs-coor>28,167,241</abs-coor>
+		<abs-dir>0, 0, 0, 0</abs-dir>
+		<rotation>8,0,0</rotation>
+	</Rotor>
+	<Rotor>
+		<name>rotor_aircleaning</name>
+		<model>models/decoration/rotor1_hack.obj, 5</model>
+		<abs-coor>4,167,241</abs-coor>
+		<abs-dir>0, 0, 0, 0</abs-dir>
+		<rotation>8,0,0</rotation>
+	</Rotor>
+	<Rotor>
+		<name>rotor_aircleaning</name>
+		<model>models/decoration/rotor1_hack.obj, 5</model>
+		<abs-coor>-20,167,241</abs-coor>
+		<abs-dir>0, 0, 0, 0</abs-dir>
+		<rotation>8,0,0</rotation>
+	</Rotor>
+		
+<!-- Main hall ------------------------------------------------------------ -->
+	<AdmTurret>
+		<model>models/guns/turret/turret_body.obj,10</model>
+		<list>group00</list>
+		<type>ceil</type>
+		<damageable>true</damageable>
+		<target>Player</target>
+		<abs-coor>191, 115, 70</abs-coor>
+		<Cannons>
+			<model>models/guns/turret/turret_riffle.obj,10</model>
+			<rel-coor>0, 47, 0</rel-coor>
+		</Cannons>
+
+		<Sensor>
+			<model>models/guns/turret/turret_radar.obj,10</model>
+			<rel-coor>0, 32.5, 0</rel-coor>
+		</Sensor>
+		<Weapon>
+			<Range>400</Range>
+			<SetDamage>10</SetDamage>
+			<FireRate>1</FireRate>
+			<AlwaysHits>false</AlwaysHits>
+			<addPoint>-30,1,11</addPoint>
+			<addPoint>-30,1,-11</addPoint>
+		</Weapon>
+	</AdmTurret>
+	
+	<SpriteParticles>
+		<name>str3</name>
+		<type>sprite</type>
+		<texture>steam01.png</texture>
+		<max-count>50</max-count>
+		<life-span>4, 6</life-span>
+		<radius>0.0, 15.0, 20.0</radius>
+		<radius>0.2, 20.0, 25.0</radius>
+		<radius>1.0, 25.0, 30.0</radius>
+		<mass>1.0, 0.3, .2</mass>
+		<color>0,1, 1, 1,.5</color>
+		<color>.5, .6, .6, .6, .2</color>
+		<color>1, .0, .0, .0, .0</color>
+		<precache>5</precache>
+		<emitters>
+			<PlaneEmitter>
+				<name>SteamEmitter</name>
+				<rel-coor>-4.005549, 251.321747, -11.710030</rel-coor>
+				<rel-dir>0.927172, -0.003523, -0.374517, 0.008722</rel-dir>
+				<spread>0.0, 1</spread>
+				<emission-velocity>20, 30</emission-velocity>
+				<size>8, 15</size>
+				<rate>7</rate>
+			</PlaneEmitter>
+		</emitters>
+	</SpriteParticles>
+		
+	<SpriteParticles>
+		<name>Big one hall</name>
+		<type>sprite</type>
+		<texture>steam01.png</texture>
+		<max-count>50</max-count>
+		<life-span>10, 2</life-span>
+		<radius>0.0, 100, 100</radius>
+		<radius>0.2, 100, 100</radius>
+		<radius>1.0, 100, 100</radius>
+		<mass>1.0, 0.5, .3</mass>
+		<color>0,1, 1, 1,.5</color>
+		<color>.5, .6, .6, .6, .2</color>
+		<color>1, .0, .0, .0, .0</color>
+		<precache>5</precache>
+		<emitters>
+			<PlaneEmitter>
+				<name>SteamEmitter</name>
+				<rel-coor>93.780792, -35.366524, 18.198116</rel-coor>
+				<rel-dir>3.1412, 0, 0, 1</rel-dir>
+				<spread>0, 1.0</spread>
+				<emission-velocity>-50,50</emission-velocity>
+				<size>100, 110</size>
+				<rate>2</rate>
+			</PlaneEmitter>
+		</emitters>
+	</SpriteParticles>
+	
+<!-- Destroyed room ------------------------------------------------------- -->
+	<ModelEntity>
+		<name>destroyed fighter</name>
+		<abs-coor>540, 30, -100</abs-coor><!--Orx: koo Y,Z,X -->
+		<abs-dir>2.3, 0.9, -2.5, -0.5</abs-dir>
+		<model>models/spaceships/human_spaceship_fighter.obj, 8.5</model>
+	</ModelEntity>
+		
+	<SpriteParticles>
+		<name>str1</name>
+		<type>sprite</type>
+		<texture>steam01.png</texture>
+		<max-count>50</max-count>
+		<life-span>4, 6</life-span>
+		<radius>0.0, 15.0, 20.0</radius>
+		<radius>0.2, 20.0, 25.0</radius>
+		<radius>1.0, 25.0, 30.0</radius>
+		<mass>1.0, 0.3, .2</mass>
+		<color>0,1, 1, 1,.5</color>
+		<color>.5, .6, .6, .6, .2</color>
+		<color>1, .0, .0, .0, .0</color>
+		<precache>5</precache>
+		<emitters>
+			<PlaneEmitter>
+				<name>SteamEmitter</name>
+				<rel-coor>727, 93, -111</rel-coor>
+				<rel-dir>3.1412, 0, 0, 1</rel-dir>
+				<spread>0.0, 1</spread>
+				<emission-velocity>10, 30</emission-velocity>
+				<size>8, 15</size>
+				<rate>7</rate>
+			</PlaneEmitter>
+		</emitters>
+	</SpriteParticles>
+		
+	<SpriteParticles>
+		<name>str2</name>
+		<type>sprite</type>
+		<texture>steam01.png</texture>
+		<max-count>50</max-count>
+		<life-span>4, 6</life-span>
+		<radius>0.0, 15.0, 20.0</radius>
+		<radius>0.2, 20.0, 25.0</radius>
+		<radius>1.0, 25.0, 30.0</radius>
+		<mass>1.0, 0.3, .2</mass>
+		<color>0,1, 1, 1,.5</color>
+		<color>.5, .6, .6, .6, .2</color>
+		<color>1, .0, .0, .0, .0</color>
+		<precache>5</precache>
+		<emitters>
+			<PlaneEmitter>
+				<name>SteamEmitter</name>
+				<rel-coor>772, 160, -87.5</rel-coor>
+				<rel-dir>3.1412, 0, 0, 1</rel-dir>
+				<spread>0.0, 1</spread>
+				<emission-velocity>10, 30</emission-velocity>
+				<size>8, 15</size>
+				<rate>7</rate>
+			</PlaneEmitter>
+		</emitters>
+	</SpriteParticles>
+		
+	<SpriteParticles>
+		<name>Big one</name>
+		<type>sprite</type>
+		<texture>steam01.png</texture>
+		<max-count>50</max-count>
+		<life-span>10, 2</life-span>
+		<radius>0.0, 100, 100</radius>
+		<radius>0.2, 100, 100</radius>
+		<radius>1.0, 100, 100</radius>
+		<mass>1.0, 0.5, .3</mass>
+		<color>0,1, 1, 1,.5</color>
+		<color>.5, .6, .6, .6, .2</color>
+		<color>1, .0, .0, .0, .0</color>
+		<precache>5</precache>
+		<emitters>
+			<PlaneEmitter>
+				<name>SteamEmitter</name>
+				<rel-coor>616, -50, -196</rel-coor>
+				<rel-dir>3.1412, 0, 0, 1</rel-dir>
+				<spread>0, 1.0</spread>
+				<emission-velocity>-50,50</emission-velocity>
+				<size>120, 150</size>
+				<rate>6</rate>
+			</PlaneEmitter>
+		</emitters>
+	</SpriteParticles>
+
+<!-- sleeping room ------------------------------------------------------ -->
+	
+	<Mover>
+		<name>door_sleepingroom_l</name>
+		<bReopen>1</bReopen>
+		<bReclose>1</bReclose>
+		<model>models/doors/door_small_b.obj, 6.2</model><!-- modelpath, size -->
+		<abs-dir>1.57, 0, 1, 0</abs-dir><!-- Pi,,Y-Axis-Rotation, -->
+		<abs-coor>405.5, 160, 175</abs-coor>
+		<triggers>
+			<ApproachTrigger>
+				<radius>50</radius>
+			</ApproachTrigger>
+		</triggers>
+		<stations>
+			<MoverStation>
+				<moving-time>0.6</moving-time>
+				<rel-target-coor>31, 0, 0</rel-target-coor>
+				<opening-sound>sounds/doors/door_opening2.wav</opening-sound>
+				<closing-sound>sounds/doors/door_opening2.wav</closing-sound>
+				<!--<closed-sound>sounds/doors/door_closed2.wav</closed-sound>-->
+			</MoverStation>
+		</stations>
+	</Mover>
+	<Mover>
+		<name>door_sleepingroom_r</name>
+		<bReopen>1</bReopen>
+		<bReclose>1</bReclose>
+		<model>models/doors/door_small_b.obj, 6.2</model><!-- modelpath, size -->
+		<abs-dir>1.57, 0, -1, 0</abs-dir><!-- Pi,,Y-Axis-Rotation, -->
+		<abs-coor>362, 160, 175</abs-coor>
+		<triggers>
+			<ApproachTrigger>
+				<radius>50</radius>
+			</ApproachTrigger>
+		</triggers>
+		<stations>
+			<MoverStation>
+				<moving-time>0.6</moving-time>
+				<rel-target-coor>-31, 0, 0</rel-target-coor>
+			</MoverStation>
+		</stations>
+	</Mover>
+	
+	<SpriteParticles>
+		<name>Steam in sleeping room</name>
+		<type>sprite</type>
+		<texture>steam01.png</texture>
+		<max-count>50</max-count>
+		<life-span>2, 5</life-span>
+		<radius>0.0, 15.0, 20.0</radius>
+		<radius>0.2, 20.0, 25.0</radius>
+		<radius>1.0, 25.0, 30.0</radius>
+		<mass>1.0, 0.3, .2</mass>
+		<color>0,1, 1, 1,.5</color>
+		<color>.5, .6, .6, .6, .2</color>
+		<color>1, .0, .0, .0, .0</color>
+		<precache>5</precache>
+		<emitters>
+			<PlaneEmitter>
+				<name>SteamEmitter</name>
+				<rel-coor>382, 210, 255</rel-coor>
+				<rel-dir>3.1412, 0, 0, 1</rel-dir>
+				<spread>0.0, 1</spread>
+				<emission-velocity>10, 30</emission-velocity>
+				<size>8, 15</size>
+				<rate>7</rate>
+			</PlaneEmitter>
+		</emitters>
+	</SpriteParticles>
+
+	<SpriteParticles>
+		<name>Stream Air Cleaning</name>
+		<type>sprite</type>
+		<texture>steam01.png</texture>
+		<max-count>50</max-count>
+		<life-span>10, 0</life-span>
+		<radius>0.0, 15.0, 2</radius>
+		<radius>0.2, 20.0, 5</radius>
+		<radius>1.0, 25.0, 7</radius>
+		<mass>1.0, 0.3, .2</mass>
+		<color>0,0, 1, 0,.5</color>
+		<color>.5, 0, .6, 0, .2</color>
+		<color>1, .0, .0, .0, .0</color>
+		<precache>0</precache>
+		<emitters>
+			<PlaneEmitter>
+				<name>SteamEmitter</name>
+				<rel-coor>85, 168, 243</rel-coor>
+				<rel-dir>1.57, 0, 0, 1</rel-dir>
+				<spread>0.0, 0</spread>
+				<emission-velocity>20, 2</emission-velocity>
+				<size>10, 14</size>
+				<rate>7</rate>
+			</PlaneEmitter>
+		</emitters>
+		</SpriteParticles>
+
+<!-- Underground      ######################################################################## -->
+	<Mover>
+		<name>door_elevator</name>
+		<bReopen>1</bReopen>
+		<bReclose>1</bReclose>
+		<model>models/doors/door_small_b.obj, 10</model><!-- modelpath, size -->
+		<abs-dir>1.57, 0, 1, 0</abs-dir><!-- Pi,,Y-Axis-Rotation, -->
+		<abs-coor>210, -810, -454</abs-coor>
+		<triggers>
+			<ApproachTrigger>
+				<radius>50</radius>
+			</ApproachTrigger>
+		</triggers>
+		<stations>
+			<MoverStation>
+				<moving-time>0.6</moving-time>
+				<rel-target-coor>60, 0, 0</rel-target-coor>
+				<opening-sound>sounds/doors/door_opening2.wav</opening-sound>
+				<closing-sound>sounds/doors/door_opening2.wav</closing-sound>
+				<!--<closed-sound>sounds/doors/door_closed2.wav</closed-sound>-->
+			</MoverStation>
+		</stations>
+	</Mover>
+		
+<!-- Cutscenes/Quests ######################################################################## -->
+
+	<NPC>
+		<name>IntroSpaceship</name>
+		<model>models/spaceships/human_spaceship_fighter.obj,9</model>
+		<mountpoints>models/spaceships/human_spaceship_fighter.oif</mountpoints>
+		<Track>
+			<mode>1</mode>
+			<speed>600</speed>
+			<addPoint>4000, 866, -284</addPoint>
+			<addPoint>1840, 866, -284</addPoint>
+			<addPoint>1302, 524, -217</addPoint>
+			<addPoint>760, 127, -137</addPoint>
+			<addPoint>-25, -360, -99</addPoint>
+			<addPoint>-100, -400, -110</addPoint><!-- hide position -->
+			<addPoint>-120, -410, -113</addPoint>
+		</Track>
+	</NPC>
+	
+	<NPC> <!-- triggerable door hack -->
+		<name>triggeredDoor</name>
+		<model>models/doors/door_blue_big.obj, 19</model><!-- modelpath, size -->
+		<abs-coor>222, 0, -472</abs-coor>
+		<abs-dir>0, 0, 1, 0</abs-dir>
+	</NPC> 
+	
+	<Building> <!-- Camera target hack -->
+		<name>MoonstationCenterHack</name>
+		<model>models/spaceships/human_spaceship_fighter.obj,0.1</model>
+		<abs-coor>300, 36, -170</abs-coor>
+		<abs-dir>3.1412, 0,1,0</abs-dir>
+	</Building>
+	 
+	<QuestGUI>
+		<name>energyQuest</name>
+		<quest-name>Hangar Door</quest-name>
+		<quest-description>QUEST: Open the door to the hangar.</quest-description>
+		<quest-picture>/textures/orxonox_logo.png</quest-picture>
+		<quest-difficulty>STORY: I have to leave this station. </quest-difficulty>
+		<quest-persons>Maybe I can find a ship in the hangar behind this door.</quest-persons>
+		<reward-picture>/textures/amiv_braeu.png</reward-picture>
+		<reward-description>HINT: Maybe it would be favourably to take a	look at the bridge on top of the station.</reward-description>
+	</QuestGUI>
+	
+	<BspEntity>
+		<Name>levels/maps/moonstation/moonstation_flares.bsp</Name>
+		<Transparency>1, 1</Transparency>
+	</BspEntity>
+
+</WorldEntities> <!-- End WoldEntities ##################################################### -->
+
+<ScriptManager> 
+	<Scripts>
+		<Script file="moonstation/intro.lua" />
+		<Script file="moonstation/quest.lua" />
+		<Script file="moonstation/switchLevel.lua" />
+	</Scripts>
+</ScriptManager>
+
+<CameraMan name="cameraManager">
+	<Cameras>
+		<Camera name="CameraIntro">
+			<Track>
+				<mode>1</mode>
+				<speed>80</speed>
+				<addPoint>-1295.883301, 621.807922, -969.386780</addPoint>
+				<addPoint>-1253.895386, 727.938721, -268.726807</addPoint><!-- cam2 station -->
+				<addPoint>-1092.265991, 743.441040, -15.836866</addPoint>
+				<addPoint>-438.112305, 661.747009, 566.756775</addPoint>
+				<addPoint>180.627167, 755.514709, 871.833801</addPoint><!-- cam2 ship 199.251480, 611.205872, 670.132324 -->
+				<addPoint>871.084534, 629.498901, 619.159058</addPoint>
+				<!-- <addPoint>1409.606201, 668.009155, 122.551933</addPoint>
+				<addPoint>1331.963867, 562.559082, -213.602997</addPoint> -->
+				<addPoint>1160.229858, 248.129639, -396.398438</addPoint>
+				<addPoint>1210.095825, 308.348694, -414.233826</addPoint>
+				<addPoint>881.456055, 184.982635, -176.643326</addPoint>
+				<addPoint>719.431091, 79.719810, -149.023880</addPoint><!-- intro end -->
+			</Track>
+		</Camera>
+		<Camera name="CameraDoor" abs-coor="346, 128, -110">
+		</Camera>
+	</Cameras>
+</CameraMan>
+
+<LightManager>
+		<Lights>
+			<Light diffuse-color="0.5,0.5,0.6" abs-coor="205,565,-162" />
+			<Light diffuse-color="0.5,0.5,0.6" abs-coor="-990.843811, 896.596130, -1569.420288" />
+			<Light diffuse-color="0.8,0.8,0.8" abs-coor="203.364914, -807.093872, -228.443466" />
+		</Lights>
+		<ambient color="1, 1, 1" />
+</LightManager>
+
+</WorldDataFile>
+
Index: code/trunk/src/CMakeLists.txt
===================================================================
--- code/trunk/src/CMakeLists.txt	(revision 151)
+++ code/trunk/src/CMakeLists.txt	(revision 164)
@@ -2,6 +2,7 @@
 
 # create a few variables to simplify life
-SET(SRC_FILES orxonox.cc)
-#SET(INC_FILES ExampleApplication.h  ExampleFrameListener.h)
+
+SET(SRC_FILES orxonox.cc loader/LevelLoader.cc xml/xmlParser.cc)
+SET(INC_FILES loader/LevelLoader.h xml/xmlParser.h)
 
 #Creates an executable
Index: code/trunk/src/loader/LevelLoader.cc
===================================================================
--- code/trunk/src/loader/LevelLoader.cc	(revision 164)
+++ code/trunk/src/loader/LevelLoader.cc	(revision 164)
@@ -0,0 +1,133 @@
+#include <string.h>
+#include <iostream>
+
+#include "LevelLoader.h"
+#include "../xml/xmlParser.h"
+
+using namespace std;
+
+namespace loader
+{
+
+LevelLoader::LevelLoader(string file, string dir)
+{
+	// Load XML level file
+	dir.append("/");
+	dir.append(file);	
+  	rootNode = XMLNode::openFileHelper(dir.c_str(),"WorldDataFile");
+  	// TODO: Error handling
+
+	// Assing general level infos to class variables
+  	this->name_ = rootNode.getChildNode("name").getText();
+  	this->description_ = rootNode.getChildNode("description").getText();
+  	this->image_ = rootNode.getChildNode("image").getText();
+  
+  	this->loadingScreen();
+  
+  // Assign sub-nodes
+  if (rootNode.nChildNode("LightManager")==1)
+  {
+  	// Init Luightmanager...
+  }
+  
+  /*
+  
+	worldNode = rootNode.getChildNode("WorldEntities");
+	scriptNode = rootNode.getChildNode("ScriptManager");
+	cameraNode = rootNode.getChildNode("CameraMan");
+	lightNode = rootNode.getChildNode("LightManager");
+*/
+
+}
+
+LevelLoader::~LevelLoader()
+{
+
+
+}
+
+
+string LevelLoader::name()
+{
+	return this->name_;
+}
+
+string LevelLoader::description()
+{
+	return this->description_;
+}
+
+string LevelLoader::image()
+{
+	return this->image_;
+}
+
+void LevelLoader::loadingScreen()
+{
+	cout << "\n\n\nThis is Orxonox\nthe hottest 3D action shooter ever to exist\n\n\n";
+	cout << "Level: " << name() << "\nDescription:" << description() << "\nImage:"<<image()<<"\n\n\n";
+}
+
+/*
+
+
+void LevelLoader::loadWorld(WorldManager* wm)
+{
+	if (!worldNode.getChildNode("lights").isEmpty())
+	{
+		
+		
+	}
+}
+
+
+void LevelLoader::loadLights(LightManager* lm)
+{
+	if (!lightNode.getChildNode("lights").isEmpty())
+	{
+		int nLights = lightNode.getChildNode("lights").nChildNode("light");
+		for (int i=0; i<nLights;i++)
+		{
+			XMLNode t = lightNode.getChildNode("lights").getChildNode("light",i);
+			const char* diffuse = t.getAttribute("diffuse-color");
+			const char* coor = t.getAttribute("abs-coor");
+			lm->addLight(diffuse,coor);	
+		}
+	}
+	lm->setAmbient(lightNode.getChildNode("ambient").getAttribute("color"));	
+}
+
+void LevelLoader::loadCameras(CameraManager* cm)
+{
+	if (!cameraNode.getChildNode("cameras").isEmpty())
+	{
+		int nCameras = cameraNode.getChildNode("cameras").nChildNode("camera");
+		for (int i=0; i<nCameras;i++)
+		{
+			XMLNode t = cameraNode.getChildNode("cameras").getChildNode("camera",i);
+			
+			
+			cm->addCamera();
+		}
+	}
+}
+
+
+void LevelLoader::loadScripts(ScriptManager* sm)
+{
+	if (!scriptNode.getChildNode("scripts").isEmpty())
+	{
+		int nScripts = scriptNode.getChildNode("scripts").nChildNode("script");
+		for (int i=0; i<nScripts;i++)
+		{
+			XMLNode t = scriptNode.getChildNode("scripts").getChildNode("script",i);
+			sm->addScript(t.getAttribute("file"));
+		}
+	
+	}
+}
+*/
+
+
+}
+
Index: code/trunk/src/loader/LevelLoader.h
===================================================================
--- code/trunk/src/loader/LevelLoader.h	(revision 164)
+++ code/trunk/src/loader/LevelLoader.h	(revision 164)
@@ -0,0 +1,54 @@
+/**
+* Orxonox - www.orxonox.net
+* Level Loader class
+* 
+* @author Nicolas Perrenoud <nicolape@ee.ethz.ch>
+*/
+
+#include <string>
+#include <iostream>
+
+#include "../xml/xmlParser.h"
+
+#ifndef __MODULE_LEVELLOADER__
+#define __MODULE_LEVELLOADER__
+
+using namespace std;
+
+namespace loader
+{
+	class LevelLoader
+	{
+	private:
+		
+		// XML Nodes 
+		XMLNode rootNode;  
+		XMLNode worldNode;
+		XMLNode scriptNode;
+		XMLNode cameraNode;
+		XMLNode lightNode;
+		
+		// Level information
+		string name_;
+		string description_;
+		string image_;
+			
+	public:
+
+		// Constructors
+		LevelLoader(string file, string dir="levels");
+		~LevelLoader();
+		
+		void loadingScreen();
+		
+		// Getters
+		string name();
+		string description();
+		string image();		
+		
+		// Managers 
+		
+			
+	};	
+}
+#endif
Index: code/trunk/src/loader/Light.cc
===================================================================
--- code/trunk/src/loader/Light.cc	(revision 164)
+++ code/trunk/src/loader/Light.cc	(revision 164)
@@ -0,0 +1,23 @@
+
+#include "../xml/xmlParser.h"
+#include "Light.h"
+
+namespace light
+{								
+	Light::Light()
+	{		
+		
+	}
+	
+	Light::Light(XMLNode xml)
+	{
+		this->loadParams(xml);	
+	}
+	
+	void Light::loadParams(XMLNode xml)
+	{
+		// Here comes the tricky part... convert strings to int
+		const char* diffuse = xml.getAttribute("diffuse-color");
+		const char* coor = xml.getAttribute("abs-coor");
+	}
+}
Index: code/trunk/src/loader/Light.h
===================================================================
--- code/trunk/src/loader/Light.h	(revision 164)
+++ code/trunk/src/loader/Light.h	(revision 164)
@@ -0,0 +1,28 @@
+
+#include "../xml/xmlParser.h"
+
+#ifndef __MODULE_LIGHT__
+#define __MODULE_LIGHT__
+
+namespace light
+{
+	class Light()
+	{
+	public:      
+		Light();
+		Light(XMLNode xml);
+		~Light();
+		void loadParams(XMLNode xml);
+	
+	private:
+		float diffuseColor_r_;
+		float diffuseColor_g_;
+		float diffuseColor_b_;
+
+		int coord_x_;
+		int coord_y_;
+		int coord_z_;
+	};
+}
+
+#endif
Index: code/trunk/src/loader/LightManager.cc
===================================================================
--- code/trunk/src/loader/LightManager.cc	(revision 164)
+++ code/trunk/src/loader/LightManager.cc	(revision 164)
@@ -0,0 +1,28 @@
+
+#include "../xml/xmlParser.h"
+#include "LightManager.h"
+
+namespace light
+{
+	LightManager::LightManager()
+	{
+		vector<Light> this->elements_ = new vector<Light>;
+	}
+	
+	void LightManager::loadParams(XMLNode xml)
+	{
+		if (!xml.isEmpty())
+		{
+			int nLights = xml.nChildNode("light");
+			for (int i=0; i<nLights;i++)
+			{
+				Light l = new Light(xml.getChildNode("light",i));
+				this->elements_.append(l);
+			}
+		}		
+		
+	}	
+		
+	
+}
+
Index: code/trunk/src/loader/LightManager.h
===================================================================
--- code/trunk/src/loader/LightManager.h	(revision 164)
+++ code/trunk/src/loader/LightManager.h	(revision 164)
@@ -0,0 +1,26 @@
+#include <vector>
+
+#include "../xml/xmlParser.h"
+#include "Light.h"
+
+#ifndef __MODULE_LIGHTMANAGER__
+#define __MODULE_LIGHTMANAGER__
+
+namespace light
+{
+	class LightManager()
+	{      
+	public:
+		LightManager();
+		~LightManager();
+		void loadParams(XMLNode xml);		
+				
+	private:
+		float ambient_r_;
+		float ambient_g_;
+		float ambient_b_;
+		vector<Light> elements_;
+	};
+}
+
+#endif
Index: code/trunk/src/orxonox.cc
===================================================================
--- code/trunk/src/orxonox.cc	(revision 151)
+++ code/trunk/src/orxonox.cc	(revision 164)
@@ -35,4 +35,11 @@
 #include <CEGUI/CEGUI.h>
 #include <OgreCEGUIRenderer.h>
+
+#include <string>
+#include <iostream>
+
+#include "xml/xmlParser.h"
+#include "loader/LevelLoader.h"
+
 
 // some tests to see if enet works without includsion
@@ -97,4 +104,5 @@
       createRenderWindow();
       initializeResourceGroups();
+      createScene();
       setupScene();
       setupInputSystem();
@@ -180,4 +188,11 @@
     }
 
+    void createScene(void)
+    {
+
+      string levelFile = "sp_level_moonstation.oxw";
+      loader::LevelLoader* loader = new loader::LevelLoader(levelFile);
+    }
+    
     void setupScene()
     {
Index: code/trunk/src/xml/xmlParser.cc
===================================================================
--- code/trunk/src/xml/xmlParser.cc	(revision 164)
+++ code/trunk/src/xml/xmlParser.cc	(revision 164)
@@ -0,0 +1,2721 @@
+/**
+ ****************************************************************************
+ * <P> XML.c - implementation file for basic XML parser written in ANSI C++
+ * for portability. It works by using recursion and a node tree for breaking
+ * down the elements of an XML document.  </P>
+ *
+ * @version     V2.33
+ * @author      Frank Vanden Berghen
+ *
+ * NOTE:
+ *
+ *   If you add "#define STRICT_PARSING", on the first line of this file
+ *   the parser will see the following XML-stream:
+ *      <a><b>some text</b><b>other text    </a>
+ *   as an error. Otherwise, this tring will be equivalent to:
+ *      <a><b>some text</b><b>other text</b></a>
+ *
+ * NOTE:
+ *
+ *   If you add "#define APPROXIMATE_PARSING" on the first line of this file
+ *   the parser will see the following XML-stream:
+ *     <data name="n1">
+ *     <data name="n2">
+ *     <data name="n3" />
+ *   as equivalent to the following XML-stream:
+ *     <data name="n1" />
+ *     <data name="n2" />
+ *     <data name="n3" />
+ *   This can be useful for badly-formed XML-streams but prevent the use
+ *   of the following XML-stream (problem is: tags at contiguous levels
+ *   have the same names):
+ *     <data name="n1">
+ *        <data name="n2">
+ *            <data name="n3" />
+ *        </data>
+ *     </data>
+ *
+ * NOTE:
+ *
+ *   If you add "#define _XMLPARSER_NO_MESSAGEBOX_" on the first line of this file
+ *   the "openFileHelper" function will always display error messages inside the
+ *   console instead of inside a message-box-window. Message-box-windows are
+ *   available on windows 9x/NT/2000/XP/Vista only.
+ *
+ * BSD license:
+ * Copyright (c) 2002, Frank Vanden Berghen
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the Frank Vanden Berghen nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ ****************************************************************************
+ */
+#ifndef _CRT_SECURE_NO_DEPRECATE
+#define _CRT_SECURE_NO_DEPRECATE
+#endif
+#include "xmlParser.h"
+#ifdef _XMLWINDOWS
+//#ifdef _DEBUG
+//#define _CRTDBG_MAP_ALLOC
+//#include <crtdbg.h>
+//#endif
+#define WIN32_LEAN_AND_MEAN
+#include <Windows.h> // to have IsTextUnicode, MultiByteToWideChar, WideCharToMultiByte to handle unicode files
+                     // to have "MessageBoxA" to display error messages for openFilHelper
+#endif
+
+#include <memory.h>
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+XMLCSTR XMLNode::getVersion() { return _X("v2.30"); }
+void freeXMLString(XMLSTR t){free(t);}
+
+static XMLNode::XMLCharEncoding characterEncoding=XMLNode::encoding_UTF8;
+static char guessWideCharChars=1, dropWhiteSpace=1;
+
+inline int mmin( const int t1, const int t2 ) { return t1 < t2 ? t1 : t2; }
+
+// You can modify the initialization of the variable "XMLClearTags" below
+// to change the clearTags that are currently recognized by the library.
+// The number on the second columns is the length of the string inside the
+// first column. The "<!DOCTYPE" declaration must be the second in the list.
+typedef struct { XMLCSTR lpszOpen; int openTagLen; XMLCSTR lpszClose;} ALLXMLClearTag;
+static ALLXMLClearTag XMLClearTags[] =
+{
+    {    _X("<![CDATA["),9,  _X("]]>")      },
+    {    _X("<!DOCTYPE"),9,  _X(">")        },
+    {    _X("<PRE>")    ,5,  _X("</PRE>")   },
+    {    _X("<Script>") ,8,  _X("</Script>")},
+    {    _X("<!--")     ,4,  _X("-->")      },
+    {    NULL           ,0,  NULL           }
+};
+
+// You can modify the initialization of the variable "XMLEntities" below
+// to change the character entities that are currently recognized by the library.
+// The number on the second columns is the length of the string inside the
+// first column. Additionally, the syntaxes "&#xA0;" and "&#160;" are recognized.
+typedef struct { XMLCSTR s; int l; XMLCHAR c;} XMLCharacterEntity;
+static XMLCharacterEntity XMLEntities[] =
+{
+    { _X("&amp;" ), 5, _X('&' )},
+    { _X("&lt;"  ), 4, _X('<' )},
+    { _X("&gt;"  ), 4, _X('>' )},
+    { _X("&quot;"), 6, _X('\"')},
+    { _X("&apos;"), 6, _X('\'')},
+    { NULL        , 0, '\0'    }
+};
+
+// When rendering the XMLNode to a string (using the "createXMLString" function),
+// you can ask for a beautiful formatting. This formatting is using the
+// following indentation character:
+#define INDENTCHAR _X('\t')
+
+// The following function parses the XML errors into a user friendly string.
+// You can edit this to change the output language of the library to something else.
+XMLCSTR XMLNode::getError(XMLError xerror)
+{
+    switch (xerror)
+    {
+    case eXMLErrorNone:                  return _X("No error");
+    case eXMLErrorMissingEndTag:         return _X("Warning: Unmatched end tag");
+    case eXMLErrorNoXMLTagFound:         return _X("Warning: No XML tag found");
+    case eXMLErrorEmpty:                 return _X("Error: No XML data");
+    case eXMLErrorMissingTagName:        return _X("Error: Missing start tag name");
+    case eXMLErrorMissingEndTagName:     return _X("Error: Missing end tag name");
+    case eXMLErrorUnmatchedEndTag:       return _X("Error: Unmatched end tag");
+    case eXMLErrorUnmatchedEndClearTag:  return _X("Error: Unmatched clear tag end");
+    case eXMLErrorUnexpectedToken:       return _X("Error: Unexpected token found");
+    case eXMLErrorNoElements:            return _X("Error: No elements found");
+    case eXMLErrorFileNotFound:          return _X("Error: File not found");
+    case eXMLErrorFirstTagNotFound:      return _X("Error: First Tag not found");
+    case eXMLErrorUnknownCharacterEntity:return _X("Error: Unknown character entity");
+    case eXMLErrorCharConversionError:   return _X("Error: unable to convert between WideChar and MultiByte chars");
+    case eXMLErrorCannotOpenWriteFile:   return _X("Error: unable to open file for writing");
+    case eXMLErrorCannotWriteFile:       return _X("Error: cannot write into file");
+
+    case eXMLErrorBase64DataSizeIsNotMultipleOf4: return _X("Warning: Base64-string length is not a multiple of 4");
+    case eXMLErrorBase64DecodeTruncatedData:      return _X("Warning: Base64-string is truncated");
+    case eXMLErrorBase64DecodeIllegalCharacter:   return _X("Error: Base64-string contains an illegal character");
+    case eXMLErrorBase64DecodeBufferTooSmall:     return _X("Error: Base64 decode output buffer is too small");
+    };
+    return _X("Unknown");
+}
+
+/////////////////////////////////////////////////////////////////////////
+//      Here start the abstraction layer to be OS-independent          //
+/////////////////////////////////////////////////////////////////////////
+
+// Here is an abstraction layer to access some common string manipulation functions.
+// The abstraction layer is currently working for gcc, Microsoft Visual Studio 6.0,
+// Microsoft Visual Studio .NET, CC (sun compiler) and Borland C++.
+// If you plan to "port" the library to a new system/compiler, all you have to do is
+// to edit the following lines.
+#ifdef XML_NO_WIDE_CHAR
+char myIsTextWideChar(const void *b, int len) { return FALSE; }
+#else
+    #if defined (UNDER_CE) || !defined(_XMLWINDOWS)
+    char myIsTextWideChar(const void *b, int len) // inspired by the Wine API: RtlIsTextUnicode
+    {
+#ifdef sun
+        // for SPARC processors: wchar_t* buffers must always be alligned, otherwise it's a char* buffer.
+        if ((((unsigned long)b)%sizeof(wchar_t))!=0) return FALSE;
+#endif
+        const wchar_t *s=(const wchar_t*)b;
+
+        // buffer too small:
+        if (len<(int)sizeof(wchar_t)) return FALSE;
+
+        // odd length test
+        if (len&1) return FALSE;
+
+        /* only checks the first 256 characters */
+        len=mmin(256,len/sizeof(wchar_t));
+
+        // Check for the special byte order:
+        if (*((unsigned short*)s) == 0xFFFE) return TRUE;     // IS_TEXT_UNICODE_REVERSE_SIGNATURE;
+        if (*((unsigned short*)s) == 0xFEFF) return TRUE;      // IS_TEXT_UNICODE_SIGNATURE
+
+        // checks for ASCII characters in the UNICODE stream
+        int i,stats=0;
+        for (i=0; i<len; i++) if (s[i]<=(unsigned short)255) stats++;
+        if (stats>len/2) return TRUE;
+
+        // Check for UNICODE NULL chars
+        for (i=0; i<len; i++) if (!s[i]) return TRUE;
+
+        return FALSE;
+    }
+    #else
+    char myIsTextWideChar(const void *b,int l) { return (char)IsTextUnicode((CONST LPVOID)b,l,NULL); };
+    #endif
+#endif
+
+#ifdef _XMLWINDOWS
+// for Microsoft Visual Studio 6.0 and Microsoft Visual Studio .NET,
+    #ifdef _XMLWIDECHAR
+        wchar_t *myMultiByteToWideChar(const char *s)
+        {
+            int i;
+            if (characterEncoding==XMLNode::encoding_UTF8) i=(int)MultiByteToWideChar(CP_UTF8,0             ,s,-1,NULL,0);
+            else                                           i=(int)MultiByteToWideChar(CP_ACP ,MB_PRECOMPOSED,s,-1,NULL,0);
+            if (i<0) return NULL;
+            wchar_t *d=(wchar_t *)malloc((i+1)*sizeof(XMLCHAR));
+            if (characterEncoding==XMLNode::encoding_UTF8) i=(int)MultiByteToWideChar(CP_UTF8,0             ,s,-1,d,i);
+            else                                           i=(int)MultiByteToWideChar(CP_ACP ,MB_PRECOMPOSED,s,-1,d,i);
+            d[i]=0;
+            return d;
+        }
+        static inline FILE *xfopen(XMLCSTR filename,XMLCSTR mode) { return _wfopen(filename,mode); }
+        static inline int xstrlen(XMLCSTR c)   { return (int)wcslen(c); }
+        static inline int xstrnicmp(XMLCSTR c1, XMLCSTR c2, int l) { return _wcsnicmp(c1,c2,l);}
+        static inline int xstrncmp(XMLCSTR c1, XMLCSTR c2, int l) { return wcsncmp(c1,c2,l);}
+        static inline int xstricmp(XMLCSTR c1, XMLCSTR c2) { return _wcsicmp(c1,c2); }
+        static inline XMLSTR xstrstr(XMLCSTR c1, XMLCSTR c2) { return (XMLSTR)wcsstr(c1,c2); }
+        static inline XMLSTR xstrcpy(XMLSTR c1, XMLCSTR c2) { return (XMLSTR)wcscpy(c1,c2); }
+    #else
+        char *myWideCharToMultiByte(const wchar_t *s)
+        {
+            UINT codePage=CP_ACP; if (characterEncoding==XMLNode::encoding_UTF8) codePage=CP_UTF8;
+            int i=(int)WideCharToMultiByte(codePage,  // code page
+                0,                       // performance and mapping flags
+                s,                       // wide-character string
+                -1,                       // number of chars in string
+                NULL,                       // buffer for new string
+                0,                       // size of buffer
+                NULL,                    // default for unmappable chars
+                NULL                     // set when default char used
+                );
+            if (i<0) return NULL;
+            char *d=(char*)malloc(i+1);
+            WideCharToMultiByte(codePage,  // code page
+                0,                       // performance and mapping flags
+                s,                       // wide-character string
+                -1,                       // number of chars in string
+                d,                       // buffer for new string
+                i,                       // size of buffer
+                NULL,                    // default for unmappable chars
+                NULL                     // set when default char used
+                );
+            d[i]=0;
+            return d;
+        }
+        static inline FILE *xfopen(XMLCSTR filename,XMLCSTR mode) { return fopen(filename,mode); }
+        static inline int xstrlen(XMLCSTR c)   { return (int)strlen(c); }
+        static inline int xstrnicmp(XMLCSTR c1, XMLCSTR c2, int l) { return _strnicmp(c1,c2,l);}
+        static inline int xstrncmp(XMLCSTR c1, XMLCSTR c2, int l) { return strncmp(c1,c2,l);}
+        static inline int xstricmp(XMLCSTR c1, XMLCSTR c2) { return _stricmp(c1,c2); }
+        static inline XMLSTR xstrstr(XMLCSTR c1, XMLCSTR c2) { return (XMLSTR)strstr(c1,c2); }
+        static inline XMLSTR xstrcpy(XMLSTR c1, XMLCSTR c2) { return (XMLSTR)strcpy(c1,c2); }
+    #endif
+    #ifdef __BORLANDC__
+    static inline int _strnicmp(char *c1, char *c2, int l){ return strnicmp(c1,c2,l);}
+    #endif
+#else
+// for gcc and CC
+    #ifdef XML_NO_WIDE_CHAR
+        char *myWideCharToMultiByte(const wchar_t *s) { return NULL; }
+    #else
+        char *myWideCharToMultiByte(const wchar_t *s)
+        {
+            const wchar_t *ss=s;
+            int i=(int)wcsrtombs(NULL,&ss,0,NULL);
+            if (i<0) return NULL;
+            char *d=(char *)malloc(i+1);
+            wcsrtombs(d,&s,i,NULL);
+            d[i]=0;
+            return d;
+        }
+    #endif
+    #ifdef _XMLWIDECHAR
+        wchar_t *myMultiByteToWideChar(const char *s)
+        {
+            const char *ss=s;
+            int i=(int)mbsrtowcs(NULL,&ss,0,NULL);
+            if (i<0) return NULL;
+            wchar_t *d=(wchar_t *)malloc((i+1)*sizeof(wchar_t));
+            mbsrtowcs(d,&s,i,NULL);
+            d[i]=0;
+            return d;
+        }
+        int xstrlen(XMLCSTR c)   { return wcslen(c); }
+        #ifdef sun
+        // for CC
+           #include <widec.h>
+           static inline int xstrnicmp(XMLCSTR c1, XMLCSTR c2, int l) { return wsncasecmp(c1,c2,l);}
+           static inline int xstrncmp(XMLCSTR c1, XMLCSTR c2, int l) { return wsncmp(c1,c2,l);}
+           static inline int xstricmp(XMLCSTR c1, XMLCSTR c2) { return wscasecmp(c1,c2); }
+        #else
+        // for gcc
+           static inline int xstrnicmp(XMLCSTR c1, XMLCSTR c2, int l) { return wcsncasecmp(c1,c2,l);}
+           static inline int xstrncmp(XMLCSTR c1, XMLCSTR c2, int l) { return wcsncmp(c1,c2,l);}
+           static inline int xstricmp(XMLCSTR c1, XMLCSTR c2) { return wcscasecmp(c1,c2); }
+        #endif
+        static inline XMLSTR xstrstr(XMLCSTR c1, XMLCSTR c2) { return (XMLSTR)wcsstr(c1,c2); }
+        static inline XMLSTR xstrcpy(XMLSTR c1, XMLCSTR c2) { return (XMLSTR)wcscpy(c1,c2); }
+        static inline FILE *xfopen(XMLCSTR filename,XMLCSTR mode)
+        {
+            char *filenameAscii=myWideCharToMultiByte(filename);
+            FILE *f;
+            if (mode[0]==_X('r')) f=fopen(filenameAscii,"rb");
+            else                  f=fopen(filenameAscii,"wb");
+            free(filenameAscii);
+            return f;
+        }
+    #else
+        static inline FILE *xfopen(XMLCSTR filename,XMLCSTR mode) { return fopen(filename,mode); }
+        static inline int xstrlen(XMLCSTR c)   { return strlen(c); }
+        static inline int xstrnicmp(XMLCSTR c1, XMLCSTR c2, int l) { return strncasecmp(c1,c2,l);}
+        static inline int xstrncmp(XMLCSTR c1, XMLCSTR c2, int l) { return strncmp(c1,c2,l);}
+        static inline int xstricmp(XMLCSTR c1, XMLCSTR c2) { return strcasecmp(c1,c2); }
+        static inline XMLSTR xstrstr(XMLCSTR c1, XMLCSTR c2) { return (XMLSTR)strstr(c1,c2); }
+        static inline XMLSTR xstrcpy(XMLSTR c1, XMLCSTR c2) { return (XMLSTR)strcpy(c1,c2); }
+    #endif
+    static inline int _strnicmp(const char *c1,const char *c2, int l) { return strncasecmp(c1,c2,l);}
+#endif
+
+/////////////////////////////////////////////////////////////////////////
+//                    the "openFileHelper" function                    //
+/////////////////////////////////////////////////////////////////////////
+
+// Since each application has its own way to report and deal with errors, you should modify & rewrite
+// the following "openFileHelper" function to get an "error reporting mechanism" tailored to your needs.
+XMLNode XMLNode::openFileHelper(XMLCSTR filename, XMLCSTR tag)
+{
+    // guess the value of the global parameter "characterEncoding"
+    // (the guess is based on the first 200 bytes of the file).
+    FILE *f=xfopen(filename,_X("rb"));
+    if (f)
+    {
+        char bb[205];
+        int l=(int)fread(bb,1,200,f);
+        setGlobalOptions(guessCharEncoding(bb,l),guessWideCharChars,dropWhiteSpace);
+        fclose(f);
+    }
+
+    // parse the file
+    XMLResults pResults;
+    XMLNode xnode=XMLNode::parseFile(filename,tag,&pResults);
+
+    // display error message (if any)
+    if (pResults.error != eXMLErrorNone)
+    {
+        // create message
+        char message[2000],*s1=(char*)"",*s3=(char*)""; XMLCSTR s2=_X("");
+        if (pResults.error==eXMLErrorFirstTagNotFound) { s1=(char*)"First Tag should be '"; s2=tag; s3=(char*)"'.\n"; }
+        sprintf(message,
+#ifdef _XMLWIDECHAR
+            "XML Parsing error inside file '%S'.\n%S\nAt line %i, column %i.\n%s%S%s"
+#else
+            "XML Parsing error inside file '%s'.\n%s\nAt line %i, column %i.\n%s%s%s"
+#endif
+            ,filename,XMLNode::getError(pResults.error),pResults.nLine,pResults.nColumn,s1,s2,s3);
+
+        // display message
+#if defined(_XMLWINDOWS) && !defined(UNDER_CE) && !defined(_XMLPARSER_NO_MESSAGEBOX_)
+        MessageBoxA(NULL,message,"XML Parsing error",MB_OK|MB_ICONERROR|MB_TOPMOST);
+#else
+        printf("%s",message);
+#endif
+        exit(255);
+    }
+    return xnode;
+}
+
+/////////////////////////////////////////////////////////////////////////
+//      Here start the core implementation of the XMLParser library    //
+/////////////////////////////////////////////////////////////////////////
+
+// You should normally not change anything below this point.
+
+#ifndef _XMLWIDECHAR
+// If "characterEncoding=ascii" then we assume that all characters have the same length of 1 byte.
+// If "characterEncoding=UTF8" then the characters have different lengths (from 1 byte to 4 bytes).
+// If "characterEncoding=ShiftJIS" then the characters have different lengths (from 1 byte to 2 bytes).
+// This table is used as lookup-table to know the length of a character (in byte) based on the
+// content of the first byte of the character.
+// (note: if you modify this, you must always have XML_utf8ByteTable[0]=0 ).
+static const char XML_utf8ByteTable[256] =
+{
+    //  0 1 2 3 4 5 6 7 8 9 a b c d e f
+    0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x00
+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x10
+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x20
+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x30
+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x40
+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x50
+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x60
+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x70End of ASCII range
+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x80 0x80 to 0xc1 invalid
+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x90
+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0xa0
+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0xb0
+    1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,// 0xc0 0xc2 to 0xdf 2 byte
+    2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,// 0xd0
+    3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,// 0xe0 0xe0 to 0xef 3 byte
+    4,4,4,4,4,1,1,1,1,1,1,1,1,1,1,1 // 0xf0 0xf0 to 0xf4 4 byte, 0xf5 and higher invalid
+};
+static const char XML_asciiByteTable[256] =
+{
+    0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
+};
+static const char XML_sjisByteTable[256] =
+{
+    //  0 1 2 3 4 5 6 7 8 9 a b c d e f
+    0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x00
+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x10
+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x20
+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x30
+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x40
+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x50
+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x60
+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0x70 End of ASCII range
+    1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,// 0x80 0x81 to 0x9F 2 bytes
+    2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,// 0x90
+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0xa0
+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0xb0
+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0xc0
+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,// 0xd0
+    2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,// 0xe0 0xe0 to 0xef 2 bytes
+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 // 0xf0
+};
+static const char *XML_ByteTable=(const char *)XML_utf8ByteTable; // the default is "characterEncoding=XMLNode::encoding_UTF8"
+#endif
+
+
+XMLNode XMLNode::emptyXMLNode;
+XMLClear XMLNode::emptyXMLClear={ NULL, NULL, NULL};
+XMLAttribute XMLNode::emptyXMLAttribute={ NULL, NULL};
+
+// Enumeration used to decipher what type a token is
+typedef enum XMLTokenTypeTag
+{
+    eTokenText = 0,
+    eTokenQuotedText,
+    eTokenTagStart,         /* "<"            */
+    eTokenTagEnd,           /* "</"           */
+    eTokenCloseTag,         /* ">"            */
+    eTokenEquals,           /* "="            */
+    eTokenDeclaration,      /* "<?"           */
+    eTokenShortHandClose,   /* "/>"           */
+    eTokenClear,
+    eTokenError
+} XMLTokenType;
+
+// Main structure used for parsing XML
+typedef struct XML
+{
+    XMLCSTR                lpXML;
+    XMLCSTR                lpszText;
+    int                    nIndex,nIndexMissigEndTag;
+    enum XMLError          error;
+    XMLCSTR                lpEndTag;
+    int                    cbEndTag;
+    XMLCSTR                lpNewElement;
+    int                    cbNewElement;
+    int                    nFirst;
+} XML;
+
+typedef struct
+{
+    ALLXMLClearTag *pClr;
+    XMLCSTR     pStr;
+} NextToken;
+
+// Enumeration used when parsing attributes
+typedef enum Attrib
+{
+    eAttribName = 0,
+    eAttribEquals,
+    eAttribValue
+} Attrib;
+
+// Enumeration used when parsing elements to dictate whether we are currently
+// inside a tag
+typedef enum Status
+{
+    eInsideTag = 0,
+    eOutsideTag
+} Status;
+
+XMLError XMLNode::writeToFile(XMLCSTR filename, const char *encoding, char nFormat) const
+{
+    if (!d) return eXMLErrorNone;
+    FILE *f=xfopen(filename,_X("wb"));
+    if (!f) return eXMLErrorCannotOpenWriteFile;
+#ifdef _XMLWIDECHAR
+    unsigned char h[2]={ 0xFF, 0xFE };
+    if (!fwrite(h,2,1,f)) return eXMLErrorCannotWriteFile;
+    if ((!isDeclaration())&&((d->lpszName)||(!getChildNode().isDeclaration())))
+    {
+        if (!fwrite(_X("<?xml version=\"1.0\" encoding=\"utf-16\"?>\n"),sizeof(wchar_t)*40,1,f))
+            return eXMLErrorCannotWriteFile;
+    }
+#else
+    if ((!isDeclaration())&&((d->lpszName)||(!getChildNode().isDeclaration())))
+    {
+        if (characterEncoding==encoding_UTF8)
+        {
+            // header so that windows recognize the file as UTF-8:
+            unsigned char h[3]={0xEF,0xBB,0xBF}; if (!fwrite(h,3,1,f)) return eXMLErrorCannotWriteFile;
+            encoding="utf-8";
+        } else if (characterEncoding==encoding_ShiftJIS) encoding="SHIFT-JIS";
+
+        if (!encoding) encoding="ISO-8859-1";
+        if (fprintf(f,"<?xml version=\"1.0\" encoding=\"%s\"?>\n",encoding)<0) return eXMLErrorCannotWriteFile;
+    } else
+    {
+        if (characterEncoding==encoding_UTF8)
+        {
+            unsigned char h[3]={0xEF,0xBB,0xBF}; if (!fwrite(h,3,1,f)) return eXMLErrorCannotWriteFile;
+        }
+    }
+#endif
+    int i;
+    XMLSTR t=createXMLString(nFormat,&i);
+    if (!fwrite(t,sizeof(XMLCHAR)*i,1,f)) return eXMLErrorCannotWriteFile;
+    if (fclose(f)!=0) return eXMLErrorCannotWriteFile;
+    free(t);
+    return eXMLErrorNone;
+}
+
+// Duplicate a given string.
+XMLSTR stringDup(XMLCSTR lpszData, int cbData)
+{
+    if (lpszData==NULL) return NULL;
+
+    XMLSTR lpszNew;
+    if (cbData==0) cbData=(int)xstrlen(lpszData);
+    lpszNew = (XMLSTR)malloc((cbData+1) * sizeof(XMLCHAR));
+    if (lpszNew)
+    {
+        memcpy(lpszNew, lpszData, (cbData) * sizeof(XMLCHAR));
+        lpszNew[cbData] = (XMLCHAR)NULL;
+    }
+    return lpszNew;
+}
+
+XMLSTR toXMLStringUnSafe(XMLSTR dest,XMLCSTR source)
+{
+    XMLSTR dd=dest;
+    XMLCHAR ch;
+    XMLCharacterEntity *entity;
+    while ((ch=*source))
+    {
+        entity=XMLEntities;
+        do
+        {
+            if (ch==entity->c) {xstrcpy(dest,entity->s); dest+=entity->l; source++; goto out_of_loop1; }
+            entity++;
+        } while(entity->s);
+#ifdef _XMLWIDECHAR
+        *(dest++)=*(source++);
+#else
+        switch(XML_ByteTable[(unsigned char)ch])
+        {
+        case 4: *(dest++)=*(source++);
+        case 3: *(dest++)=*(source++);
+        case 2: *(dest++)=*(source++);
+        case 1: *(dest++)=*(source++);
+        }
+#endif
+out_of_loop1:
+        ;
+    }
+    *dest=0;
+    return dd;
+}
+
+// private (used while rendering):
+int lengthXMLString(XMLCSTR source)
+{
+    int r=0;
+    XMLCharacterEntity *entity;
+    XMLCHAR ch;
+    while ((ch=*source))
+    {
+        entity=XMLEntities;
+        do
+        {
+            if (ch==entity->c) { r+=entity->l; source++; goto out_of_loop1; }
+            entity++;
+        } while(entity->s);
+#ifdef _XMLWIDECHAR
+        r++; source++;
+#else
+        ch=XML_ByteTable[(unsigned char)ch]; r+=ch; source+=ch;
+#endif
+out_of_loop1:
+        ;
+    }
+    return r;
+}
+
+ToXMLStringTool::~ToXMLStringTool(){ freeBuffer(); }
+void ToXMLStringTool::freeBuffer(){ if (buf) free(buf); buf=NULL; buflen=0; }
+XMLSTR ToXMLStringTool::toXML(XMLCSTR source)
+{
+    int l=lengthXMLString(source)+1;
+    if (l>buflen) { buflen=l; buf=(XMLSTR)realloc(buf,l*sizeof(XMLCHAR)); }
+    return toXMLStringUnSafe(buf,source);
+}
+
+// private:
+XMLSTR fromXMLString(XMLCSTR s, int lo, XML *pXML)
+{
+    // This function is the opposite of the function "toXMLString". It decodes the escape
+    // sequences &amp;, &quot;, &apos;, &lt;, &gt; and replace them by the characters
+    // &,",',<,>. This function is used internally by the XML Parser. All the calls to
+    // the XML library will always gives you back "decoded" strings.
+    //
+    // in: string (s) and length (lo) of string
+    // out:  new allocated string converted from xml
+    if (!s) return NULL;
+
+    int ll=0,j;
+    XMLSTR d;
+    XMLCSTR ss=s;
+    XMLCharacterEntity *entity;
+    while ((lo>0)&&(*s))
+    {
+        if (*s==_X('&'))
+        {
+            if ((lo>2)&&(s[1]==_X('#')))
+            {
+                s+=2; lo-=2;
+                if ((*s==_X('X'))||(*s==_X('x'))) { s++; lo--; }
+                while ((*s)&&(*s!=_X(';'))&&((lo--)>0)) s++;
+                if (*s!=_X(';'))
+                {
+                    pXML->error=eXMLErrorUnknownCharacterEntity;
+                    return NULL;
+                }
+                s++; lo--;
+            } else
+            {
+                entity=XMLEntities;
+                do
+                {
+                    if ((lo>=entity->l)&&(xstrnicmp(s,entity->s,entity->l)==0)) { s+=entity->l; lo-=entity->l; break; }
+                    entity++;
+                } while(entity->s);
+                if (!entity->s)
+                {
+                    pXML->error=eXMLErrorUnknownCharacterEntity;
+                    return NULL;
+                }
+            }
+        } else
+        {
+#ifdef _XMLWIDECHAR
+            s++; lo--;
+#else
+            j=XML_ByteTable[(unsigned char)*s]; s+=j; lo-=j; ll+=j-1;
+#endif
+        }
+        ll++;
+    }
+
+    d=(XMLSTR)malloc((ll+1)*sizeof(XMLCHAR));
+    s=d;
+    while (ll-->0)
+    {
+        if (*ss==_X('&'))
+        {
+            if (ss[1]==_X('#'))
+            {
+                ss+=2; j=0;
+                if ((*ss==_X('X'))||(*ss==_X('x')))
+                {
+                    ss++;
+                    while (*ss!=_X(';'))
+                    {
+                        if ((*ss>=_X('0'))&&(*ss<=_X('9'))) j=(j<<4)+*ss-_X('0');
+                        else if ((*ss>=_X('A'))&&(*ss<=_X('F'))) j=(j<<4)+*ss-_X('A')+10;
+                        else if ((*ss>=_X('a'))&&(*ss<=_X('f'))) j=(j<<4)+*ss-_X('a')+10;
+                        else { free((void*)s); pXML->error=eXMLErrorUnknownCharacterEntity;return NULL;}
+                        ss++;
+                    }
+                } else
+                {
+                    while (*ss!=_X(';'))
+                    {
+                        if ((*ss>=_X('0'))&&(*ss<=_X('9'))) j=(j*10)+*ss-_X('0');
+                        else { free((void*)s); pXML->error=eXMLErrorUnknownCharacterEntity;return NULL;}
+                        ss++;
+                    }
+                }
+                (*d++)=(XMLCHAR)j; ss++;
+            } else
+            {
+                entity=XMLEntities;
+                do
+                {
+                    if (xstrnicmp(ss,entity->s,entity->l)==0) { *(d++)=entity->c; ss+=entity->l; break; }
+                    entity++;
+                } while(entity->s);
+            }
+        } else
+        {
+#ifdef _XMLWIDECHAR
+            *(d++)=*(ss++);
+#else
+            switch(XML_ByteTable[(unsigned char)*ss])
+            {
+            case 4: *(d++)=*(ss++); ll--;
+            case 3: *(d++)=*(ss++); ll--;
+            case 2: *(d++)=*(ss++); ll--;
+            case 1: *(d++)=*(ss++);
+            }
+#endif
+        }
+    }
+    *d=0;
+    return (XMLSTR)s;
+}
+
+#define XML_isSPACECHAR(ch) ((ch==_X('\n'))||(ch==_X(' '))||(ch== _X('\t'))||(ch==_X('\r')))
+
+// private:
+char myTagCompare(XMLCSTR cclose, XMLCSTR copen)
+// !!!! WARNING strange convention&:
+// return 0 if equals
+// return 1 if different
+{
+    if (!cclose) return 1;
+    int l=(int)xstrlen(cclose);
+    if (xstrnicmp(cclose, copen, l)!=0) return 1;
+    const XMLCHAR c=copen[l];
+    if (XML_isSPACECHAR(c)||
+        (c==_X('/' ))||
+        (c==_X('<' ))||
+        (c==_X('>' ))||
+        (c==_X('=' ))) return 0;
+    return 1;
+}
+
+// Obtain the next character from the string.
+static inline XMLCHAR getNextChar(XML *pXML)
+{
+    XMLCHAR ch = pXML->lpXML[pXML->nIndex];
+#ifdef _XMLWIDECHAR
+    if (ch!=0) pXML->nIndex++;
+#else
+    pXML->nIndex+=XML_ByteTable[(unsigned char)ch];
+#endif
+    return ch;
+}
+
+// Find the next token in a string.
+// pcbToken contains the number of characters that have been read.
+static NextToken GetNextToken(XML *pXML, int *pcbToken, enum XMLTokenTypeTag *pType)
+{
+    NextToken        result;
+    XMLCHAR            ch;
+    XMLCHAR            chTemp;
+    int              indexStart,nFoundMatch,nIsText=FALSE;
+    result.pClr=NULL; // prevent warning
+
+    // Find next non-white space character
+    do { indexStart=pXML->nIndex; ch=getNextChar(pXML); } while XML_isSPACECHAR(ch);
+
+    if (ch)
+    {
+        // Cache the current string pointer
+        result.pStr = &pXML->lpXML[indexStart];
+
+        // First check whether the token is in the clear tag list (meaning it
+        // does not need formatting).
+        ALLXMLClearTag *ctag=XMLClearTags;
+        do
+        {
+            if (xstrncmp(ctag->lpszOpen, result.pStr, ctag->openTagLen)==0)
+            {
+                result.pClr=ctag;
+                pXML->nIndex+=ctag->openTagLen-1;
+                *pType=eTokenClear;
+                return result;
+            }
+            ctag++;
+        } while(ctag->lpszOpen);
+
+        // If we didn't find a clear tag then check for standard tokens
+        switch(ch)
+        {
+        // Check for quotes
+        case _X('\''):
+        case _X('\"'):
+            // Type of token
+            *pType = eTokenQuotedText;
+            chTemp = ch;
+
+            // Set the size
+            nFoundMatch = FALSE;
+
+            // Search through the string to find a matching quote
+            while((ch = getNextChar(pXML)))
+            {
+                if (ch==chTemp) { nFoundMatch = TRUE; break; }
+                if (ch==_X('<')) break;
+            }
+
+            // If we failed to find a matching quote
+            if (nFoundMatch == FALSE)
+            {
+                pXML->nIndex=indexStart+1;
+                nIsText=TRUE;
+                break;
+            }
+
+//  4.02.2002
+//            if (FindNonWhiteSpace(pXML)) pXML->nIndex--;
+
+            break;
+
+        // Equals (used with attribute values)
+        case _X('='):
+            *pType = eTokenEquals;
+            break;
+
+        // Close tag
+        case _X('>'):
+            *pType = eTokenCloseTag;
+            break;
+
+        // Check for tag start and tag end
+        case _X('<'):
+
+            // Peek at the next character to see if we have an end tag '</',
+            // or an xml declaration '<?'
+            chTemp = pXML->lpXML[pXML->nIndex];
+
+            // If we have a tag end...
+            if (chTemp == _X('/'))
+            {
+                // Set the type and ensure we point at the next character
+                getNextChar(pXML);
+                *pType = eTokenTagEnd;
+            }
+
+            // If we have an XML declaration tag
+            else if (chTemp == _X('?'))
+            {
+
+                // Set the type and ensure we point at the next character
+                getNextChar(pXML);
+                *pType = eTokenDeclaration;
+            }
+
+            // Otherwise we must have a start tag
+            else
+            {
+                *pType = eTokenTagStart;
+            }
+            break;
+
+        // Check to see if we have a short hand type end tag ('/>').
+        case _X('/'):
+
+            // Peek at the next character to see if we have a short end tag '/>'
+            chTemp = pXML->lpXML[pXML->nIndex];
+
+            // If we have a short hand end tag...
+            if (chTemp == _X('>'))
+            {
+                // Set the type and ensure we point at the next character
+                getNextChar(pXML);
+                *pType = eTokenShortHandClose;
+                break;
+            }
+
+            // If we haven't found a short hand closing tag then drop into the
+            // text process
+
+        // Other characters
+        default:
+            nIsText = TRUE;
+        }
+
+        // If this is a TEXT node
+        if (nIsText)
+        {
+            // Indicate we are dealing with text
+            *pType = eTokenText;
+            while((ch = getNextChar(pXML)))
+            {
+                if XML_isSPACECHAR(ch)
+                {
+                    indexStart++; break;
+
+                } else if (ch==_X('/'))
+                {
+                    // If we find a slash then this maybe text or a short hand end tag
+                    // Peek at the next character to see it we have short hand end tag
+                    ch=pXML->lpXML[pXML->nIndex];
+                    // If we found a short hand end tag then we need to exit the loop
+                    if (ch==_X('>')) { pXML->nIndex--; break; }
+
+                } else if ((ch==_X('<'))||(ch==_X('>'))||(ch==_X('=')))
+                {
+                    pXML->nIndex--; break;
+                }
+            }
+        }
+        *pcbToken = pXML->nIndex-indexStart;
+    } else
+    {
+        // If we failed to obtain a valid character
+        *pcbToken = 0;
+        *pType = eTokenError;
+        result.pStr=NULL;
+    }
+
+    return result;
+}
+
+XMLCSTR XMLNode::updateName_WOSD(XMLSTR lpszName)
+{
+    if (!d) { free(lpszName); return NULL; }
+    if (d->lpszName&&(lpszName!=d->lpszName)) free((void*)d->lpszName);
+    d->lpszName=lpszName;
+    return lpszName;
+}
+
+// private:
+XMLNode::XMLNode(struct XMLNodeDataTag *p){ d=p; (p->ref_count)++; }
+XMLNode::XMLNode(XMLNodeData *pParent, XMLSTR lpszName, char isDeclaration)
+{
+    d=(XMLNodeData*)malloc(sizeof(XMLNodeData));
+    d->ref_count=1;
+
+    d->lpszName=NULL;
+    d->nChild= 0;
+    d->nText = 0;
+    d->nClear = 0;
+    d->nAttribute = 0;
+
+    d->isDeclaration = isDeclaration;
+
+    d->pParent = pParent;
+    d->pChild= NULL;
+    d->pText= NULL;
+    d->pClear= NULL;
+    d->pAttribute= NULL;
+    d->pOrder= NULL;
+
+    updateName_WOSD(lpszName);
+}
+
+XMLNode XMLNode::createXMLTopNode_WOSD(XMLSTR lpszName, char isDeclaration) { return XMLNode(NULL,lpszName,isDeclaration); }
+XMLNode XMLNode::createXMLTopNode(XMLCSTR lpszName, char isDeclaration) { return XMLNode(NULL,stringDup(lpszName),isDeclaration); }
+
+#define MEMORYINCREASE 50
+
+static inline void myFree(void *p) { if (p) free(p); };
+static inline void *myRealloc(void *p, int newsize, int memInc, int sizeofElem)
+{
+    if (p==NULL) { if (memInc) return malloc(memInc*sizeofElem); return malloc(sizeofElem); }
+    if ((memInc==0)||((newsize%memInc)==0)) p=realloc(p,(newsize+memInc)*sizeofElem);
+//    if (!p)
+//    {
+//        printf("XMLParser Error: Not enough memory! Aborting...\n"); exit(220);
+//    }
+    return p;
+}
+
+// private:
+XMLElementPosition XMLNode::findPosition(XMLNodeData *d, int index, XMLElementType xxtype)
+{
+    if (index<0) return -1;
+    int i=0,j=(int)((index<<2)+xxtype),*o=d->pOrder; while (o[i]!=j) i++; return i;
+}
+
+// private:
+// update "order" information when deleting a content of a XMLNode
+int XMLNode::removeOrderElement(XMLNodeData *d, XMLElementType t, int index)
+{
+    int n=d->nChild+d->nText+d->nClear, *o=d->pOrder,i=findPosition(d,index,t);
+    memmove(o+i, o+i+1, (n-i)*sizeof(int));
+    for (;i<n;i++)
+        if ((o[i]&3)==(int)t) o[i]-=4;
+    // We should normally do:
+    // d->pOrder=(int)realloc(d->pOrder,n*sizeof(int));
+    // but we skip reallocation because it's too time consuming.
+    // Anyway, at the end, it will be free'd completely at once.
+    return i;
+}
+
+void *XMLNode::addToOrder(int memoryIncrease,int *_pos, int nc, void *p, int size, XMLElementType xtype)
+{
+    //  in: *_pos is the position inside d->pOrder ("-1" means "EndOf")
+    // out: *_pos is the index inside p
+    p=myRealloc(p,(nc+1),memoryIncrease,size);
+    int n=d->nChild+d->nText+d->nClear;
+    d->pOrder=(int*)myRealloc(d->pOrder,n+1,memoryIncrease*3,sizeof(int));
+    int pos=*_pos,*o=d->pOrder;
+
+    if ((pos<0)||(pos>=n)) { *_pos=nc; o[n]=(int)((nc<<2)+xtype); return p; }
+
+    int i=pos;
+    memmove(o+i+1, o+i, (n-i)*sizeof(int));
+
+    while ((pos<n)&&((o[pos]&3)!=(int)xtype)) pos++;
+    if (pos==n) { *_pos=nc; o[n]=(int)((nc<<2)+xtype); return p; }
+
+    o[i]=o[pos];
+    for (i=pos+1;i<=n;i++) if ((o[i]&3)==(int)xtype) o[i]+=4;
+
+    *_pos=pos=o[pos]>>2;
+    memmove(((char*)p)+(pos+1)*size,((char*)p)+pos*size,(nc-pos)*size);
+
+    return p;
+}
+
+// Add a child node to the given element.
+XMLNode XMLNode::addChild_priv(int memoryIncrease, XMLSTR lpszName, char isDeclaration, int pos)
+{
+    if (!lpszName) return emptyXMLNode;
+    d->pChild=(XMLNode*)addToOrder(memoryIncrease,&pos,d->nChild,d->pChild,sizeof(XMLNode),eNodeChild);
+    d->pChild[pos].d=NULL;
+    d->pChild[pos]=XMLNode(d,lpszName,isDeclaration);
+    d->nChild++;
+    return d->pChild[pos];
+}
+
+// Add an attribute to an element.
+XMLAttribute *XMLNode::addAttribute_priv(int memoryIncrease,XMLSTR lpszName, XMLSTR lpszValuev)
+{
+    if (!lpszName) return &emptyXMLAttribute;
+    if (!d) { myFree(lpszName); myFree(lpszValuev); return &emptyXMLAttribute; }
+    int nc=d->nAttribute;
+    d->pAttribute=(XMLAttribute*)myRealloc(d->pAttribute,(nc+1),memoryIncrease,sizeof(XMLAttribute));
+    XMLAttribute *pAttr=d->pAttribute+nc;
+    pAttr->lpszName = lpszName;
+    pAttr->lpszValue = lpszValuev;
+    d->nAttribute++;
+    return pAttr;
+}
+
+// Add text to the element.
+XMLCSTR XMLNode::addText_priv(int memoryIncrease, XMLSTR lpszValue, int pos)
+{
+    if (!lpszValue) return NULL;
+    if (!d) { myFree(lpszValue); return NULL; }
+    d->pText=(XMLCSTR*)addToOrder(memoryIncrease,&pos,d->nText,d->pText,sizeof(XMLSTR),eNodeText);
+    d->pText[pos]=lpszValue;
+    d->nText++;
+    return lpszValue;
+}
+
+// Add clear (unformatted) text to the element.
+XMLClear *XMLNode::addClear_priv(int memoryIncrease, XMLSTR lpszValue, XMLCSTR lpszOpen, XMLCSTR lpszClose, int pos)
+{
+    if (!lpszValue) return &emptyXMLClear;
+    if (!d) { myFree(lpszValue); return &emptyXMLClear; }
+    d->pClear=(XMLClear *)addToOrder(memoryIncrease,&pos,d->nClear,d->pClear,sizeof(XMLClear),eNodeClear);
+    XMLClear *pNewClear=d->pClear+pos;
+    pNewClear->lpszValue = lpszValue;
+    if (!lpszOpen) lpszOpen=XMLClearTags->lpszOpen;
+    if (!lpszClose) lpszClose=XMLClearTags->lpszClose;
+    pNewClear->lpszOpenTag = lpszOpen;
+    pNewClear->lpszCloseTag = lpszClose;
+    d->nClear++;
+    return pNewClear;
+}
+
+// private:
+// Parse a clear (unformatted) type node.
+char XMLNode::parseClearTag(void *px, void *_pClear)
+{
+    XML *pXML=(XML *)px;
+    ALLXMLClearTag pClear=*((ALLXMLClearTag*)_pClear);
+    int cbTemp=0;
+    XMLCSTR lpszTemp=NULL;
+    XMLCSTR lpXML=&pXML->lpXML[pXML->nIndex];
+    static XMLCSTR docTypeEnd=_X("]>");
+
+    // Find the closing tag
+    // Seems the <!DOCTYPE need a better treatment so lets handle it
+    if (pClear.lpszOpen==XMLClearTags[1].lpszOpen)
+    {
+        XMLCSTR pCh=lpXML;
+        while (*pCh)
+        {
+            if (*pCh==_X('<')) { pClear.lpszClose=docTypeEnd; lpszTemp=xstrstr(lpXML,docTypeEnd); break; }
+            else if (*pCh==_X('>')) { lpszTemp=pCh; break; }
+#ifdef _XMLWIDECHAR
+            pCh++;
+#else
+            pCh+=XML_ByteTable[(unsigned char)(*pCh)];
+#endif
+        }
+    } else lpszTemp=xstrstr(lpXML, pClear.lpszClose);
+
+    if (lpszTemp)
+    {
+        // Cache the size and increment the index
+        cbTemp = (int)(lpszTemp - lpXML);
+
+        pXML->nIndex += cbTemp+(int)xstrlen(pClear.lpszClose);
+
+        // Add the clear node to the current element
+        addClear_priv(MEMORYINCREASE,stringDup(lpXML,cbTemp), pClear.lpszOpen, pClear.lpszClose,-1);
+        return 0;
+    }
+
+    // If we failed to find the end tag
+    pXML->error = eXMLErrorUnmatchedEndClearTag;
+    return 1;
+}
+
+void XMLNode::exactMemory(XMLNodeData *d)
+{
+    if (d->pOrder)     d->pOrder=(int*)realloc(d->pOrder,(d->nChild+d->nText+d->nClear)*sizeof(int));
+    if (d->pChild)     d->pChild=(XMLNode*)realloc(d->pChild,d->nChild*sizeof(XMLNode));
+    if (d->pAttribute) d->pAttribute=(XMLAttribute*)realloc(d->pAttribute,d->nAttribute*sizeof(XMLAttribute));
+    if (d->pText)      d->pText=(XMLCSTR*)realloc(d->pText,d->nText*sizeof(XMLSTR));
+    if (d->pClear)     d->pClear=(XMLClear *)realloc(d->pClear,d->nClear*sizeof(XMLClear));
+}
+
+char XMLNode::maybeAddTxT(void *pa, XMLCSTR tokenPStr)
+{
+    XML *pXML=(XML *)pa;
+    XMLCSTR lpszText=pXML->lpszText;
+    if (!lpszText) return 0;
+    if (dropWhiteSpace) while (XML_isSPACECHAR(*lpszText)&&(lpszText!=tokenPStr)) lpszText++;
+    int cbText = (int)(tokenPStr - lpszText);
+    if (!cbText) { pXML->lpszText=NULL; return 0; }
+    if (dropWhiteSpace) { cbText--; while ((cbText)&&XML_isSPACECHAR(lpszText[cbText])) cbText--; cbText++; }
+    if (!cbText) { pXML->lpszText=NULL; return 0; }
+    XMLSTR lpt=fromXMLString(lpszText,cbText,pXML);
+    if (!lpt) return 1;
+    addText_priv(MEMORYINCREASE,lpt,-1);
+    pXML->lpszText=NULL;
+    return 0;
+}
+// private:
+// Recursively parse an XML element.
+int XMLNode::ParseXMLElement(void *pa)
+{
+    XML *pXML=(XML *)pa;
+    int cbToken;
+    enum XMLTokenTypeTag xtype;
+    NextToken token;
+    XMLCSTR lpszTemp=NULL;
+    int cbTemp=0;
+    char nDeclaration;
+    XMLNode pNew;
+    enum Status status; // inside or outside a tag
+    enum Attrib attrib = eAttribName;
+
+    assert(pXML);
+
+    // If this is the first call to the function
+    if (pXML->nFirst)
+    {
+        // Assume we are outside of a tag definition
+        pXML->nFirst = FALSE;
+        status = eOutsideTag;
+    } else
+    {
+        // If this is not the first call then we should only be called when inside a tag.
+        status = eInsideTag;
+    }
+
+    // Iterate through the tokens in the document
+    for(;;)
+    {
+        // Obtain the next token
+        token = GetNextToken(pXML, &cbToken, &xtype);
+
+        if (xtype != eTokenError)
+        {
+            // Check the current status
+            switch(status)
+            {
+
+            // If we are outside of a tag definition
+            case eOutsideTag:
+
+                // Check what type of token we obtained
+                switch(xtype)
+                {
+                // If we have found text or quoted text
+                case eTokenText:
+                case eTokenCloseTag:          /* '>'         */
+                case eTokenShortHandClose:    /* '/>'        */
+                case eTokenQuotedText:
+                case eTokenEquals:
+                    break;
+
+                // If we found a start tag '<' and declarations '<?'
+                case eTokenTagStart:
+                case eTokenDeclaration:
+
+                    // Cache whether this new element is a declaration or not
+                    nDeclaration = (xtype == eTokenDeclaration);
+
+                    // If we have node text then add this to the element
+                    if (maybeAddTxT(pXML,token.pStr)) return FALSE;
+
+                    // Find the name of the tag
+                    token = GetNextToken(pXML, &cbToken, &xtype);
+
+                    // Return an error if we couldn't obtain the next token or
+                    // it wasnt text
+                    if (xtype != eTokenText)
+                    {
+                        pXML->error = eXMLErrorMissingTagName;
+                        return FALSE;
+                    }
+
+                    // If we found a new element which is the same as this
+                    // element then we need to pass this back to the caller..
+
+#ifdef APPROXIMATE_PARSING
+                    if (d->lpszName &&
+                        myTagCompare(d->lpszName, token.pStr) == 0)
+                    {
+                        // Indicate to the caller that it needs to create a
+                        // new element.
+                        pXML->lpNewElement = token.pStr;
+                        pXML->cbNewElement = cbToken;
+                        return TRUE;
+                    } else
+#endif
+                    {
+                        // If the name of the new element differs from the name of
+                        // the current element we need to add the new element to
+                        // the current one and recurse
+                        pNew = addChild_priv(MEMORYINCREASE,stringDup(token.pStr,cbToken), nDeclaration,-1);
+
+                        while (!pNew.isEmpty())
+                        {
+                            // Callself to process the new node.  If we return
+                            // FALSE this means we dont have any more
+                            // processing to do...
+
+                            if (!pNew.ParseXMLElement(pXML)) return FALSE;
+                            else
+                            {
+                                // If the call to recurse this function
+                                // evented in a end tag specified in XML then
+                                // we need to unwind the calls to this
+                                // function until we find the appropriate node
+                                // (the element name and end tag name must
+                                // match)
+                                if (pXML->cbEndTag)
+                                {
+                                    // If we are back at the root node then we
+                                    // have an unmatched end tag
+                                    if (!d->lpszName)
+                                    {
+                                        pXML->error=eXMLErrorUnmatchedEndTag;
+                                        return FALSE;
+                                    }
+
+                                    // If the end tag matches the name of this
+                                    // element then we only need to unwind
+                                    // once more...
+
+                                    if (myTagCompare(d->lpszName, pXML->lpEndTag)==0)
+                                    {
+                                        pXML->cbEndTag = 0;
+                                    }
+
+                                    return TRUE;
+                                } else
+                                    if (pXML->cbNewElement)
+                                    {
+                                        // If the call indicated a new element is to
+                                        // be created on THIS element.
+
+                                        // If the name of this element matches the
+                                        // name of the element we need to create
+                                        // then we need to return to the caller
+                                        // and let it process the element.
+
+                                        if (myTagCompare(d->lpszName, pXML->lpNewElement)==0)
+                                        {
+                                            return TRUE;
+                                        }
+
+                                        // Add the new element and recurse
+                                        pNew = addChild_priv(MEMORYINCREASE,stringDup(pXML->lpNewElement,pXML->cbNewElement),0,-1);
+                                        pXML->cbNewElement = 0;
+                                    }
+                                    else
+                                    {
+                                        // If we didn't have a new element to create
+                                        pNew = emptyXMLNode;
+
+                                    }
+                            }
+                        }
+                    }
+                    break;
+
+                // If we found an end tag
+                case eTokenTagEnd:
+
+                    // If we have node text then add this to the element
+                    if (maybeAddTxT(pXML,token.pStr)) return FALSE;
+
+                    // Find the name of the end tag
+                    token = GetNextToken(pXML, &cbTemp, &xtype);
+
+                    // The end tag should be text
+                    if (xtype != eTokenText)
+                    {
+                        pXML->error = eXMLErrorMissingEndTagName;
+                        return FALSE;
+                    }
+                    lpszTemp = token.pStr;
+
+                    // After the end tag we should find a closing tag
+                    token = GetNextToken(pXML, &cbToken, &xtype);
+                    if (xtype != eTokenCloseTag)
+                    {
+                        pXML->error = eXMLErrorMissingEndTagName;
+                        return FALSE;
+                    }
+                    pXML->lpszText=pXML->lpXML+pXML->nIndex;
+
+                    // We need to return to the previous caller.  If the name
+                    // of the tag cannot be found we need to keep returning to
+                    // caller until we find a match
+                    if (myTagCompare(d->lpszName, lpszTemp) != 0)
+#ifdef STRICT_PARSING
+                    {
+                        pXML->error=eXMLErrorUnmatchedEndTag;
+                        pXML->nIndexMissigEndTag=pXML->nIndex;
+                        return FALSE;
+                    }
+#else
+                    {
+                        pXML->error=eXMLErrorMissingEndTag;
+                        pXML->nIndexMissigEndTag=pXML->nIndex;
+                        pXML->lpEndTag = lpszTemp;
+                        pXML->cbEndTag = cbTemp;
+                    }
+#endif
+
+                    // Return to the caller
+                    exactMemory(d);
+                    return TRUE;
+
+                // If we found a clear (unformatted) token
+                case eTokenClear:
+                    // If we have node text then add this to the element
+                    if (maybeAddTxT(pXML,token.pStr)) return FALSE;
+                    if (parseClearTag(pXML, token.pClr)) return FALSE;
+                    pXML->lpszText=pXML->lpXML+pXML->nIndex;
+                    break;
+
+                default:
+                    break;
+                }
+                break;
+
+            // If we are inside a tag definition we need to search for attributes
+            case eInsideTag:
+
+                // Check what part of the attribute (name, equals, value) we
+                // are looking for.
+                switch(attrib)
+                {
+                // If we are looking for a new attribute
+                case eAttribName:
+
+                    // Check what the current token type is
+                    switch(xtype)
+                    {
+                    // If the current type is text...
+                    // Eg.  'attribute'
+                    case eTokenText:
+                        // Cache the token then indicate that we are next to
+                        // look for the equals
+                        lpszTemp = token.pStr;
+                        cbTemp = cbToken;
+                        attrib = eAttribEquals;
+                        break;
+
+                    // If we found a closing tag...
+                    // Eg.  '>'
+                    case eTokenCloseTag:
+                        // We are now outside the tag
+                        status = eOutsideTag;
+                        pXML->lpszText=pXML->lpXML+pXML->nIndex;
+                        break;
+
+                    // If we found a short hand '/>' closing tag then we can
+                    // return to the caller
+                    case eTokenShortHandClose:
+                        exactMemory(d);
+                        pXML->lpszText=pXML->lpXML+pXML->nIndex;
+                        return TRUE;
+
+                    // Errors...
+                    case eTokenQuotedText:    /* '"SomeText"'   */
+                    case eTokenTagStart:      /* '<'            */
+                    case eTokenTagEnd:        /* '</'           */
+                    case eTokenEquals:        /* '='            */
+                    case eTokenDeclaration:   /* '<?'           */
+                    case eTokenClear:
+                        pXML->error = eXMLErrorUnexpectedToken;
+                        return FALSE;
+                    default: break;
+                    }
+                    break;
+
+                // If we are looking for an equals
+                case eAttribEquals:
+                    // Check what the current token type is
+                    switch(xtype)
+                    {
+                    // If the current type is text...
+                    // Eg.  'Attribute AnotherAttribute'
+                    case eTokenText:
+                        // Add the unvalued attribute to the list
+                        addAttribute_priv(MEMORYINCREASE,stringDup(lpszTemp,cbTemp), NULL);
+                        // Cache the token then indicate.  We are next to
+                        // look for the equals attribute
+                        lpszTemp = token.pStr;
+                        cbTemp = cbToken;
+                        break;
+
+                    // If we found a closing tag 'Attribute >' or a short hand
+                    // closing tag 'Attribute />'
+                    case eTokenShortHandClose:
+                    case eTokenCloseTag:
+                        // If we are a declaration element '<?' then we need
+                        // to remove extra closing '?' if it exists
+                        pXML->lpszText=pXML->lpXML+pXML->nIndex;
+
+                        if (d->isDeclaration &&
+                            (lpszTemp[cbTemp-1]) == _X('?'))
+                        {
+                            cbTemp--;
+                        }
+
+                        if (cbTemp)
+                        {
+                            // Add the unvalued attribute to the list
+                            addAttribute_priv(MEMORYINCREASE,stringDup(lpszTemp,cbTemp), NULL);
+                        }
+
+                        // If this is the end of the tag then return to the caller
+                        if (xtype == eTokenShortHandClose)
+                        {
+                            exactMemory(d);
+                            return TRUE;
+                        }
+
+                        // We are now outside the tag
+                        status = eOutsideTag;
+                        break;
+
+                    // If we found the equals token...
+                    // Eg.  'Attribute ='
+                    case eTokenEquals:
+                        // Indicate that we next need to search for the value
+                        // for the attribute
+                        attrib = eAttribValue;
+                        break;
+
+                    // Errors...
+                    case eTokenQuotedText:    /* 'Attribute "InvalidAttr"'*/
+                    case eTokenTagStart:      /* 'Attribute <'            */
+                    case eTokenTagEnd:        /* 'Attribute </'           */
+                    case eTokenDeclaration:   /* 'Attribute <?'           */
+                    case eTokenClear:
+                        pXML->error = eXMLErrorUnexpectedToken;
+                        return FALSE;
+                    default: break;
+                    }
+                    break;
+
+                // If we are looking for an attribute value
+                case eAttribValue:
+                    // Check what the current token type is
+                    switch(xtype)
+                    {
+                    // If the current type is text or quoted text...
+                    // Eg.  'Attribute = "Value"' or 'Attribute = Value' or
+                    // 'Attribute = 'Value''.
+                    case eTokenText:
+                    case eTokenQuotedText:
+                        // If we are a declaration element '<?' then we need
+                        // to remove extra closing '?' if it exists
+                        if (d->isDeclaration &&
+                            (token.pStr[cbToken-1]) == _X('?'))
+                        {
+                            cbToken--;
+                        }
+
+                        if (cbTemp)
+                        {
+                            // Add the valued attribute to the list
+                            if (xtype==eTokenQuotedText) { token.pStr++; cbToken-=2; }
+                            XMLSTR attrVal=(XMLSTR)token.pStr;
+                            if (attrVal)
+                            {
+                                attrVal=fromXMLString(attrVal,cbToken,pXML);
+                                if (!attrVal) return FALSE;
+                            }
+                            addAttribute_priv(MEMORYINCREASE,stringDup(lpszTemp,cbTemp),attrVal);
+                        }
+
+                        // Indicate we are searching for a new attribute
+                        attrib = eAttribName;
+                        break;
+
+                    // Errors...
+                    case eTokenTagStart:        /* 'Attr = <'          */
+                    case eTokenTagEnd:          /* 'Attr = </'         */
+                    case eTokenCloseTag:        /* 'Attr = >'          */
+                    case eTokenShortHandClose:  /* "Attr = />"         */
+                    case eTokenEquals:          /* 'Attr = ='          */
+                    case eTokenDeclaration:     /* 'Attr = <?'         */
+                    case eTokenClear:
+                        pXML->error = eXMLErrorUnexpectedToken;
+                        return FALSE;
+                        break;
+                    default: break;
+                    }
+                }
+            }
+        }
+        // If we failed to obtain the next token
+        else
+        {
+            if ((!d->isDeclaration)&&(d->pParent))
+            {
+#ifdef STRICT_PARSING
+                pXML->error=eXMLErrorUnmatchedEndTag;
+#else
+                pXML->error=eXMLErrorMissingEndTag;
+#endif
+                pXML->nIndexMissigEndTag=pXML->nIndex;
+            }
+            maybeAddTxT(pXML,pXML->lpXML+pXML->nIndex);
+            return FALSE;
+        }
+    }
+}
+
+// Count the number of lines and columns in an XML string.
+static void CountLinesAndColumns(XMLCSTR lpXML, int nUpto, XMLResults *pResults)
+{
+    XMLCHAR ch;
+    assert(lpXML);
+    assert(pResults);
+
+    struct XML xml={ lpXML,lpXML, 0, 0, eXMLErrorNone, NULL, 0, NULL, 0, TRUE };
+
+    pResults->nLine = 1;
+    pResults->nColumn = 1;
+    while (xml.nIndex<nUpto)
+    {
+        ch = getNextChar(&xml);
+        if (ch != _X('\n')) pResults->nColumn++;
+        else
+        {
+            pResults->nLine++;
+            pResults->nColumn=1;
+        }
+    }
+}
+
+// Parse XML and return the root element.
+XMLNode XMLNode::parseString(XMLCSTR lpszXML, XMLCSTR tag, XMLResults *pResults)
+{
+    if (!lpszXML)
+    {
+        if (pResults)
+        {
+            pResults->error=eXMLErrorNoElements;
+            pResults->nLine=0;
+            pResults->nColumn=0;
+        }
+        return emptyXMLNode;
+    }
+
+    XMLNode xnode(NULL,NULL,FALSE);
+    struct XML xml={ lpszXML, lpszXML, 0, 0, eXMLErrorNone, NULL, 0, NULL, 0, TRUE };
+
+    // Create header element
+    xnode.ParseXMLElement(&xml);
+    enum XMLError error = xml.error;
+    if (!xnode.nChildNode()) error=eXMLErrorNoXMLTagFound;
+    if ((xnode.nChildNode()==1)&&(xnode.nElement()==1)) xnode=xnode.getChildNode(); // skip the empty node
+
+    // If no error occurred
+    if ((error==eXMLErrorNone)||(error==eXMLErrorMissingEndTag)||(error==eXMLErrorNoXMLTagFound))
+    {
+        XMLCSTR name=xnode.getName();
+        if (tag&&xstrlen(tag)&&((!name)||(xstricmp(xnode.getName(),tag))))
+        {
+            XMLNode nodeTmp;
+            int i=0;
+            while (i<xnode.nChildNode())
+            {
+                nodeTmp=xnode.getChildNode(i);
+                if (xstricmp(nodeTmp.getName(),tag)==0) break;
+                if (nodeTmp.isDeclaration()) { xnode=nodeTmp; i=0; } else i++;
+            }
+            if (i>=xnode.nChildNode())
+            {
+                if (pResults)
+                {
+                    pResults->error=eXMLErrorFirstTagNotFound;
+                    pResults->nLine=0;
+                    pResults->nColumn=0;
+                }
+                return emptyXMLNode;
+            }
+            xnode=nodeTmp;
+        }
+    } else
+    {
+        // Cleanup: this will destroy all the nodes
+        xnode = emptyXMLNode;
+    }
+
+
+    // If we have been given somewhere to place results
+    if (pResults)
+    {
+        pResults->error = error;
+
+        // If we have an error
+        if (error!=eXMLErrorNone)
+        {
+            if (error==eXMLErrorMissingEndTag) xml.nIndex=xml.nIndexMissigEndTag;
+            // Find which line and column it starts on.
+            CountLinesAndColumns(xml.lpXML, xml.nIndex, pResults);
+        }
+    }
+    return xnode;
+}
+
+XMLNode XMLNode::parseFile(XMLCSTR filename, XMLCSTR tag, XMLResults *pResults)
+{
+    if (pResults) { pResults->nLine=0; pResults->nColumn=0; }
+    FILE *f=xfopen(filename,_X("rb"));
+    if (f==NULL) { if (pResults) pResults->error=eXMLErrorFileNotFound; return emptyXMLNode; }
+    fseek(f,0,SEEK_END);
+    int l=ftell(f),headerSz=0;
+    if (!l) { if (pResults) pResults->error=eXMLErrorEmpty; fclose(f); return emptyXMLNode; }
+    fseek(f,0,SEEK_SET);
+    unsigned char *buf=(unsigned char*)malloc(l+4);
+    fread(buf,l,1,f);
+    fclose(f);
+    buf[l]=0;buf[l+1]=0;buf[l+2]=0;buf[l+3]=0;
+#ifdef _XMLWIDECHAR
+    if (guessWideCharChars)
+    {
+        if (!myIsTextWideChar(buf,l))
+        {
+            if ((buf[0]==0xef)&&(buf[1]==0xbb)&&(buf[2]==0xbf)) headerSz=3;
+            XMLSTR b2=myMultiByteToWideChar((const char*)(buf+headerSz));
+            free(buf); buf=(unsigned char*)b2; headerSz=0;
+        } else
+        {
+            if ((buf[0]==0xef)&&(buf[1]==0xff)) headerSz=2;
+            if ((buf[0]==0xff)&&(buf[1]==0xfe)) headerSz=2;
+        }
+    }
+#else
+    if (guessWideCharChars)
+    {
+        if (myIsTextWideChar(buf,l))
+        {
+            l/=sizeof(wchar_t);
+            if ((buf[0]==0xef)&&(buf[1]==0xff)) headerSz=2;
+            if ((buf[0]==0xff)&&(buf[1]==0xfe)) headerSz=2;
+            char *b2=myWideCharToMultiByte((const wchar_t*)(buf+headerSz));
+            free(buf); buf=(unsigned char*)b2; headerSz=0;
+        } else
+        {
+            if ((buf[0]==0xef)&&(buf[1]==0xbb)&&(buf[2]==0xbf)) headerSz=3;
+        }
+    }
+#endif
+
+    if (!buf) { if (pResults) pResults->error=eXMLErrorCharConversionError; return emptyXMLNode; }
+    XMLNode x=parseString((XMLSTR)(buf+headerSz),tag,pResults);
+    free(buf);
+    return x;
+}
+
+static inline void charmemset(XMLSTR dest,XMLCHAR c,int l) { while (l--) *(dest++)=c; }
+// private:
+// Creates an user friendly XML string from a given element with
+// appropriate white space and carriage returns.
+//
+// This recurses through all subnodes then adds contents of the nodes to the
+// string.
+int XMLNode::CreateXMLStringR(XMLNodeData *pEntry, XMLSTR lpszMarker, int nFormat)
+{
+    int nResult = 0;
+    int cb;
+    int cbElement;
+    int nChildFormat=-1;
+    int nElementI=pEntry->nChild+pEntry->nText+pEntry->nClear;
+    int i,j;
+
+    assert(pEntry);
+
+#define LENSTR(lpsz) (lpsz ? xstrlen(lpsz) : 0)
+
+    // If the element has no name then assume this is the head node.
+    cbElement = (int)LENSTR(pEntry->lpszName);
+
+    if (cbElement)
+    {
+        // "<elementname "
+        cb = nFormat == -1 ? 0 : nFormat;
+
+        if (lpszMarker)
+        {
+            if (cb) charmemset(lpszMarker, INDENTCHAR, sizeof(XMLCHAR)*cb);
+            nResult = cb;
+            lpszMarker[nResult++]=_X('<');
+            if (pEntry->isDeclaration) lpszMarker[nResult++]=_X('?');
+            xstrcpy(&lpszMarker[nResult], pEntry->lpszName);
+            nResult+=cbElement;
+            lpszMarker[nResult++]=_X(' ');
+
+        } else
+        {
+            nResult+=cbElement+2+cb;
+            if (pEntry->isDeclaration) nResult++;
+        }
+
+        // Enumerate attributes and add them to the string
+        XMLAttribute *pAttr=pEntry->pAttribute;
+        for (i=0; i<pEntry->nAttribute; i++)
+        {
+            // "Attrib
+            cb = (int)LENSTR(pAttr->lpszName);
+            if (cb)
+            {
+                if (lpszMarker) xstrcpy(&lpszMarker[nResult], pAttr->lpszName);
+                nResult += cb;
+                // "Attrib=Value "
+                if (pAttr->lpszValue)
+                {
+                    cb=(int)lengthXMLString(pAttr->lpszValue);
+                    if (lpszMarker)
+                    {
+                        lpszMarker[nResult]=_X('=');
+                        lpszMarker[nResult+1]=_X('"');
+                        if (cb) toXMLStringUnSafe(&lpszMarker[nResult+2],pAttr->lpszValue);
+                        lpszMarker[nResult+cb+2]=_X('"');
+                    }
+                    nResult+=cb+3;
+                }
+                if (lpszMarker) lpszMarker[nResult] = _X(' ');
+                nResult++;
+            }
+            pAttr++;
+        }
+
+        if (pEntry->isDeclaration)
+        {
+            if (lpszMarker)
+            {
+                lpszMarker[nResult-1]=_X('?');
+                lpszMarker[nResult]=_X('>');
+            }
+            nResult++;
+            if (nFormat!=-1)
+            {
+                if (lpszMarker) lpszMarker[nResult]=_X('\n');
+                nResult++;
+            }
+        } else
+            // If there are child nodes we need to terminate the start tag
+            if (nElementI)
+            {
+                if (lpszMarker) lpszMarker[nResult-1]=_X('>');
+                if (nFormat!=-1)
+                {
+                    if (lpszMarker) lpszMarker[nResult]=_X('\n');
+                    nResult++;
+                }
+            } else nResult--;
+    }
+
+    // Calculate the child format for when we recurse.  This is used to
+    // determine the number of spaces used for prefixes.
+    if (nFormat!=-1)
+    {
+        if (cbElement&&(!pEntry->isDeclaration)) nChildFormat=nFormat+1;
+        else nChildFormat=nFormat;
+    }
+
+    // Enumerate through remaining children
+    for (i=0; i<nElementI; i++)
+    {
+        j=pEntry->pOrder[i];
+        switch((XMLElementType)(j&3))
+        {
+        // Text nodes
+        case eNodeText:
+            {
+                // "Text"
+                XMLCSTR pChild=pEntry->pText[j>>2];
+                cb = (int)lengthXMLString(pChild);
+                if (cb)
+                {
+                    if (nFormat!=-1)
+                    {
+                        if (lpszMarker)
+                        {
+                            charmemset(&lpszMarker[nResult],INDENTCHAR,sizeof(XMLCHAR)*(nFormat + 1));
+                            toXMLStringUnSafe(&lpszMarker[nResult+nFormat+1],pChild);
+                            lpszMarker[nResult+nFormat+1+cb]=_X('\n');
+                        }
+                        nResult+=cb+nFormat+2;
+                    } else
+                    {
+                        if (lpszMarker) toXMLStringUnSafe(&lpszMarker[nResult], pChild);
+                        nResult += cb;
+                    }
+                }
+                break;
+            }
+
+        // Clear type nodes
+        case eNodeClear:
+            {
+                XMLClear *pChild=pEntry->pClear+(j>>2);
+                // "OpenTag"
+                cb = (int)LENSTR(pChild->lpszOpenTag);
+                if (cb)
+                {
+                    if (nFormat!=-1)
+                    {
+                        if (lpszMarker)
+                        {
+                            charmemset(&lpszMarker[nResult], INDENTCHAR, sizeof(XMLCHAR)*(nFormat + 1));
+                            xstrcpy(&lpszMarker[nResult+nFormat+1], pChild->lpszOpenTag);
+                        }
+                        nResult+=cb+nFormat+1;
+                    }
+                    else
+                    {
+                        if (lpszMarker)xstrcpy(&lpszMarker[nResult], pChild->lpszOpenTag);
+                        nResult += cb;
+                    }
+                }
+
+                // "OpenTag Value"
+                cb = (int)LENSTR(pChild->lpszValue);
+                if (cb)
+                {
+                    if (lpszMarker) xstrcpy(&lpszMarker[nResult], pChild->lpszValue);
+                    nResult += cb;
+                }
+
+                // "OpenTag Value CloseTag"
+                cb = (int)LENSTR(pChild->lpszCloseTag);
+                if (cb)
+                {
+                    if (lpszMarker) xstrcpy(&lpszMarker[nResult], pChild->lpszCloseTag);
+                    nResult += cb;
+                }
+
+                if (nFormat!=-1)
+                {
+                    if (lpszMarker) lpszMarker[nResult] = _X('\n');
+                    nResult++;
+                }
+                break;
+            }
+
+        // Element nodes
+        case eNodeChild:
+            {
+                // Recursively add child nodes
+                nResult += CreateXMLStringR(pEntry->pChild[j>>2].d, lpszMarker ? lpszMarker + nResult : 0, nChildFormat);
+                break;
+            }
+        default: break;
+        }
+    }
+
+    if ((cbElement)&&(!pEntry->isDeclaration))
+    {
+        // If we have child entries we need to use long XML notation for
+        // closing the element - "<elementname>blah blah blah</elementname>"
+        if (nElementI)
+        {
+            // "</elementname>\0"
+            if (lpszMarker)
+            {
+                if (nFormat != -1)
+                {
+                    if (nFormat)
+                    {
+                        charmemset(&lpszMarker[nResult], INDENTCHAR,sizeof(XMLCHAR)*nFormat);
+                        nResult+=nFormat;
+                    }
+                }
+
+                xstrcpy(&lpszMarker[nResult], _X("</"));
+                nResult += 2;
+                xstrcpy(&lpszMarker[nResult], pEntry->lpszName);
+                nResult += cbElement;
+
+                if (nFormat == -1)
+                {
+                    xstrcpy(&lpszMarker[nResult], _X(">"));
+                    nResult++;
+                } else
+                {
+                    xstrcpy(&lpszMarker[nResult], _X(">\n"));
+                    nResult+=2;
+                }
+            } else
+            {
+                if (nFormat != -1) nResult+=cbElement+4+nFormat;
+                else nResult+=cbElement+3;
+            }
+        } else
+        {
+            // If there are no children we can use shorthand XML notation -
+            // "<elementname/>"
+            // "/>\0"
+            if (lpszMarker)
+            {
+                if (nFormat == -1)
+                {
+                    xstrcpy(&lpszMarker[nResult], _X("/>"));
+                    nResult += 2;
+                }
+                else
+                {
+                    xstrcpy(&lpszMarker[nResult], _X("/>\n"));
+                    nResult += 3;
+                }
+            }
+            else
+            {
+                nResult += nFormat == -1 ? 2 : 3;
+            }
+        }
+    }
+
+    return nResult;
+}
+
+#undef LENSTR
+
+// Create an XML string
+// @param       int nFormat             - 0 if no formatting is required
+//                                        otherwise nonzero for formatted text
+//                                        with carriage returns and indentation.
+// @param       int *pnSize             - [out] pointer to the size of the
+//                                        returned string not including the
+//                                        NULL terminator.
+// @return      XMLSTR                  - Allocated XML string, you must free
+//                                        this with free().
+XMLSTR XMLNode::createXMLString(int nFormat, int *pnSize) const
+{
+    if (!d) { if (pnSize) *pnSize=0; return NULL; }
+
+    XMLSTR lpszResult = NULL;
+    int cbStr;
+
+    // Recursively Calculate the size of the XML string
+    if (!dropWhiteSpace) nFormat=0;
+    nFormat = nFormat ? 0 : -1;
+    cbStr = CreateXMLStringR(d, 0, nFormat);
+    assert(cbStr);
+    // Alllocate memory for the XML string + the NULL terminator and
+    // create the recursively XML string.
+    lpszResult=(XMLSTR)malloc((cbStr+1)*sizeof(XMLCHAR));
+    CreateXMLStringR(d, lpszResult, nFormat);
+    if (pnSize) *pnSize = cbStr;
+    return lpszResult;
+}
+
+int XMLNode::detachFromParent(XMLNodeData *d)
+{
+    XMLNode *pa=d->pParent->pChild;
+    int i=0;
+    while (((void*)(pa[i].d))!=((void*)d)) i++;
+    d->pParent->nChild--;
+    if (d->pParent->nChild) memmove(pa+i,pa+i+1,(d->pParent->nChild-i)*sizeof(XMLNode));
+    else { free(pa); d->pParent->pChild=NULL; }
+    return removeOrderElement(d->pParent,eNodeChild,i);
+}
+
+XMLNode::~XMLNode() { deleteNodeContent_priv(1,0); }
+void XMLNode::deleteNodeContent(){ deleteNodeContent_priv(0,1); }
+void XMLNode::deleteNodeContent_priv(char isInDestuctor, char force)
+{
+    if (!d) return;
+    if (isInDestuctor) (d->ref_count)--;
+    if ((d->ref_count==0)||force)
+    {
+        int i;
+        if (d->pParent) detachFromParent(d);
+        for(i=0; i<d->nChild; i++) { d->pChild[i].d->pParent=NULL; d->pChild[i].deleteNodeContent_priv(1,force); }
+        myFree(d->pChild);
+        for(i=0; i<d->nText; i++) free((void*)d->pText[i]);
+        myFree(d->pText);
+        for(i=0; i<d->nClear; i++) free((void*)d->pClear[i].lpszValue);
+        myFree(d->pClear);
+        for(i=0; i<d->nAttribute; i++)
+        {
+            free((void*)d->pAttribute[i].lpszName);
+            if (d->pAttribute[i].lpszValue) free((void*)d->pAttribute[i].lpszValue);
+        }
+        myFree(d->pAttribute);
+        myFree(d->pOrder);
+        myFree((void*)d->lpszName);
+        d->nChild=0;    d->nText=0;    d->nClear=0;    d->nAttribute=0;
+        d->pChild=NULL; d->pText=NULL; d->pClear=NULL; d->pAttribute=NULL;
+        d->pOrder=NULL; d->lpszName=NULL; d->pParent=NULL;
+    }
+    if (d->ref_count==0)
+    {
+        free(d);
+        d=NULL;
+    }
+}
+
+XMLNode XMLNode::deepCopy() const
+{
+    if (!d) return XMLNode::emptyXMLNode;
+    XMLNode x(NULL,stringDup(d->lpszName),d->isDeclaration);
+    XMLNodeData *p=x.d;
+    int n=d->nAttribute;
+    if (n)
+    {
+        p->nAttribute=n; p->pAttribute=(XMLAttribute*)malloc(n*sizeof(XMLAttribute));
+        while (n--)
+        {
+            p->pAttribute[n].lpszName=stringDup(d->pAttribute[n].lpszName);
+            p->pAttribute[n].lpszValue=stringDup(d->pAttribute[n].lpszValue);
+        }
+    }
+    if (d->pOrder)
+    {
+        n=(d->nChild+d->nText+d->nClear)*sizeof(int); p->pOrder=(int*)malloc(n); memcpy(p->pOrder,d->pOrder,n);
+    }
+    n=d->nText;
+    if (n)
+    {
+        p->nText=n; p->pText=(XMLCSTR*)malloc(n*sizeof(XMLCSTR));
+        while(n--) p->pText[n]=stringDup(d->pText[n]);
+    }
+    n=d->nClear;
+    if (n)
+    {
+        p->nClear=n; p->pClear=(XMLClear*)malloc(n*sizeof(XMLClear));
+        while (n--)
+        {
+            p->pClear[n].lpszCloseTag=d->pClear[n].lpszCloseTag;
+            p->pClear[n].lpszOpenTag=d->pClear[n].lpszOpenTag;
+            p->pClear[n].lpszValue=stringDup(d->pClear[n].lpszValue);
+        }
+    }
+    n=d->nChild;
+    if (n)
+    {
+        p->nChild=n; p->pChild=(XMLNode*)malloc(n*sizeof(XMLNode));
+        while (n--)
+        {
+            p->pChild[n].d=NULL;
+            p->pChild[n]=d->pChild[n].deepCopy();
+            p->pChild[n].d->pParent=p;
+        }
+    }
+    return x;
+}
+
+XMLNode XMLNode::addChild(XMLNode childNode, int pos)
+{
+    XMLNodeData *dc=childNode.d;
+    if ((!dc)||(!d)) return childNode;
+    if (dc->pParent) { if ((detachFromParent(dc)<=pos)&&(dc->pParent==d)) pos--; } else dc->ref_count++;
+    dc->pParent=d;
+//     int nc=d->nChild;
+//     d->pChild=(XMLNode*)myRealloc(d->pChild,(nc+1),memoryIncrease,sizeof(XMLNode));
+    d->pChild=(XMLNode*)addToOrder(0,&pos,d->nChild,d->pChild,sizeof(XMLNode),eNodeChild);
+    d->pChild[pos].d=dc;
+    d->nChild++;
+    return childNode;
+}
+
+void XMLNode::deleteAttribute(int i)
+{
+    if ((!d)||(i<0)||(i>=d->nAttribute)) return;
+    d->nAttribute--;
+    XMLAttribute *p=d->pAttribute+i;
+    free((void*)p->lpszName);
+    if (p->lpszValue) free((void*)p->lpszValue);
+    if (d->nAttribute) memmove(p,p+1,(d->nAttribute-i)*sizeof(XMLAttribute)); else { free(p); d->pAttribute=NULL; }
+}
+
+void XMLNode::deleteAttribute(XMLAttribute *a){ if (a) deleteAttribute(a->lpszName); }
+void XMLNode::deleteAttribute(XMLCSTR lpszName)
+{
+    int j=0;
+    getAttribute(lpszName,&j);
+    if (j) deleteAttribute(j-1);
+}
+
+XMLAttribute *XMLNode::updateAttribute_WOSD(XMLSTR lpszNewValue, XMLSTR lpszNewName,int i)
+{
+    if (!d) { if (lpszNewValue) free(lpszNewValue); if (lpszNewName) free(lpszNewName); return NULL; }
+    if (i>=d->nAttribute)
+    {
+        if (lpszNewName) return addAttribute_WOSD(lpszNewName,lpszNewValue);
+        return NULL;
+    }
+    XMLAttribute *p=d->pAttribute+i;
+    if (p->lpszValue&&p->lpszValue!=lpszNewValue) free((void*)p->lpszValue);
+    p->lpszValue=lpszNewValue;
+    if (lpszNewName&&p->lpszName!=lpszNewName) { free((void*)p->lpszName); p->lpszName=lpszNewName; };
+    return p;
+}
+
+XMLAttribute *XMLNode::updateAttribute_WOSD(XMLAttribute *newAttribute, XMLAttribute *oldAttribute)
+{
+    if (oldAttribute) return updateAttribute_WOSD((XMLSTR)newAttribute->lpszValue,(XMLSTR)newAttribute->lpszName,oldAttribute->lpszName);
+    return addAttribute_WOSD((XMLSTR)newAttribute->lpszName,(XMLSTR)newAttribute->lpszValue);
+}
+
+XMLAttribute *XMLNode::updateAttribute_WOSD(XMLSTR lpszNewValue, XMLSTR lpszNewName,XMLCSTR lpszOldName)
+{
+    int j=0;
+    getAttribute(lpszOldName,&j);
+    if (j) return updateAttribute_WOSD(lpszNewValue,lpszNewName,j-1);
+    else
+    {
+        if (lpszNewName) return addAttribute_WOSD(lpszNewName,lpszNewValue);
+        else             return addAttribute_WOSD(stringDup(lpszOldName),lpszNewValue);
+    }
+}
+
+int XMLNode::indexText(XMLCSTR lpszValue) const
+{
+    if (!d) return -1;
+    int i,l=d->nText;
+    if (!lpszValue) { if (l) return 0; return -1; }
+    XMLCSTR *p=d->pText;
+    for (i=0; i<l; i++) if (lpszValue==p[i]) return i;
+    return -1;
+}
+
+void XMLNode::deleteText(int i)
+{
+    if ((!d)||(i<0)||(i>=d->nText)) return;
+    d->nText--;
+    XMLCSTR *p=d->pText+i;
+    free((void*)*p);
+    if (d->nText) memmove(p,p+1,(d->nText-i)*sizeof(XMLCSTR)); else { free(p); d->pText=NULL; }
+    removeOrderElement(d,eNodeText,i);
+}
+
+void XMLNode::deleteText(XMLCSTR lpszValue) { deleteText(indexText(lpszValue)); }
+
+XMLCSTR XMLNode::updateText_WOSD(XMLSTR lpszNewValue, int i)
+{
+    if (!d) { if (lpszNewValue) free(lpszNewValue); return NULL; }
+    if (i>=d->nText) return addText_WOSD(lpszNewValue);
+    XMLCSTR *p=d->pText+i;
+    if (*p!=lpszNewValue) { free((void*)*p); *p=lpszNewValue; }
+    return lpszNewValue;
+}
+
+XMLCSTR XMLNode::updateText_WOSD(XMLSTR lpszNewValue, XMLCSTR lpszOldValue)
+{
+    if (!d) { if (lpszNewValue) free(lpszNewValue); return NULL; }
+    int i=indexText(lpszOldValue);
+    if (i>=0) return updateText_WOSD(lpszNewValue,i);
+    return addText_WOSD(lpszNewValue);
+}
+
+void XMLNode::deleteClear(int i)
+{
+    if ((!d)||(i<0)||(i>=d->nClear)) return;
+    d->nClear--;
+    XMLClear *p=d->pClear+i;
+    free((void*)p->lpszValue);
+    if (d->nClear) memmove(p,p+1,(d->nClear-i)*sizeof(XMLClear)); else { free(p); d->pClear=NULL; }
+    removeOrderElement(d,eNodeClear,i);
+}
+
+int XMLNode::indexClear(XMLCSTR lpszValue) const
+{
+    if (!d) return -1;
+    int i,l=d->nClear;
+    if (!lpszValue) { if (l) return 0; return -1; }
+    XMLClear *p=d->pClear;
+    for (i=0; i<l; i++) if (lpszValue==p[i].lpszValue) return i;
+    return -1;
+}
+
+void XMLNode::deleteClear(XMLCSTR lpszValue) { deleteClear(indexClear(lpszValue)); }
+void XMLNode::deleteClear(XMLClear *a) { if (a) deleteClear(a->lpszValue); }
+
+XMLClear *XMLNode::updateClear_WOSD(XMLSTR lpszNewContent, int i)
+{
+    if (!d) { if (lpszNewContent) free(lpszNewContent); return NULL; }
+    if (i>=d->nClear) return addClear_WOSD(lpszNewContent);
+    XMLClear *p=d->pClear+i;
+    if (lpszNewContent!=p->lpszValue) { free((void*)p->lpszValue); p->lpszValue=lpszNewContent; }
+    return p;
+}
+
+XMLClear *XMLNode::updateClear_WOSD(XMLSTR lpszNewContent, XMLCSTR lpszOldValue)
+{
+    if (!d) { if (lpszNewContent) free(lpszNewContent); return NULL; }
+    int i=indexClear(lpszOldValue);
+    if (i>=0) return updateClear_WOSD(lpszNewContent,i);
+    return addClear_WOSD(lpszNewContent);
+}
+
+XMLClear *XMLNode::updateClear_WOSD(XMLClear *newP,XMLClear *oldP)
+{
+    if (oldP) return updateClear_WOSD((XMLSTR)newP->lpszValue,(XMLSTR)oldP->lpszValue);
+    return NULL;
+}
+
+XMLNode& XMLNode::operator=( const XMLNode& A )
+{
+    // shallow copy
+    if (this != &A)
+    {
+        deleteNodeContent_priv(1,0);
+        d=A.d;
+        if (d) (d->ref_count) ++ ;
+    }
+    return *this;
+}
+
+XMLNode::XMLNode(const XMLNode &A)
+{
+    // shallow copy
+    d=A.d;
+    if (d) (d->ref_count)++ ;
+}
+
+int XMLNode::nChildNode(XMLCSTR name) const
+{
+    if (!d) return 0;
+    int i,j=0,n=d->nChild;
+    XMLNode *pc=d->pChild;
+    for (i=0; i<n; i++)
+    {
+        if (xstricmp(pc->d->lpszName, name)==0) j++;
+        pc++;
+    }
+    return j;
+}
+
+XMLNode XMLNode::getChildNode(XMLCSTR name, int *j) const
+{
+    if (!d) return emptyXMLNode;
+    int i=0,n=d->nChild;
+    if (j) i=*j;
+    XMLNode *pc=d->pChild+i;
+    for (; i<n; i++)
+    {
+        if (xstricmp(pc->d->lpszName, name)==0)
+        {
+            if (j) *j=i+1;
+            return *pc;
+        }
+        pc++;
+    }
+    return emptyXMLNode;
+}
+
+XMLNode XMLNode::getChildNode(XMLCSTR name, int j) const
+{
+    if (!d) return emptyXMLNode;
+    int i=0;
+    while (j-->0) getChildNode(name,&i);
+    return getChildNode(name,&i);
+}
+
+XMLElementPosition XMLNode::positionOfText     (int i) const { if (i>=d->nText ) i=d->nText-1;  return findPosition(d,i,eNodeText ); }
+XMLElementPosition XMLNode::positionOfClear    (int i) const { if (i>=d->nClear) i=d->nClear-1; return findPosition(d,i,eNodeClear); }
+XMLElementPosition XMLNode::positionOfChildNode(int i) const { if (i>=d->nChild) i=d->nChild-1; return findPosition(d,i,eNodeChild); }
+XMLElementPosition XMLNode::positionOfText (XMLCSTR lpszValue) const { return positionOfText (indexText (lpszValue)); }
+XMLElementPosition XMLNode::positionOfClear(XMLCSTR lpszValue) const { return positionOfClear(indexClear(lpszValue)); }
+XMLElementPosition XMLNode::positionOfClear(XMLClear *a) const { if (a) return positionOfClear(a->lpszValue); return positionOfClear(); }
+XMLElementPosition XMLNode::positionOfChildNode(XMLNode x)  const
+{
+    if ((!d)||(!x.d)) return -1;
+    XMLNodeData *dd=x.d;
+    XMLNode *pc=d->pChild;
+    int i=d->nChild;
+    while (i--) if (pc[i].d==dd) return findPosition(d,i,eNodeChild);
+    return -1;
+}
+XMLElementPosition XMLNode::positionOfChildNode(XMLCSTR name, int count) const
+{
+    if (!name) return positionOfChildNode(count);
+    int j=0;
+    do { getChildNode(name,&j); if (j<0) return -1; } while (count--);
+    return findPosition(d,j-1,eNodeChild);
+}
+
+XMLNode XMLNode::getChildNodeWithAttribute(XMLCSTR name,XMLCSTR attributeName,XMLCSTR attributeValue, int *k) const
+{
+     int i=0,j;
+     if (k) i=*k;
+     XMLNode x;
+     XMLCSTR t;
+     do
+     {
+         x=getChildNode(name,&i);
+         if (!x.isEmpty())
+         {
+             if (attributeValue)
+             {
+                 j=0;
+                 do
+                 {
+                     t=x.getAttribute(attributeName,&j);
+                     if (t&&(xstricmp(attributeValue,t)==0)) { if (k) *k=i+1; return x; }
+                 } while (t);
+             } else
+             {
+                 if (x.isAttributeSet(attributeName)) { if (k) *k=i+1; return x; }
+             }
+         }
+     } while (!x.isEmpty());
+     return emptyXMLNode;
+}
+
+// Find an attribute on an node.
+XMLCSTR XMLNode::getAttribute(XMLCSTR lpszAttrib, int *j) const
+{
+    if (!d) return NULL;
+    int i=0,n=d->nAttribute;
+    if (j) i=*j;
+    XMLAttribute *pAttr=d->pAttribute+i;
+    for (; i<n; i++)
+    {
+        if (xstricmp(pAttr->lpszName, lpszAttrib)==0)
+        {
+            if (j) *j=i+1;
+            return pAttr->lpszValue;
+        }
+        pAttr++;
+    }
+    return NULL;
+}
+
+char XMLNode::isAttributeSet(XMLCSTR lpszAttrib) const
+{
+    if (!d) return FALSE;
+    int i,n=d->nAttribute;
+    XMLAttribute *pAttr=d->pAttribute;
+    for (i=0; i<n; i++)
+    {
+        if (xstricmp(pAttr->lpszName, lpszAttrib)==0)
+        {
+            return TRUE;
+        }
+        pAttr++;
+    }
+    return FALSE;
+}
+
+XMLCSTR XMLNode::getAttribute(XMLCSTR name, int j) const
+{
+    if (!d) return NULL;
+    int i=0;
+    while (j-->0) getAttribute(name,&i);
+    return getAttribute(name,&i);
+}
+
+XMLNodeContents XMLNode::enumContents(int i) const
+{
+    XMLNodeContents c;
+    if (!d) { c.etype=eNodeNULL; return c; }
+    if (i<d->nAttribute)
+    {
+        c.etype=eNodeAttribute;
+        c.attrib=d->pAttribute[i];
+        return c;
+    }
+    i-=d->nAttribute;
+    c.etype=(XMLElementType)(d->pOrder[i]&3);
+    i=(d->pOrder[i])>>2;
+    switch (c.etype)
+    {
+    case eNodeChild:     c.child = d->pChild[i];      break;
+    case eNodeText:      c.text  = d->pText[i];       break;
+    case eNodeClear:     c.clear = d->pClear[i];      break;
+    default: break;
+    }
+    return c;
+}
+
+XMLCSTR XMLNode::getName() const { if (!d) return NULL; return d->lpszName;   }
+int XMLNode::nText()       const { if (!d) return 0;    return d->nText;      }
+int XMLNode::nChildNode()  const { if (!d) return 0;    return d->nChild;     }
+int XMLNode::nAttribute()  const { if (!d) return 0;    return d->nAttribute; }
+int XMLNode::nClear()      const { if (!d) return 0;    return d->nClear;     }
+int XMLNode::nElement()    const { if (!d) return 0;    return d->nAttribute+d->nChild+d->nText+d->nClear; }
+XMLClear     XMLNode::getClear         (int i) const { if ((!d)||(i>=d->nClear    )) return emptyXMLClear;     return d->pClear[i];     }
+XMLAttribute XMLNode::getAttribute     (int i) const { if ((!d)||(i>=d->nAttribute)) return emptyXMLAttribute; return d->pAttribute[i]; }
+XMLCSTR      XMLNode::getAttributeName (int i) const { if ((!d)||(i>=d->nAttribute)) return NULL;              return d->pAttribute[i].lpszName;  }
+XMLCSTR      XMLNode::getAttributeValue(int i) const { if ((!d)||(i>=d->nAttribute)) return NULL;              return d->pAttribute[i].lpszValue; }
+XMLCSTR      XMLNode::getText          (int i) const { if ((!d)||(i>=d->nText     )) return NULL;              return d->pText[i];      }
+XMLNode      XMLNode::getChildNode     (int i) const { if ((!d)||(i>=d->nChild    )) return emptyXMLNode;      return d->pChild[i];     }
+XMLNode      XMLNode::getParentNode    (     ) const { if ((!d)||(!d->pParent     )) return emptyXMLNode;      return XMLNode(d->pParent); }
+char         XMLNode::isDeclaration    (     ) const { if (!d) return 0;             return d->isDeclaration; }
+char         XMLNode::isEmpty          (     ) const { return (d==NULL); }
+XMLNode       XMLNode::emptyNode       (     )       { return XMLNode::emptyXMLNode; }
+
+XMLNode       XMLNode::addChild(XMLCSTR lpszName, char isDeclaration, XMLElementPosition pos)
+              { return addChild_priv(0,stringDup(lpszName),isDeclaration,pos); }
+XMLNode       XMLNode::addChild_WOSD(XMLSTR lpszName, char isDeclaration, XMLElementPosition pos)
+              { return addChild_priv(0,lpszName,isDeclaration,pos); }
+XMLAttribute *XMLNode::addAttribute(XMLCSTR lpszName, XMLCSTR lpszValue)
+              { return addAttribute_priv(0,stringDup(lpszName),stringDup(lpszValue)); }
+XMLAttribute *XMLNode::addAttribute_WOSD(XMLSTR lpszName, XMLSTR lpszValuev)
+              { return addAttribute_priv(0,lpszName,lpszValuev); }
+XMLCSTR       XMLNode::addText(XMLCSTR lpszValue, XMLElementPosition pos)
+              { return addText_priv(0,stringDup(lpszValue),pos); }
+XMLCSTR       XMLNode::addText_WOSD(XMLSTR lpszValue, XMLElementPosition pos)
+              { return addText_priv(0,lpszValue,pos); }
+XMLClear     *XMLNode::addClear(XMLCSTR lpszValue, XMLCSTR lpszOpen, XMLCSTR lpszClose, XMLElementPosition pos)
+              { return addClear_priv(0,stringDup(lpszValue),lpszOpen,lpszClose,pos); }
+XMLClear     *XMLNode::addClear_WOSD(XMLSTR lpszValue, XMLCSTR lpszOpen, XMLCSTR lpszClose, XMLElementPosition pos)
+              { return addClear_priv(0,lpszValue,lpszOpen,lpszClose,pos); }
+XMLCSTR       XMLNode::updateName(XMLCSTR lpszName)
+              { return updateName_WOSD(stringDup(lpszName)); }
+XMLAttribute *XMLNode::updateAttribute(XMLAttribute *newAttribute, XMLAttribute *oldAttribute)
+              { return updateAttribute_WOSD(stringDup(newAttribute->lpszValue),stringDup(newAttribute->lpszName),oldAttribute->lpszName); }
+XMLAttribute *XMLNode::updateAttribute(XMLCSTR lpszNewValue, XMLCSTR lpszNewName,int i)
+              { return updateAttribute_WOSD(stringDup(lpszNewValue),stringDup(lpszNewName),i); }
+XMLAttribute *XMLNode::updateAttribute(XMLCSTR lpszNewValue, XMLCSTR lpszNewName,XMLCSTR lpszOldName)
+              { return updateAttribute_WOSD(stringDup(lpszNewValue),stringDup(lpszNewName),lpszOldName); }
+XMLCSTR       XMLNode::updateText(XMLCSTR lpszNewValue, int i)
+              { return updateText_WOSD(stringDup(lpszNewValue),i); }
+XMLCSTR       XMLNode::updateText(XMLCSTR lpszNewValue, XMLCSTR lpszOldValue)
+              { return updateText_WOSD(stringDup(lpszNewValue),lpszOldValue); }
+XMLClear     *XMLNode::updateClear(XMLCSTR lpszNewContent, int i)
+              { return updateClear_WOSD(stringDup(lpszNewContent),i); }
+XMLClear     *XMLNode::updateClear(XMLCSTR lpszNewValue, XMLCSTR lpszOldValue)
+              { return updateClear_WOSD(stringDup(lpszNewValue),lpszOldValue); }
+XMLClear     *XMLNode::updateClear(XMLClear *newP,XMLClear *oldP)
+              { return updateClear_WOSD(stringDup(newP->lpszValue),oldP->lpszValue); }
+
+char XMLNode::setGlobalOptions(XMLCharEncoding _characterEncoding, char _guessWideCharChars, char _dropWhiteSpace)
+{
+    guessWideCharChars=_guessWideCharChars; dropWhiteSpace=_dropWhiteSpace;
+#ifdef _XMLWIDECHAR
+    if (_characterEncoding) characterEncoding=_characterEncoding;
+#else
+    switch(_characterEncoding)
+    {
+    case encoding_UTF8:     characterEncoding=_characterEncoding; XML_ByteTable=XML_utf8ByteTable; break;
+    case encoding_ascii:    characterEncoding=_characterEncoding; XML_ByteTable=XML_asciiByteTable; break;
+    case encoding_ShiftJIS: characterEncoding=_characterEncoding; XML_ByteTable=XML_sjisByteTable; break;
+    default: return 1;
+    }
+#endif
+    return 0;
+}
+
+XMLNode::XMLCharEncoding XMLNode::guessCharEncoding(void *buf,int l, char useXMLEncodingAttribute)
+{
+#ifdef _XMLWIDECHAR
+    return (XMLCharEncoding)0;
+#else
+    if (l<25) return (XMLCharEncoding)0;
+    if (guessWideCharChars&&(myIsTextWideChar(buf,l))) return (XMLCharEncoding)0;
+    unsigned char *b=(unsigned char*)buf;
+    if ((b[0]==0xef)&&(b[1]==0xbb)&&(b[2]==0xbf)) return encoding_UTF8;
+
+    // Match utf-8 model ?
+    XMLCharEncoding bestGuess=encoding_UTF8;
+    int i=0;
+    while (i<l)
+        switch (XML_utf8ByteTable[b[i]])
+        {
+        case 4: i++; if ((i<l)&&(b[i]& 0xC0)!=0x80) { bestGuess=encoding_ascii; i=l; } // 10bbbbbb ?
+        case 3: i++; if ((i<l)&&(b[i]& 0xC0)!=0x80) { bestGuess=encoding_ascii; i=l; } // 10bbbbbb ?
+        case 2: i++; if ((i<l)&&(b[i]& 0xC0)!=0x80) { bestGuess=encoding_ascii; i=l; } // 10bbbbbb ?
+        case 1: i++; break;
+        case 0: i=l;
+        }
+    if (!useXMLEncodingAttribute) return bestGuess;
+    // if encoding is specified and different from utf-8 than it's non-utf8
+    // otherwise it's utf-8
+    char bb[201];
+    l=mmin(l,200);
+    memcpy(bb,buf,l); // copy buf into bb to be able to do "bb[l]=0"
+    bb[l]=0;
+    b=(unsigned char*)strstr(bb,"encoding");
+    if (!b) return bestGuess;
+    b+=8; while XML_isSPACECHAR(*b) b++; if (*b!='=') return bestGuess;
+    b++;  while XML_isSPACECHAR(*b) b++; if ((*b!='\'')&&(*b!='"')) return bestGuess;
+    b++;  while XML_isSPACECHAR(*b) b++;
+
+    if ((_strnicmp((char*)b,"utf-8",5)==0)||
+        (_strnicmp((char*)b,"utf8",4)==0))
+    {
+        if (bestGuess==encoding_ascii) return (XMLCharEncoding)0;
+        return encoding_UTF8;
+    }
+
+    if ((_strnicmp((char*)b,"shiftjis",8)==0)||
+        (_strnicmp((char*)b,"shift-jis",9)==0)||
+        (_strnicmp((char*)b,"sjis",4)==0)) return encoding_ShiftJIS;
+
+    return encoding_ascii;
+#endif
+}
+#undef XML_isSPACECHAR
+
+//////////////////////////////////////////////////////////
+//      Here starts the base64 conversion functions.    //
+//////////////////////////////////////////////////////////
+
+static const char base64Fillchar = _X('='); // used to mark partial words at the end
+
+// this lookup table defines the base64 encoding
+XMLCSTR base64EncodeTable=_X("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/");
+
+// Decode Table gives the index of any valid base64 character in the Base64 table]
+// 96: '='  -   97: space char   -   98: illegal char   -   99: end of string
+const unsigned char base64DecodeTable[] = {
+    99,98,98,98,98,98,98,98,98,97,  97,98,98,97,98,98,98,98,98,98,  98,98,98,98,98,98,98,98,98,98,  //00 -29
+    98,98,97,98,98,98,98,98,98,98,  98,98,98,62,98,98,98,63,52,53,  54,55,56,57,58,59,60,61,98,98,  //30 -59
+    98,96,98,98,98, 0, 1, 2, 3, 4,   5, 6, 7, 8, 9,10,11,12,13,14,  15,16,17,18,19,20,21,22,23,24,  //60 -89
+    25,98,98,98,98,98,98,26,27,28,  29,30,31,32,33,34,35,36,37,38,  39,40,41,42,43,44,45,46,47,48,  //90 -119
+    49,50,51,98,98,98,98,98,98,98,  98,98,98,98,98,98,98,98,98,98,  98,98,98,98,98,98,98,98,98,98,  //120 -149
+    98,98,98,98,98,98,98,98,98,98,  98,98,98,98,98,98,98,98,98,98,  98,98,98,98,98,98,98,98,98,98,  //150 -179
+    98,98,98,98,98,98,98,98,98,98,  98,98,98,98,98,98,98,98,98,98,  98,98,98,98,98,98,98,98,98,98,  //180 -209
+    98,98,98,98,98,98,98,98,98,98,  98,98,98,98,98,98,98,98,98,98,  98,98,98,98,98,98,98,98,98,98,  //210 -239
+    98,98,98,98,98,98,98,98,98,98,  98,98,98,98,98,98                                               //240 -255
+};
+
+XMLParserBase64Tool::~XMLParserBase64Tool(){ freeBuffer(); }
+
+void XMLParserBase64Tool::freeBuffer(){ if (buf) free(buf); buf=NULL; buflen=0; }
+
+int XMLParserBase64Tool::encodeLength(int inlen, char formatted)
+{
+    unsigned int i=((inlen-1)/3*4+4+1);
+    if (formatted) i+=inlen/54;
+    return i;
+}
+
+XMLSTR XMLParserBase64Tool::encode(unsigned char *inbuf, unsigned int inlen, char formatted)
+{
+    int i=encodeLength(inlen,formatted),k=17,eLen=inlen/3,j;
+    alloc(i*sizeof(XMLCHAR));
+    XMLSTR curr=(XMLSTR)buf;
+    for(i=0;i<eLen;i++)
+    {
+        // Copy next three bytes into lower 24 bits of int, paying attention to sign.
+        j=(inbuf[0]<<16)|(inbuf[1]<<8)|inbuf[2]; inbuf+=3;
+        // Encode the int into four chars
+        *(curr++)=base64EncodeTable[ j>>18      ];
+        *(curr++)=base64EncodeTable[(j>>12)&0x3f];
+        *(curr++)=base64EncodeTable[(j>> 6)&0x3f];
+        *(curr++)=base64EncodeTable[(j    )&0x3f];
+        if (formatted) { if (!k) { *(curr++)=_X('\n'); k=18; } k--; }
+    }
+    eLen=inlen-eLen*3; // 0 - 2.
+    if (eLen==1)
+    {
+        *(curr++)=base64EncodeTable[ inbuf[0]>>2      ];
+        *(curr++)=base64EncodeTable[(inbuf[0]<<4)&0x3F];
+        *(curr++)=base64Fillchar;
+        *(curr++)=base64Fillchar;
+    } else if (eLen==2)
+    {
+        j=(inbuf[0]<<8)|inbuf[1];
+        *(curr++)=base64EncodeTable[ j>>10      ];
+        *(curr++)=base64EncodeTable[(j>> 4)&0x3f];
+        *(curr++)=base64EncodeTable[(j<< 2)&0x3f];
+        *(curr++)=base64Fillchar;
+    }
+    *(curr++)=0;
+    return (XMLSTR)buf;
+}
+
+unsigned int XMLParserBase64Tool::decodeSize(XMLCSTR data,XMLError *xe)
+{
+     if (xe) *xe=eXMLErrorNone;
+    int size=0;
+    unsigned char c;
+    //skip any extra characters (e.g. newlines or spaces)
+    while (*data)
+    {
+#ifdef _XMLWIDECHAR
+        if (*data>255) { if (xe) *xe=eXMLErrorBase64DecodeIllegalCharacter; return 0; }
+#endif
+        c=base64DecodeTable[(unsigned char)(*data)];
+        if (c<97) size++;
+        else if (c==98) { if (xe) *xe=eXMLErrorBase64DecodeIllegalCharacter; return 0; }
+        data++;
+    }
+    if (xe&&(size%4!=0)) *xe=eXMLErrorBase64DataSizeIsNotMultipleOf4;
+    if (size==0) return 0;
+    do { data--; size--; } while(*data==base64Fillchar); size++;
+    return (unsigned int)((size*3)/4);
+}
+
+unsigned char XMLParserBase64Tool::decode(XMLCSTR data, unsigned char *buf, int len, XMLError *xe)
+{
+    if (xe) *xe=eXMLErrorNone;
+    int i=0,p=0;
+    unsigned char d,c;
+    for(;;)
+    {
+
+#ifdef _XMLWIDECHAR
+#define BASE64DECODE_READ_NEXT_CHAR(c)                                              \
+        do {                                                                        \
+            if (data[i]>255){ c=98; break; }                                        \
+            c=base64DecodeTable[(unsigned char)data[i++]];                       \
+        }while (c==97);                                                             \
+        if(c==98){ if(xe)*xe=eXMLErrorBase64DecodeIllegalCharacter; return 0; }
+#else
+#define BASE64DECODE_READ_NEXT_CHAR(c)                                           \
+        do { c=base64DecodeTable[(unsigned char)data[i++]]; }while (c==97);   \
+        if(c==98){ if(xe)*xe=eXMLErrorBase64DecodeIllegalCharacter; return 0; }
+#endif
+
+        BASE64DECODE_READ_NEXT_CHAR(c)
+        if (c==99) { return 2; }
+        if (c==96)
+        {
+            if (p==(int)len) return 2;
+            if (xe) *xe=eXMLErrorBase64DecodeTruncatedData;
+            return 1;
+        }
+
+        BASE64DECODE_READ_NEXT_CHAR(d)
+        if ((d==99)||(d==96)) { if (xe) *xe=eXMLErrorBase64DecodeTruncatedData;  return 1; }
+        if (p==(int)len) {      if (xe) *xe=eXMLErrorBase64DecodeBufferTooSmall; return 0; }
+        buf[p++]=(unsigned char)((c<<2)|((d>>4)&0x3));
+
+        BASE64DECODE_READ_NEXT_CHAR(c)
+        if (c==99) { if (xe) *xe=eXMLErrorBase64DecodeTruncatedData;  return 1; }
+        if (p==(int)len)
+        {
+            if (c==96) return 2;
+            if (xe) *xe=eXMLErrorBase64DecodeBufferTooSmall;
+            return 0;
+        }
+        if (c==96) { if (xe) *xe=eXMLErrorBase64DecodeTruncatedData;  return 1; }
+        buf[p++]=(unsigned char)(((d<<4)&0xf0)|((c>>2)&0xf));
+
+        BASE64DECODE_READ_NEXT_CHAR(d)
+        if (d==99 ) { if (xe) *xe=eXMLErrorBase64DecodeTruncatedData;  return 1; }
+        if (p==(int)len)
+        {
+            if (d==96) return 2;
+            if (xe) *xe=eXMLErrorBase64DecodeBufferTooSmall;
+            return 0;
+        }
+        if (d==96) { if (xe) *xe=eXMLErrorBase64DecodeTruncatedData;  return 1; }
+        buf[p++]=(unsigned char)(((c<<6)&0xc0)|d);
+    }
+}
+#undef BASE64DECODE_READ_NEXT_CHAR
+
+void XMLParserBase64Tool::alloc(int newsize)
+{
+    if ((!buf)&&(newsize)) { buf=malloc(newsize); buflen=newsize; return; }
+    if (newsize>buflen) { buf=realloc(buf,newsize); buflen=newsize; }
+}
+
+unsigned char *XMLParserBase64Tool::decode(XMLCSTR data, int *outlen, XMLError *xe)
+{
+    if (xe) *xe=eXMLErrorNone;
+    unsigned int len=decodeSize(data,xe);
+    if (outlen) *outlen=len;
+    if (!len) return NULL;
+    alloc(len+1);
+    if(!decode(data,(unsigned char*)buf,len,xe)){ return NULL; }
+    return (unsigned char*)buf;
+}
+
Index: code/trunk/src/xml/xmlParser.h
===================================================================
--- code/trunk/src/xml/xmlParser.h	(revision 164)
+++ code/trunk/src/xml/xmlParser.h	(revision 164)
@@ -0,0 +1,554 @@
+/**
+ ****************************************************************************
+ * <P> XML.c - implementation file for basic XML parser written in ANSI C++
+ * for portability. It works by using recursion and a node tree for breaking
+ * down the elements of an XML document.  </P>
+ *
+ * @version     V2.33
+ * @author      Frank Vanden Berghen
+ *
+ * BSD license:
+ * Copyright (c) 2002, Frank Vanden Berghen
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the Frank Vanden Berghen nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ ****************************************************************************
+ */
+#ifndef __INCLUDE_XML_NODE__
+#define __INCLUDE_XML_NODE__
+
+#include <stdlib.h>
+
+#ifdef _UNICODE
+// If you comment the next "define" line then the library will never "switch to" _UNICODE (wchar_t*) mode (16/32 bits per characters).
+// This is useful when you get error messages like:
+//    'XMLNode::openFileHelper' : cannot convert parameter 2 from 'const char [5]' to 'const wchar_t *'
+// The _XMLWIDECHAR preprocessor variable force the XMLParser library into either utf16/32-mode (the proprocessor variable
+// must be defined) or utf8-mode(the pre-processor variable must be undefined).
+#define _XMLWIDECHAR
+#endif
+
+#if defined(WIN32) || defined(UNDER_CE)
+// comment the next line if you are under windows and the compiler is not Microsoft Visual Studio (6.0 or .NET)
+#define _XMLWINDOWS
+#endif
+
+#ifdef XMLDLLENTRY
+#undef XMLDLLENTRY
+#endif
+#ifdef _USE_XMLPARSER_DLL
+#ifdef _DLL_EXPORTS_
+#define XMLDLLENTRY __declspec(dllexport)
+#else
+#define XMLDLLENTRY __declspec(dllimport)
+#endif
+#else
+#define XMLDLLENTRY
+#endif
+
+// uncomment the next line if you want no support for wchar_t* (no need for the <wchar.h> or <tchar.h> libraries anymore to compile)
+//#define XML_NO_WIDE_CHAR
+
+#ifdef XML_NO_WIDE_CHAR
+#undef _XMLWINDOWS
+#undef _XMLWIDECHAR
+#endif
+
+#ifdef _XMLWINDOWS
+#include <tchar.h>
+#else
+#define XMLDLLENTRY
+#ifndef XML_NO_WIDE_CHAR
+#include <wchar.h> // to have 'wcsrtombs' for ANSI version
+                   // to have 'mbsrtowcs' for WIDECHAR version
+#endif
+#endif
+
+// Some common types for char set portable code
+#ifdef _XMLWIDECHAR
+    #ifndef _X
+        #define _X(c) L ## c
+    #endif
+    #define XMLCSTR const wchar_t *
+    #define XMLSTR  wchar_t *
+    #define XMLCHAR wchar_t
+#else
+    #ifndef _X
+        #define _X(c) c
+    #endif
+    #define XMLCSTR const char *
+    #define XMLSTR  char *
+    #define XMLCHAR char
+#endif
+#ifndef FALSE
+    #define FALSE 0
+#endif /* FALSE */
+#ifndef TRUE
+    #define TRUE 1
+#endif /* TRUE */
+
+
+// Enumeration for XML parse errors.
+typedef enum XMLError
+{
+    eXMLErrorNone = 0,
+    eXMLErrorMissingEndTag,
+    eXMLErrorNoXMLTagFound,
+    eXMLErrorEmpty,
+    eXMLErrorMissingTagName,
+    eXMLErrorMissingEndTagName,
+    eXMLErrorUnmatchedEndTag,
+    eXMLErrorUnmatchedEndClearTag,
+    eXMLErrorUnexpectedToken,
+    eXMLErrorNoElements,
+    eXMLErrorFileNotFound,
+    eXMLErrorFirstTagNotFound,
+    eXMLErrorUnknownCharacterEntity,
+    eXMLErrorCharConversionError,
+    eXMLErrorCannotOpenWriteFile,
+    eXMLErrorCannotWriteFile,
+
+    eXMLErrorBase64DataSizeIsNotMultipleOf4,
+    eXMLErrorBase64DecodeIllegalCharacter,
+    eXMLErrorBase64DecodeTruncatedData,
+    eXMLErrorBase64DecodeBufferTooSmall
+} XMLError;
+
+
+// Enumeration used to manage type of data. Use in conjunction with structure XMLNodeContents
+typedef enum XMLElementType
+{
+    eNodeChild=0,
+    eNodeAttribute=1,
+    eNodeText=2,
+    eNodeClear=3,
+    eNodeNULL=4
+} XMLElementType;
+
+// Structure used to obtain error details if the parse fails.
+typedef struct XMLResults
+{
+    enum XMLError error;
+    int  nLine,nColumn;
+} XMLResults;
+
+// Structure for XML clear (unformatted) node (usually comments)
+typedef struct XMLClear {
+    XMLCSTR lpszValue; XMLCSTR lpszOpenTag; XMLCSTR lpszCloseTag;
+} XMLClear;
+
+// Structure for XML attribute.
+typedef struct XMLAttribute {
+    XMLCSTR lpszName; XMLCSTR lpszValue;
+} XMLAttribute;
+
+// XMLElementPosition are not interchangeable with simple indexes
+typedef int XMLElementPosition;
+
+struct XMLNodeContents;
+
+typedef struct XMLDLLENTRY XMLNode
+{
+  private:
+
+    struct XMLNodeDataTag;
+
+    // protected constructors: use one of these four methods to get your first instance of XMLNode:
+    //  - parseString
+    //  - parseFile
+    //  - openFileHelper
+    //  - createXMLTopNode
+    XMLNode(struct XMLNodeDataTag *pParent, XMLSTR lpszName, char isDeclaration);
+    XMLNode(struct XMLNodeDataTag *p);
+
+  public:
+
+    // You can create your first instance of XMLNode with these 4 functions:
+    // (see complete explanation of parameters below)
+
+    static XMLNode createXMLTopNode(XMLCSTR lpszName, char isDeclaration=FALSE);
+    static XMLNode parseString   (XMLCSTR  lpXMLString, XMLCSTR tag=NULL, XMLResults *pResults=NULL);
+    static XMLNode parseFile     (XMLCSTR     filename, XMLCSTR tag=NULL, XMLResults *pResults=NULL);
+    static XMLNode openFileHelper(XMLCSTR     filename, XMLCSTR tag=NULL                           );
+
+    // The tag parameter should be the name of the first tag inside the XML file.
+    // If the tag parameter is omitted, the 3 functions return a node that represents
+    // the head of the xml document including the declaration term (<? ... ?>).
+
+    // The "openFileHelper" reports to the screen all the warnings & errors that occurred during
+    // parsing of the XML file. Since each application has its own way to report and deal with errors,
+    // you should rather use the "parseFile" function to parse XML files and program yourself thereafter
+    // an "error reporting" tailored for your needs (instead of using the very crude "error reporting"
+    // mechanism included inside the "openFileHelper" function).
+
+    // If the XML document is corrupted:
+    //   * The "openFileHelper" method will:
+    //         - display an error message on the console (or inside a messageBox for windows).
+    //         - stop execution (exit).
+    //     I suggest that you write your own "openFileHelper" method tailored to your needs.
+    //   * The 2 other methods will initialize the "pResults" variable with some information that
+    //     can be used to trace the error.
+    //   * If you still want to parse the file, you can use the APPROXIMATE_PARSING option as
+    //     explained inside the note at the beginning of the "xmlParser.cpp" file.
+    // You can have a user-friendly explanation of the parsing error with this function:
+    static XMLCSTR getError(XMLError error);
+    static XMLCSTR getVersion();
+
+    XMLCSTR getName() const;                                         // name of the node
+    XMLCSTR getText(int i=0) const;                                  // return ith text field
+    int nText() const;                                               // nbr of text field
+    XMLNode getParentNode() const;                                   // return the parent node
+    XMLNode getChildNode(int i=0) const;                             // return ith child node
+    XMLNode getChildNode(XMLCSTR name, int i)  const;                // return ith child node with specific name
+                                                                     //     (return an empty node if failing)
+    XMLNode getChildNode(XMLCSTR name, int *i=NULL) const;           // return next child node with specific name
+                                                                     //     (return an empty node if failing)
+    XMLNode getChildNodeWithAttribute(XMLCSTR tagName,               // return child node with specific name/attribute
+                                      XMLCSTR attributeName,         //     (return an empty node if failing)
+                                      XMLCSTR attributeValue=NULL,   //
+                                      int *i=NULL)  const;           //
+    int nChildNode(XMLCSTR name) const;                              // return the number of child node with specific name
+    int nChildNode() const;                                          // nbr of child node
+    XMLAttribute getAttribute(int i=0) const;                        // return ith attribute
+    XMLCSTR      getAttributeName(int i=0) const;                    // return ith attribute name
+    XMLCSTR      getAttributeValue(int i=0) const;                   // return ith attribute value
+    char  isAttributeSet(XMLCSTR name) const;                        // test if an attribute with a specific name is given
+    XMLCSTR getAttribute(XMLCSTR name, int i) const;                 // return ith attribute content with specific name
+                                                                     //     (return a NULL if failing)
+    XMLCSTR getAttribute(XMLCSTR name, int *i=NULL) const;           // return next attribute content with specific name
+                                                                     //     (return a NULL if failing)
+    int nAttribute() const;                                          // nbr of attribute
+    XMLClear getClear(int i=0) const;                                // return ith clear field (comments)
+    int nClear() const;                                              // nbr of clear field
+    XMLSTR createXMLString(int nFormat=1, int *pnSize=NULL) const;   // create XML string starting from current XMLNode
+                                                                     // if nFormat==0, no formatting is required
+                                                                     // otherwise this returns an user friendly XML string from a
+                                                                     // given element with appropriate white spaces and carriage returns.
+                                                                     // if pnSize is given it returns the size in character of the string.
+    XMLError writeToFile(XMLCSTR filename, const char *encoding=NULL, char nFormat=1) const;
+                                                                     // Save the content of an xmlNode inside a file.
+                                                                     // The nFormat parameter has the same meaning as in the
+                                                                     // createXMLString function. If the global parameter
+                                                                     // "characterEncoding==encoding_UTF8", then the "encoding" parameter is
+                                                                     // ignored and always set to "utf-8". If the global parameter
+                                                                     // "characterEncoding==encoding_ShiftJIS", then the "encoding" parameter
+                                                                     // is ignored and always set to "SHIFT-JIS". If "_XMLWIDECHAR=1", then
+                                                                     // the "encoding" parameter is ignored and always set to "utf-16".
+                                                                     // If no "encoding" parameter is given the "ISO-8859-1" encoding is used.
+    XMLNodeContents enumContents(XMLElementPosition i) const;           // enumerate all the different contents (attribute,child,text,
+                                                                     //     clear) of the current XMLNode. The order is reflecting
+                                                                     //     the order of the original file/string.
+                                                                     //     NOTE: 0 <= i < nElement();
+    int nElement() const;                                            // nbr of different contents for current node
+    char isEmpty() const;                                            // is this node Empty?
+    char isDeclaration() const;                                      // is this node a declaration <? .... ?>
+    XMLNode deepCopy() const;                                        // deep copy (duplicate/clone) a XMLNode
+    static XMLNode emptyNode();                                      // return XMLNode::emptyXMLNode;
+
+// to allow shallow/fast copy:
+    ~XMLNode();
+    XMLNode(const XMLNode &A);
+    XMLNode& operator=( const XMLNode& A );
+
+    XMLNode(): d(NULL){};
+    static XMLNode emptyXMLNode;
+    static XMLClear emptyXMLClear;
+    static XMLAttribute emptyXMLAttribute;
+
+    // The following functions allows you to create from scratch (or update) a XMLNode structure
+    // Start by creating your top node with the "createXMLTopNode" function and then add new nodes with the "addChild" function.
+    // The parameter 'pos' gives the position where the childNode, the text or the XMLClearTag will be inserted.
+    // The default value (pos=-1) inserts at the end. The value (pos=0) insert at the beginning (Insertion at the beginning is slower than at the end).
+    // REMARK: 0 <= pos < nChild()+nText()+nClear()
+    XMLNode       addChild(XMLCSTR lpszName, char isDeclaration=FALSE, XMLElementPosition pos=-1);
+    XMLAttribute *addAttribute(XMLCSTR lpszName, XMLCSTR lpszValuev);
+    XMLCSTR       addText(XMLCSTR lpszValue, XMLElementPosition pos=-1);
+    XMLClear     *addClear(XMLCSTR lpszValue, XMLCSTR lpszOpen=NULL, XMLCSTR lpszClose=NULL, XMLElementPosition pos=-1);
+                                                                       // default values: lpszOpen ="<![CDATA["
+                                                                       //                 lpszClose="]]>"
+    XMLNode       addChild(XMLNode nodeToAdd, XMLElementPosition pos=-1); // If the "nodeToAdd" has some parents, it will be detached
+                                                                       // from it's parents before being attached to the current XMLNode
+    // Some update functions:
+    XMLCSTR       updateName(XMLCSTR lpszName);                                                    // change node's name
+    XMLAttribute *updateAttribute(XMLAttribute *newAttribute, XMLAttribute *oldAttribute);         // if the attribute to update is missing, a new one will be added
+    XMLAttribute *updateAttribute(XMLCSTR lpszNewValue, XMLCSTR lpszNewName=NULL,int i=0);         // if the attribute to update is missing, a new one will be added
+    XMLAttribute *updateAttribute(XMLCSTR lpszNewValue, XMLCSTR lpszNewName,XMLCSTR lpszOldName);  // set lpszNewName=NULL if you don't want to change the name of the attribute
+                                                                                                   // if the attribute to update is missing, a new one will be added
+    XMLCSTR       updateText(XMLCSTR lpszNewValue, int i=0);                                       // if the text to update is missing, a new one will be added
+    XMLCSTR       updateText(XMLCSTR lpszNewValue, XMLCSTR lpszOldValue);                          // if the text to update is missing, a new one will be added
+    XMLClear     *updateClear(XMLCSTR lpszNewContent, int i=0);                                    // if the clearTag to update is missing, a new one will be added
+    XMLClear     *updateClear(XMLClear *newP,XMLClear *oldP);                                      // if the clearTag to update is missing, a new one will be added
+    XMLClear     *updateClear(XMLCSTR lpszNewValue, XMLCSTR lpszOldValue);                         // if the clearTag to update is missing, a new one will be added
+
+    // Some deletion functions:
+    void deleteNodeContent();  // delete the content of this XMLNode and the subtree.
+    void deleteAttribute(XMLCSTR lpszName);
+    void deleteAttribute(int i=0);
+    void deleteAttribute(XMLAttribute *anAttribute);
+    void deleteText(int i=0);
+    void deleteText(XMLCSTR lpszValue);
+    void deleteClear(int i=0);
+    void deleteClear(XMLClear *p);
+    void deleteClear(XMLCSTR lpszValue);
+
+    // The strings given as parameters for the following add and update methods (all these methods have
+    // a name with the postfix "_WOSD" that means "WithOut String Duplication" ) will be free'd by the
+    // XMLNode class. For example, it means that this is incorrect:
+    //    xNode.addText_WOSD("foo");
+    //    xNode.updateAttribute_WOSD("#newcolor" ,NULL,"color");
+    // In opposition, this is correct:
+    //    xNode.addText("foo");
+    //    xNode.addText_WOSD(stringDup("foo"));
+    //    xNode.updateAttribute("#newcolor" ,NULL,"color");
+    //    xNode.updateAttribute_WOSD(stringDup("#newcolor"),NULL,"color");
+    // Typically, you will never do:
+    //    char *b=(char*)malloc(...);
+    //    xNode.addText(b);
+    //    free(b);
+    // ... but rather:
+    //    char *b=(char*)malloc(...);
+    //    xNode.addText_WOSD(b);
+    //    ('free(b)' is performed by the XMLNode class)
+
+    static XMLNode createXMLTopNode_WOSD(XMLSTR lpszName, char isDeclaration=FALSE);
+    XMLNode        addChild_WOSD(XMLSTR lpszName, char isDeclaration=FALSE, XMLElementPosition pos=-1);
+    XMLAttribute  *addAttribute_WOSD(XMLSTR lpszName, XMLSTR lpszValue);
+    XMLCSTR        addText_WOSD(XMLSTR lpszValue, XMLElementPosition pos=-1);
+    XMLClear      *addClear_WOSD(XMLSTR lpszValue, XMLCSTR lpszOpen=NULL, XMLCSTR lpszClose=NULL, XMLElementPosition pos=-1);
+
+    XMLCSTR        updateName_WOSD(XMLSTR lpszName);
+    XMLAttribute  *updateAttribute_WOSD(XMLAttribute *newAttribute, XMLAttribute *oldAttribute);
+    XMLAttribute  *updateAttribute_WOSD(XMLSTR lpszNewValue, XMLSTR lpszNewName=NULL,int i=0);
+    XMLAttribute  *updateAttribute_WOSD(XMLSTR lpszNewValue, XMLSTR lpszNewName,XMLCSTR lpszOldName);
+    XMLCSTR        updateText_WOSD(XMLSTR lpszNewValue, int i=0);
+    XMLCSTR        updateText_WOSD(XMLSTR lpszNewValue, XMLCSTR lpszOldValue);
+    XMLClear      *updateClear_WOSD(XMLSTR lpszNewContent, int i=0);
+    XMLClear      *updateClear_WOSD(XMLClear *newP,XMLClear *oldP);
+    XMLClear      *updateClear_WOSD(XMLSTR lpszNewValue, XMLCSTR lpszOldValue);
+
+    // These are some useful functions when you want to insert a childNode, a text or a XMLClearTag in the
+    // middle (at a specified position) of a XMLNode tree already constructed. The value returned by these
+    // methods is to be used as last parameter (parameter 'pos') of addChild, addText or addClear.
+    XMLElementPosition positionOfText(int i=0) const;
+    XMLElementPosition positionOfText(XMLCSTR lpszValue) const;
+    XMLElementPosition positionOfClear(int i=0) const;
+    XMLElementPosition positionOfClear(XMLCSTR lpszValue) const;
+    XMLElementPosition positionOfClear(XMLClear *a) const;
+    XMLElementPosition positionOfChildNode(int i=0) const;
+    XMLElementPosition positionOfChildNode(XMLNode x) const;
+    XMLElementPosition positionOfChildNode(XMLCSTR name, int i=0) const; // return the position of the ith childNode with the specified name
+                                                                      // if (name==NULL) return the position of the ith childNode
+
+    // The setGlobalOptions function allows you to change tree global parameters that affect string&file
+    // parsing. First of all, you most-probably will never have to change these 3 global parameters.
+    // The return value of the setGlobalOptions function is "0" when there are no errors. If you try to
+    // set an unrecognized encoding then the return value will be "1" to signal an error.
+    //
+    // About the "guessWideCharChars" parameter:
+    //     If "guessWideCharChars=1" and if this library is compiled in WideChar mode, then the
+    //     "parseFile" and "openFileHelper" functions will test if the file contains ASCII
+    //     characters. If this is the case, then the file will be loaded and converted in memory to
+    //     WideChar before being parsed. If "guessWideCharChars=0", no conversion will
+    //     be performed.
+    //
+    //     If "guessWideCharChars=1" and if this library is compiled in ASCII/UTF8/char* mode, then the
+    //     "parseFile" and "openFileHelper" functions will test if the file contains WideChar
+    //     characters. If this is the case, then the file will be loaded and converted in memory to
+    //     ASCII/UTF8/char* before being parsed. If "guessWideCharChars=0", no conversion will
+    //     be performed
+    //
+    //     Sometime, it's useful to set "guessWideCharChars=0" to disable any conversion
+    //     because the test to detect the file-type (ASCII/UTF8/char* or WideChar) may fail (rarely).
+    //
+    // About the "characterEncoding" parameter:
+    //     This parameter is only meaningful when compiling in char* mode (multibyte character mode).
+    //     In wchar_t* (wide char mode), this parameter is ignored. This parameter should be one of the
+    //     three currently recognized encodings: XMLNode::encoding_UTF8, XMLNode::encoding_ascii,
+    //     XMLNode::encoding_ShiftJIS.
+    //
+    // About the "dropWhiteSpace" parameter:
+    //     In most situations, text fields containing only white spaces (and carriage returns)
+    //     are useless. Even more, these "empty" text fields are annoying because they increase the
+    //     complexity of the user's code for parsing. So, 99% of the time, it's better to drop
+    //     the "empty" text fields. However The XML specification indicates that no white spaces
+    //     should be lost when parsing the file. So to be perfectly XML-compliant, you should set
+    //     dropWhiteSpace=0. A note of caution: if you set "dropWhiteSpace=0", the parser will be
+    //     slower and your code will be more complex.
+
+    // Enumeration for XML character encoding.
+    typedef enum XMLCharEncoding { encoding_UTF8=1, encoding_ascii=2, encoding_ShiftJIS=3 } XMLCharEncoding;
+
+    static char setGlobalOptions(XMLCharEncoding characterEncoding=XMLNode::encoding_UTF8, char guessWideCharChars=1, char dropWhiteSpace=1);
+
+    // The next function try to guess the character encoding. You most-probably will never
+    // have to use this function. It then returns the appropriate value of the global parameter
+    // "characterEncoding" described above. The guess is based on the content of a buffer of length
+    // "bufLen" bytes that contains the first bytes (minimum 25 bytes; 200 bytes is a good value) of the
+    // file to be parsed. The "openFileHelper" function is using this function to automatically compute
+    // the value of the "characterEncoding" global parameter. There are several heuristics used to do the
+    // guess. One of the heuristic is based on the "encoding" attribute. The original XML specifications
+    // forbids to use this attribute to do the guess but you can still use it if you set
+    // "useXMLEncodingAttribute" to 1 (this is the default behavior and the behavior of most parsers).
+    // If an inconsistency in the encoding is detected, then the return value is "0".
+
+    static XMLCharEncoding guessCharEncoding(void *buffer, int bufLen, char useXMLEncodingAttribute=1);
+
+  private:
+
+// these are functions and structures used internally by the XMLNode class (don't bother about them):
+
+      typedef struct XMLNodeDataTag // to allow shallow copy and "intelligent/smart" pointers (automatic delete):
+      {
+          XMLCSTR                lpszName;        // Element name (=NULL if root)
+          int                    nChild,          // Number of child nodes
+                                 nText,           // Number of text fields
+                                 nClear,          // Number of Clear fields (comments)
+                                 nAttribute;      // Number of attributes
+          char                   isDeclaration;   // Whether node is an XML declaration - '<?xml ?>'
+          struct XMLNodeDataTag  *pParent;        // Pointer to parent element (=NULL if root)
+          XMLNode                *pChild;         // Array of child nodes
+          XMLCSTR                *pText;          // Array of text fields
+          XMLClear               *pClear;         // Array of clear fields
+          XMLAttribute           *pAttribute;     // Array of attributes
+          int                    *pOrder;         // order of the child_nodes,text_fields,clear_fields
+          int                    ref_count;       // for garbage collection (smart pointers)
+      } XMLNodeData;
+      XMLNodeData *d;
+
+      char parseClearTag(void *px, void *pa);
+      char maybeAddTxT(void *pa, XMLCSTR tokenPStr);
+      int ParseXMLElement(void *pXML);
+      void *addToOrder(int memInc, int *_pos, int nc, void *p, int size, XMLElementType xtype);
+      int indexText(XMLCSTR lpszValue) const;
+      int indexClear(XMLCSTR lpszValue) const;
+      XMLNode addChild_priv(int,XMLSTR,char,int);
+      XMLAttribute *addAttribute_priv(int,XMLSTR,XMLSTR);
+      XMLCSTR addText_priv(int,XMLSTR,int);
+      XMLClear *addClear_priv(int,XMLSTR,XMLCSTR,XMLCSTR,int);
+      void deleteNodeContent_priv(char,char);
+      static inline XMLElementPosition findPosition(XMLNodeData *d, int index, XMLElementType xtype);
+      static int CreateXMLStringR(XMLNodeData *pEntry, XMLSTR lpszMarker, int nFormat);
+      static int removeOrderElement(XMLNodeData *d, XMLElementType t, int index);
+      static void exactMemory(XMLNodeData *d);
+      static int detachFromParent(XMLNodeData *d);
+} XMLNode;
+
+// This structure is given by the function "enumContents".
+typedef struct XMLNodeContents
+{
+    // This dictates what's the content of the XMLNodeContent
+    enum XMLElementType etype;
+    // should be an union to access the appropriate data.
+    // compiler does not allow union of object with constructor... too bad.
+    XMLNode child;
+    XMLAttribute attrib;
+    XMLCSTR text;
+    XMLClear clear;
+
+} XMLNodeContents;
+
+XMLDLLENTRY void freeXMLString(XMLSTR t); // {free(t);}
+
+// Duplicate (copy in a new allocated buffer) the source string. This is
+// a very handy function when used with all the "XMLNode::*_WOSD" functions.
+// (If (cbData!=0) then cbData is the number of chars to duplicate)
+XMLDLLENTRY XMLSTR stringDup(XMLCSTR source, int cbData=0);
+
+// The following class is processing strings so that all the characters
+// &,",',<,> are replaced by their XML equivalent: &amp;, &quot;, &apos;, &lt;, &gt;.
+// This  class is useful when creating from scratch an XML file using the
+// "printf", "fprintf", "cout",... functions. If you are creating from scratch an
+// XML file using the provided XMLNode class you must not use the "ToXMLStringTool"
+// class (the "XMLNode" class does the processing job for you during rendering).
+// Using the "ToXMLStringTool class" and the "fprintf function" is THE most efficient
+// way to produce VERY large XML documents VERY fast.
+typedef struct XMLDLLENTRY ToXMLStringTool
+{
+public:
+    ToXMLStringTool(): buf(NULL),buflen(0){}
+    ~ToXMLStringTool();
+    void freeBuffer();
+
+    XMLSTR toXML(XMLCSTR source);
+
+    // The next function is deprecated because there is a possibility of
+    // "destination-buffer-overflow". It converts the string
+    // "source" to the string "dest".
+    static XMLSTR toXMLUnSafe(XMLSTR dest,XMLCSTR source);
+
+private:
+    XMLSTR buf;
+    int buflen;
+}ToXMLStringTool;
+
+// Below is a class that allows you to include any binary data (images, sounds,...)
+// into an XML document using "Base64 encoding". This class is completely
+// separated from the rest of the xmlParser library and can be removed without any problem.
+// To include some binary data into an XML file, you must convert the binary data into
+// standard text (using "encode"). To retrieve the original binary data from the
+// b64-encoded text included inside the XML file use "decode". Alternatively, these
+// functions can also be used to "encrypt/decrypt" some critical data contained inside
+// the XML (it's not a strong encryption at all, but sometimes it can be useful).
+
+typedef struct XMLDLLENTRY XMLParserBase64Tool
+{
+public:
+    XMLParserBase64Tool(): buf(NULL),buflen(0){}
+    ~XMLParserBase64Tool();
+    void freeBuffer();
+
+    // returns the length of the base64 string that encodes a data buffer of size inBufLen bytes.
+    // If "formatted" parameter is true, some space will be reserved for a carriage-return every 72 chars.
+    static int encodeLength(int inBufLen, char formatted=0);
+
+    // The "base64Encode" function returns a string containing the base64 encoding of "inByteLen" bytes
+    // from "inByteBuf". If "formatted" parameter is true, then there will be a carriage-return every 72 chars.
+    // The string will be free'd when the XMLParserBase64Tool object is deleted.
+    // All returned strings are sharing the same memory space.
+    XMLSTR encode(unsigned char *inByteBuf, unsigned int inByteLen, char formatted=0);
+
+    // returns the number of bytes which will be decoded from "inString".
+    static unsigned int decodeSize(XMLCSTR inString, XMLError *xe=NULL);
+
+    // returns a pointer to a buffer containing the binary data decoded from "inString"
+    // If "inString" is malformed NULL will be returned
+    // The output buffer will be free'd when the XMLParserBase64Tool object is deleted.
+    // All output buffer are sharing the same memory space.
+    unsigned char* decode(XMLCSTR inString, int *outByteLen=NULL, XMLError *xe=NULL);
+
+    // The next function is deprecated.
+    // decodes data from "inString" to "outByteBuf". You need to provide the size (in byte) of "outByteBuf"
+    // in "inMaxByteOutBuflen". If "outByteBuf" is not large enough or if data is malformed, then "FALSE"
+    // will be returned; otherwise "TRUE".
+    static unsigned char decode(XMLCSTR inString, unsigned char *outByteBuf, int inMaxByteOutBuflen, XMLError *xe=NULL);
+
+private:
+    void *buf;
+    int buflen;
+    void alloc(int newsize);
+}XMLParserBase64Tool;
+
+#undef XMLDLLENTRY
+
+#endif
