parser/php.h

   1 #ifndef INC_PHP_H
   2 #define INC_PHP_H
   3
   4 #define PHP_METHOD(CLASS, METHOD)  void CLASS ## METHOD ()
   5 #define PHP_FUNCTION(METHOD)  void GLOBAL_ ## METHOD ()
   6 /*
   7  'class zend_function' has no member named 'common'
   8
   9 /*
  10 */
  11 class ZValField
  12 {
  13
  14 };
  15
  16 class  zvalR2 : public ZValField
  17 {
  18  public:
  19   operator bool ();
  20   template <class A> bool operator == (A &) ;
  21   template <class A> zvalR2& operator = (A &) ;
  22   zvalR2& operator = (int) ;
  23
  24 };
  25 class  zvalC2 : public ZValField
  26 {
  27 public:
  28   zvalC2 & operator ++ ();
  29   zvalC2 & operator ++ (int);
  30   zvalC2 & operator -- ();
  31   zvalC2 & operator -- (int);
  32   template <class A> zvalC2& operator = (A &) ;
  33 };
  34 class zvalV2HT
  35 {
  36
  37 };
  38 class  zvalV2 : public ZValField
  39 {
  40  public:
  41   zvalV2HT ht;
  42 };
  43 class  zvalT2 : public ZValField
  44 {
  45  public:
  46
  47   template <class T> bool operator != (T );
  48 };
  49 //  bool operator != (int );
  50
  51 template <class T> static T  MakeNullPtr();
  52 template <class T> static T  MakeNullPtrPtr();
  53
  54 // the
  55 class zval
  56 {
  57  public:
  58   zval();
  59   zval(const zval & r);
  60   ~zval();
  61   zvalR2 is_ref;
  62   zvalC2 refcount;
  63   zvalV2 value;
  64   zvalT2 type;
  65
  66   // make a null pointer
  67   //  static zval  MakeNull();
  68 };
  69
  70
  71
  72 class HashTable
  73 {
  74  public:
  75   int nNumOfElements;
  76 };
  77
  78 class vakz
  79 {
  80
  81 };
  82
  83
  84
  85
  86
  87 class NULLT
  88 {
  89  public:
  90   NULLT ()
  91     {
  92     }
  93
  94   NULLT (int)
  95     {
  96
  97     }
  98
  99   template <class Y> NULLT(Y & rY){
 100     // create a null object out of some value? well it sould always be null
 101
 102   }
 103
 104   template <class Y> operator Y**() const
 105     {
 106       //      return MakeNullPtrPtr<Y>();
 107     }
 108
 109    template <class Y> operator Y*() const
 110      {
 111   //   return MakeNullPtr<Y*>();
 112      }
 113
 114   /*  template <class Y> operator Y () const
 115     {
 116       return Y::MakeNull();
 117     }
 118   */
 119
 120   operator int () const
 121   {
 122     return 0;
 123   }
 124 };
 125
 126 // derived everything from a zval...
 127
 128 #define MYSTD(X) class X : public zval {                        \
 129 public: \
 130  X ();  \
 131  X (const NULLT); \
 132  X (int);  \
 133    template <class Y> X(Y & rY); \
 134    template <class Y> X(Y ** pY); \
 135    template <class Y> X(const Y ** pY); \
 136    template <class Y> X(const Y * rY); \
 137    template <class A,class B> X(A, B);  \
 138    template <class A,class B,class C> X(A, B, C);       \
 139    template <class A,class B,class C,class D> X(A, B, C, D);    \
 140    template <class A,class B,class C,class D,class E> X(A, B, C, D, E); \
 141    template <class A,class B,class C,class D,class E,class F> X(A, B, C, D, E, F);      \
 142    template <class A,class B,class C,class D,class E,class F,class G> X(A,B, C, D, E, F,G); \
 143    template <class A,class B,class C,class D,class E,class F,class G> X(A*,B*, C, D, E**, F,G); \
 144    template <class A> operator A () const;                              \
 145    template <class A> operator A () ;                                           \
 146    operator int () ;                                            \
 147    X operator ++ () ;                                           \
 148    X operator ++ (int) ;                                                \
 149    X & operator -- ();    \
 150    X & operator -- (int);  \
 151    template <class A> A * operator -> () ;                                              \
 152    bool operator > (int) ;                                              \
 153    bool operator ! () ;                                         \
 154    };
 155
 156 /*bool operator == (zend_hash_has_more_elements, int )
 157 {
 158
 159 }*/
 160
 161 //   template <class A> bool operator == (const A &) const ;
 162    //   template <class A> bool operator == (A &) ;
 163
 164
 165 // template <class Y,class Z> X(Y &, Z&);       \
 166
 167 extern int x;
 168
 169 MYSTD(STDRET)
 170
 171 class STDRET2
 172 {
 173  public:
 174   operator int();
 175 };
 176
 177 //   template <class Y> STDRET X(const Y * rY);
 178 // template <class P> STDRET X (P);
 179
 180 #define MYSTDF(X)   \
 181   STDRET X ();                          \
 182 template <class P> STDRET X (P*);       \
 183 template <class Y> STDRET X(Y & rY);            \
 184 template <class A,class B> STDRET X(A, B);                      \
 185 template <class A,class B,class C> STDRET X(A, B, C);                   \
 186    template <class A,class B,class C,class D> STDRET X(A, B, C, D);     \
 187    template <class A,class B,class C,class D,class E> STDRET X(A, B, C, D, E);  \
 188    template <class A,class B,class C,class D,class E,class F> STDRET X(A, B, C, D, E, F);       \
 189
 190 #define MYSTDFP(X)   \
 191 template <class P> STDRET* X (P*);      \
 192 template <class Y> STDRET* X(Y & rY);           \
 193 template <class A,class B> STDRET* X(A, B);                     \
 194 template <class A,class B,class C> STDRET *X(A, B, C);                  \
 195    template <class A,class B,class C,class D> STDRET* X(A, B, C, D);    \
 196    template <class A,class B,class C,class D,class E> STDRET * X(A, B, C, D, E);        \
 197    template <class A,class B,class C,class D,class E,class F> STDRET * X(A, B, C, D, E, F);     \
 198
 199
 200
 201 extern NULLT stderr;
 202
 203 //template <class R, class P> void X (P&);
 204
 205
 206 MYSTDF(phc_builtin_empty)
 207 MYSTDF(get_constant)
 208 MYSTDF(phc_setup_error)
 209 MYSTDF(initialize_constructor_call)
 210 MYSTDF(fprintf)
 211 MYSTDF(phc_builtin_print)
 212 MYSTDF(zval_ptr_dtor)
 213 MYSTDF(array_init)
 214 MYSTDF(ALLOC_INIT_ZVAL)
 215 MYSTDF(Z_LVAL_P)
 216 //template <class R, class P> R Z_LVAL_P (P&);
 217 //template <class R, class P> R Z_LVAL_P (P*);
 218 //template <class R, class P> R Z_LVAL_P (P);
 219
 220
 221 MYSTD(NULLT2)
 222
 223 extern NULLT2 uninitialized_zval_ptr;
 224
 225 MYSTD(CG)
 226
 227 MYSTD(E_ERROR)
 228 MYSTD(E_WARNING)
 229
 230
 231
 232
 233 //MYSTD(TSRMLS_CC)
 234 MYSTD(ZEND_REQUIRE)
 235 MYSTD(ZEND_INCLUDE)
 236 MYSTDF(STR_PRINT)
 237
 238
 239
 240 MYSTD(Z_BVAL_P)
 241 MYSTD(Z_DVAL_P)
 242
 243
 244 MYSTD(assert)
 245 MYSTD(compiled_filename)
 246 MYSTD(erealloc)
 247 MYSTD(fci)
 248 MYSTD(fcic)
 249
 250
 251 MYSTD(function_state_ptr)
 252 MYSTD(in_compilation)
 253 MYSTD(in_execution)
 254
 255 MYSTDF(initialize_function_call)
 256 MYSTDF(is_ref)
 257 MYSTD(memset)
 258 MYSTD(old_function)
 259 MYSTDF(php_error_docref)
 260 MYSTD(printf)
 261 MYSTD(stderr)
 262 MYSTDF(strlen)
 263 MYSTD(type)
 264 MYSTD(ulong)
 265 MYSTD(uninitialized_zval_ptr)
 266 MYSTD(value)
 267 MYSTD(zend_fcall_infoB)
 268 MYSTD(arg_info)
 269
 270
 271 MYSTDF(ZEND_NUM_ARGS);
 272
 273 //MYSTDF(HASH_KEY_NON_EXISTANT)
 274 MYSTD(HashPosition)
 275 MYSTDF(zend_hash_internal_pointer_reset_ex)
 276
 277 MYSTDF(initialize_method_call)
 278 MYSTDF(ZEND_NUM_ARGS)
 279 MYSTDF(ZVAL_NULL)
 280 MYSTDF(add_function)
 281 MYSTDF(bitwise_and_function)
 282 MYSTDF(bitwise_not_function)
 283 MYSTDF(boolean_not_function)
 284 MYSTDF(concat_function)
 285 MYSTDF(convert_to_boolean)
 286 MYSTDF(div_function)
 287 MYSTD(ht_iterator35472)
 288 MYSTD(ht_iterator35589)
 289 MYSTDF(increment_function)
 290 MYSTDF(is_equal_function)
 291 MYSTDF(is_identical_function)
 292 MYSTDF(is_not_equal_function)
 293 MYSTDF(is_not_identical_function)
 294 MYSTDF(is_smaller_function)
 295 MYSTDF(is_smaller_or_equal_function)
 296 MYSTDF(mod_function)
 297 MYSTDF(mul_function)
 298 MYSTDF(object_init_ex)
 299 MYSTDF(safe_free_zval_ptr)
 300 MYSTDF(shift_left_function)
 301 MYSTDF(str_length)
 302 MYSTDF(sub_function)
 303 MYSTD(uint)
 304
 305 //MYSTDF(zend_call_function)
 306 //TSTDRET zend_call_function ();
 307 //template <class P> STDRET zend_call_function (P*);
 308 //template <class Y> STDRET zend_call_function(Y & rY);
 309 template <class T> class STDRETT
 310 {
 311  public:
 312   operator T();
 313 };
 314
 315 template <class A,class B> STDRETT<int> zend_call_function(A*, B*);
 316 //template <class A,class B,class C> STDRET zend_call_function(A, B, C);
 317 //template <class A,class B,class C,class D> STDRET zend_call_function(A, B, C, D);
 318 //template <class A,class B,class C,class D,class E> STDRET zend_call_function(A, B, C, D, E);
 319 //template <class A,class B,class C,class D,class E,class F> STDRET zend_call_function(A, B, C, D, E, F);
 320
 321 MYSTDF(zend_fetch_class)
 322 MYSTDF(zend_get_parameters_array)
 323 MYSTDF(zend_hash_get_current_data_ex)
 324 MYSTDF(zend_hash_get_current_key_type_ex)
 325 MYSTDF(zend_hash_internal_pointer_end_ex)
 326 MYSTDF(zend_hash_internal_pointer_reset_ex)
 327 MYSTDF(zend_hash_move_forward_ex)
 328 MYSTDF(zend_is_true)
 329
 330
 331 MYSTD(zend_functionB)
 332 MYSTD(zend_functionPC)
 333 MYSTD(zend_functionPS)
 334 MYSTD(zend_functionR)
 335 MYSTD(zend_functionC2)
 336
 337
 338 MYSTD(zend_functionCArg)
 339 MYSTD(zend_functionCPass)
 340 MYSTD(zend_functionCReturn)
 341 MYSTD(zend_function_name)
 342
 343 class zend_functionC : public zend_functionC2
 344 {
 345  public:
 346   zend_function_name  function_name;
 347   zend_functionCArg    arg_info;
 348   zend_functionCPass   pass_rest_by_reference;
 349   zend_functionCReturn return_reference;
 350 };
 351
 352 MYSTD(zend_arg_infoB)
 353 MYSTD(zend_arg_infoR)
 354 class zend_arg_info
 355 {
 356  public:
 357   zend_arg_infoR pass_by_reference;
 358 };
 359
 360 class zend_fcall_info :public zend_fcall_infoB
 361 {
 362 public:
 363   //  'class zend_fcall_info' has no member named 'param_count'
 364   // 'class zend_fcall_info' has no member named 'params'
 365   // 'class zend_fcall_info' has no member named 'retval_ptr_ptr'
 366   zend_functionPC param_count;
 367   zend_functionPS params;
 368   zend_functionR  retval_ptr_ptr;
 369 };
 370
 371 template <class F> class zend_functionPCT  : public zend_functionPC
 372 {
 373  public:
 374   zend_functionPCT<F> & operator=(int) const
 375   {
 376   // this has got to be one...
 377   };
 378
 379 };
 380
 381
 382 MYSTD(zend_hash_del)
 383 MYSTD(zend_hash_exists)
 384 MYSTD(zend_hash_find)
 385 MYSTDF(zend_hash_get_current_data)
 386 MYSTDF(zend_hash_get_current_key_ex)
 387 MYSTDF(zend_hash_has_more_elements)
 388 MYSTDF(zend_hash_index_del)
 389 MYSTDF(zend_hash_index_exists)
 390 MYSTDF(zend_hash_index_find)
 391 MYSTDF(zend_hash_index_update)
 392 MYSTDF(zend_hash_internal_pointer_reset)
 393 MYSTDF(zend_hash_move_forward)
 394 MYSTDF(zend_hash_next_index_insert)
 395 MYSTDF(zend_hash_quick_add)
 396 MYSTDF(zend_hash_quick_find)
 397 MYSTDF(zend_hash_update)
 398 MYSTD(zend_lineno)
 399 MYSTD(zend_bool)
 400
 401 MYSTDF(zend_symtable_find)
 402 MYSTDF(zend_symtable_update)
 403
 404 #define TSRMLS_DC
 405 #define TSRMLS_CC
 406
 407 MYSTDF(zval_dtor)
 408
 409
 410 /// FUNCIONT
 411 MYSTDF(MAKE_STD_ZVAL)
 412 MYSTDF(zval_copy_ctor)
 413
 414 MYSTDF(convert_to_array)
 415 MYSTDF(convert_to_long)
 416 MYSTDF(convert_to_string)
 417
 418
 419 MYSTD(Z_ARRVAL_P_T)
 420
 421 //typedef Z_ARRVAL_P_T* Z_ARRVAL_P;
 422 typedef HashTable * Z_ARRVAL_P;
 423
 424
 425 #define MYSTDV(X) const NULLT X;
 426
 427 MYSTDF(ALLOC_HASHTABLE)
 428 MYSTDV(BP_VAR_R)
 429 MYSTDV(E_ERROR)
 430 MYSTDV(E_WARNING)
 431        MYSTDV(E_ALL)
 432        MYSTDV(E_NOTICE)
 433 MYSTDF(FREE_HASHTABLE)
 434 MYSTDF(INIT_ZVAL)
 435 MYSTDF(TODO)
 436 MYSTDV(ZEND_ACC_PRIVATE)
 437 MYSTDV(ZEND_ACC_PROTECTED)
 438 MYSTDV(ZEND_ACC_STATIC)
 439
 440
 441
 442
 443 MYSTDV(ZEND_ACC_PUBLIC)
 444 MYSTDV(ZEND_USER_FUNCTION)
 445 MYSTDV(ZEND_FETCH_CLASS_DEFAULT)
 446 MYSTDV(HASH_KEY_NON_EXISTANT)
 447 MYSTDV(NULL)
 448 MYSTDV(SUCCESS)
 449 MYSTDV(HASH_KEY_IS_STRING)
 450
 451
 452 MYSTDF(assign_expr_instanceOfMyVariable)
 453 MYSTDF(bitwise_or_function)
 454 MYSTDF(boolean_xor_function)
 455 MYSTDF(convert_to_double)
 456 MYSTDF(convert_to_object)
 457 MYSTDF(decrement_function)
 458 MYSTDF(phc_check_invariants)
 459 MYSTDF(return_value_ptr)
 460 MYSTDF(shift_right_function)
 461 MYSTDF(zend_hash_destroy)
 462 MYSTDF(zend_hash_init)
 463 MYSTDF(zend_read_static_property)
 464 MYSTDF(zend_std_get_static_property)
 465 MYSTDF(zend_update_static_property)
 466 MYSTDF(get_st_entry);
 467
 468 /*
 469 MYSTDV(IS_ARRAY)
 470 MYSTDV(IS_BOOL)
 471 MYSTDV(IS_DOUBLE)
 472 MYSTDV(IS_LONG)
 473 MYSTDV(IS_OBJECT)
 474 MYSTDV(IS_RESOURCE)
 475 MYSTDV(IS_STRING)
 476 */
 477
 478 class T
 479 {
 480  public:
 481   T(int);
 482   T();
 483   operator int () const ;
 484 };
 485
 486
 487 const int IS_NULL=0;
 488 const int IS_LONG=1;
 489 const int IS_BOOL=2;
 490 const int IS_DOUBLE=3;
 491 const int IS_ARRAY=4;
 492 const int IS_OBJECT=5;
 493 const int IS_STRING=6;
 494 const int IS_RESOURCE=7;
 495
 496 //MYSTD(zend_fcall_info_cache_T)
 497
 498 //zend_fcall_info_cache_T [] zend_fcall_info_cache;
 499 //
 500
 501 //class zvalVHT{};
 502 class zvalV{
 503  public :
 504   HashTable* ht;
 505 };
 506
 507 class return_valueV
 508 {
 509  public :
 510   template <class T> return_valueV & operator=(T &v);
 511 };
 512
 513 class return_valueT
 514 {
 515  public:
 516   template <class T> return_valueV & operator=(T &v);
 517 };
 518
 519 class return_valueT2
 520 {
 521  public :
 522   return_valueV value;
 523   return_valueT type;
 524 };
 525
 526 // global
 527 extern return_valueT2 * return_value;
 528
 529 MYSTD(zvalR)
 530 MYSTD(zvalT)
 531 MYSTD(zvalC)
 532
 533 class zvalImp
 534 {
 535  public:
 536   zvalR is_ref;
 537   zvalC refcount;
 538   zvalV value;
 539   zvalT type;
 540 };
 541
 542
 543
 544 MYSTD(zend_class_entryB)
 545 MYSTD(zend_class_entry_name)
 546
 547 class zend_class_entry : public zend_class_entryB
 548 {
 549  public:
 550   zend_class_entry_name  name;
 551   //  static  zend_class_entry * MakeNull();// make a null object?
 552   template <class T> static T*  MakeNullPtr();
 553   template <class T> static T**  MakeNullPtrPtr();
 554 };
 555
 556 extern int removethissthing;
 557
 558 class BEGIN_ARG_INFO_EX
 559 {
 560  public:
 561   /*
 562     template <class A,
 563     class B,
 564     class C>*/
 565   BEGIN_ARG_INFO_EX(int A, int B, int C, STDRET);
 566   BEGIN_ARG_INFO_EX(int A, int B, int C, STDRET,STDRET);
 567   BEGIN_ARG_INFO_EX(int A, int B, int C, STDRET,STDRET,STDRET);
 568   BEGIN_ARG_INFO_EX(int A, int B, int C, STDRET,STDRET,STDRET,STDRET);
 569   BEGIN_ARG_INFO_EX(int A, int B, int C, STDRET,STDRET,STDRET,STDRET,STDRET);
 570   BEGIN_ARG_INFO_EX(int A, int B, int C, STDRET,STDRET,STDRET,STDRET,STDRET,STDRET);
 571   BEGIN_ARG_INFO_EX(int A, int B, int C, STDRET,STDRET,STDRET,STDRET,STDRET,STDRET,STDRET);
 572   BEGIN_ARG_INFO_EX(int A, int B, int C, STDRET,STDRET,STDRET,STDRET,STDRET,STDRET,STDRET,STDRET);
 573   BEGIN_ARG_INFO_EX(int A, int B, int C, STDRET,STDRET,STDRET,STDRET,STDRET,STDRET,STDRET,STDRET,STDRET);
 574   BEGIN_ARG_INFO_EX(int A, int B, int C, STDRET,STDRET,STDRET,STDRET,STDRET,STDRET,STDRET,STDRET,STDRET,STDRET);
 575   BEGIN_ARG_INFO_EX(int A, int B, int C);
 576   BEGIN_ARG_INFO_EX(NULLT);
 577
 578 };
 579
 580
 581 #define ZEND_BEGIN_ARG_INFO_EX(X,A,B,C)  BEGIN_ARG_INFO_EX X(A,B,C /**more stuff follows*/
 582
 583 MYSTDF(ZEND_ARG_INFOIMP)
 584
 585 #define ZEND_ARG_INFO(X,Y) ,ZEND_ARG_INFOIMP(X,Y)
 586
 587
 588 #define ZEND_END_ARG_INFO() ); /**end of arguments to constructor...*/
 589
 590 MYSTD(Myfunction_entry)
 591 //MYSTD(function_entry)
 592
 593 class GetDBT
 594 {
 595 };
 596
 597 extern GetDBT GetDB;
 598
 599
 600 class  CreateObject
 601 {
 602  public:
 603   CreateObject(NULLT);
 604   template <class A,class B> CreateObject (const char *, const char*, A,B);
 605   CreateObject (const char *, const char*);
 606 };
 607
 608 class function_entry
 609 {
 610  public:
 611   CreateObject First;
 612   BEGIN_ARG_INFO_EX arginfo;
 613   NULLT access;
 614 };
 615
 616
 617 #define PHP_ME(CLASS, METHOD, C ,D) \
 618   {CreateObject(#CLASS , #METHOD) ,C,D},
 619
 620 MYSTDV(HASH_KEY_IS_LONG)
 621
 622
 623 MYSTDF(MYSsymbol_table)
 624 MYSTDF(MyArray_next)
 625 MYSTDF(MyUnset)
 626
 627
 628 MYSTD(symbol_tableT)
 629
 630 extern symbol_tableT symbol_table;// global value
 631 extern symbol_tableT active_symbol_table;
 632
 633
 634 MYSTDF(bitwise_xor_function)
 635 MYSTDF(zend_hash_add)
 636
 637
 638
 639 MYSTD(class_table_t)
 640 extern class_table_t class_table;
 641
 642 MYSTD(function_table_t)
 643 extern function_table_t function_table;
 644
 645 // for everything else
 646 class zvalP
 647 {
 648  public:
 649   zvalP(const NULLT);
 650   zvalP(zval*);
 651   zvalP();
 652   //operator -> () ;
 653   zval * operator->();
 654   zval & operator * ();
 655   //  template <class A> A  operator -> () ;
 656   //  template <class A> A  operator * () ;
 657   zvalP & operator=(const zvalP&);
 658   template <class T> bool operator != (T );
 659   template <class T> bool operator == (T );
 660   template <class T> bool operator = (T );
 661   operator zval* ( );
 662   //bool operator ! (class & A );
 663 };
 664 //typedef zval
 665 // for return values
 666
 667 typedef zvalP   zvalPA;
 668
 669 template <class F> class zend_functionRTP
 670 {
 671
 672 };
 673
 674 class zvalPP
 675 {
 676  public:
 677   zvalPP();
 678   zvalPP(zval**);
 679   zvalPP(zvalPA*);
 680   template <class A> A  operator -> () ;
 681   template <class A> A  operator * () ;
 682   zvalPP & operator=(const zvalPP&);
 683   zvalP  operator*();
 684   operator zval**();
 685
 686   /*
 687     the user of this class, uses this as return type.
 688     so, how can we store this fact?
 689   */
 690   template <class F> static void setReturnType()
 691     {
 692       //const zend_functionRTP<F> * pFunction
 693       // this object is being used as the return type of the class  F
 694     }
 695   //  template <class A> bool operator ! (class & A );
 696 };
 697
 698
 699 /**
 700    this class is a return type of a class
 701 */
 702
 703
 704 template <class T> class zvalPPReturn : public zvalPP
 705 {
 706  public:
 707   //
 708   template <class F> static void setReturnType()
 709     {
 710       // this object is being used as the return type of the class  F
 711     }
 712 };
 713
 714 //zvalPReturn<mwnamespace_getcanonicalname>::setReturnType() const
 715
 716 template <class T, class G>
 717  void setReturnTypeDynamicT(const T &, G  val);
 718
 719 template <class T> class zvalPReturn : public zvalP
 720 {
 721  public:
 722   zvalPReturn(const NULLT&)    {    }
 723
 724   //  zvalPReturn & operator=(const NULLT&) {}
 725
 726   static void setReturnType()
 727   {
 728     // this object is being used as the return type of the class  F
 729   }
 730
 731   template <class G> void setReturnTypeDynamic(G val)  const
 732   {
 733     // setReturnTypeDynamicT<T,G>(*this,val);
 734
 735     //»setReturnTypeDynamicT(const zvalPReturn<mwnamespace_getcanonicalname>&,
 736     //                     zend_functionRT<mwnamespace_getcanonicalname>*&)«
 737
 738   }
 739
 740   /*
 741   // dynamic
 742   template <class F> void setReturnType() const
 743     {
 744       // this object is being used as the return type of the class  F
 745     }
 746   */
 747 };
 748
 749 typedef zvalPP  zvalPPA;
 750 // pointer pointer pointer for arguments
 751 class zvalPPP
 752 {
 753   template <class A> A  operator -> () ;
 754   template <class A> A  operator * () ;
 755   zvalPPP & operator=(const zvalPPP&);
 756   //  template <class A> bool operator ! (class & A );
 757 };
 758
 759 /**
 760  error: new declaration 'void phc_check_invariants()'
 761
 762 */
 763 template <class Y>
 764 class SmartRet  {
 765  public:
 766   Y* operator & ();
 767   operator zval * ();
 768   operator zvalP ();
 769   operator bool ();
 770
 771 };
 772
 773 template <class Y> SmartRet<Y> EG(Y * pY);
 774 template <class Y> SmartRet<Y> EG(Y & pY);
 775
 776
 777 //MYSTDFP(Z_BVAL_PP)
 778 //MYSTD(Z_LVAL_PP)
 779 //MYSTD(Z_OBJPROP_P)
 780 MYSTDF(Z_STRLEN_P)
 781 MYSTDF(Z_STRLEN_PP)
 782 MYSTDF(Z_STRVAL_P) // string
 783 //MYSTD(Z_STRVAL_PP)
 784 MYSTDF(Z_TYPE_P)
 785 MYSTDF(Z_TYPE_PP)
 786 MYSTDF(ZVAL_DOUBLE)
 787 MYSTDF(ZVAL_PTR_DTOR)
 788 MYSTDF(ZVAL_STRING)
 789 MYSTDF(ZVAL_IS_NULL)
 790 MYSTDF(ZVAL_LONG)
 791 MYSTDF(ZVAL_BOOL)
 792 MYSTDF(ZVAL_STRINGL)
 793 MYSTDF(PZVAL_IS_REF)
 794
 795
 796 #define MYSTDFP2(X,Y)                                                   \
 797   template <class P>                                                    \
 798     Y * X(P*);                                                          \
 799   template <class A>                                                    \
 800     Y * X(A & rY);                                                      \
 801   template <class A,class B>                                            \
 802     Y * X(A, B);                                                        \
 803   template <class A,class B,class C>                                    \
 804     Y * X(A, B, C);                                                     \
 805   template <class A,class B,class C,class D>                            \
 806     Y * X(A, B, C, D);                                                  \
 807   template <class A,class B,class C,class D,class E>                    \
 808     Y * X(A, B, C, D, E);                                               \
 809   template <class A,class B,class C,class D,class E,class F>            \
 810     Y * X(A, B, C, D, E, F);
 811
 812
 813
 814 //MYSTDF(in_copy_on_write)
 815
 816
 817 class Z_OBJ_HT_PP_RET : public STDRET
 818 {
 819  public:
 820   MYSTDF(get_property_ptr_ptr)
 821     MYSTDF(read_property)
 822     MYSTDF(write_property)
 823     void f();
 824 };
 825
 826 //int x;
 827 MYSTDFP2(Z_OBJ_HT_PP,Z_OBJ_HT_PP_RET)
 828 //int y;
 829
 830 /**
 831    simple replacements on zval
 832
 833 */
 834
 835
 836 /*
 837 class zvalPPA
 838 {
 839   zvalP& operator*()           ;
 840   zvalP* operator->()         ;
 841   }*/
 842
 843   template <class T,class G>
 844   void DoAssign(T,G);
 845
 846 // params
 847 template <class F>  class zend_functionPST : public zend_functionPS
 848 {
 849   //class zend_functionPS : public zval {
 850  public:
 851   // set the arguments value
 852   //zend_functionPST <F> & operator = (zval ***);
 853    //   zend_functionPST <F> & operator = (zvalPPP);
 854    //   zend_functionPST <F> & operator = (zvalPPA *);
 855    zend_functionPST <F> & operator = (zvalPPA );
 856
 857    // generic template parameter
 858    template <class T> zend_functionPST <F> & operator = (T t)
 859      {
 860        DoAssign(*this,t);
 861      }
 862 };
 863
 864 template <class F> class zend_functionRT : public zend_functionR
 865 {
 866  public:
 867
 868   /*
 869     here we have the generic one, now we tighten it down.
 870   */
 871   /*  zend_functionRT <F> & operator = (const zvalPP & rP)
 872     {
 873       //we have a parameter, now we assert the types.
 874       rP.setReturnType<F>(); // this means that the parameter needs this type
 875     }
 876   */
 877
 878   //operator zend_functionRTP<F> ();
 879
 880
 881   zend_functionRT <F> & operator = (const zvalPPReturn<F> & rP)
 882     {
 883       //we have a parameter, now we assert the types.
 884       rP.setReturnType(); // this means that the parameter needs this type
 885     }
 886   zend_functionRT <F> & operator = (const zvalPReturn<F> * pP)
 887     {
 888       //we have a parameter, now we assert the types.
 889       //pP->setReturnType(); // this means that the parameter needs this type
 890       //zvalPReturn<F>::setReturnType();
 891       pP->setReturnTypeDynamic(this);
 892     }
 893
 894   zend_functionRT<T>&    operator=
 895     /*<zvalPReturn<mwnamespace_getcanonicalname>*>*/
 896     (zvalPReturn<T>*)
 897     {
 898     };
 899   //  zend_functionRT<mwnamespace_getcanonicalname>& zend_functionRT<mwnamespace_getcanonicalname>::operator=<zval**>(zval**){};
 900
 901 //  template <class T>  zend_functionRT <F> & operator = (T);
 902
 903 };
 904
 905
 906 template <class Function>
 907 class zend_fcall_infoT //: public zend_fcall_info
 908 {
 909  public:
 910   zend_functionPCT<Function> param_count;
 911   zend_functionPST<Function> params;
 912   zend_functionRT<Function>  retval_ptr_ptr;
 913   /**
 914      this is
 915    */
 916 };
 917 // for the call by variable
 918 extern zend_fcall_info TODO_fcic;
 919
 920 class zend_function : public zend_functionB
 921 {
 922 public:
 923   zend_functionPC param_count;
 924   zend_functionPS params;
 925   zend_functionR  retval_ptr_ptr;
 926   zend_functionC  common;
 927
 928   //  static  zend_function * MakeNull();// make a null object?
 929   template <class T> static T*  MakeNullPtr();
 930   template <class T> static T**  MakeNullPtrPtr();
 931 };
 932
 933 typedef struct _zend_fcall_info_cache {
 934         zend_bool initialized;
 935         zend_function *function_handler;
 936         zend_class_entry *calling_scope;
 937         zval **object_pp;
 938 } zend_fcall_info_cache;
 939
 940 template <class T> class zend_fcall_info_cacheT: public _zend_fcall_info_cache
 941 {
 942   /**
 943      template static method call
 944    */
 945 };
 946
 947 template <class T> class zvalParamsT
 948 {
 949
 950 };
 951
 952 #endif