       1:    2:    3:    4:    5:    6:    7:    8:    9:   10:   11:   12:   13:   14:   15:   16:   17:   18:   19:   20:   21:   22:   23:   24:   25:   26:   27:   28:   29:   30:   31:   32:   33:   34:   35:   36:   37:   38:   39:   40:   41:   42:   43:   44:   45:   46:   47:   48:   49:   50:   51:   52:   53:   54:   55:   56:   57:   58:   59:   60:   61:   62:   63:   64:   65:   66:   67:   68:   69:   70:   71:   72:   73:   74:   75:   76:   77:   78:   79:   80:   81:   82:   83:   84:   85:   86:   87:   88:   89:   90:   91:   92:   93:   94:   95:   96:   97:   98:   99:  100:  101:  102:  103:  104:  105:  106:  107:  108:  109:  110:  111:  112:  113:  114:  115:  116:  117:  118:  119:  120:  121:  122:  123:  124:  125:  126:  127:  128:  129:  130:  131:  132:  133:  134:  135:  136:  137:  138:  139:  140:  141:  142:  143:  144:  145:  146:  147:  148:  149:  150:  151:  152:  153:  154:  155:  156:  157:  158:  159:  160:  161:  162:  163:  164:  165:  166:  167:  168:  169:  170:  171:  172:  173:  174:  175:  176:  177:  178:  179:  180:  181:  182:  183:  184:  185:  186:  187:  188:  189:  190:  191:  192:  193:  194:  195:  196:  197:  198:  199:  200:  201:  202:  203:  204:  205:  206:  207:  208:  209:  210:  211:  212:  213:  214:  215:  216:  217:  218:  219:  220:  221:  222:  223:  224:  225:  226:  227:  228:  229:  230:  231:  232:  233:  234:  235:  236:  237:  238:  239:  240:  241:  242:  243:  244:  245:  246:  247:  248:  249:  250:  251:  252:  253:  254:  255:  256:  257:  258:  259:  260:  261:  262:  263:  264:  265:  266:  267:  268:  269:  270:  271:  272:  273:  274:  275:  276:  277:  278:  279:  280:  281:  282:  283:  284:  285:  286:  287:  288:  289:  290:  291:  292:  293:  294:  295:  296:  297:  298:  299:  300:  301:  302:  303:  304:  305:  306:  307:  308:  309:  310:  311:  312:  313:  314:  315:  316:  317:  318:  319:  320:  321:  322:  323:  324:  325:  326:  327:  328:  329:  330:  331:  332:  333:  334:  335:  336:  337:  338:  339:  340:  341:  342:  343:  344:  345:  346:  347:  348:  349:  350:  351:  352:  353:  354:  355:  356:  357:  358:  359:  360:  361:  362:  363:  364:  365:  366:  367:  368:  369:  370:  371:  372:  373:  374:  375:  376:  377:  378:  379:  380:  381:  382:  383:  384:  385:  386:  387:  388:  389:  390:  391:  392:  393:  394:  395:  396:  397:  398:  399:  400:  401:  402:  403:  404:  405:  406:  407:  408:  409:  410:  411:  412:  413:  414:  415:  416:  417:  418:  419:  420:  421:  422:  423:  424:  425:  426:  427:  428:  429:  430:  431:  432:  433:  434:  435:  436:  437:  438:  439:  440:  441:  442:  443:  444:  445:  446:  447:  448:  449:  450:  451:  452:  453:  454:  455:  456:  457:  458:  459:  460:  461:  462:  463:  464:  465:  466:  467:  468:  469:  470:  471:  472:  473:  474:  475:  476:  477:  478:  479:  480:  481:  482:  483:  484:  485:  486:  487:  488:  489:  490:  491:  492:  493:  494:  495:  496:  497:  498:  499:  500:  501:  502:  503:  504:  505:  506:  507:  508:  509:  510:  511:  512:  513:  514:  515:  516:  517:  518:  519:  520:  521:  522:  523:  524:  525:  526:  527:  528:  529:  530:  531:  532:  533:  534:  535:  536:  537:  538:  539:  540:  541:  542:  543:  544:  545:  546:  547:  548:  549:  550:  551:  552:  553:  554:  555:  556:  557:  558:  559:  560:  561:  562:  563:  564:  565:  566:  567:  568:  569:  570:  571:  572:  573:  574:  575:  576:  577:  578:  579:  580:  581:  582:  583:  584:  585:  586:  587:  588:  589:  590:  591:  592:  593:  594:  595:  596:  597:  598:  599:  600:  601:  602:  603:  604:  605:  606:  607:  608:  609:  610:  611:  612:  613:  614:  615:  616:  617:  618:  619:  620:  621:  622:  623:  624:  625:  626:  627:  628:  629:  630:  631:  632:  633:  634:  635:  636:  637:  638:  639:  640:  641:  642:  643:  644:  645:  646:  647:  648:  649:  650:  651:  652:  653:  654:  655:  656:  657:  658:  659:  660:  661:  662:  663:  664:  665:  666:  667:  668:  669:  670:  671:  672:  673:  674:  675:  676:  677:  678:  679:  680:  681:  682:  683:  684:  685:  686:  687:  688:  689:  690:  691:  692:  693:  694:  695:  696:  697:  698:  699:  700:  701:  702:  703:  704:  705:  706:  707:  708:  709:  710:  711:  712:  713:  714:  715:  716:  717:  718:  719:  720:  721:  722:  723:  724:  725:  726:  727:  728:  729:  730:  731:  732:  733:  734:  735:  736:  737:  738:  739:  740:  741:  742:  743:  744:  745:  746:  747:  748:  749:  750:  751:  752:  753:  754:  755:  756:  757:  758:  759:  760:  761:  762:  763:  764:  765:  766:  767:  768:  769:  770:  771:  772:  773:  774:  775:  776:  777:  778:  779:  780:  781:  782:  783:  784:  785:  786:  787:  788:  789:  790:  791:  792:  793:  794:  795:  796:  797:  798:  799:  800:  801:  802:  803:  804:  805:  806:  807:  808:  809:  810:  811:  812:  813:  814:  815:  816:  817:  818:  819:  820:  821:  822:  823:  824:  825:  826:  827:  828:  829:  830:  831:  832:  833:  834:  835:  836:  837:  838:  839:  840:  841:  842:  843:  844:  845:  846:  847:  848:  849:  850:  851:  852:  853:  854:  855:  856:  857:  858:  859:  860:  861:  862:  863:  864:  865:  866:  867:  868:  869:  870:  871:  872:  873:  874:  875:  876:  877:  878:  879:  880:  881:  882:  883:  884:  885:  886:  887:  888:  889:  890:  891:  892:  893:  894:  895:  896:  897:  898:  899:  900:  901:  902:  903:  904:  905:  906:  907:  908:  909:  910:  911:  912:  913:  914:  915:  916:  917:  918:  919:  920:  921:  922:  923:  924:  925:  926:  927:  928:  929:  930:  931:  932:  933:  934:  935:  936:  937:  938:  939:  940:  941:  942:  943:  944:  945:  946:  947:  948:  949:  950:  951:  952:  953:  954:  955:  956:  957:  958:  959:  960:  961:  962:  963:  964:  965:  966:  967:  968:  969:  970:  971:  972:  973:  974:  975:  976:  977:  978:  979:  980:  981:  982:  983:  984:  985:  986:  987:  988:  989:  990:  991:  992:  993:  994:  995:  996:  997:  998:  999: 1000: 1001: 1002: 1003: 1004: 1005: 1006: 1007: 1008: 1009: 1010: 1011: 1012: 1013: 1014: 1015: 1016: 1017: 1018: 1019: 1020: 1021: 1022: 1023: 1024: 1025: 1026: 1027: 1028: 1029: 1030: 1031: 1032: 1033: 1034: 1035: 1036: 1037: 1038: 1039: 1040: 1041: 1042: 1043: 1044: 1045: 1046: 1047: 1048: 1049: 1050: 1051: 1052: 1053: 1054: 1055: 1056: 1057: 1058: 1059: 1060: 1061: 1062: 1063: 1064: 1065: 1066: 1067: 1068: 1069: 1070: 1071: 1072: 1073: 1074: 1075: 1076: 1077: 1078: 1079: 1080: 1081: 1082: 1083: 1084: 1085: 1086: 1087: 1088: 1089: 1090: 1091: 1092: 1093: 1094: 1095: 1096: 1097: 1098: 1099: 1100: 1101: 1102: 1103: 1104: 1105: 1106: 1107: 1108: 1109: 1110: 1111: 1112: 1113: 1114: 1115: 1116: 1117: 1118: 1119: 1120: 1121: 1122: 1123: 1124: 1125: 1126: 1127: 1128: 1129: 1130: 1131: 1132: 1133: 1134: 1135: 1136: 1137: 1138: 1139: 1140: 1141: 1142: 1143: 1144: 1145: 1146: 1147: 1148: 1149: 1150: 1151: 1152: 1153: 1154: 1155: 1156: 1157: 1158: 1159: 1160: 1161: 1162: 1163: 1164: 1165: 1166: 1167: 1168: 1169: 1170: 1171: 1172: 1173: 1174: 1175: 1176: 1177: 1178: 1179: 1180: 1181: 1182: 1183: 1184: 1185: 1186: 1187: 1188: 1189: 1190: 1191: 1192: 1193: 1194: 1195: 1196: 1197: 1198: 1199: 1200: 1201: 1202: 1203: 1204: 1205: 1206: 1207: 1208: 1209: 1210: 1211: 1212: 1213: 1214: 1215: 1216: 1217: 1218: 1219: 1220: 1221: 1222: 1223: 1224: 1225: 1226: 1227: 1228: 1229: 1230: 1231: 1232: 1233: 1234: 1235: 1236: 1237: 1238: 1239: 1240: 1241: 1242: 1243: 1244: 1245: 1246: 1247: 1248: 1249: 1250: 1251: 1252: 1253: 1254: 1255: 1256: 1257: 1258: 1259: 1260: 1261: 1262: 1263: 1264: 1265: 1266: 1267: 1268: 1269: 1270: 1271: 1272: 1273: 1274: 1275: 1276: 1277: 1278: 1279: 1280: 1281: 1282: 1283: 1284: 1285: 1286: 1287: 1288: 1289: 1290: 1291: 1292: 1293: 1294: 1295: 1296: 1297: 1298: 1299: 1300: 1301: 1302: 1303: 1304: 1305: 1306: 1307: 1308: 1309: 1310: 1311: 1312: 1313: 1314: 1315: 1316: 1317: 1318: 1319: 1320: 1321: 1322: 1323: 1324: 1325: 1326: 1327: 1328: 1329: 1330: 1331: 1332: 1333: 1334: 1335: 1336: 1337: 1338: 1339: 1340: 1341: 1342: 1343: 1344: 1345: 1346: 1347: 1348: 1349: 1350: 1351: 1352: 1353: 1354: 1355: 1356: 1357: 1358: 1359: 1360: 1361: 1362: 1363: 1364: 1365: 1366: 1367: 1368: 1369: 1370: 1371: 1372: 1373: 1374: 1375: 1376: 1377: 1378: 1379: 1380: 1381: 1382: 1383: 1384: 1385: 1386: 1387: 1388: 1389: 1390: 1391: 1392: 1393: 1394: 1395: 1396: 1397: 1398: 1399: 1400: 1401: 1402: 1403: 1404: 1405: 1406: 1407: 1408: 1409: 1410: 1411: 1412: 1413: 1414: 1415: 1416: 1417: 1418: 1419: 1420: 1421: 1422: 1423: 1424: 1425: 1426: 1427: 1428: 1429: 1430: 1431: 1432: 1433: 1434: 1435: 1436: 1437: 1438: 1439: 1440: 1441: 1442: 1443: 1444: 1445: 1446: 1447: 1448: 1449: 1450: 1451: 1452: 1453: 1454: 1455: 1456: 1457: 1458: 1459: 1460: 1461: 1462: 1463: 1464: 1465: 1466: 1467: 1468: 1469: 1470: 1471: 1472: 1473: 1474: 1475: 1476: 1477: 1478: 1479: 1480: 1481: 1482: 1483: 1484: 1485: 1486: 1487: 1488: 1489: 1490: 1491: 1492: 1493: 1494: 1495: 1496: 1497: 1498: 1499: 1500: 1501: 1502: 1503: 1504: 1505: 1506: 1507: 1508: 1509: 1510: 1511: 1512: 1513: 1514: 1515: 1516: 1517: 1518: 1519: 1520: 1521: 1522: 1523: 1524: 1525: 1526: 1527: 1528: 1529: 1530: 1531: 1532: 1533: 1534: 1535: 1536: 1537: 1538: 1539: 1540: 1541: 1542: 1543: 1544: 1545: 1546: 1547: 1548: 1549: 1550: 1551: 1552: 1553: 1554: 1555: 1556: 1557: 1558: 1559: 1560: 1561: 1562: 1563: 1564: 1565: 1566: 1567: 1568: 1569: 1570: 1571: 1572: 1573: 1574: 1575: 1576: 1577: 1578: 1579: 1580: 1581: 1582: 1583: 1584: 1585: 1586: 1587: 1588: 1589: 1590: 1591: 1592: 1593: 1594: 1595: 1596: 1597: 1598: 1599: 1600: 1601: 1602: 1603: 1604: 1605: 1606: 1607: 1608: 1609: 1610: 1611: 1612: 1613: 1614: 1615: 1616: 1617: 1618: 1619: 1620: 1621: 1622: 1623: 1624: 1625: 1626: 1627: 1628: 1629: 1630: 1631: 1632: 1633: 1634: 1635: 1636: 1637: 1638: 1639: 1640: 1641: 1642: 1643: 1644: 1645: 1646: 1647: 1648: 1649: 1650: 1651: 1652: 1653: 1654: 1655: 1656: 1657: 1658: 1659: 1660: 1661: 1662: 1663: 1664: 1665: 1666: 1667: 1668: 1669: 1670: 1671: 1672: 1673: 1674: 1675: 1676: 1677: 1678: 1679: 1680: 1681: 1682: 1683: 1684: 1685: 1686: 1687: 1688: 1689: 1690: 1691: 1692: 1693: 1694: 1695: 1696: 1697: 1698: 1699: 1700: 1701: 1702: 1703: 1704: 1705: 1706: 1707: 1708: 1709: 1710: 1711: 1712: 1713: 1714: 1715: 1716: 1717: 1718: 1719: 1720: 1721: 1722: 1723: 1724: 1725: 1726: 1727: 1728: 1729: 1730: 1731: 1732: 1733: 1734: 1735: 1736: 1737: 1738: 1739: 1740: 1741: 1742: 1743: 1744: 1745: 1746: 1747: 1748: 1749: 1750: 1751: 1752: 1753: 1754: 1755: 1756: 1757: 1758: 1759: 1760: 1761: 1762: 1763: 1764: 1765: 1766: 1767: 1768: 1769: 1770: 1771: 1772: 1773: 1774: 1775: 1776: 1777: 1778: 1779: 1780: 1781: 1782: 1783: 1784: 1785: 1786: 1787: 1788: 1789: 1790: 1791: 1792: 1793: 1794: 1795: 1796: 1797: 1798: 1799: 1800: 1801: 1802: 1803: 1804: 1805: 1806: 1807: 1808: 1809: 1810: 1811: 1812: 1813: 1814: 1815: 1816: 1817: 1818: 1819: 1820: 1821: 1822: 1823: 1824: 1825: 1826: 1827: 1828: 1829: 1830: 1831: 1832: 1833: 1834: 1835: 1836: 1837: 1838: 1839: 1840: 1841: 1842: 1843: 1844: 1845: 1846: 1847: 1848: 1849: 1850: 1851: 1852: 1853: 1854: 1855: 1856: 1857: 1858: 1859: 1860: 1861: 1862: 1863: 1864: 1865: 1866: 1867: 1868: 1869: 1870: 1871: 1872: 1873: 1874: 1875: 1876: 1877: 1878: 1879: 1880: 1881: 1882: 1883: 1884: 1885: 1886: 1887: 1888: 1889: 1890: 1891: 1892: 1893: 1894: 1895: 1896: 1897: 1898: 1899: 1900: 1901: 1902: 1903: 1904: 1905: 1906: 1907: 1908: 1909: 1910: 1911: 1912: 1913: 1914: 1915: 1916: 1917: 1918: 1919: 1920: 1921: 1922: 1923: 1924: 1925: 1926: 1927: 1928: 1929: 1930: 1931: 1932: 1933: 1934: 1935: 1936: 1937: 1938: 1939: 1940: 1941: 1942: 1943: 1944: 1945: 1946: 1947: 1948: 1949: 1950: 1951: 1952: 1953: 1954: 1955: 1956: 1957: 1958: 1959: 1960: 1961: 1962: 1963: 1964: 1965: 1966: 1967: 1968: 1969: 1970: 1971: 1972: 1973: 1974: 1975: 1976: 1977: 1978: 1979: 1980: 1981: 1982: 1983: 1984: 1985: 1986: 1987: 1988: 1989: 1990: 1991: 1992: 1993: 1994: 1995: 1996: 1997: 1998: 1999: 2000: 2001: 2002: 2003: 2004: 2005: 2006: 2007: 2008: 2009: 2010: 2011: 2012: 2013: 2014: 2015: 2016: 2017: 2018: 2019: 2020: 2021: 2022: 2023: 2024: 2025: 2026: 2027: 2028: 2029: 2030: 2031: 2032: 2033: 2034: 2035: 2036: 2037: 2038: 2039: 2040: 2041: 2042: 2043: 2044: 2045: 2046: 2047: 2048: 2049: 2050: 2051: 2052: 2053: 2054: 2055: 2056: 2057: 2058: 2059: 2060: 2061: 2062: 2063: 2064: 2065: 2066: 2067: 2068: 2069: 2070: 2071: 2072: 2073: 2074: 2075: 2076: 2077: 2078: 2079: 2080: 2081: 2082: 2083: 2084: 2085: 2086: 2087: 2088: 2089: 2090: 2091: 2092: 2093: 2094: 2095: 2096: 2097: 2098: 2099: 2100: 2101: 2102: 2103: 2104: 2105: 2106: 2107: 2108: 2109: 2110: 2111: 2112: 2113: 2114: 2115: 2116: 2117: 2118: 2119: 2120: 2121: 2122: 2123: 2124: 2125: 2126: 2127: 2128: 2129: 2130: 2131: 2132: 2133: 2134: 2135: 2136: 2137: 2138: 2139: 2140: 2141: 2142: 2143: 2144: 2145: 2146: 2147: 2148: 2149: 2150: 2151: 2152: 2153: 2154: 2155: 2156: 2157: 2158: 2159: 2160: 2161: 2162: 2163: 2164: 2165: 2166: 2167: 2168: 2169: 2170: 2171: 2172: 2173: 2174: 2175: 2176: 2177: 2178: 2179: 2180: 2181: 2182: 2183: 2184: 2185: 2186: 2187: 2188: 2189: 2190: 2191: 2192: 2193: 2194: 2195: 2196: 2197: 2198: 2199: 2200: 2201: 2202: 2203: 2204: 2205: 2206: 2207: 2208: 2209: 2210: 2211: 2212: 2213: 2214: 2215: 2216: 2217: 2218: 2219: 2220: 2221: 2222: 2223: 2224: 2225: 2226: 2227: 2228: 2229: 2230: 2231: 2232: 2233: 2234: 2235: 2236: 2237: 2238: 2239: 2240: 2241: 2242: 2243: 2244: 2245: 2246: 2247: 2248: 2249: 2250: 2251: 2252: 2253: 2254: 2255: 2256: 2257: 2258: 2259: 2260: 2261: 2262: 2263: 2264: 2265: 2266: 2267: 2268: 2269: 2270: 2271: 2272: 2273: 2274: 2275: 2276: 2277: 2278: 2279: 2280: 2281: 2282: 2283: 2284: 2285: 2286: 2287: 2288: 2289: 2290: 2291: 2292: 2293: 2294: 2295: 2296: 2297:

    <?php /*-*- mode: php; tab-width:4 -*-*/

      /**
       * PHPDebugger.inc -- A PHP debugger for Eclipse for PHP Developers
       *
       * Copyright (C) 2009,2010 Jost Boekemeier.
       *
       * This file is part of the PHP/Java Bridge.
       *
       * The PHP/Java Bridge ("the library") is free software; you can
       * redistribute it and/or modify it under the terms of the GNU General
       * Public License as published by the Free Software Foundation; either
       * version 2, or (at your option) any later version.
       *
       * The library is distributed in the hope that it will be useful, but
       * WITHOUT ANY WARRANTY; without even the implied warranty of
       * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
       * General Public License for more details.
       *
       * You should have received a copy of the GNU General Public License
       * along with the PHP/Java Bridge; see the file COPYING.  If not, write to the
       * Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
       * 02111-1307 USA.
       *
       * Linking this file statically or dynamically with other modules is
       * making a combined work based on this library.  Thus, the terms and
       * conditions of the GNU General Public License cover the whole
       * combination.
       *
       * As a special exception, the copyright holders of this library give you
       * permission to link this library with independent modules to produce an
       * executable, regardless of the license terms of these independent
       * modules, and to copy and distribute the resulting executable under
       * terms of your choice, provided that you also meet, for each linked
       * independent module, the terms and conditions of the license of that
       * module.  An independent module is a module which is not derived from
       * or based on this library.  If you modify this library, you may extend
       * this exception to your version of the library, but you are not
       * obligated to do so.  If you do not wish to do so, delete this
       * exception statement from your version.
       *
       * Installation:
       *
       * Install "Eclipse for PHP Developers" version >= 3.5.2
       *
       * - Open Window -> Preferences -> Servers and set Default Web Server to: http://localhost:8080
       * - Deploy JavaBridgeTemplate.war
       * - Create a new Project using .../apache-tomcat-7.0.75/webapps/JavaBridgeTemplate as directory
       * - Open index.php and start debugger: Default Web Server with Zend Debugger (other options default)
       * - Click debug
       *
       * To debug standalone applications, remove zend_extension=ZendDebugger.so from your php.ini and set:
       *
       *<code>
       * ;; activate the PHPDebugger in the php.ini
       * auto_prepend_file=PHPDebugger.php
       *</code>
       *
       * - Debug your PHP scripts as usual.
       *
       *
       * @category   java
       * @package    pdb
       * @author     Jost Boekemeier
       * @license    GPL+Classpath exception
       * @version    7.0
       * @link       http://php-java-bridge.sf.net/phpdebugger
       */

    /** @access private */
    define ("PDB_DEBUG", 0);
    set_time_limit (0);
    if(!function_exists("token_get_all")) {
        dl("tokenizer.so");
    }

    if ($pdb_script_orig = $pdb_script = pdb_getDebugHeader("X_JAVABRIDGE_INCLUDE", $_SERVER)) {
        if ($pdb_script!="@") {
            if (($_SERVER['REMOTE_ADDR']=='127.0.0.1') || (($pdb_script = realpath($pdb_script)) && (!strncmp($_SERVER['DOCUMENT_ROOT'], $pdb_script, strlen($_SERVER['DOCUMENT_ROOT']))))) {
                $_SERVER['SCRIPT_FILENAME'] = $pdb_script; // set to the original script filename
            } else {
                trigger_error("illegal access: ".$pdb_script_orig, E_USER_ERROR);
                unset($pdb_script);
            }
        }
    }

    if (!class_exists("pdb_Parser")) {
      /**
       * The PHP parser
       * @access private
       */
      class pdb_Parser {
        const BLOCK = 1;
        const STATEMENT = 2;
        const EXPRESSION = 3;
        const FUNCTION_BLOCK = 4; // BLOCK w/ STEP() as last statement

        private $scriptName, $content;
        private $code;
        private $output;
        private $line, $currentLine;
        private $beginStatement, $inPhp, $inDQuote;

        /**
         * Create a new PHP parser
         * @param string the script name
         * @param string the script content
         * @access private
         */
        public function __construct($scriptName, $content) {
          $this->scriptName = $scriptName;
          $this->content = $content;
          $this->code = token_get_all($content);
          $this->output = "";
          $this->line = $this->currentLine = 0;
          $this->beginStatement = $this->inPhp = $this->inDQuote = false;
        }

        private function toggleDQuote($chr) {
          if ($chr == '"') $this->inDQuote = !$this->inDQuote;
        }

        private function each() {
          $next = each ($this->code);
          if ($next) {
            $cur = current($this->code);
            if (is_array($cur)) {
              $this->currentLine = $cur[2] + ($cur[1][0] == "\n" ? substr_count($cur[1], "\n") : 0);
              if ($this->isWhitespace($cur)) {
                $this->write($cur[1]);
                return $this->each();
              }
            }
            else
              $this->toggleDQuote($cur);
          }
          return $next;
        }

        private function write($code) {
          //echo "write:::".$code."\n";
          $this->output.=$code;
        }

        private function writeInclude($once) {
          $name = "";
          while(1) {
            if (!$this->each()) die("parse error");
            $val = current($this->code);
            if (is_array($val)) {
              $name.=$val[1];
            } else {
              if ($val==';') break;
              $name.=$val;
            }
          }
          if (PDB_DEBUG == 2)
            $this->write("EVAL($name);");
          else
            $this->write("eval('?>'.pdb_startInclude($name, $once)); pdb_endInclude();");
        }

        private function writeCall() {
          while(1) {
            if (!$this->each()) die("parse error");
            $val = current($this->code);
            if (is_array($val)) {
              $this->write($val[1]);
            } else {
              $this->write($val);
              if ($val=='{') break;
            }
          }
          $scriptName = addslashes($this->scriptName);
          $this->write("\$__pdb_CurrentFrame=pdb_startCall(\"$scriptName\", {$this->currentLine});");
        }

        private function writeStep($pLevel) {
          $token = current($this->code);
          if ($this->inPhp && !$pLevel && !$this->inDQuote && $this->beginStatement && !$this->isWhitespace($token) && ($this->line != $this->currentLine)) {
            $line = $this->line = $this->currentLine;
            $scriptName = addslashes($this->scriptName);
            if (PDB_DEBUG == 2)
              $this->write(";STEP($line);");
            else
              $this->write(";pdb_step(\"$scriptName\", $line, pdb_getDefinedVars(get_defined_vars(), (isset(\$this) ? \$this : NULL)));");
          }
        }

        private function writeNext() {
          $this->next();
          $token = current($this->code);
          if (is_array($token)) $token = $token[1];
          $this->write($token);
        }

        private function nextIs($chr) {
          $i = 0;
          while(each($this->code)) {
            $cur = current($this->code);
            $i++;
            if (is_array($cur)) {
              switch ($cur[0]) {
              case T_COMMENT:
              case T_DOC_COMMENT:
              case T_WHITESPACE:
                break;  /* skip */
              default:
                while($i--) prev($this->code);
                return false;   /* not found */
              }
            } else {
              while($i--) prev($this->code);
              return $cur == $chr;  /* found */
            }
          }
          while($i--) prev($this->code);
          return false; /* not found */
        }

        private function nextTokenIs($ar) {
          $i = 0;
          while(each($this->code)) {
            $cur = current($this->code);
            $i++;
            if (is_array($cur)) {
              switch ($cur[0]) {
              case T_COMMENT:
              case T_DOC_COMMENT:
              case T_WHITESPACE:
                break;  /* skip */
              default:
                while($i--) prev($this->code);
                return (in_array($cur[0], $ar));
              }
            } else {
              break; /* not found */
            }
          }
          while($i--) prev($this->code);
          return false; /* not found */
        }

        private function isWhitespace($token) {
          $isWhitespace = false;
          switch($token[0]) {
          case T_COMMENT:
          case T_DOC_COMMENT:
          case T_WHITESPACE:
            $isWhitespace = true;
            break;
          }
          return $isWhitespace;
        }
        private function next() {
          if (!$this->each()) trigger_error("parse error", E_USER_ERROR);
        }

        private function parseBlock () {
          $this->parse(self::BLOCK);
        }
        private function parseFunction () {
          $this->parse(self::FUNCTION_BLOCK);
        }
        private function parseStatement () {
          $this->parse(self::STATEMENT);
        }
        private function parseExpression () {
          $this->parse(self::EXPRESSION);
        }

        private function parse ($type) {
          pdb_Logger::debug("parse:::$type");

          $this->beginStatement = true;
          $pLevel = 0;

          do {
            $token = current($this->code);
            if (!is_array($token)) {
              pdb_Logger::debug(":::".$token);
              if (!$pLevel && $type==self::FUNCTION_BLOCK && $token=='}') $this->writeStep($pLevel);
              $this->write($token);
              if ($this->inPhp && !$this->inDQuote) {
                $this->beginStatement = false;
                switch($token) {
                case '(':
                  $pLevel++;
                  break;
                case ')':
                  if (!--$pLevel && $type==self::EXPRESSION) return;
                  break;
                case '{':
                  $this->next();
                  $this->parseBlock();
                  break;
                case '}':
                  if (!$pLevel) return;
                  break;
                case ';':
                  if (!$pLevel) {
                    if ($type==self::STATEMENT) return;
                    $this->beginStatement = true;
                  }
                  break;
                }
              }
            } else {
              pdb_Logger::debug(":::".$token[1].":(".token_name($token[0]).')');

              if ($this->inDQuote) {
                $this->write($token[1]);
                continue;
              }

              switch($token[0]) {

              case T_OPEN_TAG:
              case T_START_HEREDOC:
              case T_OPEN_TAG_WITH_ECHO:
                $this->beginStatement = $this->inPhp = true;
                $this->write($token[1]);
                break;

              case T_END_HEREDOC:
              case T_CLOSE_TAG:
                $this->writeStep($pLevel);

                $this->write($token[1]);
                $this->beginStatement = $this->inPhp = false;
                break;

              case T_FUNCTION:
                $this->write($token[1]);
                $this->writeCall();
                $this->next();
                $this->parseFunction();
                $this->beginStatement = true;
                break;

              case T_ELSE:
                $this->write($token[1]);
                if ($this->nextIs('{')) {
                  $this->writeNext();
                  $this->next();

                  $this->parseBlock();
                } else {
                  $this->next();

                  /* create an artificial block */
                  $this->write('{');
                  $this->beginStatement = true;
                  $this->writeStep($pLevel);
                  $this->parseStatement();
                  $this->write('}');

                }
                if ($type==self::STATEMENT) return;

                $this->beginStatement = true;
                break;

              case T_DO:
                $this->writeStep($pLevel);
                $this->write($token[1]);
                if ($this->nextIs('{')) {
                  $this->writeNext();
                  $this->next();

                  $this->parseBlock();
                  $this->next();

                } else {
                  $this->next();

                  /* create an artificial block */
                  $this->write('{');
                  $this->beginStatement = true;
                  $this->writeStep($pLevel);
                  $this->parseStatement();
                  $this->next();
                  $this->write('}');
                }
                $token = current($this->code);
                $this->write($token[1]);

                if ($token[0]!=T_WHILE) trigger_error("parse error", E_USER_ERROR);
                $this->next();
                $this->parseExpression();

                if ($type==self::STATEMENT) return;

                $this->beginStatement = true;
                break;

              case T_CATCH:
              case T_IF:
              case T_ELSEIF:
              case T_FOR:
              case T_FOREACH:
              case T_WHILE:
                $this->writeStep($pLevel);

                $this->write($token[1]);
                $this->next();

                $this->parseExpression();

                if ($this->nextIs('{')) {
                  $this->writeNext();
                  $this->next();

                  $this->parseBlock();

                } else {
                  $this->next();
                  /* create an artificial block */
                  $this->write('{');
                  $this->beginStatement = true;
                  $this->writeStep($pLevel);
                  $this->parseStatement();
                  $this->write('}');
                }

                if ($this->nextTokenIs(array(T_ELSE, T_ELSEIF, T_CATCH))) {
                  $this->beginStatement = false;
                } else {
                  if ($type==self::STATEMENT) return;
                  $this->beginStatement = true;
                }
                break;

              case T_REQUIRE_ONCE:
              case T_INCLUDE_ONCE:
              case T_INCLUDE:
              case T_REQUIRE:
                $this->writeStep($pLevel);
                $this->writeInclude((($token[0]==T_REQUIRE_ONCE) || ($token[0]==T_INCLUDE_ONCE)) ? 1 : 0);

                if ($type==self::STATEMENT) return;

                $this->beginStatement = true;
                break;

              case T_CLASS:
                $this->write($token[1]);
                $this->writeNext();
                if ($this->nextIs('{')) {
                  $this->writeNext();
                  $this->next();
                  $this->parseBlock();
                  $this->beginStatement = true;
                } else {
                  $this->writeNext();
                  $this->beginStatement = false;
                }
                break;

              case T_CASE:
              case T_DEFAULT:
              case T_PUBLIC:
              case T_PRIVATE:
              case T_PROTECTED:
              case T_STATIC:
              case T_CONST:
              case T_GLOBAL:
              case T_ABSTRACT:
                $this->write($token[1]);
                $this->beginStatement = false;
                break;

              default:
                $this->writeStep($pLevel);
                $this->write($token[1]);
                $this->beginStatement = false;
                break;

              }
            }
          } while($this->each());
        }

        /**
         * parse the given PHP script
         * @return the parsed PHP script
         * @access private
         */
        public function parseScript() {
          do {
            $this->parseBlock();
          } while($this->each());

          return $this->output;
        }
      }
    }

    /**
     * @access private
     */
    class pdb_Logger {
      const FATAL = 1;
      const INFO = 2;
      const VERBOSE = 3;
      const DEBUG = 4;

      private static $logLevel = 0;
      private static $logFileName;

      private static function println($msg, $level) {
        if (!self::$logLevel) self::$logLevel=PDB_DEBUG?self::DEBUG:self::INFO;
        if ($level <= self::$logLevel) {
          static $file = null;
          if(!isset(self::$logFileName)) {
            self::$logFileName = $_SERVER['HOME'].DIRECTORY_SEPARATOR."pdb_PHPDebugger.inc.log";
          }
          if (!$file) $file = fopen(self::$logFileName, "ab") or die("fopen");
          fwrite($file, time().": ");
          fwrite($file, $msg."\n");
          fflush($file);
        }
      }

      public static function logFatal($msg) {
        self::println($msg, self::FATAL);
      }
      public static function logInfo($msg) {
        self::println($msg, self::INFO);
      }
      public static function logMessage($msg) {
        self::println($msg, self::VERBOSE);
      }
      public static function logDebug($msg) {
        self::println($msg, self::DEBUG);
      }
      public static function debug($msg) {
        self::logDebug($msg);
      }
      public static function log($msg) {
        self::logMessage($msg);
      }
      public static function setLogLevel($level) {
        self::$logLevel=$level;
      }
      public static function setLogFileName($name) {
        self::$logFileName = $name;
      }
    }

    /**
     * @access private
     */
    class pdb_Environment {
      public $filename, $stepNext;
      public $vars, $line, $firstLine;
      public $parent;

      public function __construct($parent, $filename, $stepNext, $firstLine) {
        $this->parent = $parent;
        $this->filename = $filename;
        $this->stepNext = $stepNext;
        $this->firstLine = $firstLine;
        $this->line = -1;
      }

      public function update ($line, &$vars) {
        $this->line = $line;
        $this->vars = &$vars;
      }
      public function __toString() {
        return "pdb_Environment: {$this->filename}, {$this->firstLine} - {$this->line}";
      }
    }

    /**
     * @access private
     */
    abstract class pdb_Message {
      public $session;

      public abstract function getType();

      public function __construct($session) {
        $this->session = $session;
      }

      public function serialize() {
        $this->session->out->writeShort($this->getType());
      }

      private static $messages = array();
      public static function register($message) {
        pdb_Message::$messages[$message->getType()] = $message;
      }
      public function getMessageById($id) {
        $message = pdb_Message::$messages[$id];
        return $message;
      }
      public function getMessage() {
        $id = $this->session->in->readShort();
        $message = $this->getMessageById($id);
        if (!$message) trigger_error("invalid message: $id", E_USER_ERROR);
        $message->deserialize();
        return $message;
      }

      protected function handleContinueProcessFile($message) {
        $code = $this->session->parseCode($this->currentFrame->filename, file_get_contents($this->currentFrame->filename));
        if (PDB_DEBUG) pdb_Logger::debug( "parse file:::" . $code ."\n");
        if (!PDB_DEBUG) ob_start();
        self::doEval ($code);
        $output = $this->getMessageById(pdb_OutputNotification::TYPE);
        if(!PDB_DEBUG) $output->setOutput(ob_get_contents());
        if(!PDB_DEBUG) ob_end_clean();
        $output->serialize();
        $this->status = 42; //FIXME
        $this->getMessageById(pdb_DebugScriptEndedNotification::TYPE)->serialize();
        return true;
      }
      private static function doEval($__pdb_Code) {
        return  eval ("?>".$__pdb_Code);
      }
      protected function handleStep($message) {
        return false;
      }
      protected function handleGo($message) {
        foreach ($this->session->allFrames as $frame) {
          $frame->stepNext = false;
        }
        return true; // exit
      }
      public function handleRequests () {
        $this->ignoreInterrupt = false;

        $this->serialize();
        while(1) {
          $message = $this->getMessage();
          switch ($message->getType()) {
          case pdb_SetProtocolRequest::TYPE:
            $message->ack();
            break;
          case pdb_StartRequest::TYPE:
            $message->ack();
            $this->getMessageById(pdb_StartProcessFileNotification::TYPE)->serialize();
            break;
          case pdb_ContinueProcessFileNotification::TYPE:
            if ($this->handleContinueProcessFile($message)) return pdb_ContinueProcessFileNotification::TYPE;
            break;
          case pdb_AddBreakpointRequest::TYPE:
            $message->ack();
            break;
          case pdb_RemoveBreakpointRequest::TYPE:
            $message->ack();
            break;
          case pdb_RemoveAllBreakpointsRequest::TYPE:
            $message->ack();
            break;
          case pdb_GetCallStackRequest::TYPE:
            $message->ack();
            break;
          case pdb_GetCWDRequest::TYPE:
            $message->ack();
            break;
          case pdb_GetVariableValueRequest::TYPE:
            $message->ack();
            break;
          case pdb_AddFilesRequest::TYPE:
            $message->ack();
            break;
          case pdb_FileContentExtendedRequest::TYPE:
            $message->ack();
            break;
          case pdb_MsgEvalRequest::TYPE:
            $message->ack();
            break;
          case pdb_GoRequest::TYPE:
            $message->ack();
            if ($this->handleGo($message)) return pdb_GoRequest::TYPE;
            break;
          case pdb_StepOverRequest::TYPE:
            $message->ack();
            if ($this->handleStep($message)) return pdb_StepOverRequest::TYPE;
            break;
          case pdb_StepIntoRequest::TYPE:
            $message->ack();
            if ($this->handleStep($message)) return pdb_StepIntoRequest::TYPE;
            break;
          case pdb_StepOutRequest::TYPE:
            $message->ack();
            if ($this->handleStep($message)) return pdb_StepOutRequest::TYPE;
            break;
          case pdb_End::TYPE:
            $this->session->end();
          default: trigger_error("protocol error: $message", E_USER_ERROR);
          }
        }
      }
    }
    /**
     * @access private
     */
    abstract class pdb_MessageRequest extends pdb_Message {
      public abstract function ack();
    }

    /**
     * @access private
     */
    class pdb_Serializer {
      private $serial;
      private $depth;

      private function doSerialize ($o, $depth) {
        $serial = &$this->serial;

        switch(gettype($o)) {
        case 'object':
          $serial.="O:";
          $serial.=strlen(get_class($o));
          $serial.=":\"";
          $serial.=get_class($o);
          $serial.="\":";
          $serial.=count((array)$o);

          if ($depth <= $this->depth) {
            $serial.=":{";
            foreach((array)$o as $k=>$v) {
              $serial.=serialize($k);
              $this->doSerialize($v, $depth+1);
            }
            $serial.="}";
          } else {
            $serial .= ";";
          }
          break;

        case 'array':
          $serial.="a:";
          $serial.=count($o);

          if ($depth <= $this->depth) {
            $serial.=":{";
            foreach($o as $k=>$v) {
              $serial.=serialize($k);
              $this->doSerialize($v, $depth+1);
            }
            $serial.="}";
          } else {
            $serial.=";";
          }
          break;
        default:
          $serial.=serialize($o);
          break;
        }
      }

      public function serialize ($obj, $depth) {
        $this->serial = "";
        $this->depth = $depth;

        $this->doSerialize ($obj, 1);

        return $this->serial;
      }
    }

    /**
     * @access private
     */
    class pdb_DebugSessionStart extends pdb_Message {
      const TYPE = 2005;

      public $status;
      public $end;

      private $breakFirstLine;
      private $enable;
      public $uri;
      public $query;
      public $options;

      public $in, $out;
      private $outputNotification;

      public $lines;
      public $breakpoints;

      public $currentTopLevelFrame, $currentFrame;
      public $allFrames; // should be a weak map so that frames could be gc'ed

      public $ignoreInterrupt;

      public $serializer;

      public $includedScripts;

      public function getType() {
        return self::TYPE;
      }
      public function __construct($options) {
        parent::__construct($this);
        $this->end = true;
        if (isset($_SERVER["SCRIPT_FILENAME"]) && isset($_SERVER["QUERY_STRING"])&&!extension_loaded("Zend Debugger")) {
          $filename = $uri = $_SERVER["SCRIPT_FILENAME"];
          $queryStr = $_SERVER["QUERY_STRING"];
        } else { // PHPDebugger disabled
          global $pdb_script;
          $this->enable = false;
          if (isset($pdb_script) && $pdb_script!="@") {
            require_once($pdb_script);
          }
          return;
        }

        $params = explode('&', $queryStr);
        $args = array();
        for ($i=0; $i<count($params); $i++) {
            $arg=explode( '=', urldecode($params[$i]));
            $args[$arg[0]] = $arg[1];
        }
        $this->enable = $args["start_debug"];
        $this->breakFirstLine = isset($args["debug_stop"]) ? $args["debug_stop"] : 0;
        $this->uri = $uri;
        $this->query = $queryStr;
        $this->options = $options;
        $this->breakpoints = $this->lines = array();

        $this->serializer = new pdb_Serializer();

        $this->currentTopLevelFrame = $this->currentFrame = new pdb_Environment(null, $filename, false, 1);
        $this->allFrames[] = $this->currentFrame;
        $this->ignoreInterrupt = false;
        $this->includedScripts = array();

        $errno = 0; $errstr = "";
        $io = null;
        foreach(explode(",", $args["debug_host"]) as $host) {
            if ($io = fsockopen($host, $args['debug_port'], $errno, $errstr, 5)) {
                break;
            }
        }
        if ($io==null) {
            trigger_error("fsockopen", E_USER_ERROR);
        }
        $this->end = false;

        $this->in =new pdb_In($io, $this);
        $this->out=new pdb_Out($io, $this);
      }
      public function end() {
        $this->end = true;
        if (PDB_DEBUG) pdb_Logger::debug( "end() called");
        exit(0);
      }
      /**
       * @access private
       */
      public function flushOutput() {
        if (!isset($this->outputNotification))
          $this->outputNotification = $this->getMessageById(pdb_OutputNotification::TYPE);

        $this->outputNotification->setOutput(ob_get_contents());
        if (!PDB_DEBUG) ob_clean();
        $this->outputNotification->serialize();
      }

      /**
       * @access private
       */
      public function resolveIncludePath($scriptName) {
        if (file_exists($scriptName)) return realpath($scriptName);
        $paths = explode(PATH_SEPARATOR, get_include_path());
        $name = $scriptName;
        foreach ($paths as $path) {
          $scriptName = realpath("${path}${name}");
          if ($scriptName) return $scriptName;
        }
        trigger_error("file $scriptName not found", E_USER_ERROR);
      }

      public function serialize() {
        $out = $this->session->out;
        parent::serialize();
        $out->writeInt(2004102501);
        $out->writeString($this->currentFrame->filename);
        $out->writeString($this->uri);
        $out->writeString($this->query);
        $out->writeString($this->options);
        $out->flush();
        if (PDB_DEBUG) pdb_Logger::debug( "$this");
      }
      public function handleRequests () {
        if ($this->enable) {
          set_error_handler("pdb_error_handler");
          register_shutdown_function("pdb_shutdown");

          parent::handleRequests();
          if (PDB_DEBUG) pdb_Logger::debug( "exit({$this->status})");
          exit ($this->status); }
      }
      public function hasBreakpoint($scriptName, $line) {
        if ($this->breakFirstLine) {$this->breakFirstLine = false; return true;}

        if ($this->currentFrame->stepNext) return true;

        foreach ($this->breakpoints as $breakpoint) {
          if($breakpoint->type==1) {
            if ($breakpoint->file==$scriptName&&$breakpoint->line==$line) return true;
          }
        }

        return false;
      }
      function parseCode($filename, $contents) {
        $parser = new pdb_Parser($filename, $contents);
        return $parser->parseScript();
      }

      public function __toString() {
        return "pdb_DebugSessionStart: {$this->currentFrame->filename}";
      }
    }

    /**
     * @access private
     */
    class pdb_HeaderOutputNotification extends pdb_Message {
      const TYPE = 2008;
      private $out;

      public function setOutput($out) {
        $this->out = $out;
      }
      protected function getAsciiOutput() {
        return $this->out;
      }
      protected function getEncodedOutput () {
        return $this->out; //FIXME
      }
      protected function getOutput() {
        return $this->getAsciiOutput();
      }
      public function getType() {
        return self::TYPE;
      }

      public function serialize() {
        $out = $this->session->out;
        parent::serialize();
        $out->writeString($this->getOutput());
        $out->flush();
        if (PDB_DEBUG) pdb_Logger::debug( "$this");
      }
      public function __toString () {
        return "pdb_HeaderOutputNotification: ".$this->getOutput();
      }
    }

    /**
     * @access private
     */
    class pdb_OutputNotification extends pdb_HeaderOutputNotification {
      const TYPE = 2004;

      public function getType() {
        return self::TYPE;
      }
      protected function getOutput() {
        return $this->getEncodedOutput();
      }
      public function __toString () {
        return "pdb_OutputNotification: ".$this->getAsciiOutput();
      }
    }

    /**
     * @access private
     */
    class pdb_ErrorNotification extends pdb_Message {
      const TYPE = 2006;
      private $type, $filename, $lineno, $error;

      public function getType() {
        return self::TYPE;
      }
      public function setError($type, $filename, $lineno, $error) {
        $this->type = $type;
        $this->filename = $filename;
        $this->lineno = $lineno;
        $this->error = $error;
      }

      public function serialize() {
        $out = $this->session->out;
        parent::serialize();
        $out->writeInt($this->type);
        $out->writeString($this->filename);
        $out->writeInt($this->lineno);
        $out->writeString($this->error);
        $out->flush();
        if (PDB_DEBUG) pdb_Logger::debug( "$this");
      }
      public function __toString () {
        return "pdb_ErrorNotification: {$this->error} at {$this->filename} line {$this->lineno}";
      }
    }

    /**
     * @access private
     */
    class pdb_DebugScriptEndedNotification extends pdb_Message {
      const TYPE = 2002;

      public function getType() {
        return self::TYPE;
      }

      public function serialize() {
        $out = $this->session->out;
        parent::serialize();
        $out->writeShort($this->session->status);
        $out->flush();
        if (PDB_DEBUG) pdb_Logger::debug( "$this");
      }
      public function __toString () {
        return "pdb_DebugScriptEndedNotification: {$this->session->status}";
      }
    }

    /**
     * @access private
     */
    class pdb_ReadyNotification extends pdb_Message {
      const TYPE = 2003;

      public function getType() {
        return self::TYPE;
      }

      protected function handleStep($message) {
        return true;
      }

      public function serialize() {
        $out = $this->session->out;
        parent::serialize();
        $out->writeString($this->session->currentFrame->filename);
        $out->writeInt($this->session->currentFrame->line);
        $out->writeInt(0);
        $out->flush();
        if (PDB_DEBUG) pdb_Logger::debug( "$this");
      }
      public function __toString () {
        return "pdb_ReadyNotification: {$this->session->currentFrame->filename}, {$this->session->currentFrame->line}";
      }
    }

    /**
     * @access private
     */
    class pdb_SetProtocolRequest extends pdb_MessageRequest {
      const TYPE = 10000;
      public $id;
      public $protocolId;

      public function getType() {
        return self::TYPE;
      }
      public function deserialize() {
        $in = $this->session->in;
        $this->id = $in->readInt();
        $this->protocolId = $in->readInt();
        if (PDB_DEBUG) pdb_Logger::debug( "$this");
      }
      public function ack() {
        $res = new pdb_SetProtocolResponse($this);
        $res->serialize();
      }
      public function __toString () {
        return "pdb_SetProtocolRequest: ". $this->protocolId;
      }
    }

    /**
     * @access private
     */
    class pdb_SetProtocolResponse extends pdb_Message {
      const TYPE = 11000;
      private $req;

      public function __construct ($req) {
        parent::__construct($req->session);
        $this->req = $req;
      }

      public function getType() {
        return self::TYPE;
      }
      public function serialize() {
        $out = $this->session->out;
        parent::serialize();
        $out->writeInt($this->req->id);

        // use fixed id instead of $out->writeInt($this->req->protocolId);
        $out->writeInt(2012121702);

        $out->flush();
        if (PDB_DEBUG) pdb_Logger::debug( "$this");
      }
      public function __toString () {
        return "pdb_SetProtocolResponse: ";
      }
    }

    /**
     * @access private
     */
    class pdb_StartRequest extends pdb_MessageRequest {
      const TYPE = 1;
      public $id;
      public $protocolId;

      public function getType() {
        return self::TYPE;
      }
      public function deserialize() {
        $in = $this->session->in;
        $this->id = $in->readInt();
        if (PDB_DEBUG) pdb_Logger::debug( "$this");
      }

      public function ack() {
        $res = new pdb_StartResponse($this);
        $res->serialize();
      }
      public function __toString () {
        return "pdb_StartRequest: ";
      }
    }

    /**
     * @access private
     */
    class pdb_AddFilesRequest extends pdb_MessageRequest {
      const TYPE = 38;
      public $id;
      public $pathSize;
      public $paths;

      public function getType() {
        return self::TYPE;
      }
      public function deserialize() {
        $in = $this->session->in;
        $this->id = $in->readInt();
        $this->pathSize = $in->readInt();
        $this->paths = array();
        for($i=0; $i<$this->pathSize; $i++) {
           $this->paths[] = $in->readString();
        }
        if (PDB_DEBUG) pdb_Logger::debug( "$this");
      }

      public function ack() {
        $res = new pdb_AddFilesResponse($this);
        $res->serialize();
      }
      public function __toString () {
        return "pdb_AddFilesRequest: ";
      }
    }
    /**
     * @access private
     */
    class pdb_FileContentExtendedRequest extends pdb_MessageRequest {
      const TYPE = 10002;
      public $id;
      public $size;
      public $checksum;

      public function getType() {
        return self::TYPE;
      }
      public function deserialize() {
        $in = $this->session->in;
        $this->id = $in->readInt();
        $this->size = $in->readInt();
        $this->checksum = $in->readInt();

        if (PDB_DEBUG) pdb_Logger::debug( "$this");
      }

      public function ack() {
        $res = new pdb_FileContentExtendedResponse($this);
        $res->serialize();
      }
      public function __toString () {
        return "pdb_FileContentExtendedRequest: ";
      }
    }

    /**
     * @access private
     */
    class pdb_AddFilesResponse extends pdb_Message {
      const TYPE = 1038;
      private $req;

      public function __construct ($req) {
        parent::__construct($req->session);
        $this->req = $req;
      }

      public function getType() {
        return self::TYPE;
      }
      public function serialize() {
        $out = $this->session->out;
        parent::serialize();
        $out->writeInt($this->req->id);
        $out->writeInt(0);
        $out->flush();
        if (PDB_DEBUG) pdb_Logger::debug( "$this");
      }
      public function __toString () {
        return "pdb_AddFilesResponse: ";
      }
    }

    /**
     * @access private
     */
    class pdb_FileContentExtendedResponse extends pdb_Message {
      const TYPE = 11001;
      private $req;

      public function __construct ($req) {
        parent::__construct($req->session);
        $this->req = $req;
      }

      public function getType() {
        return self::TYPE;
      }
      public function serialize() {
        $out = $this->session->out;
        parent::serialize();
        $out->writeInt($this->req->id);
        $out->writeInt(0); // fixme: status
        $out->writeInt(0); // fixme: string: filecontent
        $out->flush();
        if (PDB_DEBUG) pdb_Logger::debug( "$this");
      }
      public function __toString () {
        return "pdb_FileContentExtendedResponse: ";
      }
    }

    /**
     * @access private
     */
    class pdb_StartResponse extends pdb_Message {
      const TYPE = 1001;
      private $req;

      public function __construct ($req) {
        parent::__construct($req->session);
        $this->req = $req;
      }

      public function getType() {
        return self::TYPE;
      }
      public function serialize() {
        $out = $this->session->out;
        parent::serialize();
        $out->writeInt($this->req->id);
        $out->writeInt(0);
        $out->flush();
        if (PDB_DEBUG) pdb_Logger::debug( "$this");
      }
      public function __toString () {
        return "pdb_StartResponse: ";
      }
    }
    /**
     * @access private
     */
    class pdb_StartProcessFileNotification extends pdb_Message {
      const TYPE = 2009;
      public function __construct ($session) {
        parent::__construct($session);
      }
      protected function handleContinueProcessFile($message) {
        return true; // next
      }
      public function getType() {
        return self::TYPE;
      }
      public function serialize() {
        $out = $this->session->out;
        parent::serialize();
        $out->writeString($this->session->currentFrame->filename);
        $out->flush();
        if (PDB_DEBUG) pdb_Logger::debug( "$this");
      }
      public function __toString () {
        return "pdb_StartProcessFileNotification: {$this->session->currentFrame->filename}";
      }
    }

    /**
     * @access private
     */
    class pdb_ContinueProcessFileNotification extends pdb_Message {
      const TYPE = 2010;
      public function getType() {
        return self::TYPE;
      }
      public function deserialize() {
        if (PDB_DEBUG) pdb_Logger::debug( "$this");
      }
      public function __toString () {
        return "pdb_ContinueProcessFileNotification: ";
      }
    }

    /**
     * @access private
     */
    class pdb_Breakpoint {
      public $type, $lifeTime, $file, $line, $condition;
      private $id;

      public function __construct($type, $lifeTime, $file, $line, $condition, $id) {
        $this->type = $type;
        $this->lifeTime = $lifeTime;
        $this->file = $file;
        $this->line = $line;
        $this->condition = $condition;
        $this->id = $id;
      }
      public function __toString () {
        return "pdb_Breakpoint: ";
      }
    }
    /**
     * @access private
     */
    class pdb_AddBreakpointResponse extends pdb_Message {
      const TYPE = 1021;
      private $req;
      private $id;

      private static function getId() {
        static $id = 0;
        return ++$id;
      }

      public function __construct($req) {
        parent::__construct($req->session);
        $this->req = $req;
        $this->id = self::getId();
        $this->session->breakpoints[$this->id] = new pdb_Breakpoint($req->type, $req->lifeTime, $req->file, $req->line, $req->condition, $this->id);
      }

      public function getType() {
        return self::TYPE;
      }
      public function serialize() {
        $out = $this->session->out;
        parent::serialize();
        $out->writeInt($this->req->id);
        $out->writeInt(0);
        $out->writeInt($this->id);
        $out->flush();
        if (PDB_DEBUG) pdb_Logger::debug( "$this");
      }
      public function __toString () {
        return "pdb_AddBreakpointResponse: {$this->id}";
      }
    }

    /**
     * @access private
     */
    class pdb_RemoveBreakpointResponse extends pdb_Message {
      const TYPE = 1022;
      private $req;
      private $id;
      private $failure;

      public function __construct($req) {
        parent::__construct($req->session);
        $this->req = $req;

        $this->remove();
      }

      protected function remove() {
        if (isset($this->session->breakpoints[$this->req->bpId])) {
          unset($this->session->breakpoints[$this->req->bpId]);
          $this->failure = 0;
        } else {
          $this->failure = -1;
        }
      }

      public function getType() {
        return self::TYPE;
      }
      public function serialize() {
        $out = $this->session->out;
        parent::serialize();
        $out->writeInt($this->req->id);
        $out->writeInt($this->failure);
        $out->flush();
        if (PDB_DEBUG) pdb_Logger::debug( "$this");
      }
      public function __toString () {
        return "pdb_RemoveBreakpointResponse: {$this->id}";
      }
    }
    /**
     * @access private
     */
    class pdb_RemoveAllBreakpointsResponse extends pdb_RemoveBreakpointResponse {
      const TYPE = 1023;
      public function __construct($req) {
        parent::__construct($req);
      }

      protected function remove() {
        $keys = array_keys($this->session->breakpoints);
        foreach($keys as $key)
          unset($this->session->breakpoints[$key]);

        $this->failure = 0;
      }

      public function getType() {
        return self::TYPE;
      }

      public function __toString () {
        return "pdb_RemoveAllBreakpoinstResponse: {$this->id}";
      }
    }

    /**
     * @access private
     */
    class pdb_AddBreakpointRequest extends pdb_MessageRequest {
      const TYPE = 21;
      public $id;
      public $type;
      public $lifeTime;

      public $file;
      public $line;

      public $condition;

      public function getType() {
        return self::TYPE;
      }
      public function deserialize() {
        $in = $this->session->in;
        $this->id = $in->readInt();
        $this->type = $in->readShort();
        $this->lifeType = $in->readShort();
        switch($this->type) {
        case 1:
          $this->file = $in->readString();
          $this->line = $in->readInt();
          break;
        case 2:
          $this->condition = $in->readString();
          break;
        default:
          trigger_error("invalid breakpoint", E_USER_ERROR);
        }
        if (PDB_DEBUG) pdb_Logger::debug( "$this");
      }
      public function ack() {
        $res = new pdb_AddBreakpointResponse ($this);
        $res->serialize();
      }
      public function __toString () {
        if ($this->type == 1)
          return "pdb_AddBreakpointRequest: {$this->file}, {$this->line}";
        else
          return "pdb_AddBreakpointRequest: {$this->condition}";
      }
    }
    /**
     * @access private
     */
    class pdb_RemoveAllBreakpointsRequest extends pdb_MessageRequest {
      const TYPE = 23;
      public $id;

      public function getType() {
        return self::TYPE;
      }
      public function deserialize() {
        $in = $this->session->in;
        $this->id = $in->readInt();
        if (PDB_DEBUG) pdb_Logger::debug( "$this");
      }
      public function ack() {
        $res = new pdb_RemoveAllBreakpointsResponse ($this);
        $res->serialize();
      }
      public function __toString () {
        return "pdb_RemoveAllBreakpointsRequest ";
      }
    }
    /**
     * @access private
     */
    class pdb_RemoveBreakpointRequest extends pdb_RemoveAllBreakpointsRequest {
      const TYPE = 22;
      public $bpId;

      public function getType() {
        return self::TYPE;
      }

      public function deserialize() {
        parent::deserialize();
        $in = $this->session->in;
        $this->bpId = $in->readInt();
        if (PDB_DEBUG) pdb_Logger::debug( "$this");
      }
      public function ack() {
        $res = new pdb_RemoveBreakpointResponse ($this);
        $res->serialize();
      }
      public function __toString () {
        return "pdb_RemoveBreakpointRequest: {$this->bpId}";
      }
    }

    /**
     * @access private
     */
    class pdb_GetCallStackResponse extends pdb_Message {
      const TYPE = 1034;
      private $req;

      public function __construct($req) {
        parent::__construct($req->session);
        $this->req = $req;
      }

      public function getType() {
        return self::TYPE;
      }
      public function serialize() {
        $out = $this->session->out;
        parent::serialize();
        $out->writeInt($this->req->id);

        for($frame=$this->session->currentFrame; $frame; $frame=$frame->parent)
          $environments[] = $frame;

        $environments = array_reverse($environments);
        $n = count($environments);

        $out->writeInt($n);
        for ($i=0; $i<$n; $i++) {
          $env = $environments[$i];
          $out->writeString($env->filename);
          $out->writeInt($env->line);
          $out->writeInt(0);
          $out->writeString($env->filename);
          $out->writeInt($env->firstLine);
          $out->writeInt(0);
          $out->writeInt(0); //fixme: params
        }

        $out->flush();
        if (PDB_DEBUG) pdb_Logger::debug( "$this");
      }
      public function __toString () {
        return "pdb_GetCallStackResponse: ";
      }
    }
    /**
     * @access private
     */
    class pdb_GetCallStackRequest extends pdb_MessageRequest {
      const TYPE = 34;
      public $id;

      public function getType() {
        return self::TYPE;
      }
      public function deserialize() {
        $in = $this->session->in;
        $this->id = $in->readInt();
        if (PDB_DEBUG) pdb_Logger::debug( "$this");
      }
      public function ack() {
        $res = new pdb_GetCallStackResponse ($this);
        $res->serialize();
      }
      public function __toString () {
        return "pdb_GetCallStackRequest: ";
      }
    }

    /**
     * @access private
     */
    class pdb_GetCWDResponse extends pdb_Message {
      const TYPE = 1036;
      private $req;

      public function __construct ($req) {
        parent::__construct($req->session);
        $this->req = $req;
      }

      public function getType() {
        return self::TYPE;
      }
      public function serialize() {
        $out = $this->session->out;
        parent::serialize();
        $out->writeInt($this->req->id);
        $out->writeInt(0);
        $out->writeString(getcwd());
        $out->flush();
        if (PDB_DEBUG) pdb_Logger::debug( "$this");
      }
      public function __toString () {
        return "pdb_GetCWDResponse: ";
      }
    }

    /**
     * @access private
     */
    class pdb_GetCWDRequest extends pdb_MessageRequest {
      const TYPE = 36;
      public $id;

      public function getType() {
        return self::TYPE;
      }
      public function deserialize() {
        $in = $this->session->in;
        $this->id = $in->readInt();
        if (PDB_DEBUG) pdb_Logger::debug( "$this");
      }
      public function ack() {
        $res = new pdb_GetCWDResponse($this);
        $res->serialize();
      }
      public function __toString () {
        return "pdb_GetCWDRequest: ";
      }
    }

    /**
     * @access private
     */
    class pdb_MsgEvalResponse extends pdb_Message {
      const TYPE = 1031;
      private $req;

      public function __construct ($req) {
        parent::__construct($req->session);
        $this->req = $req;
      }

      public function getType() {
        return self::TYPE;
      }

      public function serialize() {
        $out = $this->session->out;
        parent::serialize();
        $out->writeInt($this->req->id);
        if (PDB_DEBUG) pdb_Logger::debug( "evalcode:::".$this->req->code."\n");
        $error = 0;
        $code = $this->req->code;
        $res = eval("return $code ?>");
        $out->writeInt($error);
        $out->writeString($res);

        if (PDB_DEBUG) pdb_Logger::debug("pdb_MsgEvalResponse: ".print_r($res, true));
        $out->flush();
      }
      public function __toString () {
        return "pdb_MsgEvalResponse: ";
      }
    }
    /**
     * @access private
     */
    class pdb_GetVariableValueResponse extends pdb_Message {
      const TYPE = 1032;
      private $req;

      public function __construct ($req) {
        parent::__construct($req->session);
        $this->req = $req;
      }

      public function getType() {
        return self::TYPE;
      }

      public function serialize() {
        $out = $this->session->out;
        parent::serialize();
        $out->writeInt($this->req->id);
        if (PDB_DEBUG) pdb_Logger::debug( "evalcode:::".$this->req->code."\n");
        $error = 0;
        if ($this->req->code[0]=='$') {

          $this->session->end = true;
          $key = substr($this->req->code, 1);
          if (isset($this->session->currentFrame->vars[$key])) {
            $var = $this->session->currentFrame->vars[$key];
            $paths = $this->req->paths;
            foreach ($paths as $path) {
              if (is_object($var)) {
                $var = $var->$path;
              } else {
                $var = $var[$path];
              }
            }
          } else {
            $var = "${key} not found!";
            $error = -1;
          }
          $ser = $this->session->serializer->serialize($var, $this->req->depth);
          $this->session->end = false;

          $out->writeInt($error);
          $out->writeString($ser);
          if (PDB_DEBUG) pdb_Logger::debug("pdb_GetVariableValueResponse: ".print_r($var, true).": ${ser}, error: ${error}");
        } else {
          if (PDB_DEBUG) pdb_Logger::debug(print_r($this->session->currentFrame->vars, true));

          $this->session->end = true;
          $vars = $this->session->currentFrame->vars;
          $ser = $this->session->serializer->serialize($vars, $this->req->depth);
          $this->session->end = false;

          $out->writeInt($error);
          $out->writeString($ser);
          if (PDB_DEBUG) pdb_Logger::debug("pdb_GetVariableValueResponse: ".print_r($vars, true).": ${ser}, error: ${error}");
        }
        $out->flush();
      }
      public function __toString () {
        return "pdb_GetVariableValueResponse: ";
      }
    }

    /**
     * @access private
     */
    class pdb_MsgEvalRequest extends pdb_MessageRequest {
      const TYPE = 31;
      public $id;
      public $code;

      public function getType() {
        return self::TYPE;
      }
      public function deserialize() {
        $in = $this->session->in;
        $this->id = $in->readInt();
        $this->code = $in->readString();

        if (PDB_DEBUG) pdb_Logger::debug( "$this");
      }
      public function ack() {
        $res = new pdb_MsgEvalResponse($this);
        $res->serialize();
      }
      public function __toString () {
        return "pdb_MsgEvalRequest: {$this->code}";
      }
    }

    /**
     * @access private
     */
    class pdb_GetVariableValueRequest extends pdb_MessageRequest {
      const TYPE = 32;
      public $id;
      public $code;
      public $depth;
      public $paths;

      public function getType() {
        return self::TYPE;
      }
      public function deserialize() {
        $in = $this->session->in;
        $this->id = $in->readInt();
        $this->code = $in->readString();
        $this->depth = $in->readInt();

        $this->paths = array();
        $length = $in->readInt();
        while($length--) {
          $this->paths[] = $in->readString();
        }
        if (PDB_DEBUG) pdb_Logger::debug( "$this");
      }
      public function ack() {
        $res = new pdb_GetVariableValueResponse($this);
        $res->serialize();
      }
      public function __toString () {
        return "pdb_GetVariableValueRequest: {$this->code}, {$this->depth}, paths::".print_r($this->paths, true);
      }
    }

    /**
     * @access private
     */
    class pdb_StepOverResponse extends pdb_Message {
      const TYPE = 1012;
      private $req;

      public function __construct($req) {
        parent::__construct($req->session);
        $this->req = $req;
      }

      public function getType() {
        return self::TYPE;
      }
      public function serialize() {
        $out = $this->req->session->out;
        parent::serialize();
        $out->writeInt($this->req->id);
        $out->writeInt(0);
        $out->flush();
        if (PDB_DEBUG) pdb_Logger::debug( "$this");
      }
      public function __toString () {
        return "pdb_StepOverResponse: ";
      }
    }

    /**
     * @access private
     */
    class pdb_StepOverRequest extends pdb_MessageRequest {
      const TYPE = 12;
      public $id;

      public function getType() {
        return self::TYPE;
      }
      public function deserialize() {
        $in = $this->session->in;
        $this->id = $in->readInt();
        if (PDB_DEBUG) pdb_Logger::debug( "$this");
      }
      public function ack() {
        $res = new pdb_StepOverResponse($this);
        $res->serialize();
      }
      public function __toString () {
        return "pdb_StepOverRequest: ";
      }
    }

    /**
     * @access private
     */
    class pdb_StepIntoResponse extends pdb_StepOverResponse {
      const TYPE = 1011;
      public function getType() {
        return self::TYPE;
      }
      public function __toString () {
        return "pdb_StepIntoResponse: ";
      }
    }

    /**
     * @access private
     */
    class pdb_StepIntoRequest extends pdb_StepOverRequest {
      const TYPE = 11;
      public function getType() {
        return self::TYPE;
      }
      public function ack() {
        $res = new pdb_StepIntoResponse($this);
        $res->serialize();
      }
      public function __toString () {
        return "pdb_StepIntoRequest: ";
      }
    }

    /**
     * @access private
     */
    class pdb_StepOutResponse extends pdb_StepOverResponse {
      const TYPE = 1013;
      public function getType() {
        return self::TYPE;
      }
      public function __toString () {
        return "pdb_StepOutResponse: ";
      }
    }

    /**
     * @access private
     */
    class pdb_StepOutRequest extends pdb_StepOverRequest {
      const TYPE = 13;
      public function getType() {
        return self::TYPE;
      }
      public function ack() {
        $res = new pdb_StepOutResponse($this);
        $res->serialize();
      }
      public function __toString () {
        return "pdb_OutIntoRequest: ";
      }
    }

    /**
     * @access private
     */
    class pdb_GoResponse extends pdb_Message {
      const TYPE = 1014;
      private $req;

      public function __construct ($req) {
        parent::__construct($req->session);
        $this->req = $req;
      }

      public function getType() {
        return self::TYPE;
      }
      public function serialize() {
        $out = $this->session->out;
        parent::serialize();
        $out->writeInt($this->req->id);
        $out->writeInt(0);
        $out->flush();
        if (PDB_DEBUG) pdb_Logger::debug( "$this");
      }
      public function __toString () {
        return "pdb_GoResponse: ";
      }
    }

    /**
     * @access private
     */
    class pdb_GoRequest extends pdb_MessageRequest {
      const TYPE = 14;
      public $id;

      public function getType() {
        return self::TYPE;
      }
      public function deserialize() {
        $in = $this->session->in;
        $this->id = $in->readInt();
        if (PDB_DEBUG) pdb_Logger::debug( "$this");
      }
      public function ack() {
        $res = new pdb_GoResponse($this);
        $res->serialize();
      }
      public function __toString () {
        return "pdb_GoRequest: ";
      }
    }
    /**
     * @access private
     */
    class pdb_End extends pdb_Message {
      const TYPE = 3;
      public $id;

      public function getType() {
        return self::TYPE;
      }
      public function deserialize() {
        if (PDB_DEBUG) pdb_Logger::debug( "$this");
      }
      public function __toString () {
        return "pdb_End: ";
      }
    }

    /**
     * @access private
     */
    class pdb_In {
      private $in;
      private $len;
      private $session;

      public function __construct($in, $session) {
        $this->in = $in;
        $this->len = 0;
        $this->session = $session;
      }
      private function readBytes($n) {
        $str = "";
        while ($n) {
          $s = fread($this->in, $n);
          if (feof($this->in)) $this->session->end();

          $n -= strlen($s);

          $str.=$s;
        }
        return $str;
      }
      public function read() {
        if(!$this->len) {
          $str = $this->readBytes(4);
          $lenDesc = unpack("N", $str);
          $this->len = array_pop($lenDesc);
        }
      }
      public function readShort() {
        $this->read();

        $this->len-=2;
        $str = $this->readBytes(2);
        $lenDesc = unpack("n", $str);
        return array_pop($lenDesc);
      }
      public function readInt() {
        $this->read();

        $this->len-=4;
        $str = $this->readBytes(4);
        $lenDesc = unpack("N", $str);
        return array_pop($lenDesc);
      }
      public function readString() {
        $this->read();

        $length = $this->readInt();
        $this->len-=$length;
        return $this->readBytes($length);
      }
      public function __toString () {
        return "pdb_In: ";
      }
    }
    /**
     * @access private
     */
    class pdb_Out {
      private $out;
      private $buf;
      private $session;

      public function __construct($out, $session) {
        $this->out = $out;
        $this->buf = "";
        $this->session = $session;
      }

      public function writeShort($val) {
        $this->buf.=pack("n", $val);
      }
      public function writeInt($val) {
        $this->buf.=pack("N", $val);
      }
      public function writeString($str) {
        $length = strlen($str);
        $this->writeInt($length);
        $this->buf.=$str;
      }
      public function writeUTFString($str) {
        $this->writeString(urlencode($str));
      }
      public function flush() {
        $length = strlen($this->buf);
        $this->buf = pack("N", $length).$this->buf;
        fwrite($this->out, $this->buf);
        if (feof($this->out)) $this->session->end();
        $this->buf = "";
      }
      public function __toString () {
        return "pdb_Out: ";
      }
    }
    $pdb_dbg = new pdb_DebugSessionStart("&debug_fastfile=1");
    pdb_Message::register(new pdb_SetProtocolRequest($pdb_dbg));
    pdb_Message::register(new pdb_StartRequest($pdb_dbg));
    pdb_Message::register(new pdb_AddFilesRequest($pdb_dbg));
    pdb_Message::register(new pdb_FileContentExtendedRequest($pdb_dbg));
    pdb_Message::register(new pdb_ContinueProcessFileNotification($pdb_dbg));
    pdb_Message::register(new pdb_AddBreakpointRequest($pdb_dbg));
    pdb_Message::register(new pdb_RemoveBreakpointRequest($pdb_dbg));
    pdb_Message::register(new pdb_RemoveAllBreakpointsRequest($pdb_dbg));
    pdb_Message::register(new pdb_GetCallStackRequest($pdb_dbg));
    pdb_Message::register(new pdb_GetCWDRequest($pdb_dbg));
    pdb_Message::register(new pdb_GetVariableValueRequest($pdb_dbg));
    pdb_Message::register(new pdb_MsgEvalRequest($pdb_dbg));
    pdb_Message::register(new pdb_StepOverRequest($pdb_dbg));
    pdb_Message::register(new pdb_StepIntoRequest($pdb_dbg));
    pdb_Message::register(new pdb_StepOutRequest($pdb_dbg));
    pdb_Message::register(new pdb_GoRequest($pdb_dbg));
    pdb_Message::register(new pdb_End($pdb_dbg));

    pdb_Message::register(new pdb_StartProcessFileNotification($pdb_dbg));
    pdb_Message::register(new pdb_ReadyNotification($pdb_dbg));
    pdb_Message::register(new pdb_DebugScriptEndedNotification($pdb_dbg));
    pdb_Message::register(new pdb_HeaderOutputNotification($pdb_dbg));
    pdb_Message::register(new pdb_OutputNotification($pdb_dbg));
    pdb_Message::register(new pdb_ErrorNotification($pdb_dbg));

    /**
     * @access private
     */
    function pdb_getDefinedVars($vars1, $vars2) {
      //if(isset($vars2)) $vars1['pbd_This'] = $vars2;

      unset($vars1['__pdb_Code']);       // see pdb_Message::doEval()

      return $vars1;
    }
    /**
     * @access private
     */
    function pdb_startCall($scriptName, $line) {
      global $pdb_dbg;

      $stepNext = $pdb_dbg->currentFrame->stepNext == pdb_StepIntoRequest::TYPE ? pdb_StepIntoRequest::TYPE : false;

      pdb_Logger::debug("startCall::$scriptName, $stepNext");

      $env = new pdb_Environment($pdb_dbg->currentFrame, $scriptName, $stepNext, $line);
      $pdb_dbg->allFrames[] = $env;

      return $env;
    }

    /**
     * @access private
     */
    function pdb_startInclude($scriptName, $once) {
      global $pdb_dbg;

      $scriptName = $pdb_dbg->resolveIncludePath($scriptName);

      // include only from a top-level environment
      // initial line# and vars may be wrong due to a side-effect in step
      $pdb_dbg->session->currentFrame = $pdb_dbg->session->currentTopLevelFrame;

      $stepNext = $pdb_dbg->currentFrame->stepNext == pdb_StepIntoRequest::TYPE ? pdb_StepIntoRequest::TYPE : false;
      $pdb_dbg->currentFrame = new pdb_Environment($pdb_dbg->currentFrame, $scriptName, $stepNext, 1);
      $pdb_dbg->allFrames[] = $pdb_dbg->currentFrame;

      /* BEGIN: StartProcessFileNotification */
      $pdb_dbg->getMessageById(pdb_StartProcessFileNotification::TYPE)->handleRequests();
      /* ...  set breakpoints ... */
      /* END: ContinueProcessFileNotification */

      if ($once && isset($pdb_dbg->includedScripts[$scriptName]))
        $code = "<?php ?>";
      else
        $code = $pdb_dbg->parseCode(realpath($scriptName), file_get_contents($scriptName));

      $pdb_dbg->currentTopLevelFrame = $pdb_dbg->currentFrame;

      if (PDB_DEBUG) pdb_Logger::debug("include:::$code");

      if ($once) $pdb_dbg->includedScripts[$scriptName] = true;
      return $code; // eval -> pdb_step/MSG_READY or pdb_endInclude/MSG_READY OR FINISH
    }
    /**
     * @access private
     */
    function pdb_endInclude() {
      global $pdb_dbg;

      $pdb_dbg->currentFrame = $pdb_dbg->currentTopLevelFrame = $pdb_dbg->currentTopLevelFrame->parent;
    }

    /**
     * @access private
     */
    function pdb_step($filename, $line, $vars) {
      global $pdb_dbg;
      if ($pdb_dbg->ignoreInterrupt) return;

      $pdb_dbg->ignoreInterrupt = true;

      // pull the current frame from the stack or the top-level environment
      $pdb_dbg->currentFrame = (isset($vars['__pdb_CurrentFrame'])) ? $vars['__pdb_CurrentFrame'] : $pdb_dbg->currentTopLevelFrame;
      unset($vars['__pdb_CurrentFrame']);

      $pdb_dbg->currentFrame->update($line, $vars);

      if ($pdb_dbg->hasBreakpoint($filename, $line)) {
        $pdb_dbg->flushOutput();
        $stepNext = $pdb_dbg->getMessageById(pdb_ReadyNotification::TYPE)->handleRequests();
        pdb_Logger::logDebug("continue");
        /* clear all dynamic breakpoints */
        foreach ($pdb_dbg->allFrames as $currentFrame)
          $currentFrame->stepNext = false;

        /* set new dynamic breakpoint */
        if ($stepNext != pdb_GoRequest::TYPE) {
          $currentFrame = $pdb_dbg->currentFrame;

          /* break in current frame or frame below */
          if ($stepNext != pdb_StepOutRequest::TYPE)
            $currentFrame->stepNext = $stepNext;

          /* or break in any parent */
          while ($currentFrame = $currentFrame->parent) {
            $currentFrame->stepNext = $stepNext;
          }
        }
      }
      $pdb_dbg->ignoreInterrupt = false;
    }

    /**
     * @access private
     */
    function pdb_error_handler($errno, $errstr, $errfile, $errline) {
      global $pdb_dbg;
      if (PDB_DEBUG) pdb_Logger::debug("PHP error $errno: $errstr in $errfile line $errline");
      if ($pdb_dbg->end) return false;

      $msg = $pdb_dbg->getMessageById(pdb_ErrorNotification::TYPE);
      $msg->setError($errno, $errfile, $errline, $errstr);
      $msg->serialize();
      return true;
    }

    /**
     * @access private
     */
    function pdb_shutdown() {
      global $pdb_dbg;
      if (PDB_DEBUG) pdb_Logger::debug("PHP error: ".print_r(error_get_last(), true));
      if ($pdb_dbg->end) return;

      $error = error_get_last();
      if ($error) {
        $msg = $pdb_dbg->getMessageById(pdb_ErrorNotification::TYPE);
        $msg->setError($error['type'], $error['file'], $error['line'], $error['message']);
        $msg->serialize();
      }
    }

    function pdb_getDebugHeader($name,$array) {
      if (array_key_exists($name,$array)) return $array[$name];
      $name="HTTP_$name";
      if (array_key_exists($name,$array)) return $array[$name];
      return null;
    }

    if (!isset($java_include_only) && isset($pdb_script) && $pdb_script!="@") { // not called from JavaProxy.php and pdb_script is set
        chdir (dirname ($pdb_script));
        $pdb_dbg->handleRequests();
    }

    ?>