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();
}

?>