├── www
    ├── .hhconfig
    ├── index.php
    ├── xhp
    │   ├── php-lib
    │   │   ├── init.php
    │   │   ├── html.php
    │   │   └── core.php
    │   ├── tests
    │   │   ├── logical-op.phpt
    │   │   ├── whitespace-03.phpt
    │   │   ├── whitespace-02.phpt
    │   │   ├── whitespace-07.phpt
    │   │   ├── attr-blank.phpt
    │   │   ├── whitespace-04.phpt
    │   │   ├── whitespace-06.phpt
    │   │   ├── attr-entity.phpt
    │   │   ├── whitespace-01.phpt
    │   │   ├── whitespace-05.phpt
    │   │   ├── attr-float.phpt
    │   │   ├── presumptous.phpt
    │   │   ├── attr-callable.phpt
    │   │   ├── attr-quotes.phpt
    │   │   ├── class.phpt
    │   │   ├── script-fastpath.php
    │   │   ├── stack-balance-fail.phpt
    │   │   ├── apos-fastpath.phpt
    │   │   ├── array-constant.phpt
    │   │   ├── idx-01.phpt
    │   │   ├── class-constants.phpt
    │   │   ├── json_array.phpt
    │   │   ├── reflection-01.phpt
    │   │   ├── xhp-function-param.phpt
    │   │   ├── reflection-02.phpt
    │   │   ├── trait.phpt
    │   │   ├── lineno-02.phpt
    │   │   ├── reflection-07.phpt
    │   │   ├── attributes.phpt
    │   │   ├── reflection-06.phpt
    │   │   ├── syntax-error-lineno.phpt
    │   │   ├── xhp_preprocess_code.phpt
    │   │   ├── lineno-01.phpt
    │   │   ├── reflection-05.phpt
    │   │   ├── reflection-03.phpt
    │   │   ├── reflection-04.phpt
    │   │   ├── yield-03.phpt
    │   │   ├── anonymous_function.phpt
    │   │   ├── yield-01.phpt
    │   │   ├── new_call.phpt
    │   │   ├── finally.phpt
    │   │   ├── reflection-08.phpt
    │   │   ├── yield-02.phpt
    │   │   ├── array-types.phpt
    │   │   ├── idx-04.phpt
    │   │   ├── xhp_comment.phpt
    │   │   ├── lib.php
    │   │   ├── idx-03.phpt
    │   │   ├── heredoc.phpt
    │   │   └── idx-02.phpt
    │   ├── Makefile.frag
    │   ├── config.m4
    │   ├── xhp
    │   │   ├── Makefile
    │   │   ├── xhp_preprocess.hpp
    │   │   ├── code_rope.hpp
    │   │   ├── fastpath.hpp
    │   │   ├── xhpize.cpp
    │   │   ├── xhp_preprocess.cpp
    │   │   ├── code_rope.cpp
    │   │   ├── xhp.hpp
    │   │   ├── fastpath.re
    │   │   └── scanner.l
    │   ├── INSTALL
    │   ├── ext.hpp
    │   ├── LICENSE.ZEND
    │   ├── LICENSE.PHP
    │   ├── README.textile
    │   └── ext.cpp
    ├── hello
    │   └── index.php
    ├── collections
    │   └── index.php
    ├── type-checker
    │   └── index.php
    ├── attributes
    │   └── index.php
    ├── promotion
    │   └── index.php
    ├── types
    │   └── index.php
    └── hhxhp
    │   └── index.php
├── .gitignore
├── conf
    ├── php.ini
    ├── nginx-fastcgi
    └── config.hdf
├── Vagrantfile
└── README.md


/www/.hhconfig:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | .vagrant
2 | 


--------------------------------------------------------------------------------
/www/index.php:
--------------------------------------------------------------------------------
1 | <?hh
2 | 
3 | echo 'Hack works !';
4 | 
5 | 
6 | 
7 | 


--------------------------------------------------------------------------------
/www/xhp/php-lib/init.php:
--------------------------------------------------------------------------------
1 | <?php
2 | require_once 'core.php';
3 | require_once 'html.php';
4 | 


--------------------------------------------------------------------------------
/www/xhp/tests/logical-op.phpt:
--------------------------------------------------------------------------------
1 | --TEST--
2 | Logical Operator Whitespace
3 | --FILE--
4 | <?php
5 | echo true xor false;
6 | if (0) <a />;
7 | --EXPECT--
8 | 1
9 | 


--------------------------------------------------------------------------------
/www/xhp/tests/whitespace-03.phpt:
--------------------------------------------------------------------------------
1 | --TEST--
2 | Whitespace 03
3 | --FILE--
4 | <?php
5 | require 'lib.php';
6 | echo <x> {'a'} </x>;
7 | --EXPECT--
8 | <x>a</x>
9 | 


--------------------------------------------------------------------------------
/www/xhp/tests/whitespace-02.phpt:
--------------------------------------------------------------------------------
1 | --TEST--
2 | Whitespace 02
3 | --FILE--
4 | <?php
5 | require 'lib.php';
6 | echo <x> {'a'}<x /></x>;
7 | --EXPECT--
8 | <x>a<x></x></x>
9 | 


--------------------------------------------------------------------------------
/www/xhp/tests/whitespace-07.phpt:
--------------------------------------------------------------------------------
1 | --TEST--
2 | Whitespace 07
3 | --FILE--
4 | <?php
5 | require 'lib.php';
6 | echo <x> a{ 'b' }c </x>;
7 | --EXPECT--
8 | <x> abc </x>
9 | 


--------------------------------------------------------------------------------
/www/xhp/tests/attr-blank.phpt:
--------------------------------------------------------------------------------
 1 | --TEST--
 2 | Blank attribute
 3 | --FILE--
 4 | <?php
 5 | class xhp_a {}
 6 | $foo = <a b="" />;
 7 | echo "pass";
 8 | --EXPECT--
 9 | pass
10 | 


--------------------------------------------------------------------------------
/www/xhp/tests/whitespace-04.phpt:
--------------------------------------------------------------------------------
1 | --TEST--
2 | Whitespace 04
3 | --FILE--
4 | <?php
5 | require 'lib.php';
6 | echo <x> <x /> {'a'} </x>;
7 | --EXPECT--
8 | <x><x></x>a</x>
9 | 


--------------------------------------------------------------------------------
/www/xhp/tests/whitespace-06.phpt:
--------------------------------------------------------------------------------
1 | --TEST--
2 | Whitespace 06
3 | --FILE--
4 | <?php
5 | require 'lib.php';
6 | echo <x> a { 'b' } c </x>;
7 | --EXPECT--
8 | <x> a b c </x>
9 | 


--------------------------------------------------------------------------------
/www/xhp/tests/attr-entity.phpt:
--------------------------------------------------------------------------------
 1 | --TEST--
 2 | Entities in attributes
 3 | --FILE--
 4 | <?php
 5 | class xhp_a {}
 6 | $foo = <a b="&snowman;">c</a>;
 7 | echo "pass";
 8 | --EXPECT--
 9 | pass
10 | 


--------------------------------------------------------------------------------
/www/xhp/tests/whitespace-01.phpt:
--------------------------------------------------------------------------------
 1 | --TEST--
 2 | Whitespace 01
 3 | --FILE--
 4 | <?php
 5 | require 'lib.php';
 6 | echo <x>
 7 | <x>
 8 | </x>.
 9 | </x>;
10 | --EXPECT--
11 | <x><x></x>. </x>
12 | 


--------------------------------------------------------------------------------
/www/xhp/tests/whitespace-05.phpt:
--------------------------------------------------------------------------------
 1 | --TEST--
 2 | Whitespace 05
 3 | --FILE--
 4 | <?php
 5 | require 'lib.php';
 6 | echo
 7 |   <x>
 8 |     foo
 9 |   </x>;
10 | --EXPECT--
11 | <x> foo </x>
12 | 


--------------------------------------------------------------------------------
/www/xhp/tests/attr-float.phpt:
--------------------------------------------------------------------------------
 1 | --TEST--
 2 | Float attribute parsing
 3 | --FILE--
 4 | <?php
 5 | class :foo {
 6 |   attribute
 7 |     float b;
 8 | }
 9 | echo "pass";
10 | --EXPECT--
11 | pass
12 | 


--------------------------------------------------------------------------------
/www/xhp/tests/presumptous.phpt:
--------------------------------------------------------------------------------
 1 | --TEST--
 2 | Presumptous Closing Tags
 3 | --FILE--
 4 | <?php
 5 | class xhp_a {}
 6 | $foo = <a><a><a>hi</a></></a>;
 7 | echo "pass";
 8 | --EXPECT--
 9 | pass
10 | 


--------------------------------------------------------------------------------
/www/xhp/tests/attr-callable.phpt:
--------------------------------------------------------------------------------
 1 | --TEST--
 2 | Callable attribute parsing
 3 | --FILE--
 4 | <?php
 5 | class :foo {
 6 |   attribute
 7 |     callable b;
 8 | }
 9 | echo "pass";
10 | --EXPECT--
11 | pass
12 | 


--------------------------------------------------------------------------------
/www/xhp/tests/attr-quotes.phpt:
--------------------------------------------------------------------------------
 1 | --TEST--
 2 | Quotes in attribute
 3 | --FILE--
 4 | <?php
 5 | require 'lib.php';
 6 | $quote = '"';
 7 | echo <x b={$quote}>c</x>;
 8 | --EXPECT--
 9 | <x b="&quot;">c</x>
10 | 


--------------------------------------------------------------------------------
/www/xhp/tests/class.phpt:
--------------------------------------------------------------------------------
 1 | --TEST--
 2 | XHP Classes
 3 | --FILE--
 4 | <?php
 5 | class :x:etc {}
 6 | abstract class :x:foo {}
 7 | abstract class :x:bar extends :x:foo {}
 8 | echo "pass";
 9 | --EXPECT--
10 | pass
11 | 


--------------------------------------------------------------------------------
/www/xhp/tests/script-fastpath.php:
--------------------------------------------------------------------------------
 1 | --TEST--
 2 | Script Fastpath
 3 | --FILE--
 4 | <?php
 5 | $foo = xhp_preprocess_code('<?php
 6 | $foo = <script>bar</script>;');
 7 | echo isset($foo['new_code']);
 8 | --EXPECT--
 9 | 1
10 | 


--------------------------------------------------------------------------------
/www/xhp/tests/stack-balance-fail.phpt:
--------------------------------------------------------------------------------
 1 | --TEST--
 2 | Stack Balance Fail
 3 | --FILE--
 4 | <?php
 5 | class xhp_x__y {}
 6 | $a = <x:y attr={:tag::CONSTANT} />;
 7 | function f() {}
 8 | echo 'pass';
 9 | --EXPECT--
10 | pass
11 | 


--------------------------------------------------------------------------------
/www/xhp/tests/apos-fastpath.phpt:
--------------------------------------------------------------------------------
 1 | --TEST--
 2 | Apostrophe Fastpath
 3 | --FILE--
 4 | <?php
 5 | $foo = xhp_preprocess_code('<?php
 6 | $foo = <div>Her\'s</div>;foo(\'\');');
 7 | echo isset($foo['new_code']);
 8 | --EXPECT--
 9 | 1
10 | 


--------------------------------------------------------------------------------
/www/xhp/tests/array-constant.phpt:
--------------------------------------------------------------------------------
 1 | --TEST--
 2 | Constant in Array
 3 | --FILE--
 4 | <?php
 5 | class :foo {
 6 |   const bar = 'pass';
 7 | }
 8 | $foo = array('etc' => :foo::bar);
 9 | echo $foo['etc'];
10 | --EXPECT--
11 | pass
12 | 


--------------------------------------------------------------------------------
/www/xhp/tests/idx-01.phpt:
--------------------------------------------------------------------------------
 1 | --TEST--
 2 | XHP idx Expression 01
 3 | --INI--
 4 | xhp.idx_expr=1
 5 | --FILE--
 6 | <?php
 7 | function foo() {
 8 |   return array(
 9 |     'bar' => 'etc',
10 |   );
11 | }
12 | echo foo()['bar'];
13 | --EXPECT--
14 | etc
15 | 


--------------------------------------------------------------------------------
/www/xhp/Makefile.frag:
--------------------------------------------------------------------------------
1 | XHP_SHARED_DEPENDENCIES = $(srcdir)/xhp/libxhp.a
2 | XHP_SHARED_LIBADD := ${XHP_SHARED_LIBADD}
3 | $(srcdir)/ext.cpp: $(srcdir)/xhp/libxhp.a
4 | $(srcdir)/xhp/libxhp.a: FORCE
5 | 	$(MAKE) $(MFLAGS) -C $(srcdir)/xhp libxhp.a
6 | 
7 | FORCE:
8 | 


--------------------------------------------------------------------------------
/www/xhp/tests/class-constants.phpt:
--------------------------------------------------------------------------------
 1 | --TEST--
 2 | XHP Class Attributes
 3 | --FILE--
 4 | <?php
 5 | class :foo {
 6 |   public static $bar;
 7 |   const etc = 1;
 8 | }
 9 | (:foo::$bar = 2);
10 | echo :foo::etc;
11 | echo :foo::$bar;
12 | --EXPECT--
13 | 12
14 | 


--------------------------------------------------------------------------------
/www/xhp/tests/json_array.phpt:
--------------------------------------------------------------------------------
 1 | --TEST--
 2 | PHP5.4 JSON array syntax
 3 | --SKIPIF--
 4 | <?php 
 5 | if (version_compare(PHP_VERSION, '5.4', '<')) exit("Skip This test is for PHP 5.5 only.");
 6 | ?>
 7 | --FILE--
 8 | <?php
 9 | $a = [1, 2];
10 | --EXPECTF--
11 | 
12 | 


--------------------------------------------------------------------------------
/www/xhp/tests/reflection-01.phpt:
--------------------------------------------------------------------------------
 1 | --TEST--
 2 | Reflection API 01
 3 | --FILE--
 4 | <?php
 5 | /** a */ function /** b */ foo /** c */ (/** d */) {}
 6 | $foo = new ReflectionFunction('foo');
 7 | echo $foo->getDocComment();
 8 | exit;
 9 | <a />;
10 | --EXPECT--
11 | /** b */
12 | 


--------------------------------------------------------------------------------
/www/xhp/tests/xhp-function-param.phpt:
--------------------------------------------------------------------------------
 1 | --TEST--
 2 | XHP Function Call Param
 3 | --FILE--
 4 | <?php
 5 | function id($i) { return $i; }
 6 | class xhp_thing {
 7 |   public function exist() {}
 8 | }
 9 | id(<thing />)->exist();
10 | echo 'pass';
11 | --EXPECT--
12 | pass
13 | 


--------------------------------------------------------------------------------
/www/xhp/tests/reflection-02.phpt:
--------------------------------------------------------------------------------
 1 | --TEST--
 2 | Reflection API 02
 3 | --FILE--
 4 | <?php
 5 | /** a */ abstract /** b */ class /** c */ foo /** d */ {}
 6 | $foo = new ReflectionClass('foo');
 7 | echo $foo->getDocComment();
 8 | exit;
 9 | <a />;
10 | --EXPECT--
11 | /** d */
12 | 


--------------------------------------------------------------------------------
/www/xhp/tests/trait.phpt:
--------------------------------------------------------------------------------
 1 | --TEST--
 2 | PHP5.4 Traits work
 3 | --FILE--
 4 | <?php
 5 | trait simple {
 6 |   function extra() { }
 7 |   public $var = 5;
 8 | }
 9 | 
10 | class testing {
11 |   use simple;
12 | }
13 | 
14 | $a = new testing;
15 | echo $a->var;
16 | --EXPECT--
17 | 5


--------------------------------------------------------------------------------
/www/hello/index.php:
--------------------------------------------------------------------------------
 1 | <?hh
 2 | 
 3 | require "/vagrant/www/xhp/php-lib/init.php";
 4 | 
 5 | $hello = "Hello HACK!";
 6 | 
 7 | echo <html>
 8 |     <head>
 9 |         <title>{$hello}!</title>
10 |     </head>
11 |     <body>
12 |         <h1>{$hello}</h1>
13 |     </body>
14 | </html>;
15 | 


--------------------------------------------------------------------------------
/www/xhp/tests/lineno-02.phpt:
--------------------------------------------------------------------------------
 1 | --TEST--
 2 | Line Numbers 02
 3 | --FILE--
 4 | <?php
 5 | function foo() {
 6 |  return <x>&#187;
 7 |    </x>;
 8 | }
 9 | 
10 | function bar() {
11 | }
12 | 
13 | $r = new ReflectionFunction('bar');
14 | echo $r->getStartLine();
15 | --EXPECT--
16 | 7
17 | 


--------------------------------------------------------------------------------
/www/xhp/tests/reflection-07.phpt:
--------------------------------------------------------------------------------
 1 | --TEST--
 2 | Reflection API 07
 3 | --FILE--
 4 | <?php
 5 | class foo {
 6 |   public $bar /** a */;
 7 |   function etc() {}
 8 | }
 9 | $foo = new ReflectionMethod('foo', 'etc');
10 | echo $foo->getDocComment();
11 | exit;
12 | <a />;
13 | --EXPECT--
14 | 


--------------------------------------------------------------------------------
/www/xhp/tests/attributes.phpt:
--------------------------------------------------------------------------------
 1 | --TEST--
 2 | XHP attributes Declaration
 3 | --FILE--
 4 | <?php
 5 | class :foo {
 6 |   attribute
 7 |     string foo;
 8 | }
 9 | class :bar {
10 |   attribute
11 |     :foo,
12 |     :foo,
13 |     string bar;
14 | }
15 | echo "pass";
16 | --EXPECT--
17 | pass
18 | 


--------------------------------------------------------------------------------
/www/xhp/tests/reflection-06.phpt:
--------------------------------------------------------------------------------
 1 | --TEST--
 2 | Reflection API 06
 3 | --FILE--
 4 | <?php
 5 | class foo {
 6 |   /** a */ public /** b */ $bar /** c */;
 7 | }
 8 | $foo = new ReflectionProperty('foo', 'bar');
 9 | echo $foo->getDocComment();
10 | exit;
11 | <a />;
12 | --EXPECT--
13 | /** c */
14 | 


--------------------------------------------------------------------------------
/www/xhp/tests/syntax-error-lineno.phpt:
--------------------------------------------------------------------------------
 1 | --TEST--
 2 | Syntax Error Line Number
 3 | --FILE--
 4 | <?php
 5 | $foo = xhp_preprocess_code('<?php
 6 | $foo = <x><y></x>;
 7 | 
 8 | 
 9 | 
10 | 
11 | 
12 | 
13 | 
14 | 
15 | 
16 | function foo() {}');
17 | echo $foo['error_line'];
18 | --EXPECT--
19 | 2
20 | 


--------------------------------------------------------------------------------
/www/xhp/tests/xhp_preprocess_code.phpt:
--------------------------------------------------------------------------------
 1 | --TEST--
 2 | xhp_preprocess_code
 3 | --FILE--
 4 | <?php
 5 | $xhp = <<<XHP
 6 | <?php
 7 | class :thing {
 8 | }
 9 | XHP;
10 | print_r(xhp_preprocess_code($xhp));
11 | --EXPECT--
12 | Array
13 | (
14 |     [new_code] => <?php
15 | class xhp_thing{
16 | }
17 | )
18 | 


--------------------------------------------------------------------------------
/www/xhp/tests/lineno-01.phpt:
--------------------------------------------------------------------------------
 1 | --TEST--
 2 | Line Numbers 01
 3 | --FILE--
 4 | <?php
 5 | class :thing {
 6 |   attribute
 7 |     Thing a,
 8 |     Thing b;
 9 |   public function method() {}} function foo() {}
10 | 
11 | $r = new ReflectionFunction('foo');
12 | echo $r->getStartLine();
13 | --EXPECT--
14 | 6
15 | 


--------------------------------------------------------------------------------
/www/xhp/tests/reflection-05.phpt:
--------------------------------------------------------------------------------
 1 | --TEST--
 2 | Reflection API 05
 3 | --FILE--
 4 | <?php
 5 | class foo {
 6 |   /** a */ public /** b */ $bar /** c */ = /** d */ 1 /** e */;
 7 | }
 8 | $foo = new ReflectionProperty('foo', 'bar');
 9 | echo $foo->getDocComment();
10 | exit;
11 | <a />;
12 | --EXPECT--
13 | /** d */
14 | 


--------------------------------------------------------------------------------
/www/xhp/tests/reflection-03.phpt:
--------------------------------------------------------------------------------
 1 | --TEST--
 2 | Reflection API 03
 3 | --FILE--
 4 | <?php
 5 | class foo {
 6 |   /** a */ public /** b */ function /** c */ bar /** d */ (/** e */) {}
 7 | }
 8 | $foo = new ReflectionMethod('foo', 'bar');
 9 | echo $foo->getDocComment();
10 | exit;
11 | <a />;
12 | --EXPECT--
13 | /** c */
14 | 


--------------------------------------------------------------------------------
/www/xhp/tests/reflection-04.phpt:
--------------------------------------------------------------------------------
 1 | --TEST--
 2 | Reflection API 04
 3 | --FILE--
 4 | <?php
 5 | abstract class foo {
 6 |   /** a */ abstract /** b */ public /** c */ function /** d */ bar /** e */ (/** f */);
 7 | }
 8 | $foo = new ReflectionMethod('foo', 'bar');
 9 | echo $foo->getDocComment();
10 | exit;
11 | <a />;
12 | --EXPECT--
13 | /** d */
14 | 


--------------------------------------------------------------------------------
/www/xhp/tests/yield-03.phpt:
--------------------------------------------------------------------------------
 1 | --TEST--
 2 | PHP5.5 Yield keyword 03
 3 | --SKIPIF--
 4 | <?php 
 5 | if (version_compare(PHP_VERSION, '5.5', '<')) exit("Skip This test is for PHP 5.5 only.");
 6 | ?>
 7 | --FILE--
 8 | <?php
 9 | function yieldTest() {
10 |   $a = yield;
11 |   echo $a;
12 | }
13 | $b = yieldTest();
14 | $b->send(1);
15 | --EXPECT--
16 | 1


--------------------------------------------------------------------------------
/www/xhp/tests/anonymous_function.phpt:
--------------------------------------------------------------------------------
 1 | --TEST--
 2 | Anonymous Functions
 3 | --SKIPIF--
 4 | <?php 
 5 | if (version_compare(PHP_VERSION, '5.2', '<')) exit("Skip This test is for PHP 5.3 only.");
 6 | ?>
 7 | --FILE--
 8 | <?php
 9 | $one = 1;
10 | $func = function($two) use ($one) {
11 |   return $one + $two;
12 | };
13 | echo $func(2);
14 | --EXPECT--
15 | 3
16 | 


--------------------------------------------------------------------------------
/www/xhp/tests/yield-01.phpt:
--------------------------------------------------------------------------------
 1 | --TEST--
 2 | PHP5.5 Yield keyword 01
 3 | --SKIPIF--
 4 | <?php 
 5 | if (version_compare(PHP_VERSION, '5.5', '<')) exit("Skip This test is for PHP 5.5 only.");
 6 | ?>
 7 | --FILE--
 8 | <?php
 9 | function yieldTest() {
10 |   $a = 1;
11 |   yield $a;
12 | }
13 | foreach (yieldTest() as $b) {
14 |   echo $b;
15 | }
16 | --EXPECT--
17 | 1


--------------------------------------------------------------------------------
/www/xhp/tests/new_call.phpt:
--------------------------------------------------------------------------------
 1 | --TEST--
 2 | PHP5.4 (new thing)->call()
 3 | --SKIPIF--
 4 | <?php 
 5 | if (version_compare(PHP_VERSION, '5.4', '<')) exit("Skip This test is for PHP 5.5 only.");
 6 | ?>
 7 | --FILE--
 8 | <?php
 9 | class simple {
10 |   public function call() {
11 |     echo 'pass';
12 |   }
13 | }
14 | 
15 | (new simple)->call();
16 | --EXPECT--
17 | pass
18 | 


--------------------------------------------------------------------------------
/www/xhp/tests/finally.phpt:
--------------------------------------------------------------------------------
 1 | --TEST--
 2 | PHP5.5 Finally keyword
 3 | --SKIPIF--
 4 | <?php 
 5 | if (version_compare(PHP_VERSION, '5.5', '<')) exit("Skip This test is for PHP 5.5 only.");
 6 | ?>
 7 | --FILE--
 8 | <?php
 9 | try {
10 |   echo '1';
11 |   throw new Exception('e');
12 | } catch (Exception $e) {
13 |   echo '2';	
14 | } finally {
15 |   echo '3';
16 | }
17 | --EXPECT--
18 | 123


--------------------------------------------------------------------------------
/www/xhp/tests/reflection-08.phpt:
--------------------------------------------------------------------------------
 1 | --TEST--
 2 | Reflection API 08
 3 | --FILE--
 4 | <?php
 5 | class foo {}
 6 | /** a */ class /** b */ bar /** c */ extends /** d */ foo /** e */ {}
 7 | $foo = new ReflectionClass('bar');
 8 | $comment = $foo->getDocComment();
 9 | if ($comment == '/** e */') {
10 |   $comment = '/** d */';
11 | }
12 | echo $comment;
13 | exit;
14 | <a />;
15 | --EXPECT--
16 | /** d */
17 | 


--------------------------------------------------------------------------------
/www/xhp/tests/yield-02.phpt:
--------------------------------------------------------------------------------
 1 | --TEST--
 2 | PHP5.5 Yield keyword 02
 3 | --SKIPIF--
 4 | <?php 
 5 | if (version_compare(PHP_VERSION, '5.5', '<')) exit("Skip This test is for PHP 5.5 only.");
 6 | ?>
 7 | --FILE--
 8 | <?php
 9 | function yieldTest() {
10 |   $a = 1;
11 |   $b = 2;
12 |   yield $a => $b;
13 | }
14 | foreach (yieldTest() as $c => $d) {
15 |   echo $c;
16 |   echo $d;
17 | }
18 | --EXPECT--
19 | 12


--------------------------------------------------------------------------------
/www/xhp/tests/array-types.phpt:
--------------------------------------------------------------------------------
 1 | --TEST--
 2 | Types in Array
 3 | --FILE--
 4 | <?php
 5 | class Foo {}
 6 | class :x {
 7 |   attribute
 8 |   	array<int> a,
 9 |   	array<float> b,
10 |   	array<string> c,
11 |   	array<bool> d,
12 |   	array<array> e,
13 |   	array<Foo> f,
14 |   	array<string => int> g,
15 |   	array<int => string> h;
16 | }
17 | $x = <x a={array(1)} />;
18 | echo 'pass';
19 | --EXPECT--
20 | pass
21 | 


--------------------------------------------------------------------------------
/www/xhp/config.m4:
--------------------------------------------------------------------------------
 1 | PHP_ARG_ENABLE(xhp, xhp,
 2 | [ --enable-xhp   Enable XHP])
 3 | 
 4 | PHP_REQUIRE_CXX()
 5 | if test "$PHP_XHP" = "yes"; then
 6 | #  XHP_SHARED_DEPENDENCIES="libxhp.a"
 7 |   PHP_ADD_LIBRARY(stdc++,, XHP_SHARED_LIBADD)
 8 |   PHP_SUBST(XHP_SHARED_LIBADD)
 9 |   PHP_NEW_EXTENSION(xhp, ext.cpp, $ext_shared)
10 |   PHP_ADD_LIBRARY_WITH_PATH(xhp, $ext_srcdir/xhp/, XHP_SHARED_LIBADD)
11 |   PHP_ADD_MAKEFILE_FRAGMENT
12 | fi
13 | 


--------------------------------------------------------------------------------
/www/xhp/tests/idx-04.phpt:
--------------------------------------------------------------------------------
 1 | --TEST--
 2 | XHP idx Expression 04
 3 | --FILE--
 4 | <?php
 5 | $string = 'foobar';
 6 | 
 7 | @var_dump(__xhp_idx($string, 0));
 8 | @var_dump(__xhp_idx($string, '0'));
 9 | @var_dump(__xhp_idx($string, null));
10 | @var_dump(__xhp_idx($string, true));
11 | @var_dump(__xhp_idx($string, false));
12 | @var_dump(__xhp_idx($string, 'honk'));
13 | --EXPECT--
14 | string(1) "f"
15 | string(1) "f"
16 | string(1) "f"
17 | string(1) "o"
18 | string(1) "f"
19 | string(1) "f"
20 | 


--------------------------------------------------------------------------------
/www/xhp/tests/xhp_comment.phpt:
--------------------------------------------------------------------------------
 1 | --TEST--
 2 | XHP Comment Syntax
 3 | --FILE--
 4 | <?php
 5 | require 'lib.php';
 6 | echo <x><!--XML comment--></x>;
 7 | echo
 8 |   <x>
 9 |     <!--XML comment with new lines-->
10 |   </x>;
11 | echo
12 |   <x>
13 |     a
14 |     <!--
15 |       Multi-line comment
16 |       with multiple lines
17 |     -->
18 |     b
19 |     <x>
20 |       c<!-- Nested comment -->d
21 |     </x>
22 |   </x>;
23 | echo <x> <!-- Comment with some -- extras dashes --> </x>;
24 | --EXPECT--
25 | <x></x><x></x><x> a b <x> cd </x></x><x></x>
26 | 


--------------------------------------------------------------------------------
/www/xhp/tests/lib.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | // Extremely simple implementation of XHP client library useful primarily for
 3 | // unit tests.
 4 | class :x {
 5 |   public function __construct($attrs, $children) {
 6 |     $this->attrs = $attrs;
 7 |     $this->children = $children;
 8 |   }
 9 | 
10 |   public function __toString() {
11 |     $head = '<x';
12 |     foreach ($this->attrs as $key => $val) {
13 |       $head .= ' '.htmlspecialchars($key).'="'.htmlspecialchars($val, ENT_QUOTES).'"';
14 |     }
15 |     return $head.'>'.implode('', $this->children).'</x>';
16 |   }
17 | }
18 | 


--------------------------------------------------------------------------------
/www/xhp/tests/idx-03.phpt:
--------------------------------------------------------------------------------
 1 | --TEST--
 2 | XHP idx Expression 03
 3 | --FILE--
 4 | <?php
 5 | $array = array();
 6 | $array[0] = 'zero';
 7 | $array['key'] = 'value';
 8 | 
 9 | @var_dump(__xhp_idx($array, 0));
10 | @var_dump(__xhp_idx($array, '0'));
11 | @var_dump(__xhp_idx($array, NULL));
12 | @var_dump(__xhp_idx($array, true));
13 | @var_dump(__xhp_idx($array, false));
14 | @var_dump(__xhp_idx($array, 'key'));
15 | @var_dump(__xhp_idx($array, 'other_key'));
16 | --EXPECT--
17 | string(4) "zero"
18 | string(4) "zero"
19 | NULL
20 | NULL
21 | string(4) "zero"
22 | string(5) "value"
23 | NULL
24 | 


--------------------------------------------------------------------------------
/www/xhp/tests/heredoc.phpt:
--------------------------------------------------------------------------------
 1 | --TEST--
 2 | Heredoc Fastpath
 3 | --FILE--
 4 | <?php
 5 | $foo = <<<EOF
 6 | ?>
 7 | EOF;
 8 | 
 9 | // 5.2 doesn't support nowdoc so we can't put this in the test or else it will
10 | // fail. Instead we use xhp_preprocess_code to make sure nowdoc and binary
11 | // nowdocs can parse.
12 | $d = '$';
13 | $code = <<<EOF
14 | <?php
15 | {$d}foo = <<<'BAR'
16 | ?>
17 | BAR;
18 | {$d}foo = b<<<'BAR'
19 | ?>
20 | BAR;
21 | if (0) <a />;
22 | EOF;
23 | 
24 | $preprocess = xhp_preprocess_code($code);
25 | if (empty($preprocess['new_code'])) {
26 |   echo "No nowdocs!";
27 | }
28 | echo "pass";
29 | --EXPECT--
30 | pass
31 | 


--------------------------------------------------------------------------------
/www/xhp/tests/idx-02.phpt:
--------------------------------------------------------------------------------
 1 | --TEST--
 2 | XHP idx Expression 02
 3 | --FILE--
 4 | <?php
 5 | class foo implements ArrayAccess {
 6 |   public function offsetExists($offset) { return true; }
 7 |   public function offsetGet($offset) { return $offset; }
 8 |   public function offsetSet($offset, $data) {}
 9 |   public function offsetUnset($offset) {}
10 | }
11 | $foo = new foo;
12 | 
13 | @var_dump(__xhp_idx($foo, 0));
14 | @var_dump(__xhp_idx($foo, NULL));
15 | @var_dump(__xhp_idx($foo, true));
16 | @var_dump(__xhp_idx($foo, false));
17 | @var_dump(__xhp_idx($foo, 'key'));
18 | --EXPECT--
19 | int(0)
20 | NULL
21 | bool(true)
22 | bool(false)
23 | string(3) "key"
24 | 


--------------------------------------------------------------------------------
/www/collections/index.php:
--------------------------------------------------------------------------------
 1 | <?hh
 2 | 
 3 | require "/vagrant/www/xhp/php-lib/init.php";
 4 | 
 5 | $v = Vector {"d", "c", "b"};
 6 | $v->add("a");
 7 | $v->reverse();
 8 | $v = $v->map(($_) ==> strtoupper($_))->filter(($_) ==> strcmp($_, "D") < 0);
 9 | 
10 | $items = <ul />;
11 | foreach ($v as $i) {
12 |     $items->appendChild(<li>{$i}</li>);
13 | }
14 | echo <div>Vector:{$items}</div>; // A, B, C
15 | 
16 | $m = Map {"a" => 1, "b" => 2};
17 | $m->add(Pair {"d", 4});
18 | 
19 | echo <div>Map:
20 |     <ul>
21 |         <li>contains "a": {$m->contains("a") ? "yes" : "no"}</li> <!-- yes -->
22 |         <li>contains "c": {$m->contains("c") ? "yes" : "no"}</li> <!-- no -->
23 |         <li>size: {$m->count()}</li> <!-- 3 -->
24 |     </ul>
25 | </div>;
26 | 


--------------------------------------------------------------------------------
/conf/php.ini:
--------------------------------------------------------------------------------
 1 | ; from https://github.com/hhvm/packaging/blob/master/hhvm/deb/skeleton/etc/hhvm/server.ini
 2 | 
 3 | ; php options
 4 | 
 5 | pid = /var/run/hhvm/pid
 6 | 
 7 | ; hhvm specific
 8 | 
 9 | hhvm.server.port = 9000
10 | hhvm.server.type = fastcgi
11 | hhvm.server.default_document = index.php
12 | hvvm.server.source_root = /vagrant/www
13 | 
14 | hhvm.eval.enable_xhp = true
15 | hhvm.eval.allow_hhas = true
16 | hhvm.eval.enable_hip_hop_syntax=true
17 | hhvm.eval.enable_zend_compat = true
18 | 
19 | hhvm.log.level = Warning
20 | hhvm.log.always_log_unhandled_exceptions = true
21 | hhvm.log.runtime_error_reporting_level = 8191
22 | hhvm.log.use_log_file = true
23 | hhvm.log.file = /var/log/hhvm/error.log
24 | 
25 | hhvm.repo.central.path = /var/run/hhvm/hhvm.hhbc
26 | 
27 | hhvm.mysql.typed_results = false


--------------------------------------------------------------------------------
/www/type-checker/index.php:
--------------------------------------------------------------------------------
 1 | <?hh // strict
 2 | 
 3 | require "/vagrant/www/xhp/php-lib/init.php";
 4 | 
 5 | set_error_handler(function ($no, $str) {
 6 |     $func = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 2)[1]['function'];
 7 |     $line = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 2)[1]['line'];
 8 |     echo <p>ERROR(calling "{$func}()" on l.{$line}) : {$str}</p>;
 9 | });
