/hphp/test/quick/fsc.php

https://github.com/tstarling/hiphop-php · PHP · 481 lines · 445 code · 11 blank · 25 comment · 0 complexity · 2475a8f9a20260aa1cfef0881943e579 MD5 · raw file 

    

  1. <?php
    2. 

  2. error_reporting(-1);
    3. 

  3. 

  4. class A {
    5. 

  5.   public function foo() {
    6. 

  6.     echo __CLASS__ . ' ' . get_called_class() . ' ' .
    7. 

  7.          (isset($this) ? get_class($this) : '') . "\n";
    8. 

  8.   }
    9. 

  9.   public static function bar() {
    10. 

  10.     echo __CLASS__ . ' ' . get_called_class() . ' ' .
    11. 

  11.          (isset($this) ? get_class($this) : '') . "\n";
    12. 

  12.   }
    13. 

  13. }
    14. 

  14. 

  15. class B extends A {
    16. 

  16.   public function foo() {
    17. 

  17.     echo __CLASS__ . ' ' . get_called_class() . ' ' .
    18. 

  18.          (isset($this) ? get_class($this) : '') . "\n";
    19. 

  19.   }
    20. 

  20.   public static function bar() {
    21. 

  21.     echo __CLASS__ . ' ' . get_called_class() . ' ' .
    22. 

  22.          (isset($this) ? get_class($this) : '') . "\n";
    23. 

  23.   }
    24. 

  24.   public function doFoo() {
    25. 

  25.     $this->foo();  // B B B
    26. 

  26.     B::foo();      // B B B
    27. 

  27.     C::foo();      // C C   (Zend outputs: C B B) (Rule 1)
    28. 

  28.     D::foo();      // D D   (Zend outputs: D B B) (Rule 1)
    29. 

  29.     F::foo();      // F F   (Zend outputs: F B B) (Rule 1)
    30. 

  30.     G::foo();      // G G   (Zend outputs: G B B) (Rule 1)
    31. 

  31.     H::foo();      // H H   (Zend outputs: H B B) (Rule 1)
    32. 

  32.     parent::foo(); // A B B
    33. 

  33.     self::foo();   // B B B
    34. 

  34.     static::foo(); // B B B
    35. 

  35.     echo "****************\n";
    36. 

  36.   }
    37. 

  37.   public function doBar() {
    38. 

  38.     $this->bar();  // B B
    39. 

  39.     B::bar();      // B B
    40. 

  40.     C::bar();      // C C
    41. 

  41.     D::bar();      // D D
    42. 

  42.     F::bar();      // F F
    43. 

  43.     G::bar();      // G G
    44. 

  44.     H::bar();      // H H
    45. 

  45.     parent::bar(); // A B
    46. 

  46.     self::bar();   // B B
    47. 

  47.     static::bar(); // B B
    48. 

  48.     echo "****************\n";
    49. 

  49.   }
    50. 

  50. }
    51. 

  51. 

  52. class C extends B {
    53. 

  53.   public function foo() {
    54. 

  54.     echo __CLASS__ . ' ' . get_called_class() . ' ' .
    55. 

  55.          (isset($this) ? get_class($this) : '') . "\n";
    56. 

  56.   }
    57. 

  57.   public static function bar() {
    58. 

  58.     echo __CLASS__ . ' ' . get_called_class() . ' ' .
    59. 

  59.          (isset($this) ? get_class($this) : '') . "\n";
    60. 

  60.   }
    61. 

  61.   /**
    62. 

  62.    * Zend's implementation of call_user_func() and forward_static_call() has
    63. 

  63.    * a few corner cases where its behavior is strictly incorrect. HipHop will
    64. 

  64.    * match Zend's behavior except for cases that violate one of the following
    65. 

  65.    * invariants:
    66. 

  66.    *   1) If the current instance ($this) is non-null, the class of the current
    67. 

  67.    *      instance must be the same or a descendent of the class enclosing the
    68. 

  68.    *      current method. The PHP group is in the process of depracating this
    69. 

  69.    *      behavior. HipHop explicitly lists this in the inconsistencies doc.
    70. 

  70.    *   2) If the current instance ($this) is non-null, the class of the current
    71. 

  71.    *      instance must be the same as the current late bound class (aka the
    72. 

  72.    *      "called class"). This invariant is stated explicitly in Zend PHP's
    73. 

  73.    *      documentation: "In non-static contexts, the called class will be the
    74. 

  74.    *      class of the object instance."
    75. 

  75.    *   3) Normal style calls and call_user_func style calls should produce
    76. 

  76.    *      consistent results aside from any exceptions mentioned in Zend PHP's
    77. 

  77.    *      documentation. Therefore, "B::foo()" and "call_user_func('B::foo')"
    78. 

  78.    *      and "call_user_func(array('B', 'foo'))" should all produce consistent
    79. 

  79.    *      results.
    80. 

  80.    *   4) call_user_func() and forward_static_call() must never forward the
    81. 

  81.    *      caller's late bound class to the callee if the late bound class is
    82. 

  82.    *      not the same or a descendent of the class enclosing the method.
    83. 

  83.    *      Zend's implementation of forward_static_call contains a check for
    84. 

  84.    *      this, implying intent to uphold this invariant. 
    85. 

  85.    */
    86. 

  86.   public function testFoo1() {
    87. 

  87.     echo "############# testFoo1 ##############\n";
    88. 

  88.     B::foo(); // B D D
    89. 

  89.     C::foo(); // C D D
    90. 

  90.     D::foo(); // D D D
    91. 

  91.     F::foo(); // F F    (Zend: F D D) (Rule 1)
    92. 

  92.     G::foo(); // G G    (Zend: G D D) (Rule 1)
    93. 

  93.     H::foo(); // H H    (Zend: H D D) (Rule 1)
    94. 

  94.     parent::foo(); // B D D
    95. 

  95.     self::foo();   // C D D
    96. 

  96.     static::foo(); // D D D
    97. 

  97.     echo "****************\n";
    98. 

  98.     forward_static_call(array('B','foo')); // B D D
    99. 

  99.     forward_static_call(array('C','foo')); // C D D
    100. 

  100.     forward_static_call(array('D','foo')); // D D D
    101. 

  101.     forward_static_call(array('F','foo')); // F F
    102. 

  102.     forward_static_call(array('G','foo')); // G G
    103. 

  103.     forward_static_call(array('H','foo')); // H H
    104. 

  104.     forward_static_call(array('parent','foo')); // B D D
    105. 

  105.     forward_static_call(array('self','foo'));   // C D D
    106. 

  106.     forward_static_call(array('static','foo')); // D D D
    107. 

  107.     echo "****************\n";
    108. 

  108.     forward_static_call('B::foo'); // B D D
    109. 

  109.     forward_static_call('C::foo'); // C D D
    110. 

  110.     forward_static_call('D::foo'); // D D D
    111. 

  111.     forward_static_call('F::foo'); // F F
    112. 

  112.     forward_static_call('G::foo'); // G G
    113. 

  113.     forward_static_call('H::foo'); // H H
    114. 

  114.     forward_static_call('parent::foo'); // B D D
    115. 

  115.     forward_static_call('self::foo');   // C D D
    116. 

  116.     forward_static_call('static::foo'); // D D D
    117. 

  117.     echo "****************\n";
    118. 

  118.     forward_static_call(array('B','B::foo')); // B D D
    119. 

  119.     forward_static_call(array('B','C::foo')); // warning
    120. 

  120.     forward_static_call(array('B','D::foo')); // warning
    121. 

  121.     forward_static_call(array('B','F::foo')); // warning
    122. 

  122.     forward_static_call(array('B','G::foo')); // warning
    123. 

  123.     forward_static_call(array('B','H::foo')); // warning
    124. 

  124.     forward_static_call(array('B','parent::foo')); // A D D
    125. 

  125.     forward_static_call(array('B','self::foo'));   // B D D
    126. 

  126.     forward_static_call(array('B','static::foo')); // warning
    127. 

  127.     echo "****************\n";
    128. 

  128.     forward_static_call(array('G','B::foo')); // warning
    129. 

  129.     forward_static_call(array('G','C::foo')); // warning
    130. 

  130.     forward_static_call(array('G','D::foo')); // warning
    131. 

  131.     forward_static_call(array('G','F::foo')); // F F
    132. 

  132.     forward_static_call(array('G','G::foo')); // G G
    133. 

  133.     forward_static_call(array('G','H::foo')); // warning
    134. 

  134.     forward_static_call(array('G','parent::foo')); // F F (Zend: F D D) (Rule 1)
    135. 

  135.     forward_static_call(array('G','self::foo'));   // G G (Zend: G D D) (Rule 1)
    136. 

  136.     forward_static_call(array('G','static::foo')); // warning
    137. 

  137.     echo "****************\n";
    138. 

  138.     $b = new B;
    139. 

  139.     forward_static_call(array($b,'foo'));    // B B B  (Zend: B D B) (Rule 2)
    140. 

  140.     forward_static_call(array($b,'B::foo')); // B B B  (Zend: B D B) (Rule 2)
    141. 

  141.     forward_static_call(array($b,'C::foo')); // warning
    142. 

  142.     forward_static_call(array($b,'D::foo')); // warning
    143. 

  143.     forward_static_call(array($b,'F::foo')); // warning
    144. 

  144.     forward_static_call(array($b,'G::foo')); // warning
    145. 

  145.     forward_static_call(array($b,'H::foo')); // warning
    146. 

  146.     forward_static_call(array($b,'parent::foo')); // A B B (Zend: A D B) (Rule2)
    147. 

  147.     forward_static_call(array($b,'self::foo'));   // B B B (Zend: B D B) (Rule2)
    148. 

  148.     forward_static_call(array($b,'static::foo')); // warning
    149. 

  149.     echo "****************\n";
    150. 

  150.     $g = new G;
    151. 

  151.     forward_static_call(array($g,'foo'));    // G G G
    152. 

  152.     forward_static_call(array($g,'B::foo')); // warning
    153. 

  153.     forward_static_call(array($g,'C::foo')); // warning
    154. 

  154.     forward_static_call(array($g,'D::foo')); // warning
    155. 

  155.     forward_static_call(array($g,'F::foo')); // F G G
    156. 

  156.     forward_static_call(array($g,'G::foo')); // G G G
    157. 

  157.     forward_static_call(array($g,'H::foo')); // warning
    158. 

  158.     forward_static_call(array($g,'parent::foo')); // F G G
    159. 

  159.     forward_static_call(array($g,'self::foo'));   // G G G
    160. 

  160.     forward_static_call(array($g,'static::foo')); // warning
    161. 

  161.     echo "****************\n";
    162. 

  162.   }
    163. 

  163.   public static function testFoo2() {
    164. 

  164.     echo "############# testFoo2 ##############\n";
    165. 

  165.     B::foo(); // B B
    166. 

  166.     C::foo(); // C C
    167. 

  167.     D::foo(); // D D
    168. 

  168.     F::foo(); // F F
    169. 

  169.     G::foo(); // G G
    170. 

  170.     H::foo(); // H H
    171. 

  171.     parent::foo(); // B D
    172. 

  172.     self::foo();   // C D
    173. 

  173.     static::foo(); // D D
    174. 

  174.     echo "****************\n";
    175. 

  175.     forward_static_call(array('B','foo')); // B D
    176. 

  176.     forward_static_call(array('C','foo')); // C D
    177. 

  177.     forward_static_call(array('D','foo')); // D D
    178. 

  178.     forward_static_call(array('F','foo')); // F F
    179. 

  179.     forward_static_call(array('G','foo')); // G G
    180. 

  180.     forward_static_call(array('H','foo')); // H H
    181. 

  181.     forward_static_call(array('parent','foo')); // B D
    182. 

  182.     forward_static_call(array('self','foo'));   // C D
    183. 

  183.     forward_static_call(array('static','foo')); // D D
    184. 

  184.     echo "****************\n";
    185. 

  185.     forward_static_call('B::foo'); // B D
    186. 

  186.     forward_static_call('C::foo'); // C D
    187. 

  187.     forward_static_call('D::foo'); // D D
    188. 

  188.     forward_static_call('F::foo'); // F F
    189. 

  189.     forward_static_call('G::foo'); // G G
    190. 

  190.     forward_static_call('H::foo'); // H H
    191. 

  191.     forward_static_call('parent::foo'); // B D
    192. 

  192.     forward_static_call('self::foo');   // C D
    193. 

  193.     forward_static_call('static::foo'); // D D
    194. 

  194.     echo "****************\n";
    195. 

  195.     forward_static_call(array('B','B::foo')); // B D
    196. 

  196.     forward_static_call(array('B','C::foo')); // warning
    197. 

  197.     forward_static_call(array('B','D::foo')); // warning
    198. 

  198.     forward_static_call(array('B','F::foo')); // warning
    199. 

  199.     forward_static_call(array('B','G::foo')); // warning
    200. 

  200.     forward_static_call(array('B','H::foo')); // warning
    201. 

  201.     forward_static_call(array('B','parent::foo')); // A D
    202. 

  202.     forward_static_call(array('B','self::foo'));   // B D
    203. 

  203.     forward_static_call(array('B','static::foo')); // warning
    204. 

  204.     echo "****************\n";
    205. 

  205.     forward_static_call(array('G','B::foo')); // warning
    206. 

  206.     forward_static_call(array('G','C::foo')); // warning
    207. 

  207.     forward_static_call(array('G','D::foo')); // warning
    208. 

  208.     forward_static_call(array('G','F::foo')); // F F
    209. 

  209.     forward_static_call(array('G','G::foo')); // G G
    210. 

  210.     forward_static_call(array('G','H::foo')); // warning
    211. 

  211.     forward_static_call(array('G','parent::foo')); // F F  (Zend: F D) (Rule 4)
    212. 

  212.     forward_static_call(array('G','self::foo'));   // G G  (Zend: G D) (Rule 4)
    213. 

  213.     forward_static_call(array('G','static::foo'));
    214. 

  214.     echo "****************\n";
    215. 

  215.     $b = new B;
    216. 

  216.     forward_static_call(array($b,'foo'));    // B B B
    217. 

  217.     forward_static_call(array($b,'B::foo')); // B B B
    218. 

  218.     forward_static_call(array($b,'C::foo')); // warning
    219. 

  219.     forward_static_call(array($b,'D::foo')); // warning
    220. 

  220.     forward_static_call(array($b,'F::foo')); // warning
    221. 

  221.     forward_static_call(array($b,'G::foo')); // warning
    222. 

  222.     forward_static_call(array($b,'H::foo')); // warning
    223. 

  223.     forward_static_call(array($b,'parent::foo')); // A B B
    224. 

  224.     forward_static_call(array($b,'self::foo'));   // B B B
    225. 

  225.     forward_static_call(array($b,'static::foo')); // warning
    226. 

  226.     echo "****************\n";
    227. 

  227.     $g = new G;
    228. 

  228.     forward_static_call(array($g,'foo'));    // G G G
    229. 

  229.     forward_static_call(array($g,'B::foo')); // warning
    230. 

  230.     forward_static_call(array($g,'C::foo')); // warning
    231. 

  231.     forward_static_call(array($g,'D::foo')); // warning
    232. 

  232.     forward_static_call(array($g,'F::foo')); // F G G
    233. 

  233.     forward_static_call(array($g,'G::foo')); // G G G
    234. 

  234.     forward_static_call(array($g,'H::foo')); // warning
    235. 

  235.     forward_static_call(array($g,'parent::foo')); // F G G
    236. 

  236.     forward_static_call(array($g,'self::foo'));   // G G G
    237. 

  237.     forward_static_call(array($g,'static::foo')); // warning
    238. 

  238.     echo "****************\n";
    239. 

  239.   }
    240. 

  240.   public function testBar1() {
    241. 

  241.     echo "############# testBar1 ##############\n";
    242. 

  242.     B::bar(); // B B
    243. 

  243.     C::bar(); // C C
    244. 

  244.     D::bar(); // D D
    245. 

  245.     F::bar(); // F F
    246. 

  246.     G::bar(); // G G
    247. 

  247.     H::bar(); // H H
    248. 

  248.     parent::bar(); // B D
    249. 

  249.     self::bar();   // C D
    250. 

  250.     static::bar(); // D D
    251. 

  251.     echo "****************\n";
    252. 

  252.     forward_static_call(array('B','bar')); // B D
    253. 

  253.     forward_static_call(array('C','bar')); // C D
    254. 

  254.     forward_static_call(array('D','bar')); // D D
    255. 

  255.     forward_static_call(array('F','bar')); // F F
    256. 

  256.     forward_static_call(array('G','bar')); // G G
    257. 

  257.     forward_static_call(array('H','bar')); // H H
    258. 

  258.     forward_static_call(array('parent','bar')); // B D
    259. 

  259.     forward_static_call(array('self','bar'));   // C D
    260. 

  260.     forward_static_call(array('static','bar')); // D D
    261. 

  261.     echo "****************\n";
    262. 

  262.     forward_static_call('B::bar'); // B D
    263. 

  263.     forward_static_call('C::bar'); // C D
    264. 

  264.     forward_static_call('D::bar'); // D D
    265. 

  265.     forward_static_call('F::bar'); // F F
    266. 

  266.     forward_static_call('G::bar'); // G G
    267. 

  267.     forward_static_call('H::bar'); // H H
    268. 

  268.     forward_static_call('parent::bar'); // B D
    269. 

  269.     forward_static_call('self::bar');   // C D
    270. 

  270.     forward_static_call('static::bar'); // D D
    271. 

  271.     echo "****************\n";
    272. 

  272.     forward_static_call(array('B','B::bar')); // B D
    273. 

  273.     forward_static_call(array('B','C::bar')); // warning
    274. 

  274.     forward_static_call(array('B','D::bar')); // warning
    275. 

  275.     forward_static_call(array('B','F::bar')); // warning
    276. 

  276.     forward_static_call(array('B','G::bar')); // warning
    277. 

  277.     forward_static_call(array('B','H::bar')); // warning
    278. 

  278.     forward_static_call(array('B','parent::bar')); // A D
    279. 

  279.     forward_static_call(array('B','self::bar'));   // B D
    280. 

  280.     forward_static_call(array('B','static::bar')); // warning
    281. 

  281.     echo "****************\n";
    282. 

  282.     forward_static_call(array('G','B::bar'));
    283. 

  283.     forward_static_call(array('G','C::bar'));
    284. 

  284.     forward_static_call(array('G','D::bar'));
    285. 

  285.     forward_static_call(array('G','F::bar')); // F F
    286. 

  286.     forward_static_call(array('G','G::bar')); // G G
    287. 

  287.     forward_static_call(array('G','H::bar'));
    288. 

  288.     forward_static_call(array('G','parent::bar')); // F F  (Zend: F D) (Rule 4)
    289. 

  289.     forward_static_call(array('G','self::bar'));   // G G  (Zend: G D) (Rule 4)
    290. 

  290.     forward_static_call(array('G','static::bar'));
    291. 

  291.     echo "****************\n";
    292. 

  292.     $b = new B;
    293. 

  293.     forward_static_call(array($b,'bar'));    // B D
    294. 

  294.     forward_static_call(array($b,'B::bar')); // B D
    295. 

  295.     forward_static_call(array($b,'C::bar')); // warning
    296. 

  296.     forward_static_call(array($b,'D::bar')); // warning
    297. 

  297.     forward_static_call(array($b,'F::bar')); // warning
    298. 

  298.     forward_static_call(array($b,'G::bar')); // warning
    299. 

  299.     forward_static_call(array($b,'H::bar')); // warning
    300. 

  300.     forward_static_call(array($b,'parent::bar')); // A D
    301. 

  301.     forward_static_call(array($b,'self::bar'));   // B D
    302. 

  302.     forward_static_call(array($b,'static::bar')); // warning
    303. 

  303.     echo "****************\n";
    304. 

  304.     $g = new G;
    305. 

  305.     forward_static_call(array($g,'bar'));    // G G
    306. 

  306.     forward_static_call(array($g,'B::bar')); // warning
    307. 

  307.     forward_static_call(array($g,'C::bar')); // warning
    308. 

  308.     forward_static_call(array($g,'D::bar')); // warning
    309. 

  309.     forward_static_call(array($g,'F::bar')); // F G
    310. 

  310.     forward_static_call(array($g,'G::bar')); // G G
    311. 

  311.     forward_static_call(array($g,'H::bar')); // warning
    312. 

  312.     forward_static_call(array($g,'parent::bar')); // F G
    313. 

  313.     forward_static_call(array($g,'self::bar'));   // G G
    314. 

  314.     forward_static_call(array($g,'static::bar')); // warning
    315. 

  315.     echo "****************\n";
    316. 

  316.   }
    317. 

  317.   public static function testBar2() {
    318. 

  318.     echo "############# testBar2 ##############\n";
    319. 

  319.     B::bar(); // B B
    320. 

  320.     C::bar(); // C C
    321. 

  321.     D::bar(); // D D
    322. 

  322.     F::bar(); // F F
    323. 

  323.     G::bar(); // G G
    324. 

  324.     H::bar(); // H H
    325. 

  325.     parent::bar(); // B D
    326. 

  326.     self::bar();   // C D
    327. 

  327.     static::bar(); // D D
    328. 

  328.     echo "****************\n";
    329. 

  329.     forward_static_call(array('B','bar')); // B D
    330. 

  330.     forward_static_call(array('C','bar')); // C D
    331. 

  331.     forward_static_call(array('D','bar')); // D D
    332. 

  332.     forward_static_call(array('F','bar')); // F F
    333. 

  333.     forward_static_call(array('G','bar')); // G G
    334. 

  334.     forward_static_call(array('H','bar')); // H H
    335. 

  335.     forward_static_call(array('parent','bar')); // B D
    336. 

  336.     forward_static_call(array('self','bar'));   // C D
    337. 

  337.     forward_static_call(array('static','bar')); // D D
    338. 

  338.     echo "****************\n";
    339. 

  339.     forward_static_call('B::bar'); // B D
    340. 

  340.     forward_static_call('C::bar'); // C D
    341. 

  341.     forward_static_call('D::bar'); // D D
    342. 

  342.     forward_static_call('F::bar'); // F F
    343. 

  343.     forward_static_call('G::bar'); // G G
    344. 

  344.     forward_static_call('H::bar'); // H H
    345. 

  345.     forward_static_call('parent::bar'); // B D
    346. 

  346.     forward_static_call('self::bar');   // C D
    347. 

  347.     forward_static_call('static::bar'); // D D
    348. 

  348.     echo "****************\n";
    349. 

  349.     forward_static_call(array('B','B::bar')); // B D
    350. 

  350.     forward_static_call(array('B','C::bar')); // warning
    351. 

  351.     forward_static_call(array('B','D::bar')); // warning
    352. 

  352.     forward_static_call(array('B','F::bar')); // warning
    353. 

  353.     forward_static_call(array('B','G::bar')); // warning
    354. 

  354.     forward_static_call(array('B','H::bar')); // warning
    355. 

  355.     forward_static_call(array('B','parent::bar')); // A D
    356. 

  356.     forward_static_call(array('B','self::bar'));   // B D
    357. 

  357.     forward_static_call(array('B','static::bar')); // warning
    358. 

  358.     echo "****************\n";
    359. 

  359.     forward_static_call(array('G','B::bar'));
    360. 

  360.     forward_static_call(array('G','C::bar'));
    361. 

  361.     forward_static_call(array('G','D::bar'));
    362. 

  362.     forward_static_call(array('G','F::bar')); // F F
    363. 

  363.     forward_static_call(array('G','G::bar')); // G G
    364. 

  364.     forward_static_call(array('G','H::bar'));
    365. 

  365.     forward_static_call(array('G','parent::bar')); // F F (Zend: F D) (Rule 4)
    366. 

  366.     forward_static_call(array('G','self::bar'));   // G G (Zend: G D) (Rule 4)
    367. 

  367.     forward_static_call(array('G','static::bar'));
    368. 

  368.     echo "****************\n";
    369. 

  369.     $b = new B;
    370. 

  370.     forward_static_call(array($b,'bar'));    // B D
    371. 

  371.     forward_static_call(array($b,'B::bar')); // B D
    372. 

  372.     forward_static_call(array($b,'C::bar'));
    373. 

  373.     forward_static_call(array($b,'D::bar'));
    374. 

  374.     forward_static_call(array($b,'F::bar'));
    375. 

  375.     forward_static_call(array($b,'G::bar'));
    376. 

  376.     forward_static_call(array($b,'H::bar'));
    377. 

  377.     forward_static_call(array($b,'parent::bar')); // A D
    378. 

  378.     forward_static_call(array($b,'self::bar'));   // B D
    379. 

  379.     forward_static_call(array($b,'static::bar'));
    380. 

  380.     echo "****************\n";
    381. 

  381.     $g = new G;
    382. 

  382.     forward_static_call(array($g,'bar'));    // G G
    383. 

  383.     forward_static_call(array($g,'B::bar')); // warning
    384. 

  384.     forward_static_call(array($g,'C::bar')); // warning
    385. 

  385.     forward_static_call(array($g,'D::bar')); // warning
    386. 

  386.     forward_static_call(array($g,'F::bar')); // F G
    387. 

  387.     forward_static_call(array($g,'G::bar')); // G G
    388. 

  388.     forward_static_call(array($g,'H::bar')); // warning
    389. 

  389.     forward_static_call(array($g,'parent::bar')); // F G
    390. 

  390.     forward_static_call(array($g,'self::bar'));   // G G
    391. 

  391.     forward_static_call(array($g,'static::bar')); // warning
    392. 

  392.     echo "****************\n";
    393. 

  393.   }
    394. 

  394. }
    395. 

  395. 

  396. class D extends C {
    397. 

  397.   public function foo() {
    398. 

  398.     echo __CLASS__ . ' ' . get_called_class() . ' ' .
    399. 

  399.          (isset($this) ? get_class($this) : '') . "\n";
    400. 

  400.   }
    401. 

  401.   public static function bar() {
    402. 

  402.     echo __CLASS__ . ' ' . get_called_class() . ' ' .
    403. 

  403.          (isset($this) ? get_class($this) : '') . "\n";
    404. 

  404.   }
    405. 

  405. }
    406. 

  406. 

  407. class F {
    408. 

  408.   public function foo() {
    409. 

  409.     echo __CLASS__ . ' ' . get_called_class() . ' ' .
    410. 

  410.          (isset($this) ? get_class($this) : '') . "\n";
    411. 

  411.   }
    412. 

  412.   public static function bar() {
    413. 

  413.     echo __CLASS__ . ' ' . get_called_class() . ' ' .
    414. 

  414.          (isset($this) ? get_class($this) : '') . "\n";
    415. 

  415.   }
    416. 

  416. }
    417. 

  417. 

  418. class G extends F {
    419. 

  419.   public function foo() {
    420. 

  420.     echo __CLASS__ . ' ' . get_called_class() . ' ' .
    421. 

  421.          (isset($this) ? get_class($this) : '') . "\n";
    422. 

  422.   }
    423. 

  423.   public static function bar() {
    424. 

  424.     echo __CLASS__ . ' ' . get_called_class() . ' ' .
    425. 

  425.          (isset($this) ? get_class($this) : '') . "\n";
    426. 

  426.   }
    427. 

  427.   public function doFoo() {
    428. 

  428.     $this->foo();  // G G G
    429. 

  429.     B::foo();      // B B    (Zend: B G G) (Rule 1)
    430. 

  430.     C::foo();      // C C    (Zend: C G G) (Rule 1)
    431. 

  431.     D::foo();      // D D    (Zend: D G G) (Rule 1)
    432. 

  432.     F::foo();      // F G G
    433. 

  433.     G::foo();      // G G G
    434. 

  434.     H::foo();      // H H    (Zend: H G G) (Rule 1)
    435. 

  435.     parent::foo(); // F G G
    436. 

  436.     self::foo();   // G G G
    437. 

  437.     static::foo(); // G G G
    438. 

  438.     echo "****************\n";
    439. 

  439.   }
    440. 

  440.   public function doBar() {
    441. 

  441.     $this->bar();  // G G
    442. 

  442.     B::bar();      // B B
    443. 

  443.     C::bar();      // C C
    444. 

  444.     D::bar();      // D D
    445. 

  445.     F::bar();      // F F
    446. 

  446.     G::bar();      // G G
    447. 

  447.     H::bar();      // H H
    448. 

  448.     parent::bar(); // F G
    449. 

  449.     self::bar();   // G G
    450. 

  450.     static::bar(); // G G
    451. 

  451.     echo "****************\n";
    452. 

  452.   }
    453. 

  453. }
    454. 

  454. 

  455. class H extends G {
    456. 

  456.   public function foo() {
    457. 

  457.     echo __CLASS__ . ' ' . get_called_class() . ' ' .
    458. 

  458.          (isset($this) ? get_class($this) : '') . "\n";
    459. 

  459.   }
    460. 

  460.   public static function bar() {
    461. 

  461.     echo __CLASS__ . ' ' . get_called_class() . ' ' .
    462. 

  462.          (isset($this) ? get_class($this) : '') . "\n";
    463. 

  463.   }
    464. 

  464. }
    465. 

  465. 

  466. $d = new D;
    467. 

  467. $d->testFoo1();
    468. 

  468. D::testFoo2();
    469. 

  469. $d->testBar1();
    470. 

  470. D::testBar2();
    471. 

  471. 

  472. $b = new B;
    473. 

  473. $g = new G;
    474. 

  474. echo "############# doFoo ##############\n";
    475. 

  475. $b->doFoo();
    476. 

  476. $g->doFoo();
    477. 

  477. echo "############# doBar ##############\n";
    478. 

  478. $b->doBar();
    479. 

  479. $g->doBar();
    480.