<?xml version="1.0" encoding="iso-8859-1"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  <html xmlns="http://www.w3.org/1999/xhtml">
		<head>
			<!-- template designed by Marco Von Ballmoos -->
			<title>phpDocumentor Parser Errors and Warnings</title>
			<link rel="stylesheet" href="media/stylesheet.css" />
			<meta http-equiv='Content-Type' content='text/html; charset=iso-8859-1'/>
		</head>
		<body>
						<a href="#Post-parsing">Post-parsing</a><br>
<a href="#Test-JSON.php">Test-JSON.php</a><br>
<a name="Post-parsing"></a>
<h1>Post-parsing</h1>
<h2>Warnings:</h2><br>
<b>Warning</b> - Class Services_JSON_ErrorSuppression_TestCase parent PHPUnit_TestCase not found<br>
<b>Warning</b> - Class Services_JSON_Spaces_Comments_TestCase parent PHPUnit_TestCase not found<br>
<b>Warning</b> - Class Services_JSON_Empties_TestCase parent PHPUnit_TestCase not found<br>
<b>Warning</b> - Class Services_JSON_UnquotedKeys_TestCase parent PHPUnit_TestCase not found<br>
<b>Warning</b> - Class Services_JSON_Error parent PEAR_Error not found<br>
<b>Warning</b> - Class Services_JSON_AssocArray_TestCase parent PHPUnit_TestCase not found<br>
<b>Warning</b> - Class Services_JSON_EncDec_TestCase parent PHPUnit_TestCase not found<br>
<b>Warning</b> - Class Services_JSON_NestedArray_TestCase parent PHPUnit_TestCase not found<br>
<b>Warning</b> - Class Services_JSON_Object_TestCase parent PHPUnit_TestCase not found<br>
<a name="JSON.php"></a>
<h1>JSON.php</h1>
<h2>Warnings:</h2><br>
<b>Warning on line 115</b> - no @package tag was used in a DocBlock for class Services_JSON<br>
<b>Warning on line 781</b> - no @package tag was used in a DocBlock for class Services_JSON_Error<br>
<b>Warning on line 795</b> - no @package tag was used in a DocBlock for class Services_JSON_Error<br>
<b>Warning on line 795</b> - 
duplicate class element "Services_JSON_Error" in file /Users/migurski/Sites/JSON-PHP/JSON.php will be ignored.
Use an @ignore tag on the original if you want this case to be documented.<br>
<a name="Test-JSON.php"></a>
<h1>Test-JSON.php</h1>
<h2>Warnings:</h2><br>
<b>Warning on line 19</b> - package default is already in category , will now replace with category <br>
<b>Warning on line 21</b> - Page-level DocBlock precedes "require_once Test-JSON.php", use another DocBlock to document the source element<br>
<b>Warning on line 24</b> - no @package tag was used in a DocBlock for class Services_JSON_EncDec_TestCase<br>
<b>Warning on line 156</b> - no @package tag was used in a DocBlock for class Services_JSON_AssocArray_TestCase<br>
<b>Warning on line 211</b> - no @package tag was used in a DocBlock for class Services_JSON_NestedArray_TestCase<br>
<b>Warning on line 288</b> - no @package tag was used in a DocBlock for class Services_JSON_Object_TestCase<br>
<b>Warning on line 327</b> - no @package tag was used in a DocBlock for class Services_JSON_Spaces_Comments_TestCase<br>
<b>Warning on line 363</b> - no @package tag was used in a DocBlock for class Services_JSON_Empties_TestCase<br>
<b>Warning on line 405</b> - no @package tag was used in a DocBlock for class Services_JSON_UnquotedKeys_TestCase<br>
<b>Warning on line 433</b> - no @package tag was used in a DocBlock for class Services_JSON_ErrorSuppression_TestCase<br>
	<p class="notes" id="credit">
		Documentation generated on Tue, 27 Jun 2006 22:54:27 -0700 by <a href="http://www.phpdoc.org" target="_blank">phpDocumentor 1.2.3</a>
	</p>
	</body>
</html>