10 | 
11 | function add(int $a, int $b): int {
12 |     return $a + $b;
13 | }
14 | 
15 | // ERROR(calling "add()" on l.17) : Argument 2 passed to add() must be an
16 | // instance of int, string given
17 | echo <p>add(1, "a") = {add(1, "a")}</p>;
18 | 
19 | // ERROR(calling "add()" on l.22) : Argument 2 passed to add() must be an
20 | // instance of int, string given
21 | function add_array(array<int> $a): int {
22 |     return array_reduce($a, "add", 0);
23 | }
24 | 
25 | echo <p>add_array([1, "a"]) = {add_array([1, "a"])}</p>;


--------------------------------------------------------------------------------
/www/attributes/index.php:
--------------------------------------------------------------------------------
 1 | <?hh
 2 | 
 3 | require "/vagrant/www/xhp/php-lib/init.php";
 4 | 
 5 | << UA('klass', ['type' => 'class']) >>
 6 | class klass {
 7 |     protected $prop;
 8 | 
 9 |     << UA(['type' => 'function']) >>
10 |     public function funktion(<< Argument >> $arg) {
11 |     }
12 | }
13 | 
14 | $rc = new ReflectionClass(klass);
15 | $rm = $rc->getMethod('funktion');
16 | $ra = $rm->getParameters()[0];
17 | 
18 | // On class
19 | // array ( 'UA' => array ( 0 => 'klass', 1 => array ( 'type' => 'class', ), ), )
20 | // On method
21 | // array ( 'UA' => array ( 0 => array ( 'type' => 'function', ), ), )
22 | // On argument
23 | // array ( 'Argument' => array ( ), )
24 | echo <div><h1>User annotations</h1>
25 |     <h2>On the class</h2><p>{var_export($rc->getAttributes(), true)}</p>
26 |     <h2>On the method</h2><p>{var_export($rm->getAttributes(), true)}</p>
27 |     <h2>On the argument</h2><p>{var_export($ra->getAttributes(), true)}</p></div>;
28 | 


--------------------------------------------------------------------------------
/www/promotion/index.php:
--------------------------------------------------------------------------------
 1 | <?hh
 2 | 
 3 | class PHPClass {
 4 |     public $pub;
 5 |     protected $pro;
 6 |     private $pri;
 7 | 
 8 |     public function __construct($pub, $pro, $pri) {
 9 |         $this->pub = $pub;
10 |         $this->pro = $pro;
11 |         $this->pri = $pri;
12 |     }
13 | }
14 | 
15 | // object(PHPClass)#6 (3) {
16 | //   ["pub"]=> string(3) "pub"
17 | //   ["pro":protected]=> string(3) "pro"
18 | //   ["pri":"PHPClass":private]=> string(3) "pri"
19 | //}
20 | var_dump(new PHPClass('pub', 'pro', 'pri'));
21 | 
22 | // The same class written in HACK is much more concise
23 | // thanks to constructor argument promotion.
24 | 
25 | class HHClass {
26 |     public function __construct(public $pub, protected $pro, private $pri) {}
27 | }
28 | 
29 | // object(HHClass)#6 (3) {
30 | //   ["pub"]=> string(3) "pub"
31 | //   ["pro":protected]=> string(3) "pro"
32 | //   ["pri":"HHClass":private]=> string(3) "pri"
33 | // }
34 | var_dump(new HHClass('pub', 'pro', 'pri'));
35 | 


--------------------------------------------------------------------------------
/conf/nginx-fastcgi:
--------------------------------------------------------------------------------
 1 | # FastCGI Redirect to HHVM
 2 | # 	Assumes HHVM is on port 9000.
 3 | 
 4 | server {
 5 | 	listen 80 default_server;
 6 | 	listen [::]:80 default_server ipv6only=on;
 7 | 
 8 | 	root /vagrant/www;
 9 | 	index index.html index.htm index.hh index.php;
10 | 
11 | 	# Make site accessible from http://localhost/
12 | 	server_name localhost;
13 | 	
14 |        location / {
15 |                 index index.php;
16 |                 try_files $uri $uri/ @handler;
17 |                 expires 30d;
18 |         }
19 |         location @handler {
20 |                 rewrite / /index.php;
21 |         }
22 |         location ~ .(php|hh)$ {
23 |                 fastcgi_keep_conn on;
24 |                 if (!-e $request_filename) { rewrite / /index.php last; }
25 |                 expires        off;
26 |                 fastcgi_pass   127.0.0.1:9000;
27 |                 fastcgi_param PHP_VALUE "error_log=/var/report/PHP.error.log";
28 |                 fastcgi_param  SCRIPT_FILENAME  $document_root$fastcgi_script_name;
29 |                 include        fastcgi_params;
30 |         }
31 |         location ~* \.(js|css|png|jpg|jpeg|gif|ico)$ {
32 |                 expires 1y;
33 |                 log_not_found off;
34 |         }
35 | }
36 | 


--------------------------------------------------------------------------------
/www/xhp/xhp/Makefile:
--------------------------------------------------------------------------------
 1 | ifdef DEBUG
 2 | CPPFLAGS = -fPIC -ggdb -Wall -DDEBUG
 3 | else
 4 | CPPFLAGS = -fPIC -g -Wall -O3 -minline-all-stringops
 5 | endif
 6 | 
 7 | ifdef PROFILE
 8 | CPPFLAGS += -pg
 9 | endif
10 | 
11 | all: libxhp.a libxhp.so
12 | 
13 | clean:
14 | 	-rm libxhp.a xhpize parser.yacc.cpp scanner.lex.cpp scanner.lex.hpp parser.yacc.output parser.yacc.hpp fastpath.cpp *.o 2>/dev/null
15 | 
16 | parser.yacc.cpp: parser.y
17 | 	bison --debug --verbose -d -o $@ $<
18 | 
19 | parser.yacc.hpp: parser.yacc.cpp
20 | 
21 | scanner.lex.cpp: scanner.l
22 | 	`which flex35 2>/dev/null || which flex 2>/dev/null` \
23 | 	  -C --header-file=scanner.lex.hpp -o $@ -d $<
24 | 
25 | scanner.lex.hpp: scanner.lex.cpp
26 | 
27 | fastpath.cpp: fastpath.re
28 | 	re2c -c -o $@ $<
29 | 
30 | %.o: %.cpp
31 | 	g++ -c $(CPPFLAGS) -o $@ $<
32 | 
33 | xhp_preprocess.o: xhp_preprocess.cpp scanner.lex.hpp parser.yacc.hpp
34 | parser.yacc.o: scanner.lex.hpp
35 | scanner.lex.o: parser.yacc.hpp
36 | 
37 | libxhp.a: code_rope.o scanner.lex.o parser.yacc.o fastpath.o xhp_preprocess.o
38 | 	$(AR) -crs $@ $^
39 | 
40 | libxhp.so: code_rope.o scanner.lex.o parser.yacc.o fastpath.o xhp_preprocess.o
41 | 	g++ -shared -Wl,-soname,libxhp.so -o libxhp.so $^
42 | 
43 | xhpize: xhpize.cpp libxhp.a
44 | 	g++ $(CPPFLAGS) -o $@ $^
45 | 
46 | .PHONY: all clean tags
47 | 


--------------------------------------------------------------------------------
/www/xhp/INSTALL:
--------------------------------------------------------------------------------
 1 | You can install XHP with Homebrew by first enabling some required
 2 | repositories:
 3 | 
 4 |   brew tap homebrew/dupes
 5 |   brew tap homebrew/versions
 6 |   brew tap josegonzalez/homebrew-php
 7 | 
 8 | Once completed, ensure gcc is installed:
 9 | 
10 |   brew install apple-gcc42
11 | 
12 | Then run any of the following commands:
13 | 
14 |   * brew install php53-xhp
15 |   * brew install php54-xhp
16 |   * brew install php55-xhp
17 | 
18 | To install manually, continue reading.
19 | 
20 | Building XHP requires:
21 | 
22 |   * PHP 5.2.x or 5.3.x
23 |   * gcc 4.0 or higher
24 | 
25 | If you are NOT building from a release, you will also need:
26 | 
27 |   * flex 2.5.35 or higher
28 |   * Bison 2.3 or higher
29 |   * re2c 0.13.5 or higher
30 | 
31 | You may have luck with different versions of these packages, but these are the
32 | versions that have been tested to work.
33 | 
34 | If PHP was configured correctly, and you meet the system requirements (Linux)
35 | you should be able to get XHP running just like you would most PHP extensions:
36 | 
37 |   phpize
38 |   ./configure
39 |   make
40 |   make install
41 | 
42 | Then add `extension=xhp.so` to your php.ini and you should be good to go. An
43 | easy way to test if XHP is working is by running:
44 | 
45 |   php -r 'echo "XHP!\n"; exit; <a />;'
46 | 
47 | If you get a syntax error then XHP is not working.
48 | 


--------------------------------------------------------------------------------
/www/xhp/ext.hpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |   +----------------------------------------------------------------------+
 3 |   | XHP                                                                  |
 4 |   +----------------------------------------------------------------------+
 5 |   | Copyright (c) 1998-2013 Zend Technologies Ltd. (http://www.zend.com) |
 6 |   | Copyright (c) 2009-2013 Facebook, Inc. (http://www.facebook.com)     |
 7 |   +----------------------------------------------------------------------+
 8 |   | This source file is subject to version 2.00 of the Zend license,     |
 9 |   | that is bundled with this package in the file LICENSE.ZEND, and is   |
10 |   | available through the world-wide-web at the following url:           |
11 |   | http://www.zend.com/license/2_00.txt.                                |
12 |   | If you did not receive a copy of the Zend license and are unable to  |
13 |   | obtain it through the world-wide-web, please send a note to          |
14 |   | license@zend.com so we can mail you a copy immediately.              |
15 |   +----------------------------------------------------------------------+
16 | */
17 | 
18 | #pragma once
19 | #ifdef HAVE_CONFIG_H
20 | #include "../config.h"
21 | #endif
22 | #include "php.h"
23 | 
24 | #define PHP_XHP_VERSION "1.4"
25 | #define PHP_XHP_EXTNAME "xhp"
26 | 
27 | extern zend_module_entry xhp_module_entry;
28 | #define phpext_xhp_ptr &xhp_module_entry
29 | 


--------------------------------------------------------------------------------
/conf/config.hdf:
--------------------------------------------------------------------------------
 1 | PidFile = /var/hhvm/hhvm.pid
 2 | 
 3 | Server {
 4 |   Port = 9000
 5 |   Type = fastcgi
 6 |   SourceRoot = /vagrant/www
 7 |   DefaultDocument = index.php
 8 | }
 9 | 
10 | Eval {
11 |   EnableXHP = true
12 |   AllowHhas = true
13 |   EnableHipHopSyntax = true
14 |   EnableZendCompat = true
15 | }
16 | 
17 | AdminServer {
18 |   Port = 8000
19 |   Password = admin
20 | }
21 | 
22 | Log {
23 |   Level = Warning
24 |   NoSilencer = true
25 |   AlwaysLogUnhandledExceptions = true
26 |   RuntimeErrorReportingLevel = 8191
27 |   UseLogFile = true
28 |   UseSyslog = false
29 |   File = /var/log/hhvm/error.log
30 |   Access {
31 |     * {
32 |       File = /var/log/hhvm/access.log
33 |       Format = %h %l %u % t \”%r\” %>s %b
34 |     }
35 |   }
36 | }
37 | 
38 | Debug {
39 |  FullBacktrace = true
40 |  ServerStackTrace = true
41 |  ServerErrorMessage = true
42 |  TranslateSource = true
43 | }
44 | 
45 | Repo {
46 |   Central {
47 |     Path = /var/hhvm/.hhvm.hhbc
48 |   }
49 | }
50 | 
51 | # include "/usr/share/hhvm/hdf/static.mime-types.hdf"
52 | StaticFile {
53 |   FilesMatch {
54 |     * {
55 |       pattern = .*\.(dll|exe)
56 |       headers {
57 |         * = Content-Disposition: attachment
58 |       }
59 |     }
60 |   }
61 |   Extensions : StaticMimeTypes
62 | }
63 | 
64 | MySQL {
65 |   ReadOnly = false
66 |   ConnectTimeout = 1000      # in ms
67 |   ReadTimeout = 1000         # in ms
68 |   SlowQueryThreshold = 1000  # in ms, log slow queries as errors
69 |   KillOnTimeout = false
70 | }
71 | 
72 | 


--------------------------------------------------------------------------------
/www/xhp/xhp/xhp_preprocess.hpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |   +----------------------------------------------------------------------+
 3 |   | XHP                                                                  |
 4 |   +----------------------------------------------------------------------+
 5 |   | Copyright (c) 2009 - 2013 Facebook, Inc. (http://www.facebook.com)   |
 6 |   +----------------------------------------------------------------------+
 7 |   | This source file is subject to version 3.01 of the PHP license,      |
 8 |   | that is bundled with this package in the file LICENSE.PHP, and is    |
 9 |   | available through the world-wide-web at the following url:           |
10 |   | http://www.php.net/license/3_01.txt                                  |
11 |   | If you did not receive a copy of the PHP license and are unable to   |
12 |   | obtain it through the world-wide-web, please send a note to          |
13 |   | license@php.net so we can mail you a copy immediately.               |
14 |   +----------------------------------------------------------------------+
15 | */
16 | 
17 | #pragma once
18 | #include <iostream>
19 | #include <string>
20 | #include <stdint.h>
21 | 
22 | enum XHPResult {
23 |   XHPDidNothing,
24 |   XHPRewrote,
25 |   XHPErred
26 | };
27 | 
28 | struct xhp_flags_t {
29 |   bool asp_tags;
30 |   bool short_tags;
31 |   bool idx_expr;
32 |   bool include_debug;
33 |   bool eval;
34 |   bool emit_namespaces;
35 | };
36 | 
37 | XHPResult xhp_preprocess(std::istream &in, std::string &out, bool isEval,
38 |                          std::string &errDescription, uint32_t &errLineno);
39 | 
40 | XHPResult xhp_preprocess(std::string &in, std::string &out, bool isEval,
41 |                          std::string &errDescription, uint32_t &errLineno);
42 | 
43 | XHPResult xhp_preprocess(std::string &in, std::string &out,
44 |                          std::string &errDescription, uint32_t &errLineno,
45 |                          const xhp_flags_t &flags);
46 | 


--------------------------------------------------------------------------------
/Vagrantfile:
--------------------------------------------------------------------------------
 1 | # -*- mode: ruby -*-
 2 | # vi: set ft=ruby :
 3 | 
 4 | VAGRANTFILE_API_VERSION = "2"
 5 | 
 6 | Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
 7 |   config.vm.box = "precise64"
 8 |   config.vm.box_url = "http://files.vagrantup.com/precise64.box"
 9 | 
10 |   config.vm.network :forwarded_port, guest: 80, host: 8080
11 |   config.vm.network :forwarded_port, guest: 8000, host: 8100
12 |   config.vm.network :private_network, ip: "192.168.66.66"
13 | 
14 |   config.vm.provider :virtualbox do |vb|
15 |     vb.name = "HHVM"
16 |     vb.customize ["modifyvm", :id, "--memory", "2048"]
17 |     vb.customize ["modifyvm", :id, "--ostype", "Ubuntu_64"]
18 |   end
19 | 
20 |   config.vm.provision "shell", inline: <<-shell
21 |     apt-get update
22 |     apt-get install python-software-properties  -y --force-yes
23 |     add-apt-repository ppa:mapnik/boost
24 |     add-apt-repository ppa:nginx/stable
25 |     wget -O - http://dl.hhvm.com/conf/hhvm.gpg.key | sudo apt-key add -
26 |     echo deb http://dl.hhvm.com/ubuntu precise main | sudo tee /etc/apt/sources.list.d/hhvm.list
27 |     apt-get update
28 |     apt-get install nginx -y --force-yes
29 |     apt-get install hhvm-nightly -y --force-yes
30 |     apt-get install screen vim -y --force-yes
31 |     debconf-set-selections <<< 'mysql-server-5.5 mysql-server/root_password password pa$$'
32 |     debconf-set-selections <<< 'mysql-server-5.5 mysql-server/root_password_again password pa$$'
33 |     apt-get install mysql-server -y --force-yes
34 | 
35 |     sudo chown vagrant /etc/hhvm
36 |     sudo cp /vagrant/conf/config.hdf /etc/hhvm/my-config.hdf
37 |     sudo cp /vagrant/conf/php.ini /etc/hhvm/my-php.ini
38 |     sudo rm /etc/nginx/sites-enabled/default
39 |     sudo cp /vagrant/conf/nginx-fastcgi /etc/nginx/sites-available/nginx-fastcgi
40 |     sudo ln -s /etc/nginx/sites-available/nginx-fastcgi /etc/nginx/sites-enabled/nginx-fastcgi
41 |     sudo service nginx restart
42 | 
43 |     hhvm -m daemon -c /etc/hhvm/my-php.ini -v Eval.EnableXHP=1
44 | 
45 |   shell
46 | end
47 | 


--------------------------------------------------------------------------------
/www/xhp/xhp/code_rope.hpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |   +----------------------------------------------------------------------+
 3 |   | XHP                                                                  |
 4 |   +----------------------------------------------------------------------+
 5 |   | Copyright (c) 2009 - 2013 Facebook, Inc. (http://www.facebook.com)   |
 6 |   +----------------------------------------------------------------------+
 7 |   | This source file is subject to version 3.01 of the PHP license,      |
 8 |   | that is bundled with this package in the file LICENSE.PHP, and is    |
 9 |   | available through the world-wide-web at the following url:           |
10 |   | http://www.php.net/license/3_01.txt                                  |
11 |   | If you did not receive a copy of the PHP license and are unable to   |
12 |   | obtain it through the world-wide-web, please send a note to          |
13 |   | license@php.net so we can mail you a copy immediately.               |
14 |   +----------------------------------------------------------------------+
15 | */
16 | 
17 | #include <ext/rope>
18 | #include <ext/pool_allocator.h>
19 | 
20 | class code_rope {
21 |   public:
22 |     typedef __gnu_cxx::rope<char, __gnu_cxx::__pool_alloc<char> > _rope_t;
23 |   protected:
24 |     _rope_t str;
25 |     size_t lf; /* how many line breaks this code contains */
26 |     size_t no; /* line number this code starts on */
27 |   
28 |   public:
29 |     code_rope(const _rope_t = "", const size_t = 0, const size_t = 0);
30 |     code_rope(const code_rope&, const size_t = 0, const size_t = 0);
31 |     const char* c_str() const;
32 |     void prepend(const char* str);
33 |     const char back() const;
34 |     void pop_back();
35 |     void strip_lines();
36 |     size_t lineno() const;
37 |     code_rope operator+(const code_rope& right) const;
38 |     code_rope operator+(const char*) const;
39 |     code_rope& operator=(const char*);
40 | 
41 |   friend code_rope operator+(const char*, const code_rope&);
42 | };
43 | code_rope operator+(const char*, const code_rope&);
44 | 


--------------------------------------------------------------------------------
/www/types/index.php:
--------------------------------------------------------------------------------
 1 | <?hh
 2 | 
 3 | require "/vagrant/www/xhp/php-lib/init.php";
 4 | 
 5 | set_error_handler(function ($no, $str) {
 6 |   $func = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 2)[1]['function'];
 7 |   $line = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 2)[1]['line'];
 8 |   echo <p>ERROR(calling "{$func}()" on l.{$line}) : {$str}</p>;
 9 | });
10 | 
11 | function echo_upper(string $s) {
12 |     echo (strtoupper($s));
13 | }
14 | 
15 | echo_upper("lower"); // LOWER
16 | echo_upper(5);  // ERROR(calling "echo_upper()" on l.16) : Argument 1 passed to echo_upper() must be an instance of string, int given
17 | echo_upper(null); // ERROR(calling "echo_upper()" on l.17) : Argument 1 passed to echo_upper() must be an instance of string, null given
18 | 
19 | function sum(array<int> $a) {
20 |     return array_reduce($a, ($sum, $i) ==> $sum + $i);
21 | }
22 | 
23 | echo <p>sum([1, 2, 3]) = {sum([1, 2, 3])}</p>; // sum([1, 2, 3]) = 6
24 | 
25 | class Generics<T as Countable> {
26 |     private ?T $t;
27 | 
28 |     public function get() : ?T {
29 |         return $this->t;
30 |     }
31 | 
32 |     public function set(?T $t) {
33 |         $this->t = $t;
34 |     }
35 | 
36 |     public function __toString() {
37 |         return var_export($this->t, true);
38 |     }
39 | 
40 |     public function count() {
41 |         return $this->t ? $this->t->count() : 0;
42 |     }
43 | }
44 | 
45 | $type = new Generics();
46 | $type->set(Vector {1, 2, 3});
47 | 
48 | echo <div>$type
49 |     <ul>
50 |         <li>= {$type}</li> <!-- HH\Vector { 1, 2, 3, } -->
51 |         <li>size = {$type->count()}</li> <!-- 3 -->
52 |     </ul></div>;
53 | 
54 | // To keep performance at a top level, the runtime check is partial.
55 | // The runtime check doesn't iterate on objects. In the case of array<int>
56 | // passing an int would be caught both at runtime and by the type-checker,
57 | // however passing an array of strings (like in this case) would only be
58 | // caught by the type-checker.
59 | // Those programming errors would be caught by the (yet to be release)
60 | // static analyzer
61 | sum(["a", "b"]);
62 | $type->set("No check");
63 | 


--------------------------------------------------------------------------------
/www/hhxhp/index.php:
--------------------------------------------------------------------------------
 1 | <?hh
 2 | 
 3 | require "/vagrant/www/xhp/php-lib/init.php";
 4 | 
 5 | $examples = [
 6 |     'hello'        => 'Hello HHVM / HACK',
 7 |     'promotion'    => 'Constructor argument promotion',
 8 |     'collections'  => 'Collections',
 9 |     'types'        => 'Types and Generics',
10 |     'type-checker' => 'The type checker',
11 |     'attributes'   => 'User attributes',
12 | ];
13 | 
14 | // The XHP validation should be disabled for better performance in production
15 | //:x:base::$ENABLE_VALIDATION = false;
16 | 
17 | class :tuto:examples extends :x:element {
18 |     // examples, current are required attributes
19 |     attribute array examples @required;
20 |     attribute string current @required;
21 | 
22 |     // forbid to explicitly add children
23 |     children empty;
24 | 
25 |     protected function render() {
26 |         $select = <select onchange="window.location.href=window.location.pathname + '?ex=' + this.value"/>;
27 |         foreach ($this->getAttribute('examples') as $name => $label) {
28 |             $selected = $name === $this->getAttribute('current');
29 |             $child = <option selected={$selected} value={$name}>{$label}</option>;
30 |             $select->appendChild($child);
31 |         }
32 |         return $select;
33 |     }
34 | }
35 | 
36 | $folder = preg_replace('/[^-_a-z0-9]/', '',isset($_GET['ex']) ? $_GET['ex'] : '');
37 | 
38 | function getTheCode($folder) {
39 |     $path = '/' . $folder . '/index.php';
40 |     $file = __DIR__ . '/..' . $path;
41 |     $uri = str_replace('8080', '80', dirname($_SERVER['SCRIPT_URI']). $path);
42 | 
43 |     if (file_exists($file)) {
44 |         // use "<x:frag>" to return a HTML fragment
45 |         return <x:frag>
46 |         <h2>Source file</h2>
47 |         <pre><code>{file_get_contents($file)}</code></pre>
48 |         <h2>Output</h2>
49 |         <pre><code>{file_get_contents($uri)}</code></pre>
50 |         </x:frag>;
51 |     }
52 | }
53 | 
54 | echo <html>
55 |     <head><title>"XHP generated index"</title></head>
56 |     <body>
57 |         <tuto:examples examples={$examples} current={$folder} />
58 |         {getTheCode($folder)}
59 |     </body></html>;
60 | 
61 | 
62 | 
63 | 


--------------------------------------------------------------------------------
/www/xhp/xhp/fastpath.hpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |   +----------------------------------------------------------------------+
 3 |   | XHP                                                                  |
 4 |   +----------------------------------------------------------------------+
 5 |   | Copyright (c) 2009 - 2013 Facebook, Inc. (http://www.facebook.com)   |
 6 |   +----------------------------------------------------------------------+
 7 |   | This source file is subject to version 3.01 of the PHP license,      |
 8 |   | that is bundled with this package in the file LICENSE.PHP, and is    |
 9 |   | available through the world-wide-web at the following url:           |
10 |   | http://www.php.net/license/3_01.txt                                  |
11 |   | If you did not receive a copy of the PHP license and are unable to   |
12 |   | obtain it through the world-wide-web, please send a note to          |
13 |   | license@php.net so we can mail you a copy immediately.               |
14 |   +----------------------------------------------------------------------+
15 | */
16 | 
17 | #pragma once
18 | #include "xhp_preprocess.hpp"
19 | 
20 | /**
21 |  * Provides a fast way to scan over a buffer and figure out whether or not it
22 |  * contains code that XHP needs to rewrite. This is valuable because the full
23 |  * XHP parser is a lot more expensive to run. Since we assume (for now) that
24 |  * most files won't contain XHP this fast fail greatly speeds up overal parse
25 |  * times.
26 |  *
27 |  * The nature of this function is that it still may return false positives since
28 |  * it only runs a simple lexical analysis on the source text. Particularly,
29 |  * ternary operators returning numbers or constants with no spaces in between
30 |  * tokens can fool it. i.e. `$foo = true ? 1:2` or `$foo = true ? foo:bar`.
31 |  * That's not to say you should change your coding conventions because of this,
32 |  * since it has no side effect other than slightly-slower parsing. Instead you
33 |  * should install APC or something.
34 |  *
35 |  * Note that at this point the `len` parameter is just a formality and `yy` MUST
36 |  * be NULL terminated. re2c doesn't provide any dependable means to scan a
37 |  * buffer with no sentinal value. So for instance, if you want to use this on an
38 |  * mmap'd file you must read it into memory first.
39 |  *
40 |  * Furthermore, it seems the primary maintainer of re2c doesn't want to
41 |  * implement this, so we have to work around it for now.
42 |  *
43 |  * See: re2c-Support Requests-2407218 --
44 |  * http://sourceforge.net/tracker/?func=detail&atid=616201&aid=2407218&group_id=96864
45 |  */
46 | bool xhp_fastpath(const char* yy, const size_t len, const xhp_flags_t &flags);
47 | 


--------------------------------------------------------------------------------
/www/xhp/LICENSE.ZEND:
--------------------------------------------------------------------------------
 1 | -------------------------------------------------------------------- 
 2 |                 The Zend Engine License, version 2.00
 3 | Copyright (c) 1999-2002 Zend Technologies Ltd. All rights reserved.
 4 | -------------------------------------------------------------------- 
 5 | 
 6 | Redistribution and use in source and binary forms, with or without
 7 | modification, is permitted provided that the following conditions
 8 | are met:
 9 | 
10 |   1. Redistributions of source code must retain the above copyright
11 |      notice, this list of conditions and the following disclaimer. 
12 |  
13 |   2. Redistributions in binary form must reproduce the above 
14 |      copyright notice, this list of conditions and the following 
15 |      disclaimer in the documentation and/or other materials provided
16 |      with the distribution.
17 |  
18 |   3. The names "Zend" and "Zend Engine" must not be used to endorse
19 |      or promote products derived from this software without prior
20 |      permission from Zend Technologies Ltd. For written permission,
21 |      please contact license@zend.com. 
22 |  
23 |   4. Zend Technologies Ltd. may publish revised and/or new versions
24 |      of the license from time to time. Each version will be given a
25 |      distinguishing version number.
26 |      Once covered code has been published under a particular version
27 |      of the license, you may always continue to use it under the
28 |      terms of that version. You may also choose to use such covered
29 |      code under the terms of any subsequent version of the license
30 |      published by Zend Technologies Ltd. No one other than Zend
31 |      Technologies Ltd. has the right to modify the terms applicable
32 |      to covered code created under this License.
33 | 
34 |   5. Redistributions of any form whatsoever must retain the following
35 |      acknowledgment:
36 |      "This product includes the Zend Engine, freely available at
37 |      http://www.zend.com"
38 | 
39 |   6. All advertising materials mentioning features or use of this
40 |      software must display the following acknowledgment:
41 |      "The Zend Engine is freely available at http://www.zend.com"
42 | 
43 | THIS SOFTWARE IS PROVIDED BY ZEND TECHNOLOGIES LTD. ``AS IS'' AND 
44 | ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
45 | THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A 
46 | PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ZEND
47 | TECHNOLOGIES LTD.  BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
48 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
49 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
50 | USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
51 | ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
52 | OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
53 | OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
54 | SUCH DAMAGE.
55 | 
56 | -------------------------------------------------------------------- 
57 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # HHVM Vagrant box
  2 | 
  3 | Ubuntu Precise box simply installing HHVM (nightly) via apt.
  4 | 
  5 | Find more details on the examples found in the [www](https://github.com/vicb/hhvm-vagrant/tree/master/www)
  6 | folder by reading the associated SitePoint article "HHVM and Hack – Can We
  7 | Expect Them to Replace PHP?" [part 1](http://www.sitepoint.com/hhvm-hack-part-1/)
  8 | and [part 2](http://www.sitepoint.com/look-hack-php-replacement-hhvm/).
  9 | 
 10 | ## Requirements
 11 | 
 12 | * [VirtualBox](https://www.virtualbox.org)
 13 | * [Vagrant](http://vagrantup.com)
 14 | 
 15 | ## Installation
 16 | 
 17 | ```bash
 18 | $ git clone https://github.com/vicb/hhvm-vagrant.git
 19 | $ cd hhvm-vagrant
 20 | $ vagrant up
 21 | ```
 22 | 
 23 | Once the VM is booted you can log via SSH
 24 | 
 25 | ```bash
 26 | $ vagrant ssh
 27 | $ ...
 28 | ```
 29 | 
 30 | The server root folder is `/vagrant/www` (on the map) which is the `www` folder
 31 | on your host machine.
 32 | 
 33 | - The HHVM server is available at `http://localhost:8080` on the host OS
 34 | - The HHVM admin server is available at `http://localhost:8100` on the host OS,
 35 |   the password is "admin"
 36 | - A MySQL server is installed. The root user is "root" with password "pa$$".
 37 | 
 38 | ## Usage
 39 | 
 40 | Check the [bootstraping guide](http://docs.hhvm.com/manual/en/install.hack.bootstrapping.php)
 41 | and the [HHVM docs](http://docs.hhvm.com/manual/en/index.php).
 42 | 
 43 | ## HHVM Server Configuration
 44 | 
 45 | If you want to tweak the configuration, edit the `conf/php.ini` file. The hdf
 46 | format is deprecated and support will be dropped (`conf/config.hdf`).
 47 | 
 48 | You can find more information on the configuration format:
 49 | - On the [HHVM wiki at github](https://github.com/facebook/hhvm/wiki/Runtime-options),
 50 | - In the [HHVM docs](http://docs.hhvm.com/manual/en/configuration.file.php).
 51 | 
 52 | The access and error logs are available in `/var/log/hhvm`
 53 | 
 54 | ```bash
 55 | $ vagrant ssh
 56 | $ tail -f /var/log/hhvm/access.log
 57 | $ tail -f /var/log/hhvm/error.log
 58 | ```
 59 | 
 60 | ## Virtual Machine Management
 61 | 
 62 | When done just log out with `^D` and suspend the virtual machine
 63 | 
 64 | ```bash
 65 | $ vagrant suspend
 66 | ```
 67 | 
 68 | then, resume to testing again
 69 | 
 70 | ```bash
 71 | $ vagrant resume
 72 | ```
 73 | 
 74 | Run
 75 | 
 76 | ```bash
 77 | $ vagrant halt
 78 | ```
 79 | 
 80 | to shutdown the virtual machine, and
 81 | 
 82 | ```bash
 83 | $ vagrant up
 84 | ```
 85 | 
 86 | to boot it again.
 87 | 
 88 | You can find out the state of a virtual machine anytime by invoking
 89 | 
 90 | ```bash
 91 | $ vagrant status
 92 | ```
 93 | 
 94 | Finally, to completely wipe the virtual machine from the disk **destroying all
 95 | its contents**:
 96 | 
 97 | ```bash
 98 | $ vagrant destroy
 99 | ```
100 | 
101 | ## Credits
102 | 
103 | contributors:
104 | - [donmccurdy](https://github.com/donmccurdy) has added the NGINX configuration
105 | 
106 | I got some inspiration from:
107 | - https://github.com/adrienbrault/hhvm-vagrant
108 | - https://github.com/javer/hhvm-vagrant-vm
109 | 


--------------------------------------------------------------------------------
/www/xhp/xhp/xhpize.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |   +----------------------------------------------------------------------+
 3 |   | XHP                                                                  |
 4 |   +----------------------------------------------------------------------+
 5 |   | Copyright (c) 2009 - 2013 Facebook, Inc. (http://www.facebook.com)   |
 6 |   +----------------------------------------------------------------------+
 7 |   | This source file is subject to version 3.01 of the PHP license,      |
 8 |   | that is bundled with this package in the file LICENSE.PHP, and is    |
 9 |   | available through the world-wide-web at the following url:           |
10 |   | http://www.php.net/license/3_01.txt                                  |
11 |   | If you did not receive a copy of the PHP license and are unable to   |
12 |   | obtain it through the world-wide-web, please send a note to          |
13 |   | license@php.net so we can mail you a copy immediately.               |
14 |   +----------------------------------------------------------------------+
15 | */
16 | 
17 | #include "xhp_preprocess.hpp"
18 | #include <vector>
19 | #include <string.h>
20 | #include <iostream>
21 | #include <fstream>
22 | using namespace std;
23 | 
24 | int main(int argc, char* argv[]) {
25 |   bool in_place = false, dry_run = false;
26 |   vector<string> files;
27 | 
28 |   // Parse args
29 |   for (int ii = 1; ii < argc; ++ii) {
30 |     if (strcmp(argv[ii], "-i") == 0) {
31 |       in_place = true;
32 |     } else if (strcmp(argv[ii], "-d") == 0) {
33 |       dry_run = true;
34 |     } else if (strcmp(argv[ii], "-h") == 0 || strcmp(argv[ii], "-?") == 0) {
35 |       cerr<< argv[0] << " -i [files] | " << argv[0] << " [file]\n";
36 |       return 1;
37 |     } else {
38 |       files.push_back(argv[ii]);
39 |     }
40 |   }
41 | 
42 |   // Sanity checking
43 |   if (in_place && files.size() == 0) {
44 |     cerr<< "In place mode must be used with at least one file.\n";
45 |     return 1;
46 |   } else if (!in_place && files.size() > 1) {
47 |     cerr<< "Multiple files must be used with in place mode.\n";
48 |     return 1;
49 |   } else if (files.size() == 0) {
50 |     files.push_back("-");
51 |   }
52 | 
53 |   // Parse
54 |   for (vector<string>::iterator ii = files.begin(); ii != files.end(); ++ii) {
55 | 
56 |     ifstream inputFile;
57 |     istream *inputStream;
58 |     if (*ii == "-") {
59 |       inputStream = &cin;
60 |     } else {
61 |       inputFile.open(ii->c_str());
62 |       inputStream = &inputFile;
63 |     }
64 | 
65 |     string code, error;
66 |     uint32_t errLine;
67 |     XHPResult result = xhp_preprocess(*inputStream, code, false, error, errLine);
68 |     inputFile.close();
69 |     if (result == XHPRewrote) {
70 |       if (in_place) {
71 |         if (!dry_run) {
72 |           ofstream outputFile(ii->c_str());
73 |           outputFile<< code;
74 |           outputFile.close();
75 |         }
76 |       } else {
77 |         cout<< code;
78 |         cout.flush();
79 |       }
80 |       cerr<< "File `"<<(*ii)<<"` xhpized.\n";
81 |     } else if (result == XHPErred) {
82 |       cerr<< "Error parsing file `"<<(*ii)<<"`!!\n" << error << " on line " <<
83 |         errLine << endl;;
84 |     }
85 |   }
86 | 
87 |   return 0;
88 | }
89 | 


--------------------------------------------------------------------------------
/www/xhp/LICENSE.PHP:
--------------------------------------------------------------------------------
 1 | -------------------------------------------------------------------- 
 2 |                   The PHP License, version 3.01
 3 | Copyright (c) 1999 - 2013 The PHP Group. All rights reserved.
 4 | -------------------------------------------------------------------- 
 5 | 
 6 | Redistribution and use in source and binary forms, with or without
 7 | modification, is permitted provided that the following conditions
 8 | are met:
 9 | 
10 |   1. Redistributions of source code must retain the above copyright
11 |      notice, this list of conditions and the following disclaimer.
12 |  
13 |   2. Redistributions in binary form must reproduce the above copyright
14 |      notice, this list of conditions and the following disclaimer in
15 |      the documentation and/or other materials provided with the
16 |      distribution.
17 |  
18 |   3. The name "PHP" must not be used to endorse or promote products
19 |      derived from this software without prior written permission. For
20 |      written permission, please contact group@php.net.
21 |   
22 |   4. Products derived from this software may not be called "PHP", nor
23 |      may "PHP" appear in their name, without prior written permission
24 |      from group@php.net.  You may indicate that your software works in
25 |      conjunction with PHP by saying "Foo for PHP" instead of calling
26 |      it "PHP Foo" or "phpfoo"
27 |  
28 |   5. The PHP Group may publish revised and/or new versions of the
29 |      license from time to time. Each version will be given a
30 |      distinguishing version number.
31 |      Once covered code has been published under a particular version
32 |      of the license, you may always continue to use it under the terms
33 |      of that version. You may also choose to use such covered code
34 |      under the terms of any subsequent version of the license
35 |      published by the PHP Group. No one other than the PHP Group has
36 |      the right to modify the terms applicable to covered code created
37 |      under this License.
38 | 
39 |   6. Redistributions of any form whatsoever must retain the following
40 |      acknowledgment:
41 |      "This product includes PHP software, freely available from
42 |      <http://www.php.net/software/>".
43 | 
44 | THIS SOFTWARE IS PROVIDED BY THE PHP DEVELOPMENT TEAM ``AS IS'' AND 
45 | ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
46 | THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A 
47 | PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE PHP
48 | DEVELOPMENT TEAM OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
49 | INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
50 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 
51 | SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
52 | HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
53 | STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
54 | ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
55 | OF THE POSSIBILITY OF SUCH DAMAGE.
56 | 
57 | -------------------------------------------------------------------- 
58 | 
59 | This software consists of voluntary contributions made by many
60 | individuals on behalf of the PHP Group.
61 | 
62 | The PHP Group can be contacted via Email at group@php.net.
63 | 
64 | For more information on the PHP Group and the PHP project, 
65 | please see <http://www.php.net>.
66 | 
67 | PHP includes the Zend Engine, freely available at
68 | <http://www.zend.com>.
69 | 


--------------------------------------------------------------------------------
/www/xhp/xhp/xhp_preprocess.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |   +----------------------------------------------------------------------+
 3 |   | XHP                                                                  |
 4 |   +----------------------------------------------------------------------+
 5 |   | Copyright (c) 2009 - 2013 Facebook, Inc. (http://www.facebook.com)   |
 6 |   +----------------------------------------------------------------------+
 7 |   | This source file is subject to version 3.01 of the PHP license,      |
 8 |   | that is bundled with this package in the file LICENSE.PHP, and is    |
 9 |   | available through the world-wide-web at the following url:           |
10 |   | http://www.php.net/license/3_01.txt                                  |
11 |   | If you did not receive a copy of the PHP license and are unable to   |
12 |   | obtain it through the world-wide-web, please send a note to          |
13 |   | license@php.net so we can mail you a copy immediately.               |
14 |   +----------------------------------------------------------------------+
15 | */
16 | 
17 | #include "xhp.hpp"
18 | #include "xhp_preprocess.hpp"
19 | #include "fastpath.hpp"
20 | #include <sstream>
21 | using namespace std;
22 | extern int xhpdebug;
23 | #include <iostream>
24 | 
25 | XHPResult xhp_preprocess(istream &in, string &out, bool isEval, string &errDescription, uint32_t &errLineno) {
26 | 
27 |   // Read stream to string
28 |   stringbuf sb;
29 |   in >> noskipws >> &sb;
30 |   string buffer = sb.str();
31 |   return xhp_preprocess(buffer, out, isEval, errDescription, errLineno);
32 | }
33 | 
34 | XHPResult xhp_preprocess(string &in, string &out, bool isEval, string &errDescription, uint32_t &errLineno) {
35 |   xhp_flags_t flags;
36 |   memset(&flags, 0, sizeof(xhp_flags_t));
37 |   flags.eval = isEval;
38 |   flags.short_tags = true;
39 |   flags.idx_expr = true;
40 |   flags.include_debug = true;
41 |   flags.emit_namespaces = false;
42 |   return xhp_preprocess(in, out, errDescription, errLineno, flags);
43 | }
44 | 
45 | XHPResult xhp_preprocess(std::string &in, std::string &out, std::string &errDescription, uint32_t &errLineno, const xhp_flags_t &flags) {
46 | 
47 |   // Early bail if the code doesn't contain anything that looks like XHP
48 |   char* buffer = const_cast<char*>(in.c_str());
49 |   if (!xhp_fastpath(buffer, in.length(), flags)) {
50 |     return XHPDidNothing;
51 |   }
52 | 
53 |   // Create a flex buffer
54 |   in.reserve(in.size() + 1);
55 |   buffer = const_cast<char*>(in.c_str());
56 |   buffer[in.size() + 1] = 0; // need double NULL for scan_buffer
57 | 
58 |   // Parse the PHP
59 |   void* scanner;
60 |   code_rope new_code;
61 |   yy_extra_type extra;
62 |   extra.idx_expr = flags.idx_expr;
63 |   extra.include_debug = flags.include_debug;
64 |   extra.insert_token = flags.eval ? T_OPEN_TAG_FAKE : 0;
65 |   extra.short_tags = flags.short_tags;
66 |   extra.asp_tags = flags.asp_tags;
67 |   extra.emit_namespaces = flags.emit_namespaces;
68 | 
69 |   xhplex_init(&scanner);
70 |   xhpset_extra(&extra, scanner);
71 |   xhp_scan_buffer(buffer, in.size() + 2, scanner);
72 | #ifdef DEBUG
73 |   xhpdebug = 1;
74 | #endif
75 |   xhpparse(scanner, &new_code);
76 |   xhplex_destroy(scanner);
77 | 
78 |   // Check to see what happened
79 |   if (extra.terminated) {
80 |     errDescription = extra.error;
81 |     errLineno = extra.lineno;
82 |     return XHPErred;
83 |   } else if (!extra.used) {
84 |     return XHPDidNothing;
85 |   } else {
86 |     out = new_code.c_str();
87 |     return XHPRewrote;
88 |   }
89 | }
90 | 


--------------------------------------------------------------------------------
/www/xhp/xhp/code_rope.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |   +----------------------------------------------------------------------+
  3 |   | XHP                                                                  |
  4 |   +----------------------------------------------------------------------+
  5 |   | Copyright (c) 2009 - 2013 Facebook, Inc. (http://www.facebook.com)   |
  6 |   +----------------------------------------------------------------------+
  7 |   | This source file is subject to version 3.01 of the PHP license,      |
  8 |   | that is bundled with this package in the file LICENSE.PHP, and is    |
  9 |   | available through the world-wide-web at the following url:           |
 10 |   | http://www.php.net/license/3_01.txt                                  |
 11 |   | If you did not receive a copy of the PHP license and are unable to   |
 12 |   | obtain it through the world-wide-web, please send a note to          |
 13 |   | license@php.net so we can mail you a copy immediately.               |
 14 |   +----------------------------------------------------------------------+
 15 | */
 16 | 
 17 | using namespace std;
 18 | #include "code_rope.hpp"
 19 | 
 20 | code_rope::code_rope(const _rope_t str, const size_t no /* = 0 */, const size_t lf /* = 0 */) : str(str), lf(lf), no(no) {}
 21 | 
 22 | code_rope::code_rope(const code_rope& str, const size_t no /* = 0 */, const size_t lf /* = 0 */) : str(str.str), lf(lf), no(no) {
 23 |   if (str.lf || str.no) {
 24 |     if (!no && !lf) {
 25 |       this->lf = str.lf;
 26 |       this->no = str.no;
 27 |     } else {
 28 |       throw new std::exception();
 29 |     }
 30 |   } else {
 31 |     this->no = no;
 32 |     this->lf = lf;
 33 |   }
 34 | }
 35 | 
 36 | const char* code_rope::c_str() const {
 37 |   if (0 && this->no > 1) {
 38 |     return NULL;
 39 |     // lolololololol
 40 |     // this code is clowntown -- returns dealloced memory
 41 |     _rope_t whitespace(this->no - 1, '\n');
 42 |     whitespace += this->str;
 43 |     return whitespace.c_str();
 44 |   } else {
 45 |     return this->str.c_str();
 46 |   }
 47 | }
 48 | 
 49 | void code_rope::prepend(const char* str) {
 50 |   this->str = _rope_t(str) + this->str;
 51 | }
 52 | 
 53 | const char code_rope::back() const {
 54 |   return this->str.empty() ? 0 : this->str.back();
 55 | }
 56 | 
 57 | void code_rope::pop_back() {
 58 |   this->str.pop_back();
 59 | }
 60 | 
 61 | void code_rope::strip_lines() {
 62 |   lf = no = 0;
 63 | }
 64 | 
 65 | size_t code_rope::lineno() const {
 66 |   return no;
 67 | }
 68 | 
 69 | code_rope code_rope::operator+(const code_rope& right) const {
 70 |   size_t diff;
 71 |   size_t no, lf;
 72 |   _rope_t glue;
 73 |   if (this->no && right.no) {
 74 |     no = this->no;
 75 |     if (right.no > this->no + this->lf) {
 76 |       diff = right.no - this->no - this->lf;
 77 |       lf = this->lf + right.lf + diff;
 78 |       glue = _rope_t(diff, '\n');
 79 |     } else {
 80 |       no = this->no;
 81 |       lf = this->lf + right.lf;
 82 |     }
 83 |   } else if (right.no) {
 84 |     no = right.no;
 85 |     lf = this->lf + right.lf;
 86 |   } else {
 87 |     no = this->no;
 88 |     lf = this->lf + right.lf;
 89 |   }
 90 | 
 91 |   code_rope res(this->str, no, lf);
 92 |   if (!glue.empty()) res.str += glue;
 93 |   res.str += right.str;
 94 |   return res;
 95 | }
 96 | 
 97 | code_rope code_rope::operator+(const char* right) const {
 98 |   code_rope res(this->str, this->no, this->lf);
 99 |   res.str += right;
100 |   return res;
101 | }
102 | 
103 | code_rope& code_rope::operator=(const char* str) {
104 |   this->str = str;
105 |   this->no = this->lf = 0;
106 |   return *this;
107 | }
108 | 
109 | code_rope operator+(const char* left, const code_rope& right) {
110 |   code_rope ret(code_rope::_rope_t(left), right.no, right.lf);
111 |   ret.str += right.str;
112 |   return ret;
113 | }
114 | 


--------------------------------------------------------------------------------
/www/xhp/xhp/xhp.hpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |   +----------------------------------------------------------------------+
  3 |   | XHP                                                                  |
  4 |   +----------------------------------------------------------------------+
  5 |   | Copyright (c) 2009 - 2013 Facebook, Inc. (http://www.facebook.com)   |
  6 |   +----------------------------------------------------------------------+
  7 |   | This source file is subject to version 3.01 of the PHP license,      |
  8 |   | that is bundled with this package in the file LICENSE.PHP, and is    |
  9 |   | available through the world-wide-web at the following url:           |
 10 |   | http://www.php.net/license/3_01.txt                                  |
 11 |   | If you did not receive a copy of the PHP license and are unable to   |
 12 |   | obtain it through the world-wide-web, please send a note to          |
 13 |   | license@php.net so we can mail you a copy immediately.               |
 14 |   +----------------------------------------------------------------------+
 15 | */
 16 | 
 17 | #pragma once
 18 | 
 19 | #include <stdint.h>
 20 | #include <deque>
 21 | #include <stack>
 22 | #include <string>
 23 | #include "code_rope.hpp"
 24 | 
 25 | class yy_extra_type {
 26 |   public:
 27 |     yy_extra_type() {
 28 |       lineno = 1;
 29 |       terminated = false;
 30 |       used = false;
 31 |       short_tags = true;
 32 |       asp_tags = false;
 33 |       idx_expr = false;
 34 |       include_debug = false;
 35 |       has_doc_block = false;
 36 |       emit_namespaces = false;
 37 |       expecting_xhp_class_statements = false;
 38 |       pushStack();
 39 |     }
 40 | 
 41 |     bool short_tags; // `short_open_tag` in php.ini
 42 |     bool asp_tags; // `asp_tags` in php.ini
 43 |     bool idx_expr; // allow code like `foo()['bar']`
 44 |     bool include_debug; // include line numbers and file names in XHP object creation
 45 |     bool emit_namespaces; // put everything in the global namespace (php 5.3+)
 46 |     size_t first_lineno; // line number before scanning the current token
 47 |     size_t lineno; // current line number being scanned.
 48 |     std::string error; // description of error (if terminated true)
 49 |     bool terminated; // becomes true when the parser terminates with an error
 50 |     bool used; // were any XHP-specific extensions found in this code?
 51 |     int last_token; // the last token to be returned by the scanner
 52 |     int insert_token; // insert this token without reading from buffer
 53 |     size_t heredoc_yyleng; // last length of yytext while scannling
 54 |     const char* heredoc_data; // where our heredoc data starts
 55 |     std::string heredoc_label; // heredoc sentinel label
 56 |     code_rope doc_block; // last docblock to be scanned
 57 |     bool has_doc_block; // is there a scanned docblock that needs to inserted?
 58 |     std::stack<int> curly_stack; // tokens appearing before a {
 59 |     bool expecting_xhp_class_statements; // when we're one level deep in a class
 60 |     bool old_expecting_xhp_class_statements; // store old value while inside class method
 61 |     bool used_attributes; // did this class use the `attribute` keyword
 62 |     code_rope attribute_decls; // array keys and values for __xhpAttributeDescription
 63 |     code_rope attribute_inherit; // from which classes this class should inherit attributes
 64 | 
 65 |     /* Utility functions for checking proper tag closing */
 66 |     bool haveTag() {
 67 |       return !tag_stack.front().empty();
 68 |     }
 69 |     const std::string &peekTag() {
 70 |       return tag_stack.front().front();
 71 |     }
 72 |     void pushTag(const std::string &tag) {
 73 |       tag_stack.front().push_front(tag);
 74 |     }
 75 |     void popTag() {
 76 |       tag_stack.front().pop_front();
 77 |     }
 78 |     void pushStack() {
 79 |       tag_stack.push_front(std::deque<std::string>());
 80 |     }
 81 |     void popStack() {
 82 |       tag_stack.pop_front();
 83 |     }
 84 | 
 85 |   protected:
 86 |     std::deque<std::deque<std::string> > tag_stack;
 87 | };
 88 | 
 89 | #define YYSTYPE code_rope
 90 | #define YY_HEADER_EXPORT_START_CONDITIONS
 91 | #define YY_EXTRA_TYPE yy_extra_type*
 92 | 
 93 | #include "parser.yacc.hpp"
 94 | #ifndef FLEX_SCANNER
 95 |   #include "scanner.lex.hpp"
 96 | #endif
 97 | 
 98 | int xhpparse(void*, code_rope*);
 99 | void xhp_new_push_state(int s, struct yyguts_t* yyg);
100 | void xhp_new_pop_state(struct yyguts_t* yyg);
101 | void xhp_set_state(int s, struct yyguts_t* yyg);
102 | 


--------------------------------------------------------------------------------
/www/xhp/xhp/fastpath.re:
--------------------------------------------------------------------------------
  1 | /*
  2 |   +----------------------------------------------------------------------+
  3 |   | XHP                                                                  |
  4 |   +----------------------------------------------------------------------+
  5 |   | Copyright (c) 2009 - 2013 Facebook, Inc. (http://www.facebook.com)   |
  6 |   +----------------------------------------------------------------------+
  7 |   | This source file is subject to version 3.01 of the PHP license,      |
  8 |   | that is bundled with this package in the file LICENSE.PHP, and is    |
  9 |   | available through the world-wide-web at the following url:           |
 10 |   | http://www.php.net/license/3_01.txt                                  |
 11 |   | If you did not receive a copy of the PHP license and are unable to   |
 12 |   | obtain it through the world-wide-web, please send a note to          |
 13 |   | license@php.net so we can mail you a copy immediately.               |
 14 |   +----------------------------------------------------------------------+
 15 | */
 16 | 
 17 | #include "fastpath.hpp"
 18 | #include <stdio.h>
 19 | #include <stdlib.h>
 20 | #include <string.h>
 21 | 
 22 | bool xhp_fastpath(const char* yy, const size_t len, const xhp_flags_t &flags) {
 23 |   const char* YYMARKER = NULL;
 24 |   char* heredoc_marker = NULL;
 25 |   size_t heredoc_marker_len = NULL;
 26 |   bool result = false;
 27 |   enum {
 28 |     HTML,
 29 |     PHP,
 30 |     HEREDOC,
 31 |     HEREDOC_START,
 32 |     COMMENT_EOL,
 33 |     COMMENT_BLOCK
 34 |   } state = flags.eval ? PHP : HTML;
 35 | 
 36 |   #define YYCURSOR yy
 37 |   #define YYCTYPE char
 38 |   #define YYGETCONDITION() state
 39 |   #define YYFILL(ii)
 40 |   #define YYDEBUG(s, c) printf("%03d: %c [%d]\n", s, c, c)
 41 | 
 42 |   for (;;) {
 43 |     const char* yystart = yy;
 44 | /*!re2c
 45 |     re2c:condenumprefix = "";
 46 |     re2c:yyfill:check = 0;
 47 | 
 48 |     NEWLINE = ('\r'|'\n'|'\r\n');
 49 |     WHITESPACE = [ \n\r\t]+;
 50 | 
 51 |     <*> "\x00" {
 52 |       result = false;
 53 |       break;
 54 |     }
 55 |     <*> [^\x00] { continue; }
 56 | 
 57 |     <HTML> '<?php'([ \t]|NEWLINE) {
 58 |       state = PHP;
 59 |       continue;
 60 |     }
 61 |     <HTML> '<?='|'<?' {
 62 |       if (flags.short_tags) {
 63 |         state = PHP;
 64 |       }
 65 |       continue;
 66 |     }
 67 |     <HTML> '<%='|'<%' {
 68 |       if (flags.asp_tags) {
 69 |         state = PHP;
 70 |       }
 71 |       continue;
 72 |     }
 73 | 
 74 |     <PHP> '?>' {
 75 |       state = HTML;
 76 |       continue;
 77 |     }
 78 |     <PHP> '%>' {
 79 |       if (flags.asp_tags) {
 80 |         state = PHP;
 81 |       }
 82 |       continue;
 83 |     }
 84 |     <PHP> 'b'?'\''('\\'.|'\\\n'|[^\x00\\']+)*'\''|
 85 |           'b'?'\"'('\\'.|'\\\n'|[^\x00\\"]+)*'\"' { continue; }
 86 |     <PHP> '#'|'//' {
 87 |       state = COMMENT_EOL;
 88 |       continue;
 89 |     }
 90 |     <PHP> '/*' {
 91 |       state = COMMENT_BLOCK;
 92 |       continue;
 93 |     }
 94 |     <PHP> '<<<'["' \t]* {
 95 |       state = HEREDOC_START;
 96 |       continue;
 97 |     }
 98 |     <PHP> '::' { continue; }
 99 |     <PHP> '</'|
100 |           '/>'|
101 |           '<'[a-zA-Z0-9:_\-]+'>'|
102 |           ':'[a-zA-Z0-9]|
103 |           ')'WHITESPACE*'['|
104 |           '&#' {
105 |       result = true;
106 |       break;
107 |     }
108 | 
109 |     <HEREDOC_START> [a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]* {
110 |       heredoc_marker_len = yy - yystart;
111 |       heredoc_marker = (char*)malloc(heredoc_marker_len + 1);
112 |       memcpy(heredoc_marker, yystart, heredoc_marker_len);
113 |       heredoc_marker[heredoc_marker_len] = 0;
114 |       state = HEREDOC;
115 |       continue;
116 |     }
117 | 
118 |     <HEREDOC> [^\r\n\x00]+ {
119 |       continue;
120 |     }
121 |     <HEREDOC> [\r\n]+ {
122 |       if (strncmp(yy, heredoc_marker, heredoc_marker_len) == 0 && (
123 |             yy[heredoc_marker_len] == ';' || yy[heredoc_marker_len] == '\r' ||
124 |             yy[heredoc_marker_len] == '\n')
125 |       ) {
126 |         free(heredoc_marker);
127 |         heredoc_marker = NULL;
128 |         state = PHP;
129 |       }
130 |       continue;
131 |     }
132 | 
133 |     <COMMENT_EOL> NEWLINE {
134 |       state = PHP;
135 |       continue;
136 |     }
137 |     <COMMENT_EOL> '?>' {
138 |       state = HTML;
139 |       continue;
140 |     }
141 | 
142 |     <COMMENT_BLOCK> [^*\x00] { continue; }
143 |     <COMMENT_BLOCK> '*/' {
144 |       state = PHP;
145 |       continue;
146 |     }
147 | */
148 |   }
149 |   if (heredoc_marker) {
150 |     free(heredoc_marker);
151 |   }
152 |   return result;
153 | }
154 | 


--------------------------------------------------------------------------------
/www/xhp/README.textile:
--------------------------------------------------------------------------------
  1 | h1. Introduction
  2 | 
  3 | 
  4 | XHP is a PHP extension which augments the syntax of the language such that XML document fragments become valid PHP expressions. This allows you to use PHP as a stricter templating engine and offers much more straightforward implementation of reusable components.
  5 | 
  6 | h1. Simple Example
  7 | 
  8 | bc. <?php
  9 | $href = 'http://www.facebook.com';
 10 | echo <a href={$href}>Facebook</a>;
 11 | 
 12 | Take note of the syntax on line 3, this is not a string. This is the major new syntax that XHP introduces to PHP.
 13 | 
 14 | Anything that's in {}'s is interpreted as a full PHP expression. This differs from {}'s in double-quoted strings; double-quoted strings can only contain variables.
 15 | 
 16 | You can define arbitrary elements that can be instantiated in PHP. Under the covers each element you create is an instance of an class. To define new elements you just define a new class. XHP comes with a set of predefined elements which implement most of HTML for you.
 17 | 
 18 | *Important*: Please be sure to include "init.php":http://github.com/facebook/xhp/blob/master/php-lib/init.php which is in the "php-lib":http://github.com/facebook/xhp/tree/master/php-lib/ directory of the repository. The XHP extension only handles adding the XML syntax, the actual elements are defined directly in PHP. Including the core XHP libraries in PHP code means you can customize XHP for your own applications, though it's recommended to avoid large forks which may cause incompatibilities as XHP evolves. _All the examples you see on this page omit the required includes._
 19 | 
 20 | h1. Complex Structures
 21 | 
 22 | Note that XHP structures can be arbitrarily complex. This is a valid XHP program:
 23 | 
 24 | bc. <?php
 25 | $post =
 26 |   <div class="post">
 27 |     <h2>{$post}</h2>
 28 |     <p><span>Hey there.</span></p>
 29 |     <a href={$like_link}>Like</a>
 30 |   </div>;
 31 | 
 32 | One advantage that XHP has over string construction is that it enforces correct markup structure at compile time. That is, the expression @$foo = <h1>Header</h2>;@ is not a valid expression, because you can not close an @h1@ tag with a @/h2@. When building large chunks of markup it can be difficult to be totally correct. With XHP the compiler now checks your work and will refuse to run until the markup is correct.
 33 | 
 34 | h1. Dynamic Structures
 35 | 
 36 | Sometimes it may be useful to create a bunch of elements and dynamically add them as children to an element. All XHP objects support the @appendChild@ method which behaves similarly to the same Javascript method. For example:
 37 | 
 38 | bc. <?php
 39 | $list = <ul />;
 40 | foreach ($items as $item) {
 41 |   $list->appendChild(<li>{$item}</li>);
 42 | }
 43 | 
 44 | In the code, @<ul />@ creates a ul with no children. Then we dynamically append children to it for each item in the @$items@ list.
 45 | 
 46 | h1. Escaping
 47 | 
 48 | An interesting feature of XHP is the idea of automatic escaping. In vanilla PHP if you want to render input from the user you must manually escape it. This practice is error-prone and has been proven over time to be an untenable solution. It increases code complexity and still leads to security vulnerabilities by careless programming. However, since XHP has context-specific about the page structure it can automatically escape data. The following two examples are identical, and both are "safe".
 49 | 
 50 | bc. <?php
 51 | echo '<div>Hello '.htmlspecialchars($_GET['name']).'</div>';
 52 | 
 53 | bc. <?php
 54 | echo <div>Hello {$_GET['name']}</div>;
 55 | 
 56 | As you can see, using XHP makes safety the default rather than the exception.
 57 | 
 58 | If for some reason you need to bypass XHP's escaping you can explicitly upcast a raw-str to an html-str with the @HTML()@ function. For example: @<div>{HTML($html)}</div>@. You should avoid this at all costs, however. See the "Best Practices" section below for more information.
 59 | 
 60 | h1. Defining Elements
 61 | 
 62 | All elements in XHP are just PHP classes. Even the basic HTML elements like div and span are classes. You define an element just like you do a class, except you use a leading colon to specify that you're creating an XHP element:
 63 | 
 64 | bc. <?php
 65 | class :fb:thing extends :x:element {
 66 |   ...
 67 | }
 68 | 
 69 | After we define @fb:thing@ we can instantiate it with the expression @<fb:thing />@. @:x:element@ is the core XHP class you should subclass from when defining an element. It will provide you all the methods you need like @appendChild@, and so on. As an @:x:element@ you must define only @render()@. @render()@ should always return more XHP elements. It's important to remember this rule: even elements you define yourself will return XHP elements. The only XHP elements that are allowed to return a string are elements which subclass from @:x:primitive@. The only elements which should subclass @:x:primitive@ are base elements that make HTML building blocks. XHP with the core HTML library is a viable replacement for strings of markup.
 70 | 
 71 | You can also use the leading-colon syntax to use an XHP element where you would normally use a class name, for instance while referencing class constants or typehinting:
 72 | 
 73 | bc. <?php
 74 | echo :fb:thing::someConstant;
 75 | 
 76 | bc. <?php
 77 | function giveMeAThing(:fb:thing $thing) {
 78 | }
 79 | 
 80 | h1. Defining Attributes
 81 | 
 82 | Most elements will take some number of attributes which affect its behavior. You define attributes in an element with the @attribute@ keyword.
 83 | 
 84 | bc. <?php
 85 | class :fb:thing extends :x:element {
 86 |   attribute
 87 |     string title = "No Title",
 88 |     enum { "cool", "lame" } type;
 89 | }
 90 | 
 91 | Here we define two attributes, @title@ and @type@. @title@ is of type @string@ and the default value is @"No Title"@. type is of type @enum@ and has two valid values -- @"cool"@ and @"lame"@. Valid types are @bool@, @int@, @array@, @string@, and @var@. You can also specify a class or element name as a type. Finally, you can put @required after the name to specify that this attribute is required for the element to render.
 92 | 
 93 | Note that when you extend another element you will always inherit its attributes. However, any attributes you specify with the same name will override your parent's attributes.
 94 | 
 95 | You can also steal another element's attributes by specifying only a tag name in a definition. The declaration @attribute :div@ says that this element may accept any attribute that a div element could accept.
 96 | 
 97 | h1. Defining Element Structure
 98 | 
 99 | All elements have some kind of structure that they must follow. For instance, in HTML5 it is illegal for an @<input />@ to appear directly inside of a @<body />@ tag (it must be inside a form). XHP allows you to define a content model which documents ".":http://www.overheadmovies.com must adhere to. This is done with the @children@ keyword, which uses a syntax similar to regular expressions. Note, that unlike @attribute@, @children@ may only appear once inside any class.
100 | 
101 | bc. <?php
102 | class :fb:thing-container extends :x:element {
103 |   children (:fb:thing1 | :fb:thing2)*;
104 | }
105 | 
106 | A children declaration supports the following postfix operators:
107 | * ? : Zero or one instance
108 | * * : Zero or more instances
109 | * + : One or more instances
110 | 
111 | If no operator is specified then the declaration must be matched exactly one time. You may also use the @,@ or @|@ operator to combine multiple declarations into one. The @,@ operator specifies a list of declarations that must appear in order, and a @|@ specifies a list of declarations, of which one must match. For instance if you are defining a page layout your children declaration may look like:
112 | 
113 | bc. children (:fb:left-column?, :fb:content, :fb:right-column?);
114 | 
115 | This specifies an optional left column followed by a required content and an optional right column.
116 | 
117 | You can also use the special declarations @any@ or @empty@ to specify that your element can accept any elements, or no elements. If you don't specify a children declaration your parent class's declaration will be inherited. @:x:element@'s children declaration is @children any;@.
118 | 
119 | Note: The algorithm which checks adherence to a children declaration is greedy with no backtracking. For most children declarations this will make no difference, however if you're defining a complex children declaration you should know how it works. Basically, this declaration is impossible to satisfy: @children (:fb:thing*, :fb:thing);@. The @*@ postfix operator is greedy and will capture all @fb:thing@'s. After that it's impossible to match another @fb:thing@.
120 | 
121 | h1. Element Categories
122 | 
123 | A lot of times you may want to accept all children of a particular group, but enumerating the group starts to become unsustainable. When this happens you can define an element group and specify in your child declaration that your element is a member. Then you can reference that group in a children declaration using the % prefix.
124 | 
125 | bc. class :fb:thing1 extends :x:element {
126 |   category %fb:thing;
127 | }
128 | class :fb:thing2 extends :x:element {
129 |   category %fb:thing;
130 | }
131 | class :fb:thing-container extends :x:element {
132 |   children (%fb:thing)*;
133 | }
134 | 
135 | h1. Whitespace
136 | 
137 | In XHP, text nodes that contain only whitespace are removed. The expressions @<div> </div>@ and @<div />@ are identical. Text nodes that contain non-whitespace are trimmed on the left and right to at most 1 space. This is worth noting because you may want to do something like:
138 | 
139 | bc. <?php
140 | $node = <div><label>Title:</label> <span>{$title}</span></div>;
141 | 
142 | This will lead to non-desirable results as the space in between the @:@ and @$title@ will be lost. In order to fix this try moving the space into the @<label />@ tag. If you can't do this then just use @{' '}@ which will not be stripped.
143 | 
144 | h1. Best Practices
145 | 
146 | There are certain conventions that you should comply with while using XHP.
147 | 
148 | * Don't pollute the global XHP namespace with namespace-less elements. Most elements you define should use some namespace. Elements that use no namespace should not be "magic" at all. For instance,
149 | 
150 | bc. <?php
151 | class :fb:thing extends :x:element {
152 |   protected function render() {
153 |     return <div class="thing">thing</div>;
154 |   }
155 | }
156 | 
157 | This element would be considered magic because when you print an @<fb:thing />@ it actually returns a div.
158 | 
159 | * Don't use @HTML()@. You should not use @HTML()@ unless you have a very good reason, and you have a very very good understanding of the differences between HTML strings and raw strings. And even then, avoid @HTML()@.
160 | 
161 | h1. External Resources
162 | 
163 | Below are a list of external resources about XHP:
164 | 
165 | "Code Before the Horse":http://codebeforethehorse.tumblr.com - Basic XHP introduction, examples, and lessons learned from Facebook written by one of their UI Engineers.
166 | 


--------------------------------------------------------------------------------
/www/xhp/ext.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |   +----------------------------------------------------------------------+
  3 |   | XHP                                                                  |
  4 |   +----------------------------------------------------------------------+
  5 |   | Copyright (c) 1998-2013 Zend Technologies Ltd. (http://www.zend.com) |
  6 |   | Copyright (c) 2009-2013 Facebook, Inc. (http://www.facebook.com)     |
  7 |   +----------------------------------------------------------------------+
  8 |   | This source file is subject to version 2.00 of the Zend license,     |
  9 |   | that is bundled with this package in the file LICENSE.ZEND, and is   |
 10 |   | available through the world-wide-web at the following url:           |
 11 |   | http://www.zend.com/license/2_00.txt.                                |
 12 |   | If you did not receive a copy of the Zend license and are unable to  |
 13 |   | obtain it through the world-wide-web, please send a note to          |
 14 |   | license@zend.com so we can mail you a copy immediately.              |
 15 |   +----------------------------------------------------------------------+
 16 | */
 17 | 
 18 | #include "ext.hpp"
 19 | #include "xhp/xhp_preprocess.hpp"
 20 | #include "php.h"
 21 | #include "php_ini.h"
 22 | #include "zend.h"
 23 | #include "zend_API.h"
 24 | #include "zend_compile.h"
 25 | #include "zend_operators.h"
 26 | #include "zend_hash.h"
 27 | #include "zend_extensions.h"
 28 | #include "ext/standard/info.h"
 29 | #include <string>
 30 | #include <sstream>
 31 | #include <iostream>
 32 | using namespace std;
 33 | 
 34 | //
 35 | // Decls
 36 | typedef zend_op_array* (zend_compile_file_t)(zend_file_handle*, int TSRMLS_DC);
 37 | typedef zend_op_array* (zend_compile_string_t)(zval*, char* TSRMLS_DC);
 38 | static zend_compile_file_t* dist_compile_file;
 39 | static zend_compile_string_t* dist_compile_string;
 40 | 
 41 | typedef struct {
 42 |   const char* str;
 43 |   size_t pos;
 44 |   size_t len;
 45 | } xhp_stream_t;
 46 | 
 47 | //
 48 | // Globals
 49 | ZEND_BEGIN_MODULE_GLOBALS(xhp)
 50 |   bool idx_expr;
 51 |   bool include_debug;
 52 | ZEND_END_MODULE_GLOBALS(xhp)
 53 | ZEND_DECLARE_MODULE_GLOBALS(xhp)
 54 | 
 55 | #ifdef ZTS
 56 | # define XHPG(i) TSRMG(xhp_globals_id, zend_xhp_globals*, i)
 57 | #else
 58 | # define XHPG(i) (xhp_globals.i)
 59 | #endif
 60 | 
 61 | //
 62 | // PHP 5.3 helper functions
 63 | #if PHP_VERSION_ID >= 50300
 64 | 
 65 | // These functions wese made static to zend_stream.c in r255174. These an inline copies of those functions.
 66 | static int zend_stream_getc(zend_file_handle *file_handle TSRMLS_DC) {
 67 |   char buf;
 68 | 
 69 |   if (file_handle->handle.stream.reader(file_handle->handle.stream.handle, &buf, sizeof(buf) TSRMLS_CC)) {
 70 |     return (int)buf;
 71 |   }
 72 |   return EOF;
 73 | }
 74 | 
 75 | static size_t zend_stream_read(zend_file_handle *file_handle, char *buf, size_t len TSRMLS_DC) {
 76 |   if (file_handle->type != ZEND_HANDLE_MAPPED && file_handle->handle.stream.isatty) {
 77 |     int c = '*';
 78 |     size_t n;
 79 | 
 80 | #ifdef NETWARE
 81 |     /*
 82 |       c != 4 check is there as fread of a character in NetWare LibC gives 4 upon ^D character.
 83 |       Ascii value 4 is actually EOT character which is not defined anywhere in the LibC
 84 |       or else we can use instead of hardcoded 4.
 85 |     */
 86 |     for (n = 0; n < len && (c = zend_stream_getc(file_handle TSRMLS_CC)) != EOF && c != 4 && c != '\n'; ++n) {
 87 | #else
 88 |     for (n = 0; n < len && (c = zend_stream_getc(file_handle TSRMLS_CC)) != EOF && c != '\n'; ++n)  {
 89 | #endif
 90 |         buf[n] = (char)c;
 91 |     }
 92 |     if (c == '\n') {
 93 |       buf[n++] = (char)c;
 94 |     }
 95 | 
 96 |     return n;
 97 |   }
 98 |   return file_handle->handle.stream.reader(file_handle->handle.stream.handle, buf, len TSRMLS_CC);
 99 | }
100 | #endif
101 | 
102 | //
103 | // XHP Streams
104 | size_t xhp_stream_reader(xhp_stream_t* handle, char* buf, size_t len TSRMLS_DC) {
105 |   if (len > handle->len - handle->pos) {
106 |     len = handle->len - handle->pos;
107 |   }
108 |   if (len) {
109 |     memcpy(buf, handle->str + handle->pos, len);
110 |     buf[len] = 0;
111 |     handle->pos += len;
112 |     return len;
113 |   } else {
114 |     return 0;
115 |   }
116 | }
117 | 
118 | long xhp_stream_fteller(xhp_stream_t* handle TSRMLS_DC) {
119 |   return (long)handle->pos;
120 | }
121 | 
122 | //
123 | // PHP compilation intercepter
124 | static zend_op_array* xhp_compile_file(zend_file_handle* f, int type TSRMLS_DC) {
125 | 
126 |   if (open_file_for_scanning(f TSRMLS_CC) == FAILURE) {
127 |     // If opening the file fails just send it to the original func
128 |     return dist_compile_file(f, type TSRMLS_CC);
129 |   }
130 | 
131 |   // Grab code from zend file handle
132 |   string original_code;
133 | #if PHP_VERSION_ID >= 50300
134 |   if (f->type == ZEND_HANDLE_MAPPED) {
135 |     original_code = f->handle.stream.mmap.buf;
136 |   }
137 | #else
138 |   if (0);
139 | #endif
140 |   else {
141 | 
142 |     // Read full program from zend stream
143 |     char read_buf[4096];
144 |     size_t len;
145 |     while (len = zend_stream_read(f, (char*)&read_buf, 4095 TSRMLS_CC)) {
146 |       read_buf[len] = 0;
147 |       original_code += read_buf;
148 |     }
149 |   }
150 | 
151 |   // Process XHP
152 |   XHPResult result;
153 |   xhp_flags_t flags;
154 |   string rewrit, error_str;
155 |   uint32_t error_lineno;
156 |   string* code_to_give_to_php;
157 | 
158 |   memset(&flags, 0, sizeof(xhp_flags_t));
159 |   flags.asp_tags = CG(asp_tags);
160 |   flags.short_tags = CG(short_tags);
161 |   flags.idx_expr = XHPG(idx_expr);
162 |   flags.include_debug = XHPG(include_debug);
163 | #if PHP_VERSION_ID >= 50300
164 |   flags.emit_namespaces = true;
165 | #else
166 |   flags.emit_namespaces = false;
167 | #endif
168 |   result = xhp_preprocess(original_code, rewrit, error_str, error_lineno, flags);
169 | 
170 |   if (result == XHPErred) {
171 |     // Bubble error up to PHP
172 |     CG(in_compilation) = true;
173 |     CG(zend_lineno) = error_lineno;
174 |     zend_set_compiled_filename(const_cast<char*>(f->filename) TSRMLS_CC);
175 |     zend_error(E_PARSE, "%s", error_str.c_str());
176 |     zend_bailout();
177 |   } else if (result == XHPRewrote) {
178 |     code_to_give_to_php = &rewrit;
179 |   } else {
180 |     code_to_give_to_php = &original_code;
181 |   }
182 | 
183 |   // Create a fake file to give back to PHP to handle
184 |   zend_file_handle fake_file;
185 |   fake_file.opened_path = f->opened_path ? estrdup(f->opened_path) : NULL;
186 |   fake_file.filename = f->filename;
187 |   fake_file.free_filename = false;
188 | 
189 | #if PHP_VERSION_ID >= 50300
190 |   fake_file.handle.stream.isatty = 0;
191 |   fake_file.handle.stream.mmap.pos = 0;
192 |   fake_file.handle.stream.mmap.buf = const_cast<char*>(code_to_give_to_php->c_str());
193 |   fake_file.handle.stream.mmap.len = code_to_give_to_php->size();
194 |   fake_file.handle.stream.closer = NULL;
195 |   fake_file.type = ZEND_HANDLE_MAPPED;
196 | #else
197 |   // This code works fine in PHP 5.3, but the mmap method is faster
198 |   xhp_stream_t stream_handle;
199 |   stream_handle.str = code_to_give_to_php->c_str();
200 |   stream_handle.pos = 0;
201 |   stream_handle.len = code_to_give_to_php->size();
202 | 
203 |   fake_file.type = ZEND_HANDLE_STREAM;
204 |   fake_file.handle.stream.handle = &stream_handle;
205 |   fake_file.handle.stream.reader = (zend_stream_reader_t)&xhp_stream_reader;
206 | #if PHP_VERSION_ID >= 50300
207 |   fake_file.handle.stream.fsizer = (zend_stream_fsizer_t)&xhp_stream_fteller;
208 | #else
209 |   fake_file.handle.stream.fteller = (zend_stream_fteller_t)&xhp_stream_fteller;
210 | #endif
211 |   fake_file.handle.stream.closer = NULL;
212 |   fake_file.handle.stream.interactive = 0;
213 | #endif
214 | 
215 |   zend_op_array* ret = dist_compile_file(&fake_file, type TSRMLS_CC);
216 |   return ret;
217 | }
218 | 
219 | static zend_op_array* xhp_compile_string(zval* str, char *filename TSRMLS_DC) {
220 | 
221 |   // Cast to str
222 |   zval tmp;
223 |   char* val;
224 |   if (str->type != IS_STRING) {
225 |     tmp = *str;
226 |     zval_copy_ctor(&tmp);
227 |     convert_to_string(&tmp);
228 |     val = tmp.value.str.val;
229 |   } else {
230 |     val = str->value.str.val;; 
231 |   }
232 | 
233 |   // Process XHP
234 |   string rewrit, error_str;
235 |   string* code_to_give_to_php;
236 |   uint32_t error_lineno;
237 |   string original_code(val);
238 |   xhp_flags_t flags;
239 | 
240 |   memset(&flags, 0, sizeof(xhp_flags_t));
241 |   flags.asp_tags = CG(asp_tags);
242 |   flags.short_tags = CG(short_tags);
243 |   flags.idx_expr = XHPG(idx_expr);
244 |   flags.include_debug = XHPG(include_debug);
245 |   flags.eval = true;
246 |   XHPResult result = xhp_preprocess(original_code, rewrit, error_str, error_lineno, flags);
247 | 
248 |   // Destroy temporary in the case of non-string input (why?)
249 |   if (str->type != IS_STRING) {
250 |     zval_dtor(&tmp);
251 |   }
252 | 
253 |   if (result == XHPErred) {
254 | 
255 |     // Bubble error up to PHP
256 |     bool original_in_compilation = CG(in_compilation);
257 |     CG(in_compilation) = true;
258 |     CG(zend_lineno) = error_lineno;
259 |     zend_error(E_PARSE, "%s", error_str.c_str());
260 |     CG(unclean_shutdown) = 1;
261 |     CG(in_compilation) = original_in_compilation;
262 |     return NULL;
263 |   } else if (result == XHPRewrote) {
264 | 
265 |     // Create another tmp zval with the rewritten PHP code and pass it to the original function
266 |     INIT_ZVAL(tmp);
267 |     tmp.type = IS_STRING;
268 |     tmp.value.str.val = const_cast<char*>(rewrit.c_str());
269 |     tmp.value.str.len = rewrit.size();
270 |     zend_op_array* ret = dist_compile_string(&tmp, filename TSRMLS_CC);
271 |     return ret;
272 |   } else {
273 |     return dist_compile_string(str, filename TSRMLS_CC);
274 |   }
275 | }
276 | 
277 | //
278 | // globals initialization
279 | static void php_xhp_init_globals(zend_xhp_globals* xhp_globals) {
280 |   xhp_globals->idx_expr = false;
281 |   xhp_globals->include_debug = true;
282 | }
283 | 
284 | //
285 | // ini entry
286 | PHP_INI_BEGIN()
287 |   STD_PHP_INI_BOOLEAN("xhp.idx_expr", "0", PHP_INI_PERDIR, OnUpdateBool, idx_expr, zend_xhp_globals, xhp_globals)
288 |   STD_PHP_INI_BOOLEAN("xhp.include_debug", "1", PHP_INI_PERDIR, OnUpdateBool, include_debug, zend_xhp_globals, xhp_globals)
289 | PHP_INI_END()
290 | 
291 | //
292 | // Extension entry
293 | static PHP_MINIT_FUNCTION(xhp) {
294 | 
295 |   ZEND_INIT_MODULE_GLOBALS(xhp, php_xhp_init_globals, NULL);
296 | 
297 |   REGISTER_INI_ENTRIES();
298 | 
299 |   // APC has this crazy magic api you can use to avoid the race condition for when an extension overwrites
300 |   // the compile_file function. The desired order here is APC -> XHP -> PHP, that way APC can cache the
301 |   // file as usual.
302 |   zend_module_entry *apc_lookup;
303 |   zend_constant *apc_magic;
304 |   if (zend_hash_find(&module_registry, "apc", sizeof("apc"), (void**)&apc_lookup) != FAILURE &&
305 |       zend_hash_find(EG(zend_constants), "\000apc_magic", 11, (void**)&apc_magic) != FAILURE) {
306 |     zend_compile_file_t* (*apc_set_compile_file)(zend_compile_file_t*) = (zend_compile_file_t* (*)(zend_compile_file_t*))apc_magic->value.value.lval;
307 |     dist_compile_file = apc_set_compile_file(NULL);
308 |     apc_set_compile_file(xhp_compile_file);
309 |   } else {
310 |     dist_compile_file = zend_compile_file;
311 |     zend_compile_file = xhp_compile_file;
312 |   }
313 | 
314 |   // For eval
315 |   dist_compile_string = zend_compile_string;
316 |   zend_compile_string = xhp_compile_string;
317 |   return SUCCESS;
318 | }
319 | 
320 | static PHP_MSHUTDOWN_FUNCTION(xhp) {
321 |   UNREGISTER_INI_ENTRIES();
322 |   return SUCCESS;
323 | }
324 | 
325 | //
326 | // phpinfo();
327 | static PHP_MINFO_FUNCTION(xhp) {
328 |   php_info_print_table_start();
329 |   php_info_print_table_row(2, "Version", PHP_XHP_VERSION);
330 |   php_info_print_table_end();
331 | }
332 | 
333 | //
334 | // __xhp_idx
335 | ZEND_FUNCTION(__xhp_idx) {
336 |   zval *dict, *offset;
337 |   if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &dict, &offset) == FAILURE) {
338 |     RETURN_NULL();
339 |   }
340 | 
341 |   switch (Z_TYPE_P(dict)) {
342 |     //
343 |     // These are always NULL
344 |     case IS_NULL:
345 |     case IS_BOOL:
346 |     case IS_LONG:
347 |     case IS_DOUBLE:
348 |     default:
349 |       RETURN_NULL();
350 |       break;
351 | 
352 |     //
353 |     // array()[] -- Array index
354 |     case IS_ARRAY:
355 |       switch (Z_TYPE_P(offset)) {
356 |         case IS_RESOURCE:
357 |           zend_error(E_STRICT, "Resource ID#%ld used as offset, casting to integer (%ld)", Z_LVAL_P(offset), Z_LVAL_P(offset));
358 |           /* Fall Through */
359 |         case IS_DOUBLE:
360 |         case IS_BOOL:
361 |         case IS_LONG:
362 |           long loffset;
363 |           zval **value;
364 |           if (Z_TYPE_P(offset) == IS_DOUBLE) {
365 |             loffset = (long)Z_DVAL_P(offset);
366 |           } else {
367 |             loffset = Z_LVAL_P(offset);
368 |           }
369 |           if (zend_hash_index_find(Z_ARRVAL_P(dict), loffset, (void **) &value) == SUCCESS) {
370 |             *return_value = **value;
371 |             break;
372 |           }
373 |           zend_error(E_NOTICE, "Undefined offset:  %ld", loffset);
374 |           RETURN_NULL();
375 |           break;
376 | 
377 |         case IS_STRING:
378 |           if (zend_symtable_find(Z_ARRVAL_P(dict), offset->value.str.val, offset->value.str.len+1, (void **) &value) == SUCCESS) {
379 |             *return_value = **value;
380 |             break;
381 |           }
382 |           zend_error(E_NOTICE, "Undefined index:  %s", offset->value.str.val);
383 |           RETURN_NULL();
384 |           break;
385 | 
386 |         case IS_NULL:
387 |           if (zend_hash_find(Z_ARRVAL_P(dict), "", sizeof(""), (void **) &value) == SUCCESS) {
388 |             *return_value = **value;
389 |             break;
390 |           }
391 |           zend_error(E_NOTICE, "Undefined index:  ");
392 |           RETURN_NULL();
393 |           break;
394 | 
395 |         default:
396 |           zend_error(E_WARNING, "Illegal offset type");
397 |           RETURN_NULL();
398 |           break;
399 |       }
400 |       break;
401 | 
402 |     //
403 |     // 'string'[] -- String offset
404 |     case IS_STRING:
405 |       long loffset;
406 |       switch (Z_TYPE_P(offset)) {
407 |         case IS_LONG:
408 |         case IS_BOOL:
409 |           loffset = Z_LVAL_P(offset);
410 |           break;
411 | 
412 |         case IS_DOUBLE:
413 |           loffset = (long)Z_DVAL_P(offset);
414 |           break;
415 | 
416 |         case IS_NULL:
417 |           loffset = 0;
418 |           break;
419 | 
420 |         case IS_STRING: {
421 |           zval tmp = *offset;
422 |           zval_copy_ctor(&tmp);
423 |           convert_to_long(&tmp);
424 |           loffset = Z_LVAL(tmp);
425 |           zval_dtor(&tmp);
426 |           break;
427 |         }
428 | 
429 |         default:
430 |           zend_error(E_WARNING, "Illegal offset type");
431 |           RETURN_NULL();
432 |           break;
433 |       }
434 |       if (loffset < 0 || Z_STRLEN_P(dict) <= loffset) {
435 |         zend_error(E_NOTICE, "Uninitialized string offset: %ld", loffset);
436 |         RETURN_NULL();
437 |       }
438 |       RETURN_STRINGL(Z_STRVAL_P(dict) + loffset, 1, true);
439 |       break;
440 | 
441 |     //
442 |     // (new foo)[] -- Object overload (ArrayAccess)
443 |     case IS_OBJECT:
444 |       if (!Z_OBJ_HT_P(dict)->read_dimension) {
445 |         zend_error(E_ERROR, "Cannot use object as array");
446 |         RETURN_NULL();
447 |       } else {
448 |         zval* overloaded_result = Z_OBJ_HT_P(dict)->read_dimension(dict, offset, BP_VAR_R TSRMLS_CC);
449 |         if (overloaded_result) {
450 |           *return_value = *overloaded_result;
451 |         } else {
452 |           RETURN_NULL();
453 |         }
454 |       }
455 |       break;
456 |   }
457 |   zval_copy_ctor(return_value);
458 | }
459 | 
460 | //
461 | // xhp_preprocess_code
462 | ZEND_FUNCTION(xhp_preprocess_code) {
463 |   // Parse zend params
464 |   char *code;
465 |   int code_len;
466 |   if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &code, &code_len) == FAILURE) {
467 |     RETURN_NULL();
468 |   }
469 |   string rewrit, error;
470 |   uint32_t error_line;
471 | 
472 |   // Mangle code
473 |   string code_str(code, code_len);
474 |   XHPResult result = xhp_preprocess(code_str, rewrit, false, error, error_line);
475 | 
476 |   // Build return code
477 |   array_init(return_value);
478 |   if (result == XHPErred) {
479 |     add_assoc_string(return_value, "error", const_cast<char*>(error.c_str()), true);
480 |     add_assoc_long(return_value, "error_line", error_line);
481 |   } else if (result == XHPRewrote) {
482 |     add_assoc_string(return_value, "new_code", const_cast<char*>(rewrit.c_str()), true);
483 |   }
484 | }
485 | 
486 | //
487 | // Module description
488 | zend_function_entry xhp_functions[] = {
489 |   ZEND_FE(__xhp_idx, NULL)
490 |   ZEND_FE(xhp_preprocess_code, NULL)
491 |   {NULL, NULL, NULL}
492 | };
493 | 
494 | zend_module_entry xhp_module_entry = {
495 |   STANDARD_MODULE_HEADER,
496 |   PHP_XHP_EXTNAME,
497 |   xhp_functions,
498 |   PHP_MINIT(xhp),
499 |   PHP_MSHUTDOWN(xhp),
500 |   NULL,
501 |   NULL,
502 |   PHP_MINFO(xhp),
503 |   PHP_XHP_VERSION,
504 |   STANDARD_MODULE_PROPERTIES
505 | };
506 | 
507 | #ifdef COMPILE_DL_XHP
508 | ZEND_GET_MODULE(xhp)
509 | #endif
510 | 


--------------------------------------------------------------------------------
/www/xhp/php-lib/html.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /*
  3 |   +----------------------------------------------------------------------+
  4 |   | XHP                                                                  |
  5 |   +----------------------------------------------------------------------+
  6 |   | Copyright (c) 2009 - 2012 Facebook, Inc. (http://www.facebook.com)   |
  7 |   +----------------------------------------------------------------------+
  8 |   | This source file is subject to version 3.01 of the PHP license,      |
  9 |   | that is bundled with this package in the file LICENSE.PHP, and is    |
 10 |   | available through the world-wide-web at the following url:           |
 11 |   | http://www.php.net/license/3_01.txt                                  |
 12 |   | If you did not receive a copy of the PHP license and are unable to   |
 13 |   | obtain it through the world-wide-web, please send a note to          |
 14 |   | license@php.net so we can mail you a copy immediately.               |
 15 |   +----------------------------------------------------------------------+
 16 | */
 17 | 
 18 | /**
 19 |  * This is the base library of HTML elements for use in XHP. This includes all
 20 |  * non-deprecated tags and attributes. Elements in this file should stay as
 21 |  * close to spec as possible. Facebook-specific extensions should go into their
 22 |  * own elements.
 23 |  */
 24 | abstract class :xhp:html-element extends :x:primitive {
 25 | 
 26 |   attribute
 27 |     // Global HTML attributes
 28 |     string accesskey, string class, bool contenteditable, string contextmenu,
 29 |     string dir, bool draggable, string dropzone, bool hidden, string id,
 30 |     string lang, string role, enum {'true', 'false'} spellcheck, string style,
 31 |     string tabindex, string title, enum {'yes', 'no'} translate,
 32 | 
 33 |     // Javascript events
 34 |     string onabort, string onblur, string oncancel, string oncanplay,
 35 |     string oncanplaythrough, string onchange, string onclick, string onclose,
 36 |     string oncontextmenu, string oncuechange, string ondblclick,
 37 |     string ondrag, string ondragend, string ondragenter, string ondragexit,
 38 |     string ondragleave, string ondragover, string ondragstart, string ondrop,
 39 |     string ondurationchange, string onemptied, string onended, string onerror,
 40 |     string onfocus, string oninput, string oninvalid, string onkeydown,
 41 |     string onkeypress, string onkeyup, string onload, string onloadeddata,
 42 |     string onloadedmetadata, string onloadstart, string onmousedown,
 43 |     string onmousemove, string onmouseout, string onmouseover,
 44 |     string onmouseup, string onmousewheel, string onpause, string onplay,
 45 |     string onplaying, string onprogress, string onratechange,
 46 |     string onreadystatechange, string onreset, string onscroll,
 47 |     string onseeked, string onseeking, string onselect, string onshow,
 48 |     string onstalled, string onsubmit, string onsuspend, string ontimeupdate,
 49 |     string onvolumechange, string onwaiting,
 50 | 
 51 |     // IE only
 52 |     string onmouseenter, string onmouseleave;
 53 | 
 54 |   protected
 55 |     $tagName;
 56 | 
 57 |   public function getID() {
 58 |     return $this->requireUniqueID();
 59 |   }
 60 | 
 61 |   public function requireUniqueID() {
 62 |     if (!($id = $this->getAttribute('id'))) {
 63 |       $this->setAttribute('id', $id = substr(md5(mt_rand(0, 100000)), 0, 10));
 64 |     }
 65 |     return $id;
 66 |   }
 67 | 
 68 |   protected final function renderBaseAttrs() {
 69 |     $buf = '<'.$this->tagName;
 70 |     foreach ($this->getAttributes() as $key => $val) {
 71 |       if ($val !== null && $val !== false) {
 72 |         if ($val === true) {
 73 |           $buf .= ' '.htmlspecialchars($key);
 74 |         } else {
 75 |           $buf .= ' '.htmlspecialchars($key).'="'.htmlspecialchars($val, ENT_QUOTES).'"';
 76 |         }
 77 |       }
 78 |     }
 79 |     return $buf;
 80 |   }
 81 | 
 82 |   public function addClass($class) {
 83 |     $this->setAttribute('class', trim($this->getAttribute('class').' '.$class));
 84 |     return $this;
 85 |   }
 86 | 
 87 |   public function conditionClass($cond, $class) {
 88 |     if ($cond) {
 89 |       $this->addClass($class);
 90 |     }
 91 |     return $this;
 92 |   }
 93 | 
 94 |   protected function stringify() {
 95 |     $buf = $this->renderBaseAttrs().'>';
 96 |     foreach ($this->getChildren() as $child) {
 97 |       $buf .= :x:base::renderChild($child);
 98 |     }
 99 |     $buf .= '</'.$this->tagName.'>';
100 |     return $buf;
101 |   }
102 | }
103 | 
104 | /**
105 |  * Subclasses of :xhp:html-singleton may not contain children. When
106 |  * rendered they will be in singleton (<img />, <br />) form.
107 |  */
108 | abstract class :xhp:html-singleton extends :xhp:html-element {
109 |   children empty;
110 | 
111 |   protected function stringify() {
112 |     return $this->renderBaseAttrs().'>';
113 |   }
114 | }
115 | 
116 | /**
117 |  * Subclasses of :xhp:pcdata-elements may contain only string children.
118 |  */
119 | abstract class :xhp:pcdata-element extends :xhp:html-element {
120 |   children (pcdata)*;
121 | }
122 | 
123 | /**
124 |  * Subclasses of :xhp:raw-pcdata-element must contain only string children.
125 |  * However, the strings will not be escaped. This is intended for tags like
126 |  * <script> or <style> whose content is interpreted literally by the browser.
127 |  *
128 |  * From section 6.2 of the HTML 4.01 spec: "Although the STYLE and SCRIPT
129 |  * elements use CDATA for their data model, for these elements, CDATA must be
130 |  * handled differently by user agents. Markup and entities must be treated as
131 |  * raw text and passed to the application as is. The first occurrence of the
132 |  * character sequence "</" (end-tag open delimiter) is treated as terminating
133 |  * the end of the s content. In valid documents, this would be the end tag for
134 |  * the element."
135 |  */
136 | abstract class :xhp:raw-pcdata-element extends :xhp:pcdata-element {
137 |   protected function stringify() {
138 |     $buf = $this->renderBaseAttrs() . '>';
139 |     foreach ($this->getChildren() as $child) {
140 |       if (!is_string($child)) {
141 |         throw new XHPClassException($this, 'Child must be a string');
142 |       }
143 |       $buf .= $child;
144 |     }
145 |     $buf .= '</'.$this->tagName.'>';
146 |     return $buf;
147 |   }
148 | }
149 | 
150 | /**
151 |  * Below is a big wall of element definitions. These are the basic building
152 |  * blocks of XHP pages.
153 |  */
154 | class :a extends :xhp:html-element {
155 |   attribute
156 |     string download, string href, string hreflang, string media, string rel,
157 |     string target, string type,
158 |     // Legacy
159 |     string name;
160 |   category %flow, %phrase, %interactive;
161 |   // Should not contain %interactive
162 |   children (pcdata | %flow)*;
163 |   protected $tagName = 'a';
164 | }
165 | 
166 | class :abbr extends :xhp:html-element {
167 |   category %flow, %phrase;
168 |   children (pcdata | %phrase)*;
169 |   protected $tagName = 'abbr';
170 | }
171 | 
172 | class :address extends :xhp:html-element {
173 |   category %flow;
174 |   // May not contain %heading, %sectioning, :header, :footer, or :address
175 |   children (pcdata | %flow)*;
176 |   protected $tagName = 'address';
177 | }
178 | 
179 | class :area extends :xhp:html-singleton {
180 |   attribute
181 |     string alt, string coords, string download, string href, bool hreflang,
182 |     string media, string rel,
183 |     enum {
184 |       'circ', 'circle', 'default', 'poly', 'polygon', 'rect', 'rectangle'
185 |     } shape, string target, string type;
186 |   category %flow, %phrase;
187 |   protected $tagName = 'area';
188 | }
189 | 
190 | class :article extends :xhp:html-element {
191 |   category %flow, %sectioning;
192 |   children (pcdata | %flow)*;
193 |   protected $tagName = 'article';
194 | }
195 | 
196 | class :aside extends :xhp:html-element {
197 |   category %flow, %sectioning;
198 |   children (pcdata | %flow)*;
199 |   protected $tagName = 'aside';
200 | }
201 | 
202 | class :audio extends :xhp:html-element {
203 |   attribute
204 |     bool autoplay, bool controls,
205 |     enum {'anonymous', 'use-credentials'} crossorigin, bool loop,
206 |     string mediagroup, bool muted, enum {'none', 'metadata', 'auto'} preload,
207 |     string src;
208 |   category %flow, %phrase, %embedded, %interactive;
209 |   children (:source*, :track*, (pcdata | %flow)*);
210 |   protected $tagName = 'audio';
211 | }
212 | 
213 | class :b extends :xhp:html-element {
214 |   category %flow, %phrase;
215 |   children (pcdata | %phrase)*;
216 |   protected $tagName = 'b';
217 | }
218 | 
219 | class :base extends :xhp:html-singleton {
220 |   attribute string href, string target;
221 |   category %metadata;
222 |   protected $tagName = 'base';
223 | }
224 | 
225 | class :bdi extends :xhp:html-element {
226 |   category %flow, %phrase;
227 |   children (pcdata | %phrase)*;
228 |   protected $tagName = 'bdi';
229 | }
230 | 
231 | class :bdo extends :xhp:html-element {
232 |   category %flow, %phrase;
233 |   children (pcdata | %phrase)*;
234 |   protected $tagName = 'bdo';
235 | }
236 | 
237 | class :blockquote extends :xhp:html-element {
238 |   attribute string cite;
239 |   category %flow;
240 |   children (pcdata | %flow)*;
241 |   protected $tagName = 'blockquote';
242 | }
243 | 
244 | class :body extends :xhp:html-element {
245 |   attribute
246 |     string onafterprint, string onbeforeprint, string onbeforeunload,
247 |     string onhashchange, string onmessage, string onoffline, string ononline,
248 |     string onpagehide, string onpageshow, string onpopstate, string onresize,
249 |     string onstorage, string onunload;
250 |   children (pcdata | %flow)*;
251 |   protected $tagName = 'body';
252 | }
253 | 
254 | class :br extends :xhp:html-singleton {
255 |   category %flow, %phrase;
256 |   protected $tagName = 'br';
257 | }
258 | 
259 | class :button extends :xhp:html-element {
260 |   attribute
261 |     bool autofocus, bool disabled, string form, string formaction,
262 |     string formenctype, enum {'get', 'post'} formmethod, bool formnovalidate,
263 |     string formtarget, string name, enum {'submit', 'button', 'reset'} type,
264 |     string value;
265 |   category %flow, %phrase, %interactive;
266 |   // Should not contain interactive
267 |   children (pcdata | %phrase)*;
268 |   protected $tagName = 'button';
269 | }
270 | 
271 | class :caption extends :xhp:html-element {
272 |   // Should not contain :table
273 |   children (pcdata | %flow)*;
274 |   protected $tagName = 'caption';
275 | }
276 | 
277 | class :canvas extends :xhp:html-element {
278 |   attribute int height, int width;
279 |   category %flow, %phrase, %embedded;
280 |   // Should not contain :table
281 |   children (pcdata | %flow)*;
282 |   protected $tagName = 'canvas';
283 | }
284 | 
285 | class :cite extends :xhp:html-element {
286 |   category %flow, %phrase;
287 |   children (pcdata | %phrase)*;
288 |   protected $tagName = 'cite';
289 | }
290 | 
291 | class :code extends :xhp:html-element {
292 |   category %flow, %phrase;
293 |   children (pcdata | %phrase)*;
294 |   protected $tagName = 'code';
295 | }
296 | 
297 | class :col extends :xhp:html-singleton {
298 |   attribute int span;
299 |   protected $tagName = 'col';
300 | }
301 | 
302 | class :colgroup extends :xhp:html-element {
303 |   attribute int span;
304 |   children (:col)*;
305 |   protected $tagName = 'colgroup';
306 | }
307 | 
308 | class :data extends :xhp:html-element {
309 |   attribute string value @required;
310 |   category %flow, %phrase;
311 |   children (%phrase*);
312 |   protected $tagName = 'data';
313 | }
314 | 
315 | class :dd extends :xhp:html-element {
316 |   children (pcdata | %flow)*;
317 |   protected $tagName = 'dd';
318 | }
319 | 
320 | class :del extends :xhp:html-element {
321 |   attribute string cite, string datetime;
322 |   category %flow, %phrase;
323 |   // transparent
324 |   children (pcdata | %flow)*;
325 |   protected $tagName = 'del';
326 | }
327 | 
328 | class :details extends :xhp:html-element {
329 |   attribute bool open;
330 |   category %flow, %phrase, %interactive;
331 |   children (:summary, %flow+);
332 |   protected $tagName = 'details';
333 | }
334 | 
335 | class :dialog extends :xhp:html-element {
336 |   attribute bool open;
337 |   category %flow, %sectioning;
338 |   children (%flow);
339 |   protected $tagName = 'dialog';
340 | }
341 | 
342 | class :div extends :xhp:html-element {
343 |   category %flow;
344 |   children (pcdata | %flow)*;
345 |   protected $tagName = 'div';
346 | }
347 | 
348 | class :dfn extends :xhp:html-element {
349 |   category %flow, %phrase;
350 |   children (pcdata | %phrase)*;
351 |   protected $tagName = 'dfn';
352 | }
353 | 
354 | class :dl extends :xhp:html-element {
355 |   category %flow;
356 |   children (:dt+, :dd+)*;
357 |   protected $tagName = 'dl';
358 | }
359 | 
360 | class :dt extends :xhp:html-element {
361 |   children (pcdata | %flow)*;
362 |   protected $tagName = 'dt';
363 | }
364 | 
365 | class :em extends :xhp:html-element {
366 |   category %flow, %phrase;
367 |   children (pcdata | %phrase)*;
368 |   protected $tagName = 'em';
369 | }
370 | 
371 | class :embed extends :xhp:html-element {
372 |   attribute
373 |     int height, string src, string type, int width,
374 |     /**
375 |      * The following attributes are Flash specific.
376 |      * Most notable use: youtube video embedding
377 |      */
378 |     bool allowfullscreen, enum {'always', 'never'} allowscriptaccess,
379 |     string wmode;
380 | 
381 |   category %flow, %phrase, %embedded, %interactive;
382 |   children (pcdata | %phrase)*;
383 |   protected $tagName = 'embed';
384 | }
385 | 
386 | class :fieldset extends :xhp:html-element {
387 |   attribute bool disabled, string form, string name;
388 |   category %flow;
389 |   children (:legend?, (pcdata | %flow)*);
390 |   protected $tagName = 'fieldset';
391 | }
392 | 
393 | class :figcaption extends :xhp:html-element {
394 |   children (pcdata | %flow)*;
395 |   protected $tagName = 'figcaption';
396 | }
397 | 
398 | class :figure extends :xhp:html-element {
399 |   category %flow;
400 |   children ((:figcaption, %flow+) | (%flow+, :figcaption?));
401 |   protected $tagName = 'figure';
402 | }
403 | 
404 | class :footer extends :xhp:html-element {
405 |   category %flow;
406 |   children (pcdata | %flow)*;
407 |   protected $tagName = 'footer';
408 | }
409 | 
410 | class :form extends :xhp:html-element {
411 |   attribute
412 |     string action, string accept-charset, enum {'on', 'off'} autocomplete,
413 |     string enctype, enum {'get', 'post'} method, string name, bool novalidate,
414 |     string target;
415 |   category %flow;
416 |   // Should not contain :form
417 |   children (pcdata | %flow)*;
418 |   protected $tagName = 'form';
419 | }
420 | 
421 | class :h1 extends :xhp:html-element {
422 |   category %flow;
423 |   children (pcdata | %phrase)*;
424 |   protected $tagName = 'h1';
425 | }
426 | 
427 | class :h2 extends :xhp:html-element {
428 |   category %flow;
429 |   children (pcdata | %phrase)*;
430 |   protected $tagName = 'h2';
431 | }
432 | 
433 | class :h3 extends :xhp:html-element {
434 |   category %flow;
435 |   children (pcdata | %phrase)*;
436 |   protected $tagName = 'h3';
437 | }
438 | 
439 | class :h4 extends :xhp:html-element {
440 |   category %flow;
441 |   children (pcdata | %phrase)*;
442 |   protected $tagName = 'h4';
443 | }
444 | 
445 | class :h5 extends :xhp:html-element {
446 |   category %flow;
447 |   children (pcdata | %phrase)*;
448 |   protected $tagName = 'h5';
449 | }
450 | 
451 | class :h6 extends :xhp:html-element {
452 |   category %flow;
453 |   children (pcdata | %phrase)*;
454 |   protected $tagName = 'h6';
455 | }
456 | 
457 | class :head extends :xhp:html-element {
458 |   children (%metadata*);
459 |   protected $tagName = 'head';
460 | }
461 | 
462 | class :header extends :xhp:html-element {
463 |   category %flow, %heading;
464 |   children (pcdata | %flow)*;
465 |   protected $tagName = 'header';
466 | }
467 | 
468 | class :hgroup extends :xhp:html-element {
469 |   category %flow, %heading;
470 |   children (:h1 | :h2 | :h3 | :h4 | :h5 | :h6)+;
471 |   protected $tagName = 'hgroup';
472 | }
473 | 
474 | class :hr extends :xhp:html-singleton {
475 |   category %flow;
476 |   protected $tagName = 'hr';
477 | }
478 | 
479 | class :html extends :xhp:html-element {
480 |   attribute string manifest, string xmlns;
481 |   children (:head, :body);
482 |   protected $tagName = 'html';
483 | }
484 | 
485 | class :i extends :xhp:html-element {
486 |   category %flow, %phrase;
487 |   children (pcdata | %phrase)*;
488 |   protected $tagName = 'i';
489 | }
490 | 
491 | class :iframe extends :xhp:pcdata-element {
492 |   attribute
493 |     string name, int height, string sandbox, bool seamless, string src,
494 |     string srcdoc, int width;
495 |   category %flow, %phrase, %embedded, %interactive;
496 |   protected $tagName = 'iframe';
497 | }
498 | 
499 | class :img extends :xhp:html-singleton {
500 |   attribute
501 |     string alt, enum {'anonymous', 'use-credentials'} crossorigin, int height,
502 |     bool ismap, string src, string usemap, int width;
503 |   category %flow, %phrase;
504 |   protected $tagName = 'img';
505 | }
506 | 
507 | class :input extends :xhp:html-singleton {
508 |   attribute
509 |     string accept, string alt, enum {'on', 'off'} autocomplete, bool autofocus,
510 |     bool checked, string dirname, bool disabled, string form,
511 |     string formaction, string formenctype, enum {'get', 'post'} formmethod,
512 |     bool formnovalidate, string formtarget, int height, string list,
513 |     float max, int maxlength, float min, bool multiple, string name,
514 |     string pattern, string placeholder, bool readonly, bool required,
515 |     int size, string src, float step, enum {
516 |       'hidden', 'text', 'search', 'tel', 'url', 'email', 'password',
517 |       'datetime', 'date', 'month', 'week', 'time', 'datetime-local', 'number',
518 |       'range', 'color', 'checkbox', 'radio', 'file', 'submit', 'image',
519 |       'reset', 'button'
520 |     } type, string value, int width;
521 |   category %flow, %phrase, %interactive;
522 |   protected $tagName = 'input';
523 | }
524 | 
525 | class :ins extends :xhp:html-element {
526 |   attribute string cite, string datetime;
527 |   category %flow, %phrase;
528 |   children (pcdata | %flow)*;
529 |   protected $tagName = 'ins';
530 | }
531 | 
532 | class :keygen extends :xhp:html-singleton {
533 |   attribute
534 |     bool autofocus, string challenge, bool disabled, string form,
535 |     string keytype, string name;
536 |   category %flow, %phrase, %interactive;
537 |   protected $tagName = 'keygen';
538 | }
539 | 
540 | class :kbd extends :xhp:html-element {
541 |   category %flow, %phrase;
542 |   children (pcdata | %phrase)*;
543 |   protected $tagName = 'kbd';
544 | }
545 | 
546 | class :label extends :xhp:html-element {
547 |   attribute string for, string form;
548 |   category %flow, %phrase, %interactive;
549 |   // may not contain label
550 |   children (pcdata | %phrase)*;
551 |   protected $tagName = 'label';
552 | }
553 | 
554 | class :legend extends :xhp:html-element {
555 |   children (pcdata | %phrase)*;
556 |   protected $tagName = 'legend';
557 | }
558 | 
559 | class :li extends :xhp:html-element {
560 |   children (pcdata | %flow)*;
561 |   protected $tagName = 'li';
562 | }
563 | 
564 | class :link extends :xhp:html-singleton {
565 |   attribute
566 |     enum {'anonymous', 'use-credentials'} crossorigin, string href,
567 |     string hreflang, string media, string rel @required, string sizes,
568 |     string type;
569 |   category %metadata;
570 |   protected $tagName = 'link';
571 | }
572 | 
573 | class :main extends :xhp:html-element {
574 |   category %flow;
575 |   children (pcdata | %flow)*;
576 |   protected $tagName = 'main';
577 | }
578 | 
579 | class :map extends :xhp:html-element {
580 |   attribute string name;
581 |   category %flow, %phrase;
582 |   children (pcdata | %flow)*;
583 |   protected $tagName = 'map';
584 | }
585 | 
586 | class :mark extends :xhp:html-element {
587 |   category %flow, %phrase;
588 |   children (pcdata | %phrase)*;
589 |   protected $tagName = 'mark';
590 | }
591 | 
592 | class :meta extends :xhp:html-singleton {
593 |   attribute
594 |     // The correct definition of http-equiv is an enum, but there are legacy
595 |     // values still used and any strictness here would only be frustrating.
596 |     string charset, string content @required, string http-equiv, string name,
597 |     // Facebook OG
598 |     string property;
599 |   category %metadata;
600 |   protected $tagName = 'meta';
601 | }
602 | 
603 | class :meter extends :xhp:html-element {
604 |   attribute
605 |     float high, float low, float max, float min, float optimum, float value;
606 |   category %flow, %phrase;
607 |   // Should not contain :meter
608 |   children (pcdata | %phrase)*;
609 |   protected $tagName = 'meter';
610 | }
611 | 
612 | class :nav extends :xhp:html-element {
613 |   category %flow;
614 |   children (pcdata | %flow)*;
615 |   protected $tagName = 'nav';
616 | }
617 | 
618 | class :noscript extends :xhp:html-element {
619 |   children (pcdata)*;
620 |   category %flow, %phrase, %metadata;
621 |   protected $tagName = 'noscript';
622 | }
623 | 
624 | class :object extends :xhp:html-element {
625 |   attribute
626 |     string data, int height, string form, string name, string type,
627 |     bool typemustmatch, string usemap, int width;
628 |   category %flow, %phrase, %embedded, %interactive;
629 |   children (:param*, (pcdata | %flow)*);
630 |   protected $tagName = 'object';
631 | }
632 | 
633 | class :ol extends :xhp:html-element {
634 |   attribute bool reversed, int start, enum {'1', 'a', 'A', 'i', 'I'} type;
635 |   category %flow;
636 |   children (:li)*;
637 |   protected $tagName = 'ol';
638 | }
639 | 
640 | class :optgroup extends :xhp:html-element {
641 |   attribute bool disabled, string label;
642 |   children (:option)*;
643 |   protected $tagName = 'optgroup';
644 | }
645 | 
646 | class :option extends :xhp:pcdata-element {
647 |   attribute bool disabled, string label, bool selected, string value;
648 |   protected $tagName = 'option';
649 | }
650 | 
651 | class :output extends :xhp:html-element {
652 |   attribute string for, string form, string name;
653 |   category %flow, %phrase;
654 |   children (pcdata | %phrase)*;
655 |   protected $tagName = 'output';
656 | }
657 | 
658 | class :p extends :xhp:html-element {
659 |   category %flow;
660 |   children (pcdata | %phrase)*;
661 |   protected $tagName = 'p';
662 | }
663 | 
664 | class :param extends :xhp:pcdata-element {
665 |   attribute string name, string value;
666 |   protected $tagName = 'param';
667 | }
668 | 
669 | class :pre extends :xhp:html-element {
670 |   category %flow;
671 |   children (pcdata | %phrase)*;
672 |   protected $tagName = 'pre';
673 | }
674 | 
675 | class :progress extends :xhp:html-element {
676 |   attribute float max, float value;
677 |   category %flow, %phrase;
678 |   // Should not contain :progress
679 |   children (pcdata | %phrase)*;
680 |   protected $tagName = 'progress';
681 | }
682 | 
683 | class :q extends :xhp:html-element {
684 |   attribute string cite;
685 |   category %flow, %phrase;
686 |   children (pcdata | %phrase)*;
687 |   protected $tagName = 'q';
688 | }
689 | 
690 | class :rp extends :xhp:html-element {
691 |   children (pcdata | %phrase)+;
692 |   protected $tagName = 'rp';
693 | }
694 | 
695 | class :rt extends :xhp:html-element {
696 |   children (pcdata | %phrase)+;
697 |   protected $tagName = 'rt';
698 | }
699 | 
700 | class :ruby extends :xhp:html-element {
701 |   category %flow, %phrase;
702 |   children (pcdata+, (:rt | (:rp, :rt, :rp)))+;
703 |   protected $tagName = 'ruby';
704 | }
705 | 
706 | class :s extends :xhp:html-element {
707 |   category %flow, %phrase;
708 |   children (pcdata | %phrase)*;
709 |   protected $tagName = 's';
710 | }
711 | 
712 | class :samp extends :xhp:html-element {
713 |   category %flow, %phrase;
714 |   children (pcdata | %phrase)*;
715 |   protected $tagName = 'samp';
716 | }
717 | 
718 | class :script extends :xhp:raw-pcdata-element {
719 |   attribute bool async, string charset,
720 |   enum {'anonymous', 'use-credentials'} crossorigin, bool defer, string src,
721 |   string type,
722 |   // Legacy
723 |   string language;
724 |   category %flow, %phrase, %metadata;
725 |   protected $tagName = 'script';
726 | }
727 | 
728 | class :section extends :xhp:html-element {
729 |   category %flow, %sectioning;
730 |   children (pcdata | %flow)*;
731 |   protected $tagName = 'section';
732 | }
733 | 
734 | class :select extends :xhp:html-element {
735 |   attribute
736 |     bool autofocus, bool disabled, string form, bool multiple, string name,
737 |     bool required, int size;
738 |   category %flow, %phrase, %interactive;
739 |   children (:option | :optgroup)*;
740 |   protected $tagName = 'select';
741 | }
742 | 
743 | class :small extends :xhp:html-element {
744 |   category %flow, %phrase;
745 |   children (pcdata | %phrase)*;
746 |   protected $tagName = 'small';
747 | }
748 | 
749 | class :source extends :xhp:html-singleton {
750 |   attribute string media, string src, string type;
751 |   protected $tagName = 'source';
752 | }
753 | 
754 | class :span extends :xhp:html-element {
755 |   category %flow, %phrase;
756 |   children (pcdata | %phrase)*;
757 |   protected $tagName = 'span';
758 | }
759 | 
760 | class :strong extends :xhp:html-element {
761 |   category %flow, %phrase;
762 |   children (pcdata | %phrase)*;
763 |   protected $tagName = 'strong';
764 | }
765 | 
766 | class :style extends :xhp:raw-pcdata-element {
767 |   attribute
768 |     enum {
769 |       'all', 'aural', 'braille', 'embossed', 'handheld', 'print', 'projection',
770 |       'screen', 'speech', 'tty', 'tv'
771 |     } media, bool scoped, string type;
772 |   category %flow, %metadata;
773 |   protected $tagName = 'style';
774 | }
775 | 
776 | class :sub extends :xhp:html-element {
777 |   category %flow, %phrase;
778 |   children (pcdata | %phrase)*;
779 |   protected $tagName = 'sub';
780 | }
781 | 
782 | class :summary extends :xhp:html-element {
783 |   children (pcdata | %phrase)*;
784 |   protected $tagName = 'summary';
785 | }
786 | 
787 | class :sup extends :xhp:html-element {
788 |   category %flow, %phrase;
789 |   children (pcdata | %phrase)*;
790 |   protected $tagName = 'sup';
791 | }
792 | 
793 | class :table extends :xhp:html-element {
794 |   attribute int border;
795 |   category %flow;
796 |   children (
797 |     :caption?, :colgroup*,
798 |     :thead?,
799 |     (
800 |       (:tfoot, (:tbody+ | :tr*)) |
801 |       ((:tbody+ | :tr*), :tfoot?)
802 |     )
803 |   );
804 |   protected $tagName = 'table';
805 | }
806 | 
807 | class :tbody extends :xhp:html-element {
808 |   children (:tr)*;
809 |   protected $tagName = 'tbody';
810 | }
811 | 
812 | 
813 | class :td extends :xhp:html-element {
814 |   attribute int colspan, string headers, int rowspan;
815 |   children (pcdata | %flow)*;
816 |   protected $tagName = 'td';
817 | }
818 | 
819 | class :textarea extends :xhp:pcdata-element {
820 |   attribute
821 |     enum {'on', 'off'} autocomplete, bool autofocus, int cols, string dirname,
822 |     bool disabled, string form, int maxlength, string name,
823 |     string placeholder, bool readonly, bool required, int rows,
824 |     enum {'soft', 'hard'} wrap;
825 |   category %flow, %phrase, %interactive;
826 |   protected $tagName = 'textarea';
827 | }
828 | 
829 | class :tfoot extends :xhp:html-element {
830 |   children (:tr)*;
831 |   protected $tagName = 'tfoot';
832 | }
833 | 
834 | class :th extends :xhp:html-element {
835 |   attribute
836 |     string abbr, int colspan, string headers, int rowspan,
837 |     enum {'col', 'colgroup', 'row', 'rowgroup'} scope;
838 |   children (pcdata | %flow)*;
839 |   protected $tagName = 'th';
840 | }
841 | 
842 | class :thead extends :xhp:html-element {
843 |   children (:tr)*;
844 |   protected $tagName = 'thead';
845 | }
846 | 
847 | class :time extends :xhp:html-element {
848 |   attribute string datetime;
849 |   category %flow, %phrase;
850 |   children (pcdata | %phrase)*;
851 |   protected $tagName = 'time';
852 | }
853 | 
854 | class :title extends :xhp:pcdata-element {
855 |   category %metadata;
856 |   protected $tagName = 'title';
857 | }
858 | 
859 | class :tr extends :xhp:html-element {
860 |   children (:th | :td)*;
861 |   protected $tagName = 'tr';
862 | }
863 | 
864 | class :track extends :xhp:html-singleton {
865 |   attribute
866 |     bool default,
867 |     enum {
868 |       'subtitles', 'captions', 'descriptions', 'chapters', 'metadata'
869 |     } kind, string label, string src, string srclang;
870 |   protected $tagName = 'track';
871 | }
872 | 
873 | class :tt extends :xhp:html-element {
874 |   category %flow, %phrase;
875 |   children (pcdata | %phrase)*;
876 |   protected $tagName = 'tt';
877 | }
878 | 
879 | class :u extends :xhp:html-element {
880 |   category %flow, %phrase;
881 |   children (pcdata | %phrase)*;
882 |   protected $tagName = 'u';
883 | }
884 | 
885 | class :ul extends :xhp:html-element {
886 |   category %flow;
887 |   children (:li)*;
888 |   protected $tagName = 'ul';
889 | }
890 | 
891 | class :var extends :xhp:html-element {
892 |   category %flow, %phrase;
893 |   children (pcdata | %phrase)*;
894 |   protected $tagName = 'var';
895 | }
896 | 
897 | class :video extends :xhp:html-element {
898 |   attribute
899 |     bool autoplay, bool controls,
900 |     enum {'anonymous', 'use-credentials'} crossorigin, int height, bool loop,
901 |     string mediagroup, bool muted, string poster,
902 |     enum {'none', 'metadata', 'auto'} preload, string src, int width;
903 |   category %flow, %phrase, %embedded, %interactive;
904 |   children (:source*, :track*, (pcdata | %flow)*);
905 |   protected $tagName = 'video';
906 | }
907 | 
908 | class :wbr extends :xhp:html-singleton {
909 |   category %flow, %phrase;
910 |   protected $tagName = 'wbr';
911 | }
912 | 
913 | /**
914 |  * Render an <html /> element with a DOCTYPE, XHP has chosen to only support
915 |  * the HTML5 doctype.
916 |  */
917 | class :x:doctype extends :x:primitive {
918 |   children (:html);
919 | 
920 |   protected function stringify() {
921 |     $children = $this->getChildren();
922 |     return '<!DOCTYPE html>' . (:x:base::renderChild($children[0]));
923 |   }
924 | }
925 | 


--------------------------------------------------------------------------------
/www/xhp/php-lib/core.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /*
  3 |   +----------------------------------------------------------------------+
  4 |   | XHP                                                                  |
  5 |   +----------------------------------------------------------------------+
  6 |   | Copyright (c) 2009 - 2013 Facebook, Inc. (http://www.facebook.com)   |
  7 |   +----------------------------------------------------------------------+
  8 |   | This source file is subject to version 3.01 of the PHP license,      |
  9 |   | that is bundled with this package in the file LICENSE.PHP, and is    |
 10 |   | available through the world-wide-web at the following url:           |
 11 |   | http://www.php.net/license/3_01.txt                                  |
 12 |   | If you did not receive a copy of the PHP license and are unable to   |
 13 |   | obtain it through the world-wide-web, please send a note to          |
 14 |   | license@php.net so we can mail you a copy immediately.               |
 15 |   +----------------------------------------------------------------------+
 16 | */
 17 | 
 18 | abstract class :x:base {
 19 |   abstract public function __construct($attributes, $children);
 20 |   abstract public function appendChild($child);
 21 |   abstract public function prependChild($child);
 22 |   abstract public function replaceChildren();
 23 |   abstract protected function getChildren($selector = null);
 24 |   abstract protected function getFirstChild($selector = null);
 25 |   abstract protected function getLastChild($selector = null);
 26 |   abstract public function getAttribute($attr);
 27 |   abstract public function getAttributes();
 28 |   abstract public function setAttribute($attr, $val);
 29 |   abstract public function setAttributes(array $attrs);
 30 |   abstract public function isAttributeSet($attr);
 31 |   abstract public function removeAttribute($attr);
 32 |   abstract public function categoryOf($cat);
 33 |   abstract public function __toString();
 34 |   abstract protected function &__xhpCategoryDeclaration();
 35 |   abstract protected function &__xhpChildrenDeclaration();
 36 |   protected static function &__xhpAttributeDeclaration() {}
 37 | 
 38 |   /**
 39 |    * Enabling validation will give you stricter documents; you won't be able to
 40 |    * do many things that violate the XHTML 1.0 Strict spec. It is recommend that
 41 |    * you leave this on because otherwise things like the `children` keyword will
 42 |    * do nothing. This validation comes at some CPU cost, however, so if you are
 43 |    * running a high-traffic site you will probably want to disable this in
 44 |    * production. You should still leave it on while developing new features,
 45 |    * though.
 46 |    */
 47 |   public static $ENABLE_VALIDATION = true;
 48 | 
 49 |   final protected static function renderChild($child) {
 50 |     if ($child instanceof :x:base) {
 51 |       return $child->__toString();
 52 |     } else if ($child instanceof HTML) {
 53 |       return $child->render();
 54 |     } else if (is_array($child)) {
 55 |       throw new XHPRenderArrayException('Can not render array!');
 56 |     } else {
 57 |       return htmlspecialchars((string)$child);
 58 |     }
 59 |   }
 60 | 
 61 |   public static function element2class($element) {
 62 |     return 'xhp_'.str_replace(array(':', '-'), array('__', '_'), $element);
 63 |   }
 64 | 
 65 |   public static function class2element($class) {
 66 |     return str_replace(array('__', '_'), array(':', '-'), preg_replace('#^xhp_#i', '', $class));
 67 |   }
 68 | }
 69 | 
 70 | abstract class :x:composable-element extends :x:base {
 71 |   private
 72 |     $attributes = array(),
 73 |     $children = array();
 74 | 
 75 |   private static $specialAttributes = array('data' => true, 'aria' => true);
 76 | 
 77 |   // Private constants indicating the declared types of attributes
 78 |   const TYPE_STRING   = 1;
 79 |   const TYPE_BOOL     = 2;
 80 |   const TYPE_NUMBER   = 3;
 81 |   const TYPE_ARRAY    = 4;
 82 |   const TYPE_OBJECT   = 5;
 83 |   const TYPE_VAR      = 6;
 84 |   const TYPE_ENUM     = 7;
 85 |   const TYPE_FLOAT    = 8;
 86 |   const TYPE_CALLABLE = 9;
 87 | 
 88 |   protected function init() {}
 89 | 
 90 |   /**
 91 |    * A new :x:composable-element is instantiated for every literal tag
 92 |    * expression in the script.
 93 |    *
 94 |    * The following code:
 95 |    * $foo = <foo attr="val">bar</foo>;
 96 |    *
 97 |    * will execute something like:
 98 |    * $foo = new xhp_foo(array('attr' => 'val'), array('bar'));
 99 |    *
100 |    * @param $attributes    map of attributes to values
101 |    * @param $children      list of children
102 |    */
103 |   final public function __construct($attributes, $children) {
104 |     foreach ($children as $child) {
105 |       $this->appendChild($child);
106 |     }
107 |     $this->setAttributes($attributes);
108 |     if (:x:base::$ENABLE_VALIDATION) {
109 |       // There is some cost to having defaulted unused arguments on a function
110 |       // so we leave these out and get them with func_get_args().
111 |       $args = func_get_args();
112 |       if (isset($args[2])) {
113 |         $this->source = "$args[2]:$args[3]";
114 |       } else {
115 |         $this->source =
116 |           'You have ENABLE_VALIDATION on, but debug information is not being ' .
117 |           'passed to XHP objects correctly. Ensure xhp.include_debug is on ' .
118 |           'in your PHP configuration. Without this option enabled, ' .
119 |           'validation errors will be painful to debug at best.';
120 |       }
121 |     }
122 |     $this->init();
123 |   }
124 | 
125 |   /**
126 |    * Adds a child to the end of this node. If you give an array to this method
127 |    * then it will behave like a DocumentFragment.
128 |    *
129 |    * @param $child     single child or array of children
130 |    */
131 |   final public function appendChild($child) {
132 |     if (is_array($child)) {
133 |       foreach ($child as $c) {
134 |         $this->appendChild($c);
135 |       }
136 |     } else if ($child instanceof :x:frag) {
137 |       $this->children = array_merge($this->children, $child->children);
138 |     } else if ($child !== null) {
139 |       $this->children[] = $child;
140 |     }
141 |     return $this;
142 |   }
143 | 
144 |   /**
145 |    * Adds a child to the beginning of this node. If you give an array to this
146 |    * method then it will behave like a DocumentFragment.
147 |    *
148 |    * @param $child     single child or array of children
149 |    */
150 |   final public function prependChild($child) {
151 |     if (is_array($child)) {
152 |       foreach (array_reverse($child) as $c) {
153 |         $this->prependChild($c);
154 |       }
155 |     } else if ($child instanceof :x:frag) {
156 |       $this->children = array_merge($child->children, $this->children);
157 |     } else if ($child !== null) {
158 |       array_unshift($this->children, $child);
159 |     }
160 |     return $this;
161 |   }
162 | 
163 |   /**
164 |    * Replaces all children in this node. You may pass a single array or
165 |    * multiple parameters.
166 |    *
167 |    * @param $children  Single child or array of children
168 |    */
169 |   final public function replaceChildren(/* ... */) {
170 |     // This function has been micro-optimized
171 |     $args = func_get_args();
172 |     $new_children = array();
173 |     foreach ($args as $xhp) {
174 |       if ($xhp) {
175 |         if ($xhp instanceof :x:frag) {
176 |           foreach ($xhp->children as $child) {
177 |             $new_children[] = $child;
178 |           }
179 |         } else if (!is_array($xhp)) {
180 |           $new_children[] = $xhp;
181 |         } else {
182 |           foreach ($xhp as $element) {
183 |             if ($element instanceof :x:frag) {
184 |               foreach ($element->children as $child) {
185 |                 $new_children[] = $child;
186 |               }
187 |             } else if ($element !== null) {
188 |               $new_children[] = $element;
189 |             }
190 |           }
191 |         }
192 |       }
193 |     }
194 |     $this->children = $new_children;
195 |     return $this;
196 |   }
197 | 
198 |   /**
199 |    * Fetches all direct children of this element that match a particular tag
200 |    * name or category (or all children if none is given)
201 |    *
202 |    * @param $selector   tag name or category (optional)
203 |    * @return array
204 |    */
205 |   final protected function getChildren($selector = null) {
206 |     if (!$selector) {
207 |       return $this->children;
208 |     }
209 |     $result = array();
210 |     if ($selector[0] == '%') {
211 |       $selector = substr($selector, 1);
212 |       foreach ($this->children as $child) {
213 |         if ($child instanceof :x:base && $child->categoryOf($selector)) {
214 |           $result[] = $child;
215 |         }
216 |       }
217 |     } else {
218 |       $selector = :x:base::element2class($selector);
219 |       foreach ($this->children as $child) {
220 |         if ($child instanceof $selector) {
221 |           $result[] = $child;
222 |         }
223 |       }
224 |     }
225 |     return $result;
226 |   }
227 | 
228 | 
229 |   /**
230 |    * Fetches the first direct child of the element, or the first child that
231 |    * matches the tag if one is given
232 |    *
233 |    * @param $selector   string   tag name or category (optional)
234 |    * @return            element  the first child node (with the given selector),
235 |    *                             false if there are no (matching) children
236 |    */
237 |   final protected function getFirstChild($selector = null) {
238 |     if (!$selector) {
239 |       return reset($this->children);
240 |     } else if ($selector[0] == '%') {
241 |       $selector = substr($selector, 1);
242 |       foreach ($this->children as $child) {
243 |         if ($child instanceof :x:base && $child->categoryOf($selector)) {
244 |           return $child;
245 |         }
246 |       }
247 |     } else {
248 |       $selector = :x:base::element2class($selector);
249 |       foreach ($this->children as $child) {
250 |         if ($child instanceof $selector) {
251 |           return $child;
252 |         }
253 |       }
254 |     }
255 |     return null;
256 |   }
257 | 
258 |   /**
259 |    * Fetches the last direct child of the element, or the last child that
260 |    * matches the tag or category if one is given
261 |    *
262 |    * @param $selector  string   tag name or category (optional)
263 |    * @return           element  the last child node (with the given selector),
264 |    *                            false if there are no (matching) children
265 |    */
266 |   final protected function getLastChild($selector = null) {
267 |     $temp = $this->getChildren($selector);
268 |     return end($temp);
269 |   }
270 | 
271 |   /**
272 |    * Returns true if the attribute is a data- or aria- attribute.
273 |    *
274 |    * @param $attr      attribute to fetch
275 |    * @return           bool
276 |    */
277 |   final private static function isAttributeSpecial($attr) {
278 |     // Must be at least 6 characters, with a '-' in the 5th position
279 |     return
280 |       isset($attr[5])
281 |       && $attr[4] == '-'
282 |       && isset(self::$specialAttributes[substr($attr, 0, 4)]);
283 |   }
284 | 
285 |   /**
286 |    * Fetches an attribute from this elements attribute store. If $attr is not
287 |    * defined in the store and is not a data- or aria- attribute an exception
288 |    * will be thrown. An exception will also be thrown if $attr is required and
289 |    * not set.
290 |    *
291 |    * @param $attr      attribute to fetch
292 |    * @return           value
293 |    */
294 |   final public function getAttribute($attr) {
295 |     // Return the attribute if it's there
296 |     if (isset($this->attributes[$attr])) {
297 |       return $this->attributes[$attr];
298 |     }
299 | 
300 |     if (!self::isAttributeSpecial($attr)) {
301 |       // Get the declaration
302 |       $decl = $this->__xhpAttributeDeclaration();
303 | 
304 |       if (!isset($decl[$attr])) {
305 |         throw new XHPAttributeNotSupportedException($this, $attr);
306 |       } else if (!empty($decl[$attr][3])) {
307 |         throw new XHPAttributeRequiredException($this, $attr);
308 |       } else {
309 |         return $decl[$attr][2];
310 |       }
311 |     } else {
312 |       return null;
313 |     }
314 |   }
315 | 
316 |   final public function getAttributes() {
317 |     return $this->attributes;
318 |   }
319 | 
320 |   /**
321 |    * Sets an attribute in this element's attribute store. If the attribute is
322 |    * not defined in the store and is not a data- or aria- attribute an
323 |    * exception will be thrown. An exception will also be thrown if the
324 |    * attribute value is invalid.
325 |    *
326 |    * @param $attr      attribute to set
327 |    * @param $val       value
328 |    */
329 |   final public function setAttribute($attr, $value) {
330 |     if (!self::isAttributeSpecial($attr)) {
331 |       $this->validateAttributeValue($attr, $value);
332 |     } else {
333 |       $value = (string)$value;
334 |     }
335 |     $this->attributes[$attr] = $value;
336 |     return $this;
337 |   }
338 | 
339 |   /**
340 |    * Takes an array of key/value pairs and adds each as an attribute.
341 |    *
342 |    * @param $attrs    array of attributes
343 |    */
344 |   final public function setAttributes(array $attrs) {
345 |     foreach ($attrs as $key => $value) {
346 |       $this->setAttribute($key, $value);
347 |     }
348 |     return $this;
349 |   }
350 | 
351 |   /**
352 |    * Whether the attribute has been explicitly set to a non-null value by the
353 |    * caller (vs. using the default set by "attribute" in the class definition).
354 |    *
355 |    * @param $attr attribute to check
356 |    */
357 |   final public function isAttributeSet($attr) {
358 |     return isset($this->attributes[$attr]);
359 |   }
360 | 
361 |   /**
362 |    * Removes an attribute from this element's attribute store. An exception
363 |    * will be thrown if $attr is not supported.
364 |    *
365 |    * @param $attr      attribute to remove
366 |    * @param $val       value
367 |    */
368 |   final public function removeAttribute($attr) {
369 |     if (!self::isAttributeSpecial($attr)) {
370 |       $this->validateAttributeValue($attr, $value = null);
371 |     }
372 |     unset($this->attributes[$attr]);
373 |     return $this;
374 |   }
375 | 
376 |   /**
377 |    * Sets an attribute in this element's attribute store. Always foregoes
378 |    * validation.
379 |    *
380 |    * @param $attr      attribute to set
381 |    * @param $val       value
382 |    */
383 |   final public function forceAttribute($attr, $value) {
384 |     $this->attributes[$attr] = $value;
385 |     return $this;
386 |   }
387 | 
388 |   final protected function __flushElementChildren() {
389 | 
390 |     // Flush all :x:base elements to x:primitive's
391 |     $ln = count($this->children);
392 |     for ($ii = 0; $ii < $ln; ++$ii) {
393 |       $child = $this->children[$ii];
394 |       if ($child instanceof :x:element) {
395 |         do {
396 |           if (:x:base::$ENABLE_VALIDATION) {
397 |             $child->validateChildren();
398 |           }
399 |           $child = $child->render();
400 |         } while ($child instanceof :x:element);
401 | 
402 |         if (!($child instanceof :x:primitive)) {
403 |           throw new XHPCoreRenderException($this->children[$ii], $child);
404 |         }
405 | 
406 |         if ($child instanceof :x:frag) {
407 |           array_splice($this->children, $ii, 1, $child->children);
408 |           $ln = count($this->children);
409 |           --$ii;
410 |         } else {
411 |           $this->children[$ii] = $child;
412 |         }
413 |       }
414 |     }
415 |   }
416 | 
417 |   /**
418 |    * Defined in elements by the `attribute` keyword. The declaration is simple.
419 |    * There is a keyed array, with each key being an attribute. Each value is
420 |    * an array with 4 elements. The first is the attribute type. The second is
421 |    * meta-data about the attribute. The third is a default value (null for
422 |    * none). And the fourth is whether or not this value is required.
423 |    *
424 |    * Attribute types are suggested by the TYPE_* constants.
425 |    */
426 |   protected static function &__xhpAttributeDeclaration() {
427 |     static $_ = array();
428 |     return $_;
429 |   }
430 | 
431 |   /**
432 |    * Defined in elements by the `category` keyword. This is just a list of all
433 |    * categories an element belongs to. Each category is a key with value 1.
434 |    */
435 |   protected function &__xhpCategoryDeclaration() {
436 |     static $_ = array();
437 |     return $_;
438 |   }
439 | 
440 |   /**
441 |    * Defined in elements by the `children` keyword. This returns a pattern of
442 |    * allowed children. The return value is potentially very complicated. The
443 |    * two simplest are 0 and 1 which mean no children and any children,
444 |    * respectively. Otherwise you're dealing with an array which is just the
445 |    * biggest mess you've ever seen.
446 |    */
447 |   protected function &__xhpChildrenDeclaration() {
448 |     static $_ = 1;
449 |     return $_;
450 |   }
451 | 
452 |   /**
453 |    * Throws an exception if $val is not a valid value for the attribute $attr
454 |    * on this element.
455 |    */
456 |   final protected function validateAttributeValue($attr, &$val) {
457 |     $decl = $this->__xhpAttributeDeclaration();
458 |     if (!isset($decl[$attr])) {
459 |       throw new XHPAttributeNotSupportedException($this, $attr);
460 |     }
461 |     if ($val === null) {
462 |       return;
463 |     }
464 |     switch ($decl[$attr][0]) {
465 |       case self::TYPE_STRING:
466 |         $val = (string)$val;
467 |         return;
468 | 
469 |       case self::TYPE_BOOL:
470 |         if (!is_bool($val)) {
471 |           if ($val === "false") {
472 |             $val = false;
473 |           } else {
474 |             $val = (bool)$val;
475 |           }
476 |         }
477 |         return;
478 | 
479 |       case self::TYPE_NUMBER:
480 |         if (!is_int($val)) {
481 |           $val = (int)$val;
482 |         }
483 |         return;
484 | 
485 |       case self::TYPE_FLOAT:
486 |         if (!is_numeric($val)) {
487 |           $val = (float)$val;
488 |         }
489 |         return;
490 | 
491 |       case self::TYPE_CALLABLE:
492 |         if (!is_callable($val)) {
493 |           throw new XHPInvalidAttributeException($this, 'callable', $attr, $val);
494 |         }
495 |         return;
496 | 
497 |       case self::TYPE_ARRAY:
498 |         if (!is_array($val)) {
499 |           throw new XHPInvalidAttributeException($this, 'array', $attr, $val);
500 |         }
501 |         if ($decl[$attr][1]) {
502 |           if ($decl[$attr][1][0]) {
503 |             if ($decl[$attr][1][0] == self::TYPE_STRING) {
504 |               $type = 'string';
505 |               $func = 'is_string';
506 |             } else {
507 |               $type = 'int';
508 |               $func = 'is_int';
509 |             }
510 |             if (count($val) != count(array_filter(array_keys($val), $func))) {
511 |               $bad = $type == 'string' ? 'int' : 'string';
512 |               throw new XHPInvalidArrayKeyAttributeException($this, $type, $attr, $bad);
513 |             }
514 |           }
515 |           switch ($decl[$attr][1][1]) {
516 |             case self::TYPE_STRING:
517 |               $type = 'string';
518 |               $func = 'is_string';
519 |               break;
520 |             case self::TYPE_BOOL:
521 |               $type = 'bool';
522 |               $func = 'is_bool';
523 |               break;
524 |             case self::TYPE_NUMBER:
525 |               $type = 'int';
526 |               $func = 'is_int';
527 |               break;
528 |             case self::TYPE_FLOAT:
529 |               $type = 'float';
530 |               $func = 'is_numeric';
531 |               break;
532 |             case self::TYPE_ARRAY:
533 |               $type = 'array';
534 |               $func = 'is_array';
535 |               break;
536 |             case self::TYPE_OBJECT:
537 |               $type = $decl[$attr][1][2];
538 |               $func = function($item) use ($type) {
539 |                 return $item instanceof $type;
540 |               };
541 |               break;
542 |           }
543 |           $filtered = array_filter($val, $func);
544 |           if (count($val) != count($filtered)) {
545 |             $bad = array_diff($val, $filtered);
546 |             throw new XHPInvalidArrayAttributeException($this, $type, $attr, reset($bad));
547 |           }
548 |         }
549 |         return;
550 | 
551 |       case self::TYPE_OBJECT:
552 |         if (!($val instanceof $decl[$attr][1])) {
553 |           throw new XHPInvalidAttributeException(
554 |             $this, $decl[$attr][1], $attr, $val
555 |           );
556 |         }
557 |         return;
558 | 
559 |       // case self::TYPE_VAR: `var` (any type)
560 | 
561 |       case self::TYPE_ENUM:
562 |         foreach ($decl[$attr][1] as $enum) {
563 |           if ($enum === $val) {
564 |             return;
565 |           }
566 |         }
567 |         $enums = 'enum("' . implode('","', $decl[$attr][1]) . '")';
568 |         throw new XHPInvalidAttributeException($this, $enums, $attr, $val);
569 |     }
570 |   }
571 | 
572 |   /**
573 |    * Validates that this element's children match its children descriptor, and
574 |    * throws an exception if that's not the case.
575 |    */
576 |   final protected function validateChildren() {
577 |     $decl = $this->__xhpChildrenDeclaration();
578 |     if ($decl === 1) { // Any children allowed
579 |       return;
580 |     }
581 |     if ($decl === 0) { // No children allowed
582 |       if ($this->children) {
583 |         throw new XHPInvalidChildrenException($this, 0);
584 |       } else {
585 |         return;
586 |       }
587 |     }
588 |     $ii = 0;
589 |     if (!$this->validateChildrenExpression($decl, $ii) ||
590 |         $ii < count($this->children)) {
591 |       // Use of HTML() breaks the content model definition.
592 |       // Lesson: Don't use HTML().
593 |       if (isset($this->children[$ii]) && $this->children[$ii] instanceof HTML) {
594 |         return;
595 |       }
596 |       throw new XHPInvalidChildrenException($this, $ii);
597 |     }
598 |   }
599 | 
600 |   final private function validateChildrenExpression($decl, &$index) {
601 |     switch ($decl[0]) {
602 |       case 0: // Exactly once -- :fb-thing
603 |         if ($this->validateChildrenRule($decl[1], $decl[2], $index)) {
604 |           return true;
605 |         }
606 |         return false;
607 | 
608 |       case 1: // Zero or more times -- :fb-thing*
609 |         while ($this->validateChildrenRule($decl[1], $decl[2], $index));
610 |         return true;
611 | 
612 |       case 2: // Zero or one times -- :fb-thing?
613 |         if ($this->validateChildrenRule($decl[1], $decl[2], $index));
614 |         return true;
615 | 
616 |       case 3: // One or more times -- :fb-thing+
617 |         if (!$this->validateChildrenRule($decl[1], $decl[2], $index)) {
618 |           return false;
619 |         }
620 |         while ($this->validateChildrenRule($decl[1], $decl[2], $index));
621 |         return true;
622 | 
623 |       case 4: // Specific order -- :fb-thing, :fb-other-thing
624 |         $oindex = $index;
625 |         if ($this->validateChildrenExpression($decl[1], $index) &&
626 |             $this->validateChildrenExpression($decl[2], $index)) {
627 |           return true;
628 |         }
629 |         $index = $oindex;
630 |         return false;
631 | 
632 |       case 5: // Either or -- :fb-thing | :fb-other-thing
633 |         if ($this->validateChildrenExpression($decl[1], $index) ||
634 |             $this->validateChildrenExpression($decl[2], $index)) {
635 |           return true;
636 |         }
637 |         return false;
638 |     }
639 |   }
640 | 
641 |   final private function validateChildrenRule($type, $rule, &$index) {
642 |     switch ($type) {
643 |       case 1: // any element -- any
644 |         if (isset($this->children[$index])) {
645 |           ++$index;
646 |           return true;
647 |         }
648 |         return false;
649 | 
650 |       case 2: // pcdata -- pcdata
651 |         if (isset($this->children[$index]) &&
652 |             !($this->children[$index] instanceof :x:base)) {
653 |           ++$index;
654 |           return true;
655 |         }
656 |         return false;
657 | 
658 |       case 3: // specific element -- :fb-thing
659 |         if (isset($this->children[$index]) &&
660 |             $this->children[$index] instanceof $rule) {
661 |           ++$index;
662 |           return true;
663 |         }
664 |         return false;
665 | 
666 |       case 4: // element category -- %block
667 |         if (!isset($this->children[$index]) ||
668 |             !($this->children[$index] instanceof :x:base)) {
669 |           return false;
670 |         }
671 |         $categories = $this->children[$index]->__xhpCategoryDeclaration();
672 |         if (empty($categories[$rule])) {
673 |           return false;
674 |         }
675 |         ++$index;
676 |         return true;
677 | 
678 |       case 5: // nested rule -- ((:fb-thing, :fb-other-thing)*, :fb:thing-footer)
679 |         return $this->validateChildrenExpression($rule, $index);
680 |     }
681 |   }
682 | 
683 |   /**
684 |    * Returns the human-readable `children` declaration as seen in this class's
685 |    * source code.
686 |    */
687 |   final public function __getChildrenDeclaration() {
688 |     $decl = $this->__xhpChildrenDeclaration();
689 |     if ($decl === 1) {
690 |       return 'any';
691 |     }
692 |     if ($decl === 0) {
693 |       return 'empty';
694 |     }
695 |     return $this->renderChildrenDeclaration($decl);
696 |   }
697 | 
698 |   final private function renderChildrenDeclaration($decl) {
699 |     switch ($decl[0]) {
700 |       case 0:
701 |         return $this->renderChildrenRule($decl[1], $decl[2]);
702 | 
703 |       case 1:
704 |         return $this->renderChildrenRule($decl[1], $decl[2]) . '*';
705 | 
706 |       case 2:
707 |         return $this->renderChildrenRule($decl[1], $decl[2]) . '?';
708 | 
709 |       case 3:
710 |         return $this->renderChildrenRule($decl[1], $decl[2]) . '+';
711 | 
712 |       case 4:
713 |         return $this->renderChildrenDeclaration($decl[1]) . ',' .
714 |           $this->renderChildrenDeclaration($decl[2]);
715 | 
716 |       case 5:
717 |         return $this->renderChildrenDeclaration($decl[1]) . '|' .
718 |           $this->renderChildrenDeclaration($decl[2]);
719 |     }
720 |   }
721 | 
722 |   final private function renderChildrenRule($type, $rule) {
723 |     switch ($type) {
724 |       case 1:
725 |         return 'any';
726 | 
727 |       case 2:
728 |         return 'pcdata';
729 | 
730 |       case 3:
731 |         return ':' . :x:base::class2element($rule);
732 | 
733 |       case 4:
734 |         return '%' . $rule;
735 | 
736 |       case 5:
737 |         return '(' . $this->renderChildrenDeclaration($rule) . ')';
738 |     }
739 |   }
740 | 
741 |   /**
742 |    * Returns a description of the current children in this element. Maybe
743 |    * something like this:
744 |    * <div><span>foo</span>bar</div> ->
745 |    * :span[%inline],pcdata
746 |    */
747 |   final public function __getChildrenDescription() {
748 |     $desc = array();
749 |     foreach ($this->children as $child) {
750 |       if ($child instanceof :x:base) {
751 |         $tmp = ':' . :x:base::class2element(get_class($child));
752 |         if ($categories = $child->__xhpCategoryDeclaration()) {
753 |           $tmp .= '[%'. implode(',%', array_keys($categories)) . ']';
754 |         }
755 |         $desc[] = $tmp;
756 |       } else {
757 |         $desc[] = 'pcdata';
758 |       }
759 |     }
760 |     return implode(',', $desc);
761 |   }
762 | 
763 |   final public function categoryOf($c) {
764 |     $categories = $this->__xhpCategoryDeclaration();
765 |     if (isset($categories[$c])) {
766 |       return true;
767 |     }
768 |     // XHP parses the category string
769 |     $c = str_replace(array(':', '-'), array('__', '_'), $c);
770 |     return isset($categories[$c]);
771 |   }
772 | }
773 | 
774 | /**
775 |  * :x:primitive lays down the foundation for very low-level elements. You
776 |  * should directly :x:primitive only if you are creating a core element that
777 |  * needs to directly implement stringify(). All other elements should subclass
778 |  * from :x:element.
779 |  */
780 | abstract class :x:primitive extends :x:composable-element {
781 |   abstract protected function stringify();
782 | 
783 |   /**
784 |    *  This isn't __toString() because throwing an exception out of __toString()
785 |    *  produces a useless, immediate fatal, and allowing XHP to seamlessly cast
786 |    *  into strings encourages bad practices, like this real snippet:
787 |    *
788 |    *    $links .= <a>...</a>;
789 |    *    $links .= <a>...</a>;
790 |    *    return HTML($links);
791 |    *
792 |    */
793 |   final public function __toString() {
794 | 
795 |     // Validate our children
796 |     $this->__flushElementChildren();
797 |     if (:x:base::$ENABLE_VALIDATION) {
798 |       try {
799 |         $this->validateChildren();
800 |       } catch (Exception $error) {
801 |         trigger_error($error->getMessage(), E_USER_ERROR);
802 |       }
803 |     }
804 | 
805 |     // Render to string
806 |     return $this->stringify();
807 |   }
808 | }
809 | 
810 | /**
811 |  * :x:element defines an interface that all user-land elements should subclass
812 |  * from. The main difference between :x:element and :x:primitive is that
813 |  * subclasses of :x:element should implement `render()` instead of `stringify`.
814 |  * This is important because most elements should not be dealing with strings
815 |  * of markup.
816 |  */
817 | abstract class :x:element extends :x:composable-element {
818 |   final public function __toString() {
819 |     $that = $this;
820 | 
821 |     if (:x:base::$ENABLE_VALIDATION) {
822 |       try {
823 |         // Validate the current object
824 |         $that->validateChildren();
825 | 
826 |         // And each intermediary object it returns
827 |         while (($that = $that->render()) instanceof :x:element) {
828 |           $that->validateChildren();
829 |         }
830 | 
831 |         // render() must always return XHPPrimitives
832 |         if (!($that instanceof :x:composable-element)) {
833 |           throw new XHPCoreRenderException($this, $that);
834 |         }
835 |       } catch (Exception $error) {
836 |         trigger_error($error->getMessage(), E_USER_ERROR);
837 |       }
838 |     } else {
839 |       // Skip the above checks when not validating
840 |       while (($that = $that->render()) instanceof :x:element);
841 |     }
842 | 
843 |     return $that->__toString();
844 |   }
845 | }
846 | 
847 | /**
848 |  * An <x:frag /> is a transparent wrapper around any number of elements. When
849 |  * you render it just the children will be rendered. When you append it to an
850 |  * element the <x:frag /> will disappear and each child will be sequentially
851 |  * appended to the element.
852 |  */
853 | class :x:frag extends :x:primitive {
854 |   protected function stringify() {
855 |     $buf = '';
856 |     foreach ($this->getChildren() as $child) {
857 |       $buf .= :x:base::renderChild($child);
858 |     }
859 |     return $buf;
860 |   }
861 | }
862 | 
863 | /**
864 |  * Exceptions are neat.
865 |  */
866 | class XHPException extends Exception {
867 |   protected static function getElementName($that) {
868 |     $name = get_class($that);
869 |     if (substr($name, 0, 4) !== 'xhp_') {
870 |       return $name;
871 |     } else {
872 |       return :x:base::class2element($name);
873 |     }
874 |   }
875 | }
876 | 
877 | class XHPClassException extends XHPException {
878 |   public function __construct($that, $msg) {
879 |     parent::__construct(
880 |       'Exception in class `' . XHPException::getElementName($that) . "`\n\n".
881 |       "$that->source\n\n".
882 |       $msg
883 |     );
884 |   }
885 | }
886 | 
887 | class XHPCoreRenderException extends XHPException {
888 |   public function __construct($that, $rend) {
889 |     parent::__construct(
890 |       ':x:element::render must reduce an object to an :x:primitive, but `'.
891 |       :x:base::class2element(get_class($that)).'` reduced into `'.gettype($rend)."`.\n\n".
892 |       $that->source
893 |     );
894 |   }
895 | }
896 | 
897 | class XHPRenderArrayException extends XHPException {
898 | }
899 | 
900 | class XHPInvalidArrayAttributeException extends XHPException {
901 |   public function __construct($that, $type, $attr, $val) {
902 |     if (is_object($val)) {
903 |       $val_type = get_class($val);
904 |     } else {
905 |       $val_type = gettype($val);
906 |     }
907 |     parent::__construct(
908 |       "Invalid attribute `$attr` of type array<`$val_type`> supplied to element `".
909 |       :x:base::class2element(get_class($that))."`, expected array<`$type`>.\n\n".
910 |       $that->source
911 |     );
912 |   }
913 | }
914 | 
915 | class XHPInvalidArrayKeyAttributeException extends XHPException {
916 |   public function __construct($that, $type, $attr, $val_type) {
917 |     parent::__construct(
918 |       "Invalid key in attribute `$attr` of type array<$val_type => ?> supplied to element `".
919 |       :x:base::class2element(get_class($that))."`, expected array<$type => ?>.\n\n".
920 |       $that->source
921 |     );
922 |   }
923 | }
924 | 
925 | class XHPAttributeNotSupportedException extends XHPException {
926 |   public function __construct($that, $attr) {
927 |     parent::__construct(
928 |       'Attribute "'.$attr.'" is not supported in class '.
929 |       '"'.XHPException::getElementName($that).'"'.
930 |       "\n\n".$that->source."\n\n".
931 |       'Please check for typos in your attribute. If you are creating a new '.
932 |       'attribute on this element define it with the "attribute" keyword'."\n\n"
933 |     );
934 |   }
935 | }
936 | 
937 | class XHPAttributeRequiredException extends XHPException {
938 |   public function __construct($that, $attr) {
939 |     parent::__construct(
940 |       'Required attribute `'.$attr.'` was not specified in element '.
941 |       '`'.XHPException::getElementName($that)."`.\n\n".
942 |       $that->source
943 |     );
944 |   }
945 | }
946 | 
947 | class XHPInvalidAttributeException extends XHPException {
948 |   public function __construct($that, $type, $attr, $val) {
949 |     if (is_object($val)) {
950 |       $val_type = get_class($val);
951 |     } else {
952 |       $val_type = gettype($val);
953 |     }
954 |     parent::__construct(
955 |       "Invalid attribute `$attr` of type `$val_type` supplied to element `".
956 |       :x:base::class2element(get_class($that))."`, expected `$type`.\n\n".
957 |       $that->source
958 |     );
959 |   }
960 | }
961 | 
962 | class XHPInvalidChildrenException extends XHPException {
963 |   public function __construct($that, $index) {
964 |     parent::__construct(
965 |       'Element `'.XHPException::getElementName($that).'` was rendered with '.
966 |       "invalid children.\n\n".
967 |       "$that->source\n\n".
968 |       "Verified $index children before failing.\n\n".
969 |       "Children expected:\n".$that->__getChildrenDeclaration()."\n\n".
970 |       "Children received:\n".$that->__getChildrenDescription()
971 |     );
972 |   }
973 | }
974 | 


--------------------------------------------------------------------------------
/www/xhp/xhp/scanner.l:
--------------------------------------------------------------------------------
   1 | /*
   2 |   +----------------------------------------------------------------------+
   3 |   | XHP                                                                  |
   4 |   +----------------------------------------------------------------------+
   5 |   | Copyright (c) 1998-2013 Zend Technologies Ltd. (http://www.zend.com) |
   6 |   | Copyright (c) 2009-2013 Facebook, Inc. (http://www.facebook.com)     |
   7 |   +----------------------------------------------------------------------+
   8 |   | This source file is subject to version 2.00 of the Zend license,     |
   9 |   | that is bundled with this package in the file LICENSE.ZEND, and is   |
  10 |   | available through the world-wide-web at the following url:           |
  11 |   | http://www.zend.com/license/2_00.txt.                                |
  12 |   | If you did not receive a copy of the Zend license and are unable to  |
  13 |   | obtain it through the world-wide-web, please send a note to          |
  14 |   | license@zend.com so we can mail you a copy immediately.              |
  15 |   +----------------------------------------------------------------------+
  16 | */
  17 | 
  18 | %{
  19 | #include "xhp.hpp"
  20 | #include <string.h>
  21 | 
  22 | // A PHP file is made of multiple languages, each with its own lexing rules.
  23 | // The starting mode or state is the HTML state, then comes the PHP state, 
  24 | // and with XHP there is even an XHP state. Certain tokens indicate a 
  25 | // transition from one state to another and the macros below are used to 
  26 | // manage this state.
  27 | #define push_state(s) xhp_new_push_state(s, yyg)
  28 | #define pop_state() xhp_new_pop_state(yyg)
  29 | #define set_state(s) xhp_set_state(s, yyg)
  30 | 
  31 | // This is used to help contextual lexing. For instance 'attribute' is
  32 | // considered a XHP keyword after a '{' of a class definition, 
  33 | // but a regular identifier in other contexts.
  34 | #define last_token() yyextra->last_token
  35 | 
  36 | #define YY_USER_ACTION \
  37 |   if (yyextra->terminated) \
  38 |     return 0; \
  39 |   if (!yyg->yy_more_len) \
  40 |     yyextra->first_lineno = yyextra->lineno;
  41 | 
  42 | #define tok(t) \
  43 |   if (yyextra->has_doc_block) { \
  44 |     *yylval = yyextra->doc_block + code_rope(yytext, yyextra->first_lineno, yyextra->lineno - yyextra->first_lineno); \
  45 |     yyextra->has_doc_block = false; \
  46 |   } else { \
  47 |     *yylval = code_rope(yytext, yyextra->first_lineno, yyextra->lineno - yyextra->first_lineno); \
  48 |   } \
  49 |   return yy_token(t, yyg)
  50 | 
  51 | #ifdef DEBUG
  52 |   static void yy_log_token(int tok);
  53 |   #define tokt(t) *yylval = t; push_state(XHP_AFTER_ENT); yy_log_token(T_XHP_TEXT); return yyextra->last_token = T_XHP_TEXT;
  54 | #else
  55 |   #define tokt(t) *yylval = t; push_state(XHP_AFTER_ENT); return yyextra->last_token = T_XHP_TEXT;
  56 | #endif
  57 | 
  58 | #define YY_USER_INIT \
  59 |   if (yyextra->insert_token) { \
  60 |     yyg->yy_init = 0; \
  61 |     int ft = yyextra->insert_token; \
  62 |     yyextra->insert_token = 0; \
  63 |     return yy_token(ft, yyg); \
  64 |   }
  65 | 
  66 | using namespace std;
  67 | 
  68 | const char* yytokname(int tok);
  69 | static int yy_token(int tok, struct yyguts_t* yyg);
  70 | static void yy_scan_newlines(const char* text, struct yyguts_t* yyg);
  71 | 
  72 | static bool utf8ize(uint32_t v, char* buf /* [5] */) {
  73 |   if (v <= 0x7f) { // 0xxxxxxx
  74 |     buf[0] = v;
  75 |     buf[1] = 0;
  76 |   } else if (v <= 0x7ff) { // 110yyyxx 10xxxxxx
  77 |     buf[0] = 0xc0 | (v >> 6);
  78 |     buf[1] = 0x80 | (v & 0x3f);
  79 |     buf[2] = 0;
  80 |   } else if (v <= 0xffff) { // 1110yyyy 10yyyyxx 10xxxxxx
  81 |     buf[0] = 0xe0 | (v >> 12);
  82 |     buf[1] = 0x80 | ((v >> 6) & 0x3f);
  83 |     buf[2] = 0x80 | (v & 0x3f);
  84 |     buf[3] = 0;
  85 |   } else if (v <= 0x1fffff) { // 11110zzz 10zzyyyy 10yyyyxx 10xxxxxx
  86 |     buf[0] = 0xf0 | (v >> 18);
  87 |     buf[1] = 0x80 | ((v >> 12) & 0x3f);
  88 |     buf[2] = 0x80 | ((v >> 6) & 0x3f);
  89 |     buf[3] = 0x80 | (v & 0x3f);
  90 |     buf[4] = 0;
  91 |   } else {
  92 |     return false;
  93 |   }
  94 |   return true;
  95 | }
  96 | 
  97 | %}
  98 | 
  99 | %option prefix="xhp"
 100 | %option reentrant
 101 |  /* PHP allows IF or if */
 102 | %option case-insensitive
 103 | %option noyywrap nodefault
 104 | %option stack
 105 | %option bison-bridge
 106 | %option 8bit
 107 | 
 108 |  /* I think an interactive scanner is required because of the bison state 
 109 |   * pushing we do. I'm putting an explicit interactive declaration here in case
 110 |   * someone tries adding -CF or whatever to the make flags. */
 111 | %option interactive
 112 | 
 113 |  /* The different lexing states. Note that the transitions are done either
 114 |   * in the lex actions, or in a generic manner in yy_token(). */
 115 | %s PHP
 116 | %s PHP_COMMENT
 117 | %s PHP_EOL_COMMENT
 118 | %s PHP_DOC_COMMENT
 119 | %s PHP_HEREDOC_START
 120 | %s PHP_HEREDOC_NSTART
 121 | %s PHP_HEREDOC_NEWLINE
 122 | %s PHP_HEREDOC_DATA
 123 | %s PHP_NO_RESERVED_WORDS
 124 | %s PHP_NO_RESERVED_WORDS_PERSIST
 125 | %s XHP_LABEL
 126 | %s XHP_LABEL_WHITESPACE
 127 | %s XHP_ATTRS
 128 | %s XHP_ATTR_VAL
 129 | %s XHP_AFTER_ENT
 130 | %s XHP_CHILD
 131 | %s XHP_CHILD_START
 132 | %s XHP_INVALID_ENTITY
 133 | %s XHP_ATTR_TYPE_DECL
 134 | %s XHP_CHILDREN_DECL
 135 | %s XHP_COMMENT
 136 | 
 137 | LNUM [0-9]+
 138 | DNUM ([0-9]*"."[0-9]+)|([0-9]+"."[0-9]*)
 139 | EXPONENT_DNUM (({LNUM}|{DNUM})[eE][+-]?{LNUM})
 140 | HNUM "0x"[0-9a-fA-F]+
 141 | 
 142 | LABEL [a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*
 143 | BYTE (.|\n)
 144 | 
 145 | WHITESPACE [ \n\r\t]+
 146 | TABS_AND_SPACES [ \t]*
 147 | NEWLINE ("\r\n"|"\n"|"\r")
 148 | 
 149 | %%
 150 | 
 151 | <XHP_ATTR_TYPE_DECL>{
 152 |   "bool"     tok(T_XHP_BOOLEAN);
 153 |   "int"      tok(T_XHP_NUMBER);
 154 |   "float"    tok(T_XHP_FLOAT);
 155 |   "callable" tok(T_XHP_CALLABLE);
 156 |   "var"      tok(T_VAR);
 157 |   "array"    tok(T_XHP_ARRAY);
 158 |   "string"   tok(T_XHP_STRING);
 159 |   "enum"     tok(T_XHP_ENUM);
 160 |   @required tok(T_XHP_REQUIRED);
 161 |   "(" tok('(');
 162 |   ":" tok(T_XHP_COLON);
 163 | }
 164 | 
 165 |  /* Open / close PHP + inline HTML */
 166 | <INITIAL>{
 167 |   "<?php"([ \t]|{NEWLINE}) {
 168 |     yy_scan_newlines(yytext + 5, yyg);
 169 |     // the state transition will be done in yy_token()
 170 |     tok(T_OPEN_TAG);
 171 |   }
 172 |   "<?" {
 173 |     if (yyextra->short_tags) {
 174 |       tok(T_OPEN_TAG);
 175 |     } else {
 176 |       tok(T_INLINE_HTML);
 177 |     }
 178 |   }
 179 |   "<?=" {
 180 |     if (yyextra->short_tags) {
 181 |       tok(T_OPEN_TAG_WITH_ECHO);
 182 |     } else {
 183 |       tok(T_INLINE_HTML);
 184 |     }
 185 |   }
 186 |   "<%" {
 187 |     if (yyextra->asp_tags) {
 188 |       tok(T_OPEN_TAG);
 189 |     } else {
 190 |       tok(T_INLINE_HTML);
 191 |     }
 192 |   }
 193 |   "<%=" {
 194 |     if (yyextra->asp_tags) {
 195 |       tok(T_OPEN_TAG_WITH_ECHO);
 196 |     } else {
 197 |       tok(T_INLINE_HTML);
 198 |     }
 199 |   }
 200 |   "<"|[^<]* {
 201 |     yy_scan_newlines(yytext, yyg);
 202 |     tok(T_INLINE_HTML);
 203 |   }
 204 | }
 205 | <PHP,PHP_NO_RESERVED_WORDS,PHP_NO_RESERVED_WORDS_PERSIST>{
 206 |   ("?>"|"</script"{WHITESPACE}*">"){NEWLINE}? {
 207 |     yy_scan_newlines(yytext + 2, yyg);
 208 |     tok(T_CLOSE_TAG);
 209 |   }
 210 |   "%>" {
 211 |     if (yyextra->asp_tags) {
 212 |       tok(T_CLOSE_TAG);
 213 |     } else {
 214 |       yyless(1);
 215 |       tok(yytext[0]);
 216 |     }
 217 |   }
 218 | }
 219 | 
 220 |  /* Comments and whitespace */
 221 | <PHP,PHP_NO_RESERVED_WORDS,PHP_NO_RESERVED_WORDS_PERSIST,XHP_CHILDREN_DECL,XHP_ATTR_TYPE_DECL>{
 222 |   "#"|"//" {
 223 |     push_state(PHP_EOL_COMMENT);
 224 |     yymore();
 225 |   }
 226 |   "/**"{WHITESPACE} {
 227 |     yy_scan_newlines(yytext + 3, yyg);
 228 |     push_state(PHP_DOC_COMMENT);
 229 |     yymore();
 230 |   }
 231 |   "/*" {
 232 |     push_state(PHP_COMMENT);
 233 |     yymore();
 234 |   }
 235 |   {WHITESPACE}+ yy_scan_newlines(yytext, yyg);
 236 | }
 237 | <PHP_EOL_COMMENT>{
 238 |   {NEWLINE} {
 239 |     ++yyextra->lineno;
 240 |     pop_state();
 241 |   }
 242 |   [^\r\n?]+ yymore();
 243 |   "?>" {
 244 |     yyless(yyleng - 2);
 245 |     pop_state();
 246 |   }
 247 |   . yymore();
 248 | }
 249 | <PHP_DOC_COMMENT,PHP_COMMENT>{
 250 |   {NEWLINE} {
 251 |     ++yyextra->lineno;
 252 |     yymore();
 253 |   }
 254 |   [^*\r\n]+|"*" yymore();
 255 | }
 256 | <PHP_DOC_COMMENT>"*/" {
 257 |   yyextra->doc_block = code_rope(yytext, yyextra->first_lineno, yyextra->lineno - yyextra->first_lineno);
 258 |   yyextra->has_doc_block = true;
 259 |   pop_state();
 260 | }
 261 | <PHP_COMMENT>"*/" pop_state();
 262 | 
 263 |  /* Reserved words */
 264 | <PHP>{
 265 |   include tok(T_INCLUDE);
 266 |   include_once tok(T_INCLUDE_ONCE);
 267 |   eval tok(T_EVAL);
 268 |   require tok(T_REQUIRE);
 269 |   require_once tok(T_REQUIRE_ONCE);
 270 |   or tok(T_LOGICAL_OR);
 271 |   xor tok(T_LOGICAL_XOR);
 272 |   and tok(T_LOGICAL_AND);
 273 |   print tok(T_PRINT);
 274 |   instanceof tok(T_INSTANCEOF);
 275 |   new tok(T_NEW);
 276 |   clone tok(T_CLONE);
 277 |   exit tok(T_EXIT);
 278 |   if tok(T_IF);
 279 |   elseif tok(T_ELSEIF);
 280 |   else tok(T_ELSE);
 281 |   endif tok(T_ENDIF);
 282 |   echo tok(T_ECHO);
 283 |   do tok(T_DO);
 284 |   while tok(T_WHILE);
 285 |   endwhile tok(T_ENDWHILE);
 286 |   for tok(T_FOR);
 287 |   endfor tok(T_ENDFOR);
 288 |   foreach tok(T_FOREACH);
 289 |   endforeach tok(T_ENDFOREACH);
 290 |   declare tok(T_DECLARE);
 291 |   enddeclare tok(T_ENDDECLARE);
 292 |   as tok(T_AS);
 293 |   switch tok(T_SWITCH);
 294 |   endswitch tok(T_ENDSWITCH);
 295 |   case tok(T_CASE);
 296 |   default tok(T_DEFAULT);
 297 |   break tok(T_BREAK);
 298 |   continue tok(T_CONTINUE);
 299 |   goto tok(T_GOTO);
 300 |   function tok(T_FUNCTION);
 301 |   const tok(T_CONST);
 302 |   return tok(T_RETURN);
 303 |   try tok(T_TRY);
 304 |   catch tok(T_CATCH);
 305 |   finally tok(T_FINALLY);
 306 |   throw tok(T_THROW);
 307 |   use tok(T_USE);
 308 |   global tok(T_GLOBAL);
 309 |   static tok(T_STATIC);
 310 |   abstract tok(T_ABSTRACT);
 311 |   final tok(T_FINAL);
 312 |   private tok(T_PRIVATE);
 313 |   protected tok(T_PROTECTED);
 314 |   public tok(T_PUBLIC);
 315 |   var tok(T_VAR);
 316 |   unset tok(T_UNSET);
 317 |   isset tok(T_ISSET);
 318 |   empty tok(T_EMPTY);
 319 |   __halt_compiler tok(T_HALT_COMPILER);
 320 |   class tok(T_CLASS);
 321 |   interface tok(T_INTERFACE);
 322 |   extends tok(T_EXTENDS);
 323 |   implements tok(T_IMPLEMENTS);
 324 |   list tok(T_LIST);
 325 |   array tok(T_ARRAY);
 326 |   __class__ tok(T_CLASS_C);
 327 |   __method__ tok(T_METHOD_C);
 328 |   __function__ tok(T_FUNC_C);
 329 |   __line__ tok(T_LINE);
 330 |   __file__ tok(T_FILE);
 331 |   __trait__ tok(T_TRAIT_C);
 332 |   namespace tok(T_NAMESPACE);
 333 |   trait tok(T_TRAIT);
 334 |   insteadof tok(T_INSTEADOF);
 335 |   yield tok(T_YIELD);
 336 |   __namespace__ tok(T_NS_C);
 337 |   __dir__ tok(T_DIR);
 338 |   attribute {
 339 |     // expecting_xhp_class_statements is set in some actions in the grammar.
 340 |     // This means the lexer and parser are interdependent.
 341 |     if ((last_token() == '{' || last_token() == '}' || last_token() == ';') &&
 342 |         (yyextra->expecting_xhp_class_statements)) {
 343 |       tok(T_XHP_ATTRIBUTE);
 344 |     } else {
 345 |       tok(T_STRING);
 346 |     }
 347 |   }
 348 |   category {
 349 |     if ((last_token() == '{' || last_token() == '}' || last_token() == ';') &&
 350 |         (yyextra->expecting_xhp_class_statements)) {
 351 |       tok(T_XHP_CATEGORY);
 352 |     } else {
 353 |       tok(T_STRING);
 354 |     }
 355 |   }
 356 |   children {
 357 |     if ((last_token() == '{' || last_token() == '}' || last_token() == ';') &&
 358 |         (yyextra->expecting_xhp_class_statements)) {
 359 |       tok(T_XHP_CHILDREN);
 360 |     } else {
 361 |       tok(T_STRING);
 362 |     }
 363 |   }
 364 | }
 365 | 
 366 |  /* Operators */
 367 | <PHP,PHP_NO_RESERVED_WORDS,PHP_NO_RESERVED_WORDS_PERSIST,XHP_ATTR_TYPE_DECL>{
 368 |   "+=" tok(T_PLUS_EQUAL);
 369 |   "-=" tok(T_MINUS_EQUAL);
 370 |   "*=" tok(T_MUL_EQUAL);
 371 |   "/=" tok(T_DIV_EQUAL);
 372 |   ".=" tok(T_CONCAT_EQUAL);
 373 |   "%=" tok(T_MOD_EQUAL);
 374 |   "&=" tok(T_AND_EQUAL);
 375 |   "|=" tok(T_OR_EQUAL);
 376 |   "^=" tok(T_XOR_EQUAL);
 377 |   "<<=" tok(T_SL_EQUAL);
 378 |   ">>=" tok(T_SR_EQUAL);
 379 |   "||" tok(T_BOOLEAN_OR);
 380 |   "&&" tok(T_BOOLEAN_AND);
 381 |   "==" tok(T_IS_EQUAL);
 382 |   "!="|"<>" tok(T_IS_NOT_EQUAL);
 383 |   "===" tok(T_IS_IDENTICAL);
 384 |   "!==" tok(T_IS_NOT_IDENTICAL);
 385 |   "<=" tok(T_IS_SMALLER_OR_EQUAL);
 386 |   ">=" tok(T_IS_GREATER_OR_EQUAL);
 387 |   "<<" tok(T_SL);
 388 |   ">>" tok(T_SR);
 389 |   "++" tok(T_INC);
 390 |   "--" tok(T_DEC);
 391 |   "->" tok(T_OBJECT_OPERATOR);
 392 |   "=>" tok(T_DOUBLE_ARROW);
 393 |   "::" tok(T_PAAMAYIM_NEKUDOTAYIM);
 394 |   "\\" tok(T_NS_SEPARATOR);
 395 |   ":" {
 396 |     // A colon can either mean the start (or component) of an XHP class,
 397 |     // a ternary expression (as in 1?false:null), the colon of a 'case', 
 398 |     // or finally the start of a block in the old PHP syntax. The following
 399 |     // disambiguate between the XHP case, which requires a special token,
 400 |     // and the other cases.
 401 |     switch (yyextra->last_token) {
 402 |       // In a ternary expression, the colon must follow a full-fledged
 403 |       // expression so seeing for instance a binary operator means
 404 |       // it must be an XHP class.
 405 |       case ',': case '=': case '|': case '^': case '&': case '<': case '>':
 406 |       case '+': case '-': case '%': case '!': case '~': case '[': case '(':
 407 |       case '{': case '.':
 408 |       case T_LOGICAL_OR: case T_LOGICAL_XOR: case T_LOGICAL_AND:
 409 |       case T_PLUS_EQUAL: case T_MINUS_EQUAL: case T_MUL_EQUAL:
 410 |       case T_DIV_EQUAL: case T_CONCAT_EQUAL: case T_MOD_EQUAL:
 411 |       case T_AND_EQUAL: case T_OR_EQUAL: case T_XOR_EQUAL:
 412 |       case T_SL_EQUAL: case T_SR_EQUAL: case T_BOOLEAN_OR:
 413 |       case T_BOOLEAN_AND: case T_IS_EQUAL: case T_IS_NOT_EQUAL:
 414 |       case T_IS_IDENTICAL: case T_IS_NOT_IDENTICAL: case T_IS_SMALLER_OR_EQUAL:
 415 |       case T_IS_GREATER_OR_EQUAL:
 416 |       // An XHP class can also occur after certain keywords. Not sure
 417 |       // we got them all covered though.
 418 |       case T_ECHO: case T_RETURN:
 419 |       case T_EXTENDS: case T_INSTANCEOF: case T_DOUBLE_ARROW:
 420 |       case T_XHP_ATTRIBUTE: case T_IMPLEMENTS:
 421 |         tok(T_XHP_COLON);
 422 |         break;
 423 |       default:
 424 |         tok(':');
 425 |         break;
 426 |     }
 427 |   }
 428 | }
 429 | 
 430 |  /* Casts */
 431 | <PHP,PHP_NO_RESERVED_WORDS,PHP_NO_RESERVED_WORDS_PERSIST>{
 432 |   "("{TABS_AND_SPACES}(int|integer){TABS_AND_SPACES}")" tok(T_INT_CAST);
 433 |   "("{TABS_AND_SPACES}(real|double|float){TABS_AND_SPACES}")" tok(T_DOUBLE_CAST);
 434 |   "("{TABS_AND_SPACES}string{TABS_AND_SPACES}")" tok(T_STRING_CAST);
 435 |   "("{TABS_AND_SPACES}unicode{TABS_AND_SPACES}")" tok(T_UNICODE_CAST);
 436 |   "("{TABS_AND_SPACES}binary{TABS_AND_SPACES}")" tok(T_BINARY_CAST);
 437 |   "("{TABS_AND_SPACES}array{TABS_AND_SPACES}")" tok(T_ARRAY_CAST);
 438 |   "("{TABS_AND_SPACES}object{TABS_AND_SPACES}")" tok(T_OBJECT_CAST);
 439 |   "("{TABS_AND_SPACES}(bool|boolean){TABS_AND_SPACES}")" tok(T_BOOL_CAST);
 440 |   "("{TABS_AND_SPACES}unset{TABS_AND_SPACES}")" tok(T_UNSET_CAST);
 441 | }
 442 | 
 443 |  /* Scalars (parsing these doesn't really matter since we just pass them through literally) */
 444 | <PHP,PHP_NO_RESERVED_WORDS,PHP_NO_RESERVED_WORDS_PERSIST,XHP_ATTR_TYPE_DECL>{
 445 |   {LNUM}|{HNUM} tok(T_LNUMBER);
 446 |   {DNUM}|{EXPONENT_DNUM} tok(T_DNUMBER);
 447 |   {LABEL} tok(T_STRING);
 448 |   "$"{LABEL} tok(T_VARIABLE);
 449 |   b?'(\\.|\\\n|[^\\']+)*'|b?\"(\\.|\\\n|[^\\\"]+)*\" {
 450 |     yy_scan_newlines(yytext, yyg);
 451 |     tok(T_CONSTANT_ENCAPSED_STRING);
 452 |   }
 453 |   `[^`]*` {
 454 |     yy_scan_newlines(yytext, yyg);
 455 |     tok(T_BACKTICKS_EXPR);
 456 |   }
 457 | }
 458 | 
 459 |  /* (HERE|NOW)DOC's */
 460 | <PHP,PHP_NO_RESERVED_WORDS,PHP_NO_RESERVED_WORDS_PERSIST>b?"<<<"{TABS_AND_SPACES} {
 461 |   push_state(PHP_HEREDOC_START);
 462 |   yyextra->heredoc_yyleng = yyleng;
 463 |   yymore();
 464 | }
 465 | <PHP_HEREDOC_START>{
 466 |   "'"{LABEL}"'"|\"{LABEL}\" {
 467 |     // Create a new string for the heredoc label. Since we're using yymore above
 468 |     // yytext will actually start at the "<<<" and not the label. Use of
 469 |     // heredoc_yyleng jumps past that. Then we add 1 to get past the " or '. The
 470 |     // match is similar to calculate length.
 471 |     yyextra->heredoc_label = string(yytext + yyextra->heredoc_yyleng + 1, yyleng - yyextra->heredoc_yyleng - 2);
 472 |     set_state(PHP_HEREDOC_NSTART);
 473 |     yyextra->heredoc_yyleng = yyleng;
 474 |     yymore();
 475 |   }
 476 |   {LABEL} {
 477 |     yyextra->heredoc_label = string(yytext + yyextra->heredoc_yyleng);
 478 |     set_state(PHP_HEREDOC_NSTART);
 479 |     yyextra->heredoc_yyleng = yyleng;
 480 |     yymore();
 481 |   }
 482 | }
 483 | <PHP_HEREDOC_NSTART>{NEWLINE} {
 484 |   ++yyextra->lineno;
 485 |   yyextra->heredoc_data = yytext + yyleng;
 486 |   set_state(PHP_HEREDOC_DATA);
 487 |   yymore();
 488 | }
 489 | <PHP_HEREDOC_DATA>{
 490 |   [^\r\n]*{NEWLINE} {
 491 |     ++yyextra->lineno;
 492 |     set_state(PHP_HEREDOC_NEWLINE);
 493 |     yyextra->heredoc_yyleng = yyleng;
 494 |     yymore();
 495 |   }
 496 | }
 497 | <PHP_HEREDOC_NEWLINE>{
 498 |   {LABEL};?{NEWLINE} {
 499 |     if (strncmp(yyextra->heredoc_label.c_str(), yytext + yyextra->heredoc_yyleng, yyextra->heredoc_label.size()) == 0) {
 500 |       switch (yytext[yyextra->heredoc_yyleng + yyextra->heredoc_label.size()]) {
 501 |         case ';': case '\n': case '\r':
 502 |           yyless(yyleng - (yyleng - yyextra->heredoc_yyleng - yyextra->heredoc_label.size()));
 503 |           pop_state();
 504 |           tok(T_HEREDOC);
 505 |       }
 506 |     }
 507 |     ++yyextra->lineno;
 508 |     yyextra->heredoc_yyleng = yyleng;
 509 |     yymore();
 510 |   }
 511 |   [^\r\n]+ {
 512 |     set_state(PHP_HEREDOC_DATA);
 513 |     yyextra->heredoc_yyleng = yyleng;
 514 |     yymore();
 515 |   }
 516 |   {NEWLINE} {
 517 |     ++yyextra->lineno;
 518 |     yyextra->heredoc_yyleng = yyleng;
 519 |     yymore();
 520 |   }
 521 | }
 522 | 
 523 |  /* XHP */
 524 | <XHP_LABEL_WHITESPACE>{
 525 |   {WHITESPACE}+ yy_scan_newlines(yytext, yyg);
 526 | }
 527 | <XHP_LABEL,XHP_LABEL_WHITESPACE>{
 528 |   ":" tok(T_XHP_COLON);
 529 |   "-" tok(T_XHP_HYPHEN);
 530 |   "::" {
 531 |     pop_state();
 532 | 
 533 |     // Hack: Please don't expect this to work: $foo = <a href={Thing::if} />;
 534 |     // PHP will let you use reserved words for member variables and methods, but
 535 |     // they are verboten in XHP classes now.
 536 |     //
 537 |     // We don't use tok() because that pushes PHP_NO_RESERVED_WORDS, which the
 538 |     // scanner expects to pop at some point, but XHP_LABEL (in parser.y) will pop
 539 |     // sooner and then you're left with an imbalanced tag stack and that's when
 540 |     // the fun stops.
 541 |   *yylval = code_rope(yytext, yyextra->first_lineno, yyextra->lineno - yyextra->first_lineno);
 542 | #ifdef DEBUG
 543 |   yy_log_token(T_PAAMAYIM_NEKUDOTAYIM);
 544 | #endif
 545 |     return T_PAAMAYIM_NEKUDOTAYIM;
 546 |   }
 547 |   "--" {
 548 |     pop_state();
 549 |     tok(T_DEC);
 550 |   }
 551 |   {WHITESPACE} {
 552 |     yy_scan_newlines(yytext, yyg);
 553 |     pop_state();
 554 |     tok(T_XHP_WHITESPACE);
 555 |   }
 556 |   {LABEL} tok(T_STRING);
 557 |   . {
 558 |     pop_state();
 559 |     tok(yytext[0]);
 560 |   }
 561 | }
 562 | 
 563 | <XHP_ATTRS>{
 564 |   "="|"/"|">" tok(yytext[0]);
 565 |   {WHITESPACE}+ yy_scan_newlines(yytext, yyg);
 566 |   {LABEL} tok(T_STRING);
 567 | }
 568 | 
 569 | <XHP_ATTR_VAL>{
 570 |   [^&'\\"]+ tok(T_XHP_TEXT);
 571 |   \" {
 572 |     pop_state();
 573 |     tok('"');
 574 |   }
 575 | }
 576 | 
 577 | <XHP_CHILD_START>{
 578 |   {WHITESPACE}+ {
 579 |     /* ignore whitespace at the start */
 580 |     yy_scan_newlines(yytext, yyg);
 581 |     unput(' ');
 582 |     set_state(XHP_CHILD);
 583 |   }
 584 |   . {
 585 |     yyless(0);
 586 |     set_state(XHP_CHILD);
 587 |   }
 588 | }
 589 | 
 590 |  /* Below we use tokt() (and not tok) which internally transits to
 591 |   * the XHP_AFTER_ENT state. */
 592 | <XHP_CHILD,XHP_AFTER_ENT,XHP_ATTR_VAL>{
 593 |   /* xml entities */
 594 |   (?-i:&quot;) tokt("\"");
 595 |   (?-i:&amp;) tokt("&");
 596 |   (?-i:&apos;) tokt("\\'");
 597 |   (?-i:&lt;) tokt("<")
 598 |   (?-i:&gt;) tokt(">");
 599 | 
 600 |   /* html entities */
 601 |   (?-i:&nbsp;) tokt("\u00A0");
 602 |   (?-i:&iexcl;) tokt("\u00A1");
 603 |   (?-i:&cent;) tokt("\u00A2");
 604 |   (?-i:&pound;) tokt("\u00A3");
 605 |   (?-i:&curren;) tokt("\u00A4");
 606 |   (?-i:&yen;) tokt("\u00A5");
 607 |   (?-i:&brvbar;) tokt("\u00A6");
 608 |   (?-i:&sect;) tokt("\u00A7");
 609 |   (?-i:&uml;) tokt("\u00A8");
 610 |   (?-i:&copy;) tokt("\u00A9");
 611 |   (?-i:&ordf;) tokt("\u00AA");
 612 |   (?-i:&laquo;) tokt("\u00AB");
 613 |   (?-i:&not;) tokt("\u00AC");
 614 |   (?-i:&shy;) tokt("\u00AD");
 615 |   (?-i:&reg;) tokt("\u00AE");
 616 |   (?-i:&macr;) tokt("\u00AF");
 617 |   (?-i:&deg;) tokt("\u00B0");
 618 |   (?-i:&plusmn;) tokt("\u00B1");
 619 |   (?-i:&sup2;) tokt("\u00B2");
 620 |   (?-i:&sup3;) tokt("\u00B3");
 621 |   (?-i:&acute;) tokt("\u00B4");
 622 |   (?-i:&micro;) tokt("\u00B5");
 623 |   (?-i:&para;) tokt("\u00B6");
 624 |   (?-i:&middot;) tokt("\u00B7");
 625 |   (?-i:&cedil;) tokt("\u00B8");
 626 |   (?-i:&sup1;) tokt("\u00B9");
 627 |   (?-i:&ordm;) tokt("\u00BA");
 628 |   (?-i:&raquo;) tokt("\u00BB");
 629 |   (?-i:&frac14;) tokt("\u00BC");
 630 |   (?-i:&frac12;) tokt("\u00BD");
 631 |   (?-i:&frac34;) tokt("\u00BE");
 632 |   (?-i:&iquest;) tokt("\u00BF");
 633 |   (?-i:&Agrave;) tokt("\u00C0");
 634 |   (?-i:&Aacute;) tokt("\u00C1");
 635 |   (?-i:&Acirc;) tokt("\u00C2");
 636 |   (?-i:&Atilde;) tokt("\u00C3");
 637 |   (?-i:&Auml;) tokt("\u00C4");
 638 |   (?-i:&Aring;) tokt("\u00C5");
 639 |   (?-i:&AElig;) tokt("\u00C6");
 640 |   (?-i:&Ccedil;) tokt("\u00C7");
 641 |   (?-i:&Egrave;) tokt("\u00C8");
 642 |   (?-i:&Eacute;) tokt("\u00C9");
 643 |   (?-i:&Ecirc;) tokt("\u00CA");
 644 |   (?-i:&Euml;) tokt("\u00CB");
 645 |   (?-i:&Igrave;) tokt("\u00CC");
 646 |   (?-i:&Iacute;) tokt("\u00CD");
 647 |   (?-i:&Icirc;) tokt("\u00CE");
 648 |   (?-i:&Iuml;) tokt("\u00CF");
 649 |   (?-i:&ETH;) tokt("\u00D0");
 650 |   (?-i:&Ntilde;) tokt("\u00D1");
 651 |   (?-i:&Ograve;) tokt("\u00D2");
 652 |   (?-i:&Oacute;) tokt("\u00D3");
 653 |   (?-i:&Ocirc;) tokt("\u00D4");
 654 |   (?-i:&Otilde;) tokt("\u00D5");
 655 |   (?-i:&Ouml;) tokt("\u00D6");
 656 |   (?-i:&times;) tokt("\u00D7");
 657 |   (?-i:&Oslash;) tokt("\u00D8");
 658 |   (?-i:&Ugrave;) tokt("\u00D9");
 659 |   (?-i:&Uacute;) tokt("\u00DA");
 660 |   (?-i:&Ucirc;) tokt("\u00DB");
 661 |   (?-i:&Uuml;) tokt("\u00DC");
 662 |   (?-i:&Yacute;) tokt("\u00DD");
 663 |   (?-i:&THORN;) tokt("\u00DE");
 664 |   (?-i:&szlig;) tokt("\u00DF");
 665 |   (?-i:&agrave;) tokt("\u00E0");
 666 |   (?-i:&aacute;) tokt("\u00E1");
 667 |   (?-i:&acirc;) tokt("\u00E2");
 668 |   (?-i:&atilde;) tokt("\u00E3");
 669 |   (?-i:&auml;) tokt("\u00E4");
 670 |   (?-i:&aring;) tokt("\u00E5");
 671 |   (?-i:&aelig;) tokt("\u00E6");
 672 |   (?-i:&ccedil;) tokt("\u00E7");
 673 |   (?-i:&egrave;) tokt("\u00E8");
 674 |   (?-i:&eacute;) tokt("\u00E9");
 675 |   (?-i:&ecirc;) tokt("\u00EA");
 676 |   (?-i:&euml;) tokt("\u00EB");
 677 |   (?-i:&igrave;) tokt("\u00EC");
 678 |   (?-i:&iacute;) tokt("\u00ED");
 679 |   (?-i:&icirc;) tokt("\u00EE");
 680 |   (?-i:&iuml;) tokt("\u00EF");
 681 |   (?-i:&eth;) tokt("\u00F0");
 682 |   (?-i:&ntilde;) tokt("\u00F1");
 683 |   (?-i:&ograve;) tokt("\u00F2");
 684 |   (?-i:&oacute;) tokt("\u00F3");
 685 |   (?-i:&ocirc;) tokt("\u00F4");
 686 |   (?-i:&otilde;) tokt("\u00F5");
 687 |   (?-i:&ouml;) tokt("\u00F6");
 688 |   (?-i:&divide;) tokt("\u00F7");
 689 |   (?-i:&oslash;) tokt("\u00F8");
 690 |   (?-i:&ugrave;) tokt("\u00F9");
 691 |   (?-i:&uacute;) tokt("\u00FA");
 692 |   (?-i:&ucirc;) tokt("\u00FB");
 693 |   (?-i:&uuml;) tokt("\u00FC");
 694 |   (?-i:&yacute;) tokt("\u00FD");
 695 |   (?-i:&thorn;) tokt("\u00FE");
 696 |   (?-i:&yuml;) tokt("\u00FF");
 697 |   (?-i:&OElig;) tokt("\u0152");
 698 |   (?-i:&oelig;) tokt("\u0153");
 699 |   (?-i:&Scaron;) tokt("\u0160");
 700 |   (?-i:&scaron;) tokt("\u0161");
 701 |   (?-i:&Yuml;) tokt("\u0178");
 702 |   (?-i:&fnof;) tokt("\u0192");
 703 |   (?-i:&circ;) tokt("\u02C6");
 704 |   (?-i:&tilde;) tokt("\u02DC");
 705 |   (?-i:&Alpha;) tokt("\u0391");
 706 |   (?-i:&Beta;) tokt("\u0392");
 707 |   (?-i:&Gamma;) tokt("\u0393");
 708 |   (?-i:&Delta;) tokt("\u0394");
 709 |   (?-i:&Epsilon;) tokt("\u0395");
 710 |   (?-i:&Zeta;) tokt("\u0396");
 711 |   (?-i:&Eta;) tokt("\u0397");
 712 |   (?-i:&Theta;) tokt("\u0398");
 713 |   (?-i:&Iota;) tokt("\u0399");
 714 |   (?-i:&Kappa;) tokt("\u039A");
 715 |   (?-i:&Lambda;) tokt("\u039B");
 716 |   (?-i:&Mu;) tokt("\u039C");
 717 |   (?-i:&Nu;) tokt("\u039D");
 718 |   (?-i:&Xi;) tokt("\u039E");
 719 |   (?-i:&Omicron;) tokt("\u039F");
 720 |   (?-i:&Pi;) tokt("\u03A0");
 721 |   (?-i:&Rho;) tokt("\u03A1");
 722 |   (?-i:&Sigma;) tokt("\u03A3");
 723 |   (?-i:&Tau;) tokt("\u03A4");
 724 |   (?-i:&Upsilon;) tokt("\u03A5");
 725 |   (?-i:&Phi;) tokt("\u03A6");
 726 |   (?-i:&Chi;) tokt("\u03A7");
 727 |   (?-i:&Psi;) tokt("\u03A8");
 728 |   (?-i:&Omega;) tokt("\u03A9");
 729 |   (?-i:&alpha;) tokt("\u03B1");
 730 |   (?-i:&beta;) tokt("\u03B2");
 731 |   (?-i:&gamma;) tokt("\u03B3");
 732 |   (?-i:&delta;) tokt("\u03B4");
 733 |   (?-i:&epsilon;) tokt("\u03B5");
 734 |   (?-i:&zeta;) tokt("\u03B6");
 735 |   (?-i:&eta;) tokt("\u03B7");
 736 |   (?-i:&theta;) tokt("\u03B8");
 737 |   (?-i:&iota;) tokt("\u03B9");
 738 |   (?-i:&kappa;) tokt("\u03BA");
 739 |   (?-i:&lambda;) tokt("\u03BB");
 740 |   (?-i:&mu;) tokt("\u03BC");
 741 |   (?-i:&nu;) tokt("\u03BD");
 742 |   (?-i:&xi;) tokt("\u03BE");
 743 |   (?-i:&omicron;) tokt("\u03BF");
 744 |   (?-i:&pi;) tokt("\u03C0");
 745 |   (?-i:&rho;) tokt("\u03C1");
 746 |   (?-i:&sigmaf;) tokt("\u03C2");
 747 |   (?-i:&sigma;) tokt("\u03C3");
 748 |   (?-i:&tau;) tokt("\u03C4");
 749 |   (?-i:&upsilon;) tokt("\u03C5");
 750 |   (?-i:&phi;) tokt("\u03C6");
 751 |   (?-i:&chi;) tokt("\u03C7");
 752 |   (?-i:&psi;) tokt("\u03C8");
 753 |   (?-i:&omega;) tokt("\u03C9");
 754 |   (?-i:&thetasym;) tokt("\u03D1");
 755 |   (?-i:&upsih;) tokt("\u03D2");
 756 |   (?-i:&piv;) tokt("\u03D6");
 757 |   (?-i:&ensp;) tokt("\u2002");
 758 |   (?-i:&emsp;) tokt("\u2003");
 759 |   (?-i:&thinsp;) tokt("\u2009");
 760 |   (?-i:&zwnj;) tokt("\u200C");
 761 |   (?-i:&zwj;) tokt("\u200D");
 762 |   (?-i:&lrm;) tokt("\u200E");
 763 |   (?-i:&rlm;) tokt("\u200F");
 764 |   (?-i:&ndash;) tokt("\u2013");
 765 |   (?-i:&mdash;) tokt("\u2014");
 766 |   (?-i:&lsquo;) tokt("\u2018");
 767 |   (?-i:&rsquo;) tokt("\u2019");
 768 |   (?-i:&sbquo;) tokt("\u201A");
 769 |   (?-i:&ldquo;) tokt("\u201C");
 770 |   (?-i:&rdquo;) tokt("\u201D");
 771 |   (?-i:&bdquo;) tokt("\u201E");
 772 |   (?-i:&dagger;) tokt("\u2020");
 773 |   (?-i:&Dagger;) tokt("\u2021");
 774 |   (?-i:&bull;) tokt("\u2022");
 775 |   (?-i:&hellip;) tokt("\u2026");
 776 |   (?-i:&permil;) tokt("\u2030");
 777 |   (?-i:&prime;) tokt("\u2032");
 778 |   (?-i:&Prime;) tokt("\u2033");
 779 |   (?-i:&lsaquo;) tokt("\u2039");
 780 |   (?-i:&rsaquo;) tokt("\u203A");
 781 |   (?-i:&oline;) tokt("\u203E");
 782 |   (?-i:&frasl;) tokt("\u2044");
 783 |   (?-i:&euro;) tokt("\u20AC");
 784 |   (?-i:&image;) tokt("\u2111");
 785 |   (?-i:&weierp;) tokt("\u2118");
 786 |   (?-i:&real;) tokt("\u211C");
 787 |   (?-i:&trade;) tokt("\u2122");
 788 |   (?-i:&alefsym;) tokt("\u2135");
 789 |   (?-i:&larr;) tokt("\u2190");
 790 |   (?-i:&uarr;) tokt("\u2191");
 791 |   (?-i:&rarr;) tokt("\u2192");
 792 |   (?-i:&darr;) tokt("\u2193");
 793 |   (?-i:&harr;) tokt("\u2194");
 794 |   (?-i:&crarr;) tokt("\u21B5");
 795 |   (?-i:&lArr;) tokt("\u21D0");
 796 |   (?-i:&uArr;) tokt("\u21D1");
 797 |   (?-i:&rArr;) tokt("\u21D2");
 798 |   (?-i:&dArr;) tokt("\u21D3");
 799 |   (?-i:&hArr;) tokt("\u21D4");
 800 |   (?-i:&forall;) tokt("\u2200");
 801 |   (?-i:&part;) tokt("\u2202");
 802 |   (?-i:&exist;) tokt("\u2203");
 803 |   (?-i:&empty;) tokt("\u2205");
 804 |   (?-i:&nabla;) tokt("\u2207");
 805 |   (?-i:&isin;) tokt("\u2208");
 806 |   (?-i:&notin;) tokt("\u2209");
 807 |   (?-i:&ni;) tokt("\u220B");
 808 |   (?-i:&prod;) tokt("\u220F");
 809 |   (?-i:&sum;) tokt("\u2211");
 810 |   (?-i:&minus;) tokt("\u2212");
 811 |   (?-i:&lowast;) tokt("\u2217");
 812 |   (?-i:&radic;) tokt("\u221A");
 813 |   (?-i:&prop;) tokt("\u221D");
 814 |   (?-i:&infin;) tokt("\u221E");
 815 |   (?-i:&ang;) tokt("\u2220");
 816 |   (?-i:&and;) tokt("\u2227");
 817 |   (?-i:&or;) tokt("\u2228");
 818 |   (?-i:&cap;) tokt("\u2229");
 819 |   (?-i:&cup;) tokt("\u222A");
 820 |   (?-i:&int;) tokt("\u222B");
 821 |   (?-i:&there4;) tokt("\u2234");
 822 |   (?-i:&sim;) tokt("\u223C");
 823 |   (?-i:&cong;) tokt("\u2245");
 824 |   (?-i:&asymp;) tokt("\u2248");
 825 |   (?-i:&ne;) tokt("\u2260");
 826 |   (?-i:&equiv;) tokt("\u2261");
 827 |   (?-i:&le;) tokt("\u2264");
 828 |   (?-i:&ge;) tokt("\u2265");
 829 |   (?-i:&sub;) tokt("\u2282");
 830 |   (?-i:&sup;) tokt("\u2283");
 831 |   (?-i:&nsub;) tokt("\u2284");
 832 |   (?-i:&sube;) tokt("\u2286");
 833 |   (?-i:&supe;) tokt("\u2287");
 834 |   (?-i:&oplus;) tokt("\u2295");
 835 |   (?-i:&otimes;) tokt("\u2297");
 836 |   (?-i:&perp;) tokt("\u22A5");
 837 |   (?-i:&sdot;) tokt("\u22C5");
 838 |   (?-i:&lceil;) tokt("\u2308");
 839 |   (?-i:&rceil;) tokt("\u2309");
 840 |   (?-i:&lfloor;) tokt("\u230A");
 841 |   (?-i:&rfloor;) tokt("\u230B");
 842 |   (?-i:&lang;) tokt("\u2329");
 843 |   (?-i:&rang;) tokt("\u232A");
 844 |   (?-i:&loz;) tokt("\u25CA");
 845 |   (?-i:&spades;) tokt("\u2660");
 846 |   (?-i:&clubs;) tokt("\u2663");
 847 |   (?-i:&hearts;) tokt("\u2665");
 848 |   (?-i:&diams;) tokt("\u2666");
 849 | 
 850 |   /* awesome entities */
 851 |   (?-i:&cloud;) tokt("\u2601");
 852 |   (?-i:&umbrella;) tokt("\u2602");
 853 |   (?-i:&snowman;) tokt("\u2603");
 854 |   (?-i:&snowflake;) tokt("\u2745");
 855 |   (?-i:&comet;) tokt("\u2604");
 856 |   (?-i:&thunderstorm;) tokt("\u2608");
 857 | 
 858 |   /* pseudo entities */
 859 |   ' tokt("\\'");
 860 |   "\\" tokt("\\\\");
 861 | 
 862 |   /* meta entities */
 863 |   (?-i:&#[0-9]+;) {
 864 |     char buf[5];
 865 |     utf8ize(atoi(yytext + 2), buf);
 866 |     tokt(buf);
 867 |   }
 868 |   (?-i:&#x)[A-F0-9]+; {
 869 |     char buf[5];
 870 |     char *_;
 871 |     utf8ize(strtol(yytext + 3, &_, 16), buf);
 872 |     tokt(buf);
 873 |   }
 874 | 
 875 |   /* not entities */
 876 |   & {
 877 |     yymore();
 878 |     BEGIN(XHP_INVALID_ENTITY);
 879 |   }
 880 | }
 881 | 
 882 | <XHP_INVALID_ENTITY>{
 883 |   {BYTE}{1,10} {
 884 |     for (char* ii = yytext; *ii; ++ii) {
 885 |       if (*ii == ';') {
 886 |         ii[1] = 0;
 887 |         break;
 888 |       }
 889 |     }
 890 |     if (!yyextra->terminated) {
 891 |       yyextra->error = string("Invalid entity: (") + yytext + ")";
 892 |       yyextra->terminated = true;
 893 |     }
 894 |   }
 895 | }
 896 | 
 897 | <XHP_AFTER_ENT>{
 898 |   [ \t\x0b\x0c\xa0\r\n]|\r\n {
 899 |     if (*yytext == '\r' || *yytext == '\n') {
 900 |       // Since we rewrite newlines into space we need to increment both line
 901 |       // counters. The first_lineno increment is quite a hack, and makes it so
 902 |       // that this ent is on the wrong line but it doesn't mess up the rest of
 903 |       // the file.
 904 |       ++yyextra->lineno;
 905 |       ++yyextra->first_lineno;
 906 |     }
 907 |     pop_state();
 908 |     yytext[0] = ' ';
 909 |     yytext[1] = 0;
 910 |     tok(T_XHP_TEXT);
 911 |   }
 912 |   . {
 913 |     pop_state();
 914 |     yyless(0);
 915 |   }
 916 | }
 917 | 
 918 | <XHP_CHILD>{
 919 |   [^&'<>\\{ \t\x0b\x0c\xa0\r\n]+{WHITESPACE}? {
 920 |     yy_scan_newlines(yytext, yyg);
 921 |     // Crunch white space at the end
 922 |     char* ii = yytext + yyleng - 1;
 923 |     while (*ii == ' ' || *ii == '\t' || *ii == '\n' || *ii == '\r') {
 924 |       --ii;
 925 |     }
 926 |    if (ii != yytext + yyleng - 1) {
 927 |       ii[1] = ' ';
 928 |       ii[2] = 0;
 929 |     }
 930 |     tok(T_XHP_TEXT);
 931 |   }
 932 |   {WHITESPACE}* {
 933 |     yy_scan_newlines(yytext, yyg);
 934 |     yytext[0] = ' ';
 935 |     yytext[1] = 0;
 936 |     tok(T_XHP_TEXT);
 937 |   }
 938 |   {WHITESPACE}*"{" {
 939 |     yy_scan_newlines(yytext, yyg);
 940 |     tok('{');
 941 |   }
 942 |   {WHITESPACE}*"<" {
 943 |     yy_scan_newlines(yytext, yyg);
 944 |     tok('<');
 945 |   }
 946 |   {WHITESPACE}*"</" {
 947 |     yy_scan_newlines(yytext, yyg);
 948 |     tok(T_XHP_LT_DIV);
 949 |   }
 950 |   {WHITESPACE}*"</>" {
 951 |     yy_scan_newlines(yytext, yyg);
 952 |     tok(T_XHP_LT_DIV_GT);
 953 |   }
 954 | }
 955 | 
 956 | <XHP_CHILD>[ \n\r\t]*"<!--" {
 957 |   push_state(XHP_COMMENT);
 958 |   yymore();
 959 | }
 960 | 
 961 | <XHP_COMMENT>[^-]+ {
 962 |   yymore();
 963 | }
 964 | 
 965 | <XHP_COMMENT>"-->"[ \n\r\t]* {
 966 |   pop_state();
 967 | }
 968 | 
 969 | <XHP_COMMENT>"-" {
 970 |   yymore();
 971 | }
 972 | 
 973 | <XHP_CHILDREN_DECL>{
 974 |   any tok(T_XHP_ANY);
 975 |   pcdata tok(T_XHP_PCDATA);
 976 |   empty tok(T_XHP_EMPTY);
 977 |   {LABEL} tok(T_STRING);
 978 |   ";" {
 979 |     pop_state();
 980 |     tok(';');
 981 |   }
 982 |   ":" {
 983 |     tok(T_XHP_COLON);
 984 |   }
 985 | }
 986 | 
 987 |  /* Other */
 988 | <*>{BYTE} {
 989 |   tok(yytext[0]);
 990 |   // fix unused function warnings
 991 |   yy_top_state(NULL);
 992 |   yyunput(0, 0, NULL);
 993 | }
 994 | 
 995 | %%
 996 | 
 997 | #ifdef DEBUG
 998 | static const char* yy_state_name(int state) {
 999 |   switch (state) {
1000 |     case INITIAL:
1001 |       return "INITIAL";
1002 |     case PHP:
1003 |       return "PHP";
1004 |     case PHP_COMMENT:
1005 |       return "PHP_COMMENT";
1006 |     case PHP_EOL_COMMENT:
1007 |       return "PHP_EOL_COMMENT";
1008 |     case PHP_DOC_COMMENT:
1009 |       return "PHP_DOC_COMMENT";
1010 |     case PHP_HEREDOC_START:
1011 |       return "PHP_HEREDOC_START";
1012 |     case PHP_HEREDOC_NSTART:
1013 |       return "PHP_HEREDOC_NSTART";
1014 |     case PHP_HEREDOC_NEWLINE:
1015 |       return "PHP_HEREDOC_NEWLINE";
1016 |     case PHP_HEREDOC_DATA:
1017 |       return "PHP_HEREDOC_DATA";
1018 |     case PHP_NO_RESERVED_WORDS:
1019 |       return "PHP_NO_RESERVED_WORDS";
1020 |     case PHP_NO_RESERVED_WORDS_PERSIST:
1021 |       return "PHP_NO_RESERVED_WORDS_PERSIST";
1022 |     case XHP_LABEL:
1023 |       return "XHP_LABEL";
1024 |     case XHP_LABEL_WHITESPACE:
1025 |       return "XHP_LABEL_WHITESPACE";
1026 |     case XHP_ATTRS:
1027 |       return "XHP_ATTRS";
1028 |     case XHP_ATTR_VAL:
1029 |       return "XHP_ATTR_VAL";
1030 |     case XHP_AFTER_ENT:
1031 |       return "XHP_AFTER_ENT";
1032 |     case XHP_CHILD:
1033 |       return "XHP_CHILD";
1034 |     case XHP_CHILD_START:
1035 |       return "XHP_CHILD_START";
1036 |     case XHP_INVALID_ENTITY:
1037 |       return "XHP_INVALID_ENTITY";
1038 |     case XHP_ATTR_TYPE_DECL:
1039 |       return "XHP_ATTR_TYPE_DECL";
1040 |     case XHP_CHILDREN_DECL:
1041 |       return "XHP_CHILDREN_DECL";
1042 |     case XHP_COMMENT:
1043 |       return "XHP_COMMENT";
1044 |     default:
1045 |       return "???";
1046 |   }
1047 | }
1048 | 
1049 | static void yy_log_token(int tok) {
1050 |   const char* tokname = yytokname(tok);
1051 |   if (tokname) {
1052 |     fprintf(stderr, "--> %s\n", tokname);
1053 |   } else {
1054 |     fprintf(stderr, "--> '%c'\n", tok);
1055 |   }
1056 | }
1057 | #endif
1058 | 
1059 | static int yy_token(int tok, yyguts_t* yyg) {
1060 |   if (YY_START == PHP_NO_RESERVED_WORDS) {
1061 |     pop_state();
1062 |   }
1063 | 
1064 |   switch (tok) {
1065 |     case T_OPEN_TAG:
1066 |     case T_OPEN_TAG_WITH_ECHO:
1067 |     case T_OPEN_TAG_FAKE:
1068 |       push_state(PHP);
1069 |       break;
1070 | 
1071 |     case T_CLOSE_TAG:
1072 |       pop_state();
1073 |       return ';';
1074 | 
1075 |     // In PHP it's ok to use keywords such as 'if' as field names
1076 |     // or function names.
1077 |     case T_OBJECT_OPERATOR:
1078 |     case T_PAAMAYIM_NEKUDOTAYIM:
1079 |     case T_FUNCTION:
1080 |       push_state(PHP_NO_RESERVED_WORDS);
1081 |       break;
1082 | 
1083 |     case '{':
1084 |       // not used anymore
1085 |       yyextra->curly_stack.push(tok);
1086 |       break;
1087 |   }
1088 | #ifdef DEBUG
1089 |   yy_log_token(tok);
1090 | #endif
1091 |   return yyextra->last_token = tok;
1092 | }
1093 | 
1094 | static inline void yy_scan_newlines(const char* text, struct yyguts_t* yyg) {
1095 |   for (; *text; ++text) {
1096 |     if (*text == '\r') {
1097 |       if (text[1] == '\n') {
1098 |         ++text;
1099 |       }
1100 |       ++yyextra->lineno;
1101 |     } else if (*text == '\n') {
1102 |       ++yyextra->lineno;
1103 |     }
1104 |   }
1105 | }
1106 | 
1107 | void xhp_new_push_state(int s, struct yyguts_t* yyg) {
1108 | #ifdef DEBUG
1109 |   fprintf(stderr, "--> PUSH(%s -> %s)\n", yy_state_name(YY_START), yy_state_name(s));
1110 | #endif
1111 |   yy_push_state(s, yyg);
1112 | }
1113 | 
1114 | void xhp_new_pop_state(struct yyguts_t* yyg) {
1115 | #ifdef DEBUG
1116 |   int s = YY_START;
1117 | #endif
1118 |   yy_pop_state(yyg);
1119 | #ifdef DEBUG
1120 |   fprintf(stderr, "--> POP(%s -> %s)\n", yy_state_name(s), yy_state_name(YY_START));
1121 | #endif
1122 | }
1123 | 
1124 | void xhp_set_state(int s, struct yyguts_t* yyg) {
1125 | #ifdef DEBUG
1126 |   fprintf(stderr, "--> SET(%s)\n", yy_state_name(s));
1127 | #endif
1128 |   BEGIN(s);
1129 | }


--------------------------------------------------------------------------------