?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
update porting to new machine
[wikipedia-parser-hphp.git] / parser / ParserOutput.php.c
blob21678315a017cb45d89a8cab2b6e0e4de236b8c3
1 // BEGIN INCLUDED FILES
2 /* The difference between zend_symtable_X and zend_hash_X is that
3 * the _symtable version will check if the key is a string of an
4 * integer, and if so, use the int version instead. We can use the
5 * zend_hash_X versions safely for symbol tables, since
6 * variables cant be integer strings, but we cant safely use
7 * zend_hash_X versions for hashtable lookups. Well-named, they are.
8 */
9
10 /* An important note of zval*s and zval**s. Frequently, zval** are
11 * fetched from arrays and symbol tables. The zval** will point into
12 * the array, and so updating it will update the relevant array
13 * entry. It is normally not the same to dereference it to a local
14 * variable, and pass a reference to that.
15 */
16
17
18
19 // Some common functions
20 #include "php.h"
21
22 /*
23 * The runtime needs its own initialization and finalization. phc is
24 * responsible for generating calls to these functions.
25 */
26
27 void
28 init_runtime ()
29 {
30 }
31
32 void
33 finalize_runtime ()
34 {
35 }
36
37 static void
38 ht_debug (HashTable * ht)
39 {
40 printf ("\nHASH\n");
41 if (ht == NULL)
42 {
43 printf ("NULL\n");
44 return;
45 }
46 for (zend_hash_internal_pointer_reset (ht);
47 zend_hash_has_more_elements (ht) == SUCCESS;
48 zend_hash_move_forward (ht))
49 {
50 char *key;
51 unsigned keylen;
52 unsigned long idx;
53 int type;
54 zval **ppzval;
55 zval *zvp;
56
57 type = zend_hash_get_current_key_ex (ht, &key, &keylen, &idx, 0, NULL);
58 zend_hash_get_current_data (ht, (void **) &ppzval);
59
60 zvp = *ppzval;
61
62 if (type == HASH_KEY_IS_STRING)
63 {
64 printf ("%s", key);
65 }
66 else
67 {
68 printf ("%ld", idx);
69 }
70
71 printf (": addr = %08lX, refcount = %d, is_ref = %d ",
72 (long unsigned int) (*ppzval), (*ppzval)->refcount,
73 (*ppzval)->is_ref);
74 switch (Z_TYPE_P (zvp))
75 {
76 case IS_NULL:
77 printf ("(NULL)");
78 break;
79 case IS_LONG:
80 printf ("(%ldL)", Z_LVAL_P (zvp));
81 break;
82 case IS_DOUBLE:
83 printf ("(%lff)", Z_DVAL_P (zvp));
84 break;
85 case IS_BOOL:
86 printf (Z_BVAL_P (zvp) ? "(true)" : "(false)");
87 break;
88 case IS_ARRAY:
89 printf ("(array(%d))", Z_ARRVAL_P (zvp)->nNumOfElements);
90 break;
91 case IS_OBJECT:
92 printf ("(Object)");
93 break;
94 case IS_STRING:
95 printf ("(\"%s\")", Z_STRVAL_P (zvp));
96 break;
97 case IS_RESOURCE:
98 printf ("(Resource)");
99 break;
100 default:
101 printf ("(Invalid: %d)", Z_TYPE_P (zvp));
102 }
103
104 printf ("\n");
105
106 }
107 printf ("END HASH\n");
108 }
109
110 // Call ht_debug on the named var in the given symbol table
111 static void
112 ht_var_debug (HashTable * st, char *name)
113 {
114 zval **p_zvp;
115 if (zend_symtable_find (st, name, strlen (name) + 1,
116 (void **) &p_zvp) != SUCCESS)
117 {
118 printf ("VAR NOT IN SYMBOL TABLE: '%s'\n", name);
119 return;
120 }
121
122 if (Z_TYPE_P (*p_zvp) != IS_ARRAY)
123 {
124 printf ("NOT HASH\n");
125 return;
126 }
127
128 ht_debug ((*p_zvp)->value.ht);
129 }
130
131 static zval* counters;
132
133 static void init_counters ()
134 {
135 ALLOC_INIT_ZVAL (counters);
136 array_init (counters);
137 }
138
139 // Dump and cleanup memory
140 static void finalize_counters ()
141 {
142 HashTable* ht = Z_ARRVAL_P (counters);
143 for (zend_hash_internal_pointer_reset (ht);
144 zend_hash_has_more_elements (ht) == SUCCESS;
145 zend_hash_move_forward (ht))
146 {
147 char *key;
148 zval **p_zvp;
149
150 zend_hash_get_current_key_ex (ht, &key, NULL, NULL, 0, NULL);
151 zend_hash_get_current_data (ht, (void **) &p_zvp);
152
153 fprintf (stderr, "COUNTER:%s:%ld\n", key, Z_LVAL_P (*p_zvp));
154 }
155
156 zval_ptr_dtor (&counters);
157 }
158
159 static void increment_counter (char* name, int length, ulong hashval)
160 {
161 zval** p_zvp;
162 int success = zend_hash_quick_find (Z_ARRVAL_P (counters),
163 name,
164 length,
165 hashval,
166 (void **) &p_zvp);
167
168 if (success == SUCCESS)
169 {
170 Z_LVAL_PP (p_zvp)++;
171 }
172 else
173 {
174
175 zval* new_val;
176 ALLOC_INIT_ZVAL (new_val);
177 ZVAL_LONG (new_val, 1);
178
179 zend_hash_quick_add (Z_ARRVAL_P (counters),
180 name,
181 length,
182 hashval,
183 &new_val,
184 sizeof (zval *),
185 NULL);
186 }
187 }
188
189
190
191 /* Make a copy of *P_ZVP, storing it in *P_ZVP. */
192 static zval *
193 zvp_clone_ex (zval * zvp)
194 {
195 // TODO: use INIT_PZVAL_COPY
196 zval *clone;
197 MAKE_STD_ZVAL (clone);
198 clone->value = zvp->value;
199 clone->type = zvp->type;
200 zval_copy_ctor (clone);
201 return clone;
202 }
203
204
205 static inline int
206 in_copy_on_write (zval * zvp)
207 {
208 return (zvp->refcount > 1 && !zvp->is_ref);
209 }
210
211 static inline int
212 in_change_on_write (zval * zvp)
213 {
214 return (zvp->refcount > 1 && zvp->is_ref);
215 }
216
217 /* If *P_ZVP is in a copy-on-write set, separate it by overwriting
218 * *P_ZVP with a clone of itself, and lowering the refcount on the
219 * original. */
220 static void
221 sep_copy_on_write (zval ** p_zvp)
222 {
223 if (!in_copy_on_write (*p_zvp))
224 return;
225
226 zval *old = *p_zvp;
227
228 *p_zvp = zvp_clone_ex (*p_zvp);
229
230 zval_ptr_dtor (&old);
231 }
232
233 /* If *P_ZVP is in a copy-on-write set, separate it by overwriting
234 * *P_ZVP with a clone of itself, and lowering the refcount on the
235 * original. */
236 static void
237 sep_change_on_write (zval ** p_zvp)
238 {
239 assert (in_change_on_write (*p_zvp));
240
241 zval *old = *p_zvp;
242
243 *p_zvp = zvp_clone_ex (*p_zvp);
244
245 zval_ptr_dtor (&old);
246 }
247
248 /* Assign RHS into LHS, by reference. After this, LHS will point to the same
249 * zval* as RHS. */
250 static void
251 copy_into_ref (zval ** lhs, zval ** rhs)
252 {
253 (*rhs)->is_ref = 1;
254 (*rhs)->refcount++;
255 zval_ptr_dtor (lhs);
256 *lhs = *rhs;
257 }
258
259
260 // Overwrite one zval with another
261 static void
262 overwrite_lhs (zval * lhs, zval * rhs)
263 {
264 // First, call the destructor to remove any data structures
265 // associated with lhs that will now be overwritten
266 zval_dtor (lhs);
267 // Overwrite LHS
268 lhs->value = rhs->value;
269 lhs->type = rhs->type;
270 zval_copy_ctor (lhs);
271 }
272
273 // Overwrite one zval with another
274 static void
275 overwrite_lhs_no_copy (zval * lhs, zval * rhs)
276 {
277 // First, call the destructor to remove any data structures
278 // associated with lhs that will now be overwritten
279 zval_dtor (lhs);
280 // Overwrite LHS
281 lhs->value = rhs->value;
282 lhs->type = rhs->type;
283 }
284
285 /* Write P_RHS into the symbol table as a variable named VAR_NAME. */
286 // NOTE: We do not alter p_rhs's refcount, unless p_lhs joins its
287 // Copy-on-write set.
288 // TODO: this is crying out to be inlined.
289 static void
290 write_var (zval ** p_lhs, zval * rhs)
291 {
292 if (!(*p_lhs)->is_ref)
293 {
294 zval_ptr_dtor (p_lhs);
295 // Take a copy of RHS for LHS.
296 if (rhs->is_ref)
297 {
298 *p_lhs = zvp_clone_ex (rhs);
299 }
300 else // share a copy
301 {
302 rhs->refcount++;
303 *p_lhs = rhs;
304 }
305 }
306 else
307 {
308 overwrite_lhs (*p_lhs, rhs);
309 }
310 }
311
312 // TODO: this functino does too much, and much might be redundant
313 static zval **
314 get_st_entry (HashTable * st, char *name, int length, ulong hashval TSRMLS_DC)
315 {
316 zval **p_zvp;
317 if (zend_hash_quick_find
318 (st, name, length, hashval, (void **) &p_zvp) == SUCCESS)
319 {
320 assert (p_zvp != NULL);
321 return p_zvp;
322 }
323
324 // If we dont find it, put EG (uninitialized_zval_ptr) into the
325 // hashtable, and return a pointer to its container.
326 EG (uninitialized_zval_ptr)->refcount++;
327 int result = zend_hash_quick_add (st, name, length, hashval,
328 &EG (uninitialized_zval_ptr),
329 sizeof (zval *), (void **) &p_zvp);
330 assert (result == SUCCESS);
331 assert (p_zvp != NULL);
332
333 return p_zvp;
334 }
335
336 /* Read the variable named VAR_NAME from the local symbol table and
337 * return it. If the variable doent exist, a new one is created and
338 * *IS_NEW is set. */
339 static zval *
340 read_var (HashTable * st, char *name, int length, ulong hashval TSRMLS_DC)
341 {
342 zval **p_zvp;
343 if (zend_hash_quick_find
344 (st, name, length, hashval, (void **) &p_zvp) == SUCCESS)
345 return *p_zvp;
346
347 return EG (uninitialized_zval_ptr);
348 }
349
350 static long
351 get_integer_index (zval * ind TSRMLS_DC)
352 {
353 long index;
354 switch (Z_TYPE_P (ind))
355 {
356 case IS_DOUBLE:
357 return (long) Z_DVAL_P (ind);
358
359 case IS_LONG:
360 case IS_BOOL:
361 return Z_LVAL_P (ind);
362
363 case IS_NULL:
364 return 0;
365
366 default:
367 php_error_docref (NULL TSRMLS_CC, E_WARNING, "Illegal offset type");
368 }
369 }
370
371 static zval *
372 read_string_index (zval * var, zval * ind TSRMLS_DC)
373 {
374 // This must always allocate memory, since we cant return the
375 // passed string.
376 assert (Z_TYPE_P (var) == IS_STRING);
377 long index = get_integer_index (ind TSRMLS_CC);
378
379 zval *result;
380 ALLOC_INIT_ZVAL (result);
381
382 if (index >= Z_STRLEN_P (var) || index < 0)
383 {
384 // this is 1 byte long, must be copied
385 ZVAL_STRINGL (result, "", 0, 1);
386 }
387 else
388 {
389 char *string = Z_STRVAL_P (var);
390 ZVAL_STRINGL (result, &string[index], 1, 1);
391 }
392
393 return result;
394 }
395
396 /* Given a string (p_lhs), write into it for $x[i] = $y; */
397 void
398 write_string_index (zval ** p_lhs, zval * ind, zval * rhs TSRMLS_DC)
399 {
400 assert (Z_TYPE_P (*p_lhs) == IS_STRING);
401
402 long index = get_integer_index (ind TSRMLS_CC);
403
404 // Get the appropriate character
405 char new_char;
406 if (Z_TYPE_P (rhs) != IS_STRING)
407 {
408 // TODO: remove allocate
409 zval *copy = zvp_clone_ex (rhs);
410 convert_to_string (copy);
411 new_char = Z_STRVAL_P (copy)[0];
412 zval_ptr_dtor (&copy);
413 }
414 else
415 {
416 new_char = Z_STRVAL_P (rhs)[0];
417 }
418
419 // Bounds check
420 if (index < 0)
421 {
422 php_error_docref (NULL TSRMLS_CC, E_WARNING,
423 "Illegal string offset: %ld", index);
424 return;
425 }
426
427 // We overwrite if it's change-on-write
428 sep_copy_on_write (p_lhs);
429
430 if (index > Z_STRLEN_PP (p_lhs))
431 {
432 // Extend to fix new
433 int len = Z_STRLEN_PP (p_lhs);
434 int new_length = index + 1; // space for the new character
435 Z_STRVAL_PP (p_lhs) = erealloc (Z_STRVAL_PP (p_lhs), new_length + 1);
436
437 // pad with ' '
438 memset (&Z_STRVAL_PP (p_lhs)[len], ' ', index - len);
439
440 // change the strlen
441 Z_STRLEN_PP (p_lhs) = new_length;
442
443 // add a null terminator
444 Z_STRVAL_PP (p_lhs)[new_length] = '\0';
445 }
446
447 // write in the first character of the new value
448 Z_STRVAL_PP (p_lhs)[index] = new_char;
449
450
451 // index < 0: E_WARNING illegal string offset
452 }
453
454 // Extract the hashtable from a hash-valued zval
455 static HashTable *
456 extract_ht_ex (zval * arr TSRMLS_DC)
457 {
458 // TODO: this likely should be inlined somewhere.
459 assert (!in_copy_on_write (arr));
460 if (Z_TYPE_P (arr) == IS_NULL)
461 {
462 array_init (arr);
463 }
464 else if (Z_TYPE_P (arr) != IS_ARRAY)
465 {
466 php_error_docref (NULL TSRMLS_CC, E_WARNING,
467 "Cannot use a scalar value as an array");
468 array_init (arr);
469 }
470 return Z_ARRVAL_P (arr);
471 }
472
473
474 /* P_VAR points into a symbol table, at a variable which we wish to index as a hashtable. */
475 static HashTable *
476 extract_ht (zval ** p_var TSRMLS_DC)
477 {
478 sep_copy_on_write (p_var);
479
480 return extract_ht_ex (*p_var TSRMLS_CC);
481 }
482
483 /* Using IND as a key to HT, call the appropriate zend_index_X
484 * function with data as a parameter, and return its result. This
485 * updates the zval** pointed to by DATA. */
486 static int
487 ht_find (HashTable * ht, zval * ind, zval *** data)
488 {
489 int result;
490 if (Z_TYPE_P (ind) == IS_LONG || Z_TYPE_P (ind) == IS_BOOL)
491 {
492 result = zend_hash_index_find (ht, Z_LVAL_P (ind), (void **) data);
493 }
494 else if (Z_TYPE_P (ind) == IS_DOUBLE)
495 {
496 result = zend_hash_index_find (ht, (long) Z_DVAL_P (ind),
497 (void **) data);
498 }
499 else if (Z_TYPE_P (ind) == IS_NULL)
500 {
501 result = zend_hash_find (ht, "", sizeof (""), (void **)data);
502 }
503 else if (Z_TYPE_P (ind) == IS_STRING)
504 {
505 result = zend_symtable_find (ht, Z_STRVAL_P (ind),
506 Z_STRLEN_P (ind) + 1, (void **) data);
507 }
508 else
509 {
510 // TODO: I believe this might need a warning.
511
512 // TODO avoid alloc
513 // use a string index for other types
514 zval *string_index;
515 MAKE_STD_ZVAL (string_index);
516 string_index->value = ind->value;
517 string_index->type = ind->type;
518 zval_copy_ctor (string_index);
519 convert_to_string (string_index);
520
521 result = zend_symtable_find (ht, Z_STRVAL_P (string_index),
522 Z_STRLEN_P (string_index) + 1,
523 (void **) data);
524 zval_ptr_dtor (&string_index);
525 }
526 return result;
527 }
528
529
530 static int
531 check_array_index_type (zval * ind TSRMLS_DC)
532 {
533 if (Z_TYPE_P (ind) == IS_OBJECT || Z_TYPE_P (ind) == IS_ARRAY)
534 {
535 php_error_docref (NULL TSRMLS_CC, E_WARNING, "Illegal offset type");
536 return 0;
537 }
538
539 return 1;
540 }
541
542 // Update a hashtable using a zval* index
543 static void
544 ht_update (HashTable * ht, zval * ind, zval * val, zval *** dest)
545 {
546 int result;
547 if (Z_TYPE_P (ind) == IS_LONG || Z_TYPE_P (ind) == IS_BOOL)
548 {
549 result = zend_hash_index_update (ht, Z_LVAL_P (ind), &val,
550 sizeof (zval *), (void **) dest);
551 }
552 else if (Z_TYPE_P (ind) == IS_DOUBLE)
553 {
554 result = zend_hash_index_update (ht, (long) Z_DVAL_P (ind),
555 &val, sizeof (zval *), (void **) dest);
556 }
557 else if (Z_TYPE_P (ind) == IS_NULL)
558 {
559 result = zend_hash_update (ht, "", sizeof (""), &val,
560 sizeof (zval *), (void **) dest);
561 }
562 else if (Z_TYPE_P (ind) == IS_STRING)
563 {
564 result = zend_symtable_update (ht, Z_STRVAL_P (ind),
565 Z_STRLEN_P (ind) + 1,
566 &val, sizeof (zval *), (void **) dest);
567 }
568 else
569 {
570 // TODO avoid alloc
571 zval *string_index;
572 MAKE_STD_ZVAL (string_index);
573 string_index->value = ind->value;
574 string_index->type = ind->type;
575 zval_copy_ctor (string_index);
576 convert_to_string (string_index);
577 result = zend_symtable_update (ht, Z_STRVAL_P (string_index),
578 Z_STRLEN_P (string_index) + 1,
579 &val, sizeof (zval *), (void **) dest);
580
581 zval_ptr_dtor (&string_index);
582 }
583 assert (result == SUCCESS);
584 }
585
586 // Delete from a hashtable using a zval* index
587 static void
588 ht_delete (HashTable * ht, zval * ind)
589 {
590 // This may fail if the index doesnt exist, which is fine.
591 if (Z_TYPE_P (ind) == IS_LONG || Z_TYPE_P (ind) == IS_BOOL)
592 {
593 zend_hash_index_del (ht, Z_LVAL_P (ind));
594 }
595 else if (Z_TYPE_P (ind) == IS_DOUBLE)
596 {
597 zend_hash_index_del (ht, (long) Z_DVAL_P (ind));
598 }
599 else if (Z_TYPE_P (ind) == IS_NULL)
600 {
601 zend_hash_del (ht, "", sizeof (""));
602 }
603 else if (Z_TYPE_P (ind) == IS_STRING)
604 {
605 zend_hash_del (ht, Z_STRVAL_P (ind), Z_STRLEN_P (ind) + 1);
606 }
607 else
608 {
609 // TODO avoid alloc
610 zval *string_index;
611 MAKE_STD_ZVAL (string_index);
612 string_index->value = ind->value;
613 string_index->type = ind->type;
614 zval_copy_ctor (string_index);
615 convert_to_string (string_index);
616 zend_hash_del (ht, Z_STRVAL_P (string_index),
617 Z_STRLEN_P (string_index) + 1);
618
619 zval_ptr_dtor (&string_index);
620 }
621 }
622
623 // Check if a key exists in a hashtable
624 static int
625 ht_exists (HashTable * ht, zval * ind)
626 {
627 if (Z_TYPE_P (ind) == IS_LONG || Z_TYPE_P (ind) == IS_BOOL)
628 {
629 return zend_hash_index_exists (ht, Z_LVAL_P (ind));
630 }
631 else if (Z_TYPE_P (ind) == IS_DOUBLE)
632 {
633 return zend_hash_index_exists (ht, (long) Z_DVAL_P (ind));
634 }
635 else if (Z_TYPE_P (ind) == IS_NULL)
636 {
637 return zend_hash_exists (ht, "", sizeof (""));
638 }
639 else if (Z_TYPE_P (ind) == IS_STRING)
640 {
641 return zend_hash_exists (ht, Z_STRVAL_P (ind), Z_STRLEN_P (ind) + 1);
642 }
643 else
644 {
645 // TODO avoid alloc
646 int result;
647 zval *string_index;
648 MAKE_STD_ZVAL (string_index);
649 string_index->value = ind->value;
650 string_index->type = ind->type;
651 zval_copy_ctor (string_index);
652 convert_to_string (string_index);
653 result = zend_hash_exists (ht, Z_STRVAL_P (string_index),
654 Z_STRLEN_P (string_index) + 1);
655 zval_ptr_dtor (&string_index);
656 return result;
657 }
658 assert (0);
659 }
660
661 static zval **
662 get_ht_entry (zval ** p_var, zval * ind TSRMLS_DC)
663 {
664 if (Z_TYPE_P (*p_var) == IS_STRING)
665 {
666 if (Z_STRLEN_PP (p_var) > 0)
667 {
668 php_error_docref (NULL TSRMLS_CC, E_ERROR,
669 "Cannot create references to/from string offsets nor overloaded objects");
670 }
671 }
672
673 if (Z_TYPE_P (*p_var) != IS_ARRAY)
674 {
675 zval_ptr_dtor (p_var);
676 ALLOC_INIT_ZVAL (*p_var);
677 array_init (*p_var);
678 }
679
680 HashTable *ht = extract_ht (p_var TSRMLS_CC);
681
682 zval **data;
683 if (ht_find (ht, ind, &data) == SUCCESS)
684 {
685 assert (data != NULL);
686 return data;
687 }
688
689 // If we dont find it, put EG (uninitialized_zval_ptr) into the
690 // hashtable, and return a pointer to its container.
691 EG (uninitialized_zval_ptr)->refcount++;
692 ht_update (ht, ind, EG (uninitialized_zval_ptr), &data);
693
694 assert (data != NULL);
695
696 return data;
697 }
698
699
700 // Like extract_ht_ex, but for objects
701 static HashTable *
702 extract_field_ex (zval * obj TSRMLS_DC)
703 {
704 // TODO: this likely should be inlined somewhere.
705 assert (!in_copy_on_write (obj));
706 if (Z_TYPE_P (obj) == IS_NULL)
707 {
708 assert (0);
709 // TODO: implement initialization
710 }
711 else if (Z_TYPE_P (obj) != IS_OBJECT)
712 {
713 // TODO: test if this is the right error message
714 php_error_docref (NULL TSRMLS_CC, E_WARNING,
715 "Cannot use a scalar value as an object");
716 // TODO: implement initialization
717 assert (0);
718 }
719 return Z_OBJPROP_P (obj);
720 }
721
722 // Like extract_ht, but for objects
723 static HashTable *
724 extract_field (zval ** p_var TSRMLS_DC)
725 {
726 sep_copy_on_write (p_var);
727
728 return extract_field_ex (*p_var TSRMLS_CC);
729 }
730
731 // Like get_ht_entry, but for objects
732 static zval **
733 get_field (zval ** p_var, char *ind TSRMLS_DC)
734 {
735 if (Z_TYPE_P (*p_var) != IS_OBJECT)
736 {
737 // TODO: implement initialization
738 assert (0);
739 }
740
741 HashTable *ht = extract_field (p_var TSRMLS_CC);
742
743 zval **data;
744 if (zend_symtable_find (ht, ind, strlen (ind) + 1, (void **) &data) ==
745 SUCCESS)
746 {
747 assert (data != NULL);
748 return data;
749 }
750
751 // If we dont find it, put EG (uninitialized_zval_ptr) into the
752 // hashtable, and return a pointer to its container.
753 EG (uninitialized_zval_ptr)->refcount++;
754 zend_symtable_update (ht, ind, strlen (ind) + 1,
755 &EG (uninitialized_zval_ptr), sizeof (zval *),
756 (void **) &data);
757
758 assert (data != NULL);
759
760 return data;
761 }
762
763 void
764 read_array (zval ** result, zval * array, zval * ind TSRMLS_DC)
765 {
766 // Memory can be allocated in read_string_index
767 if (array == EG (uninitialized_zval_ptr))
768 {
769 *result = array;
770 return;
771 }
772
773 // Since we know its an array, and we dont write to it, we dont need
774 // to separate it.
775 HashTable *ht = Z_ARRVAL_P (array);
776
777 // find the result
778 zval **p_result;
779 if (ht_find (ht, ind, &p_result) == SUCCESS)
780 {
781 *result = *p_result;
782 return;
783 }
784
785 *result = EG (uninitialized_zval_ptr);
786 }
787
788 /* If its not an array, convert it into an array. */
789 static void
790 check_array_type (zval ** p_var TSRMLS_DC)
791 {
792 if ((Z_TYPE_P (*p_var) == IS_BOOL && !Z_BVAL_PP (p_var))
793 || Z_TYPE_P (*p_var) == IS_NULL
794 || (Z_TYPE_P (*p_var) == IS_STRING && Z_STRLEN_PP (p_var) == 0))
795 {
796 // Non ref use new values
797 if (!PZVAL_IS_REF (*p_var))
798 {
799 zval_ptr_dtor (p_var);
800 ALLOC_INIT_ZVAL (*p_var);
801 }
802 else
803 // Refs are just replaced
804 zval_dtor (*p_var);
805
806 array_init (*p_var);
807 }
808 else if (Z_TYPE_PP (p_var) != IS_STRING && Z_TYPE_PP (p_var) != IS_ARRAY)
809 {
810 // TODO: why are these different types than pushing
811 php_error_docref (NULL TSRMLS_CC, E_WARNING,
812 "Cannot use a scalar value as an array");
813 }
814 }
815
816 /* If its not an array, convert it into an object. */
817 static void
818 check_object_type (zval ** p_var TSRMLS_DC)
819 {
820 // TODO: implement
821 }
822
823 /* Push EG (uninitialized_zval_ptr) and return a pointer into the ht
824 * for it */
825 /*
826 * Converted to array automatically:
827 * ""
828 * NULL
829 * false
830 *
831 * Warning, no conversion:
832 * ints
833 * floats
834 * true
835 *
836 * Error, no conversion:
837 * strings other than ""
838 */
839 // TODO: objects, resources, etc
840 static zval **
841 push_and_index_ht (zval ** p_var TSRMLS_DC)
842 {
843 // Check for errors conditions
844
845 if (Z_TYPE_P (*p_var) == IS_STRING && Z_STRLEN_PP (p_var) > 0)
846 {
847 php_error_docref (NULL TSRMLS_CC, E_ERROR,
848 "[] operator not supported for strings");
849 assert (0); // unreachable
850 }
851
852 if (Z_TYPE_P (*p_var) == IS_BOOL && Z_BVAL_PP (p_var)
853 || Z_TYPE_P (*p_var) == IS_LONG || Z_TYPE_P (*p_var) == IS_DOUBLE)
854 {
855 php_error_docref (NULL TSRMLS_CC, E_WARNING,
856 "Cannot use a scalar value as an array");
857 return NULL;
858 }
859
860 if (Z_TYPE_P (*p_var) != IS_ARRAY)
861 {
862 zval_ptr_dtor (p_var);
863 ALLOC_INIT_ZVAL (*p_var);
864 array_init (*p_var);
865 }
866
867 // if its not an array, make it an array
868 HashTable *ht = extract_ht (p_var TSRMLS_CC);
869 zval **data;
870
871 EG (uninitialized_zval_ptr)->refcount++;
872 int result = zend_hash_next_index_insert (ht, &EG (uninitialized_zval_ptr),
873 sizeof (zval *), (void **) &data);
874 assert (result == SUCCESS);
875
876 assert (data);
877
878 return data;
879 }
880
881
882 /*
883 * isset
884 */
885 static int
886 isset_var (HashTable * st, char *name, int length)
887 {
888 return zend_hash_exists (st, name, length);
889 }
890
891 static int
892 isset_array (zval ** p_var, zval * ind)
893 {
894 if (Z_TYPE_P (*p_var) == IS_STRING)
895 {
896 ind = zvp_clone_ex (ind);
897 convert_to_long (ind);
898 int result = (Z_LVAL_P (ind) >= 0
899 && Z_LVAL_P (ind) < Z_STRLEN_PP (p_var));
900 assert (ind->refcount == 1);
901 zval_ptr_dtor (&ind);
902 return result;
903 }
904
905 // NO error required; return false
906 if (Z_TYPE_P (*p_var) != IS_ARRAY)
907 return 0;
908
909 // if its not an array, make it an array
910 HashTable *ht = Z_ARRVAL_P (*p_var);
911
912 zval **data;
913 if (ht_find (ht, ind, &data) == SUCCESS)
914 {
915 return !ZVAL_IS_NULL (*data);
916 }
917 else
918 return 0;
919 }
920
921
922 static zval **
923 fetch_var_arg_by_ref (zval ** p_arg)
924 {
925 // We are passing by reference
926 sep_copy_on_write (p_arg);
927
928 // We don't need to restore ->is_ref afterwards,
929 // because the called function will reduce the
930 // refcount of arg on return, and will reset is_ref to
931 // 0 when refcount drops to 1. If the refcount does
932 // not drop to 1 when the function returns, but we did
933 // set is_ref to 1 here, that means that is_ref must
934 // already have been 1 to start with (since if it had
935 // not, that means that the variable would have been
936 // in a copy-on-write set, and would have been
937 // seperated above).
938 (*p_arg)->is_ref = 1;
939
940 return p_arg;
941 }
942
943 /* Dont pass-by-ref */
944 static zval *
945 fetch_var_arg (zval * arg, int *is_arg_new)
946 {
947 if (arg->is_ref)
948 {
949 // We dont separate since we don't own one of ARG's references.
950 arg = zvp_clone_ex (arg);
951 *is_arg_new = 1;
952
953 // It seems we get incorrect refcounts without this.
954 // TODO This decreases the refcount to zero, which seems wrong,
955 // but gives the right answer. We should look at how zend does
956 // this.
957
958 arg->refcount--;
959 }
960 return arg;
961 }
962
963 // TODO dont overwrite line numbers if we're compiling an extension
964 static void
965 phc_setup_error (int init, char *filename, int line_number,
966 zend_function * function TSRMLS_DC)
967 {
968 static int old_in_compilation;
969 static int old_in_execution;
970 static char *old_filename;
971 static int old_lineno;
972 static zend_function *old_function;
973 if (init)
974 {
975 if (filename == NULL)
976 filename = "[phc_compiled_file]";
977 // Save old values
978 old_in_compilation = CG (in_compilation);
979 old_in_execution = EG (in_execution);
980 old_filename = CG (compiled_filename);
981 old_lineno = CG (zend_lineno);
982 old_function = EG (function_state_ptr)->function;
983 // Put in our values
984 CG (in_compilation) = 1;
985 EG (in_execution) = 1;
986 CG (compiled_filename) = filename;
987 CG (zend_lineno) = line_number;
988 if (function)
989 EG (function_state_ptr)->function = function;
990 }
991 else
992 {
993 CG (in_compilation) = old_in_compilation;
994 EG (in_execution) = old_in_execution;
995 CG (compiled_filename) = old_filename;
996 CG (zend_lineno) = old_lineno;
997 EG (function_state_ptr)->function = old_function;
998 }
999 }
1000
1001 static void
1002 initialize_function_call (zend_fcall_info * fci, zend_fcall_info_cache * fcic,
1003 char *function_name, char *filename,
1004 int line_number TSRMLS_DC)
1005 {
1006 if (fcic->initialized)
1007 return;
1008
1009 zval fn;
1010 INIT_PZVAL (&fn);
1011 ZVAL_STRING (&fn, function_name, 0);
1012 int result = zend_fcall_info_init (&fn, fci, fcic TSRMLS_CC);
1013 if (result != SUCCESS)
1014 {
1015 phc_setup_error (1, filename, line_number, NULL TSRMLS_CC);
1016 php_error_docref (NULL TSRMLS_CC, E_ERROR,
1017 "Call to undefined function %s()", function_name);
1018 }
1019 }
1020
1021 /*
1022 * Initialize zend_fcall_info for a method lookup
1023 *
1024 * Implementation partly based on zend_call_method in Zend/zend_interfaces.c
1025 * Main difference is that we use Z_OBJ_HTT_PP(obj)->get_method to retrieve
1026 * the function handler for the method instead of looking it up directly;
1027 * this means that we correctly deal with __call.
1028 */
1029
1030 static void
1031 initialize_method_call (zend_fcall_info * fci, zend_fcall_info_cache * fcic,
1032 zval ** obj, char *function_name,
1033 char *filename, int line_number TSRMLS_DC)
1034 {
1035 if (fcic->initialized)
1036 return;
1037
1038 zend_class_entry *obj_ce;
1039 obj_ce = Z_OBJCE_PP (obj);
1040
1041 /*
1042 * we do not initialize fci.
1043 * function_table -- not initialized by zend_call_method
1044 * function_name -- zend_call_method initializes this to a pointer to
1045 * a zval 'z_fname', but does not initialize z_fname
1046 * in case of a method invocation
1047 * retval_ptr_ptr -- should be initialized by caller
1048 * param_count -- should be initialized by caller
1049 * params -- should be initialized by caller
1050 */
1051 fci->size = sizeof (*fci);
1052 fci->object_pp = obj;
1053 fci->no_separation = 1;
1054 fci->symbol_table = NULL;
1055
1056 fcic->initialized = 1;
1057 fcic->calling_scope = obj_ce;
1058 fcic->object_pp = obj;
1059 fcic->function_handler
1060 = Z_OBJ_HT_PP (obj)->get_method (obj,
1061 function_name,
1062 strlen (function_name) TSRMLS_CC);
1063
1064 if (fcic->function_handler == NULL)
1065 {
1066 phc_setup_error (1, filename, line_number, NULL TSRMLS_CC);
1067 php_error_docref (NULL TSRMLS_CC, E_ERROR,
1068 "Call to undefined method %s::%s",
1069 obj_ce->name, function_name);
1070 }
1071 }
1072
1073 /*
1074 * Like initialize_method_call, but return 0 if no constructor is defined
1075 * rather than giving an error.
1076 */
1077
1078 static int
1079 initialize_constructor_call (zend_fcall_info * fci,
1080 zend_fcall_info_cache * fcic, zval ** obj,
1081 char *filename, int line_number TSRMLS_DC)
1082 {
1083 if (fcic->initialized)
1084 return;
1085
1086 zend_class_entry *obj_ce;
1087 obj_ce = Z_OBJCE_PP (obj);
1088
1089 /*
1090 * we do not initialize fci.
1091 * function_table -- not initialized by zend_call_method
1092 * function_name -- zend_call_method initializes this to a pointer to
1093 * a zval 'z_fname', but does not initialize z_fname
1094 * in case of a method invocation
1095 * retval_ptr_ptr -- should be initialized by caller
1096 * param_count -- should be initialized by caller
1097 * params -- should be initialized by caller
1098 */
1099 fci->size = sizeof (*fci);
1100 fci->object_pp = obj;
1101 fci->no_separation = 1;
1102 fci->symbol_table = NULL;
1103
1104 fcic->initialized = 1;
1105 fcic->calling_scope = obj_ce;
1106 fcic->object_pp = obj;
1107 fcic->function_handler
1108 = Z_OBJ_HT_PP (obj)->get_constructor (*obj TSRMLS_CC);
1109
1110 return (fcic->function_handler != NULL);
1111 }
1112 // vi:set ts=8:
1113
1114 /*
1115 * Creates a copy of *in using persistent memory, optionally destroying *in
1116 *
1117 * Does not work for objects/resources and will loop on self-recursive arrays.
1118 */
1119
1120 zval *
1121 persistent_clone (zval * in, int destroy_in TSRMLS_DC)
1122 {
1123 zval *out = pemalloc (sizeof (zval), 1);
1124 *out = *in;
1125
1126 switch (Z_TYPE_P (in))
1127 {
1128 case IS_NULL:
1129 case IS_LONG:
1130 case IS_DOUBLE:
1131 case IS_BOOL:
1132 /* nothing more to be done */
1133 break;
1134 case IS_STRING:
1135 Z_STRVAL_P (out) = pemalloc (Z_STRLEN_P (in) + 1, 1);
1136 memcpy (Z_STRVAL_P (out), Z_STRVAL_P (in), Z_STRLEN_P (in) + 1);
1137 break;
1138 case IS_ARRAY:
1139 {
1140 HashTable *old_arr = Z_ARRVAL_P (in);
1141 HashTable *new_arr = pemalloc (sizeof (HashTable), 1);
1142 zend_hash_init (new_arr, old_arr->nNumOfElements, NULL, ZVAL_PTR_DTOR,
1143 /* persistent */ 1);
1144
1145 for (zend_hash_internal_pointer_reset (old_arr);
1146 zend_hash_has_more_elements (old_arr) == SUCCESS;
1147 zend_hash_move_forward (old_arr))
1148 {
1149 char *key;
1150 uint keylen;
1151 ulong idx;
1152 int type;
1153 zval **old_elem, *new_elem;
1154
1155 type =
1156 zend_hash_get_current_key_ex (old_arr, &key, &keylen, &idx, 0,
1157 NULL);
1158 assert (zend_hash_get_current_data
1159 (old_arr, (void **) &old_elem) == SUCCESS);
1160
1161 new_elem = persistent_clone (*old_elem, destroy_in TSRMLS_CC);
1162
1163 if (type == HASH_KEY_IS_STRING)
1164 zend_hash_add (new_arr, key, keylen, &new_elem, sizeof (zval *),
1165 NULL);
1166 else
1167 zend_hash_index_update (new_arr, idx, &new_elem,
1168 sizeof (zval *), NULL);
1169
1170 }
1171
1172 Z_ARRVAL_P (out) = new_arr;
1173 }
1174 break;
1175 default:
1176 /* other types are not supported */
1177 assert (0);
1178 }
1179
1180 zval_ptr_dtor (&in);
1181 return out;
1182 }
1183
1184 /*
1185 * Wrapper around zend_declare_property which
1186 *
1187 * - Asserts that the ZEND_INTERNAL_CLASS flag is cleared
1188 * (otherwise we cannot add complex (i.e., array) properties)
1189 * - Creates a persistent clone of the property to be added before
1190 * calling zend_declare_property, since the memory for this property
1191 * should only be deallocated when the module is shut down
1192 * (and not when the request finishes)
1193 * - Cleans up after zend_declare_property by re-allocating the name of
1194 * the property using persistent memory, for much the same reason
1195 */
1196
1197 static int
1198 phc_declare_property (zend_class_entry * ce, char *name, int name_length,
1199 zval * property, int access_type TSRMLS_DC)
1200 {
1201 assert (!(ce->type & ZEND_INTERNAL_CLASS));
1202 assert (zend_declare_property
1203 (ce, name, name_length, persistent_clone (property, 1 TSRMLS_CC),
1204 access_type TSRMLS_CC) == SUCCESS);
1205
1206 zend_property_info *property_info;
1207 assert (zend_hash_find
1208 (&ce->properties_info, name, name_length + 1,
1209 (void **) &property_info) == SUCCESS);
1210 efree (property_info->name);
1211 property_info->name = name;
1212
1213 return SUCCESS;
1214 }
1215
1216 // vi:set ts=8:
1217
1218
1219 static void
1220 cast_var (zval ** p_zvp, int type)
1221 {
1222 assert (type >= 0 && type <= 6);
1223 if ((*p_zvp)->type == type)
1224 return;
1225
1226 sep_copy_on_write (p_zvp);
1227 zval *zvp = *p_zvp;
1228
1229 switch (type)
1230 {
1231 case IS_NULL:
1232 convert_to_null (zvp);
1233 break;
1234 case IS_BOOL:
1235 convert_to_boolean (zvp);
1236 break;
1237 case IS_LONG:
1238 convert_to_long (zvp);
1239 break;
1240 case IS_DOUBLE:
1241 convert_to_double (zvp);
1242 break;
1243 case IS_STRING:
1244 convert_to_string (zvp);
1245 break;
1246 case IS_ARRAY:
1247 convert_to_array (zvp);
1248 break;
1249 case IS_OBJECT:
1250 convert_to_object (zvp);
1251 break;
1252 default:
1253 assert (0); // TODO unimplemented
1254 break;
1255 }
1256 }
1257
1258 /* Copies a constant into ZVP. Note that LENGTH does not include the NULL-terminating byte. */
1259 static void
1260 get_constant (char *name, int length, zval ** p_zvp TSRMLS_DC)
1261 {
1262 MAKE_STD_ZVAL (*p_zvp);
1263 // zend_get_constant returns 1 for success, not SUCCESS
1264 int result = zend_get_constant (name, length, *p_zvp TSRMLS_CC);
1265 if (result == 0)
1266 ZVAL_STRINGL (*p_zvp, name, length, 1);
1267 }
1268
1269 /* The function call mechanism deals specially with EG(uninitialize_zval_ptr)
1270 * (or sometime EG(uninitialize_zval)), so we need to use this too. This
1271 * particular zval can also be set, but there is an implicit guarantee
1272 * of the information below.
1273 *
1274 * If assertions are off, this should be inlined to nothing.
1275 */
1276 static void
1277 phc_check_invariants (TSRMLS_D)
1278 {
1279 assert (EG (uninitialized_zval_ptr) == &EG (uninitialized_zval));
1280 assert (EG (uninitialized_zval).refcount >= 1);
1281 assert (EG (uninitialized_zval).value.lval == 0);
1282 assert (EG (uninitialized_zval).type == IS_NULL);
1283 assert (EG (uninitialized_zval).is_ref == 0);
1284 }
1285
1286
1287 static int
1288 check_unset_index_type (zval * ind TSRMLS_DC)
1289 {
1290 if (Z_TYPE_P (ind) == IS_OBJECT || Z_TYPE_P (ind) == IS_ARRAY)
1291 {
1292 php_error_docref (NULL TSRMLS_CC, E_WARNING,
1293 "Illegal offset type in unset");
1294 return 0;
1295 }
1296
1297 return 1;
1298 }
1299
1300
1301
1302 /*
1303 * unset
1304 */
1305
1306 static void
1307 unset_var (HashTable * st, char *name, int length)
1308 {
1309 zend_hash_del (st, name, length);
1310 }
1311
1312 static void
1313 unset_array (zval ** p_var, zval * ind TSRMLS_DC)
1314 {
1315 // NO error required
1316 if (Z_TYPE_PP (p_var) != IS_ARRAY)
1317 {
1318 if (Z_TYPE_PP (p_var) == IS_STRING)
1319 {
1320 php_error_docref (NULL TSRMLS_CC, E_ERROR,
1321 "Cannot unset string offsets");
1322 }
1323 else if (Z_TYPE_PP (p_var) != IS_NULL)
1324 {
1325 php_error_docref (NULL TSRMLS_CC, E_WARNING,
1326 "Cannot unset offsets in a non-array variable");
1327 }
1328
1329 return;
1330 }
1331
1332 // if its not an array, make it an array
1333 HashTable *ht = Z_ARRVAL_P (*p_var);
1334
1335 ht_delete (ht, ind);
1336 }
1337
1338 /*
1339 * Lookup variable whose name is var_var in st. We do not call
1340 * ht_find because ht_find uses zend_symtable_find to search for strings
1341 * rather than zend_hash_find. The difference is that zend_symtable_find
1342 * will convert strings to integers where possible: arrays are always
1343 * integer-indexed if at all possible. Variable names however should
1344 * _always_ be treated as strings.
1345 *
1346 */
1347
1348 /*
1349 * If the parameter is a string, returns the parameter, with the refcount
1350 * incremented. If its not a string, returns a new zval, with a refcount of
1351 * 1. Either way, zval_dtor_ptr must be run by the caller on the return
1352 * value.
1353 */
1354 zval*
1355 get_string_val (zval* zvp)
1356 {
1357 if (Z_TYPE_P (zvp) == IS_STRING)
1358 {
1359 zvp->refcount++;
1360 return zvp;
1361 }
1362 else
1363 {
1364 zval* clone = zvp_clone_ex (zvp);
1365 convert_to_string (clone);
1366 return clone;
1367 }
1368 }
1369
1370 zval **
1371 get_var_var (HashTable * st, zval * index TSRMLS_DC)
1372 {
1373 zval* str_index = get_string_val (index);
1374 char* name = Z_STRVAL_P (str_index);
1375 int length = Z_STRLEN_P (str_index) + 1;
1376 unsigned long hash = zend_get_hash_value (name, length);
1377
1378 zval** result = get_st_entry (st, name, length, hash TSRMLS_CC);
1379 zval_ptr_dtor (&str_index);
1380 return result;
1381 }
1382
1383 /*
1384 * Read the variable described by var_var from symbol table st
1385 * See comments for get_var_var
1386 */
1387 zval *
1388 read_var_var (HashTable * st, zval * index TSRMLS_DC)
1389 {
1390 zval* str_index = get_string_val (index);
1391 char* name = Z_STRVAL_P (str_index);
1392 int length = Z_STRLEN_P (str_index) + 1;
1393 unsigned long hash = zend_get_hash_value (name, length);
1394
1395 zval* result = read_var (st, name, length, hash TSRMLS_CC);
1396 zval_ptr_dtor (&str_index);
1397 return result;
1398 }
1399
1400 static void
1401 phc_builtin_eval (zval * arg, zval ** p_result, char *filename TSRMLS_DC)
1402 {
1403 // If the user wrote "return ..", we need to store the
1404 // return value; however, in that case, zend_eval_string
1405 // will slap an extra "return" onto the front of the string,
1406 // so we must remove the "return" from the string the user
1407 // wrote. If the user did not write "return", he is not
1408 // interested in the return value, and we must pass NULL
1409 // instead or rhs to avoid zend_eval_string adding "return".
1410
1411 // convert to a string
1412 // TODO avoid allocation
1413 zval *copy = zvp_clone_ex (arg);
1414 convert_to_string (copy);
1415
1416 if (*p_result && !strncmp (Z_STRVAL_P (copy), "return ", 7))
1417 {
1418 zend_eval_string (Z_STRVAL_P (copy) + 7, *p_result,
1419 "eval'd code" TSRMLS_CC);
1420 }
1421 else
1422 {
1423 zend_eval_string (Z_STRVAL_P (copy), NULL, "eval'd code" TSRMLS_CC);
1424 }
1425
1426 // cleanup
1427 assert (copy->refcount == 1);
1428 zval_ptr_dtor (&copy);
1429 }
1430
1431 static void
1432 phc_builtin_exit (zval * arg, zval ** p_result, char *filename TSRMLS_DC)
1433 {
1434 if (Z_TYPE_P (arg) == IS_LONG)
1435 EG (exit_status) = Z_LVAL_P (arg);
1436 else
1437 zend_print_variable (arg);
1438
1439 zend_bailout ();
1440 }
1441
1442 static void
1443 phc_builtin_die (zval * arg, zval ** p_result, char *filename TSRMLS_DC)
1444 {
1445 phc_builtin_exit (arg, p_result, filename TSRMLS_CC);
1446 }
1447
1448 static void
1449 phc_builtin_echo (zval * arg, zval ** p_result TSRMLS_DC)
1450 {
1451 assert (*p_result == NULL);
1452 zend_print_variable (arg);
1453 }
1454
1455 static void
1456 phc_builtin_print (zval * arg, zval ** p_result, char *filename TSRMLS_DC)
1457 {
1458 zval *echo_arg = NULL;
1459 phc_builtin_echo (arg, &echo_arg TSRMLS_CC);
1460
1461 if (*p_result)
1462 ZVAL_LONG (*p_result, 1);
1463 }
1464
1465 // TODO is there a memory leak here is result has a value?
1466 // TOOD isnt this just the same as isset
1467 static void
1468 phc_builtin_empty (zval * arg, zval ** p_result, char *filename TSRMLS_DC)
1469 {
1470 assert (*p_result);
1471 ZVAL_BOOL (*p_result, !zend_is_true (arg));
1472 }
1473
1474 // For require, include, require_once and include_once.
1475
1476 // Include:
1477 // return 1 for success
1478 // Warning, and return false for failure
1479 // Require:
1480 // return 1 for success
1481 // Fail for failure
1482 // Include_once
1483 // Return true if already included
1484 // Return 1 for success
1485 // Warning and return false for failure
1486 // Require_once:
1487 // Return true if already included
1488 // return 1 for success
1489 // Fail for failure
1490 //
1491 static void
1492 include_backend (zval * arg, zval ** p_result, char *filename, int type, int is_once, char* error, char* error_function TSRMLS_DC)
1493 {
1494 // In the event that the Zend engine cannot find the file, after checking the
1495 // include path, it tries the current directory. It does this only if the
1496 // interpreter is executing, and it checks the interpreters opcodes for a
1497 // filename (see streams/plain_wrapper.c:1352)
1498
1499 // An alternative is to add the directory to include_path, but its
1500 // semantically incorrect (get_included_path() would give the wrong answer),
1501 // and error prone (if people overwrite include_path).
1502 // TODO: though we could add it for this function only
1503
1504 assert (EG (active_op_array) == NULL);
1505 assert (filename != NULL);
1506
1507 zval *arg_file = arg;
1508 // Check we have a string
1509 if (Z_TYPE_P (arg_file) != IS_STRING)
1510 {
1511 arg_file = zvp_clone_ex (arg_file);
1512 convert_to_string (arg_file);
1513 }
1514
1515 zend_file_handle handle;
1516 zend_op_array* new_op_array;
1517 zend_function zf;
1518
1519 // Check the _ONCE varieties (based on zend_vm_def.h)
1520 if (is_once)
1521 {
1522 if (IS_ABSOLUTE_PATH (Z_STRVAL_P (arg_file), Z_STRLEN_P (arg_file)))
1523 {
1524 // Get the proper path name for require
1525 cwd_state state;
1526
1527 state.cwd_length = 0;
1528 state.cwd = malloc(1);
1529 state.cwd[0] = 0;
1530 int success = !virtual_file_ex(&state, Z_STRVAL_P(arg_file), NULL, 1)
1531 && zend_hash_exists(&EG(included_files), state.cwd,
1532 state.cwd_length+1);
1533
1534 free (state.cwd);
1535
1536 if (!success)
1537 goto cleanup;
1538 }
1539 }
1540
1541
1542 // Compile the file
1543 // Pretend the interpreter is running
1544 EG (in_execution) = 1;
1545
1546 int success = zend_stream_open (Z_STRVAL_P (arg_file), &handle TSRMLS_CC);
1547
1548 // Stop pretending
1549 EG (in_execution) = 0;
1550 EG (active_op_array) = NULL;
1551
1552 if (success != SUCCESS)
1553 goto fail;
1554
1555
1556 if (is_once)
1557 {
1558 // Check it hadnt been included already
1559 int once_success = zend_hash_add_empty_element(&EG(included_files),
1560 handle.opened_path,
1561 strlen (handle.opened_path)+1);
1562 // Return true
1563 if (once_success != SUCCESS)
1564 {
1565 ZVAL_BOOL (*p_result, 1);
1566 goto cleanup;
1567 }
1568 }
1569
1570 if (!handle.opened_path)
1571 handle.opened_path = estrndup (Z_STRVAL_P(arg_file), Z_STRLEN_P (arg_file));
1572
1573 // run it
1574 success = zend_execute_scripts (type TSRMLS_CC, p_result, 1, &handle);
1575 assert (success == SUCCESS);
1576 zend_stream_close (&handle);
1577
1578 // Success
1579 if (*p_result)
1580 ZVAL_LONG (*p_result, 1);
1581
1582
1583 goto cleanup;
1584
1585
1586 fail:
1587
1588 php_error_docref (error_function
1589 TSRMLS_CC,
1590 (type == ZEND_INCLUDE) ? E_WARNING : E_ERROR,
1591 error,
1592 php_strip_url_passwd (Z_STRVAL_P (arg_file)),
1593 STR_PRINT (PG (include_path)));
1594
1595
1596 // Failure
1597 if (*p_result)
1598 ZVAL_BOOL (*p_result, 0);
1599
1600 cleanup:
1601
1602 if (handle.opened_path)
1603 efree (handle.opened_path);
1604 zend_destroy_file_handle (&handle TSRMLS_CC);
1605
1606
1607 if (arg != arg_file)
1608 zval_ptr_dtor (&arg_file);
1609 }
1610
1611 static void
1612 phc_builtin_include (zval * arg, zval ** p_result, char *filename TSRMLS_DC)
1613 {
1614 include_backend ( arg,
1615 p_result,
1616 filename,
1617 ZEND_INCLUDE,
1618 0,
1619 "Failed opening '%s' for inclusion (include_path='%s')",
1620 "function.include"
1621 TSRMLS_CC);
1622 }
1623
1624 static void
1625 phc_builtin_require (zval * arg, zval ** p_result, char *filename TSRMLS_DC)
1626 {
1627 include_backend ( arg,
1628 p_result,
1629 filename,
1630 ZEND_REQUIRE,
1631 0,
1632 "Failed opening required '%s' (include_path='%s')",
1633 "function.require"
1634 TSRMLS_CC);
1635 }
1636
1637 static void
1638 phc_builtin_include_once (zval * arg, zval ** p_result, char *filename TSRMLS_DC)
1639 {
1640 include_backend ( arg,
1641 p_result,
1642 filename,
1643 ZEND_INCLUDE,
1644 1,
1645 "Failed opening '%s' for inclusion (include_path='%s')",
1646 "function.include_once"
1647 TSRMLS_CC);
1648 }
1649
1650 static void
1651 phc_builtin_require_once (zval * arg, zval ** p_result, char *filename TSRMLS_DC)
1652 {
1653 include_backend ( arg,
1654 p_result,
1655 filename,
1656 ZEND_REQUIRE,
1657 1,
1658 "Failed opening required '%s' (include_path='%s')",
1659 "function.require_once"
1660 TSRMLS_CC);
1661 }
1662
1663 // END INCLUDED FILES
1664 int saved_refcount;
1665 static zend_fcall_info array_keys_fci;
1666 static zend_fcall_info_cache array_keys_fcic = {0,NULL,NULL,NULL};
1667 static zend_fcall_info is_null_fci;
1668 static zend_fcall_info_cache is_null_fcic = {0,NULL,NULL,NULL};
1669 static zend_fcall_info version_compare_fci;
1670 static zend_fcall_info_cache version_compare_fcic = {0,NULL,NULL,NULL};
1671 static zend_fcall_info wfsetvar_fci;
1672 static zend_fcall_info_cache wfsetvar_fcic = {0,NULL,NULL,NULL};
1673 // class ParserOutput
1674 // {
1675 // var $mText = NULL;
1676 // var $mLanguageLinks = NULL;
1677 // var $mCategories = NULL;
1678 // var $mContainsOldMagic = NULL;
1679 // var $mTitleText = NULL;
1680 // var $mCacheTime = '';
1681 // var $mVersion = Parser::VERSION;
1682 // var $mLinks = array();
1683 // var $mTemplates = array();
1684 // var $mTemplateIds = array();
1685 // var $mImages = array();
1686 // var $mExternalLinks = array();
1687 // var $mNewSection = False;
1688 // var $mNoGallery = False;
1689 // var $mHeadItems = array();
1690 // var $mOutputHooks = array();
1691 // var $mWarnings = array();
1692 // var $mSections = array();
1693 // var $mProperties = array();
1694 // private $mIndexPolicy = '';
1695 // private $displayTitle = False;
1696 // function parseroutput($text = '', $languageLinks = array(), $categoryLinks = array(), $containsOldMagic = False, $titletext = '')
1697 // {
1698 // $this->mText = $text;
1699 // $this->mLanguageLinks = $languageLinks;
1700 // $this->mCategories = $categoryLinks;
1701 // $this->mContainsOldMagic = $containsOldMagic;
1702 // $this->mTitleText = $titletext;
1703 // }
1704 // function gettext()
1705 // {
1706 // $TSt9 = $this->mText;
1707 // return $TSt9;
1708 // }
1709 // function &getlanguagelinks()
1710 // {
1711 // $TSt10 =& $this->mLanguageLinks;
1712 // return $TSt10;
1713 // }
1714 // function getcategorylinks()
1715 // {
1716 // $TLE100 = param_is_ref (NULL, "array_keys", 0);
1717 // ;
1718 // if (TLE100) goto L128 else goto L129;
1719 // L128:
1720 // $TMIt99 =& $this->mCategories;
1721 // goto L130;
1722 // L129:
1723 // $TMIt99 = $this->mCategories;
1724 // goto L130;
1725 // L130:
1726 // $TLE11 = array_keys($TMIt99);
1727 // return $TLE11;
1728 // }
1729 // function &getcategories()
1730 // {
1731 // $TSt12 =& $this->mCategories;
1732 // return $TSt12;
1733 // }
1734 // function getcachetime()
1735 // {
1736 // $TSt13 = $this->mCacheTime;
1737 // return $TSt13;
1738 // }
1739 // function gettitletext()
1740 // {
1741 // $TSt14 = $this->mTitleText;
1742 // return $TSt14;
1743 // }
1744 // function getsections()
1745 // {
1746 // $TSt15 = $this->mSections;
1747 // return $TSt15;
1748 // }
1749 // function &getlinks()
1750 // {
1751 // $TSt16 =& $this->mLinks;
1752 // return $TSt16;
1753 // }
1754 // function &gettemplates()
1755 // {
1756 // $TSt17 =& $this->mTemplates;
1757 // return $TSt17;
1758 // }
1759 // function &getimages()
1760 // {
1761 // $TSt18 =& $this->mImages;
1762 // return $TSt18;
1763 // }
1764 // function &getexternallinks()
1765 // {
1766 // $TSt19 =& $this->mExternalLinks;
1767 // return $TSt19;
1768 // }
1769 // function getnogallery()
1770 // {
1771 // $TSt20 = $this->mNoGallery;
1772 // return $TSt20;
1773 // }
1774 // function getsubtitle()
1775 // {
1776 // $TSt21 = $this->mSubtitle;
1777 // return $TSt21;
1778 // }
1779 // function getoutputhooks()
1780 // {
1781 // $TSt22 = $this->mOutputHooks;
1782 // $TLE23 = (array) $TSt22;
1783 // return $TLE23;
1784 // }
1785 // function getwarnings()
1786 // {
1787 // $TLE102 = param_is_ref (NULL, "array_keys", 0);
1788 // ;
1789 // if (TLE102) goto L131 else goto L132;
1790 // L131:
1791 // $TMIt101 =& $this->mWarnings;
1792 // goto L133;
1793 // L132:
1794 // $TMIt101 = $this->mWarnings;
1795 // goto L133;
1796 // L133:
1797 // $TLE24 = array_keys($TMIt101);
1798 // return $TLE24;
1799 // }
1800 // function getindexpolicy()
1801 // {
1802 // $TSt25 = $this->mIndexPolicy;
1803 // return $TSt25;
1804 // }
1805 // function containsoldmagic()
1806 // {
1807 // $TSt26 = $this->mContainsOldMagic;
1808 // return $TSt26;
1809 // }
1810 // function settext($text)
1811 // {
1812 // $TLE104 = param_is_ref (NULL, "wfsetvar", 0);
1813 // ;
1814 // if (TLE104) goto L134 else goto L135;
1815 // L134:
1816 // $TMIt103 =& $this->mText;
1817 // goto L136;
1818 // L135:
1819 // $TMIt103 = $this->mText;
1820 // goto L136;
1821 // L136:
1822 // $TLE27 = wfsetvar($TMIt103, $text);
1823 // return $TLE27;
1824 // }
1825 // function setlanguagelinks($ll)
1826 // {
1827 // $TLE106 = param_is_ref (NULL, "wfsetvar", 0);
1828 // ;
1829 // if (TLE106) goto L137 else goto L138;
1830 // L137:
1831 // $TMIt105 =& $this->mLanguageLinks;
1832 // goto L139;
1833 // L138:
1834 // $TMIt105 = $this->mLanguageLinks;
1835 // goto L139;
1836 // L139:
1837 // $TLE28 = wfsetvar($TMIt105, $ll);
1838 // return $TLE28;
1839 // }
1840 // function setcategorylinks($cl)
1841 // {
1842 // $TLE108 = param_is_ref (NULL, "wfsetvar", 0);
1843 // ;
1844 // if (TLE108) goto L140 else goto L141;
1845 // L140:
1846 // $TMIt107 =& $this->mCategories;
1847 // goto L142;
1848 // L141:
1849 // $TMIt107 = $this->mCategories;
1850 // goto L142;
1851 // L142:
1852 // $TLE29 = wfsetvar($TMIt107, $cl);
1853 // return $TLE29;
1854 // }
1855 // function setcontainsoldmagic($com)
1856 // {
1857 // $TLE110 = param_is_ref (NULL, "wfsetvar", 0);
1858 // ;
1859 // if (TLE110) goto L143 else goto L144;
1860 // L143:
1861 // $TMIt109 =& $this->mContainsOldMagic;
1862 // goto L145;
1863 // L144:
1864 // $TMIt109 = $this->mContainsOldMagic;
1865 // goto L145;
1866 // L145:
1867 // $TLE30 = wfsetvar($TMIt109, $com);
1868 // return $TLE30;
1869 // }
1870 // function setcachetime($t)
1871 // {
1872 // $TLE112 = param_is_ref (NULL, "wfsetvar", 0);
1873 // ;
1874 // if (TLE112) goto L146 else goto L147;
1875 // L146:
1876 // $TMIt111 =& $this->mCacheTime;
1877 // goto L148;
1878 // L147:
1879 // $TMIt111 = $this->mCacheTime;
1880 // goto L148;
1881 // L148:
1882 // $TLE31 = wfsetvar($TMIt111, $t);
1883 // return $TLE31;
1884 // }
1885 // function settitletext($t)
1886 // {
1887 // $TLE114 = param_is_ref (NULL, "wfsetvar", 0);
1888 // ;
1889 // if (TLE114) goto L149 else goto L150;
1890 // L149:
1891 // $TMIt113 =& $this->mTitleText;
1892 // goto L151;
1893 // L150:
1894 // $TMIt113 = $this->mTitleText;
1895 // goto L151;
1896 // L151:
1897 // $TLE32 = wfsetvar($TMIt113, $t);
1898 // return $TLE32;
1899 // }
1900 // function setsections($toc)
1901 // {
1902 // $TLE116 = param_is_ref (NULL, "wfsetvar", 0);
1903 // ;
1904 // if (TLE116) goto L152 else goto L153;
1905 // L152:
1906 // $TMIt115 =& $this->mSections;
1907 // goto L154;
1908 // L153:
1909 // $TMIt115 = $this->mSections;
1910 // goto L154;
1911 // L154:
1912 // $TLE33 = wfsetvar($TMIt115, $toc);
1913 // return $TLE33;
1914 // }
1915 // function setindexpolicy($policy)
1916 // {
1917 // $TLE118 = param_is_ref (NULL, "wfsetvar", 0);
1918 // ;
1919 // if (TLE118) goto L155 else goto L156;
1920 // L155:
1921 // $TMIt117 =& $this->mIndexPolicy;
1922 // goto L157;
1923 // L156:
1924 // $TMIt117 = $this->mIndexPolicy;
1925 // goto L157;
1926 // L157:
1927 // $TLE34 = wfsetvar($TMIt117, $policy);
1928 // return $TLE34;
1929 // }
1930 // function addcategory($c, $sort)
1931 // {
1932 // $TSt35 =& $this->mCategories;
1933 // $TSt35[$c] = $sort;
1934 // }
1935 // function addlanguagelink($t)
1936 // {
1937 // $TSt36 =& $this->mLanguageLinks;
1938 // $TSt36[] = $t;
1939 // }
1940 // function addexternallink($url)
1941 // {
1942 // $TSt37 =& $this->mExternalLinks;
1943 // $TLE38 = 1;
1944 // $TSt37[$url] = $TLE38;
1945 // }
1946 // function addwarning($s)
1947 // {
1948 // $TSt39 =& $this->mWarnings;
1949 // $TLE40 = 1;
1950 // $TSt39[$s] = $TLE40;
1951 // }
1952 // function addoutputhook($hook, $data = False)
1953 // {
1954 // $TSt41 =& $this->mOutputHooks;
1955 // unset($TSa42);
1956 // $TSa42 = (array) $TSa42;
1957 // $TSa42[] = $hook;
1958 // $TSa42[] = $data;
1959 // $TSt41[] = $TSa42;
1960 // }
1961 // function setnewsection($value)
1962 // {
1963 // $TLE43 = (bool) $value;
1964 // $this->mNewSection = $TLE43;
1965 // }
1966 // function getnewsection()
1967 // {
1968 // $TSt44 = $this->mNewSection;
1969 // $TLE45 = (bool) $TSt44;
1970 // return $TLE45;
1971 // }
1972 // function addlink($title, $id = NULL)
1973 // {
1974 // $ns = $title->getnamespace();
1975 // $dbk = $title->getdbkey();
1976 // $TLE46 = NS_MEDIA;
1977 // $TLE47 = ($ns == $TLE46);
1978 // if (TLE47) goto L164 else goto L165;
1979 // L164:
1980 // $ns = NS_FILE;
1981 // goto L166;
1982 // L165:
1983 // $TLE48 = NS_SPECIAL;
1984 // $TLE49 = ($ns == $TLE48);
1985 // if (TLE49) goto L161 else goto L162;
1986 // L161:
1987 // $TLE50 = NULL;
1988 // return $TLE50;
1989 // goto L163;
1990 // L162:
1991 // $TLE51 = '';
1992 // $TLE52 = ($dbk === $TLE51);
1993 // if (TLE52) goto L158 else goto L159;
1994 // L158:
1995 // $TLE53 = NULL;
1996 // return $TLE53;
1997 // goto L160;
1998 // L159:
1999 // goto L160;
2000 // L160:
2001 // goto L163;
2002 // L163:
2003 // goto L166;
2004 // L166:
2005 // $TMIt119 = $this->mLinks;
2006 // $TLE54 = isset($TMIt119[$ns]);
2007 // $TLE55 = !$TLE54;
2008 // if (TLE55) goto L167 else goto L168;
2009 // L167:
2010 // $TSt56 =& $this->mLinks;
2011 // unset($TSa57);
2012 // $TSa57 = (array) $TSa57;
2013 // $TSt56[$ns] = $TSa57;
2014 // goto L169;
2015 // L168:
2016 // goto L169;
2017 // L169:
2018 // $TLE58 = is_null($id);
2019 // if (TLE58) goto L170 else goto L171;
2020 // L170:
2021 // $id = $title->getarticleid();
2022 // goto L172;
2023 // L171:
2024 // goto L172;
2025 // L172:
2026 // $TSt59 =& $this->mLinks;
2027 // $TSi60 =& $TSt59[$ns];
2028 // $TSi60[$dbk] = $id;
2029 // }
2030 // function addimage($name)
2031 // {
2032 // $TSt61 =& $this->mImages;
2033 // $TLE62 = 1;
2034 // $TSt61[$name] = $TLE62;
2035 // }
2036 // function addtemplate($title, $page_id, $rev_id)
2037 // {
2038 // $ns = $title->getnamespace();
2039 // $dbk = $title->getdbkey();
2040 // $TMIt120 = $this->mTemplates;
2041 // $TLE63 = isset($TMIt120[$ns]);
2042 // $TLE64 = !$TLE63;
2043 // if (TLE64) goto L173 else goto L174;
2044 // L173:
2045 // $TSt65 =& $this->mTemplates;
2046 // unset($TSa66);
2047 // $TSa66 = (array) $TSa66;
2048 // $TSt65[$ns] = $TSa66;
2049 // goto L175;
2050 // L174:
2051 // goto L175;
2052 // L175:
2053 // $TSt67 =& $this->mTemplates;
2054 // $TSi68 =& $TSt67[$ns];
2055 // $TSi68[$dbk] = $page_id;
2056 // $TMIt121 = $this->mTemplateIds;
2057 // $TLE69 = isset($TMIt121[$ns]);
2058 // $TLE70 = !$TLE69;
2059 // if (TLE70) goto L176 else goto L177;
2060 // L176:
2061 // $TSt71 =& $this->mTemplateIds;
2062 // unset($TSa72);
2063 // $TSa72 = (array) $TSa72;
2064 // $TSt71[$ns] = $TSa72;
2065 // goto L178;
2066 // L177:
2067 // goto L178;
2068 // L178:
2069 // $TSt73 =& $this->mTemplateIds;
2070 // $TSi74 =& $TSt73[$ns];
2071 // $TSi74[$dbk] = $rev_id;
2072 // }
2073 // function expired($touched)
2074 // {
2075 // global $wgCacheEpoch;
2076 // $TLE75 = $this->getcachetime();
2077 // $TLE76 = -1;
2078 // $TLE0 = ($TLE75 == $TLE76);
2079 // if (TLE0) goto L179 else goto L180;
2080 // L179:
2081 // $TEF1 = $TLE0;
2082 // goto L181;
2083 // L180:
2084 // $TLE77 = $this->getcachetime();
2085 // $TEF1 = ($TLE77 < $touched);
2086 // goto L181;
2087 // L181:
2088 // $TLE2 = (bool) $TEF1;
2089 // if (TLE2) goto L182 else goto L183;
2090 // L182:
2091 // $TEF3 = $TLE2;
2092 // goto L184;
2093 // L183:
2094 // $TLE78 = $this->getcachetime();
2095 // $TEF3 = ($TLE78 <= $wgCacheEpoch);
2096 // goto L184;
2097 // L184:
2098 // $TLE4 = (bool) $TEF3;
2099 // if (TLE4) goto L185 else goto L186;
2100 // L185:
2101 // $TEF5 = $TLE4;
2102 // goto L187;
2103 // L186:
2104 // $TMIt122 = $this->mVersion;
2105 // $TLE79 = isset($TMIt122);
2106 // $TEF5 = !$TLE79;
2107 // goto L187;
2108 // L187:
2109 // $TLE6 = (bool) $TEF5;
2110 // if (TLE6) goto L191 else goto L192;
2111 // L191:
2112 // $TEF7 = $TLE6;
2113 // goto L193;
2114 // L192:
2115 // $TLE80 = Parser::VERSION;
2116 // $TLE81 = 'lt';
2117 // $TLE124 = param_is_ref (NULL, "version_compare", 0);
2118 // ;
2119 // if (TLE124) goto L188 else goto L189;
2120 // L188:
2121 // $TMIt123 =& $this->mVersion;
2122 // goto L190;
2123 // L189:
2124 // $TMIt123 = $this->mVersion;
2125 // goto L190;
2126 // L190:
2127 // $TEF7 = version_compare($TMIt123, $TLE80, $TLE81);
2128 // goto L193;
2129 // L193:
2130 // $TLE82 = (bool) $TEF7;
2131 // return $TLE82;
2132 // }
2133 // function addheaditem($section, $tag = False)
2134 // {
2135 // $TLE83 = False;
2136 // $TLE84 = ($tag !== $TLE83);
2137 // if (TLE84) goto L194 else goto L195;
2138 // L194:
2139 // $TSt85 =& $this->mHeadItems;
2140 // $TSt85[$tag] = $section;
2141 // goto L196;
2142 // L195:
2143 // $TSt86 =& $this->mHeadItems;
2144 // $TSt86[] = $section;
2145 // goto L196;
2146 // L196:
2147 // }
2148 // public function setdisplaytitle($text)
2149 // {
2150 // $this->displayTitle = $text;
2151 // }
2152 // public function getdisplaytitle()
2153 // {
2154 // $TSt87 = $this->displayTitle;
2155 // return $TSt87;
2156 // }
2157 // public function setflag($flag)
2158 // {
2159 // $TSt88 =& $this->mFlags;
2160 // $TLE89 = True;
2161 // $TSt88[$flag] = $TLE89;
2162 // }
2163 // public function getflag($flag)
2164 // {
2165 // $TMIt125 = $this->mFlags;
2166 // $TLE90 = isset($TMIt125[$flag]);
2167 // return $TLE90;
2168 // }
2169 // public function setproperty($name, $value)
2170 // {
2171 // $TSt91 =& $this->mProperties;
2172 // $TSt91[$name] = $value;
2173 // }
2174 // public function getproperty($name)
2175 // {
2176 // $TMIt126 = $this->mProperties;
2177 // $TLE92 = isset($TMIt126[$name]);
2178 // if (TLE92) goto L197 else goto L198;
2179 // L197:
2180 // $TSt93 = $this->mProperties;
2181 // $TSi94 = $TSt93[$name];
2182 // $TEF8 = $TSi94;
2183 // goto L199;
2184 // L198:
2185 // $TEF8 = False;
2186 // goto L199;
2187 // L199:
2188 // return $TEF8;
2189 // }
2190 // public function getproperties()
2191 // {
2192 // $TMIt127 = $this->mProperties;
2193 // $TLE95 = isset($TMIt127);
2194 // $TLE96 = !$TLE95;
2195 // if (TLE96) goto L200 else goto L201;
2196 // L200:
2197 // unset($TSa97);
2198 // $TSa97 = (array) $TSa97;
2199 // $this->mProperties = $TSa97;
2200 // goto L202;
2201 // L201:
2202 // goto L202;
2203 // L202:
2204 // $TSt98 = $this->mProperties;
2205 // return $TSt98;
2206 // }
2207 // }
2208 // function parseroutput($text = '', $languageLinks = array(), $categoryLinks = array(), $containsOldMagic = False, $titletext = '')
2209 // {
2210 // $this->mText = $text;
2211 // $this->mLanguageLinks = $languageLinks;
2212 // $this->mCategories = $categoryLinks;
2213 // $this->mContainsOldMagic = $containsOldMagic;
2214 // $this->mTitleText = $titletext;
2215 // }
2216 PHP_METHOD(ParserOutput, parseroutput)
2217 {
2218 zval* local_categoryLinks = NULL;
2219 zval* local_containsOldMagic = NULL;
2220 zval* local_languageLinks = NULL;
2221 zval* local_text = NULL;
2222 zval* local_this = getThis();
2223 zval* local_titletext = NULL;
2224 // Add all parameters as local variables
2225 {
2226 int num_args = ZEND_NUM_ARGS ();
2227 zval* params[5];
2228 zend_get_parameters_array(0, num_args, params);
2229 // param 0
2230 if (num_args <= 0)
2231 {
2232 zval* default_value;
2233 {
2234 zval* local___static_value__ = NULL;
2235 // $__static_value__ = '';
2236 {
2237 if (local___static_value__ == NULL)
2238 {
2239 local___static_value__ = EG (uninitialized_zval_ptr);
2240 local___static_value__->refcount++;
2241 }
2242 zval** p_lhs = &local___static_value__;
2243
2244 zval* value;
2245 if ((*p_lhs)->is_ref)
2246 {
2247 // Always overwrite the current value
2248 value = *p_lhs;
2249 zval_dtor (value);
2250 }
2251 else
2252 {
2253 ALLOC_INIT_ZVAL (value);
2254 zval_ptr_dtor (p_lhs);
2255 *p_lhs = value;
2256 }
2257
2258 ZVAL_STRINGL(value, "", 0, 1);
2259
2260 phc_check_invariants (TSRMLS_C);
2261 }
2262 default_value = local___static_value__;
2263 assert(!default_value->is_ref);
2264 default_value->refcount++;
2265 if (local___static_value__ != NULL)
2266 {
2267 zval_ptr_dtor (&local___static_value__);
2268 }
2269 }
2270 default_value->refcount--;
2271 params[0] = default_value;
2272 }
2273 params[0]->refcount++;
2274 if (local_text != NULL)
2275 {
2276 zval_ptr_dtor (&local_text);
2277 }
2278 local_text = params[0];
2279 // param 1
2280 if (num_args <= 1)
2281 {
2282 zval* default_value;
2283 {
2284 zval* local_TSa203 = NULL;
2285 zval* local___static_value__ = NULL;
2286 // unset($TSa203);
2287 {
2288 if (local_TSa203 != NULL)
2289 {
2290 zval_ptr_dtor (&local_TSa203);
2291 local_TSa203 = NULL;
2292 }
2293 phc_check_invariants (TSRMLS_C);
2294 }
2295 // $TSa203 = (array) $TSa203;
2296 {
2297 if (local_TSa203 == NULL)
2298 {
2299 local_TSa203 = EG (uninitialized_zval_ptr);
2300 local_TSa203->refcount++;
2301 }
2302 zval** p_lhs = &local_TSa203;
2303
2304 zval* rhs;
2305 if (local_TSa203 == NULL)
2306 rhs = EG (uninitialized_zval_ptr);
2307 else
2308 rhs = local_TSa203;
2309
2310 if (*p_lhs != rhs)
2311 {
2312 if ((*p_lhs)->is_ref)
2313 overwrite_lhs (*p_lhs, rhs);
2314 else
2315 {
2316 zval_ptr_dtor (p_lhs);
2317 if (rhs->is_ref)
2318 {
2319 // Take a copy of RHS for LHS
2320 *p_lhs = zvp_clone_ex (rhs);
2321 }
2322 else
2323 {
2324 // Share a copy
2325 rhs->refcount++;
2326 *p_lhs = rhs;
2327 }
2328
2329 }
2330
2331 }
2332
2333 assert (IS_ARRAY >= 0 && IS_ARRAY <= 6);
2334 if ((*p_lhs)->type != IS_ARRAY)
2335 {
2336 sep_copy_on_write (p_lhs);
2337 convert_to_array (*p_lhs);
2338 }
2339
2340 phc_check_invariants (TSRMLS_C);
2341 }
2342 // $__static_value__ = $TSa203;
2343 {
2344 if (local___static_value__ == NULL)
2345 {
2346 local___static_value__ = EG (uninitialized_zval_ptr);
2347 local___static_value__->refcount++;
2348 }
2349 zval** p_lhs = &local___static_value__;
2350
2351 zval* rhs;
2352 if (local_TSa203 == NULL)
2353 rhs = EG (uninitialized_zval_ptr);
2354 else
2355 rhs = local_TSa203;
2356
2357 if (*p_lhs != rhs)
2358 {
2359 if ((*p_lhs)->is_ref)
2360 overwrite_lhs (*p_lhs, rhs);
2361 else
2362 {
2363 zval_ptr_dtor (p_lhs);
2364 if (rhs->is_ref)
2365 {
2366 // Take a copy of RHS for LHS
2367 *p_lhs = zvp_clone_ex (rhs);
2368 }
2369 else
2370 {
2371 // Share a copy
2372 rhs->refcount++;
2373 *p_lhs = rhs;
2374 }
2375
2376 }
2377
2378 }
2379 phc_check_invariants (TSRMLS_C);
2380 }
2381 default_value = local___static_value__;
2382 assert(!default_value->is_ref);
2383 default_value->refcount++;
2384 if (local_TSa203 != NULL)
2385 {
2386 zval_ptr_dtor (&local_TSa203);
2387 }
2388 if (local___static_value__ != NULL)
2389 {
2390 zval_ptr_dtor (&local___static_value__);
2391 }
2392 }
2393 default_value->refcount--;
2394 params[1] = default_value;
2395 }
2396 params[1]->refcount++;
2397 if (local_languageLinks != NULL)
2398 {
2399 zval_ptr_dtor (&local_languageLinks);
2400 }
2401 local_languageLinks = params[1];
2402 // param 2
2403 if (num_args <= 2)
2404 {
2405 zval* default_value;
2406 {
2407 zval* local_TSa204 = NULL;
2408 zval* local___static_value__ = NULL;
2409 // unset($TSa204);
2410 {
2411 if (local_TSa204 != NULL)
2412 {
2413 zval_ptr_dtor (&local_TSa204);
2414 local_TSa204 = NULL;
2415 }
2416 phc_check_invariants (TSRMLS_C);
2417 }
2418 // $TSa204 = (array) $TSa204;
2419 {
2420 if (local_TSa204 == NULL)
2421 {
2422 local_TSa204 = EG (uninitialized_zval_ptr);
2423 local_TSa204->refcount++;
2424 }
2425 zval** p_lhs = &local_TSa204;
2426
2427 zval* rhs;
2428 if (local_TSa204 == NULL)
2429 rhs = EG (uninitialized_zval_ptr);
2430 else
2431 rhs = local_TSa204;
2432
2433 if (*p_lhs != rhs)
2434 {
2435 if ((*p_lhs)->is_ref)
2436 overwrite_lhs (*p_lhs, rhs);
2437 else
2438 {
2439 zval_ptr_dtor (p_lhs);
2440 if (rhs->is_ref)
2441 {
2442 // Take a copy of RHS for LHS
2443 *p_lhs = zvp_clone_ex (rhs);
2444 }
2445 else
2446 {
2447 // Share a copy
2448 rhs->refcount++;
2449 *p_lhs = rhs;
2450 }
2451
2452 }
2453
2454 }
2455
2456 assert (IS_ARRAY >= 0 && IS_ARRAY <= 6);
2457 if ((*p_lhs)->type != IS_ARRAY)
2458 {
2459 sep_copy_on_write (p_lhs);
2460 convert_to_array (*p_lhs);
2461 }
2462
2463 phc_check_invariants (TSRMLS_C);
2464 }
2465 // $__static_value__ = $TSa204;
2466 {
2467 if (local___static_value__ == NULL)
2468 {
2469 local___static_value__ = EG (uninitialized_zval_ptr);
2470 local___static_value__->refcount++;
2471 }
2472 zval** p_lhs = &local___static_value__;
2473
2474 zval* rhs;
2475 if (local_TSa204 == NULL)
2476 rhs = EG (uninitialized_zval_ptr);
2477 else
2478 rhs = local_TSa204;
2479
2480 if (*p_lhs != rhs)
2481 {
2482 if ((*p_lhs)->is_ref)
2483 overwrite_lhs (*p_lhs, rhs);
2484 else
2485 {
2486 zval_ptr_dtor (p_lhs);
2487 if (rhs->is_ref)
2488 {
2489 // Take a copy of RHS for LHS
2490 *p_lhs = zvp_clone_ex (rhs);
2491 }
2492 else
2493 {
2494 // Share a copy
2495 rhs->refcount++;
2496 *p_lhs = rhs;
2497 }
2498
2499 }
2500
2501 }
2502 phc_check_invariants (TSRMLS_C);
2503 }
2504 default_value = local___static_value__;
2505 assert(!default_value->is_ref);
2506 default_value->refcount++;
2507 if (local_TSa204 != NULL)
2508 {
2509 zval_ptr_dtor (&local_TSa204);
2510 }
2511 if (local___static_value__ != NULL)
2512 {
2513 zval_ptr_dtor (&local___static_value__);
2514 }
2515 }
2516 default_value->refcount--;
2517 params[2] = default_value;
2518 }
2519 params[2]->refcount++;
2520 if (local_categoryLinks != NULL)
2521 {
2522 zval_ptr_dtor (&local_categoryLinks);
2523 }
2524 local_categoryLinks = params[2];
2525 // param 3
2526 if (num_args <= 3)
2527 {
2528 zval* default_value;
2529 {
2530 zval* local___static_value__ = NULL;
2531 // $__static_value__ = False;
2532 {
2533 if (local___static_value__ == NULL)
2534 {
2535 local___static_value__ = EG (uninitialized_zval_ptr);
2536 local___static_value__->refcount++;
2537 }
2538 zval** p_lhs = &local___static_value__;
2539
2540 zval* value;
2541 if ((*p_lhs)->is_ref)
2542 {
2543 // Always overwrite the current value
2544 value = *p_lhs;
2545 zval_dtor (value);
2546 }
2547 else
2548 {
2549 ALLOC_INIT_ZVAL (value);
2550 zval_ptr_dtor (p_lhs);
2551 *p_lhs = value;
2552 }
2553
2554 ZVAL_BOOL (value, 0);
2555
2556 phc_check_invariants (TSRMLS_C);
2557 }
2558 default_value = local___static_value__;
2559 assert(!default_value->is_ref);
2560 default_value->refcount++;
2561 if (local___static_value__ != NULL)
2562 {
2563 zval_ptr_dtor (&local___static_value__);
2564 }
2565 }
2566 default_value->refcount--;
2567 params[3] = default_value;
2568 }
2569 params[3]->refcount++;
2570 if (local_containsOldMagic != NULL)
2571 {
2572 zval_ptr_dtor (&local_containsOldMagic);
2573 }
2574 local_containsOldMagic = params[3];
2575 // param 4
2576 if (num_args <= 4)
2577 {
2578 zval* default_value;
2579 {
2580 zval* local___static_value__ = NULL;
2581 // $__static_value__ = '';
2582 {
2583 if (local___static_value__ == NULL)
2584 {
2585 local___static_value__ = EG (uninitialized_zval_ptr);
2586 local___static_value__->refcount++;
2587 }
2588 zval** p_lhs = &local___static_value__;
2589
2590 zval* value;
2591 if ((*p_lhs)->is_ref)
2592 {
2593 // Always overwrite the current value
2594 value = *p_lhs;
2595 zval_dtor (value);
2596 }
2597 else
2598 {
2599 ALLOC_INIT_ZVAL (value);
2600 zval_ptr_dtor (p_lhs);
2601 *p_lhs = value;
2602 }
2603
2604 ZVAL_STRINGL(value, "", 0, 1);
2605
2606 phc_check_invariants (TSRMLS_C);
2607 }
2608 default_value = local___static_value__;
2609 assert(!default_value->is_ref);
2610 default_value->refcount++;
2611 if (local___static_value__ != NULL)
2612 {
2613 zval_ptr_dtor (&local___static_value__);
2614 }
2615 }
2616 default_value->refcount--;
2617 params[4] = default_value;
2618 }
2619 params[4]->refcount++;
2620 if (local_titletext != NULL)
2621 {
2622 zval_ptr_dtor (&local_titletext);
2623 }
2624 local_titletext = params[4];
2625 }
2626 // Function body
2627 // $this->mText = $text;
2628 {
2629 if (local_this == NULL)
2630 {
2631 local_this = EG (uninitialized_zval_ptr);
2632 local_this->refcount++;
2633 }
2634 zval** p_obj = &local_this;
2635
2636 zval* rhs;
2637 if (local_text == NULL)
2638 rhs = EG (uninitialized_zval_ptr);
2639 else
2640 rhs = local_text;
2641
2642 zval field_name;
2643 INIT_ZVAL (field_name);
2644 ZVAL_STRING (&field_name, "mText", 0);
2645
2646 Z_OBJ_HT_PP(p_obj)->write_property(*p_obj, &field_name, rhs TSRMLS_CC);
2647 phc_check_invariants (TSRMLS_C);
2648 }
2649 // $this->mLanguageLinks = $languageLinks;
2650 {
2651 if (local_this == NULL)
2652 {
2653 local_this = EG (uninitialized_zval_ptr);
2654 local_this->refcount++;
2655 }
2656 zval** p_obj = &local_this;
2657
2658 zval* rhs;
2659 if (local_languageLinks == NULL)
2660 rhs = EG (uninitialized_zval_ptr);
2661 else
2662 rhs = local_languageLinks;
2663
2664 zval field_name;
2665 INIT_ZVAL (field_name);
2666 ZVAL_STRING (&field_name, "mLanguageLinks", 0);
2667
2668 Z_OBJ_HT_PP(p_obj)->write_property(*p_obj, &field_name, rhs TSRMLS_CC);
2669 phc_check_invariants (TSRMLS_C);
2670 }
2671 // $this->mCategories = $categoryLinks;
2672 {
2673 if (local_this == NULL)
2674 {
2675 local_this = EG (uninitialized_zval_ptr);
2676 local_this->refcount++;
2677 }
2678 zval** p_obj = &local_this;
2679
2680 zval* rhs;
2681 if (local_categoryLinks == NULL)
2682 rhs = EG (uninitialized_zval_ptr);
2683 else
2684 rhs = local_categoryLinks;
2685
2686 zval field_name;
2687 INIT_ZVAL (field_name);
2688 ZVAL_STRING (&field_name, "mCategories", 0);
2689
2690 Z_OBJ_HT_PP(p_obj)->write_property(*p_obj, &field_name, rhs TSRMLS_CC);
2691 phc_check_invariants (TSRMLS_C);
2692 }
2693 // $this->mContainsOldMagic = $containsOldMagic;
2694 {
2695 if (local_this == NULL)
2696 {
2697 local_this = EG (uninitialized_zval_ptr);
2698 local_this->refcount++;
2699 }
2700 zval** p_obj = &local_this;
2701
2702 zval* rhs;
2703 if (local_containsOldMagic == NULL)
2704 rhs = EG (uninitialized_zval_ptr);
2705 else
2706 rhs = local_containsOldMagic;
2707
2708 zval field_name;
2709 INIT_ZVAL (field_name);
2710 ZVAL_STRING (&field_name, "mContainsOldMagic", 0);
2711
2712 Z_OBJ_HT_PP(p_obj)->write_property(*p_obj, &field_name, rhs TSRMLS_CC);
2713 phc_check_invariants (TSRMLS_C);
2714 }
2715 // $this->mTitleText = $titletext;
2716 {
2717 if (local_this == NULL)
2718 {
2719 local_this = EG (uninitialized_zval_ptr);
2720 local_this->refcount++;
2721 }
2722 zval** p_obj = &local_this;
2723
2724 zval* rhs;
2725 if (local_titletext == NULL)
2726 rhs = EG (uninitialized_zval_ptr);
2727 else
2728 rhs = local_titletext;
2729
2730 zval field_name;
2731 INIT_ZVAL (field_name);
2732 ZVAL_STRING (&field_name, "mTitleText", 0);
2733
2734 Z_OBJ_HT_PP(p_obj)->write_property(*p_obj, &field_name, rhs TSRMLS_CC);
2735 phc_check_invariants (TSRMLS_C);
2736 }
2737 // Method exit
2738 end_of_function:__attribute__((unused));
2739 if (local_categoryLinks != NULL)
2740 {
2741 zval_ptr_dtor (&local_categoryLinks);
2742 }
2743 if (local_containsOldMagic != NULL)
2744 {
2745 zval_ptr_dtor (&local_containsOldMagic);
2746 }
2747 if (local_languageLinks != NULL)
2748 {
2749 zval_ptr_dtor (&local_languageLinks);
2750 }
2751 if (local_text != NULL)
2752 {
2753 zval_ptr_dtor (&local_text);
2754 }
2755 if (local_titletext != NULL)
2756 {
2757 zval_ptr_dtor (&local_titletext);
2758 }
2759 }
2760 // function gettext()
2761 // {
2762 // $TSt9 = $this->mText;
2763 // return $TSt9;
2764 // }
2765 PHP_METHOD(ParserOutput, gettext)
2766 {
2767 zval* local_TSt9 = NULL;
2768 zval* local_this = getThis();
2769 // Function body
2770 // $TSt9 = $this->mText;
2771 {
2772 if (local_this == NULL)
2773 {
2774 local_this = EG (uninitialized_zval_ptr);
2775 local_this->refcount++;
2776 }
2777 zval** p_obj = &local_this;
2778
2779 zval field_name;
2780 INIT_ZVAL (field_name);
2781 ZVAL_STRING (&field_name, "mText", 0);
2782
2783 // I *think* this is correct, but documentation of the Zend API is scarce :)
2784 zval* field = Z_OBJ_HT_PP(p_obj)->read_property(*p_obj, &field_name, BP_VAR_R TSRMLS_CC);
2785 if (local_TSt9 == NULL)
2786 {
2787 local_TSt9 = EG (uninitialized_zval_ptr);
2788 local_TSt9->refcount++;
2789 }
2790 zval** p_lhs = &local_TSt9;
2791
2792 write_var (p_lhs, field);
2793 phc_check_invariants (TSRMLS_C);
2794 }
2795 // return $TSt9;
2796 {
2797 zval* rhs;
2798 if (local_TSt9 == NULL)
2799 rhs = EG (uninitialized_zval_ptr);
2800 else
2801 rhs = local_TSt9;
2802
2803 // Run-time return by reference has different semantics to compile-time.
2804 // If the function has CTRBR and RTRBR, the the assignment will be
2805 // reference. If one or the other is return-by-copy, the result will be
2806 // by copy. Its a question of whether its separated at return-time (which
2807 // we do here) or at the call-site.
2808 return_value->value = rhs->value;
2809 return_value->type = rhs->type;
2810 zval_copy_ctor (return_value);
2811 goto end_of_function;
2812 phc_check_invariants (TSRMLS_C);
2813 }
2814 // Method exit
2815 end_of_function:__attribute__((unused));
2816 if (local_TSt9 != NULL)
2817 {
2818 zval_ptr_dtor (&local_TSt9);
2819 }
2820 }
2821 // function &getlanguagelinks()
2822 // {
2823 // $TSt10 =& $this->mLanguageLinks;
2824 // return $TSt10;
2825 // }
2826 PHP_METHOD(ParserOutput, getlanguagelinks)
2827 {
2828 zval* local_TSt10 = NULL;
2829 zval* local_this = getThis();
2830 // Function body
2831 // $TSt10 =& $this->mLanguageLinks;
2832 {
2833 if (local_this == NULL)
2834 {
2835 local_this = EG (uninitialized_zval_ptr);
2836 local_this->refcount++;
2837 }
2838 zval** p_obj = &local_this;
2839
2840 zval field_name;
2841 INIT_ZVAL (field_name);
2842 ZVAL_STRING (&field_name, "mLanguageLinks", 0);
2843
2844 zval** field = Z_OBJ_HT_PP(p_obj)->get_property_ptr_ptr(*p_obj, &field_name TSRMLS_CC);
2845 sep_copy_on_write (field);
2846 if (local_TSt10 == NULL)
2847 {
2848 local_TSt10 = EG (uninitialized_zval_ptr);
2849 local_TSt10->refcount++;
2850 }
2851 zval** p_lhs = &local_TSt10;
2852
2853 copy_into_ref (p_lhs, field);
2854 phc_check_invariants (TSRMLS_C);
2855 }
2856 // return $TSt10;
2857 {
2858 if (local_TSt10 == NULL)
2859 {
2860 local_TSt10 = EG (uninitialized_zval_ptr);
2861 local_TSt10->refcount++;
2862 }
2863 zval** p_rhs = &local_TSt10;
2864
2865 sep_copy_on_write (p_rhs);
2866 zval_ptr_dtor (return_value_ptr);
2867 (*p_rhs)->is_ref = 1;
2868 (*p_rhs)->refcount++;
2869 *return_value_ptr = *p_rhs;
2870 goto end_of_function;
2871 phc_check_invariants (TSRMLS_C);
2872 }
2873 // Method exit
2874 end_of_function:__attribute__((unused));
2875 if (local_TSt10 != NULL)
2876 {
2877 zval_ptr_dtor (&local_TSt10);
2878 }
2879 if (*return_value_ptr)
2880 saved_refcount = (*return_value_ptr)->refcount;
2881 }
2882 // function getcategorylinks()
2883 // {
2884 // $TLE100 = param_is_ref (NULL, "array_keys", 0);
2885 // ;
2886 // if (TLE100) goto L128 else goto L129;
2887 // L128:
2888 // $TMIt99 =& $this->mCategories;
2889 // goto L130;
2890 // L129:
2891 // $TMIt99 = $this->mCategories;
2892 // goto L130;
2893 // L130:
2894 // $TLE11 = array_keys($TMIt99);
2895 // return $TLE11;
2896 // }
2897 PHP_METHOD(ParserOutput, getcategorylinks)
2898 {
2899 zval* local_TLE100 = NULL;
2900 zval* local_TLE11 = NULL;
2901 zval* local_TMIt99 = NULL;
2902 zval* local_this = getThis();
2903 // Function body
2904 // $TLE100 = param_is_ref (NULL, "array_keys", 0);
2905 // ;
2906 {
2907 initialize_function_call (&array_keys_fci, &array_keys_fcic, "array_keys", "<unknown>", 0 TSRMLS_CC);
2908 zend_function* signature = array_keys_fcic.function_handler;
2909 zend_arg_info* arg_info = signature->common.arg_info;
2910 int count = 0;
2911 while (arg_info && count < 0)
2912 {
2913 count++;
2914 arg_info++;
2915 }
2916
2917 if (local_TLE100 == NULL)
2918 {
2919 local_TLE100 = EG (uninitialized_zval_ptr);
2920 local_TLE100->refcount++;
2921 }
2922 zval** p_lhs = &local_TLE100;
2923
2924 zval* rhs;
2925 ALLOC_INIT_ZVAL (rhs);
2926 if (arg_info && count == 0)
2927 {
2928 ZVAL_BOOL (rhs, arg_info->pass_by_reference);
2929 }
2930 else
2931 {
2932 ZVAL_BOOL (rhs, signature->common.pass_rest_by_reference);
2933 }
2934 write_var (p_lhs, rhs);
2935 zval_ptr_dtor (&rhs);
2936 phc_check_invariants (TSRMLS_C);
2937 }
2938 // if (TLE100) goto L128 else goto L129;
2939 {
2940 zval* p_cond;
2941 if (local_TLE100 == NULL)
2942 p_cond = EG (uninitialized_zval_ptr);
2943 else
2944 p_cond = local_TLE100;
2945
2946 zend_bool bcond = zend_is_true (p_cond);
2947 if (bcond)
2948 goto L128;
2949 else
2950 goto L129;
2951 phc_check_invariants (TSRMLS_C);
2952 }
2953 // L128:
2954 L128:;
2955 // $TMIt99 =& $this->mCategories;
2956 {
2957 if (local_this == NULL)
2958 {
2959 local_this = EG (uninitialized_zval_ptr);
2960 local_this->refcount++;
2961 }
2962 zval** p_obj = &local_this;
2963
2964 zval field_name;
2965 INIT_ZVAL (field_name);
2966 ZVAL_STRING (&field_name, "mCategories", 0);
2967
2968 zval** field = Z_OBJ_HT_PP(p_obj)->get_property_ptr_ptr(*p_obj, &field_name TSRMLS_CC);
2969 sep_copy_on_write (field);
2970 if (local_TMIt99 == NULL)
2971 {
2972 local_TMIt99 = EG (uninitialized_zval_ptr);
2973 local_TMIt99->refcount++;
2974 }
2975 zval** p_lhs = &local_TMIt99;
2976
2977 copy_into_ref (p_lhs, field);
2978 phc_check_invariants (TSRMLS_C);
2979 }
2980 // goto L130;
2981 {
2982 goto L130;
2983 phc_check_invariants (TSRMLS_C);
2984 }
2985 // L129:
2986 L129:;
2987 // $TMIt99 = $this->mCategories;
2988 {
2989 if (local_this == NULL)
2990 {
2991 local_this = EG (uninitialized_zval_ptr);
2992 local_this->refcount++;
2993 }
2994 zval** p_obj = &local_this;
2995
2996 zval field_name;
2997 INIT_ZVAL (field_name);
2998 ZVAL_STRING (&field_name, "mCategories", 0);
2999
3000 // I *think* this is correct, but documentation of the Zend API is scarce :)
3001 zval* field = Z_OBJ_HT_PP(p_obj)->read_property(*p_obj, &field_name, BP_VAR_R TSRMLS_CC);
3002 if (local_TMIt99 == NULL)
3003 {
3004 local_TMIt99 = EG (uninitialized_zval_ptr);
3005 local_TMIt99->refcount++;
3006 }
3007 zval** p_lhs = &local_TMIt99;
3008
3009 write_var (p_lhs, field);
3010 phc_check_invariants (TSRMLS_C);
3011 }
3012 // goto L130;
3013 {
3014 goto L130;
3015 phc_check_invariants (TSRMLS_C);
3016 }
3017 // L130:
3018 L130:;
3019 // $TLE11 = array_keys($TMIt99);
3020 {
3021 initialize_function_call (&array_keys_fci, &array_keys_fcic, "array_keys", "/home/mdupont/2009/02/introspector/rdfintrospector/mediawiki/trunk/phase3/includes/parser/ParserOutput.php", 46 TSRMLS_CC);
3022 zend_function* signature = array_keys_fcic.function_handler;
3023 zend_arg_info* arg_info = signature->common.arg_info; // optional
3024
3025 int by_ref[1];
3026 int abr_index = 0;
3027 // TODO: find names to replace index
3028 if (arg_info)
3029 {
3030 by_ref[abr_index] = arg_info->pass_by_reference;
3031 arg_info++;
3032 }
3033 else
3034 by_ref[abr_index] = signature->common.pass_rest_by_reference;
3035
3036 abr_index++;
3037
3038
3039 // Setup array of arguments
3040 // TODO: i think arrays of size 0 is an error
3041 int destruct [1];
3042 zval* args [1];
3043 zval** args_ind [1];
3044
3045 int af_index = 0;
3046 destruct[af_index] = 0;
3047 if (by_ref[af_index])
3048 {
3049 if (local_TMIt99 == NULL)
3050 {
3051 local_TMIt99 = EG (uninitialized_zval_ptr);
3052 local_TMIt99->refcount++;
3053 }
3054 zval** p_arg = &local_TMIt99;
3055
3056 args_ind[af_index] = fetch_var_arg_by_ref (p_arg);
3057 assert (!in_copy_on_write (*args_ind[af_index]));
3058 args[af_index] = *args_ind[af_index];
3059 }
3060 else
3061 {
3062 zval* arg;
3063 if (local_TMIt99 == NULL)
3064 arg = EG (uninitialized_zval_ptr);
3065 else
3066 arg = local_TMIt99;
3067
3068 args[af_index] = fetch_var_arg (arg, &destruct[af_index]);
3069 args_ind[af_index] = &args[af_index];
3070 }
3071 af_index++;
3072
3073
3074 phc_setup_error (1, "/home/mdupont/2009/02/introspector/rdfintrospector/mediawiki/trunk/phase3/includes/parser/ParserOutput.php", 46, NULL TSRMLS_CC);
3075
3076 // save existing parameters, in case of recursion
3077 int param_count_save = array_keys_fci.param_count;
3078 zval*** params_save = array_keys_fci.params;
3079 zval** retval_save = array_keys_fci.retval_ptr_ptr;
3080
3081 zval* rhs = NULL;
3082
3083 // set up params
3084 array_keys_fci.params = args_ind;
3085 array_keys_fci.param_count = 1;
3086 array_keys_fci.retval_ptr_ptr = &rhs;
3087
3088 // call the function
3089 int success = zend_call_function (&array_keys_fci, &array_keys_fcic TSRMLS_CC);
3090 assert(success == SUCCESS);
3091
3092 // restore params
3093 array_keys_fci.params = params_save;
3094 array_keys_fci.param_count = param_count_save;
3095 array_keys_fci.retval_ptr_ptr = retval_save;
3096
3097 // unset the errors
3098 phc_setup_error (0, NULL, 0, NULL TSRMLS_CC);
3099
3100 int i;
3101 for (i = 0; i < 1; i++)
3102 {
3103 if (destruct[i])
3104 {
3105 assert (destruct[i]);
3106 zval_ptr_dtor (args_ind[i]);
3107 }
3108 }
3109
3110
3111 // When the Zend engine returns by reference, it allocates a zval into
3112 // retval_ptr_ptr. To return by reference, the callee writes into the
3113 // retval_ptr_ptr, freeing the allocated value as it does. (Note, it may
3114 // not actually return anything). So the zval returned - whether we return
3115 // it, or it is the allocated zval - has a refcount of 1.
3116
3117 // The caller is responsible for cleaning that up (note, this is unaffected
3118 // by whether it is added to some COW set).
3119
3120 // For reasons unknown, the Zend API resets the refcount and is_ref fields
3121 // of the return value after the function returns (unless the callee is
3122 // interpreted). If the function is supposed to return by reference, this
3123 // loses the refcount. This only happens when non-interpreted code is
3124 // called. We work around it, when compiled code is called, by saving the
3125 // refcount into SAVED_REFCOUNT, in the return statement. The downside is
3126 // that we may create an error if our code is called by a callback, and
3127 // returns by reference, and the callback returns by reference. At least
3128 // this is an obscure case.
3129 if(signature->common.return_reference && signature->type != ZEND_USER_FUNCTION)
3130 {
3131 assert (rhs != EG(uninitialized_zval_ptr));
3132 rhs->is_ref = 1;
3133 if (saved_refcount != 0)
3134 {
3135 rhs->refcount = saved_refcount;
3136 }
3137 rhs->refcount++;
3138 }
3139 saved_refcount = 0; // for 'obscure cases'
3140
3141 if (local_TLE11 == NULL)
3142 {
3143 local_TLE11 = EG (uninitialized_zval_ptr);
3144 local_TLE11->refcount++;
3145 }
3146 zval** p_lhs = &local_TLE11;
3147
3148 write_var (p_lhs, rhs);
3149
3150
3151 zval_ptr_dtor (&rhs);
3152 if(signature->common.return_reference && signature->type != ZEND_USER_FUNCTION)
3153 zval_ptr_dtor (&rhs);
3154
3155 phc_check_invariants (TSRMLS_C);
3156 }
3157 // return $TLE11;
3158 {
3159 zval* rhs;
3160 if (local_TLE11 == NULL)
3161 rhs = EG (uninitialized_zval_ptr);
3162 else
3163 rhs = local_TLE11;
3164
3165 // Run-time return by reference has different semantics to compile-time.
3166 // If the function has CTRBR and RTRBR, the the assignment will be
3167 // reference. If one or the other is return-by-copy, the result will be
3168 // by copy. Its a question of whether its separated at return-time (which
3169 // we do here) or at the call-site.
3170 return_value->value = rhs->value;
3171 return_value->type = rhs->type;
3172 zval_copy_ctor (return_value);
3173 goto end_of_function;
3174 phc_check_invariants (TSRMLS_C);
3175 }
3176 // Method exit
3177 end_of_function:__attribute__((unused));
3178 if (local_TLE100 != NULL)
3179 {
3180 zval_ptr_dtor (&local_TLE100);
3181 }
3182 if (local_TLE11 != NULL)
3183 {
3184 zval_ptr_dtor (&local_TLE11);
3185 }
3186 if (local_TMIt99 != NULL)
3187 {
3188 zval_ptr_dtor (&local_TMIt99);
3189 }
3190 }
3191 // function &getcategories()
3192 // {
3193 // $TSt12 =& $this->mCategories;
3194 // return $TSt12;
3195 // }
3196 PHP_METHOD(ParserOutput, getcategories)
3197 {
3198 zval* local_TSt12 = NULL;
3199 zval* local_this = getThis();
3200 // Function body
3201 // $TSt12 =& $this->mCategories;
3202 {
3203 if (local_this == NULL)
3204 {
3205 local_this = EG (uninitialized_zval_ptr);
3206 local_this->refcount++;
3207 }
3208 zval** p_obj = &local_this;
3209
3210 zval field_name;
3211 INIT_ZVAL (field_name);
3212 ZVAL_STRING (&field_name, "mCategories", 0);
3213
3214 zval** field = Z_OBJ_HT_PP(p_obj)->get_property_ptr_ptr(*p_obj, &field_name TSRMLS_CC);
3215 sep_copy_on_write (field);
3216 if (local_TSt12 == NULL)
3217 {
3218 local_TSt12 = EG (uninitialized_zval_ptr);
3219 local_TSt12->refcount++;
3220 }
3221 zval** p_lhs = &local_TSt12;
3222
3223 copy_into_ref (p_lhs, field);
3224 phc_check_invariants (TSRMLS_C);
3225 }
3226 // return $TSt12;
3227 {
3228 if (local_TSt12 == NULL)
3229 {
3230 local_TSt12 = EG (uninitialized_zval_ptr);
3231 local_TSt12->refcount++;
3232 }
3233 zval** p_rhs = &local_TSt12;
3234
3235 sep_copy_on_write (p_rhs);
3236 zval_ptr_dtor (return_value_ptr);
3237 (*p_rhs)->is_ref = 1;
3238 (*p_rhs)->refcount++;
3239 *return_value_ptr = *p_rhs;
3240 goto end_of_function;
3241 phc_check_invariants (TSRMLS_C);
3242 }
3243 // Method exit
3244 end_of_function:__attribute__((unused));
3245 if (local_TSt12 != NULL)
3246 {
3247 zval_ptr_dtor (&local_TSt12);
3248 }
3249 if (*return_value_ptr)
3250 saved_refcount = (*return_value_ptr)->refcount;
3251 }
3252 // function getcachetime()
3253 // {
3254 // $TSt13 = $this->mCacheTime;
3255 // return $TSt13;
3256 // }
3257 PHP_METHOD(ParserOutput, getcachetime)
3258 {
3259 zval* local_TSt13 = NULL;
3260 zval* local_this = getThis();
3261 // Function body
3262 // $TSt13 = $this->mCacheTime;
3263 {
3264 if (local_this == NULL)
3265 {
3266 local_this = EG (uninitialized_zval_ptr);
3267 local_this->refcount++;
3268 }
3269 zval** p_obj = &local_this;
3270
3271 zval field_name;
3272 INIT_ZVAL (field_name);
3273 ZVAL_STRING (&field_name, "mCacheTime", 0);
3274
3275 // I *think* this is correct, but documentation of the Zend API is scarce :)
3276 zval* field = Z_OBJ_HT_PP(p_obj)->read_property(*p_obj, &field_name, BP_VAR_R TSRMLS_CC);
3277 if (local_TSt13 == NULL)
3278 {
3279 local_TSt13 = EG (uninitialized_zval_ptr);
3280 local_TSt13->refcount++;
3281 }
3282 zval** p_lhs = &local_TSt13;
3283
3284 write_var (p_lhs, field);
3285 phc_check_invariants (TSRMLS_C);
3286 }
3287 // return $TSt13;
3288 {
3289 zval* rhs;
3290 if (local_TSt13 == NULL)
3291 rhs = EG (uninitialized_zval_ptr);
3292 else
3293 rhs = local_TSt13;
3294
3295 // Run-time return by reference has different semantics to compile-time.
3296 // If the function has CTRBR and RTRBR, the the assignment will be
3297 // reference. If one or the other is return-by-copy, the result will be
3298 // by copy. Its a question of whether its separated at return-time (which
3299 // we do here) or at the call-site.
3300 return_value->value = rhs->value;
3301 return_value->type = rhs->type;
3302 zval_copy_ctor (return_value);
3303 goto end_of_function;
3304 phc_check_invariants (TSRMLS_C);
3305 }
3306 // Method exit
3307 end_of_function:__attribute__((unused));
3308 if (local_TSt13 != NULL)
3309 {
3310 zval_ptr_dtor (&local_TSt13);
3311 }
3312 }
3313 // function gettitletext()
3314 // {
3315 // $TSt14 = $this->mTitleText;
3316 // return $TSt14;
3317 // }
3318 PHP_METHOD(ParserOutput, gettitletext)
3319 {
3320 zval* local_TSt14 = NULL;
3321 zval* local_this = getThis();
3322 // Function body
3323 // $TSt14 = $this->mTitleText;
3324 {
3325 if (local_this == NULL)
3326 {
3327 local_this = EG (uninitialized_zval_ptr);
3328 local_this->refcount++;
3329 }
3330 zval** p_obj = &local_this;
3331
3332 zval field_name;
3333 INIT_ZVAL (field_name);
3334 ZVAL_STRING (&field_name, "mTitleText", 0);
3335
3336 // I *think* this is correct, but documentation of the Zend API is scarce :)
3337 zval* field = Z_OBJ_HT_PP(p_obj)->read_property(*p_obj, &field_name, BP_VAR_R TSRMLS_CC);
3338 if (local_TSt14 == NULL)
3339 {
3340 local_TSt14 = EG (uninitialized_zval_ptr);
3341 local_TSt14->refcount++;
3342 }
3343 zval** p_lhs = &local_TSt14;
3344
3345 write_var (p_lhs, field);
3346 phc_check_invariants (TSRMLS_C);
3347 }
3348 // return $TSt14;
3349 {
3350 zval* rhs;
3351 if (local_TSt14 == NULL)
3352 rhs = EG (uninitialized_zval_ptr);
3353 else
3354 rhs = local_TSt14;
3355
3356 // Run-time return by reference has different semantics to compile-time.
3357 // If the function has CTRBR and RTRBR, the the assignment will be
3358 // reference. If one or the other is return-by-copy, the result will be
3359 // by copy. Its a question of whether its separated at return-time (which
3360 // we do here) or at the call-site.
3361 return_value->value = rhs->value;
3362 return_value->type = rhs->type;
3363 zval_copy_ctor (return_value);
3364 goto end_of_function;
3365 phc_check_invariants (TSRMLS_C);
3366 }
3367 // Method exit
3368 end_of_function:__attribute__((unused));
3369 if (local_TSt14 != NULL)
3370 {
3371 zval_ptr_dtor (&local_TSt14);
3372 }
3373 }
3374 // function getsections()
3375 // {
3376 // $TSt15 = $this->mSections;
3377 // return $TSt15;
3378 // }
3379 PHP_METHOD(ParserOutput, getsections)
3380 {
3381 zval* local_TSt15 = NULL;
3382 zval* local_this = getThis();
3383 // Function body
3384 // $TSt15 = $this->mSections;
3385 {
3386 if (local_this == NULL)
3387 {
3388 local_this = EG (uninitialized_zval_ptr);
3389 local_this->refcount++;
3390 }
3391 zval** p_obj = &local_this;
3392
3393 zval field_name;
3394 INIT_ZVAL (field_name);
3395 ZVAL_STRING (&field_name, "mSections", 0);
3396
3397 // I *think* this is correct, but documentation of the Zend API is scarce :)
3398 zval* field = Z_OBJ_HT_PP(p_obj)->read_property(*p_obj, &field_name, BP_VAR_R TSRMLS_CC);
3399 if (local_TSt15 == NULL)
3400 {
3401 local_TSt15 = EG (uninitialized_zval_ptr);
3402 local_TSt15->refcount++;
3403 }
3404 zval** p_lhs = &local_TSt15;
3405
3406 write_var (p_lhs, field);
3407 phc_check_invariants (TSRMLS_C);
3408 }
3409 // return $TSt15;
3410 {
3411 zval* rhs;
3412 if (local_TSt15 == NULL)
3413 rhs = EG (uninitialized_zval_ptr);
3414 else
3415 rhs = local_TSt15;
3416
3417 // Run-time return by reference has different semantics to compile-time.
3418 // If the function has CTRBR and RTRBR, the the assignment will be
3419 // reference. If one or the other is return-by-copy, the result will be
3420 // by copy. Its a question of whether its separated at return-time (which
3421 // we do here) or at the call-site.
3422 return_value->value = rhs->value;
3423 return_value->type = rhs->type;
3424 zval_copy_ctor (return_value);
3425 goto end_of_function;
3426 phc_check_invariants (TSRMLS_C);
3427 }
3428 // Method exit
3429 end_of_function:__attribute__((unused));
3430 if (local_TSt15 != NULL)
3431 {
3432 zval_ptr_dtor (&local_TSt15);
3433 }
3434 }
3435 // function &getlinks()
3436 // {
3437 // $TSt16 =& $this->mLinks;
3438 // return $TSt16;
3439 // }
3440 PHP_METHOD(ParserOutput, getlinks)
3441 {
3442 zval* local_TSt16 = NULL;
3443 zval* local_this = getThis();
3444 // Function body
3445 // $TSt16 =& $this->mLinks;
3446 {
3447 if (local_this == NULL)
3448 {
3449 local_this = EG (uninitialized_zval_ptr);
3450 local_this->refcount++;
3451 }
3452 zval** p_obj = &local_this;
3453
3454 zval field_name;
3455 INIT_ZVAL (field_name);
3456 ZVAL_STRING (&field_name, "mLinks", 0);
3457
3458 zval** field = Z_OBJ_HT_PP(p_obj)->get_property_ptr_ptr(*p_obj, &field_name TSRMLS_CC);
3459 sep_copy_on_write (field);
3460 if (local_TSt16 == NULL)
3461 {
3462 local_TSt16 = EG (uninitialized_zval_ptr);
3463 local_TSt16->refcount++;
3464 }
3465 zval** p_lhs = &local_TSt16;
3466
3467 copy_into_ref (p_lhs, field);
3468 phc_check_invariants (TSRMLS_C);
3469 }
3470 // return $TSt16;
3471 {
3472 if (local_TSt16 == NULL)
3473 {
3474 local_TSt16 = EG (uninitialized_zval_ptr);
3475 local_TSt16->refcount++;
3476 }
3477 zval** p_rhs = &local_TSt16;
3478
3479 sep_copy_on_write (p_rhs);
3480 zval_ptr_dtor (return_value_ptr);
3481 (*p_rhs)->is_ref = 1;
3482 (*p_rhs)->refcount++;
3483 *return_value_ptr = *p_rhs;
3484 goto end_of_function;
3485 phc_check_invariants (TSRMLS_C);
3486 }
3487 // Method exit
3488 end_of_function:__attribute__((unused));
3489 if (local_TSt16 != NULL)
3490 {
3491 zval_ptr_dtor (&local_TSt16);
3492 }
3493 if (*return_value_ptr)
3494 saved_refcount = (*return_value_ptr)->refcount;
3495 }
3496 // function &gettemplates()
3497 // {
3498 // $TSt17 =& $this->mTemplates;
3499 // return $TSt17;
3500 // }
3501 PHP_METHOD(ParserOutput, gettemplates)
3502 {
3503 zval* local_TSt17 = NULL;
3504 zval* local_this = getThis();
3505 // Function body
3506 // $TSt17 =& $this->mTemplates;
3507 {
3508 if (local_this == NULL)
3509 {
3510 local_this = EG (uninitialized_zval_ptr);
3511 local_this->refcount++;
3512 }
3513 zval** p_obj = &local_this;
3514
3515 zval field_name;
3516 INIT_ZVAL (field_name);
3517 ZVAL_STRING (&field_name, "mTemplates", 0);
3518
3519 zval** field = Z_OBJ_HT_PP(p_obj)->get_property_ptr_ptr(*p_obj, &field_name TSRMLS_CC);
3520 sep_copy_on_write (field);
3521 if (local_TSt17 == NULL)
3522 {
3523 local_TSt17 = EG (uninitialized_zval_ptr);
3524 local_TSt17->refcount++;
3525 }
3526 zval** p_lhs = &local_TSt17;
3527
3528 copy_into_ref (p_lhs, field);
3529 phc_check_invariants (TSRMLS_C);
3530 }
3531 // return $TSt17;
3532 {
3533 if (local_TSt17 == NULL)
3534 {
3535 local_TSt17 = EG (uninitialized_zval_ptr);
3536 local_TSt17->refcount++;
3537 }
3538 zval** p_rhs = &local_TSt17;
3539
3540 sep_copy_on_write (p_rhs);
3541 zval_ptr_dtor (return_value_ptr);
3542 (*p_rhs)->is_ref = 1;
3543 (*p_rhs)->refcount++;
3544 *return_value_ptr = *p_rhs;
3545 goto end_of_function;
3546 phc_check_invariants (TSRMLS_C);
3547 }
3548 // Method exit
3549 end_of_function:__attribute__((unused));
3550 if (local_TSt17 != NULL)
3551 {
3552 zval_ptr_dtor (&local_TSt17);
3553 }
3554 if (*return_value_ptr)
3555 saved_refcount = (*return_value_ptr)->refcount;
3556 }
3557 // function &getimages()
3558 // {
3559 // $TSt18 =& $this->mImages;
3560 // return $TSt18;
3561 // }
3562 PHP_METHOD(ParserOutput, getimages)
3563 {
3564 zval* local_TSt18 = NULL;
3565 zval* local_this = getThis();
3566 // Function body
3567 // $TSt18 =& $this->mImages;
3568 {
3569 if (local_this == NULL)
3570 {
3571 local_this = EG (uninitialized_zval_ptr);
3572 local_this->refcount++;
3573 }
3574 zval** p_obj = &local_this;
3575
3576 zval field_name;
3577 INIT_ZVAL (field_name);
3578 ZVAL_STRING (&field_name, "mImages", 0);
3579
3580 zval** field = Z_OBJ_HT_PP(p_obj)->get_property_ptr_ptr(*p_obj, &field_name TSRMLS_CC);
3581 sep_copy_on_write (field);
3582 if (local_TSt18 == NULL)
3583 {
3584 local_TSt18 = EG (uninitialized_zval_ptr);
3585 local_TSt18->refcount++;
3586 }
3587 zval** p_lhs = &local_TSt18;
3588
3589 copy_into_ref (p_lhs, field);
3590 phc_check_invariants (TSRMLS_C);
3591 }
3592 // return $TSt18;
3593 {
3594 if (local_TSt18 == NULL)
3595 {
3596 local_TSt18 = EG (uninitialized_zval_ptr);
3597 local_TSt18->refcount++;
3598 }
3599 zval** p_rhs = &local_TSt18;
3600
3601 sep_copy_on_write (p_rhs);
3602 zval_ptr_dtor (return_value_ptr);
3603 (*p_rhs)->is_ref = 1;
3604 (*p_rhs)->refcount++;
3605 *return_value_ptr = *p_rhs;
3606 goto end_of_function;
3607 phc_check_invariants (TSRMLS_C);
3608 }
3609 // Method exit
3610 end_of_function:__attribute__((unused));
3611 if (local_TSt18 != NULL)
3612 {
3613 zval_ptr_dtor (&local_TSt18);
3614 }
3615 if (*return_value_ptr)
3616 saved_refcount = (*return_value_ptr)->refcount;
3617 }
3618 // function &getexternallinks()
3619 // {
3620 // $TSt19 =& $this->mExternalLinks;
3621 // return $TSt19;
3622 // }
3623 PHP_METHOD(ParserOutput, getexternallinks)
3624 {
3625 zval* local_TSt19 = NULL;
3626 zval* local_this = getThis();
3627 // Function body
3628 // $TSt19 =& $this->mExternalLinks;
3629 {
3630 if (local_this == NULL)
3631 {
3632 local_this = EG (uninitialized_zval_ptr);
3633 local_this->refcount++;
3634 }
3635 zval** p_obj = &local_this;
3636
3637 zval field_name;
3638 INIT_ZVAL (field_name);
3639 ZVAL_STRING (&field_name, "mExternalLinks", 0);
3640
3641 zval** field = Z_OBJ_HT_PP(p_obj)->get_property_ptr_ptr(*p_obj, &field_name TSRMLS_CC);
3642 sep_copy_on_write (field);
3643 if (local_TSt19 == NULL)
3644 {
3645 local_TSt19 = EG (uninitialized_zval_ptr);
3646 local_TSt19->refcount++;
3647 }
3648 zval** p_lhs = &local_TSt19;
3649
3650 copy_into_ref (p_lhs, field);
3651 phc_check_invariants (TSRMLS_C);
3652 }
3653 // return $TSt19;
3654 {
3655 if (local_TSt19 == NULL)
3656 {
3657 local_TSt19 = EG (uninitialized_zval_ptr);
3658 local_TSt19->refcount++;
3659 }
3660 zval** p_rhs = &local_TSt19;
3661
3662 sep_copy_on_write (p_rhs);
3663 zval_ptr_dtor (return_value_ptr);
3664 (*p_rhs)->is_ref = 1;
3665 (*p_rhs)->refcount++;
3666 *return_value_ptr = *p_rhs;
3667 goto end_of_function;
3668 phc_check_invariants (TSRMLS_C);
3669 }
3670 // Method exit
3671 end_of_function:__attribute__((unused));
3672 if (local_TSt19 != NULL)
3673 {
3674 zval_ptr_dtor (&local_TSt19);
3675 }
3676 if (*return_value_ptr)
3677 saved_refcount = (*return_value_ptr)->refcount;
3678 }
3679 // function getnogallery()
3680 // {
3681 // $TSt20 = $this->mNoGallery;
3682 // return $TSt20;
3683 // }
3684 PHP_METHOD(ParserOutput, getnogallery)
3685 {
3686 zval* local_TSt20 = NULL;
3687 zval* local_this = getThis();
3688 // Function body
3689 // $TSt20 = $this->mNoGallery;
3690 {
3691 if (local_this == NULL)
3692 {
3693 local_this = EG (uninitialized_zval_ptr);
3694 local_this->refcount++;
3695 }
3696 zval** p_obj = &local_this;
3697
3698 zval field_name;
3699 INIT_ZVAL (field_name);
3700 ZVAL_STRING (&field_name, "mNoGallery", 0);
3701
3702 // I *think* this is correct, but documentation of the Zend API is scarce :)
3703 zval* field = Z_OBJ_HT_PP(p_obj)->read_property(*p_obj, &field_name, BP_VAR_R TSRMLS_CC);
3704 if (local_TSt20 == NULL)
3705 {
3706 local_TSt20 = EG (uninitialized_zval_ptr);
3707 local_TSt20->refcount++;
3708 }
3709 zval** p_lhs = &local_TSt20;
3710
3711 write_var (p_lhs, field);
3712 phc_check_invariants (TSRMLS_C);
3713 }
3714 // return $TSt20;
3715 {
3716 zval* rhs;
3717 if (local_TSt20 == NULL)
3718 rhs = EG (uninitialized_zval_ptr);
3719 else
3720 rhs = local_TSt20;
3721
3722 // Run-time return by reference has different semantics to compile-time.
3723 // If the function has CTRBR and RTRBR, the the assignment will be
3724 // reference. If one or the other is return-by-copy, the result will be
3725 // by copy. Its a question of whether its separated at return-time (which
3726 // we do here) or at the call-site.
3727 return_value->value = rhs->value;
3728 return_value->type = rhs->type;
3729 zval_copy_ctor (return_value);
3730 goto end_of_function;
3731 phc_check_invariants (TSRMLS_C);
3732 }
3733 // Method exit
3734 end_of_function:__attribute__((unused));
3735 if (local_TSt20 != NULL)
3736 {
3737 zval_ptr_dtor (&local_TSt20);
3738 }
3739 }
3740 // function getsubtitle()
3741 // {
3742 // $TSt21 = $this->mSubtitle;
3743 // return $TSt21;
3744 // }
3745 PHP_METHOD(ParserOutput, getsubtitle)
3746 {
3747 zval* local_TSt21 = NULL;
3748 zval* local_this = getThis();
3749 // Function body
3750 // $TSt21 = $this->mSubtitle;
3751 {
3752 if (local_this == NULL)
3753 {
3754 local_this = EG (uninitialized_zval_ptr);
3755 local_this->refcount++;
3756 }
3757 zval** p_obj = &local_this;
3758
3759 zval field_name;
3760 INIT_ZVAL (field_name);
3761 ZVAL_STRING (&field_name, "mSubtitle", 0);
3762
3763 // I *think* this is correct, but documentation of the Zend API is scarce :)
3764 zval* field = Z_OBJ_HT_PP(p_obj)->read_property(*p_obj, &field_name, BP_VAR_R TSRMLS_CC);
3765 if (local_TSt21 == NULL)
3766 {
3767 local_TSt21 = EG (uninitialized_zval_ptr);
3768 local_TSt21->refcount++;
3769 }
3770 zval** p_lhs = &local_TSt21;
3771
3772 write_var (p_lhs, field);
3773 phc_check_invariants (TSRMLS_C);
3774 }
3775 // return $TSt21;
3776 {
3777 zval* rhs;
3778 if (local_TSt21 == NULL)
3779 rhs = EG (uninitialized_zval_ptr);
3780 else
3781 rhs = local_TSt21;
3782
3783 // Run-time return by reference has different semantics to compile-time.
3784 // If the function has CTRBR and RTRBR, the the assignment will be
3785 // reference. If one or the other is return-by-copy, the result will be
3786 // by copy. Its a question of whether its separated at return-time (which
3787 // we do here) or at the call-site.
3788 return_value->value = rhs->value;
3789 return_value->type = rhs->type;
3790 zval_copy_ctor (return_value);
3791 goto end_of_function;
3792 phc_check_invariants (TSRMLS_C);
3793 }
3794 // Method exit
3795 end_of_function:__attribute__((unused));
3796 if (local_TSt21 != NULL)
3797 {
3798 zval_ptr_dtor (&local_TSt21);
3799 }
3800 }
3801 // function getoutputhooks()
3802 // {
3803 // $TSt22 = $this->mOutputHooks;
3804 // $TLE23 = (array) $TSt22;
3805 // return $TLE23;
3806 // }
3807 PHP_METHOD(ParserOutput, getoutputhooks)
3808 {
3809 zval* local_TLE23 = NULL;
3810 zval* local_TSt22 = NULL;
3811 zval* local_this = getThis();
3812 // Function body
3813 // $TSt22 = $this->mOutputHooks;
3814 {
3815 if (local_this == NULL)
3816 {
3817 local_this = EG (uninitialized_zval_ptr);
3818 local_this->refcount++;
3819 }
3820 zval** p_obj = &local_this;
3821
3822 zval field_name;
3823 INIT_ZVAL (field_name);
3824 ZVAL_STRING (&field_name, "mOutputHooks", 0);
3825
3826 // I *think* this is correct, but documentation of the Zend API is scarce :)
3827 zval* field = Z_OBJ_HT_PP(p_obj)->read_property(*p_obj, &field_name, BP_VAR_R TSRMLS_CC);
3828 if (local_TSt22 == NULL)
3829 {
3830 local_TSt22 = EG (uninitialized_zval_ptr);
3831 local_TSt22->refcount++;
3832 }
3833 zval** p_lhs = &local_TSt22;
3834
3835 write_var (p_lhs, field);
3836 phc_check_invariants (TSRMLS_C);
3837 }
3838 // $TLE23 = (array) $TSt22;
3839 {
3840 if (local_TLE23 == NULL)
3841 {
3842 local_TLE23 = EG (uninitialized_zval_ptr);
3843 local_TLE23->refcount++;
3844 }
3845 zval** p_lhs = &local_TLE23;
3846
3847 zval* rhs;
3848 if (local_TSt22 == NULL)
3849 rhs = EG (uninitialized_zval_ptr);
3850 else
3851 rhs = local_TSt22;
3852
3853 if (*p_lhs != rhs)
3854 {
3855 if ((*p_lhs)->is_ref)
3856 overwrite_lhs (*p_lhs, rhs);
3857 else
3858 {
3859 zval_ptr_dtor (p_lhs);
3860 if (rhs->is_ref)
3861 {
3862 // Take a copy of RHS for LHS
3863 *p_lhs = zvp_clone_ex (rhs);
3864 }
3865 else
3866 {
3867 // Share a copy
3868 rhs->refcount++;
3869 *p_lhs = rhs;
3870 }
3871
3872 }
3873
3874 }
3875
3876 assert (IS_ARRAY >= 0 && IS_ARRAY <= 6);
3877 if ((*p_lhs)->type != IS_ARRAY)
3878 {
3879 sep_copy_on_write (p_lhs);
3880 convert_to_array (*p_lhs);
3881 }
3882
3883 phc_check_invariants (TSRMLS_C);
3884 }
3885 // return $TLE23;
3886 {
3887 zval* rhs;
3888 if (local_TLE23 == NULL)
3889 rhs = EG (uninitialized_zval_ptr);
3890 else
3891 rhs = local_TLE23;
3892
3893 // Run-time return by reference has different semantics to compile-time.
3894 // If the function has CTRBR and RTRBR, the the assignment will be
3895 // reference. If one or the other is return-by-copy, the result will be
3896 // by copy. Its a question of whether its separated at return-time (which
3897 // we do here) or at the call-site.
3898 return_value->value = rhs->value;
3899 return_value->type = rhs->type;
3900 zval_copy_ctor (return_value);
3901 goto end_of_function;
3902 phc_check_invariants (TSRMLS_C);
3903 }
3904 // Method exit
3905 end_of_function:__attribute__((unused));
3906 if (local_TLE23 != NULL)
3907 {
3908 zval_ptr_dtor (&local_TLE23);
3909 }
3910 if (local_TSt22 != NULL)
3911 {
3912 zval_ptr_dtor (&local_TSt22);
3913 }
3914 }
3915 // function getwarnings()
3916 // {
3917 // $TLE102 = param_is_ref (NULL, "array_keys", 0);
3918 // ;
3919 // if (TLE102) goto L131 else goto L132;
3920 // L131:
3921 // $TMIt101 =& $this->mWarnings;
3922 // goto L133;
3923 // L132:
3924 // $TMIt101 = $this->mWarnings;
3925 // goto L133;
3926 // L133:
3927 // $TLE24 = array_keys($TMIt101);
3928 // return $TLE24;
3929 // }
3930 PHP_METHOD(ParserOutput, getwarnings)
3931 {
3932 zval* local_TLE102 = NULL;
3933 zval* local_TLE24 = NULL;
3934 zval* local_TMIt101 = NULL;
3935 zval* local_this = getThis();
3936 // Function body
3937 // $TLE102 = param_is_ref (NULL, "array_keys", 0);
3938 // ;
3939 {
3940 initialize_function_call (&array_keys_fci, &array_keys_fcic, "array_keys", "<unknown>", 0 TSRMLS_CC);
3941 zend_function* signature = array_keys_fcic.function_handler;
3942 zend_arg_info* arg_info = signature->common.arg_info;
3943 int count = 0;
3944 while (arg_info && count < 0)
3945 {
3946 count++;
3947 arg_info++;
3948 }
3949
3950 if (local_TLE102 == NULL)
3951 {
3952 local_TLE102 = EG (uninitialized_zval_ptr);
3953 local_TLE102->refcount++;
3954 }
3955 zval** p_lhs = &local_TLE102;
3956
3957 zval* rhs;
3958 ALLOC_INIT_ZVAL (rhs);
3959 if (arg_info && count == 0)
3960 {
3961 ZVAL_BOOL (rhs, arg_info->pass_by_reference);
3962 }
3963 else
3964 {
3965 ZVAL_BOOL (rhs, signature->common.pass_rest_by_reference);
3966 }
3967 write_var (p_lhs, rhs);
3968 zval_ptr_dtor (&rhs);
3969 phc_check_invariants (TSRMLS_C);
3970 }
3971 // if (TLE102) goto L131 else goto L132;
3972 {
3973 zval* p_cond;
3974 if (local_TLE102 == NULL)
3975 p_cond = EG (uninitialized_zval_ptr);
3976 else
3977 p_cond = local_TLE102;
3978
3979 zend_bool bcond = zend_is_true (p_cond);
3980 if (bcond)
3981 goto L131;
3982 else
3983 goto L132;
3984 phc_check_invariants (TSRMLS_C);
3985 }
3986 // L131:
3987 L131:;
3988 // $TMIt101 =& $this->mWarnings;
3989 {
3990 if (local_this == NULL)
3991 {
3992 local_this = EG (uninitialized_zval_ptr);
3993 local_this->refcount++;
3994 }
3995 zval** p_obj = &local_this;
3996
3997 zval field_name;
3998 INIT_ZVAL (field_name);
3999 ZVAL_STRING (&field_name, "mWarnings", 0);
4000
4001 zval** field = Z_OBJ_HT_PP(p_obj)->get_property_ptr_ptr(*p_obj, &field_name TSRMLS_CC);
4002 sep_copy_on_write (field);
4003 if (local_TMIt101 == NULL)
4004 {
4005 local_TMIt101 = EG (uninitialized_zval_ptr);
4006 local_TMIt101->refcount++;
4007 }
4008 zval** p_lhs = &local_TMIt101;
4009
4010 copy_into_ref (p_lhs, field);
4011 phc_check_invariants (TSRMLS_C);
4012 }
4013 // goto L133;
4014 {
4015 goto L133;
4016 phc_check_invariants (TSRMLS_C);
4017 }
4018 // L132:
4019 L132:;
4020 // $TMIt101 = $this->mWarnings;
4021 {
4022 if (local_this == NULL)
4023 {
4024 local_this = EG (uninitialized_zval_ptr);
4025 local_this->refcount++;
4026 }
4027 zval** p_obj = &local_this;
4028
4029 zval field_name;
4030 INIT_ZVAL (field_name);
4031 ZVAL_STRING (&field_name, "mWarnings", 0);
4032
4033 // I *think* this is correct, but documentation of the Zend API is scarce :)
4034 zval* field = Z_OBJ_HT_PP(p_obj)->read_property(*p_obj, &field_name, BP_VAR_R TSRMLS_CC);
4035 if (local_TMIt101 == NULL)
4036 {
4037 local_TMIt101 = EG (uninitialized_zval_ptr);
4038 local_TMIt101->refcount++;
4039 }
4040 zval** p_lhs = &local_TMIt101;
4041
4042 write_var (p_lhs, field);
4043 phc_check_invariants (TSRMLS_C);
4044 }
4045 // goto L133;
4046 {
4047 goto L133;
4048 phc_check_invariants (TSRMLS_C);
4049 }
4050 // L133:
4051 L133:;
4052 // $TLE24 = array_keys($TMIt101);
4053 {
4054 initialize_function_call (&array_keys_fci, &array_keys_fcic, "array_keys", "/home/mdupont/2009/02/introspector/rdfintrospector/mediawiki/trunk/phase3/includes/parser/ParserOutput.php", 58 TSRMLS_CC);
4055 zend_function* signature = array_keys_fcic.function_handler;
4056 zend_arg_info* arg_info = signature->common.arg_info; // optional
4057
4058 int by_ref[1];
4059 int abr_index = 0;
4060 // TODO: find names to replace index
4061 if (arg_info)
4062 {
4063 by_ref[abr_index] = arg_info->pass_by_reference;
4064 arg_info++;
4065 }
4066 else
4067 by_ref[abr_index] = signature->common.pass_rest_by_reference;
4068
4069 abr_index++;
4070
4071
4072 // Setup array of arguments
4073 // TODO: i think arrays of size 0 is an error
4074 int destruct [1];
4075 zval* args [1];
4076 zval** args_ind [1];
4077
4078 int af_index = 0;
4079 destruct[af_index] = 0;
4080 if (by_ref[af_index])
4081 {
4082 if (local_TMIt101 == NULL)
4083 {
4084 local_TMIt101 = EG (uninitialized_zval_ptr);
4085 local_TMIt101->refcount++;
4086 }
4087 zval** p_arg = &local_TMIt101;
4088
4089 args_ind[af_index] = fetch_var_arg_by_ref (p_arg);
4090 assert (!in_copy_on_write (*args_ind[af_index]));
4091 args[af_index] = *args_ind[af_index];
4092 }
4093 else
4094 {
4095 zval* arg;
4096 if (local_TMIt101 == NULL)
4097 arg = EG (uninitialized_zval_ptr);
4098 else
4099 arg = local_TMIt101;
4100
4101 args[af_index] = fetch_var_arg (arg, &destruct[af_index]);
4102 args_ind[af_index] = &args[af_index];
4103 }
4104 af_index++;
4105
4106
4107 phc_setup_error (1, "/home/mdupont/2009/02/introspector/rdfintrospector/mediawiki/trunk/phase3/includes/parser/ParserOutput.php", 58, NULL TSRMLS_CC);
4108
4109 // save existing parameters, in case of recursion
4110 int param_count_save = array_keys_fci.param_count;
4111 zval*** params_save = array_keys_fci.params;
4112 zval** retval_save = array_keys_fci.retval_ptr_ptr;
4113
4114 zval* rhs = NULL;
4115
4116 // set up params
4117 array_keys_fci.params = args_ind;
4118 array_keys_fci.param_count = 1;
4119 array_keys_fci.retval_ptr_ptr = &rhs;
4120
4121 // call the function
4122 int success = zend_call_function (&array_keys_fci, &array_keys_fcic TSRMLS_CC);
4123 assert(success == SUCCESS);
4124
4125 // restore params
4126 array_keys_fci.params = params_save;
4127 array_keys_fci.param_count = param_count_save;
4128 array_keys_fci.retval_ptr_ptr = retval_save;
4129
4130 // unset the errors
4131 phc_setup_error (0, NULL, 0, NULL TSRMLS_CC);
4132
4133 int i;
4134 for (i = 0; i < 1; i++)
4135 {
4136 if (destruct[i])
4137 {
4138 assert (destruct[i]);
4139 zval_ptr_dtor (args_ind[i]);
4140 }
4141 }
4142
4143
4144 // When the Zend engine returns by reference, it allocates a zval into
4145 // retval_ptr_ptr. To return by reference, the callee writes into the
4146 // retval_ptr_ptr, freeing the allocated value as it does. (Note, it may
4147 // not actually return anything). So the zval returned - whether we return
4148 // it, or it is the allocated zval - has a refcount of 1.
4149
4150 // The caller is responsible for cleaning that up (note, this is unaffected
4151 // by whether it is added to some COW set).
4152
4153 // For reasons unknown, the Zend API resets the refcount and is_ref fields
4154 // of the return value after the function returns (unless the callee is
4155 // interpreted). If the function is supposed to return by reference, this
4156 // loses the refcount. This only happens when non-interpreted code is
4157 // called. We work around it, when compiled code is called, by saving the
4158 // refcount into SAVED_REFCOUNT, in the return statement. The downside is
4159 // that we may create an error if our code is called by a callback, and
4160 // returns by reference, and the callback returns by reference. At least
4161 // this is an obscure case.
4162 if(signature->common.return_reference && signature->type != ZEND_USER_FUNCTION)
4163 {
4164 assert (rhs != EG(uninitialized_zval_ptr));
4165 rhs->is_ref = 1;
4166 if (saved_refcount != 0)
4167 {
4168 rhs->refcount = saved_refcount;
4169 }
4170 rhs->refcount++;
4171 }
4172 saved_refcount = 0; // for 'obscure cases'
4173
4174 if (local_TLE24 == NULL)
4175 {
4176 local_TLE24 = EG (uninitialized_zval_ptr);
4177 local_TLE24->refcount++;
4178 }
4179 zval** p_lhs = &local_TLE24;
4180
4181 write_var (p_lhs, rhs);
4182
4183
4184 zval_ptr_dtor (&rhs);
4185 if(signature->common.return_reference && signature->type != ZEND_USER_FUNCTION)
4186 zval_ptr_dtor (&rhs);
4187
4188 phc_check_invariants (TSRMLS_C);
4189 }
4190 // return $TLE24;
4191 {
4192 zval* rhs;
4193 if (local_TLE24 == NULL)
4194 rhs = EG (uninitialized_zval_ptr);
4195 else
4196 rhs = local_TLE24;
4197
4198 // Run-time return by reference has different semantics to compile-time.
4199 // If the function has CTRBR and RTRBR, the the assignment will be
4200 // reference. If one or the other is return-by-copy, the result will be
4201 // by copy. Its a question of whether its separated at return-time (which
4202 // we do here) or at the call-site.
4203 return_value->value = rhs->value;
4204 return_value->type = rhs->type;
4205 zval_copy_ctor (return_value);
4206 goto end_of_function;
4207 phc_check_invariants (TSRMLS_C);
4208 }
4209 // Method exit
4210 end_of_function:__attribute__((unused));
4211 if (local_TLE102 != NULL)
4212 {
4213 zval_ptr_dtor (&local_TLE102);
4214 }
4215 if (local_TLE24 != NULL)
4216 {
4217 zval_ptr_dtor (&local_TLE24);
4218 }
4219 if (local_TMIt101 != NULL)
4220 {
4221 zval_ptr_dtor (&local_TMIt101);
4222 }
4223 }
4224 // function getindexpolicy()
4225 // {
4226 // $TSt25 = $this->mIndexPolicy;
4227 // return $TSt25;
4228 // }
4229 PHP_METHOD(ParserOutput, getindexpolicy)
4230 {
4231 zval* local_TSt25 = NULL;
4232 zval* local_this = getThis();
4233 // Function body
4234 // $TSt25 = $this->mIndexPolicy;
4235 {
4236 if (local_this == NULL)
4237 {
4238 local_this = EG (uninitialized_zval_ptr);
4239 local_this->refcount++;
4240 }
4241 zval** p_obj = &local_this;
4242
4243 zval field_name;
4244 INIT_ZVAL (field_name);
4245 ZVAL_STRING (&field_name, "mIndexPolicy", 0);
4246
4247 // I *think* this is correct, but documentation of the Zend API is scarce :)
4248 zval* field = Z_OBJ_HT_PP(p_obj)->read_property(*p_obj, &field_name, BP_VAR_R TSRMLS_CC);
4249 if (local_TSt25 == NULL)
4250 {
4251 local_TSt25 = EG (uninitialized_zval_ptr);
4252 local_TSt25->refcount++;
4253 }
4254 zval** p_lhs = &local_TSt25;
4255
4256 write_var (p_lhs, field);
4257 phc_check_invariants (TSRMLS_C);
4258 }
4259 // return $TSt25;
4260 {
4261 zval* rhs;
4262 if (local_TSt25 == NULL)
4263 rhs = EG (uninitialized_zval_ptr);
4264 else
4265 rhs = local_TSt25;
4266
4267 // Run-time return by reference has different semantics to compile-time.
4268 // If the function has CTRBR and RTRBR, the the assignment will be
4269 // reference. If one or the other is return-by-copy, the result will be
4270 // by copy. Its a question of whether its separated at return-time (which
4271 // we do here) or at the call-site.
4272 return_value->value = rhs->value;
4273 return_value->type = rhs->type;
4274 zval_copy_ctor (return_value);
4275 goto end_of_function;
4276 phc_check_invariants (TSRMLS_C);
4277 }
4278 // Method exit
4279 end_of_function:__attribute__((unused));
4280 if (local_TSt25 != NULL)
4281 {
4282 zval_ptr_dtor (&local_TSt25);
4283 }
4284 }
4285 // function containsoldmagic()
4286 // {
4287 // $TSt26 = $this->mContainsOldMagic;
4288 // return $TSt26;
4289 // }
4290 PHP_METHOD(ParserOutput, containsoldmagic)
4291 {
4292 zval* local_TSt26 = NULL;
4293 zval* local_this = getThis();
4294 // Function body
4295 // $TSt26 = $this->mContainsOldMagic;
4296 {
4297 if (local_this == NULL)
4298 {
4299 local_this = EG (uninitialized_zval_ptr);
4300 local_this->refcount++;
4301 }
4302 zval** p_obj = &local_this;
4303
4304 zval field_name;
4305 INIT_ZVAL (field_name);
4306 ZVAL_STRING (&field_name, "mContainsOldMagic", 0);
4307
4308 // I *think* this is correct, but documentation of the Zend API is scarce :)
4309 zval* field = Z_OBJ_HT_PP(p_obj)->read_property(*p_obj, &field_name, BP_VAR_R TSRMLS_CC);
4310 if (local_TSt26 == NULL)
4311 {
4312 local_TSt26 = EG (uninitialized_zval_ptr);
4313 local_TSt26->refcount++;
4314 }
4315 zval** p_lhs = &local_TSt26;
4316
4317 write_var (p_lhs, field);
4318 phc_check_invariants (TSRMLS_C);
4319 }
4320 // return $TSt26;
4321 {
4322 zval* rhs;
4323 if (local_TSt26 == NULL)
4324 rhs = EG (uninitialized_zval_ptr);
4325 else
4326 rhs = local_TSt26;
4327
4328 // Run-time return by reference has different semantics to compile-time.
4329 // If the function has CTRBR and RTRBR, the the assignment will be
4330 // reference. If one or the other is return-by-copy, the result will be
4331 // by copy. Its a question of whether its separated at return-time (which
4332 // we do here) or at the call-site.
4333 return_value->value = rhs->value;
4334 return_value->type = rhs->type;
4335 zval_copy_ctor (return_value);
4336 goto end_of_function;
4337 phc_check_invariants (TSRMLS_C);
4338 }
4339 // Method exit
4340 end_of_function:__attribute__((unused));
4341 if (local_TSt26 != NULL)
4342 {
4343 zval_ptr_dtor (&local_TSt26);
4344 }
4345 }
4346 // function settext($text)
4347 // {
4348 // $TLE104 = param_is_ref (NULL, "wfsetvar", 0);
4349 // ;
4350 // if (TLE104) goto L134 else goto L135;
4351 // L134:
4352 // $TMIt103 =& $this->mText;
4353 // goto L136;
4354 // L135:
4355 // $TMIt103 = $this->mText;
4356 // goto L136;
4357 // L136:
4358 // $TLE27 = wfsetvar($TMIt103, $text);
4359 // return $TLE27;
4360 // }
4361 PHP_METHOD(ParserOutput, settext)
4362 {
4363 zval* local_TLE104 = NULL;
4364 zval* local_TLE27 = NULL;
4365 zval* local_TMIt103 = NULL;
4366 zval* local_text = NULL;
4367 zval* local_this = getThis();
4368 // Add all parameters as local variables
4369 {
4370 int num_args = ZEND_NUM_ARGS ();
4371 zval* params[1];
4372 zend_get_parameters_array(0, num_args, params);
4373 // param 0
4374 params[0]->refcount++;
4375 if (local_text != NULL)
4376 {
4377 zval_ptr_dtor (&local_text);
4378 }
4379 local_text = params[0];
4380 }
4381 // Function body
4382 // $TLE104 = param_is_ref (NULL, "wfsetvar", 0);
4383 // ;
4384 {
4385 initialize_function_call (&wfsetvar_fci, &wfsetvar_fcic, "wfsetvar", "<unknown>", 0 TSRMLS_CC);
4386 zend_function* signature = wfsetvar_fcic.function_handler;
4387 zend_arg_info* arg_info = signature->common.arg_info;
4388 int count = 0;
4389 while (arg_info && count < 0)
4390 {
4391 count++;
4392 arg_info++;
4393 }
4394
4395 if (local_TLE104 == NULL)
4396 {
4397 local_TLE104 = EG (uninitialized_zval_ptr);
4398 local_TLE104->refcount++;
4399 }
4400 zval** p_lhs = &local_TLE104;
4401
4402 zval* rhs;
4403 ALLOC_INIT_ZVAL (rhs);
4404 if (arg_info && count == 0)
4405 {
4406 ZVAL_BOOL (rhs, arg_info->pass_by_reference);
4407 }
4408 else
4409 {
4410 ZVAL_BOOL (rhs, signature->common.pass_rest_by_reference);
4411 }
4412 write_var (p_lhs, rhs);
4413 zval_ptr_dtor (&rhs);
4414 phc_check_invariants (TSRMLS_C);
4415 }
4416 // if (TLE104) goto L134 else goto L135;
4417 {
4418 zval* p_cond;
4419 if (local_TLE104 == NULL)
4420 p_cond = EG (uninitialized_zval_ptr);
4421 else
4422 p_cond = local_TLE104;
4423
4424 zend_bool bcond = zend_is_true (p_cond);
4425 if (bcond)
4426 goto L134;
4427 else
4428 goto L135;
4429 phc_check_invariants (TSRMLS_C);
4430 }
4431 // L134:
4432 L134:;
4433 // $TMIt103 =& $this->mText;
4434 {
4435 if (local_this == NULL)
4436 {
4437 local_this = EG (uninitialized_zval_ptr);
4438 local_this->refcount++;
4439 }
4440 zval** p_obj = &local_this;
4441
4442 zval field_name;
4443 INIT_ZVAL (field_name);
4444 ZVAL_STRING (&field_name, "mText", 0);
4445
4446 zval** field = Z_OBJ_HT_PP(p_obj)->get_property_ptr_ptr(*p_obj, &field_name TSRMLS_CC);
4447 sep_copy_on_write (field);
4448 if (local_TMIt103 == NULL)
4449 {
4450 local_TMIt103 = EG (uninitialized_zval_ptr);
4451 local_TMIt103->refcount++;
4452 }
4453 zval** p_lhs = &local_TMIt103;
4454
4455 copy_into_ref (p_lhs, field);
4456 phc_check_invariants (TSRMLS_C);
4457 }
4458 // goto L136;
4459 {
4460 goto L136;
4461 phc_check_invariants (TSRMLS_C);
4462 }
4463 // L135:
4464 L135:;
4465 // $TMIt103 = $this->mText;
4466 {
4467 if (local_this == NULL)
4468 {
4469 local_this = EG (uninitialized_zval_ptr);
4470 local_this->refcount++;
4471 }
4472 zval** p_obj = &local_this;
4473
4474 zval field_name;
4475 INIT_ZVAL (field_name);
4476 ZVAL_STRING (&field_name, "mText", 0);
4477
4478 // I *think* this is correct, but documentation of the Zend API is scarce :)
4479 zval* field = Z_OBJ_HT_PP(p_obj)->read_property(*p_obj, &field_name, BP_VAR_R TSRMLS_CC);
4480 if (local_TMIt103 == NULL)
4481 {
4482 local_TMIt103 = EG (uninitialized_zval_ptr);
4483 local_TMIt103->refcount++;
4484 }
4485 zval** p_lhs = &local_TMIt103;
4486
4487 write_var (p_lhs, field);
4488 phc_check_invariants (TSRMLS_C);
4489 }
4490 // goto L136;
4491 {
4492 goto L136;
4493 phc_check_invariants (TSRMLS_C);
4494 }
4495 // L136:
4496 L136:;
4497 // $TLE27 = wfsetvar($TMIt103, $text);
4498 {
4499 initialize_function_call (&wfsetvar_fci, &wfsetvar_fcic, "wfsetvar", "/home/mdupont/2009/02/introspector/rdfintrospector/mediawiki/trunk/phase3/includes/parser/ParserOutput.php", 62 TSRMLS_CC);
4500 zend_function* signature = wfsetvar_fcic.function_handler;
4501 zend_arg_info* arg_info = signature->common.arg_info; // optional
4502
4503 int by_ref[2];
4504 int abr_index = 0;
4505 // TODO: find names to replace index
4506 if (arg_info)
4507 {
4508 by_ref[abr_index] = arg_info->pass_by_reference;
4509 arg_info++;
4510 }
4511 else
4512 by_ref[abr_index] = signature->common.pass_rest_by_reference;
4513
4514 abr_index++;
4515 // TODO: find names to replace index
4516 if (arg_info)
4517 {
4518 by_ref[abr_index] = arg_info->pass_by_reference;
4519 arg_info++;
4520 }
4521 else
4522 by_ref[abr_index] = signature->common.pass_rest_by_reference;
4523
4524 abr_index++;
4525
4526
4527 // Setup array of arguments
4528 // TODO: i think arrays of size 0 is an error
4529 int destruct [2];
4530 zval* args [2];
4531 zval** args_ind [2];
4532
4533 int af_index = 0;
4534 destruct[af_index] = 0;
4535 if (by_ref[af_index])
4536 {
4537 if (local_TMIt103 == NULL)
4538 {
4539 local_TMIt103 = EG (uninitialized_zval_ptr);
4540 local_TMIt103->refcount++;
4541 }
4542 zval** p_arg = &local_TMIt103;
4543
4544 args_ind[af_index] = fetch_var_arg_by_ref (p_arg);
4545 assert (!in_copy_on_write (*args_ind[af_index]));
4546 args[af_index] = *args_ind[af_index];
4547 }
4548 else
4549 {
4550 zval* arg;
4551 if (local_TMIt103 == NULL)
4552 arg = EG (uninitialized_zval_ptr);
4553 else
4554 arg = local_TMIt103;
4555
4556 args[af_index] = fetch_var_arg (arg, &destruct[af_index]);
4557 args_ind[af_index] = &args[af_index];
4558 }
4559 af_index++;
4560 destruct[af_index] = 0;
4561 if (by_ref[af_index])
4562 {
4563 if (local_text == NULL)
4564 {
4565 local_text = EG (uninitialized_zval_ptr);
4566 local_text->refcount++;
4567 }
4568 zval** p_arg = &local_text;
4569
4570 args_ind[af_index] = fetch_var_arg_by_ref (p_arg);
4571 assert (!in_copy_on_write (*args_ind[af_index]));
4572 args[af_index] = *args_ind[af_index];
4573 }
4574 else
4575 {
4576 zval* arg;
4577 if (local_text == NULL)
4578 arg = EG (uninitialized_zval_ptr);
4579 else
4580 arg = local_text;
4581
4582 args[af_index] = fetch_var_arg (arg, &destruct[af_index]);
4583 args_ind[af_index] = &args[af_index];
4584 }
4585 af_index++;
4586
4587
4588 phc_setup_error (1, "/home/mdupont/2009/02/introspector/rdfintrospector/mediawiki/trunk/phase3/includes/parser/ParserOutput.php", 62, NULL TSRMLS_CC);
4589
4590 // save existing parameters, in case of recursion
4591 int param_count_save = wfsetvar_fci.param_count;
4592 zval*** params_save = wfsetvar_fci.params;
4593 zval** retval_save = wfsetvar_fci.retval_ptr_ptr;
4594
4595 zval* rhs = NULL;
4596
4597 // set up params
4598 wfsetvar_fci.params = args_ind;
4599 wfsetvar_fci.param_count = 2;
4600 wfsetvar_fci.retval_ptr_ptr = &rhs;
4601
4602 // call the function
4603 int success = zend_call_function (&wfsetvar_fci, &wfsetvar_fcic TSRMLS_CC);
4604 assert(success == SUCCESS);
4605
4606 // restore params
4607 wfsetvar_fci.params = params_save;
4608 wfsetvar_fci.param_count = param_count_save;
4609 wfsetvar_fci.retval_ptr_ptr = retval_save;
4610
4611 // unset the errors
4612 phc_setup_error (0, NULL, 0, NULL TSRMLS_CC);
4613
4614 int i;
4615 for (i = 0; i < 2; i++)
4616 {
4617 if (destruct[i])
4618 {
4619 assert (destruct[i]);
4620 zval_ptr_dtor (args_ind[i]);
4621 }
4622 }
4623
4624
4625 // When the Zend engine returns by reference, it allocates a zval into
4626 // retval_ptr_ptr. To return by reference, the callee writes into the
4627 // retval_ptr_ptr, freeing the allocated value as it does. (Note, it may
4628 // not actually return anything). So the zval returned - whether we return
4629 // it, or it is the allocated zval - has a refcount of 1.
4630
4631 // The caller is responsible for cleaning that up (note, this is unaffected
4632 // by whether it is added to some COW set).
4633
4634 // For reasons unknown, the Zend API resets the refcount and is_ref fields
4635 // of the return value after the function returns (unless the callee is
4636 // interpreted). If the function is supposed to return by reference, this
4637 // loses the refcount. This only happens when non-interpreted code is
4638 // called. We work around it, when compiled code is called, by saving the
4639 // refcount into SAVED_REFCOUNT, in the return statement. The downside is
4640 // that we may create an error if our code is called by a callback, and
4641 // returns by reference, and the callback returns by reference. At least
4642 // this is an obscure case.
4643 if(signature->common.return_reference && signature->type != ZEND_USER_FUNCTION)
4644 {
4645 assert (rhs != EG(uninitialized_zval_ptr));
4646 rhs->is_ref = 1;
4647 if (saved_refcount != 0)
4648 {
4649 rhs->refcount = saved_refcount;
4650 }
4651 rhs->refcount++;
4652 }
4653 saved_refcount = 0; // for 'obscure cases'
4654
4655 if (local_TLE27 == NULL)
4656 {
4657 local_TLE27 = EG (uninitialized_zval_ptr);
4658 local_TLE27->refcount++;
4659 }
4660 zval** p_lhs = &local_TLE27;
4661
4662 write_var (p_lhs, rhs);
4663
4664
4665 zval_ptr_dtor (&rhs);
4666 if(signature->common.return_reference && signature->type != ZEND_USER_FUNCTION)
4667 zval_ptr_dtor (&rhs);
4668
4669 phc_check_invariants (TSRMLS_C);
4670 }
4671 // return $TLE27;
4672 {
4673 zval* rhs;
4674 if (local_TLE27 == NULL)
4675 rhs = EG (uninitialized_zval_ptr);
4676 else
4677 rhs = local_TLE27;
4678
4679 // Run-time return by reference has different semantics to compile-time.
4680 // If the function has CTRBR and RTRBR, the the assignment will be
4681 // reference. If one or the other is return-by-copy, the result will be
4682 // by copy. Its a question of whether its separated at return-time (which
4683 // we do here) or at the call-site.
4684 return_value->value = rhs->value;
4685 return_value->type = rhs->type;
4686 zval_copy_ctor (return_value);
4687 goto end_of_function;
4688 phc_check_invariants (TSRMLS_C);
4689 }
4690 // Method exit
4691 end_of_function:__attribute__((unused));
4692 if (local_TLE104 != NULL)
4693 {
4694 zval_ptr_dtor (&local_TLE104);
4695 }
4696 if (local_TLE27 != NULL)
4697 {
4698 zval_ptr_dtor (&local_TLE27);
4699 }
4700 if (local_TMIt103 != NULL)
4701 {
4702 zval_ptr_dtor (&local_TMIt103);
4703 }
4704 if (local_text != NULL)
4705 {
4706 zval_ptr_dtor (&local_text);
4707 }
4708 }
4709 // function setlanguagelinks($ll)
4710 // {
4711 // $TLE106 = param_is_ref (NULL, "wfsetvar", 0);
4712 // ;
4713 // if (TLE106) goto L137 else goto L138;
4714 // L137:
4715 // $TMIt105 =& $this->mLanguageLinks;
4716 // goto L139;
4717 // L138:
4718 // $TMIt105 = $this->mLanguageLinks;
4719 // goto L139;
4720 // L139:
4721 // $TLE28 = wfsetvar($TMIt105, $ll);
4722 // return $TLE28;
4723 // }
4724 PHP_METHOD(ParserOutput, setlanguagelinks)
4725 {
4726 zval* local_TLE106 = NULL;
4727 zval* local_TLE28 = NULL;
4728 zval* local_TMIt105 = NULL;
4729 zval* local_ll = NULL;
4730 zval* local_this = getThis();
4731 // Add all parameters as local variables
4732 {
4733 int num_args = ZEND_NUM_ARGS ();
4734 zval* params[1];
4735 zend_get_parameters_array(0, num_args, params);
4736 // param 0
4737 params[0]->refcount++;
4738 if (local_ll != NULL)
4739 {
4740 zval_ptr_dtor (&local_ll);
4741 }
4742 local_ll = params[0];
4743 }
4744 // Function body
4745 // $TLE106 = param_is_ref (NULL, "wfsetvar", 0);
4746 // ;
4747 {
4748 initialize_function_call (&wfsetvar_fci, &wfsetvar_fcic, "wfsetvar", "<unknown>", 0 TSRMLS_CC);
4749 zend_function* signature = wfsetvar_fcic.function_handler;
4750 zend_arg_info* arg_info = signature->common.arg_info;
4751 int count = 0;
4752 while (arg_info && count < 0)
4753 {
4754 count++;
4755 arg_info++;
4756 }
4757
4758 if (local_TLE106 == NULL)
4759 {
4760 local_TLE106 = EG (uninitialized_zval_ptr);
4761 local_TLE106->refcount++;
4762 }
4763 zval** p_lhs = &local_TLE106;
4764
4765 zval* rhs;
4766 ALLOC_INIT_ZVAL (rhs);
4767 if (arg_info && count == 0)
4768 {
4769 ZVAL_BOOL (rhs, arg_info->pass_by_reference);
4770 }
4771 else
4772 {
4773 ZVAL_BOOL (rhs, signature->common.pass_rest_by_reference);
4774 }
4775 write_var (p_lhs, rhs);
4776 zval_ptr_dtor (&rhs);
4777 phc_check_invariants (TSRMLS_C);
4778 }
4779 // if (TLE106) goto L137 else goto L138;
4780 {
4781 zval* p_cond;
4782 if (local_TLE106 == NULL)
4783 p_cond = EG (uninitialized_zval_ptr);
4784 else
4785 p_cond = local_TLE106;
4786
4787 zend_bool bcond = zend_is_true (p_cond);
4788 if (bcond)
4789 goto L137;
4790 else
4791 goto L138;
4792 phc_check_invariants (TSRMLS_C);
4793 }
4794 // L137:
4795 L137:;
4796 // $TMIt105 =& $this->mLanguageLinks;
4797 {
4798 if (local_this == NULL)
4799 {
4800 local_this = EG (uninitialized_zval_ptr);
4801 local_this->refcount++;
4802 }
4803 zval** p_obj = &local_this;
4804
4805 zval field_name;
4806 INIT_ZVAL (field_name);
4807 ZVAL_STRING (&field_name, "mLanguageLinks", 0);
4808
4809 zval** field = Z_OBJ_HT_PP(p_obj)->get_property_ptr_ptr(*p_obj, &field_name TSRMLS_CC);
4810 sep_copy_on_write (field);
4811 if (local_TMIt105 == NULL)
4812 {
4813 local_TMIt105 = EG (uninitialized_zval_ptr);
4814 local_TMIt105->refcount++;
4815 }
4816 zval** p_lhs = &local_TMIt105;
4817
4818 copy_into_ref (p_lhs, field);
4819 phc_check_invariants (TSRMLS_C);
4820 }
4821 // goto L139;
4822 {
4823 goto L139;
4824 phc_check_invariants (TSRMLS_C);
4825 }
4826 // L138:
4827 L138:;
4828 // $TMIt105 = $this->mLanguageLinks;
4829 {
4830 if (local_this == NULL)
4831 {
4832 local_this = EG (uninitialized_zval_ptr);
4833 local_this->refcount++;
4834 }
4835 zval** p_obj = &local_this;
4836
4837 zval field_name;
4838 INIT_ZVAL (field_name);
4839 ZVAL_STRING (&field_name, "mLanguageLinks", 0);
4840
4841 // I *think* this is correct, but documentation of the Zend API is scarce :)
4842 zval* field = Z_OBJ_HT_PP(p_obj)->read_property(*p_obj, &field_name, BP_VAR_R TSRMLS_CC);
4843 if (local_TMIt105 == NULL)
4844 {
4845 local_TMIt105 = EG (uninitialized_zval_ptr);
4846 local_TMIt105->refcount++;
4847 }
4848 zval** p_lhs = &local_TMIt105;
4849
4850 write_var (p_lhs, field);
4851 phc_check_invariants (TSRMLS_C);
4852 }
4853 // goto L139;
4854 {
4855 goto L139;
4856 phc_check_invariants (TSRMLS_C);
4857 }
4858 // L139:
4859 L139:;
4860 // $TLE28 = wfsetvar($TMIt105, $ll);
4861 {
4862 initialize_function_call (&wfsetvar_fci, &wfsetvar_fcic, "wfsetvar", "/home/mdupont/2009/02/introspector/rdfintrospector/mediawiki/trunk/phase3/includes/parser/ParserOutput.php", 63 TSRMLS_CC);
4863 zend_function* signature = wfsetvar_fcic.function_handler;
4864 zend_arg_info* arg_info = signature->common.arg_info; // optional
4865
4866 int by_ref[2];
4867 int abr_index = 0;
4868 // TODO: find names to replace index
4869 if (arg_info)
4870 {
4871 by_ref[abr_index] = arg_info->pass_by_reference;
4872 arg_info++;
4873 }
4874 else
4875 by_ref[abr_index] = signature->common.pass_rest_by_reference;
4876
4877 abr_index++;
4878 // TODO: find names to replace index
4879 if (arg_info)
4880 {
4881 by_ref[abr_index] = arg_info->pass_by_reference;
4882 arg_info++;
4883 }
4884 else
4885 by_ref[abr_index] = signature->common.pass_rest_by_reference;
4886
4887 abr_index++;
4888
4889
4890 // Setup array of arguments
4891 // TODO: i think arrays of size 0 is an error
4892 int destruct [2];
4893 zval* args [2];
4894 zval** args_ind [2];
4895
4896 int af_index = 0;
4897 destruct[af_index] = 0;
4898 if (by_ref[af_index])
4899 {
4900 if (local_TMIt105 == NULL)
4901 {
4902 local_TMIt105 = EG (uninitialized_zval_ptr);
4903 local_TMIt105->refcount++;
4904 }
4905 zval** p_arg = &local_TMIt105;
4906
4907 args_ind[af_index] = fetch_var_arg_by_ref (p_arg);
4908 assert (!in_copy_on_write (*args_ind[af_index]));
4909 args[af_index] = *args_ind[af_index];
4910 }
4911 else
4912 {
4913 zval* arg;
4914 if (local_TMIt105 == NULL)
4915 arg = EG (uninitialized_zval_ptr);
4916 else
4917 arg = local_TMIt105;
4918
4919 args[af_index] = fetch_var_arg (arg, &destruct[af_index]);
4920 args_ind[af_index] = &args[af_index];
4921 }
4922 af_index++;
4923 destruct[af_index] = 0;
4924 if (by_ref[af_index])
4925 {
4926 if (local_ll == NULL)
4927 {
4928 local_ll = EG (uninitialized_zval_ptr);
4929 local_ll->refcount++;
4930 }
4931 zval** p_arg = &local_ll;
4932
4933 args_ind[af_index] = fetch_var_arg_by_ref (p_arg);
4934 assert (!in_copy_on_write (*args_ind[af_index]));
4935 args[af_index] = *args_ind[af_index];
4936 }
4937 else
4938 {
4939 zval* arg;
4940 if (local_ll == NULL)
4941 arg = EG (uninitialized_zval_ptr);
4942 else
4943 arg = local_ll;
4944
4945 args[af_index] = fetch_var_arg (arg, &destruct[af_index]);
4946 args_ind[af_index] = &args[af_index];
4947 }
4948 af_index++;
4949
4950
4951 phc_setup_error (1, "/home/mdupont/2009/02/introspector/rdfintrospector/mediawiki/trunk/phase3/includes/parser/ParserOutput.php", 63, NULL TSRMLS_CC);
4952
4953 // save existing parameters, in case of recursion
4954 int param_count_save = wfsetvar_fci.param_count;
4955 zval*** params_save = wfsetvar_fci.params;
4956 zval** retval_save = wfsetvar_fci.retval_ptr_ptr;
4957
4958 zval* rhs = NULL;
4959
4960 // set up params
4961 wfsetvar_fci.params = args_ind;
4962 wfsetvar_fci.param_count = 2;
4963 wfsetvar_fci.retval_ptr_ptr = &rhs;
4964
4965 // call the function
4966 int success = zend_call_function (&wfsetvar_fci, &wfsetvar_fcic TSRMLS_CC);
4967 assert(success == SUCCESS);
4968
4969 // restore params
4970 wfsetvar_fci.params = params_save;
4971 wfsetvar_fci.param_count = param_count_save;
4972 wfsetvar_fci.retval_ptr_ptr = retval_save;
4973
4974 // unset the errors
4975 phc_setup_error (0, NULL, 0, NULL TSRMLS_CC);
4976
4977 int i;
4978 for (i = 0; i < 2; i++)
4979 {
4980 if (destruct[i])
4981 {
4982 assert (destruct[i]);
4983 zval_ptr_dtor (args_ind[i]);
4984 }
4985 }
4986
4987
4988 // When the Zend engine returns by reference, it allocates a zval into
4989 // retval_ptr_ptr. To return by reference, the callee writes into the
4990 // retval_ptr_ptr, freeing the allocated value as it does. (Note, it may
4991 // not actually return anything). So the zval returned - whether we return
4992 // it, or it is the allocated zval - has a refcount of 1.
4993
4994 // The caller is responsible for cleaning that up (note, this is unaffected
4995 // by whether it is added to some COW set).
4996
4997 // For reasons unknown, the Zend API resets the refcount and is_ref fields
4998 // of the return value after the function returns (unless the callee is
4999 // interpreted). If the function is supposed to return by reference, this
5000 // loses the refcount. This only happens when non-interpreted code is
5001 // called. We work around it, when compiled code is called, by saving the
5002 // refcount into SAVED_REFCOUNT, in the return statement. The downside is
5003 // that we may create an error if our code is called by a callback, and
5004 // returns by reference, and the callback returns by reference. At least
5005 // this is an obscure case.
5006 if(signature->common.return_reference && signature->type != ZEND_USER_FUNCTION)
5007 {
5008 assert (rhs != EG(uninitialized_zval_ptr));
5009 rhs->is_ref = 1;
5010 if (saved_refcount != 0)
5011 {
5012 rhs->refcount = saved_refcount;
5013 }
5014 rhs->refcount++;
5015 }
5016 saved_refcount = 0; // for 'obscure cases'
5017
5018 if (local_TLE28 == NULL)
5019 {
5020 local_TLE28 = EG (uninitialized_zval_ptr);
5021 local_TLE28->refcount++;
5022 }
5023 zval** p_lhs = &local_TLE28;
5024
5025 write_var (p_lhs, rhs);
5026
5027
5028 zval_ptr_dtor (&rhs);
5029 if(signature->common.return_reference && signature->type != ZEND_USER_FUNCTION)
5030 zval_ptr_dtor (&rhs);
5031
5032 phc_check_invariants (TSRMLS_C);
5033 }
5034 // return $TLE28;
5035 {
5036 zval* rhs;
5037 if (local_TLE28 == NULL)
5038 rhs = EG (uninitialized_zval_ptr);
5039 else
5040 rhs = local_TLE28;
5041
5042 // Run-time return by reference has different semantics to compile-time.
5043 // If the function has CTRBR and RTRBR, the the assignment will be
5044 // reference. If one or the other is return-by-copy, the result will be
5045 // by copy. Its a question of whether its separated at return-time (which
5046 // we do here) or at the call-site.
5047 return_value->value = rhs->value;
5048 return_value->type = rhs->type;
5049 zval_copy_ctor (return_value);
5050 goto end_of_function;
5051 phc_check_invariants (TSRMLS_C);
5052 }
5053 // Method exit
5054 end_of_function:__attribute__((unused));
5055 if (local_TLE106 != NULL)
5056 {
5057 zval_ptr_dtor (&local_TLE106);
5058 }
5059 if (local_TLE28 != NULL)
5060 {
5061 zval_ptr_dtor (&local_TLE28);
5062 }
5063 if (local_TMIt105 != NULL)
5064 {
5065 zval_ptr_dtor (&local_TMIt105);
5066 }
5067 if (local_ll != NULL)
5068 {
5069 zval_ptr_dtor (&local_ll);
5070 }
5071 }
5072 // function setcategorylinks($cl)
5073 // {
5074 // $TLE108 = param_is_ref (NULL, "wfsetvar", 0);
5075 // ;
5076 // if (TLE108) goto L140 else goto L141;
5077 // L140:
5078 // $TMIt107 =& $this->mCategories;
5079 // goto L142;
5080 // L141:
5081 // $TMIt107 = $this->mCategories;
5082 // goto L142;
5083 // L142:
5084 // $TLE29 = wfsetvar($TMIt107, $cl);
5085 // return $TLE29;
5086 // }
5087 PHP_METHOD(ParserOutput, setcategorylinks)
5088 {
5089 zval* local_TLE108 = NULL;
5090 zval* local_TLE29 = NULL;
5091 zval* local_TMIt107 = NULL;
5092 zval* local_cl = NULL;
5093 zval* local_this = getThis();
5094 // Add all parameters as local variables
5095 {
5096 int num_args = ZEND_NUM_ARGS ();
5097 zval* params[1];
5098 zend_get_parameters_array(0, num_args, params);
5099 // param 0
5100 params[0]->refcount++;
5101 if (local_cl != NULL)
5102 {
5103 zval_ptr_dtor (&local_cl);
5104 }
5105 local_cl = params[0];
5106 }
5107 // Function body
5108 // $TLE108 = param_is_ref (NULL, "wfsetvar", 0);
5109 // ;
5110 {
5111 initialize_function_call (&wfsetvar_fci, &wfsetvar_fcic, "wfsetvar", "<unknown>", 0 TSRMLS_CC);
5112 zend_function* signature = wfsetvar_fcic.function_handler;
5113 zend_arg_info* arg_info = signature->common.arg_info;
5114 int count = 0;
5115 while (arg_info && count < 0)
5116 {
5117 count++;
5118 arg_info++;
5119 }
5120
5121 if (local_TLE108 == NULL)
5122 {
5123 local_TLE108 = EG (uninitialized_zval_ptr);
5124 local_TLE108->refcount++;
5125 }
5126 zval** p_lhs = &local_TLE108;
5127
5128 zval* rhs;
5129 ALLOC_INIT_ZVAL (rhs);
5130 if (arg_info && count == 0)
5131 {
5132 ZVAL_BOOL (rhs, arg_info->pass_by_reference);
5133 }
5134 else
5135 {
5136 ZVAL_BOOL (rhs, signature->common.pass_rest_by_reference);
5137 }
5138 write_var (p_lhs, rhs);
5139 zval_ptr_dtor (&rhs);
5140 phc_check_invariants (TSRMLS_C);
5141 }
5142 // if (TLE108) goto L140 else goto L141;
5143 {
5144 zval* p_cond;
5145 if (local_TLE108 == NULL)
5146 p_cond = EG (uninitialized_zval_ptr);
5147 else
5148 p_cond = local_TLE108;
5149
5150 zend_bool bcond = zend_is_true (p_cond);
5151 if (bcond)
5152 goto L140;
5153 else
5154 goto L141;
5155 phc_check_invariants (TSRMLS_C);
5156 }
5157 // L140:
5158 L140:;
5159 // $TMIt107 =& $this->mCategories;
5160 {
5161 if (local_this == NULL)
5162 {
5163 local_this = EG (uninitialized_zval_ptr);
5164 local_this->refcount++;
5165 }
5166 zval** p_obj = &local_this;
5167
5168 zval field_name;
5169 INIT_ZVAL (field_name);
5170 ZVAL_STRING (&field_name, "mCategories", 0);
5171
5172 zval** field = Z_OBJ_HT_PP(p_obj)->get_property_ptr_ptr(*p_obj, &field_name TSRMLS_CC);
5173 sep_copy_on_write (field);
5174 if (local_TMIt107 == NULL)
5175 {
5176 local_TMIt107 = EG (uninitialized_zval_ptr);
5177 local_TMIt107->refcount++;
5178 }
5179 zval** p_lhs = &local_TMIt107;
5180
5181 copy_into_ref (p_lhs, field);
5182 phc_check_invariants (TSRMLS_C);
5183 }
5184 // goto L142;
5185 {
5186 goto L142;
5187 phc_check_invariants (TSRMLS_C);
5188 }
5189 // L141:
5190 L141:;
5191 // $TMIt107 = $this->mCategories;
5192 {
5193 if (local_this == NULL)
5194 {
5195 local_this = EG (uninitialized_zval_ptr);
5196 local_this->refcount++;
5197 }
5198 zval** p_obj = &local_this;
5199
5200 zval field_name;
5201 INIT_ZVAL (field_name);
5202 ZVAL_STRING (&field_name, "mCategories", 0);
5203
5204 // I *think* this is correct, but documentation of the Zend API is scarce :)
5205 zval* field = Z_OBJ_HT_PP(p_obj)->read_property(*p_obj, &field_name, BP_VAR_R TSRMLS_CC);
5206 if (local_TMIt107 == NULL)
5207 {
5208 local_TMIt107 = EG (uninitialized_zval_ptr);
5209 local_TMIt107->refcount++;
5210 }
5211 zval** p_lhs = &local_TMIt107;
5212
5213 write_var (p_lhs, field);
5214 phc_check_invariants (TSRMLS_C);
5215 }
5216 // goto L142;
5217 {
5218 goto L142;
5219 phc_check_invariants (TSRMLS_C);
5220 }
5221 // L142:
5222 L142:;
5223 // $TLE29 = wfsetvar($TMIt107, $cl);
5224 {
5225 initialize_function_call (&wfsetvar_fci, &wfsetvar_fcic, "wfsetvar", "/home/mdupont/2009/02/introspector/rdfintrospector/mediawiki/trunk/phase3/includes/parser/ParserOutput.php", 64 TSRMLS_CC);
5226 zend_function* signature = wfsetvar_fcic.function_handler;
5227 zend_arg_info* arg_info = signature->common.arg_info; // optional
5228
5229 int by_ref[2];
5230 int abr_index = 0;
5231 // TODO: find names to replace index
5232 if (arg_info)
5233 {
5234 by_ref[abr_index] = arg_info->pass_by_reference;
5235 arg_info++;
5236 }
5237 else
5238 by_ref[abr_index] = signature->common.pass_rest_by_reference;
5239
5240 abr_index++;
5241 // TODO: find names to replace index
5242 if (arg_info)
5243 {
5244 by_ref[abr_index] = arg_info->pass_by_reference;
5245 arg_info++;
5246 }
5247 else
5248 by_ref[abr_index] = signature->common.pass_rest_by_reference;
5249
5250 abr_index++;
5251
5252
5253 // Setup array of arguments
5254 // TODO: i think arrays of size 0 is an error
5255 int destruct [2];
5256 zval* args [2];
5257 zval** args_ind [2];
5258
5259 int af_index = 0;
5260 destruct[af_index] = 0;
5261 if (by_ref[af_index])
5262 {
5263 if (local_TMIt107 == NULL)
5264 {
5265 local_TMIt107 = EG (uninitialized_zval_ptr);
5266 local_TMIt107->refcount++;
5267 }
5268 zval** p_arg = &local_TMIt107;
5269
5270 args_ind[af_index] = fetch_var_arg_by_ref (p_arg);
5271 assert (!in_copy_on_write (*args_ind[af_index]));
5272 args[af_index] = *args_ind[af_index];
5273 }
5274 else
5275 {
5276 zval* arg;
5277 if (local_TMIt107 == NULL)
5278 arg = EG (uninitialized_zval_ptr);
5279 else
5280 arg = local_TMIt107;
5281
5282 args[af_index] = fetch_var_arg (arg, &destruct[af_index]);
5283 args_ind[af_index] = &args[af_index];
5284 }
5285 af_index++;
5286 destruct[af_index] = 0;
5287 if (by_ref[af_index])
5288 {
5289 if (local_cl == NULL)
5290 {
5291 local_cl = EG (uninitialized_zval_ptr);
5292 local_cl->refcount++;
5293 }
5294 zval** p_arg = &local_cl;
5295
5296 args_ind[af_index] = fetch_var_arg_by_ref (p_arg);
5297 assert (!in_copy_on_write (*args_ind[af_index]));
5298 args[af_index] = *args_ind[af_index];
5299 }
5300 else
5301 {
5302 zval* arg;
5303 if (local_cl == NULL)
5304 arg = EG (uninitialized_zval_ptr);
5305 else
5306 arg = local_cl;
5307
5308 args[af_index] = fetch_var_arg (arg, &destruct[af_index]);
5309 args_ind[af_index] = &args[af_index];
5310 }
5311 af_index++;
5312
5313
5314 phc_setup_error (1, "/home/mdupont/2009/02/introspector/rdfintrospector/mediawiki/trunk/phase3/includes/parser/ParserOutput.php", 64, NULL TSRMLS_CC);
5315
5316 // save existing parameters, in case of recursion
5317 int param_count_save = wfsetvar_fci.param_count;
5318 zval*** params_save = wfsetvar_fci.params;
5319 zval** retval_save = wfsetvar_fci.retval_ptr_ptr;
5320
5321 zval* rhs = NULL;
5322
5323 // set up params
5324 wfsetvar_fci.params = args_ind;
5325 wfsetvar_fci.param_count = 2;
5326 wfsetvar_fci.retval_ptr_ptr = &rhs;
5327
5328 // call the function
5329 int success = zend_call_function (&wfsetvar_fci, &wfsetvar_fcic TSRMLS_CC);
5330 assert(success == SUCCESS);
5331
5332 // restore params
5333 wfsetvar_fci.params = params_save;
5334 wfsetvar_fci.param_count = param_count_save;
5335 wfsetvar_fci.retval_ptr_ptr = retval_save;
5336
5337 // unset the errors
5338 phc_setup_error (0, NULL, 0, NULL TSRMLS_CC);
5339
5340 int i;
5341 for (i = 0; i < 2; i++)
5342 {
5343 if (destruct[i])
5344 {
5345 assert (destruct[i]);
5346 zval_ptr_dtor (args_ind[i]);
5347 }
5348 }
5349
5350
5351 // When the Zend engine returns by reference, it allocates a zval into
5352 // retval_ptr_ptr. To return by reference, the callee writes into the
5353 // retval_ptr_ptr, freeing the allocated value as it does. (Note, it may
5354 // not actually return anything). So the zval returned - whether we return
5355 // it, or it is the allocated zval - has a refcount of 1.
5356
5357 // The caller is responsible for cleaning that up (note, this is unaffected
5358 // by whether it is added to some COW set).
5359
5360 // For reasons unknown, the Zend API resets the refcount and is_ref fields
5361 // of the return value after the function returns (unless the callee is
5362 // interpreted). If the function is supposed to return by reference, this
5363 // loses the refcount. This only happens when non-interpreted code is
5364 // called. We work around it, when compiled code is called, by saving the
5365 // refcount into SAVED_REFCOUNT, in the return statement. The downside is
5366 // that we may create an error if our code is called by a callback, and
5367 // returns by reference, and the callback returns by reference. At least
5368 // this is an obscure case.
5369 if(signature->common.return_reference && signature->type != ZEND_USER_FUNCTION)
5370 {
5371 assert (rhs != EG(uninitialized_zval_ptr));
5372 rhs->is_ref = 1;
5373 if (saved_refcount != 0)
5374 {
5375 rhs->refcount = saved_refcount;
5376 }
5377 rhs->refcount++;
5378 }
5379 saved_refcount = 0; // for 'obscure cases'
5380
5381 if (local_TLE29 == NULL)
5382 {
5383 local_TLE29 = EG (uninitialized_zval_ptr);
5384 local_TLE29->refcount++;
5385 }
5386 zval** p_lhs = &local_TLE29;
5387
5388 write_var (p_lhs, rhs);
5389
5390
5391 zval_ptr_dtor (&rhs);
5392 if(signature->common.return_reference && signature->type != ZEND_USER_FUNCTION)
5393 zval_ptr_dtor (&rhs);
5394
5395 phc_check_invariants (TSRMLS_C);
5396 }
5397 // return $TLE29;
5398 {
5399 zval* rhs;
5400 if (local_TLE29 == NULL)
5401 rhs = EG (uninitialized_zval_ptr);
5402 else
5403 rhs = local_TLE29;
5404
5405 // Run-time return by reference has different semantics to compile-time.
5406 // If the function has CTRBR and RTRBR, the the assignment will be
5407 // reference. If one or the other is return-by-copy, the result will be
5408 // by copy. Its a question of whether its separated at return-time (which
5409 // we do here) or at the call-site.
5410 return_value->value = rhs->value;
5411 return_value->type = rhs->type;
5412 zval_copy_ctor (return_value);
5413 goto end_of_function;
5414 phc_check_invariants (TSRMLS_C);
5415 }
5416 // Method exit
5417 end_of_function:__attribute__((unused));
5418 if (local_TLE108 != NULL)
5419 {
5420 zval_ptr_dtor (&local_TLE108);
5421 }
5422 if (local_TLE29 != NULL)
5423 {
5424 zval_ptr_dtor (&local_TLE29);
5425 }
5426 if (local_TMIt107 != NULL)
5427 {
5428 zval_ptr_dtor (&local_TMIt107);
5429 }
5430 if (local_cl != NULL)
5431 {
5432 zval_ptr_dtor (&local_cl);
5433 }
5434 }
5435 // function setcontainsoldmagic($com)
5436 // {
5437 // $TLE110 = param_is_ref (NULL, "wfsetvar", 0);
5438 // ;
5439 // if (TLE110) goto L143 else goto L144;
5440 // L143:
5441 // $TMIt109 =& $this->mContainsOldMagic;
5442 // goto L145;
5443 // L144:
5444 // $TMIt109 = $this->mContainsOldMagic;
5445 // goto L145;
5446 // L145:
5447 // $TLE30 = wfsetvar($TMIt109, $com);
5448 // return $TLE30;
5449 // }
5450 PHP_METHOD(ParserOutput, setcontainsoldmagic)
5451 {
5452 zval* local_TLE110 = NULL;
5453 zval* local_TLE30 = NULL;
5454 zval* local_TMIt109 = NULL;
5455 zval* local_com = NULL;
5456 zval* local_this = getThis();
5457 // Add all parameters as local variables
5458 {
5459 int num_args = ZEND_NUM_ARGS ();
5460 zval* params[1];
5461 zend_get_parameters_array(0, num_args, params);
5462 // param 0
5463 params[0]->refcount++;
5464 if (local_com != NULL)
5465 {
5466 zval_ptr_dtor (&local_com);
5467 }
5468 local_com = params[0];
5469 }
5470 // Function body
5471 // $TLE110 = param_is_ref (NULL, "wfsetvar", 0);
5472 // ;
5473 {
5474 initialize_function_call (&wfsetvar_fci, &wfsetvar_fcic, "wfsetvar", "<unknown>", 0 TSRMLS_CC);
5475 zend_function* signature = wfsetvar_fcic.function_handler;
5476 zend_arg_info* arg_info = signature->common.arg_info;
5477 int count = 0;
5478 while (arg_info && count < 0)
5479 {
5480 count++;
5481 arg_info++;
5482 }
5483
5484 if (local_TLE110 == NULL)
5485 {
5486 local_TLE110 = EG (uninitialized_zval_ptr);
5487 local_TLE110->refcount++;
5488 }
5489 zval** p_lhs = &local_TLE110;
5490
5491 zval* rhs;
5492 ALLOC_INIT_ZVAL (rhs);
5493 if (arg_info && count == 0)
5494 {
5495 ZVAL_BOOL (rhs, arg_info->pass_by_reference);
5496 }
5497 else
5498 {
5499 ZVAL_BOOL (rhs, signature->common.pass_rest_by_reference);
5500 }
5501 write_var (p_lhs, rhs);
5502 zval_ptr_dtor (&rhs);
5503 phc_check_invariants (TSRMLS_C);
5504 }
5505 // if (TLE110) goto L143 else goto L144;
5506 {
5507 zval* p_cond;
5508 if (local_TLE110 == NULL)
5509 p_cond = EG (uninitialized_zval_ptr);
5510 else
5511 p_cond = local_TLE110;
5512
5513 zend_bool bcond = zend_is_true (p_cond);
5514 if (bcond)
5515 goto L143;
5516 else
5517 goto L144;
5518 phc_check_invariants (TSRMLS_C);
5519 }
5520 // L143:
5521 L143:;
5522 // $TMIt109 =& $this->mContainsOldMagic;
5523 {
5524 if (local_this == NULL)
5525 {
5526 local_this = EG (uninitialized_zval_ptr);
5527 local_this->refcount++;
5528 }
5529 zval** p_obj = &local_this;
5530
5531 zval field_name;
5532 INIT_ZVAL (field_name);
5533 ZVAL_STRING (&field_name, "mContainsOldMagic", 0);
5534
5535 zval** field = Z_OBJ_HT_PP(p_obj)->get_property_ptr_ptr(*p_obj, &field_name TSRMLS_CC);
5536 sep_copy_on_write (field);
5537 if (local_TMIt109 == NULL)
5538 {
5539 local_TMIt109 = EG (uninitialized_zval_ptr);
5540 local_TMIt109->refcount++;
5541 }
5542 zval** p_lhs = &local_TMIt109;
5543
5544 copy_into_ref (p_lhs, field);
5545 phc_check_invariants (TSRMLS_C);
5546 }
5547 // goto L145;
5548 {
5549 goto L145;
5550 phc_check_invariants (TSRMLS_C);
5551 }
5552 // L144:
5553 L144:;
5554 // $TMIt109 = $this->mContainsOldMagic;
5555 {
5556 if (local_this == NULL)
5557 {
5558 local_this = EG (uninitialized_zval_ptr);
5559 local_this->refcount++;
5560 }
5561 zval** p_obj = &local_this;
5562
5563 zval field_name;
5564 INIT_ZVAL (field_name);
5565 ZVAL_STRING (&field_name, "mContainsOldMagic", 0);
5566
5567 // I *think* this is correct, but documentation of the Zend API is scarce :)
5568 zval* field = Z_OBJ_HT_PP(p_obj)->read_property(*p_obj, &field_name, BP_VAR_R TSRMLS_CC);
5569 if (local_TMIt109 == NULL)
5570 {
5571 local_TMIt109 = EG (uninitialized_zval_ptr);
5572 local_TMIt109->refcount++;
5573 }
5574 zval** p_lhs = &local_TMIt109;
5575
5576 write_var (p_lhs, field);
5577 phc_check_invariants (TSRMLS_C);
5578 }
5579 // goto L145;
5580 {
5581 goto L145;
5582 phc_check_invariants (TSRMLS_C);
5583 }
5584 // L145:
5585 L145:;
5586 // $TLE30 = wfsetvar($TMIt109, $com);
5587 {
5588 initialize_function_call (&wfsetvar_fci, &wfsetvar_fcic, "wfsetvar", "/home/mdupont/2009/02/introspector/rdfintrospector/mediawiki/trunk/phase3/includes/parser/ParserOutput.php", 65 TSRMLS_CC);
5589 zend_function* signature = wfsetvar_fcic.function_handler;
5590 zend_arg_info* arg_info = signature->common.arg_info; // optional
5591
5592 int by_ref[2];
5593 int abr_index = 0;
5594 // TODO: find names to replace index
5595 if (arg_info)
5596 {
5597 by_ref[abr_index] = arg_info->pass_by_reference;
5598 arg_info++;
5599 }
5600 else
5601 by_ref[abr_index] = signature->common.pass_rest_by_reference;
5602
5603 abr_index++;
5604 // TODO: find names to replace index
5605 if (arg_info)
5606 {
5607 by_ref[abr_index] = arg_info->pass_by_reference;
5608 arg_info++;
5609 }
5610 else
5611 by_ref[abr_index] = signature->common.pass_rest_by_reference;
5612
5613 abr_index++;
5614
5615
5616 // Setup array of arguments
5617 // TODO: i think arrays of size 0 is an error
5618 int destruct [2];
5619 zval* args [2];
5620 zval** args_ind [2];
5621
5622 int af_index = 0;
5623 destruct[af_index] = 0;
5624 if (by_ref[af_index])
5625 {
5626 if (local_TMIt109 == NULL)
5627 {
5628 local_TMIt109 = EG (uninitialized_zval_ptr);
5629 local_TMIt109->refcount++;
5630 }
5631 zval** p_arg = &local_TMIt109;
5632
5633 args_ind[af_index] = fetch_var_arg_by_ref (p_arg);
5634 assert (!in_copy_on_write (*args_ind[af_index]));
5635 args[af_index] = *args_ind[af_index];
5636 }
5637 else
5638 {
5639 zval* arg;
5640 if (local_TMIt109 == NULL)
5641 arg = EG (uninitialized_zval_ptr);
5642 else
5643 arg = local_TMIt109;
5644
5645 args[af_index] = fetch_var_arg (arg, &destruct[af_index]);
5646 args_ind[af_index] = &args[af_index];
5647 }
5648 af_index++;
5649 destruct[af_index] = 0;
5650 if (by_ref[af_index])
5651 {
5652 if (local_com == NULL)
5653 {
5654 local_com = EG (uninitialized_zval_ptr);
5655 local_com->refcount++;
5656 }
5657 zval** p_arg = &local_com;
5658
5659 args_ind[af_index] = fetch_var_arg_by_ref (p_arg);
5660 assert (!in_copy_on_write (*args_ind[af_index]));
5661 args[af_index] = *args_ind[af_index];
5662 }
5663 else
5664 {
5665 zval* arg;
5666 if (local_com == NULL)
5667 arg = EG (uninitialized_zval_ptr);
5668 else
5669 arg = local_com;
5670
5671 args[af_index] = fetch_var_arg (arg, &destruct[af_index]);
5672 args_ind[af_index] = &args[af_index];
5673 }
5674 af_index++;
5675
5676
5677 phc_setup_error (1, "/home/mdupont/2009/02/introspector/rdfintrospector/mediawiki/trunk/phase3/includes/parser/ParserOutput.php", 65, NULL TSRMLS_CC);
5678
5679 // save existing parameters, in case of recursion
5680 int param_count_save = wfsetvar_fci.param_count;
5681 zval*** params_save = wfsetvar_fci.params;
5682 zval** retval_save = wfsetvar_fci.retval_ptr_ptr;
5683
5684 zval* rhs = NULL;
5685
5686 // set up params
5687 wfsetvar_fci.params = args_ind;
5688 wfsetvar_fci.param_count = 2;
5689 wfsetvar_fci.retval_ptr_ptr = &rhs;
5690
5691 // call the function
5692 int success = zend_call_function (&wfsetvar_fci, &wfsetvar_fcic TSRMLS_CC);
5693 assert(success == SUCCESS);
5694
5695 // restore params
5696 wfsetvar_fci.params = params_save;
5697 wfsetvar_fci.param_count = param_count_save;
5698 wfsetvar_fci.retval_ptr_ptr = retval_save;
5699
5700 // unset the errors
5701 phc_setup_error (0, NULL, 0, NULL TSRMLS_CC);
5702
5703 int i;
5704 for (i = 0; i < 2; i++)
5705 {
5706 if (destruct[i])
5707 {
5708 assert (destruct[i]);
5709 zval_ptr_dtor (args_ind[i]);
5710 }
5711 }
5712
5713
5714 // When the Zend engine returns by reference, it allocates a zval into
5715 // retval_ptr_ptr. To return by reference, the callee writes into the
5716 // retval_ptr_ptr, freeing the allocated value as it does. (Note, it may
5717 // not actually return anything). So the zval returned - whether we return
5718 // it, or it is the allocated zval - has a refcount of 1.
5719
5720 // The caller is responsible for cleaning that up (note, this is unaffected
5721 // by whether it is added to some COW set).
5722
5723 // For reasons unknown, the Zend API resets the refcount and is_ref fields
5724 // of the return value after the function returns (unless the callee is
5725 // interpreted). If the function is supposed to return by reference, this
5726 // loses the refcount. This only happens when non-interpreted code is
5727 // called. We work around it, when compiled code is called, by saving the
5728 // refcount into SAVED_REFCOUNT, in the return statement. The downside is
5729 // that we may create an error if our code is called by a callback, and
5730 // returns by reference, and the callback returns by reference. At least
5731 // this is an obscure case.
5732 if(signature->common.return_reference && signature->type != ZEND_USER_FUNCTION)
5733 {
5734 assert (rhs != EG(uninitialized_zval_ptr));
5735 rhs->is_ref = 1;
5736 if (saved_refcount != 0)
5737 {
5738 rhs->refcount = saved_refcount;
5739 }
5740 rhs->refcount++;
5741 }
5742 saved_refcount = 0; // for 'obscure cases'
5743
5744 if (local_TLE30 == NULL)
5745 {
5746 local_TLE30 = EG (uninitialized_zval_ptr);
5747 local_TLE30->refcount++;
5748 }
5749 zval** p_lhs = &local_TLE30;
5750
5751 write_var (p_lhs, rhs);
5752
5753
5754 zval_ptr_dtor (&rhs);
5755 if(signature->common.return_reference && signature->type != ZEND_USER_FUNCTION)
5756 zval_ptr_dtor (&rhs);
5757
5758 phc_check_invariants (TSRMLS_C);
5759 }
5760 // return $TLE30;
5761 {
5762 zval* rhs;
5763 if (local_TLE30 == NULL)
5764 rhs = EG (uninitialized_zval_ptr);
5765 else
5766 rhs = local_TLE30;
5767
5768 // Run-time return by reference has different semantics to compile-time.
5769 // If the function has CTRBR and RTRBR, the the assignment will be
5770 // reference. If one or the other is return-by-copy, the result will be
5771 // by copy. Its a question of whether its separated at return-time (which
5772 // we do here) or at the call-site.
5773 return_value->value = rhs->value;
5774 return_value->type = rhs->type;
5775 zval_copy_ctor (return_value);
5776 goto end_of_function;
5777 phc_check_invariants (TSRMLS_C);
5778 }
5779 // Method exit
5780 end_of_function:__attribute__((unused));
5781 if (local_TLE110 != NULL)
5782 {
5783 zval_ptr_dtor (&local_TLE110);
5784 }
5785 if (local_TLE30 != NULL)
5786 {
5787 zval_ptr_dtor (&local_TLE30);
5788 }
5789 if (local_TMIt109 != NULL)
5790 {
5791 zval_ptr_dtor (&local_TMIt109);
5792 }
5793 if (local_com != NULL)
5794 {
5795 zval_ptr_dtor (&local_com);
5796 }
5797 }
5798 // function setcachetime($t)
5799 // {
5800 // $TLE112 = param_is_ref (NULL, "wfsetvar", 0);
5801 // ;
5802 // if (TLE112) goto L146 else goto L147;
5803 // L146:
5804 // $TMIt111 =& $this->mCacheTime;
5805 // goto L148;
5806 // L147:
5807 // $TMIt111 = $this->mCacheTime;
5808 // goto L148;
5809 // L148:
5810 // $TLE31 = wfsetvar($TMIt111, $t);
5811 // return $TLE31;
5812 // }
5813 PHP_METHOD(ParserOutput, setcachetime)
5814 {
5815 zval* local_TLE112 = NULL;
5816 zval* local_TLE31 = NULL;
5817 zval* local_TMIt111 = NULL;
5818 zval* local_t = NULL;
5819 zval* local_this = getThis();
5820 // Add all parameters as local variables
5821 {
5822 int num_args = ZEND_NUM_ARGS ();
5823 zval* params[1];
5824 zend_get_parameters_array(0, num_args, params);
5825 // param 0
5826 params[0]->refcount++;
5827 if (local_t != NULL)
5828 {
5829 zval_ptr_dtor (&local_t);
5830 }
5831 local_t = params[0];
5832 }
5833 // Function body
5834 // $TLE112 = param_is_ref (NULL, "wfsetvar", 0);
5835 // ;
5836 {
5837 initialize_function_call (&wfsetvar_fci, &wfsetvar_fcic, "wfsetvar", "<unknown>", 0 TSRMLS_CC);
5838 zend_function* signature = wfsetvar_fcic.function_handler;
5839 zend_arg_info* arg_info = signature->common.arg_info;
5840 int count = 0;
5841 while (arg_info && count < 0)
5842 {
5843 count++;
5844 arg_info++;
5845 }
5846
5847 if (local_TLE112 == NULL)
5848 {
5849 local_TLE112 = EG (uninitialized_zval_ptr);
5850 local_TLE112->refcount++;
5851 }
5852 zval** p_lhs = &local_TLE112;
5853
5854 zval* rhs;
5855 ALLOC_INIT_ZVAL (rhs);
5856 if (arg_info && count == 0)
5857 {
5858 ZVAL_BOOL (rhs, arg_info->pass_by_reference);
5859 }
5860 else
5861 {
5862 ZVAL_BOOL (rhs, signature->common.pass_rest_by_reference);
5863 }
5864 write_var (p_lhs, rhs);
5865 zval_ptr_dtor (&rhs);
5866 phc_check_invariants (TSRMLS_C);
5867 }
5868 // if (TLE112) goto L146 else goto L147;
5869 {
5870 zval* p_cond;
5871 if (local_TLE112 == NULL)
5872 p_cond = EG (uninitialized_zval_ptr);
5873 else
5874 p_cond = local_TLE112;
5875
5876 zend_bool bcond = zend_is_true (p_cond);
5877 if (bcond)
5878 goto L146;
5879 else
5880 goto L147;
5881 phc_check_invariants (TSRMLS_C);
5882 }
5883 // L146:
5884 L146:;
5885 // $TMIt111 =& $this->mCacheTime;
5886 {
5887 if (local_this == NULL)
5888 {
5889 local_this = EG (uninitialized_zval_ptr);
5890 local_this->refcount++;
5891 }
5892 zval** p_obj = &local_this;
5893
5894 zval field_name;
5895 INIT_ZVAL (field_name);
5896 ZVAL_STRING (&field_name, "mCacheTime", 0);
5897
5898 zval** field = Z_OBJ_HT_PP(p_obj)->get_property_ptr_ptr(*p_obj, &field_name TSRMLS_CC);
5899 sep_copy_on_write (field);
5900 if (local_TMIt111 == NULL)
5901 {
5902 local_TMIt111 = EG (uninitialized_zval_ptr);
5903 local_TMIt111->refcount++;
5904 }
5905 zval** p_lhs = &local_TMIt111;
5906
5907 copy_into_ref (p_lhs, field);
5908 phc_check_invariants (TSRMLS_C);
5909 }
5910 // goto L148;
5911 {
5912 goto L148;
5913 phc_check_invariants (TSRMLS_C);
5914 }
5915 // L147:
5916 L147:;
5917 // $TMIt111 = $this->mCacheTime;
5918 {
5919 if (local_this == NULL)
5920 {
5921 local_this = EG (uninitialized_zval_ptr);
5922 local_this->refcount++;
5923 }
5924 zval** p_obj = &local_this;
5925
5926 zval field_name;
5927 INIT_ZVAL (field_name);
5928 ZVAL_STRING (&field_name, "mCacheTime", 0);
5929
5930 // I *think* this is correct, but documentation of the Zend API is scarce :)
5931 zval* field = Z_OBJ_HT_PP(p_obj)->read_property(*p_obj, &field_name, BP_VAR_R TSRMLS_CC);
5932 if (local_TMIt111 == NULL)
5933 {
5934 local_TMIt111 = EG (uninitialized_zval_ptr);
5935 local_TMIt111->refcount++;
5936 }
5937 zval** p_lhs = &local_TMIt111;
5938
5939 write_var (p_lhs, field);
5940 phc_check_invariants (TSRMLS_C);
5941 }
5942 // goto L148;
5943 {
5944 goto L148;
5945 phc_check_invariants (TSRMLS_C);
5946 }
5947 // L148:
5948 L148:;
5949 // $TLE31 = wfsetvar($TMIt111, $t);
5950 {
5951 initialize_function_call (&wfsetvar_fci, &wfsetvar_fcic, "wfsetvar", "/home/mdupont/2009/02/introspector/rdfintrospector/mediawiki/trunk/phase3/includes/parser/ParserOutput.php", 66 TSRMLS_CC);
5952 zend_function* signature = wfsetvar_fcic.function_handler;
5953 zend_arg_info* arg_info = signature->common.arg_info; // optional
5954
5955 int by_ref[2];
5956 int abr_index = 0;
5957 // TODO: find names to replace index
5958 if (arg_info)
5959 {
5960 by_ref[abr_index] = arg_info->pass_by_reference;
5961 arg_info++;
5962 }
5963 else
5964 by_ref[abr_index] = signature->common.pass_rest_by_reference;
5965
5966 abr_index++;
5967 // TODO: find names to replace index
5968 if (arg_info)
5969 {
5970 by_ref[abr_index] = arg_info->pass_by_reference;
5971 arg_info++;
5972 }
5973 else
5974 by_ref[abr_index] = signature->common.pass_rest_by_reference;
5975
5976 abr_index++;
5977
5978
5979 // Setup array of arguments
5980 // TODO: i think arrays of size 0 is an error
5981 int destruct [2];
5982 zval* args [2];
5983 zval** args_ind [2];
5984
5985 int af_index = 0;
5986 destruct[af_index] = 0;
5987 if (by_ref[af_index])
5988 {
5989 if (local_TMIt111 == NULL)
5990 {
5991 local_TMIt111 = EG (uninitialized_zval_ptr);
5992 local_TMIt111->refcount++;
5993 }
5994 zval** p_arg = &local_TMIt111;
5995
5996 args_ind[af_index] = fetch_var_arg_by_ref (p_arg);
5997 assert (!in_copy_on_write (*args_ind[af_index]));
5998 args[af_index] = *args_ind[af_index];
5999 }
6000 else
6001 {
6002 zval* arg;
6003 if (local_TMIt111 == NULL)
6004 arg = EG (uninitialized_zval_ptr);
6005 else
6006 arg = local_TMIt111;
6007
6008 args[af_index] = fetch_var_arg (arg, &destruct[af_index]);
6009 args_ind[af_index] = &args[af_index];
6010 }
6011 af_index++;
6012 destruct[af_index] = 0;
6013 if (by_ref[af_index])
6014 {
6015 if (local_t == NULL)
6016 {
6017 local_t = EG (uninitialized_zval_ptr);
6018 local_t->refcount++;
6019 }
6020 zval** p_arg = &local_t;
6021
6022 args_ind[af_index] = fetch_var_arg_by_ref (p_arg);
6023 assert (!in_copy_on_write (*args_ind[af_index]));
6024 args[af_index] = *args_ind[af_index];
6025 }
6026 else
6027 {
6028 zval* arg;
6029 if (local_t == NULL)
6030 arg = EG (uninitialized_zval_ptr);
6031 else
6032 arg = local_t;
6033
6034 args[af_index] = fetch_var_arg (arg, &destruct[af_index]);
6035 args_ind[af_index] = &args[af_index];
6036 }
6037 af_index++;
6038
6039
6040 phc_setup_error (1, "/home/mdupont/2009/02/introspector/rdfintrospector/mediawiki/trunk/phase3/includes/parser/ParserOutput.php", 66, NULL TSRMLS_CC);
6041
6042 // save existing parameters, in case of recursion
6043 int param_count_save = wfsetvar_fci.param_count;
6044 zval*** params_save = wfsetvar_fci.params;
6045 zval** retval_save = wfsetvar_fci.retval_ptr_ptr;
6046
6047 zval* rhs = NULL;
6048
6049 // set up params
6050 wfsetvar_fci.params = args_ind;
6051 wfsetvar_fci.param_count = 2;
6052 wfsetvar_fci.retval_ptr_ptr = &rhs;
6053
6054 // call the function
6055 int success = zend_call_function (&wfsetvar_fci, &wfsetvar_fcic TSRMLS_CC);
6056 assert(success == SUCCESS);
6057
6058 // restore params
6059 wfsetvar_fci.params = params_save;
6060 wfsetvar_fci.param_count = param_count_save;
6061 wfsetvar_fci.retval_ptr_ptr = retval_save;
6062
6063 // unset the errors
6064 phc_setup_error (0, NULL, 0, NULL TSRMLS_CC);
6065
6066 int i;
6067 for (i = 0; i < 2; i++)
6068 {
6069 if (destruct[i])
6070 {
6071 assert (destruct[i]);
6072 zval_ptr_dtor (args_ind[i]);
6073 }
6074 }
6075
6076
6077 // When the Zend engine returns by reference, it allocates a zval into
6078 // retval_ptr_ptr. To return by reference, the callee writes into the
6079 // retval_ptr_ptr, freeing the allocated value as it does. (Note, it may
6080 // not actually return anything). So the zval returned - whether we return
6081 // it, or it is the allocated zval - has a refcount of 1.
6082
6083 // The caller is responsible for cleaning that up (note, this is unaffected
6084 // by whether it is added to some COW set).
6085
6086 // For reasons unknown, the Zend API resets the refcount and is_ref fields
6087 // of the return value after the function returns (unless the callee is
6088 // interpreted). If the function is supposed to return by reference, this
6089 // loses the refcount. This only happens when non-interpreted code is
6090 // called. We work around it, when compiled code is called, by saving the
6091 // refcount into SAVED_REFCOUNT, in the return statement. The downside is
6092 // that we may create an error if our code is called by a callback, and
6093 // returns by reference, and the callback returns by reference. At least
6094 // this is an obscure case.
6095 if(signature->common.return_reference && signature->type != ZEND_USER_FUNCTION)
6096 {
6097 assert (rhs != EG(uninitialized_zval_ptr));
6098 rhs->is_ref = 1;
6099 if (saved_refcount != 0)
6100 {
6101 rhs->refcount = saved_refcount;
6102 }
6103 rhs->refcount++;
6104 }
6105 saved_refcount = 0; // for 'obscure cases'
6106
6107 if (local_TLE31 == NULL)
6108 {
6109 local_TLE31 = EG (uninitialized_zval_ptr);
6110 local_TLE31->refcount++;
6111 }
6112 zval** p_lhs = &local_TLE31;
6113
6114 write_var (p_lhs, rhs);
6115
6116
6117 zval_ptr_dtor (&rhs);
6118 if(signature->common.return_reference && signature->type != ZEND_USER_FUNCTION)
6119 zval_ptr_dtor (&rhs);
6120
6121 phc_check_invariants (TSRMLS_C);
6122 }
6123 // return $TLE31;
6124 {
6125 zval* rhs;
6126 if (local_TLE31 == NULL)
6127 rhs = EG (uninitialized_zval_ptr);
6128 else
6129 rhs = local_TLE31;
6130
6131 // Run-time return by reference has different semantics to compile-time.
6132 // If the function has CTRBR and RTRBR, the the assignment will be
6133 // reference. If one or the other is return-by-copy, the result will be
6134 // by copy. Its a question of whether its separated at return-time (which
6135 // we do here) or at the call-site.
6136 return_value->value = rhs->value;
6137 return_value->type = rhs->type;
6138 zval_copy_ctor (return_value);
6139 goto end_of_function;
6140 phc_check_invariants (TSRMLS_C);
6141 }
6142 // Method exit
6143 end_of_function:__attribute__((unused));
6144 if (local_TLE112 != NULL)
6145 {
6146 zval_ptr_dtor (&local_TLE112);
6147 }
6148 if (local_TLE31 != NULL)
6149 {
6150 zval_ptr_dtor (&local_TLE31);
6151 }
6152 if (local_TMIt111 != NULL)
6153 {
6154 zval_ptr_dtor (&local_TMIt111);
6155 }
6156 if (local_t != NULL)
6157 {
6158 zval_ptr_dtor (&local_t);
6159 }
6160 }
6161 // function settitletext($t)
6162 // {
6163 // $TLE114 = param_is_ref (NULL, "wfsetvar", 0);
6164 // ;
6165 // if (TLE114) goto L149 else goto L150;
6166 // L149:
6167 // $TMIt113 =& $this->mTitleText;
6168 // goto L151;
6169 // L150:
6170 // $TMIt113 = $this->mTitleText;
6171 // goto L151;
6172 // L151:
6173 // $TLE32 = wfsetvar($TMIt113, $t);
6174 // return $TLE32;
6175 // }
6176 PHP_METHOD(ParserOutput, settitletext)
6177 {
6178 zval* local_TLE114 = NULL;
6179 zval* local_TLE32 = NULL;
6180 zval* local_TMIt113 = NULL;
6181 zval* local_t = NULL;
6182 zval* local_this = getThis();
6183 // Add all parameters as local variables
6184 {
6185 int num_args = ZEND_NUM_ARGS ();
6186 zval* params[1];
6187 zend_get_parameters_array(0, num_args, params);
6188 // param 0
6189 params[0]->refcount++;
6190 if (local_t != NULL)
6191 {
6192 zval_ptr_dtor (&local_t);
6193 }
6194 local_t = params[0];
6195 }
6196 // Function body
6197 // $TLE114 = param_is_ref (NULL, "wfsetvar", 0);
6198 // ;
6199 {
6200 initialize_function_call (&wfsetvar_fci, &wfsetvar_fcic, "wfsetvar", "<unknown>", 0 TSRMLS_CC);
6201 zend_function* signature = wfsetvar_fcic.function_handler;
6202 zend_arg_info* arg_info = signature->common.arg_info;
6203 int count = 0;
6204 while (arg_info && count < 0)
6205 {
6206 count++;
6207 arg_info++;
6208 }
6209
6210 if (local_TLE114 == NULL)
6211 {
6212 local_TLE114 = EG (uninitialized_zval_ptr);
6213 local_TLE114->refcount++;
6214 }
6215 zval** p_lhs = &local_TLE114;
6216
6217 zval* rhs;
6218 ALLOC_INIT_ZVAL (rhs);
6219 if (arg_info && count == 0)
6220 {
6221 ZVAL_BOOL (rhs, arg_info->pass_by_reference);
6222 }
6223 else
6224 {
6225 ZVAL_BOOL (rhs, signature->common.pass_rest_by_reference);
6226 }
6227 write_var (p_lhs, rhs);
6228 zval_ptr_dtor (&rhs);
6229 phc_check_invariants (TSRMLS_C);
6230 }
6231 // if (TLE114) goto L149 else goto L150;
6232 {
6233 zval* p_cond;
6234 if (local_TLE114 == NULL)
6235 p_cond = EG (uninitialized_zval_ptr);
6236 else
6237 p_cond = local_TLE114;
6238
6239 zend_bool bcond = zend_is_true (p_cond);
6240 if (bcond)
6241 goto L149;
6242 else
6243 goto L150;
6244 phc_check_invariants (TSRMLS_C);
6245 }
6246 // L149:
6247 L149:;
6248 // $TMIt113 =& $this->mTitleText;
6249 {
6250 if (local_this == NULL)
6251 {
6252 local_this = EG (uninitialized_zval_ptr);
6253 local_this->refcount++;
6254 }
6255 zval** p_obj = &local_this;
6256
6257 zval field_name;
6258 INIT_ZVAL (field_name);
6259 ZVAL_STRING (&field_name, "mTitleText", 0);
6260
6261 zval** field = Z_OBJ_HT_PP(p_obj)->get_property_ptr_ptr(*p_obj, &field_name TSRMLS_CC);
6262 sep_copy_on_write (field);
6263 if (local_TMIt113 == NULL)
6264 {
6265 local_TMIt113 = EG (uninitialized_zval_ptr);
6266 local_TMIt113->refcount++;
6267 }
6268 zval** p_lhs = &local_TMIt113;
6269
6270 copy_into_ref (p_lhs, field);
6271 phc_check_invariants (TSRMLS_C);
6272 }
6273 // goto L151;
6274 {
6275 goto L151;
6276 phc_check_invariants (TSRMLS_C);
6277 }
6278 // L150:
6279 L150:;
6280 // $TMIt113 = $this->mTitleText;
6281 {
6282 if (local_this == NULL)
6283 {
6284 local_this = EG (uninitialized_zval_ptr);
6285 local_this->refcount++;
6286 }
6287 zval** p_obj = &local_this;
6288
6289 zval field_name;
6290 INIT_ZVAL (field_name);
6291 ZVAL_STRING (&field_name, "mTitleText", 0);
6292
6293 // I *think* this is correct, but documentation of the Zend API is scarce :)
6294 zval* field = Z_OBJ_HT_PP(p_obj)->read_property(*p_obj, &field_name, BP_VAR_R TSRMLS_CC);
6295 if (local_TMIt113 == NULL)
6296 {
6297 local_TMIt113 = EG (uninitialized_zval_ptr);
6298 local_TMIt113->refcount++;
6299 }
6300 zval** p_lhs = &local_TMIt113;
6301
6302 write_var (p_lhs, field);
6303 phc_check_invariants (TSRMLS_C);
6304 }
6305 // goto L151;
6306 {
6307 goto L151;
6308 phc_check_invariants (TSRMLS_C);
6309 }
6310 // L151:
6311 L151:;
6312 // $TLE32 = wfsetvar($TMIt113, $t);
6313 {
6314 initialize_function_call (&wfsetvar_fci, &wfsetvar_fcic, "wfsetvar", "/home/mdupont/2009/02/introspector/rdfintrospector/mediawiki/trunk/phase3/includes/parser/ParserOutput.php", 67 TSRMLS_CC);
6315 zend_function* signature = wfsetvar_fcic.function_handler;
6316 zend_arg_info* arg_info = signature->common.arg_info; // optional
6317
6318 int by_ref[2];
6319 int abr_index = 0;
6320 // TODO: find names to replace index
6321 if (arg_info)
6322 {
6323 by_ref[abr_index] = arg_info->pass_by_reference;
6324 arg_info++;
6325 }
6326 else
6327 by_ref[abr_index] = signature->common.pass_rest_by_reference;
6328
6329 abr_index++;
6330 // TODO: find names to replace index
6331 if (arg_info)
6332 {
6333 by_ref[abr_index] = arg_info->pass_by_reference;
6334 arg_info++;
6335 }
6336 else
6337 by_ref[abr_index] = signature->common.pass_rest_by_reference;
6338
6339 abr_index++;
6340
6341
6342 // Setup array of arguments
6343 // TODO: i think arrays of size 0 is an error
6344 int destruct [2];
6345 zval* args [2];
6346 zval** args_ind [2];
6347
6348 int af_index = 0;
6349 destruct[af_index] = 0;
6350 if (by_ref[af_index])
6351 {
6352 if (local_TMIt113 == NULL)
6353 {
6354 local_TMIt113 = EG (uninitialized_zval_ptr);
6355 local_TMIt113->refcount++;
6356 }
6357 zval** p_arg = &local_TMIt113;
6358
6359 args_ind[af_index] = fetch_var_arg_by_ref (p_arg);
6360 assert (!in_copy_on_write (*args_ind[af_index]));
6361 args[af_index] = *args_ind[af_index];
6362 }
6363 else
6364 {
6365 zval* arg;
6366 if (local_TMIt113 == NULL)
6367 arg = EG (uninitialized_zval_ptr);
6368 else
6369 arg = local_TMIt113;
6370
6371 args[af_index] = fetch_var_arg (arg, &destruct[af_index]);
6372 args_ind[af_index] = &args[af_index];
6373 }
6374 af_index++;
6375 destruct[af_index] = 0;
6376 if (by_ref[af_index])
6377 {
6378 if (local_t == NULL)
6379 {
6380 local_t = EG (uninitialized_zval_ptr);
6381 local_t->refcount++;
6382 }
6383 zval** p_arg = &local_t;
6384
6385 args_ind[af_index] = fetch_var_arg_by_ref (p_arg);
6386 assert (!in_copy_on_write (*args_ind[af_index]));
6387 args[af_index] = *args_ind[af_index];
6388 }
6389 else
6390 {
6391 zval* arg;
6392 if (local_t == NULL)
6393 arg = EG (uninitialized_zval_ptr);
6394 else
6395 arg = local_t;
6396
6397 args[af_index] = fetch_var_arg (arg, &destruct[af_index]);
6398 args_ind[af_index] = &args[af_index];
6399 }
6400 af_index++;
6401
6402
6403 phc_setup_error (1, "/home/mdupont/2009/02/introspector/rdfintrospector/mediawiki/trunk/phase3/includes/parser/ParserOutput.php", 67, NULL TSRMLS_CC);
6404
6405 // save existing parameters, in case of recursion
6406 int param_count_save = wfsetvar_fci.param_count;
6407 zval*** params_save = wfsetvar_fci.params;
6408 zval** retval_save = wfsetvar_fci.retval_ptr_ptr;
6409
6410 zval* rhs = NULL;
6411
6412 // set up params
6413 wfsetvar_fci.params = args_ind;
6414 wfsetvar_fci.param_count = 2;
6415 wfsetvar_fci.retval_ptr_ptr = &rhs;
6416
6417 // call the function
6418 int success = zend_call_function (&wfsetvar_fci, &wfsetvar_fcic TSRMLS_CC);
6419 assert(success == SUCCESS);
6420
6421 // restore params
6422 wfsetvar_fci.params = params_save;
6423 wfsetvar_fci.param_count = param_count_save;
6424 wfsetvar_fci.retval_ptr_ptr = retval_save;
6425
6426 // unset the errors
6427 phc_setup_error (0, NULL, 0, NULL TSRMLS_CC);
6428
6429 int i;
6430 for (i = 0; i < 2; i++)
6431 {
6432 if (destruct[i])
6433 {
6434 assert (destruct[i]);
6435 zval_ptr_dtor (args_ind[i]);
6436 }
6437 }
6438
6439
6440 // When the Zend engine returns by reference, it allocates a zval into
6441 // retval_ptr_ptr. To return by reference, the callee writes into the
6442 // retval_ptr_ptr, freeing the allocated value as it does. (Note, it may
6443 // not actually return anything). So the zval returned - whether we return
6444 // it, or it is the allocated zval - has a refcount of 1.
6445
6446 // The caller is responsible for cleaning that up (note, this is unaffected
6447 // by whether it is added to some COW set).
6448
6449 // For reasons unknown, the Zend API resets the refcount and is_ref fields
6450 // of the return value after the function returns (unless the callee is
6451 // interpreted). If the function is supposed to return by reference, this
6452 // loses the refcount. This only happens when non-interpreted code is
6453 // called. We work around it, when compiled code is called, by saving the
6454 // refcount into SAVED_REFCOUNT, in the return statement. The downside is
6455 // that we may create an error if our code is called by a callback, and
6456 // returns by reference, and the callback returns by reference. At least
6457 // this is an obscure case.
6458 if(signature->common.return_reference && signature->type != ZEND_USER_FUNCTION)
6459 {
6460 assert (rhs != EG(uninitialized_zval_ptr));
6461 rhs->is_ref = 1;
6462 if (saved_refcount != 0)
6463 {
6464 rhs->refcount = saved_refcount;
6465 }
6466 rhs->refcount++;
6467 }
6468 saved_refcount = 0; // for 'obscure cases'
6469
6470 if (local_TLE32 == NULL)
6471 {
6472 local_TLE32 = EG (uninitialized_zval_ptr);
6473 local_TLE32->refcount++;
6474 }
6475 zval** p_lhs = &local_TLE32;
6476
6477 write_var (p_lhs, rhs);
6478
6479
6480 zval_ptr_dtor (&rhs);
6481 if(signature->common.return_reference && signature->type != ZEND_USER_FUNCTION)
6482 zval_ptr_dtor (&rhs);
6483
6484 phc_check_invariants (TSRMLS_C);
6485 }
6486 // return $TLE32;
6487 {
6488 zval* rhs;
6489 if (local_TLE32 == NULL)
6490 rhs = EG (uninitialized_zval_ptr);
6491 else
6492 rhs = local_TLE32;
6493
6494 // Run-time return by reference has different semantics to compile-time.
6495 // If the function has CTRBR and RTRBR, the the assignment will be
6496 // reference. If one or the other is return-by-copy, the result will be
6497 // by copy. Its a question of whether its separated at return-time (which
6498 // we do here) or at the call-site.
6499 return_value->value = rhs->value;
6500 return_value->type = rhs->type;
6501 zval_copy_ctor (return_value);
6502 goto end_of_function;
6503 phc_check_invariants (TSRMLS_C);
6504 }
6505 // Method exit
6506 end_of_function:__attribute__((unused));
6507 if (local_TLE114 != NULL)
6508 {
6509 zval_ptr_dtor (&local_TLE114);
6510 }
6511 if (local_TLE32 != NULL)
6512 {
6513 zval_ptr_dtor (&local_TLE32);
6514 }
6515 if (local_TMIt113 != NULL)
6516 {
6517 zval_ptr_dtor (&local_TMIt113);
6518 }
6519 if (local_t != NULL)
6520 {
6521 zval_ptr_dtor (&local_t);
6522 }
6523 }
6524 // function setsections($toc)
6525 // {
6526 // $TLE116 = param_is_ref (NULL, "wfsetvar", 0);
6527 // ;
6528 // if (TLE116) goto L152 else goto L153;
6529 // L152:
6530 // $TMIt115 =& $this->mSections;
6531 // goto L154;
6532 // L153:
6533 // $TMIt115 = $this->mSections;
6534 // goto L154;
6535 // L154:
6536 // $TLE33 = wfsetvar($TMIt115, $toc);
6537 // return $TLE33;
6538 // }
6539 PHP_METHOD(ParserOutput, setsections)
6540 {
6541 zval* local_TLE116 = NULL;
6542 zval* local_TLE33 = NULL;
6543 zval* local_TMIt115 = NULL;
6544 zval* local_this = getThis();
6545 zval* local_toc = NULL;
6546 // Add all parameters as local variables
6547 {
6548 int num_args = ZEND_NUM_ARGS ();
6549 zval* params[1];
6550 zend_get_parameters_array(0, num_args, params);
6551 // param 0
6552 params[0]->refcount++;
6553 if (local_toc != NULL)
6554 {
6555 zval_ptr_dtor (&local_toc);
6556 }
6557 local_toc = params[0];
6558 }
6559 // Function body
6560 // $TLE116 = param_is_ref (NULL, "wfsetvar", 0);
6561 // ;
6562 {
6563 initialize_function_call (&wfsetvar_fci, &wfsetvar_fcic, "wfsetvar", "<unknown>", 0 TSRMLS_CC);
6564 zend_function* signature = wfsetvar_fcic.function_handler;
6565 zend_arg_info* arg_info = signature->common.arg_info;
6566 int count = 0;
6567 while (arg_info && count < 0)
6568 {
6569 count++;
6570 arg_info++;
6571 }
6572
6573 if (local_TLE116 == NULL)
6574 {
6575 local_TLE116 = EG (uninitialized_zval_ptr);
6576 local_TLE116->refcount++;
6577 }
6578 zval** p_lhs = &local_TLE116;
6579
6580 zval* rhs;
6581 ALLOC_INIT_ZVAL (rhs);
6582 if (arg_info && count == 0)
6583 {
6584 ZVAL_BOOL (rhs, arg_info->pass_by_reference);
6585 }
6586 else
6587 {
6588 ZVAL_BOOL (rhs, signature->common.pass_rest_by_reference);
6589 }
6590 write_var (p_lhs, rhs);
6591 zval_ptr_dtor (&rhs);
6592 phc_check_invariants (TSRMLS_C);
6593 }
6594 // if (TLE116) goto L152 else goto L153;
6595 {
6596 zval* p_cond;
6597 if (local_TLE116 == NULL)
6598 p_cond = EG (uninitialized_zval_ptr);
6599 else
6600 p_cond = local_TLE116;
6601
6602 zend_bool bcond = zend_is_true (p_cond);
6603 if (bcond)
6604 goto L152;
6605 else
6606 goto L153;
6607 phc_check_invariants (TSRMLS_C);
6608 }
6609 // L152:
6610 L152:;
6611 // $TMIt115 =& $this->mSections;
6612 {
6613 if (local_this == NULL)
6614 {
6615 local_this = EG (uninitialized_zval_ptr);
6616 local_this->refcount++;
6617 }
6618 zval** p_obj = &local_this;
6619
6620 zval field_name;
6621 INIT_ZVAL (field_name);
6622 ZVAL_STRING (&field_name, "mSections", 0);
6623
6624 zval** field = Z_OBJ_HT_PP(p_obj)->get_property_ptr_ptr(*p_obj, &field_name TSRMLS_CC);
6625 sep_copy_on_write (field);
6626 if (local_TMIt115 == NULL)
6627 {
6628 local_TMIt115 = EG (uninitialized_zval_ptr);
6629 local_TMIt115->refcount++;
6630 }
6631 zval** p_lhs = &local_TMIt115;
6632
6633 copy_into_ref (p_lhs, field);
6634 phc_check_invariants (TSRMLS_C);
6635 }
6636 // goto L154;
6637 {
6638 goto L154;
6639 phc_check_invariants (TSRMLS_C);
6640 }
6641 // L153:
6642 L153:;
6643 // $TMIt115 = $this->mSections;
6644 {
6645 if (local_this == NULL)
6646 {
6647 local_this = EG (uninitialized_zval_ptr);
6648 local_this->refcount++;
6649 }
6650 zval** p_obj = &local_this;
6651
6652 zval field_name;
6653 INIT_ZVAL (field_name);
6654 ZVAL_STRING (&field_name, "mSections", 0);
6655
6656 // I *think* this is correct, but documentation of the Zend API is scarce :)
6657 zval* field = Z_OBJ_HT_PP(p_obj)->read_property(*p_obj, &field_name, BP_VAR_R TSRMLS_CC);
6658 if (local_TMIt115 == NULL)
6659 {
6660 local_TMIt115 = EG (uninitialized_zval_ptr);
6661 local_TMIt115->refcount++;
6662 }
6663 zval** p_lhs = &local_TMIt115;
6664
6665 write_var (p_lhs, field);
6666 phc_check_invariants (TSRMLS_C);
6667 }
6668 // goto L154;
6669 {
6670 goto L154;
6671 phc_check_invariants (TSRMLS_C);
6672 }
6673 // L154:
6674 L154:;
6675 // $TLE33 = wfsetvar($TMIt115, $toc);
6676 {
6677 initialize_function_call (&wfsetvar_fci, &wfsetvar_fcic, "wfsetvar", "/home/mdupont/2009/02/introspector/rdfintrospector/mediawiki/trunk/phase3/includes/parser/ParserOutput.php", 68 TSRMLS_CC);
6678 zend_function* signature = wfsetvar_fcic.function_handler;
6679 zend_arg_info* arg_info = signature->common.arg_info; // optional
6680
6681 int by_ref[2];
6682 int abr_index = 0;
6683 // TODO: find names to replace index
6684 if (arg_info)
6685 {
6686 by_ref[abr_index] = arg_info->pass_by_reference;
6687 arg_info++;
6688 }
6689 else
6690 by_ref[abr_index] = signature->common.pass_rest_by_reference;
6691
6692 abr_index++;
6693 // TODO: find names to replace index
6694 if (arg_info)
6695 {
6696 by_ref[abr_index] = arg_info->pass_by_reference;
6697 arg_info++;
6698 }
6699 else
6700 by_ref[abr_index] = signature->common.pass_rest_by_reference;
6701
6702 abr_index++;
6703
6704
6705 // Setup array of arguments
6706 // TODO: i think arrays of size 0 is an error
6707 int destruct [2];
6708 zval* args [2];
6709 zval** args_ind [2];
6710
6711 int af_index = 0;
6712 destruct[af_index] = 0;
6713 if (by_ref[af_index])
6714 {
6715 if (local_TMIt115 == NULL)
6716 {
6717 local_TMIt115 = EG (uninitialized_zval_ptr);
6718 local_TMIt115->refcount++;
6719 }
6720 zval** p_arg = &local_TMIt115;
6721
6722 args_ind[af_index] = fetch_var_arg_by_ref (p_arg);
6723 assert (!in_copy_on_write (*args_ind[af_index]));
6724 args[af_index] = *args_ind[af_index];
6725 }
6726 else
6727 {
6728 zval* arg;
6729 if (local_TMIt115 == NULL)
6730 arg = EG (uninitialized_zval_ptr);
6731 else
6732 arg = local_TMIt115;
6733
6734 args[af_index] = fetch_var_arg (arg, &destruct[af_index]);
6735 args_ind[af_index] = &args[af_index];
6736 }
6737 af_index++;
6738 destruct[af_index] = 0;
6739 if (by_ref[af_index])
6740 {
6741 if (local_toc == NULL)
6742 {
6743 local_toc = EG (uninitialized_zval_ptr);
6744 local_toc->refcount++;
6745 }
6746 zval** p_arg = &local_toc;
6747
6748 args_ind[af_index] = fetch_var_arg_by_ref (p_arg);
6749 assert (!in_copy_on_write (*args_ind[af_index]));
6750 args[af_index] = *args_ind[af_index];
6751 }
6752 else
6753 {
6754 zval* arg;
6755 if (local_toc == NULL)
6756 arg = EG (uninitialized_zval_ptr);
6757 else
6758 arg = local_toc;
6759
6760 args[af_index] = fetch_var_arg (arg, &destruct[af_index]);
6761 args_ind[af_index] = &args[af_index];
6762 }
6763 af_index++;
6764
6765
6766 phc_setup_error (1, "/home/mdupont/2009/02/introspector/rdfintrospector/mediawiki/trunk/phase3/includes/parser/ParserOutput.php", 68, NULL TSRMLS_CC);
6767
6768 // save existing parameters, in case of recursion
6769 int param_count_save = wfsetvar_fci.param_count;
6770 zval*** params_save = wfsetvar_fci.params;
6771 zval** retval_save = wfsetvar_fci.retval_ptr_ptr;
6772
6773 zval* rhs = NULL;
6774
6775 // set up params
6776 wfsetvar_fci.params = args_ind;
6777 wfsetvar_fci.param_count = 2;
6778 wfsetvar_fci.retval_ptr_ptr = &rhs;
6779
6780 // call the function
6781 int success = zend_call_function (&wfsetvar_fci, &wfsetvar_fcic TSRMLS_CC);
6782 assert(success == SUCCESS);
6783
6784 // restore params
6785 wfsetvar_fci.params = params_save;
6786 wfsetvar_fci.param_count = param_count_save;
6787 wfsetvar_fci.retval_ptr_ptr = retval_save;
6788
6789 // unset the errors
6790 phc_setup_error (0, NULL, 0, NULL TSRMLS_CC);
6791
6792 int i;
6793 for (i = 0; i < 2; i++)
6794 {
6795 if (destruct[i])
6796 {
6797 assert (destruct[i]);
6798 zval_ptr_dtor (args_ind[i]);
6799 }
6800 }
6801
6802
6803 // When the Zend engine returns by reference, it allocates a zval into
6804 // retval_ptr_ptr. To return by reference, the callee writes into the
6805 // retval_ptr_ptr, freeing the allocated value as it does. (Note, it may
6806 // not actually return anything). So the zval returned - whether we return
6807 // it, or it is the allocated zval - has a refcount of 1.
6808
6809 // The caller is responsible for cleaning that up (note, this is unaffected
6810 // by whether it is added to some COW set).
6811
6812 // For reasons unknown, the Zend API resets the refcount and is_ref fields
6813 // of the return value after the function returns (unless the callee is
6814 // interpreted). If the function is supposed to return by reference, this
6815 // loses the refcount. This only happens when non-interpreted code is
6816 // called. We work around it, when compiled code is called, by saving the
6817 // refcount into SAVED_REFCOUNT, in the return statement. The downside is
6818 // that we may create an error if our code is called by a callback, and
6819 // returns by reference, and the callback returns by reference. At least
6820 // this is an obscure case.
6821 if(signature->common.return_reference && signature->type != ZEND_USER_FUNCTION)
6822 {
6823 assert (rhs != EG(uninitialized_zval_ptr));
6824 rhs->is_ref = 1;
6825 if (saved_refcount != 0)
6826 {
6827 rhs->refcount = saved_refcount;
6828 }
6829 rhs->refcount++;
6830 }
6831 saved_refcount = 0; // for 'obscure cases'
6832
6833 if (local_TLE33 == NULL)
6834 {
6835 local_TLE33 = EG (uninitialized_zval_ptr);
6836 local_TLE33->refcount++;
6837 }
6838 zval** p_lhs = &local_TLE33;
6839
6840 write_var (p_lhs, rhs);
6841
6842
6843 zval_ptr_dtor (&rhs);
6844 if(signature->common.return_reference && signature->type != ZEND_USER_FUNCTION)
6845 zval_ptr_dtor (&rhs);
6846
6847 phc_check_invariants (TSRMLS_C);
6848 }
6849 // return $TLE33;
6850 {
6851 zval* rhs;
6852 if (local_TLE33 == NULL)
6853 rhs = EG (uninitialized_zval_ptr);
6854 else
6855 rhs = local_TLE33;
6856
6857 // Run-time return by reference has different semantics to compile-time.
6858 // If the function has CTRBR and RTRBR, the the assignment will be
6859 // reference. If one or the other is return-by-copy, the result will be
6860 // by copy. Its a question of whether its separated at return-time (which
6861 // we do here) or at the call-site.
6862 return_value->value = rhs->value;
6863 return_value->type = rhs->type;
6864 zval_copy_ctor (return_value);
6865 goto end_of_function;
6866 phc_check_invariants (TSRMLS_C);
6867 }
6868 // Method exit
6869 end_of_function:__attribute__((unused));
6870 if (local_TLE116 != NULL)
6871 {
6872 zval_ptr_dtor (&local_TLE116);
6873 }
6874 if (local_TLE33 != NULL)
6875 {
6876 zval_ptr_dtor (&local_TLE33);
6877 }
6878 if (local_TMIt115 != NULL)
6879 {
6880 zval_ptr_dtor (&local_TMIt115);
6881 }
6882 if (local_toc != NULL)
6883 {
6884 zval_ptr_dtor (&local_toc);
6885 }
6886 }
6887 // function setindexpolicy($policy)
6888 // {
6889 // $TLE118 = param_is_ref (NULL, "wfsetvar", 0);
6890 // ;
6891 // if (TLE118) goto L155 else goto L156;
6892 // L155:
6893 // $TMIt117 =& $this->mIndexPolicy;
6894 // goto L157;
6895 // L156:
6896 // $TMIt117 = $this->mIndexPolicy;
6897 // goto L157;
6898 // L157:
6899 // $TLE34 = wfsetvar($TMIt117, $policy);
6900 // return $TLE34;
6901 // }
6902 PHP_METHOD(ParserOutput, setindexpolicy)
6903 {
6904 zval* local_TLE118 = NULL;
6905 zval* local_TLE34 = NULL;
6906 zval* local_TMIt117 = NULL;
6907 zval* local_policy = NULL;
6908 zval* local_this = getThis();
6909 // Add all parameters as local variables
6910 {
6911 int num_args = ZEND_NUM_ARGS ();
6912 zval* params[1];
6913 zend_get_parameters_array(0, num_args, params);
6914 // param 0
6915 params[0]->refcount++;
6916 if (local_policy != NULL)
6917 {
6918 zval_ptr_dtor (&local_policy);
6919 }
6920 local_policy = params[0];
6921 }
6922 // Function body
6923 // $TLE118 = param_is_ref (NULL, "wfsetvar", 0);
6924 // ;
6925 {
6926 initialize_function_call (&wfsetvar_fci, &wfsetvar_fcic, "wfsetvar", "<unknown>", 0 TSRMLS_CC);
6927 zend_function* signature = wfsetvar_fcic.function_handler;
6928 zend_arg_info* arg_info = signature->common.arg_info;
6929 int count = 0;
6930 while (arg_info && count < 0)
6931 {
6932 count++;
6933 arg_info++;
6934 }
6935
6936 if (local_TLE118 == NULL)
6937 {
6938 local_TLE118 = EG (uninitialized_zval_ptr);
6939 local_TLE118->refcount++;
6940 }
6941 zval** p_lhs = &local_TLE118;
6942
6943 zval* rhs;
6944 ALLOC_INIT_ZVAL (rhs);
6945 if (arg_info && count == 0)
6946 {
6947 ZVAL_BOOL (rhs, arg_info->pass_by_reference);
6948 }
6949 else
6950 {
6951 ZVAL_BOOL (rhs, signature->common.pass_rest_by_reference);
6952 }
6953 write_var (p_lhs, rhs);
6954 zval_ptr_dtor (&rhs);
6955 phc_check_invariants (TSRMLS_C);
6956 }
6957 // if (TLE118) goto L155 else goto L156;
6958 {
6959 zval* p_cond;
6960 if (local_TLE118 == NULL)
6961 p_cond = EG (uninitialized_zval_ptr);
6962 else
6963 p_cond = local_TLE118;
6964
6965 zend_bool bcond = zend_is_true (p_cond);
6966 if (bcond)
6967 goto L155;
6968 else
6969 goto L156;
6970 phc_check_invariants (TSRMLS_C);
6971 }
6972 // L155:
6973 L155:;
6974 // $TMIt117 =& $this->mIndexPolicy;
6975 {
6976 if (local_this == NULL)
6977 {
6978 local_this = EG (uninitialized_zval_ptr);
6979 local_this->refcount++;
6980 }
6981 zval** p_obj = &local_this;
6982
6983 zval field_name;
6984 INIT_ZVAL (field_name);
6985 ZVAL_STRING (&field_name, "mIndexPolicy", 0);
6986
6987 zval** field = Z_OBJ_HT_PP(p_obj)->get_property_ptr_ptr(*p_obj, &field_name TSRMLS_CC);
6988 sep_copy_on_write (field);
6989 if (local_TMIt117 == NULL)
6990 {
6991 local_TMIt117 = EG (uninitialized_zval_ptr);
6992 local_TMIt117->refcount++;
6993 }
6994 zval** p_lhs = &local_TMIt117;
6995
6996 copy_into_ref (p_lhs, field);
6997 phc_check_invariants (TSRMLS_C);
6998 }
6999 // goto L157;
7000 {
7001 goto L157;
7002 phc_check_invariants (TSRMLS_C);
7003 }
7004 // L156:
7005 L156:;
7006 // $TMIt117 = $this->mIndexPolicy;
7007 {
7008 if (local_this == NULL)
7009 {
7010 local_this = EG (uninitialized_zval_ptr);
7011 local_this->refcount++;
7012 }
7013 zval** p_obj = &local_this;
7014
7015 zval field_name;
7016 INIT_ZVAL (field_name);
7017 ZVAL_STRING (&field_name, "mIndexPolicy", 0);
7018
7019 // I *think* this is correct, but documentation of the Zend API is scarce :)
7020 zval* field = Z_OBJ_HT_PP(p_obj)->read_property(*p_obj, &field_name, BP_VAR_R TSRMLS_CC);
7021 if (local_TMIt117 == NULL)
7022 {
7023 local_TMIt117 = EG (uninitialized_zval_ptr);
7024 local_TMIt117->refcount++;
7025 }
7026 zval** p_lhs = &local_TMIt117;
7027
7028 write_var (p_lhs, field);
7029 phc_check_invariants (TSRMLS_C);
7030 }
7031 // goto L157;
7032 {
7033 goto L157;
7034 phc_check_invariants (TSRMLS_C);
7035 }
7036 // L157:
7037 L157:;
7038 // $TLE34 = wfsetvar($TMIt117, $policy);
7039 {
7040 initialize_function_call (&wfsetvar_fci, &wfsetvar_fcic, "wfsetvar", "/home/mdupont/2009/02/introspector/rdfintrospector/mediawiki/trunk/phase3/includes/parser/ParserOutput.php", 69 TSRMLS_CC);
7041 zend_function* signature = wfsetvar_fcic.function_handler;
7042 zend_arg_info* arg_info = signature->common.arg_info; // optional
7043
7044 int by_ref[2];
7045 int abr_index = 0;
7046 // TODO: find names to replace index
7047 if (arg_info)
7048 {
7049 by_ref[abr_index] = arg_info->pass_by_reference;
7050 arg_info++;
7051 }
7052 else
7053 by_ref[abr_index] = signature->common.pass_rest_by_reference;
7054
7055 abr_index++;
7056 // TODO: find names to replace index
7057 if (arg_info)
7058 {
7059 by_ref[abr_index] = arg_info->pass_by_reference;
7060 arg_info++;
7061 }
7062 else
7063 by_ref[abr_index] = signature->common.pass_rest_by_reference;
7064
7065 abr_index++;
7066
7067
7068 // Setup array of arguments
7069 // TODO: i think arrays of size 0 is an error
7070 int destruct [2];
7071 zval* args [2];
7072 zval** args_ind [2];
7073
7074 int af_index = 0;
7075 destruct[af_index] = 0;
7076 if (by_ref[af_index])
7077 {
7078 if (local_TMIt117 == NULL)
7079 {
7080 local_TMIt117 = EG (uninitialized_zval_ptr);
7081 local_TMIt117->refcount++;
7082 }
7083 zval** p_arg = &local_TMIt117;
7084
7085 args_ind[af_index] = fetch_var_arg_by_ref (p_arg);
7086 assert (!in_copy_on_write (*args_ind[af_index]));
7087 args[af_index] = *args_ind[af_index];
7088 }
7089 else
7090 {
7091 zval* arg;
7092 if (local_TMIt117 == NULL)
7093 arg = EG (uninitialized_zval_ptr);
7094 else
7095 arg = local_TMIt117;
7096
7097 args[af_index] = fetch_var_arg (arg, &destruct[af_index]);
7098 args_ind[af_index] = &args[af_index];
7099 }
7100 af_index++;
7101 destruct[af_index] = 0;
7102 if (by_ref[af_index])
7103 {
7104 if (local_policy == NULL)
7105 {
7106 local_policy = EG (uninitialized_zval_ptr);
7107 local_policy->refcount++;
7108 }
7109 zval** p_arg = &local_policy;
7110
7111 args_ind[af_index] = fetch_var_arg_by_ref (p_arg);
7112 assert (!in_copy_on_write (*args_ind[af_index]));
7113 args[af_index] = *args_ind[af_index];
7114 }
7115 else
7116 {
7117 zval* arg;
7118 if (local_policy == NULL)
7119 arg = EG (uninitialized_zval_ptr);
7120 else
7121 arg = local_policy;
7122
7123 args[af_index] = fetch_var_arg (arg, &destruct[af_index]);
7124 args_ind[af_index] = &args[af_index];
7125 }
7126 af_index++;
7127
7128
7129 phc_setup_error (1, "/home/mdupont/2009/02/introspector/rdfintrospector/mediawiki/trunk/phase3/includes/parser/ParserOutput.php", 69, NULL TSRMLS_CC);
7130
7131 // save existing parameters, in case of recursion
7132 int param_count_save = wfsetvar_fci.param_count;
7133 zval*** params_save = wfsetvar_fci.params;
7134 zval** retval_save = wfsetvar_fci.retval_ptr_ptr;
7135
7136 zval* rhs = NULL;
7137
7138 // set up params
7139 wfsetvar_fci.params = args_ind;
7140 wfsetvar_fci.param_count = 2;
7141 wfsetvar_fci.retval_ptr_ptr = &rhs;
7142
7143 // call the function
7144 int success = zend_call_function (&wfsetvar_fci, &wfsetvar_fcic TSRMLS_CC);
7145 assert(success == SUCCESS);
7146
7147 // restore params
7148 wfsetvar_fci.params = params_save;
7149 wfsetvar_fci.param_count = param_count_save;
7150 wfsetvar_fci.retval_ptr_ptr = retval_save;
7151
7152 // unset the errors
7153 phc_setup_error (0, NULL, 0, NULL TSRMLS_CC);
7154
7155 int i;
7156 for (i = 0; i < 2; i++)
7157 {
7158 if (destruct[i])
7159 {
7160 assert (destruct[i]);
7161 zval_ptr_dtor (args_ind[i]);
7162 }
7163 }
7164
7165
7166 // When the Zend engine returns by reference, it allocates a zval into
7167 // retval_ptr_ptr. To return by reference, the callee writes into the
7168 // retval_ptr_ptr, freeing the allocated value as it does. (Note, it may
7169 // not actually return anything). So the zval returned - whether we return
7170 // it, or it is the allocated zval - has a refcount of 1.
7171
7172 // The caller is responsible for cleaning that up (note, this is unaffected
7173 // by whether it is added to some COW set).
7174
7175 // For reasons unknown, the Zend API resets the refcount and is_ref fields
7176 // of the return value after the function returns (unless the callee is
7177 // interpreted). If the function is supposed to return by reference, this
7178 // loses the refcount. This only happens when non-interpreted code is
7179 // called. We work around it, when compiled code is called, by saving the
7180 // refcount into SAVED_REFCOUNT, in the return statement. The downside is
7181 // that we may create an error if our code is called by a callback, and
7182 // returns by reference, and the callback returns by reference. At least
7183 // this is an obscure case.
7184 if(signature->common.return_reference && signature->type != ZEND_USER_FUNCTION)
7185 {
7186 assert (rhs != EG(uninitialized_zval_ptr));
7187 rhs->is_ref = 1;
7188 if (saved_refcount != 0)
7189 {
7190 rhs->refcount = saved_refcount;
7191 }
7192 rhs->refcount++;
7193 }
7194 saved_refcount = 0; // for 'obscure cases'
7195
7196 if (local_TLE34 == NULL)
7197 {
7198 local_TLE34 = EG (uninitialized_zval_ptr);
7199 local_TLE34->refcount++;
7200 }
7201 zval** p_lhs = &local_TLE34;
7202
7203 write_var (p_lhs, rhs);
7204
7205
7206 zval_ptr_dtor (&rhs);
7207 if(signature->common.return_reference && signature->type != ZEND_USER_FUNCTION)
7208 zval_ptr_dtor (&rhs);
7209
7210 phc_check_invariants (TSRMLS_C);
7211 }
7212 // return $TLE34;
7213 {
7214 zval* rhs;
7215 if (local_TLE34 == NULL)
7216 rhs = EG (uninitialized_zval_ptr);
7217 else
7218 rhs = local_TLE34;
7219
7220 // Run-time return by reference has different semantics to compile-time.
7221 // If the function has CTRBR and RTRBR, the the assignment will be
7222 // reference. If one or the other is return-by-copy, the result will be
7223 // by copy. Its a question of whether its separated at return-time (which
7224 // we do here) or at the call-site.
7225 return_value->value = rhs->value;
7226 return_value->type = rhs->type;
7227 zval_copy_ctor (return_value);
7228 goto end_of_function;
7229 phc_check_invariants (TSRMLS_C);
7230 }
7231 // Method exit
7232 end_of_function:__attribute__((unused));
7233 if (local_TLE118 != NULL)
7234 {
7235 zval_ptr_dtor (&local_TLE118);
7236 }
7237 if (local_TLE34 != NULL)
7238 {
7239 zval_ptr_dtor (&local_TLE34);
7240 }
7241 if (local_TMIt117 != NULL)
7242 {
7243 zval_ptr_dtor (&local_TMIt117);
7244 }
7245 if (local_policy != NULL)
7246 {
7247 zval_ptr_dtor (&local_policy);
7248 }
7249 }
7250 // function addcategory($c, $sort)
7251 // {
7252 // $TSt35 =& $this->mCategories;
7253 // $TSt35[$c] = $sort;
7254 // }
7255 PHP_METHOD(ParserOutput, addcategory)
7256 {
7257 zval* local_TSt35 = NULL;
7258 zval* local_c = NULL;
7259 zval* local_sort = NULL;
7260 zval* local_this = getThis();
7261 // Add all parameters as local variables
7262 {
7263 int num_args = ZEND_NUM_ARGS ();
7264 zval* params[2];
7265 zend_get_parameters_array(0, num_args, params);
7266 // param 0
7267 params[0]->refcount++;
7268 if (local_c != NULL)
7269 {
7270 zval_ptr_dtor (&local_c);
7271 }
7272 local_c = params[0];
7273 // param 1
7274 params[1]->refcount++;
7275 if (local_sort != NULL)
7276 {
7277 zval_ptr_dtor (&local_sort);
7278 }
7279 local_sort = params[1];
7280 }
7281 // Function body
7282 // $TSt35 =& $this->mCategories;
7283 {
7284 if (local_this == NULL)
7285 {
7286 local_this = EG (uninitialized_zval_ptr);
7287 local_this->refcount++;
7288 }
7289 zval** p_obj = &local_this;
7290
7291 zval field_name;
7292 INIT_ZVAL (field_name);
7293 ZVAL_STRING (&field_name, "mCategories", 0);
7294
7295 zval** field = Z_OBJ_HT_PP(p_obj)->get_property_ptr_ptr(*p_obj, &field_name TSRMLS_CC);
7296 sep_copy_on_write (field);
7297 if (local_TSt35 == NULL)
7298 {
7299 local_TSt35 = EG (uninitialized_zval_ptr);
7300 local_TSt35->refcount++;
7301 }
7302 zval** p_lhs = &local_TSt35;
7303
7304 copy_into_ref (p_lhs, field);
7305 phc_check_invariants (TSRMLS_C);
7306 }
7307 // $TSt35[$c] = $sort;
7308 {
7309 if (local_TSt35 == NULL)
7310 {
7311 local_TSt35 = EG (uninitialized_zval_ptr);
7312 local_TSt35->refcount++;
7313 }
7314 zval** p_array = &local_TSt35;
7315
7316 check_array_type (p_array TSRMLS_CC);
7317
7318 zval* index;
7319 if (local_c == NULL)
7320 index = EG (uninitialized_zval_ptr);
7321 else
7322 index = local_c;
7323
7324
7325 // String indexing
7326 if (Z_TYPE_PP (p_array) == IS_STRING && Z_STRLEN_PP (p_array) > 0)
7327 {
7328 zval* rhs;
7329 if (local_sort == NULL)
7330 rhs = EG (uninitialized_zval_ptr);
7331 else
7332 rhs = local_sort;
7333
7334 write_string_index (p_array, index, rhs TSRMLS_CC);
7335 }
7336 else if (Z_TYPE_PP (p_array) == IS_ARRAY)
7337 {
7338 zval** p_lhs = get_ht_entry (p_array, index TSRMLS_CC);
7339 zval* rhs;
7340 if (local_sort == NULL)
7341 rhs = EG (uninitialized_zval_ptr);
7342 else
7343 rhs = local_sort;
7344
7345 if (*p_lhs != rhs)
7346 {
7347 write_var (p_lhs, rhs);
7348 }
7349 }
7350 phc_check_invariants (TSRMLS_C);
7351 }
7352 // Method exit
7353 end_of_function:__attribute__((unused));
7354 if (local_TSt35 != NULL)
7355 {
7356 zval_ptr_dtor (&local_TSt35);
7357 }
7358 if (local_c != NULL)
7359 {
7360 zval_ptr_dtor (&local_c);
7361 }
7362 if (local_sort != NULL)
7363 {
7364 zval_ptr_dtor (&local_sort);
7365 }
7366 }
7367 // function addlanguagelink($t)
7368 // {
7369 // $TSt36 =& $this->mLanguageLinks;
7370 // $TSt36[] = $t;
7371 // }
7372 PHP_METHOD(ParserOutput, addlanguagelink)
7373 {
7374 zval* local_TSt36 = NULL;
7375 zval* local_t = NULL;
7376 zval* local_this = getThis();
7377 // Add all parameters as local variables
7378 {
7379 int num_args = ZEND_NUM_ARGS ();
7380 zval* params[1];
7381 zend_get_parameters_array(0, num_args, params);
7382 // param 0
7383 params[0]->refcount++;
7384 if (local_t != NULL)
7385 {
7386 zval_ptr_dtor (&local_t);
7387 }
7388 local_t = params[0];
7389 }
7390 // Function body
7391 // $TSt36 =& $this->mLanguageLinks;
7392 {
7393 if (local_this == NULL)
7394 {
7395 local_this = EG (uninitialized_zval_ptr);
7396 local_this->refcount++;
7397 }
7398 zval** p_obj = &local_this;
7399
7400 zval field_name;
7401 INIT_ZVAL (field_name);
7402 ZVAL_STRING (&field_name, "mLanguageLinks", 0);
7403
7404 zval** field = Z_OBJ_HT_PP(p_obj)->get_property_ptr_ptr(*p_obj, &field_name TSRMLS_CC);
7405 sep_copy_on_write (field);
7406 if (local_TSt36 == NULL)
7407 {
7408 local_TSt36 = EG (uninitialized_zval_ptr);
7409 local_TSt36->refcount++;
7410 }
7411 zval** p_lhs = &local_TSt36;
7412
7413 copy_into_ref (p_lhs, field);
7414 phc_check_invariants (TSRMLS_C);
7415 }
7416 // $TSt36[] = $t;
7417 {
7418 if (local_TSt36 == NULL)
7419 {
7420 local_TSt36 = EG (uninitialized_zval_ptr);
7421 local_TSt36->refcount++;
7422 }
7423 zval** p_array = &local_TSt36;
7424
7425 // Push EG(uninit) and get a pointer to the symtable entry
7426 zval** p_lhs = push_and_index_ht (p_array TSRMLS_CC);
7427 if (p_lhs != NULL)
7428 {
7429 zval* rhs;
7430 if (local_t == NULL)
7431 rhs = EG (uninitialized_zval_ptr);
7432 else
7433 rhs = local_t;
7434
7435 if (*p_lhs != rhs)
7436 write_var (p_lhs, rhs);
7437 }
7438 // I think if this is NULL, then the LHS is a bool or similar, and you cant
7439 // push onto it.
7440 phc_check_invariants (TSRMLS_C);
7441 }
7442 // Method exit
7443 end_of_function:__attribute__((unused));
7444 if (local_TSt36 != NULL)
7445 {
7446 zval_ptr_dtor (&local_TSt36);
7447 }
7448 if (local_t != NULL)
7449 {
7450 zval_ptr_dtor (&local_t);
7451 }
7452 }
7453 // function addexternallink($url)
7454 // {
7455 // $TSt37 =& $this->mExternalLinks;
7456 // $TLE38 = 1;
7457 // $TSt37[$url] = $TLE38;
7458 // }
7459 PHP_METHOD(ParserOutput, addexternallink)
7460 {
7461 zval* local_TLE38 = NULL;
7462 zval* local_TSt37 = NULL;
7463 zval* local_this = getThis();
7464 zval* local_url = NULL;
7465 // Add all parameters as local variables
7466 {
7467 int num_args = ZEND_NUM_ARGS ();
7468 zval* params[1];
7469 zend_get_parameters_array(0, num_args, params);
7470 // param 0
7471 params[0]->refcount++;
7472 if (local_url != NULL)
7473 {
7474 zval_ptr_dtor (&local_url);
7475 }
7476 local_url = params[0];
7477 }
7478 // Function body
7479 // $TSt37 =& $this->mExternalLinks;
7480 {
7481 if (local_this == NULL)
7482 {
7483 local_this = EG (uninitialized_zval_ptr);
7484 local_this->refcount++;
7485 }
7486 zval** p_obj = &local_this;
7487
7488 zval field_name;
7489 INIT_ZVAL (field_name);
7490 ZVAL_STRING (&field_name, "mExternalLinks", 0);
7491
7492 zval** field = Z_OBJ_HT_PP(p_obj)->get_property_ptr_ptr(*p_obj, &field_name TSRMLS_CC);
7493 sep_copy_on_write (field);
7494 if (local_TSt37 == NULL)
7495 {
7496 local_TSt37 = EG (uninitialized_zval_ptr);
7497 local_TSt37->refcount++;
7498 }
7499 zval** p_lhs = &local_TSt37;
7500
7501 copy_into_ref (p_lhs, field);
7502 phc_check_invariants (TSRMLS_C);
7503 }
7504 // $TLE38 = 1;
7505 {
7506 if (local_TLE38 == NULL)
7507 {
7508 local_TLE38 = EG (uninitialized_zval_ptr);
7509 local_TLE38->refcount++;
7510 }
7511 zval** p_lhs = &local_TLE38;
7512
7513 zval* value;
7514 if ((*p_lhs)->is_ref)
7515 {
7516 // Always overwrite the current value
7517 value = *p_lhs;
7518 zval_dtor (value);
7519 }
7520 else
7521 {
7522 ALLOC_INIT_ZVAL (value);
7523 zval_ptr_dtor (p_lhs);
7524 *p_lhs = value;
7525 }
7526
7527 ZVAL_LONG (value, 1);
7528
7529 phc_check_invariants (TSRMLS_C);
7530 }
7531 // $TSt37[$url] = $TLE38;
7532 {
7533 if (local_TSt37 == NULL)
7534 {
7535 local_TSt37 = EG (uninitialized_zval_ptr);
7536 local_TSt37->refcount++;
7537 }
7538 zval** p_array = &local_TSt37;
7539
7540 check_array_type (p_array TSRMLS_CC);
7541
7542 zval* index;
7543 if (local_url == NULL)
7544 index = EG (uninitialized_zval_ptr);
7545 else
7546 index = local_url;
7547
7548
7549 // String indexing
7550 if (Z_TYPE_PP (p_array) == IS_STRING && Z_STRLEN_PP (p_array) > 0)
7551 {
7552 zval* rhs;
7553 if (local_TLE38 == NULL)
7554 rhs = EG (uninitialized_zval_ptr);
7555 else
7556 rhs = local_TLE38;
7557
7558 write_string_index (p_array, index, rhs TSRMLS_CC);
7559 }
7560 else if (Z_TYPE_PP (p_array) == IS_ARRAY)
7561 {
7562 zval** p_lhs = get_ht_entry (p_array, index TSRMLS_CC);
7563 zval* rhs;
7564 if (local_TLE38 == NULL)
7565 rhs = EG (uninitialized_zval_ptr);
7566 else
7567 rhs = local_TLE38;
7568
7569 if (*p_lhs != rhs)
7570 {
7571 write_var (p_lhs, rhs);
7572 }
7573 }
7574 phc_check_invariants (TSRMLS_C);
7575 }
7576 // Method exit
7577 end_of_function:__attribute__((unused));
7578 if (local_TLE38 != NULL)
7579 {
7580 zval_ptr_dtor (&local_TLE38);
7581 }
7582 if (local_TSt37 != NULL)
7583 {
7584 zval_ptr_dtor (&local_TSt37);
7585 }
7586 if (local_url != NULL)
7587 {
7588 zval_ptr_dtor (&local_url);
7589 }
7590 }
7591 // function addwarning($s)
7592 // {
7593 // $TSt39 =& $this->mWarnings;
7594 // $TLE40 = 1;
7595 // $TSt39[$s] = $TLE40;
7596 // }
7597 PHP_METHOD(ParserOutput, addwarning)
7598 {
7599 zval* local_TLE40 = NULL;
7600 zval* local_TSt39 = NULL;
7601 zval* local_s = NULL;
7602 zval* local_this = getThis();
7603 // Add all parameters as local variables
7604 {
7605 int num_args = ZEND_NUM_ARGS ();
7606 zval* params[1];
7607 zend_get_parameters_array(0, num_args, params);
7608 // param 0
7609 params[0]->refcount++;
7610 if (local_s != NULL)
7611 {
7612 zval_ptr_dtor (&local_s);
7613 }
7614 local_s = params[0];
7615 }
7616 // Function body
7617 // $TSt39 =& $this->mWarnings;
7618 {
7619 if (local_this == NULL)
7620 {
7621 local_this = EG (uninitialized_zval_ptr);
7622 local_this->refcount++;
7623 }
7624 zval** p_obj = &local_this;
7625
7626 zval field_name;
7627 INIT_ZVAL (field_name);
7628 ZVAL_STRING (&field_name, "mWarnings", 0);
7629
7630 zval** field = Z_OBJ_HT_PP(p_obj)->get_property_ptr_ptr(*p_obj, &field_name TSRMLS_CC);
7631 sep_copy_on_write (field);
7632 if (local_TSt39 == NULL)
7633 {
7634 local_TSt39 = EG (uninitialized_zval_ptr);
7635 local_TSt39->refcount++;
7636 }
7637 zval** p_lhs = &local_TSt39;
7638
7639 copy_into_ref (p_lhs, field);
7640 phc_check_invariants (TSRMLS_C);
7641 }
7642 // $TLE40 = 1;
7643 {
7644 if (local_TLE40 == NULL)
7645 {
7646 local_TLE40 = EG (uninitialized_zval_ptr);
7647 local_TLE40->refcount++;
7648 }
7649 zval** p_lhs = &local_TLE40;
7650
7651 zval* value;
7652 if ((*p_lhs)->is_ref)
7653 {
7654 // Always overwrite the current value
7655 value = *p_lhs;
7656 zval_dtor (value);
7657 }
7658 else
7659 {
7660 ALLOC_INIT_ZVAL (value);
7661 zval_ptr_dtor (p_lhs);
7662 *p_lhs = value;
7663 }
7664
7665 ZVAL_LONG (value, 1);
7666
7667 phc_check_invariants (TSRMLS_C);
7668 }
7669 // $TSt39[$s] = $TLE40;
7670 {
7671 if (local_TSt39 == NULL)
7672 {
7673 local_TSt39 = EG (uninitialized_zval_ptr);
7674 local_TSt39->refcount++;
7675 }
7676 zval** p_array = &local_TSt39;
7677
7678 check_array_type (p_array TSRMLS_CC);
7679
7680 zval* index;
7681 if (local_s == NULL)
7682 index = EG (uninitialized_zval_ptr);
7683 else
7684 index = local_s;
7685
7686
7687 // String indexing
7688 if (Z_TYPE_PP (p_array) == IS_STRING && Z_STRLEN_PP (p_array) > 0)
7689 {
7690 zval* rhs;
7691 if (local_TLE40 == NULL)
7692 rhs = EG (uninitialized_zval_ptr);
7693 else
7694 rhs = local_TLE40;
7695
7696 write_string_index (p_array, index, rhs TSRMLS_CC);
7697 }
7698 else if (Z_TYPE_PP (p_array) == IS_ARRAY)
7699 {
7700 zval** p_lhs = get_ht_entry (p_array, index TSRMLS_CC);
7701 zval* rhs;
7702 if (local_TLE40 == NULL)
7703 rhs = EG (uninitialized_zval_ptr);
7704 else
7705 rhs = local_TLE40;
7706
7707 if (*p_lhs != rhs)
7708 {
7709 write_var (p_lhs, rhs);
7710 }
7711 }
7712 phc_check_invariants (TSRMLS_C);
7713 }
7714 // Method exit
7715 end_of_function:__attribute__((unused));
7716 if (local_TLE40 != NULL)
7717 {
7718 zval_ptr_dtor (&local_TLE40);
7719 }
7720 if (local_TSt39 != NULL)
7721 {
7722 zval_ptr_dtor (&local_TSt39);
7723 }
7724 if (local_s != NULL)
7725 {
7726 zval_ptr_dtor (&local_s);
7727 }
7728 }
7729 // function addoutputhook($hook, $data = False)
7730 // {
7731 // $TSt41 =& $this->mOutputHooks;
7732 // unset($TSa42);
7733 // $TSa42 = (array) $TSa42;
7734 // $TSa42[] = $hook;
7735 // $TSa42[] = $data;
7736 // $TSt41[] = $TSa42;
7737 // }
7738 PHP_METHOD(ParserOutput, addoutputhook)
7739 {
7740 zval* local_TSa42 = NULL;
7741 zval* local_TSt41 = NULL;
7742 zval* local_data = NULL;
7743 zval* local_hook = NULL;
7744 zval* local_this = getThis();
7745 // Add all parameters as local variables
7746 {
7747 int num_args = ZEND_NUM_ARGS ();
7748 zval* params[2];
7749 zend_get_parameters_array(0, num_args, params);
7750 // param 0
7751 params[0]->refcount++;
7752 if (local_hook != NULL)
7753 {
7754 zval_ptr_dtor (&local_hook);
7755 }
7756 local_hook = params[0];
7757 // param 1
7758 if (num_args <= 1)
7759 {
7760 zval* default_value;
7761 {
7762 zval* local___static_value__ = NULL;
7763 // $__static_value__ = False;
7764 {
7765 if (local___static_value__ == NULL)
7766 {
7767 local___static_value__ = EG (uninitialized_zval_ptr);
7768 local___static_value__->refcount++;
7769 }
7770 zval** p_lhs = &local___static_value__;
7771
7772 zval* value;
7773 if ((*p_lhs)->is_ref)
7774 {
7775 // Always overwrite the current value
7776 value = *p_lhs;
7777 zval_dtor (value);
7778 }
7779 else
7780 {
7781 ALLOC_INIT_ZVAL (value);
7782 zval_ptr_dtor (p_lhs);
7783 *p_lhs = value;
7784 }
7785
7786 ZVAL_BOOL (value, 0);
7787
7788 phc_check_invariants (TSRMLS_C);
7789 }
7790 default_value = local___static_value__;
7791 assert(!default_value->is_ref);
7792 default_value->refcount++;
7793 if (local___static_value__ != NULL)
7794 {
7795 zval_ptr_dtor (&local___static_value__);
7796 }
7797 }
7798 default_value->refcount--;
7799 params[1] = default_value;
7800 }
7801 params[1]->refcount++;
7802 if (local_data != NULL)
7803 {
7804 zval_ptr_dtor (&local_data);
7805 }
7806 local_data = params[1];
7807 }
7808 // Function body
7809 // $TSt41 =& $this->mOutputHooks;
7810 {
7811 if (local_this == NULL)
7812 {
7813 local_this = EG (uninitialized_zval_ptr);
7814 local_this->refcount++;
7815 }
7816 zval** p_obj = &local_this;
7817
7818 zval field_name;
7819 INIT_ZVAL (field_name);
7820 ZVAL_STRING (&field_name, "mOutputHooks", 0);
7821
7822 zval** field = Z_OBJ_HT_PP(p_obj)->get_property_ptr_ptr(*p_obj, &field_name TSRMLS_CC);
7823 sep_copy_on_write (field);
7824 if (local_TSt41 == NULL)
7825 {
7826 local_TSt41 = EG (uninitialized_zval_ptr);
7827 local_TSt41->refcount++;
7828 }
7829 zval** p_lhs = &local_TSt41;
7830
7831 copy_into_ref (p_lhs, field);
7832 phc_check_invariants (TSRMLS_C);
7833 }
7834 // unset($TSa42);
7835 {
7836 if (local_TSa42 != NULL)
7837 {
7838 zval_ptr_dtor (&local_TSa42);
7839 local_TSa42 = NULL;
7840 }
7841 phc_check_invariants (TSRMLS_C);
7842 }
7843 // $TSa42 = (array) $TSa42;
7844 {
7845 if (local_TSa42 == NULL)
7846 {
7847 local_TSa42 = EG (uninitialized_zval_ptr);
7848 local_TSa42->refcount++;
7849 }
7850 zval** p_lhs = &local_TSa42;
7851
7852 zval* rhs;
7853 if (local_TSa42 == NULL)
7854 rhs = EG (uninitialized_zval_ptr);
7855 else
7856 rhs = local_TSa42;
7857
7858 if (*p_lhs != rhs)
7859 {
7860 if ((*p_lhs)->is_ref)
7861 overwrite_lhs (*p_lhs, rhs);
7862 else
7863 {
7864 zval_ptr_dtor (p_lhs);
7865 if (rhs->is_ref)
7866 {
7867 // Take a copy of RHS for LHS
7868 *p_lhs = zvp_clone_ex (rhs);
7869 }
7870 else
7871 {
7872 // Share a copy
7873 rhs->refcount++;
7874 *p_lhs = rhs;
7875 }
7876
7877 }
7878
7879 }
7880
7881 assert (IS_ARRAY >= 0 && IS_ARRAY <= 6);
7882 if ((*p_lhs)->type != IS_ARRAY)
7883 {
7884 sep_copy_on_write (p_lhs);
7885 convert_to_array (*p_lhs);
7886 }
7887
7888 phc_check_invariants (TSRMLS_C);
7889 }
7890 // $TSa42[] = $hook;
7891 {
7892 if (local_TSa42 == NULL)
7893 {
7894 local_TSa42 = EG (uninitialized_zval_ptr);
7895 local_TSa42->refcount++;
7896 }
7897 zval** p_array = &local_TSa42;
7898
7899 // Push EG(uninit) and get a pointer to the symtable entry
7900 zval** p_lhs = push_and_index_ht (p_array TSRMLS_CC);
7901 if (p_lhs != NULL)
7902 {
7903 zval* rhs;
7904 if (local_hook == NULL)
7905 rhs = EG (uninitialized_zval_ptr);
7906 else
7907 rhs = local_hook;
7908
7909 if (*p_lhs != rhs)
7910 write_var (p_lhs, rhs);
7911 }
7912 // I think if this is NULL, then the LHS is a bool or similar, and you cant
7913 // push onto it.
7914 phc_check_invariants (TSRMLS_C);
7915 }
7916 // $TSa42[] = $data;
7917 {
7918 if (local_TSa42 == NULL)
7919 {
7920 local_TSa42 = EG (uninitialized_zval_ptr);
7921 local_TSa42->refcount++;
7922 }
7923 zval** p_array = &local_TSa42;
7924
7925 // Push EG(uninit) and get a pointer to the symtable entry
7926 zval** p_lhs = push_and_index_ht (p_array TSRMLS_CC);
7927 if (p_lhs != NULL)
7928 {
7929 zval* rhs;
7930 if (local_data == NULL)
7931 rhs = EG (uninitialized_zval_ptr);
7932 else
7933 rhs = local_data;
7934
7935 if (*p_lhs != rhs)
7936 write_var (p_lhs, rhs);
7937 }
7938 // I think if this is NULL, then the LHS is a bool or similar, and you cant
7939 // push onto it.
7940 phc_check_invariants (TSRMLS_C);
7941 }
7942 // $TSt41[] = $TSa42;
7943 {
7944 if (local_TSt41 == NULL)
7945 {
7946 local_TSt41 = EG (uninitialized_zval_ptr);
7947 local_TSt41->refcount++;
7948 }
7949 zval** p_array = &local_TSt41;
7950
7951 // Push EG(uninit) and get a pointer to the symtable entry
7952 zval** p_lhs = push_and_index_ht (p_array TSRMLS_CC);
7953 if (p_lhs != NULL)
7954 {
7955 zval* rhs;
7956 if (local_TSa42 == NULL)
7957 rhs = EG (uninitialized_zval_ptr);
7958 else
7959 rhs = local_TSa42;
7960
7961 if (*p_lhs != rhs)
7962 write_var (p_lhs, rhs);
7963 }
7964 // I think if this is NULL, then the LHS is a bool or similar, and you cant
7965 // push onto it.
7966 phc_check_invariants (TSRMLS_C);
7967 }
7968 // Method exit
7969 end_of_function:__attribute__((unused));
7970 if (local_TSa42 != NULL)
7971 {
7972 zval_ptr_dtor (&local_TSa42);
7973 }
7974 if (local_TSt41 != NULL)
7975 {
7976 zval_ptr_dtor (&local_TSt41);
7977 }
7978 if (local_data != NULL)
7979 {
7980 zval_ptr_dtor (&local_data);
7981 }
7982 if (local_hook != NULL)
7983 {
7984 zval_ptr_dtor (&local_hook);
7985 }
7986 }
7987 // function setnewsection($value)
7988 // {
7989 // $TLE43 = (bool) $value;
7990 // $this->mNewSection = $TLE43;
7991 // }
7992 PHP_METHOD(ParserOutput, setnewsection)
7993 {
7994 zval* local_TLE43 = NULL;
7995 zval* local_this = getThis();
7996 zval* local_value = NULL;
7997 // Add all parameters as local variables
7998 {
7999 int num_args = ZEND_NUM_ARGS ();
8000 zval* params[1];
8001 zend_get_parameters_array(0, num_args, params);
8002 // param 0
8003 params[0]->refcount++;
8004 if (local_value != NULL)
8005 {
8006 zval_ptr_dtor (&local_value);
8007 }
8008 local_value = params[0];
8009 }
8010 // Function body
8011 // $TLE43 = (bool) $value;
8012 {
8013 if (local_TLE43 == NULL)
8014 {
8015 local_TLE43 = EG (uninitialized_zval_ptr);
8016 local_TLE43->refcount++;
8017 }
8018 zval** p_lhs = &local_TLE43;
8019
8020 zval* rhs;
8021 if (local_value == NULL)
8022 rhs = EG (uninitialized_zval_ptr);
8023 else
8024 rhs = local_value;
8025
8026 if (*p_lhs != rhs)
8027 {
8028 if ((*p_lhs)->is_ref)
8029 overwrite_lhs (*p_lhs, rhs);
8030 else
8031 {
8032 zval_ptr_dtor (p_lhs);
8033 if (rhs->is_ref)
8034 {
8035 // Take a copy of RHS for LHS
8036 *p_lhs = zvp_clone_ex (rhs);
8037 }
8038 else
8039 {
8040 // Share a copy
8041 rhs->refcount++;
8042 *p_lhs = rhs;
8043 }
8044
8045 }
8046
8047 }
8048
8049 assert (IS_BOOL >= 0 && IS_BOOL <= 6);
8050 if ((*p_lhs)->type != IS_BOOL)
8051 {
8052 sep_copy_on_write (p_lhs);
8053 convert_to_boolean (*p_lhs);
8054 }
8055
8056 phc_check_invariants (TSRMLS_C);
8057 }
8058 // $this->mNewSection = $TLE43;
8059 {
8060 if (local_this == NULL)
8061 {
8062 local_this = EG (uninitialized_zval_ptr);
8063 local_this->refcount++;
8064 }
8065 zval** p_obj = &local_this;
8066
8067 zval* rhs;
8068 if (local_TLE43 == NULL)
8069 rhs = EG (uninitialized_zval_ptr);
8070 else
8071 rhs = local_TLE43;
8072
8073 zval field_name;
8074 INIT_ZVAL (field_name);
8075 ZVAL_STRING (&field_name, "mNewSection", 0);
8076
8077 Z_OBJ_HT_PP(p_obj)->write_property(*p_obj, &field_name, rhs TSRMLS_CC);
8078 phc_check_invariants (TSRMLS_C);
8079 }
8080 // Method exit
8081 end_of_function:__attribute__((unused));
8082 if (local_TLE43 != NULL)
8083 {
8084 zval_ptr_dtor (&local_TLE43);
8085 }
8086 if (local_value != NULL)
8087 {
8088 zval_ptr_dtor (&local_value);
8089 }
8090 }
8091 // function getnewsection()
8092 // {
8093 // $TSt44 = $this->mNewSection;
8094 // $TLE45 = (bool) $TSt44;
8095 // return $TLE45;
8096 // }
8097 PHP_METHOD(ParserOutput, getnewsection)
8098 {
8099 zval* local_TLE45 = NULL;
8100 zval* local_TSt44 = NULL;
8101 zval* local_this = getThis();
8102 // Function body
8103 // $TSt44 = $this->mNewSection;
8104 {
8105 if (local_this == NULL)
8106 {
8107 local_this = EG (uninitialized_zval_ptr);
8108 local_this->refcount++;
8109 }
8110 zval** p_obj = &local_this;
8111
8112 zval field_name;
8113 INIT_ZVAL (field_name);
8114 ZVAL_STRING (&field_name, "mNewSection", 0);
8115
8116 // I *think* this is correct, but documentation of the Zend API is scarce :)
8117 zval* field = Z_OBJ_HT_PP(p_obj)->read_property(*p_obj, &field_name, BP_VAR_R TSRMLS_CC);
8118 if (local_TSt44 == NULL)
8119 {
8120 local_TSt44 = EG (uninitialized_zval_ptr);
8121 local_TSt44->refcount++;
8122 }
8123 zval** p_lhs = &local_TSt44;
8124
8125 write_var (p_lhs, field);
8126 phc_check_invariants (TSRMLS_C);
8127 }
8128 // $TLE45 = (bool) $TSt44;
8129 {
8130 if (local_TLE45 == NULL)
8131 {
8132 local_TLE45 = EG (uninitialized_zval_ptr);
8133 local_TLE45->refcount++;
8134 }
8135 zval** p_lhs = &local_TLE45;
8136
8137 zval* rhs;
8138 if (local_TSt44 == NULL)
8139 rhs = EG (uninitialized_zval_ptr);
8140 else
8141 rhs = local_TSt44;
8142
8143 if (*p_lhs != rhs)
8144 {
8145 if ((*p_lhs)->is_ref)
8146 overwrite_lhs (*p_lhs, rhs);
8147 else
8148 {
8149 zval_ptr_dtor (p_lhs);
8150 if (rhs->is_ref)
8151 {
8152 // Take a copy of RHS for LHS
8153 *p_lhs = zvp_clone_ex (rhs);
8154 }
8155 else
8156 {
8157 // Share a copy
8158 rhs->refcount++;
8159 *p_lhs = rhs;
8160 }
8161
8162 }
8163
8164 }
8165
8166 assert (IS_BOOL >= 0 && IS_BOOL <= 6);
8167 if ((*p_lhs)->type != IS_BOOL)
8168 {
8169 sep_copy_on_write (p_lhs);
8170 convert_to_boolean (*p_lhs);
8171 }
8172
8173 phc_check_invariants (TSRMLS_C);
8174 }
8175 // return $TLE45;
8176 {
8177 zval* rhs;
8178 if (local_TLE45 == NULL)
8179 rhs = EG (uninitialized_zval_ptr);
8180 else
8181 rhs = local_TLE45;
8182
8183 // Run-time return by reference has different semantics to compile-time.
8184 // If the function has CTRBR and RTRBR, the the assignment will be
8185 // reference. If one or the other is return-by-copy, the result will be
8186 // by copy. Its a question of whether its separated at return-time (which
8187 // we do here) or at the call-site.
8188 return_value->value = rhs->value;
8189 return_value->type = rhs->type;
8190 zval_copy_ctor (return_value);
8191 goto end_of_function;
8192 phc_check_invariants (TSRMLS_C);
8193 }
8194 // Method exit
8195 end_of_function:__attribute__((unused));
8196 if (local_TLE45 != NULL)
8197 {
8198 zval_ptr_dtor (&local_TLE45);
8199 }
8200 if (local_TSt44 != NULL)
8201 {
8202 zval_ptr_dtor (&local_TSt44);
8203 }
8204 }
8205 // function addlink($title, $id = NULL)
8206 // {
8207 // $ns = $title->getnamespace();
8208 // $dbk = $title->getdbkey();
8209 // $TLE46 = NS_MEDIA;
8210 // $TLE47 = ($ns == $TLE46);
8211 // if (TLE47) goto L164 else goto L165;
8212 // L164:
8213 // $ns = NS_FILE;
8214 // goto L166;
8215 // L165:
8216 // $TLE48 = NS_SPECIAL;
8217 // $TLE49 = ($ns == $TLE48);
8218 // if (TLE49) goto L161 else goto L162;
8219 // L161:
8220 // $TLE50 = NULL;
8221 // return $TLE50;
8222 // goto L163;
8223 // L162:
8224 // $TLE51 = '';
8225 // $TLE52 = ($dbk === $TLE51);
8226 // if (TLE52) goto L158 else goto L159;
8227 // L158:
8228 // $TLE53 = NULL;
8229 // return $TLE53;
8230 // goto L160;
8231 // L159:
8232 // goto L160;
8233 // L160:
8234 // goto L163;
8235 // L163:
8236 // goto L166;
8237 // L166:
8238 // $TMIt119 = $this->mLinks;
8239 // $TLE54 = isset($TMIt119[$ns]);
8240 // $TLE55 = !$TLE54;
8241 // if (TLE55) goto L167 else goto L168;
8242 // L167:
8243 // $TSt56 =& $this->mLinks;
8244 // unset($TSa57);
8245 // $TSa57 = (array) $TSa57;
8246 // $TSt56[$ns] = $TSa57;
8247 // goto L169;
8248 // L168:
8249 // goto L169;
8250 // L169:
8251 // $TLE58 = is_null($id);
8252 // if (TLE58) goto L170 else goto L171;
8253 // L170:
8254 // $id = $title->getarticleid();
8255 // goto L172;
8256 // L171:
8257 // goto L172;
8258 // L172:
8259 // $TSt59 =& $this->mLinks;
8260 // $TSi60 =& $TSt59[$ns];
8261 // $TSi60[$dbk] = $id;
8262 // }
8263 PHP_METHOD(ParserOutput, addlink)
8264 {
8265 zval* local_TLE46 = NULL;
8266 zval* local_TLE47 = NULL;
8267 zval* local_TLE48 = NULL;
8268 zval* local_TLE49 = NULL;
8269 zval* local_TLE50 = NULL;
8270 zval* local_TLE51 = NULL;
8271 zval* local_TLE52 = NULL;
8272 zval* local_TLE53 = NULL;
8273 zval* local_TLE54 = NULL;
8274 zval* local_TLE55 = NULL;
8275 zval* local_TLE58 = NULL;
8276 zval* local_TMIt119 = NULL;
8277 zval* local_TSa57 = NULL;
8278 zval* local_TSi60 = NULL;
8279 zval* local_TSt56 = NULL;
8280 zval* local_TSt59 = NULL;
8281 zval* local_dbk = NULL;
8282 zval* local_id = NULL;
8283 zval* local_ns = NULL;
8284 zval* local_this = getThis();
8285 zval* local_title = NULL;
8286 // Add all parameters as local variables
8287 {
8288 int num_args = ZEND_NUM_ARGS ();
8289 zval* params[2];
8290 zend_get_parameters_array(0, num_args, params);
8291 // param 0
8292 params[0]->refcount++;
8293 if (local_title != NULL)
8294 {
8295 zval_ptr_dtor (&local_title);
8296 }
8297 local_title = params[0];
8298 // param 1
8299 if (num_args <= 1)
8300 {
8301 zval* default_value;
8302 {
8303 zval* local___static_value__ = NULL;
8304 // $__static_value__ = NULL;
8305 {
8306 if (local___static_value__ == NULL)
8307 {
8308 local___static_value__ = EG (uninitialized_zval_ptr);
8309 local___static_value__->refcount++;
8310 }
8311 zval** p_lhs = &local___static_value__;
8312
8313 zval* value;
8314 if ((*p_lhs)->is_ref)
8315 {
8316 // Always overwrite the current value
8317 value = *p_lhs;
8318 zval_dtor (value);
8319 }
8320 else
8321 {
8322 ALLOC_INIT_ZVAL (value);
8323 zval_ptr_dtor (p_lhs);
8324 *p_lhs = value;
8325 }
8326
8327 ZVAL_NULL (value);
8328
8329 phc_check_invariants (TSRMLS_C);
8330 }
8331 default_value = local___static_value__;
8332 assert(!default_value->is_ref);
8333 default_value->refcount++;
8334 if (local___static_value__ != NULL)
8335 {
8336 zval_ptr_dtor (&local___static_value__);
8337 }
8338 }
8339 default_value->refcount--;
8340 params[1] = default_value;
8341 }
8342 params[1]->refcount++;
8343 if (local_id != NULL)
8344 {
8345 zval_ptr_dtor (&local_id);
8346 }
8347 local_id = params[1];
8348 }
8349 // Function body
8350 // $ns = $title->getnamespace();
8351 {
8352 if (local_title == NULL)
8353 {
8354 local_title = EG (uninitialized_zval_ptr);
8355 local_title->refcount++;
8356 }
8357 zval** p_obj = &local_title;
8358
8359 zend_fcall_info fci_object;
8360 zend_fcall_info_cache fcic_object = {0, NULL, NULL, NULL};
8361 initialize_method_call (&fci_object, &fcic_object, p_obj, "getnamespace", "/home/mdupont/2009/02/introspector/rdfintrospector/mediawiki/trunk/phase3/includes/parser/ParserOutput.php", 88 TSRMLS_CC);
8362 zend_function* signature = fcic_object.function_handler;
8363 zend_arg_info* arg_info = signature->common.arg_info; // optional
8364
8365 int by_ref[0];
8366 int abr_index = 0;
8367
8368
8369 // Setup array of arguments
8370 // TODO: i think arrays of size 0 is an error
8371 int destruct [0];
8372 zval* args [0];
8373 zval** args_ind [0];
8374
8375 int af_index = 0;
8376
8377
8378 phc_setup_error (1, "/home/mdupont/2009/02/introspector/rdfintrospector/mediawiki/trunk/phase3/includes/parser/ParserOutput.php", 88, NULL TSRMLS_CC);
8379
8380 // save existing parameters, in case of recursion
8381 int param_count_save = fci_object.param_count;
8382 zval*** params_save = fci_object.params;
8383 zval** retval_save = fci_object.retval_ptr_ptr;
8384
8385 zval* rhs = NULL;
8386
8387 // set up params
8388 fci_object.params = args_ind;
8389 fci_object.param_count = 0;
8390 fci_object.retval_ptr_ptr = &rhs;
8391
8392 // call the function
8393 int success = zend_call_function (&fci_object, &fcic_object TSRMLS_CC);
8394 assert(success == SUCCESS);
8395
8396 // restore params
8397 fci_object.params = params_save;
8398 fci_object.param_count = param_count_save;
8399 fci_object.retval_ptr_ptr = retval_save;
8400
8401 // unset the errors
8402 phc_setup_error (0, NULL, 0, NULL TSRMLS_CC);
8403
8404 int i;
8405 for (i = 0; i < 0; i++)
8406 {
8407 if (destruct[i])
8408 {
8409 assert (destruct[i]);
8410 zval_ptr_dtor (args_ind[i]);
8411 }
8412 }
8413
8414
8415 // When the Zend engine returns by reference, it allocates a zval into
8416 // retval_ptr_ptr. To return by reference, the callee writes into the
8417 // retval_ptr_ptr, freeing the allocated value as it does. (Note, it may
8418 // not actually return anything). So the zval returned - whether we return
8419 // it, or it is the allocated zval - has a refcount of 1.
8420
8421 // The caller is responsible for cleaning that up (note, this is unaffected
8422 // by whether it is added to some COW set).
8423
8424 // For reasons unknown, the Zend API resets the refcount and is_ref fields
8425 // of the return value after the function returns (unless the callee is
8426 // interpreted). If the function is supposed to return by reference, this
8427 // loses the refcount. This only happens when non-interpreted code is
8428 // called. We work around it, when compiled code is called, by saving the
8429 // refcount into SAVED_REFCOUNT, in the return statement. The downside is
8430 // that we may create an error if our code is called by a callback, and
8431 // returns by reference, and the callback returns by reference. At least
8432 // this is an obscure case.
8433 if(signature->common.return_reference && signature->type != ZEND_USER_FUNCTION)
8434 {
8435 assert (rhs != EG(uninitialized_zval_ptr));
8436 rhs->is_ref = 1;
8437 if (saved_refcount != 0)
8438 {
8439 rhs->refcount = saved_refcount;
8440 }
8441 rhs->refcount++;
8442 }
8443 saved_refcount = 0; // for 'obscure cases'
8444
8445 if (local_ns == NULL)
8446 {
8447 local_ns = EG (uninitialized_zval_ptr);
8448 local_ns->refcount++;
8449 }
8450 zval** p_lhs = &local_ns;
8451
8452 write_var (p_lhs, rhs);
8453
8454
8455 zval_ptr_dtor (&rhs);
8456 if(signature->common.return_reference && signature->type != ZEND_USER_FUNCTION)
8457 zval_ptr_dtor (&rhs);
8458
8459 phc_check_invariants (TSRMLS_C);
8460 }
8461 // $dbk = $title->getdbkey();
8462 {
8463 if (local_title == NULL)
8464 {
8465 local_title = EG (uninitialized_zval_ptr);
8466 local_title->refcount++;
8467 }
8468 zval** p_obj = &local_title;
8469
8470 zend_fcall_info fci_object;
8471 zend_fcall_info_cache fcic_object = {0, NULL, NULL, NULL};
8472 initialize_method_call (&fci_object, &fcic_object, p_obj, "getdbkey", "/home/mdupont/2009/02/introspector/rdfintrospector/mediawiki/trunk/phase3/includes/parser/ParserOutput.php", 89 TSRMLS_CC);
8473 zend_function* signature = fcic_object.function_handler;
8474 zend_arg_info* arg_info = signature->common.arg_info; // optional
8475
8476 int by_ref[0];
8477 int abr_index = 0;
8478
8479
8480 // Setup array of arguments
8481 // TODO: i think arrays of size 0 is an error
8482 int destruct [0];
8483 zval* args [0];
8484 zval** args_ind [0];
8485
8486 int af_index = 0;
8487
8488
8489 phc_setup_error (1, "/home/mdupont/2009/02/introspector/rdfintrospector/mediawiki/trunk/phase3/includes/parser/ParserOutput.php", 89, NULL TSRMLS_CC);
8490
8491 // save existing parameters, in case of recursion
8492 int param_count_save = fci_object.param_count;
8493 zval*** params_save = fci_object.params;
8494 zval** retval_save = fci_object.retval_ptr_ptr;
8495
8496 zval* rhs = NULL;
8497
8498 // set up params
8499 fci_object.params = args_ind;
8500 fci_object.param_count = 0;
8501 fci_object.retval_ptr_ptr = &rhs;
8502
8503 // call the function
8504 int success = zend_call_function (&fci_object, &fcic_object TSRMLS_CC);
8505 assert(success == SUCCESS);
8506
8507 // restore params
8508 fci_object.params = params_save;
8509 fci_object.param_count = param_count_save;
8510 fci_object.retval_ptr_ptr = retval_save;
8511
8512 // unset the errors
8513 phc_setup_error (0, NULL, 0, NULL TSRMLS_CC);
8514
8515 int i;
8516 for (i = 0; i < 0; i++)
8517 {
8518 if (destruct[i])
8519 {
8520 assert (destruct[i]);
8521 zval_ptr_dtor (args_ind[i]);
8522 }
8523 }
8524
8525
8526 // When the Zend engine returns by reference, it allocates a zval into
8527 // retval_ptr_ptr. To return by reference, the callee writes into the
8528 // retval_ptr_ptr, freeing the allocated value as it does. (Note, it may
8529 // not actually return anything). So the zval returned - whether we return
8530 // it, or it is the allocated zval - has a refcount of 1.
8531
8532 // The caller is responsible for cleaning that up (note, this is unaffected
8533 // by whether it is added to some COW set).
8534
8535 // For reasons unknown, the Zend API resets the refcount and is_ref fields
8536 // of the return value after the function returns (unless the callee is
8537 // interpreted). If the function is supposed to return by reference, this
8538 // loses the refcount. This only happens when non-interpreted code is
8539 // called. We work around it, when compiled code is called, by saving the
8540 // refcount into SAVED_REFCOUNT, in the return statement. The downside is
8541 // that we may create an error if our code is called by a callback, and
8542 // returns by reference, and the callback returns by reference. At least
8543 // this is an obscure case.
8544 if(signature->common.return_reference && signature->type != ZEND_USER_FUNCTION)
8545 {
8546 assert (rhs != EG(uninitialized_zval_ptr));
8547 rhs->is_ref = 1;
8548 if (saved_refcount != 0)
8549 {
8550 rhs->refcount = saved_refcount;
8551 }
8552 rhs->refcount++;
8553 }
8554 saved_refcount = 0; // for 'obscure cases'
8555
8556 if (local_dbk == NULL)
8557 {
8558 local_dbk = EG (uninitialized_zval_ptr);
8559 local_dbk->refcount++;
8560 }
8561 zval** p_lhs = &local_dbk;
8562
8563 write_var (p_lhs, rhs);
8564
8565
8566 zval_ptr_dtor (&rhs);
8567 if(signature->common.return_reference && signature->type != ZEND_USER_FUNCTION)
8568 zval_ptr_dtor (&rhs);
8569
8570 phc_check_invariants (TSRMLS_C);
8571 }
8572 // $TLE46 = NS_MEDIA;
8573 {
8574 // No null-terminator in length for get_constant.
8575 // zend_get_constant always returns a copy of the constant.
8576 if (local_TLE46 == NULL)
8577 {
8578 local_TLE46 = EG (uninitialized_zval_ptr);
8579 local_TLE46->refcount++;
8580 }
8581 zval** p_lhs = &local_TLE46;
8582
8583 if (!(*p_lhs)->is_ref)
8584 {
8585 zval_ptr_dtor (p_lhs);
8586 get_constant ("NS_MEDIA", 8, p_lhs TSRMLS_CC);
8587
8588 }
8589 else
8590 {
8591 zval* constant;
8592 get_constant ("NS_MEDIA", 8, p_lhs TSRMLS_CC);
8593 overwrite_lhs_no_copy (*p_lhs, constant);
8594 safe_free_zval_ptr (constant);
8595
8596 }
8597 phc_check_invariants (TSRMLS_C);
8598 }
8599 // $TLE47 = ($ns == $TLE46);
8600 {
8601 if (local_TLE47 == NULL)
8602 {
8603 local_TLE47 = EG (uninitialized_zval_ptr);
8604 local_TLE47->refcount++;
8605 }
8606 zval** p_lhs = &local_TLE47;
8607
8608 zval* left;
8609 if (local_ns == NULL)
8610 left = EG (uninitialized_zval_ptr);
8611 else
8612 left = local_ns;
8613
8614 zval* right;
8615 if (local_TLE46 == NULL)
8616 right = EG (uninitialized_zval_ptr);
8617 else
8618 right = local_TLE46;
8619
8620 if (in_copy_on_write (*p_lhs))
8621 {
8622 zval_ptr_dtor (p_lhs);
8623 ALLOC_INIT_ZVAL (*p_lhs);
8624 }
8625
8626 zval old = **p_lhs;
8627 int result_is_operand = (*p_lhs == left || *p_lhs == right);
8628 is_equal_function (*p_lhs, left, right TSRMLS_CC);
8629
8630 // If the result is one of the operands, the operator function
8631 // will already have cleaned up the result
8632 if (!result_is_operand)
8633 zval_dtor (&old);
8634 phc_check_invariants (TSRMLS_C);
8635 }
8636 // if (TLE47) goto L164 else goto L165;
8637 {
8638 zval* p_cond;
8639 if (local_TLE47 == NULL)
8640 p_cond = EG (uninitialized_zval_ptr);
8641 else
8642 p_cond = local_TLE47;
8643
8644 zend_bool bcond = zend_is_true (p_cond);
8645 if (bcond)
8646 goto L164;
8647 else
8648 goto L165;
8649 phc_check_invariants (TSRMLS_C);
8650 }
8651 // L164:
8652 L164:;
8653 // $ns = NS_FILE;
8654 {
8655 // No null-terminator in length for get_constant.
8656 // zend_get_constant always returns a copy of the constant.
8657 if (local_ns == NULL)
8658 {
8659 local_ns = EG (uninitialized_zval_ptr);
8660 local_ns->refcount++;
8661 }
8662 zval** p_lhs = &local_ns;
8663
8664 if (!(*p_lhs)->is_ref)
8665 {
8666 zval_ptr_dtor (p_lhs);
8667 get_constant ("NS_FILE", 7, p_lhs TSRMLS_CC);
8668
8669 }
8670 else
8671 {
8672 zval* constant;
8673 get_constant ("NS_FILE", 7, p_lhs TSRMLS_CC);
8674 overwrite_lhs_no_copy (*p_lhs, constant);
8675 safe_free_zval_ptr (constant);
8676
8677 }
8678 phc_check_invariants (TSRMLS_C);
8679 }
8680 // goto L166;
8681 {
8682 goto L166;
8683 phc_check_invariants (TSRMLS_C);
8684 }
8685 // L165:
8686 L165:;
8687 // $TLE48 = NS_SPECIAL;
8688 {
8689 // No null-terminator in length for get_constant.
8690 // zend_get_constant always returns a copy of the constant.
8691 if (local_TLE48 == NULL)
8692 {
8693 local_TLE48 = EG (uninitialized_zval_ptr);
8694 local_TLE48->refcount++;
8695 }
8696 zval** p_lhs = &local_TLE48;
8697
8698 if (!(*p_lhs)->is_ref)
8699 {
8700 zval_ptr_dtor (p_lhs);
8701 get_constant ("NS_SPECIAL", 10, p_lhs TSRMLS_CC);
8702
8703 }
8704 else
8705 {
8706 zval* constant;
8707 get_constant ("NS_SPECIAL", 10, p_lhs TSRMLS_CC);
8708 overwrite_lhs_no_copy (*p_lhs, constant);
8709 safe_free_zval_ptr (constant);
8710
8711 }
8712 phc_check_invariants (TSRMLS_C);
8713 }
8714 // $TLE49 = ($ns == $TLE48);
8715 {
8716 if (local_TLE49 == NULL)
8717 {
8718 local_TLE49 = EG (uninitialized_zval_ptr);
8719 local_TLE49->refcount++;
8720 }
8721 zval** p_lhs = &local_TLE49;
8722
8723 zval* left;
8724 if (local_ns == NULL)
8725 left = EG (uninitialized_zval_ptr);
8726 else
8727 left = local_ns;
8728
8729 zval* right;
8730 if (local_TLE48 == NULL)
8731 right = EG (uninitialized_zval_ptr);
8732 else
8733 right = local_TLE48;
8734
8735 if (in_copy_on_write (*p_lhs))
8736 {
8737 zval_ptr_dtor (p_lhs);
8738 ALLOC_INIT_ZVAL (*p_lhs);
8739 }
8740
8741 zval old = **p_lhs;
8742 int result_is_operand = (*p_lhs == left || *p_lhs == right);
8743 is_equal_function (*p_lhs, left, right TSRMLS_CC);
8744
8745 // If the result is one of the operands, the operator function
8746 // will already have cleaned up the result
8747 if (!result_is_operand)
8748 zval_dtor (&old);
8749 phc_check_invariants (TSRMLS_C);
8750 }
8751 // if (TLE49) goto L161 else goto L162;
8752 {
8753 zval* p_cond;
8754 if (local_TLE49 == NULL)
8755 p_cond = EG (uninitialized_zval_ptr);
8756 else
8757 p_cond = local_TLE49;
8758
8759 zend_bool bcond = zend_is_true (p_cond);
8760 if (bcond)
8761 goto L161;
8762 else
8763 goto L162;
8764 phc_check_invariants (TSRMLS_C);
8765 }
8766 // L161:
8767 L161:;
8768 // $TLE50 = NULL;
8769 {
8770 if (local_TLE50 == NULL)
8771 {
8772 local_TLE50 = EG (uninitialized_zval_ptr);
8773 local_TLE50->refcount++;
8774 }
8775 zval** p_lhs = &local_TLE50;
8776
8777 zval* value;
8778 if ((*p_lhs)->is_ref)
8779 {
8780 // Always overwrite the current value
8781 value = *p_lhs;
8782 zval_dtor (value);
8783 }
8784 else
8785 {
8786 ALLOC_INIT_ZVAL (value);
8787 zval_ptr_dtor (p_lhs);
8788 *p_lhs = value;
8789 }
8790
8791 ZVAL_NULL (value);
8792
8793 phc_check_invariants (TSRMLS_C);
8794 }
8795 // return $TLE50;
8796 {
8797 zval* rhs;
8798 if (local_TLE50 == NULL)
8799 rhs = EG (uninitialized_zval_ptr);
8800 else
8801 rhs = local_TLE50;
8802
8803 // Run-time return by reference has different semantics to compile-time.
8804 // If the function has CTRBR and RTRBR, the the assignment will be
8805 // reference. If one or the other is return-by-copy, the result will be
8806 // by copy. Its a question of whether its separated at return-time (which
8807 // we do here) or at the call-site.
8808 return_value->value = rhs->value;
8809 return_value->type = rhs->type;
8810 zval_copy_ctor (return_value);
8811 goto end_of_function;
8812 phc_check_invariants (TSRMLS_C);
8813 }
8814 // goto L163;
8815 {
8816 goto L163;
8817 phc_check_invariants (TSRMLS_C);
8818 }
8819 // L162:
8820 L162:;
8821 // $TLE51 = '';
8822 {
8823 if (local_TLE51 == NULL)
8824 {
8825 local_TLE51 = EG (uninitialized_zval_ptr);
8826 local_TLE51->refcount++;
8827 }
8828 zval** p_lhs = &local_TLE51;
8829
8830 zval* value;
8831 if ((*p_lhs)->is_ref)
8832 {
8833 // Always overwrite the current value
8834 value = *p_lhs;
8835 zval_dtor (value);
8836 }
8837 else
8838 {
8839 ALLOC_INIT_ZVAL (value);
8840 zval_ptr_dtor (p_lhs);
8841 *p_lhs = value;
8842 }
8843
8844 ZVAL_STRINGL(value, "", 0, 1);
8845
8846 phc_check_invariants (TSRMLS_C);
8847 }
8848 // $TLE52 = ($dbk === $TLE51);
8849 {
8850 if (local_TLE52 == NULL)
8851 {
8852 local_TLE52 = EG (uninitialized_zval_ptr);
8853 local_TLE52->refcount++;
8854 }
8855 zval** p_lhs = &local_TLE52;
8856
8857 zval* left;
8858 if (local_dbk == NULL)
8859 left = EG (uninitialized_zval_ptr);
8860 else
8861 left = local_dbk;
8862
8863 zval* right;
8864 if (local_TLE51 == NULL)
8865 right = EG (uninitialized_zval_ptr);
8866 else
8867 right = local_TLE51;
8868
8869 if (in_copy_on_write (*p_lhs))
8870 {
8871 zval_ptr_dtor (p_lhs);
8872 ALLOC_INIT_ZVAL (*p_lhs);
8873 }
8874
8875 zval old = **p_lhs;
8876 int result_is_operand = (*p_lhs == left || *p_lhs == right);
8877 is_identical_function (*p_lhs, left, right TSRMLS_CC);
8878
8879 // If the result is one of the operands, the operator function
8880 // will already have cleaned up the result
8881 if (!result_is_operand)
8882 zval_dtor (&old);
8883 phc_check_invariants (TSRMLS_C);
8884 }
8885 // if (TLE52) goto L158 else goto L159;
8886 {
8887 zval* p_cond;
8888 if (local_TLE52 == NULL)
8889 p_cond = EG (uninitialized_zval_ptr);
8890 else
8891 p_cond = local_TLE52;
8892
8893 zend_bool bcond = zend_is_true (p_cond);
8894 if (bcond)
8895 goto L158;
8896 else
8897 goto L159;
8898 phc_check_invariants (TSRMLS_C);
8899 }
8900 // L158:
8901 L158:;
8902 // $TLE53 = NULL;
8903 {
8904 if (local_TLE53 == NULL)
8905 {
8906 local_TLE53 = EG (uninitialized_zval_ptr);
8907 local_TLE53->refcount++;
8908 }
8909 zval** p_lhs = &local_TLE53;
8910
8911 zval* value;
8912 if ((*p_lhs)->is_ref)
8913 {
8914 // Always overwrite the current value
8915 value = *p_lhs;
8916 zval_dtor (value);
8917 }
8918 else
8919 {
8920 ALLOC_INIT_ZVAL (value);
8921 zval_ptr_dtor (p_lhs);
8922 *p_lhs = value;
8923 }
8924
8925 ZVAL_NULL (value);
8926
8927 phc_check_invariants (TSRMLS_C);
8928 }
8929 // return $TLE53;
8930 {
8931 zval* rhs;
8932 if (local_TLE53 == NULL)
8933 rhs = EG (uninitialized_zval_ptr);
8934 else
8935 rhs = local_TLE53;
8936
8937 // Run-time return by reference has different semantics to compile-time.
8938 // If the function has CTRBR and RTRBR, the the assignment will be
8939 // reference. If one or the other is return-by-copy, the result will be
8940 // by copy. Its a question of whether its separated at return-time (which
8941 // we do here) or at the call-site.
8942 return_value->value = rhs->value;
8943 return_value->type = rhs->type;
8944 zval_copy_ctor (return_value);
8945 goto end_of_function;
8946 phc_check_invariants (TSRMLS_C);
8947 }
8948 // goto L160;
8949 {
8950 goto L160;
8951 phc_check_invariants (TSRMLS_C);
8952 }
8953 // L159:
8954 L159:;
8955 // goto L160;
8956 {
8957 goto L160;
8958 phc_check_invariants (TSRMLS_C);
8959 }
8960 // L160:
8961 L160:;
8962 // goto L163;
8963 {
8964 goto L163;
8965 phc_check_invariants (TSRMLS_C);
8966 }
8967 // L163:
8968 L163:;
8969 // goto L166;
8970 {
8971 goto L166;
8972 phc_check_invariants (TSRMLS_C);
8973 }
8974 // L166:
8975 L166:;
8976 // $TMIt119 = $this->mLinks;
8977 {
8978 if (local_this == NULL)
8979 {
8980 local_this = EG (uninitialized_zval_ptr);
8981 local_this->refcount++;
8982 }
8983 zval** p_obj = &local_this;
8984
8985 zval field_name;
8986 INIT_ZVAL (field_name);
8987 ZVAL_STRING (&field_name, "mLinks", 0);
8988
8989 // I *think* this is correct, but documentation of the Zend API is scarce :)
8990 zval* field = Z_OBJ_HT_PP(p_obj)->read_property(*p_obj, &field_name, BP_VAR_R TSRMLS_CC);
8991 if (local_TMIt119 == NULL)
8992 {
8993 local_TMIt119 = EG (uninitialized_zval_ptr);
8994 local_TMIt119->refcount++;
8995 }
8996 zval** p_lhs = &local_TMIt119;
8997
8998 write_var (p_lhs, field);
8999 phc_check_invariants (TSRMLS_C);
9000 }
9001 // $TLE54 = isset($TMIt119[$ns]);
9002 {
9003 if (local_TLE54 == NULL)
9004 {
9005 local_TLE54 = EG (uninitialized_zval_ptr);
9006 local_TLE54->refcount++;
9007 }
9008 zval** p_lhs = &local_TLE54;
9009 zval* value;
9010 if ((*p_lhs)->is_ref)
9011 {
9012 // Always overwrite the current value
9013 value = *p_lhs;
9014 zval_dtor (value);
9015 }
9016 else
9017 {
9018 ALLOC_INIT_ZVAL (value);
9019 zval_ptr_dtor (p_lhs);
9020 *p_lhs = value;
9021 }
9022 if (local_TMIt119 == NULL)
9023 {
9024 local_TMIt119 = EG (uninitialized_zval_ptr);
9025 local_TMIt119->refcount++;
9026 }
9027 zval** u_array = &local_TMIt119;
9028 zval* u_index;
9029 if (local_ns == NULL)
9030 {
9031 u_index = EG (uninitialized_zval_ptr);
9032 }
9033 else
9034 {
9035 u_index = local_ns;
9036 }
9037 ZVAL_BOOL(value, isset_array (u_array, u_index));
9038 phc_check_invariants (TSRMLS_C);
9039 }
9040 // $TLE55 = !$TLE54;
9041 {
9042 if (local_TLE55 == NULL)
9043 {
9044 local_TLE55 = EG (uninitialized_zval_ptr);
9045 local_TLE55->refcount++;
9046 }
9047 zval** p_lhs = &local_TLE55;
9048
9049 zval* rhs;
9050 if (local_TLE54 == NULL)
9051 rhs = EG (uninitialized_zval_ptr);
9052 else
9053 rhs = local_TLE54;
9054
9055 if (in_copy_on_write (*p_lhs))
9056 {
9057 zval_ptr_dtor (p_lhs);
9058 ALLOC_INIT_ZVAL (*p_lhs);
9059 }
9060
9061 zval old = **p_lhs;
9062 int result_is_operand = (*p_lhs == rhs);
9063 boolean_not_function (*p_lhs, rhs TSRMLS_CC);
9064 if (!result_is_operand)
9065 zval_dtor (&old);
9066 phc_check_invariants (TSRMLS_C);
9067 }
9068 // if (TLE55) goto L167 else goto L168;
9069 {
9070 zval* p_cond;
9071 if (local_TLE55 == NULL)
9072 p_cond = EG (uninitialized_zval_ptr);
9073 else
9074 p_cond = local_TLE55;
9075
9076 zend_bool bcond = zend_is_true (p_cond);
9077 if (bcond)
9078 goto L167;
9079 else
9080 goto L168;
9081 phc_check_invariants (TSRMLS_C);
9082 }
9083 // L167:
9084 L167:;
9085 // $TSt56 =& $this->mLinks;
9086 {
9087 if (local_this == NULL)
9088 {
9089 local_this = EG (uninitialized_zval_ptr);
9090 local_this->refcount++;
9091 }
9092 zval** p_obj = &local_this;
9093
9094 zval field_name;
9095 INIT_ZVAL (field_name);
9096 ZVAL_STRING (&field_name, "mLinks", 0);
9097
9098 zval** field = Z_OBJ_HT_PP(p_obj)->get_property_ptr_ptr(*p_obj, &field_name TSRMLS_CC);
9099 sep_copy_on_write (field);
9100 if (local_TSt56 == NULL)
9101 {
9102 local_TSt56 = EG (uninitialized_zval_ptr);
9103 local_TSt56->refcount++;
9104 }
9105 zval** p_lhs = &local_TSt56;
9106
9107 copy_into_ref (p_lhs, field);
9108 phc_check_invariants (TSRMLS_C);
9109 }
9110 // unset($TSa57);
9111 {
9112 if (local_TSa57 != NULL)
9113 {
9114 zval_ptr_dtor (&local_TSa57);
9115 local_TSa57 = NULL;
9116 }
9117 phc_check_invariants (TSRMLS_C);
9118 }
9119 // $TSa57 = (array) $TSa57;
9120 {
9121 if (local_TSa57 == NULL)
9122 {
9123 local_TSa57 = EG (uninitialized_zval_ptr);
9124 local_TSa57->refcount++;
9125 }
9126 zval** p_lhs = &local_TSa57;
9127
9128 zval* rhs;
9129 if (local_TSa57 == NULL)
9130 rhs = EG (uninitialized_zval_ptr);
9131 else
9132 rhs = local_TSa57;
9133
9134 if (*p_lhs != rhs)
9135 {
9136 if ((*p_lhs)->is_ref)
9137 overwrite_lhs (*p_lhs, rhs);
9138 else
9139 {
9140 zval_ptr_dtor (p_lhs);
9141 if (rhs->is_ref)
9142 {
9143 // Take a copy of RHS for LHS
9144 *p_lhs = zvp_clone_ex (rhs);
9145 }
9146 else
9147 {
9148 // Share a copy
9149 rhs->refcount++;
9150 *p_lhs = rhs;
9151 }
9152
9153 }
9154
9155 }
9156
9157 assert (IS_ARRAY >= 0 && IS_ARRAY <= 6);
9158 if ((*p_lhs)->type != IS_ARRAY)
9159 {
9160 sep_copy_on_write (p_lhs);
9161 convert_to_array (*p_lhs);
9162 }
9163
9164 phc_check_invariants (TSRMLS_C);
9165 }
9166 // $TSt56[$ns] = $TSa57;
9167 {
9168 if (local_TSt56 == NULL)
9169 {
9170 local_TSt56 = EG (uninitialized_zval_ptr);
9171 local_TSt56->refcount++;
9172 }
9173 zval** p_array = &local_TSt56;
9174
9175 check_array_type (p_array TSRMLS_CC);
9176
9177 zval* index;
9178 if (local_ns == NULL)
9179 index = EG (uninitialized_zval_ptr);
9180 else
9181 index = local_ns;
9182
9183
9184 // String indexing
9185 if (Z_TYPE_PP (p_array) == IS_STRING && Z_STRLEN_PP (p_array) > 0)
9186 {
9187 zval* rhs;
9188 if (local_TSa57 == NULL)
9189 rhs = EG (uninitialized_zval_ptr);
9190 else
9191 rhs = local_TSa57;
9192
9193 write_string_index (p_array, index, rhs TSRMLS_CC);
9194 }
9195 else if (Z_TYPE_PP (p_array) == IS_ARRAY)
9196 {
9197 zval** p_lhs = get_ht_entry (p_array, index TSRMLS_CC);
9198 zval* rhs;
9199 if (local_TSa57 == NULL)
9200 rhs = EG (uninitialized_zval_ptr);
9201 else
9202 rhs = local_TSa57;
9203
9204 if (*p_lhs != rhs)
9205 {
9206 write_var (p_lhs, rhs);
9207 }
9208 }
9209 phc_check_invariants (TSRMLS_C);
9210 }
9211 // goto L169;
9212 {
9213 goto L169;
9214 phc_check_invariants (TSRMLS_C);
9215 }
9216 // L168:
9217 L168:;
9218 // goto L169;
9219 {
9220 goto L169;
9221 phc_check_invariants (TSRMLS_C);
9222 }
9223 // L169:
9224 L169:;
9225 // $TLE58 = is_null($id);
9226 {
9227 initialize_function_call (&is_null_fci, &is_null_fcic, "is_null", "/home/mdupont/2009/02/introspector/rdfintrospector/mediawiki/trunk/phase3/includes/parser/ParserOutput.php", 104 TSRMLS_CC);
9228 zend_function* signature = is_null_fcic.function_handler;
9229 zend_arg_info* arg_info = signature->common.arg_info; // optional
9230
9231 int by_ref[1];
9232 int abr_index = 0;
9233 // TODO: find names to replace index
9234 if (arg_info)
9235 {
9236 by_ref[abr_index] = arg_info->pass_by_reference;
9237 arg_info++;
9238 }
9239 else
9240 by_ref[abr_index] = signature->common.pass_rest_by_reference;
9241
9242 abr_index++;
9243
9244
9245 // Setup array of arguments
9246 // TODO: i think arrays of size 0 is an error
9247 int destruct [1];
9248 zval* args [1];
9249 zval** args_ind [1];
9250
9251 int af_index = 0;
9252 destruct[af_index] = 0;
9253 if (by_ref[af_index])
9254 {
9255 if (local_id == NULL)
9256 {
9257 local_id = EG (uninitialized_zval_ptr);
9258 local_id->refcount++;
9259 }
9260 zval** p_arg = &local_id;
9261
9262 args_ind[af_index] = fetch_var_arg_by_ref (p_arg);
9263 assert (!in_copy_on_write (*args_ind[af_index]));
9264 args[af_index] = *args_ind[af_index];
9265 }
9266 else
9267 {
9268 zval* arg;
9269 if (local_id == NULL)
9270 arg = EG (uninitialized_zval_ptr);
9271 else
9272 arg = local_id;
9273
9274 args[af_index] = fetch_var_arg (arg, &destruct[af_index]);
9275 args_ind[af_index] = &args[af_index];
9276 }
9277 af_index++;
9278
9279
9280 phc_setup_error (1, "/home/mdupont/2009/02/introspector/rdfintrospector/mediawiki/trunk/phase3/includes/parser/ParserOutput.php", 104, NULL TSRMLS_CC);
9281
9282 // save existing parameters, in case of recursion
9283 int param_count_save = is_null_fci.param_count;
9284 zval*** params_save = is_null_fci.params;
9285 zval** retval_save = is_null_fci.retval_ptr_ptr;
9286
9287 zval* rhs = NULL;
9288
9289 // set up params
9290 is_null_fci.params = args_ind;
9291 is_null_fci.param_count = 1;
9292 is_null_fci.retval_ptr_ptr = &rhs;
9293
9294 // call the function
9295 int success = zend_call_function (&is_null_fci, &is_null_fcic TSRMLS_CC);
9296 assert(success == SUCCESS);
9297
9298 // restore params
9299 is_null_fci.params = params_save;
9300 is_null_fci.param_count = param_count_save;
9301 is_null_fci.retval_ptr_ptr = retval_save;
9302
9303 // unset the errors
9304 phc_setup_error (0, NULL, 0, NULL TSRMLS_CC);
9305
9306 int i;
9307 for (i = 0; i < 1; i++)
9308 {
9309 if (destruct[i])
9310 {
9311 assert (destruct[i]);
9312 zval_ptr_dtor (args_ind[i]);
9313 }
9314 }
9315
9316
9317 // When the Zend engine returns by reference, it allocates a zval into
9318 // retval_ptr_ptr. To return by reference, the callee writes into the
9319 // retval_ptr_ptr, freeing the allocated value as it does. (Note, it may
9320 // not actually return anything). So the zval returned - whether we return
9321 // it, or it is the allocated zval - has a refcount of 1.
9322
9323 // The caller is responsible for cleaning that up (note, this is unaffected
9324 // by whether it is added to some COW set).
9325
9326 // For reasons unknown, the Zend API resets the refcount and is_ref fields
9327 // of the return value after the function returns (unless the callee is
9328 // interpreted). If the function is supposed to return by reference, this
9329 // loses the refcount. This only happens when non-interpreted code is
9330 // called. We work around it, when compiled code is called, by saving the
9331 // refcount into SAVED_REFCOUNT, in the return statement. The downside is
9332 // that we may create an error if our code is called by a callback, and
9333 // returns by reference, and the callback returns by reference. At least
9334 // this is an obscure case.
9335 if(signature->common.return_reference && signature->type != ZEND_USER_FUNCTION)
9336 {
9337 assert (rhs != EG(uninitialized_zval_ptr));
9338 rhs->is_ref = 1;
9339 if (saved_refcount != 0)
9340 {
9341 rhs->refcount = saved_refcount;
9342 }
9343 rhs->refcount++;
9344 }
9345 saved_refcount = 0; // for 'obscure cases'
9346
9347 if (local_TLE58 == NULL)
9348 {
9349 local_TLE58 = EG (uninitialized_zval_ptr);
9350 local_TLE58->refcount++;
9351 }
9352 zval** p_lhs = &local_TLE58;
9353
9354 write_var (p_lhs, rhs);
9355
9356
9357 zval_ptr_dtor (&rhs);
9358 if(signature->common.return_reference && signature->type != ZEND_USER_FUNCTION)
9359 zval_ptr_dtor (&rhs);
9360
9361 phc_check_invariants (TSRMLS_C);
9362 }
9363 // if (TLE58) goto L170 else goto L171;
9364 {
9365 zval* p_cond;
9366 if (local_TLE58 == NULL)
9367 p_cond = EG (uninitialized_zval_ptr);
9368 else
9369 p_cond = local_TLE58;
9370
9371 zend_bool bcond = zend_is_true (p_cond);
9372 if (bcond)
9373 goto L170;
9374 else
9375 goto L171;
9376 phc_check_invariants (TSRMLS_C);
9377 }
9378 // L170:
9379 L170:;
9380 // $id = $title->getarticleid();
9381 {
9382 if (local_title == NULL)
9383 {
9384 local_title = EG (uninitialized_zval_ptr);
9385 local_title->refcount++;
9386 }
9387 zval** p_obj = &local_title;
9388
9389 zend_fcall_info fci_object;
9390 zend_fcall_info_cache fcic_object = {0, NULL, NULL, NULL};
9391 initialize_method_call (&fci_object, &fcic_object, p_obj, "getarticleid", "/home/mdupont/2009/02/introspector/rdfintrospector/mediawiki/trunk/phase3/includes/parser/ParserOutput.php", 105 TSRMLS_CC);
9392 zend_function* signature = fcic_object.function_handler;
9393 zend_arg_info* arg_info = signature->common.arg_info; // optional
9394
9395 int by_ref[0];
9396 int abr_index = 0;
9397
9398
9399 // Setup array of arguments
9400 // TODO: i think arrays of size 0 is an error
9401 int destruct [0];
9402 zval* args [0];
9403 zval** args_ind [0];
9404
9405 int af_index = 0;
9406
9407
9408 phc_setup_error (1, "/home/mdupont/2009/02/introspector/rdfintrospector/mediawiki/trunk/phase3/includes/parser/ParserOutput.php", 105, NULL TSRMLS_CC);
9409
9410 // save existing parameters, in case of recursion
9411 int param_count_save = fci_object.param_count;
9412 zval*** params_save = fci_object.params;
9413 zval** retval_save = fci_object.retval_ptr_ptr;
9414
9415 zval* rhs = NULL;
9416
9417 // set up params
9418 fci_object.params = args_ind;
9419 fci_object.param_count = 0;
9420 fci_object.retval_ptr_ptr = &rhs;
9421
9422 // call the function
9423 int success = zend_call_function (&fci_object, &fcic_object TSRMLS_CC);
9424 assert(success == SUCCESS);
9425
9426 // restore params
9427 fci_object.params = params_save;
9428 fci_object.param_count = param_count_save;
9429 fci_object.retval_ptr_ptr = retval_save;
9430
9431 // unset the errors
9432 phc_setup_error (0, NULL, 0, NULL TSRMLS_CC);
9433
9434 int i;
9435 for (i = 0; i < 0; i++)
9436 {
9437 if (destruct[i])
9438 {
9439 assert (destruct[i]);
9440 zval_ptr_dtor (args_ind[i]);
9441 }
9442 }
9443
9444
9445 // When the Zend engine returns by reference, it allocates a zval into
9446 // retval_ptr_ptr. To return by reference, the callee writes into the
9447 // retval_ptr_ptr, freeing the allocated value as it does. (Note, it may
9448 // not actually return anything). So the zval returned - whether we return
9449 // it, or it is the allocated zval - has a refcount of 1.
9450
9451 // The caller is responsible for cleaning that up (note, this is unaffected
9452 // by whether it is added to some COW set).
9453
9454 // For reasons unknown, the Zend API resets the refcount and is_ref fields
9455 // of the return value after the function returns (unless the callee is
9456 // interpreted). If the function is supposed to return by reference, this
9457 // loses the refcount. This only happens when non-interpreted code is
9458 // called. We work around it, when compiled code is called, by saving the
9459 // refcount into SAVED_REFCOUNT, in the return statement. The downside is
9460 // that we may create an error if our code is called by a callback, and
9461 // returns by reference, and the callback returns by reference. At least
9462 // this is an obscure case.
9463 if(signature->common.return_reference && signature->type != ZEND_USER_FUNCTION)
9464 {
9465 assert (rhs != EG(uninitialized_zval_ptr));
9466 rhs->is_ref = 1;
9467 if (saved_refcount != 0)
9468 {
9469 rhs->refcount = saved_refcount;
9470 }
9471 rhs->refcount++;
9472 }
9473 saved_refcount = 0; // for 'obscure cases'
9474
9475 if (local_id == NULL)
9476 {
9477 local_id = EG (uninitialized_zval_ptr);
9478 local_id->refcount++;
9479 }
9480 zval** p_lhs = &local_id;
9481
9482 write_var (p_lhs, rhs);
9483
9484
9485 zval_ptr_dtor (&rhs);
9486 if(signature->common.return_reference && signature->type != ZEND_USER_FUNCTION)
9487 zval_ptr_dtor (&rhs);
9488
9489 phc_check_invariants (TSRMLS_C);
9490 }
9491 // goto L172;
9492 {
9493 goto L172;
9494 phc_check_invariants (TSRMLS_C);
9495 }
9496 // L171:
9497 L171:;
9498 // goto L172;
9499 {
9500 goto L172;
9501 phc_check_invariants (TSRMLS_C);
9502 }
9503 // L172:
9504 L172:;
9505 // $TSt59 =& $this->mLinks;
9506 {
9507 if (local_this == NULL)
9508 {
9509 local_this = EG (uninitialized_zval_ptr);
9510 local_this->refcount++;
9511 }
9512 zval** p_obj = &local_this;
9513
9514 zval field_name;
9515 INIT_ZVAL (field_name);
9516 ZVAL_STRING (&field_name, "mLinks", 0);
9517
9518 zval** field = Z_OBJ_HT_PP(p_obj)->get_property_ptr_ptr(*p_obj, &field_name TSRMLS_CC);
9519 sep_copy_on_write (field);
9520 if (local_TSt59 == NULL)
9521 {
9522 local_TSt59 = EG (uninitialized_zval_ptr);
9523 local_TSt59->refcount++;
9524 }
9525 zval** p_lhs = &local_TSt59;
9526
9527 copy_into_ref (p_lhs, field);
9528 phc_check_invariants (TSRMLS_C);
9529 }
9530 // $TSi60 =& $TSt59[$ns];
9531 {
9532 if (local_TSi60 == NULL)
9533 {
9534 local_TSi60 = EG (uninitialized_zval_ptr);
9535 local_TSi60->refcount++;
9536 }
9537 zval** p_lhs = &local_TSi60;
9538
9539 if (local_TSt59 == NULL)
9540 {
9541 local_TSt59 = EG (uninitialized_zval_ptr);
9542 local_TSt59->refcount++;
9543 }
9544 zval** p_r_array = &local_TSt59;
9545
9546 zval* r_index;
9547 if (local_ns == NULL)
9548 r_index = EG (uninitialized_zval_ptr);
9549 else
9550 r_index = local_ns;
9551
9552 check_array_type (p_r_array TSRMLS_CC);
9553 zval** p_rhs = get_ht_entry (p_r_array, r_index TSRMLS_CC);
9554 sep_copy_on_write (p_rhs);
9555 copy_into_ref (p_lhs, p_rhs);
9556 phc_check_invariants (TSRMLS_C);
9557 }
9558 // $TSi60[$dbk] = $id;
9559 {
9560 if (local_TSi60 == NULL)
9561 {
9562 local_TSi60 = EG (uninitialized_zval_ptr);
9563 local_TSi60->refcount++;
9564 }
9565 zval** p_array = &local_TSi60;
9566
9567 check_array_type (p_array TSRMLS_CC);
9568
9569 zval* index;
9570 if (local_dbk == NULL)
9571 index = EG (uninitialized_zval_ptr);
9572 else
9573 index = local_dbk;
9574
9575
9576 // String indexing
9577 if (Z_TYPE_PP (p_array) == IS_STRING && Z_STRLEN_PP (p_array) > 0)
9578 {
9579 zval* rhs;
9580 if (local_id == NULL)
9581 rhs = EG (uninitialized_zval_ptr);
9582 else
9583 rhs = local_id;
9584
9585 write_string_index (p_array, index, rhs TSRMLS_CC);
9586 }
9587 else if (Z_TYPE_PP (p_array) == IS_ARRAY)
9588 {
9589 zval** p_lhs = get_ht_entry (p_array, index TSRMLS_CC);
9590 zval* rhs;
9591 if (local_id == NULL)
9592 rhs = EG (uninitialized_zval_ptr);
9593 else
9594 rhs = local_id;
9595
9596 if (*p_lhs != rhs)
9597 {
9598 write_var (p_lhs, rhs);
9599 }
9600 }
9601 phc_check_invariants (TSRMLS_C);
9602 }
9603 // Method exit
9604 end_of_function:__attribute__((unused));
9605 if (local_TLE46 != NULL)
9606 {
9607 zval_ptr_dtor (&local_TLE46);
9608 }
9609 if (local_TLE47 != NULL)
9610 {
9611 zval_ptr_dtor (&local_TLE47);
9612 }
9613 if (local_TLE48 != NULL)
9614 {
9615 zval_ptr_dtor (&local_TLE48);
9616 }
9617 if (local_TLE49 != NULL)
9618 {
9619 zval_ptr_dtor (&local_TLE49);
9620 }
9621 if (local_TLE50 != NULL)
9622 {
9623 zval_ptr_dtor (&local_TLE50);
9624 }
9625 if (local_TLE51 != NULL)
9626 {
9627 zval_ptr_dtor (&local_TLE51);
9628 }
9629 if (local_TLE52 != NULL)
9630 {
9631 zval_ptr_dtor (&local_TLE52);
9632 }
9633 if (local_TLE53 != NULL)
9634 {
9635 zval_ptr_dtor (&local_TLE53);
9636 }
9637 if (local_TLE54 != NULL)
9638 {
9639 zval_ptr_dtor (&local_TLE54);
9640 }
9641 if (local_TLE55 != NULL)
9642 {
9643 zval_ptr_dtor (&local_TLE55);
9644 }
9645 if (local_TLE58 != NULL)
9646 {
9647 zval_ptr_dtor (&local_TLE58);
9648 }
9649 if (local_TMIt119 != NULL)
9650 {
9651 zval_ptr_dtor (&local_TMIt119);
9652 }
9653 if (local_TSa57 != NULL)
9654 {
9655 zval_ptr_dtor (&local_TSa57);
9656 }
9657 if (local_TSi60 != NULL)
9658 {
9659 zval_ptr_dtor (&local_TSi60);
9660 }
9661 if (local_TSt56 != NULL)
9662 {
9663 zval_ptr_dtor (&local_TSt56);
9664 }
9665 if (local_TSt59 != NULL)
9666 {
9667 zval_ptr_dtor (&local_TSt59);
9668 }
9669 if (local_dbk != NULL)
9670 {
9671 zval_ptr_dtor (&local_dbk);
9672 }
9673 if (local_id != NULL)
9674 {
9675 zval_ptr_dtor (&local_id);
9676 }
9677 if (local_ns != NULL)
9678 {
9679 zval_ptr_dtor (&local_ns);
9680 }
9681 if (local_title != NULL)
9682 {
9683 zval_ptr_dtor (&local_title);
9684 }
9685 }
9686 // function addimage($name)
9687 // {
9688 // $TSt61 =& $this->mImages;
9689 // $TLE62 = 1;
9690 // $TSt61[$name] = $TLE62;
9691 // }
9692 PHP_METHOD(ParserOutput, addimage)
9693 {
9694 zval* local_TLE62 = NULL;
9695 zval* local_TSt61 = NULL;
9696 zval* local_name = NULL;
9697 zval* local_this = getThis();
9698 // Add all parameters as local variables
9699 {
9700 int num_args = ZEND_NUM_ARGS ();
9701 zval* params[1];
9702 zend_get_parameters_array(0, num_args, params);
9703 // param 0
9704 params[0]->refcount++;
9705 if (local_name != NULL)
9706 {
9707 zval_ptr_dtor (&local_name);
9708 }
9709 local_name = params[0];
9710 }
9711 // Function body
9712 // $TSt61 =& $this->mImages;
9713 {
9714 if (local_this == NULL)
9715 {
9716 local_this = EG (uninitialized_zval_ptr);
9717 local_this->refcount++;
9718 }
9719 zval** p_obj = &local_this;
9720
9721 zval field_name;
9722 INIT_ZVAL (field_name);
9723 ZVAL_STRING (&field_name, "mImages", 0);
9724
9725 zval** field = Z_OBJ_HT_PP(p_obj)->get_property_ptr_ptr(*p_obj, &field_name TSRMLS_CC);
9726 sep_copy_on_write (field);
9727 if (local_TSt61 == NULL)
9728 {
9729 local_TSt61 = EG (uninitialized_zval_ptr);
9730 local_TSt61->refcount++;
9731 }
9732 zval** p_lhs = &local_TSt61;
9733
9734 copy_into_ref (p_lhs, field);
9735 phc_check_invariants (TSRMLS_C);
9736 }
9737 // $TLE62 = 1;
9738 {
9739 if (local_TLE62 == NULL)
9740 {
9741 local_TLE62 = EG (uninitialized_zval_ptr);
9742 local_TLE62->refcount++;
9743 }
9744 zval** p_lhs = &local_TLE62;
9745
9746 zval* value;
9747 if ((*p_lhs)->is_ref)
9748 {
9749 // Always overwrite the current value
9750 value = *p_lhs;
9751 zval_dtor (value);
9752 }
9753 else
9754 {
9755 ALLOC_INIT_ZVAL (value);
9756 zval_ptr_dtor (p_lhs);
9757 *p_lhs = value;
9758 }
9759
9760 ZVAL_LONG (value, 1);
9761
9762 phc_check_invariants (TSRMLS_C);
9763 }
9764 // $TSt61[$name] = $TLE62;
9765 {
9766 if (local_TSt61 == NULL)
9767 {
9768 local_TSt61 = EG (uninitialized_zval_ptr);
9769 local_TSt61->refcount++;
9770 }
9771 zval** p_array = &local_TSt61;
9772
9773 check_array_type (p_array TSRMLS_CC);
9774
9775 zval* index;
9776 if (local_name == NULL)
9777 index = EG (uninitialized_zval_ptr);
9778 else
9779 index = local_name;
9780
9781
9782 // String indexing
9783 if (Z_TYPE_PP (p_array) == IS_STRING && Z_STRLEN_PP (p_array) > 0)
9784 {
9785 zval* rhs;
9786 if (local_TLE62 == NULL)
9787 rhs = EG (uninitialized_zval_ptr);
9788 else
9789 rhs = local_TLE62;
9790
9791 write_string_index (p_array, index, rhs TSRMLS_CC);
9792 }
9793 else if (Z_TYPE_PP (p_array) == IS_ARRAY)
9794 {
9795 zval** p_lhs = get_ht_entry (p_array, index TSRMLS_CC);
9796 zval* rhs;
9797 if (local_TLE62 == NULL)
9798 rhs = EG (uninitialized_zval_ptr);
9799 else
9800 rhs = local_TLE62;
9801
9802 if (*p_lhs != rhs)
9803 {
9804 write_var (p_lhs, rhs);
9805 }
9806 }
9807 phc_check_invariants (TSRMLS_C);
9808 }
9809 // Method exit
9810 end_of_function:__attribute__((unused));
9811 if (local_TLE62 != NULL)
9812 {
9813 zval_ptr_dtor (&local_TLE62);
9814 }
9815 if (local_TSt61 != NULL)
9816 {
9817 zval_ptr_dtor (&local_TSt61);
9818 }
9819 if (local_name != NULL)
9820 {
9821 zval_ptr_dtor (&local_name);
9822 }
9823 }
9824 // function addtemplate($title, $page_id, $rev_id)
9825 // {
9826 // $ns = $title->getnamespace();
9827 // $dbk = $title->getdbkey();
9828 // $TMIt120 = $this->mTemplates;
9829 // $TLE63 = isset($TMIt120[$ns]);
9830 // $TLE64 = !$TLE63;
9831 // if (TLE64) goto L173 else goto L174;
9832 // L173:
9833 // $TSt65 =& $this->mTemplates;
9834 // unset($TSa66);
9835 // $TSa66 = (array) $TSa66;
9836 // $TSt65[$ns] = $TSa66;
9837 // goto L175;
9838 // L174:
9839 // goto L175;
9840 // L175:
9841 // $TSt67 =& $this->mTemplates;
9842 // $TSi68 =& $TSt67[$ns];
9843 // $TSi68[$dbk] = $page_id;
9844 // $TMIt121 = $this->mTemplateIds;
9845 // $TLE69 = isset($TMIt121[$ns]);
9846 // $TLE70 = !$TLE69;
9847 // if (TLE70) goto L176 else goto L177;
9848 // L176:
9849 // $TSt71 =& $this->mTemplateIds;
9850 // unset($TSa72);
9851 // $TSa72 = (array) $TSa72;
9852 // $TSt71[$ns] = $TSa72;
9853 // goto L178;
9854 // L177:
9855 // goto L178;
9856 // L178:
9857 // $TSt73 =& $this->mTemplateIds;
9858 // $TSi74 =& $TSt73[$ns];
9859 // $TSi74[$dbk] = $rev_id;
9860 // }
9861 PHP_METHOD(ParserOutput, addtemplate)
9862 {
9863 zval* local_TLE63 = NULL;
9864 zval* local_TLE64 = NULL;
9865 zval* local_TLE69 = NULL;
9866 zval* local_TLE70 = NULL;
9867 zval* local_TMIt120 = NULL;
9868 zval* local_TMIt121 = NULL;
9869 zval* local_TSa66 = NULL;
9870 zval* local_TSa72 = NULL;
9871 zval* local_TSi68 = NULL;
9872 zval* local_TSi74 = NULL;
9873 zval* local_TSt65 = NULL;
9874 zval* local_TSt67 = NULL;
9875 zval* local_TSt71 = NULL;
9876 zval* local_TSt73 = NULL;
9877 zval* local_dbk = NULL;
9878 zval* local_ns = NULL;
9879 zval* local_page_id = NULL;
9880 zval* local_rev_id = NULL;
9881 zval* local_this = getThis();
9882 zval* local_title = NULL;
9883 // Add all parameters as local variables
9884 {
9885 int num_args = ZEND_NUM_ARGS ();
9886 zval* params[3];
9887 zend_get_parameters_array(0, num_args, params);
9888 // param 0
9889 params[0]->refcount++;
9890 if (local_title != NULL)
9891 {
9892 zval_ptr_dtor (&local_title);
9893 }
9894 local_title = params[0];
9895 // param 1
9896 params[1]->refcount++;
9897 if (local_page_id != NULL)
9898 {
9899 zval_ptr_dtor (&local_page_id);
9900 }
9901 local_page_id = params[1];
9902 // param 2
9903 params[2]->refcount++;
9904 if (local_rev_id != NULL)
9905 {
9906 zval_ptr_dtor (&local_rev_id);
9907 }
9908 local_rev_id = params[2];
9909 }
9910 // Function body
9911 // $ns = $title->getnamespace();
9912 {
9913 if (local_title == NULL)
9914 {
9915 local_title = EG (uninitialized_zval_ptr);
9916 local_title->refcount++;
9917 }
9918 zval** p_obj = &local_title;
9919
9920 zend_fcall_info fci_object;
9921 zend_fcall_info_cache fcic_object = {0, NULL, NULL, NULL};
9922 initialize_method_call (&fci_object, &fcic_object, p_obj, "getnamespace", "/home/mdupont/2009/02/introspector/rdfintrospector/mediawiki/trunk/phase3/includes/parser/ParserOutput.php", 115 TSRMLS_CC);
9923 zend_function* signature = fcic_object.function_handler;
9924 zend_arg_info* arg_info = signature->common.arg_info; // optional
9925
9926 int by_ref[0];
9927 int abr_index = 0;
9928
9929
9930 // Setup array of arguments
9931 // TODO: i think arrays of size 0 is an error
9932 int destruct [0];
9933 zval* args [0];
9934 zval** args_ind [0];
9935
9936 int af_index = 0;
9937
9938
9939 phc_setup_error (1, "/home/mdupont/2009/02/introspector/rdfintrospector/mediawiki/trunk/phase3/includes/parser/ParserOutput.php", 115, NULL TSRMLS_CC);
9940
9941 // save existing parameters, in case of recursion
9942 int param_count_save = fci_object.param_count;
9943 zval*** params_save = fci_object.params;
9944 zval** retval_save = fci_object.retval_ptr_ptr;
9945
9946 zval* rhs = NULL;
9947
9948 // set up params
9949 fci_object.params = args_ind;
9950 fci_object.param_count = 0;
9951 fci_object.retval_ptr_ptr = &rhs;
9952
9953 // call the function
9954 int success = zend_call_function (&fci_object, &fcic_object TSRMLS_CC);
9955 assert(success == SUCCESS);
9956
9957 // restore params
9958 fci_object.params = params_save;
9959 fci_object.param_count = param_count_save;
9960 fci_object.retval_ptr_ptr = retval_save;
9961
9962 // unset the errors
9963 phc_setup_error (0, NULL, 0, NULL TSRMLS_CC);
9964
9965 int i;
9966 for (i = 0; i < 0; i++)
9967 {
9968 if (destruct[i])
9969 {
9970 assert (destruct[i]);
9971 zval_ptr_dtor (args_ind[i]);
9972 }
9973 }
9974
9975
9976 // When the Zend engine returns by reference, it allocates a zval into
9977 // retval_ptr_ptr. To return by reference, the callee writes into the
9978 // retval_ptr_ptr, freeing the allocated value as it does. (Note, it may
9979 // not actually return anything). So the zval returned - whether we return
9980 // it, or it is the allocated zval - has a refcount of 1.
9981
9982 // The caller is responsible for cleaning that up (note, this is unaffected
9983 // by whether it is added to some COW set).
9984
9985 // For reasons unknown, the Zend API resets the refcount and is_ref fields
9986 // of the return value after the function returns (unless the callee is
9987 // interpreted). If the function is supposed to return by reference, this
9988 // loses the refcount. This only happens when non-interpreted code is
9989 // called. We work around it, when compiled code is called, by saving the
9990 // refcount into SAVED_REFCOUNT, in the return statement. The downside is
9991 // that we may create an error if our code is called by a callback, and
9992 // returns by reference, and the callback returns by reference. At least
9993 // this is an obscure case.
9994 if(signature->common.return_reference && signature->type != ZEND_USER_FUNCTION)
9995 {
9996 assert (rhs != EG(uninitialized_zval_ptr));
9997 rhs->is_ref = 1;
9998 if (saved_refcount != 0)
9999 {
10000 rhs->refcount = saved_refcount;
10001 }
10002 rhs->refcount++;
10003 }
10004 saved_refcount = 0; // for 'obscure cases'
10005
10006 if (local_ns == NULL)
10007 {
10008 local_ns = EG (uninitialized_zval_ptr);
10009 local_ns->refcount++;
10010 }
10011 zval** p_lhs = &local_ns;
10012
10013 write_var (p_lhs, rhs);
10014
10015
10016 zval_ptr_dtor (&rhs);
10017 if(signature->common.return_reference && signature->type != ZEND_USER_FUNCTION)
10018 zval_ptr_dtor (&rhs);
10019
10020 phc_check_invariants (TSRMLS_C);
10021 }
10022 // $dbk = $title->getdbkey();
10023 {
10024 if (local_title == NULL)
10025 {
10026 local_title = EG (uninitialized_zval_ptr);
10027 local_title->refcount++;
10028 }
10029 zval** p_obj = &local_title;
10030
10031 zend_fcall_info fci_object;
10032 zend_fcall_info_cache fcic_object = {0, NULL, NULL, NULL};
10033 initialize_method_call (&fci_object, &fcic_object, p_obj, "getdbkey", "/home/mdupont/2009/02/introspector/rdfintrospector/mediawiki/trunk/phase3/includes/parser/ParserOutput.php", 116 TSRMLS_CC);
10034 zend_function* signature = fcic_object.function_handler;
10035 zend_arg_info* arg_info = signature->common.arg_info; // optional
10036
10037 int by_ref[0];
10038 int abr_index = 0;
10039
10040
10041 // Setup array of arguments
10042 // TODO: i think arrays of size 0 is an error
10043 int destruct [0];
10044 zval* args [0];
10045 zval** args_ind [0];
10046
10047 int af_index = 0;
10048
10049
10050 phc_setup_error (1, "/home/mdupont/2009/02/introspector/rdfintrospector/mediawiki/trunk/phase3/includes/parser/ParserOutput.php", 116, NULL TSRMLS_CC);
10051
10052 // save existing parameters, in case of recursion
10053 int param_count_save = fci_object.param_count;
10054 zval*** params_save = fci_object.params;
10055 zval** retval_save = fci_object.retval_ptr_ptr;
10056
10057 zval* rhs = NULL;
10058
10059 // set up params
10060 fci_object.params = args_ind;
10061 fci_object.param_count = 0;
10062 fci_object.retval_ptr_ptr = &rhs;
10063
10064 // call the function
10065 int success = zend_call_function (&fci_object, &fcic_object TSRMLS_CC);
10066 assert(success == SUCCESS);
10067
10068 // restore params
10069 fci_object.params = params_save;
10070 fci_object.param_count = param_count_save;
10071 fci_object.retval_ptr_ptr = retval_save;
10072
10073 // unset the errors
10074 phc_setup_error (0, NULL, 0, NULL TSRMLS_CC);
10075
10076 int i;
10077 for (i = 0; i < 0; i++)
10078 {
10079 if (destruct[i])
10080 {
10081 assert (destruct[i]);
10082 zval_ptr_dtor (args_ind[i]);
10083 }
10084 }
10085
10086
10087 // When the Zend engine returns by reference, it allocates a zval into
10088 // retval_ptr_ptr. To return by reference, the callee writes into the
10089 // retval_ptr_ptr, freeing the allocated value as it does. (Note, it may
10090 // not actually return anything). So the zval returned - whether we return
10091 // it, or it is the allocated zval - has a refcount of 1.
10092
10093 // The caller is responsible for cleaning that up (note, this is unaffected
10094 // by whether it is added to some COW set).
10095
10096 // For reasons unknown, the Zend API resets the refcount and is_ref fields
10097 // of the return value after the function returns (unless the callee is
10098 // interpreted). If the function is supposed to return by reference, this
10099 // loses the refcount. This only happens when non-interpreted code is
10100 // called. We work around it, when compiled code is called, by saving the
10101 // refcount into SAVED_REFCOUNT, in the return statement. The downside is
10102 // that we may create an error if our code is called by a callback, and
10103 // returns by reference, and the callback returns by reference. At least
10104 // this is an obscure case.
10105 if(signature->common.return_reference && signature->type != ZEND_USER_FUNCTION)
10106 {
10107 assert (rhs != EG(uninitialized_zval_ptr));
10108 rhs->is_ref = 1;
10109 if (saved_refcount != 0)
10110 {
10111 rhs->refcount = saved_refcount;
10112 }
10113 rhs->refcount++;
10114 }
10115 saved_refcount = 0; // for 'obscure cases'
10116
10117 if (local_dbk == NULL)
10118 {
10119 local_dbk = EG (uninitialized_zval_ptr);
10120 local_dbk->refcount++;
10121 }
10122 zval** p_lhs = &local_dbk;
10123
10124 write_var (p_lhs, rhs);
10125
10126
10127 zval_ptr_dtor (&rhs);
10128 if(signature->common.return_reference && signature->type != ZEND_USER_FUNCTION)
10129 zval_ptr_dtor (&rhs);
10130
10131 phc_check_invariants (TSRMLS_C);
10132 }
10133 // $TMIt120 = $this->mTemplates;
10134 {
10135 if (local_this == NULL)
10136 {
10137 local_this = EG (uninitialized_zval_ptr);
10138 local_this->refcount++;
10139 }
10140 zval** p_obj = &local_this;
10141
10142 zval field_name;
10143 INIT_ZVAL (field_name);
10144 ZVAL_STRING (&field_name, "mTemplates", 0);
10145
10146 // I *think* this is correct, but documentation of the Zend API is scarce :)
10147 zval* field = Z_OBJ_HT_PP(p_obj)->read_property(*p_obj, &field_name, BP_VAR_R TSRMLS_CC);
10148 if (local_TMIt120 == NULL)
10149 {
10150 local_TMIt120 = EG (uninitialized_zval_ptr);
10151 local_TMIt120->refcount++;
10152 }
10153 zval** p_lhs = &local_TMIt120;
10154
10155 write_var (p_lhs, field);
10156 phc_check_invariants (TSRMLS_C);
10157 }
10158 // $TLE63 = isset($TMIt120[$ns]);
10159 {
10160 if (local_TLE63 == NULL)
10161 {
10162 local_TLE63 = EG (uninitialized_zval_ptr);
10163 local_TLE63->refcount++;
10164 }
10165 zval** p_lhs = &local_TLE63;
10166 zval* value;
10167 if ((*p_lhs)->is_ref)
10168 {
10169 // Always overwrite the current value
10170 value = *p_lhs;
10171 zval_dtor (value);
10172 }
10173 else
10174 {
10175 ALLOC_INIT_ZVAL (value);
10176 zval_ptr_dtor (p_lhs);
10177 *p_lhs = value;
10178 }
10179 if (local_TMIt120 == NULL)
10180 {
10181 local_TMIt120 = EG (uninitialized_zval_ptr);
10182 local_TMIt120->refcount++;
10183 }
10184 zval** u_array = &local_TMIt120;
10185 zval* u_index;
10186 if (local_ns == NULL)
10187 {
10188 u_index = EG (uninitialized_zval_ptr);
10189 }
10190 else
10191 {
10192 u_index = local_ns;
10193 }
10194 ZVAL_BOOL(value, isset_array (u_array, u_index));
10195 phc_check_invariants (TSRMLS_C);
10196 }
10197 // $TLE64 = !$TLE63;
10198 {
10199 if (local_TLE64 == NULL)
10200 {
10201 local_TLE64 = EG (uninitialized_zval_ptr);
10202 local_TLE64->refcount++;
10203 }
10204 zval** p_lhs = &local_TLE64;
10205
10206 zval* rhs;
10207 if (local_TLE63 == NULL)
10208 rhs = EG (uninitialized_zval_ptr);
10209 else
10210 rhs = local_TLE63;
10211
10212 if (in_copy_on_write (*p_lhs))
10213 {
10214 zval_ptr_dtor (p_lhs);
10215 ALLOC_INIT_ZVAL (*p_lhs);
10216 }
10217
10218 zval old = **p_lhs;
10219 int result_is_operand = (*p_lhs == rhs);
10220 boolean_not_function (*p_lhs, rhs TSRMLS_CC);
10221 if (!result_is_operand)
10222 zval_dtor (&old);
10223 phc_check_invariants (TSRMLS_C);
10224 }
10225 // if (TLE64) goto L173 else goto L174;
10226 {
10227 zval* p_cond;
10228 if (local_TLE64 == NULL)
10229 p_cond = EG (uninitialized_zval_ptr);
10230 else
10231 p_cond = local_TLE64;
10232
10233 zend_bool bcond = zend_is_true (p_cond);
10234 if (bcond)
10235 goto L173;
10236 else
10237 goto L174;
10238 phc_check_invariants (TSRMLS_C);
10239 }
10240 // L173:
10241 L173:;
10242 // $TSt65 =& $this->mTemplates;
10243 {
10244 if (local_this == NULL)
10245 {
10246 local_this = EG (uninitialized_zval_ptr);
10247 local_this->refcount++;
10248 }
10249 zval** p_obj = &local_this;
10250
10251 zval field_name;
10252 INIT_ZVAL (field_name);
10253 ZVAL_STRING (&field_name, "mTemplates", 0);
10254
10255 zval** field = Z_OBJ_HT_PP(p_obj)->get_property_ptr_ptr(*p_obj, &field_name TSRMLS_CC);
10256 sep_copy_on_write (field);
10257 if (local_TSt65 == NULL)
10258 {
10259 local_TSt65 = EG (uninitialized_zval_ptr);
10260 local_TSt65->refcount++;
10261 }
10262 zval** p_lhs = &local_TSt65;
10263
10264 copy_into_ref (p_lhs, field);
10265 phc_check_invariants (TSRMLS_C);
10266 }
10267 // unset($TSa66);
10268 {
10269 if (local_TSa66 != NULL)
10270 {
10271 zval_ptr_dtor (&local_TSa66);
10272 local_TSa66 = NULL;
10273 }
10274 phc_check_invariants (TSRMLS_C);
10275 }
10276 // $TSa66 = (array) $TSa66;
10277 {
10278 if (local_TSa66 == NULL)
10279 {
10280 local_TSa66 = EG (uninitialized_zval_ptr);
10281 local_TSa66->refcount++;
10282 }
10283 zval** p_lhs = &local_TSa66;
10284
10285 zval* rhs;
10286 if (local_TSa66 == NULL)
10287 rhs = EG (uninitialized_zval_ptr);
10288 else
10289 rhs = local_TSa66;
10290
10291 if (*p_lhs != rhs)
10292 {
10293 if ((*p_lhs)->is_ref)
10294 overwrite_lhs (*p_lhs, rhs);
10295 else
10296 {
10297 zval_ptr_dtor (p_lhs);
10298 if (rhs->is_ref)
10299 {
10300 // Take a copy of RHS for LHS
10301 *p_lhs = zvp_clone_ex (rhs);
10302 }
10303 else
10304 {
10305 // Share a copy
10306 rhs->refcount++;
10307 *p_lhs = rhs;
10308 }
10309
10310 }
10311
10312 }
10313
10314 assert (IS_ARRAY >= 0 && IS_ARRAY <= 6);
10315 if ((*p_lhs)->type != IS_ARRAY)
10316 {
10317 sep_copy_on_write (p_lhs);
10318 convert_to_array (*p_lhs);
10319 }
10320
10321 phc_check_invariants (TSRMLS_C);
10322 }
10323 // $TSt65[$ns] = $TSa66;
10324 {
10325 if (local_TSt65 == NULL)
10326 {
10327 local_TSt65 = EG (uninitialized_zval_ptr);
10328 local_TSt65->refcount++;
10329 }
10330 zval** p_array = &local_TSt65;
10331
10332 check_array_type (p_array TSRMLS_CC);
10333
10334 zval* index;
10335 if (local_ns == NULL)
10336 index = EG (uninitialized_zval_ptr);
10337 else
10338 index = local_ns;
10339
10340
10341 // String indexing
10342 if (Z_TYPE_PP (p_array) == IS_STRING && Z_STRLEN_PP (p_array) > 0)
10343 {
10344 zval* rhs;
10345 if (local_TSa66 == NULL)
10346 rhs = EG (uninitialized_zval_ptr);
10347 else
10348 rhs = local_TSa66;
10349
10350 write_string_index (p_array, index, rhs TSRMLS_CC);
10351 }
10352 else if (Z_TYPE_PP (p_array) == IS_ARRAY)
10353 {
10354 zval** p_lhs = get_ht_entry (p_array, index TSRMLS_CC);
10355 zval* rhs;
10356 if (local_TSa66 == NULL)
10357 rhs = EG (uninitialized_zval_ptr);
10358 else
10359 rhs = local_TSa66;
10360
10361 if (*p_lhs != rhs)
10362 {
10363 write_var (p_lhs, rhs);
10364 }
10365 }
10366 phc_check_invariants (TSRMLS_C);
10367 }
10368 // goto L175;
10369 {
10370 goto L175;
10371 phc_check_invariants (TSRMLS_C);
10372 }
10373 // L174:
10374 L174:;
10375 // goto L175;
10376 {
10377 goto L175;
10378 phc_check_invariants (TSRMLS_C);
10379 }
10380 // L175:
10381 L175:;
10382 // $TSt67 =& $this->mTemplates;
10383 {
10384 if (local_this == NULL)
10385 {
10386 local_this = EG (uninitialized_zval_ptr);
10387 local_this->refcount++;
10388 }
10389 zval** p_obj = &local_this;
10390
10391 zval field_name;
10392 INIT_ZVAL (field_name);
10393 ZVAL_STRING (&field_name, "mTemplates", 0);
10394
10395 zval** field = Z_OBJ_HT_PP(p_obj)->get_property_ptr_ptr(*p_obj, &field_name TSRMLS_CC);
10396 sep_copy_on_write (field);
10397 if (local_TSt67 == NULL)
10398 {
10399 local_TSt67 = EG (uninitialized_zval_ptr);
10400 local_TSt67->refcount++;
10401 }
10402 zval** p_lhs = &local_TSt67;
10403
10404 copy_into_ref (p_lhs, field);
10405 phc_check_invariants (TSRMLS_C);
10406 }
10407 // $TSi68 =& $TSt67[$ns];
10408 {
10409 if (local_TSi68 == NULL)
10410 {
10411 local_TSi68 = EG (uninitialized_zval_ptr);
10412 local_TSi68->refcount++;
10413 }
10414 zval** p_lhs = &local_TSi68;
10415
10416 if (local_TSt67 == NULL)
10417 {
10418 local_TSt67 = EG (uninitialized_zval_ptr);
10419 local_TSt67->refcount++;
10420 }
10421 zval** p_r_array = &local_TSt67;
10422
10423 zval* r_index;
10424 if (local_ns == NULL)
10425 r_index = EG (uninitialized_zval_ptr);
10426 else
10427 r_index = local_ns;
10428
10429 check_array_type (p_r_array TSRMLS_CC);
10430 zval** p_rhs = get_ht_entry (p_r_array, r_index TSRMLS_CC);
10431 sep_copy_on_write (p_rhs);
10432 copy_into_ref (p_lhs, p_rhs);
10433 phc_check_invariants (TSRMLS_C);
10434 }
10435 // $TSi68[$dbk] = $page_id;
10436 {
10437 if (local_TSi68 == NULL)
10438 {
10439 local_TSi68 = EG (uninitialized_zval_ptr);
10440 local_TSi68->refcount++;
10441 }
10442 zval** p_array = &local_TSi68;
10443
10444 check_array_type (p_array TSRMLS_CC);
10445
10446 zval* index;
10447 if (local_dbk == NULL)
10448 index = EG (uninitialized_zval_ptr);
10449 else
10450 index = local_dbk;
10451
10452
10453 // String indexing
10454 if (Z_TYPE_PP (p_array) == IS_STRING && Z_STRLEN_PP (p_array) > 0)
10455 {
10456 zval* rhs;
10457 if (local_page_id == NULL)
10458 rhs = EG (uninitialized_zval_ptr);
10459 else
10460 rhs = local_page_id;
10461
10462 write_string_index (p_array, index, rhs TSRMLS_CC);
10463 }
10464 else if (Z_TYPE_PP (p_array) == IS_ARRAY)
10465 {
10466 zval** p_lhs = get_ht_entry (p_array, index TSRMLS_CC);
10467 zval* rhs;
10468 if (local_page_id == NULL)
10469 rhs = EG (uninitialized_zval_ptr);
10470 else
10471 rhs = local_page_id;
10472
10473 if (*p_lhs != rhs)
10474 {
10475 write_var (p_lhs, rhs);
10476 }
10477 }
10478 phc_check_invariants (TSRMLS_C);
10479 }
10480 // $TMIt121 = $this->mTemplateIds;
10481 {
10482 if (local_this == NULL)
10483 {
10484 local_this = EG (uninitialized_zval_ptr);
10485 local_this->refcount++;
10486 }
10487 zval** p_obj = &local_this;
10488
10489 zval field_name;
10490 INIT_ZVAL (field_name);
10491 ZVAL_STRING (&field_name, "mTemplateIds", 0);
10492
10493 // I *think* this is correct, but documentation of the Zend API is scarce :)
10494 zval* field = Z_OBJ_HT_PP(p_obj)->read_property(*p_obj, &field_name, BP_VAR_R TSRMLS_CC);
10495 if (local_TMIt121 == NULL)
10496 {
10497 local_TMIt121 = EG (uninitialized_zval_ptr);
10498 local_TMIt121->refcount++;
10499 }
10500 zval** p_lhs = &local_TMIt121;
10501
10502 write_var (p_lhs, field);
10503 phc_check_invariants (TSRMLS_C);
10504 }
10505 // $TLE69 = isset($TMIt121[$ns]);
10506 {
10507 if (local_TLE69 == NULL)
10508 {
10509 local_TLE69 = EG (uninitialized_zval_ptr);
10510 local_TLE69->refcount++;
10511 }
10512 zval** p_lhs = &local_TLE69;
10513 zval* value;
10514 if ((*p_lhs)->is_ref)
10515 {
10516 // Always overwrite the current value
10517 value = *p_lhs;
10518 zval_dtor (value);
10519 }
10520 else
10521 {
10522 ALLOC_INIT_ZVAL (value);
10523 zval_ptr_dtor (p_lhs);
10524 *p_lhs = value;
10525 }
10526 if (local_TMIt121 == NULL)
10527 {
10528 local_TMIt121 = EG (uninitialized_zval_ptr);
10529 local_TMIt121->refcount++;
10530 }
10531 zval** u_array = &local_TMIt121;
10532 zval* u_index;
10533 if (local_ns == NULL)
10534 {
10535 u_index = EG (uninitialized_zval_ptr);
10536 }
10537 else
10538 {
10539 u_index = local_ns;
10540 }
10541 ZVAL_BOOL(value, isset_array (u_array, u_index));
10542 phc_check_invariants (TSRMLS_C);
10543 }
10544 // $TLE70 = !$TLE69;
10545 {
10546 if (local_TLE70 == NULL)
10547 {
10548 local_TLE70 = EG (uninitialized_zval_ptr);
10549 local_TLE70->refcount++;
10550 }
10551 zval** p_lhs = &local_TLE70;
10552
10553 zval* rhs;
10554 if (local_TLE69 == NULL)
10555 rhs = EG (uninitialized_zval_ptr);
10556 else
10557 rhs = local_TLE69;
10558
10559 if (in_copy_on_write (*p_lhs))
10560 {
10561 zval_ptr_dtor (p_lhs);
10562 ALLOC_INIT_ZVAL (*p_lhs);
10563 }
10564
10565 zval old = **p_lhs;
10566 int result_is_operand = (*p_lhs == rhs);
10567 boolean_not_function (*p_lhs, rhs TSRMLS_CC);
10568 if (!result_is_operand)
10569 zval_dtor (&old);
10570 phc_check_invariants (TSRMLS_C);
10571 }
10572 // if (TLE70) goto L176 else goto L177;
10573 {
10574 zval* p_cond;
10575 if (local_TLE70 == NULL)
10576 p_cond = EG (uninitialized_zval_ptr);
10577 else
10578 p_cond = local_TLE70;
10579
10580 zend_bool bcond = zend_is_true (p_cond);
10581 if (bcond)
10582 goto L176;
10583 else
10584 goto L177;
10585 phc_check_invariants (TSRMLS_C);
10586 }
10587 // L176:
10588 L176:;
10589 // $TSt71 =& $this->mTemplateIds;
10590 {
10591 if (local_this == NULL)
10592 {
10593 local_this = EG (uninitialized_zval_ptr);
10594 local_this->refcount++;
10595 }
10596 zval** p_obj = &local_this;
10597
10598 zval field_name;
10599 INIT_ZVAL (field_name);
10600 ZVAL_STRING (&field_name, "mTemplateIds", 0);
10601
10602 zval** field = Z_OBJ_HT_PP(p_obj)->get_property_ptr_ptr(*p_obj, &field_name TSRMLS_CC);
10603 sep_copy_on_write (field);
10604 if (local_TSt71 == NULL)
10605 {
10606 local_TSt71 = EG (uninitialized_zval_ptr);
10607 local_TSt71->refcount++;
10608 }
10609 zval** p_lhs = &local_TSt71;
10610
10611 copy_into_ref (p_lhs, field);
10612 phc_check_invariants (TSRMLS_C);
10613 }
10614 // unset($TSa72);
10615 {
10616 if (local_TSa72 != NULL)
10617 {
10618 zval_ptr_dtor (&local_TSa72);
10619 local_TSa72 = NULL;
10620 }
10621 phc_check_invariants (TSRMLS_C);
10622 }
10623 // $TSa72 = (array) $TSa72;
10624 {
10625 if (local_TSa72 == NULL)
10626 {
10627 local_TSa72 = EG (uninitialized_zval_ptr);
10628 local_TSa72->refcount++;
10629 }
10630 zval** p_lhs = &local_TSa72;
10631
10632 zval* rhs;
10633 if (local_TSa72 == NULL)
10634 rhs = EG (uninitialized_zval_ptr);
10635 else
10636 rhs = local_TSa72;
10637
10638 if (*p_lhs != rhs)
10639 {
10640 if ((*p_lhs)->is_ref)
10641 overwrite_lhs (*p_lhs, rhs);
10642 else
10643 {
10644 zval_ptr_dtor (p_lhs);
10645 if (rhs->is_ref)
10646 {
10647 // Take a copy of RHS for LHS
10648 *p_lhs = zvp_clone_ex (rhs);
10649 }
10650 else
10651 {
10652 // Share a copy
10653 rhs->refcount++;
10654 *p_lhs = rhs;
10655 }
10656
10657 }
10658
10659 }
10660
10661 assert (IS_ARRAY >= 0 && IS_ARRAY <= 6);
10662 if ((*p_lhs)->type != IS_ARRAY)
10663 {
10664 sep_copy_on_write (p_lhs);
10665 convert_to_array (*p_lhs);
10666 }
10667
10668 phc_check_invariants (TSRMLS_C);
10669 }
10670 // $TSt71[$ns] = $TSa72;
10671 {
10672 if (local_TSt71 == NULL)
10673 {
10674 local_TSt71 = EG (uninitialized_zval_ptr);
10675 local_TSt71->refcount++;
10676 }
10677 zval** p_array = &local_TSt71;
10678
10679 check_array_type (p_array TSRMLS_CC);
10680
10681 zval* index;
10682 if (local_ns == NULL)
10683 index = EG (uninitialized_zval_ptr);
10684 else
10685 index = local_ns;
10686
10687
10688 // String indexing
10689 if (Z_TYPE_PP (p_array) == IS_STRING && Z_STRLEN_PP (p_array) > 0)
10690 {
10691 zval* rhs;
10692 if (local_TSa72 == NULL)
10693 rhs = EG (uninitialized_zval_ptr);
10694 else
10695 rhs = local_TSa72;
10696
10697 write_string_index (p_array, index, rhs TSRMLS_CC);
10698 }
10699 else if (Z_TYPE_PP (p_array) == IS_ARRAY)
10700 {
10701 zval** p_lhs = get_ht_entry (p_array, index TSRMLS_CC);
10702 zval* rhs;
10703 if (local_TSa72 == NULL)
10704 rhs = EG (uninitialized_zval_ptr);
10705 else
10706 rhs = local_TSa72;
10707
10708 if (*p_lhs != rhs)
10709 {
10710 write_var (p_lhs, rhs);
10711 }
10712 }
10713 phc_check_invariants (TSRMLS_C);
10714 }
10715 // goto L178;
10716 {
10717 goto L178;
10718 phc_check_invariants (TSRMLS_C);
10719 }
10720 // L177:
10721 L177:;
10722 // goto L178;
10723 {
10724 goto L178;
10725 phc_check_invariants (TSRMLS_C);
10726 }
10727 // L178:
10728 L178:;
10729 // $TSt73 =& $this->mTemplateIds;
10730 {
10731 if (local_this == NULL)
10732 {
10733 local_this = EG (uninitialized_zval_ptr);
10734 local_this->refcount++;
10735 }
10736 zval** p_obj = &local_this;
10737
10738 zval field_name;
10739 INIT_ZVAL (field_name);
10740 ZVAL_STRING (&field_name, "mTemplateIds", 0);
10741
10742 zval** field = Z_OBJ_HT_PP(p_obj)->get_property_ptr_ptr(*p_obj, &field_name TSRMLS_CC);
10743 sep_copy_on_write (field);
10744 if (local_TSt73 == NULL)
10745 {
10746 local_TSt73 = EG (uninitialized_zval_ptr);
10747 local_TSt73->refcount++;
10748 }
10749 zval** p_lhs = &local_TSt73;
10750
10751 copy_into_ref (p_lhs, field);
10752 phc_check_invariants (TSRMLS_C);
10753 }
10754 // $TSi74 =& $TSt73[$ns];
10755 {
10756 if (local_TSi74 == NULL)
10757 {
10758 local_TSi74 = EG (uninitialized_zval_ptr);
10759 local_TSi74->refcount++;
10760 }
10761 zval** p_lhs = &local_TSi74;
10762
10763 if (local_TSt73 == NULL)
10764 {
10765 local_TSt73 = EG (uninitialized_zval_ptr);
10766 local_TSt73->refcount++;
10767 }
10768 zval** p_r_array = &local_TSt73;
10769
10770 zval* r_index;
10771 if (local_ns == NULL)
10772 r_index = EG (uninitialized_zval_ptr);
10773 else
10774 r_index = local_ns;
10775
10776 check_array_type (p_r_array TSRMLS_CC);
10777 zval** p_rhs = get_ht_entry (p_r_array, r_index TSRMLS_CC);
10778 sep_copy_on_write (p_rhs);
10779 copy_into_ref (p_lhs, p_rhs);
10780 phc_check_invariants (TSRMLS_C);
10781 }
10782 // $TSi74[$dbk] = $rev_id;
10783 {
10784 if (local_TSi74 == NULL)
10785 {
10786 local_TSi74 = EG (uninitialized_zval_ptr);
10787 local_TSi74->refcount++;
10788 }
10789 zval** p_array = &local_TSi74;
10790
10791 check_array_type (p_array TSRMLS_CC);
10792
10793 zval* index;
10794 if (local_dbk == NULL)
10795 index = EG (uninitialized_zval_ptr);
10796 else
10797 index = local_dbk;
10798
10799
10800 // String indexing
10801 if (Z_TYPE_PP (p_array) == IS_STRING && Z_STRLEN_PP (p_array) > 0)
10802 {
10803 zval* rhs;
10804 if (local_rev_id == NULL)
10805 rhs = EG (uninitialized_zval_ptr);
10806 else
10807 rhs = local_rev_id;
10808
10809 write_string_index (p_array, index, rhs TSRMLS_CC);
10810 }
10811 else if (Z_TYPE_PP (p_array) == IS_ARRAY)
10812 {
10813 zval** p_lhs = get_ht_entry (p_array, index TSRMLS_CC);
10814 zval* rhs;
10815 if (local_rev_id == NULL)
10816 rhs = EG (uninitialized_zval_ptr);
10817 else
10818 rhs = local_rev_id;
10819
10820 if (*p_lhs != rhs)
10821 {
10822 write_var (p_lhs, rhs);
10823 }
10824 }
10825 phc_check_invariants (TSRMLS_C);
10826 }
10827 // Method exit
10828 end_of_function:__attribute__((unused));
10829 if (local_TLE63 != NULL)
10830 {
10831 zval_ptr_dtor (&local_TLE63);
10832 }
10833 if (local_TLE64 != NULL)
10834 {
10835 zval_ptr_dtor (&local_TLE64);
10836 }
10837 if (local_TLE69 != NULL)
10838 {
10839 zval_ptr_dtor (&local_TLE69);
10840 }
10841 if (local_TLE70 != NULL)
10842 {
10843 zval_ptr_dtor (&local_TLE70);
10844 }
10845 if (local_TMIt120 != NULL)
10846 {
10847 zval_ptr_dtor (&local_TMIt120);
10848 }
10849 if (local_TMIt121 != NULL)
10850 {
10851 zval_ptr_dtor (&local_TMIt121);
10852 }
10853 if (local_TSa66 != NULL)
10854 {
10855 zval_ptr_dtor (&local_TSa66);
10856 }
10857 if (local_TSa72 != NULL)
10858 {
10859 zval_ptr_dtor (&local_TSa72);
10860 }
10861 if (local_TSi68 != NULL)
10862 {
10863 zval_ptr_dtor (&local_TSi68);
10864 }
10865 if (local_TSi74 != NULL)
10866 {
10867 zval_ptr_dtor (&local_TSi74);
10868 }
10869 if (local_TSt65 != NULL)
10870 {
10871 zval_ptr_dtor (&local_TSt65);
10872 }
10873 if (local_TSt67 != NULL)
10874 {
10875 zval_ptr_dtor (&local_TSt67);
10876 }
10877 if (local_TSt71 != NULL)
10878 {
10879 zval_ptr_dtor (&local_TSt71);
10880 }
10881 if (local_TSt73 != NULL)
10882 {
10883 zval_ptr_dtor (&local_TSt73);
10884 }
10885 if (local_dbk != NULL)
10886 {
10887 zval_ptr_dtor (&local_dbk);
10888 }
10889 if (local_ns != NULL)
10890 {
10891 zval_ptr_dtor (&local_ns);
10892 }
10893 if (local_page_id != NULL)
10894 {
10895 zval_ptr_dtor (&local_page_id);
10896 }
10897 if (local_rev_id != NULL)
10898 {
10899 zval_ptr_dtor (&local_rev_id);
10900 }
10901 if (local_title != NULL)
10902 {
10903 zval_ptr_dtor (&local_title);
10904 }
10905 }
10906 // function expired($touched)
10907 // {
10908 // global $wgCacheEpoch;
10909 // $TLE75 = $this->getcachetime();
10910 // $TLE76 = -1;
10911 // $TLE0 = ($TLE75 == $TLE76);
10912 // if (TLE0) goto L179 else goto L180;
10913 // L179:
10914 // $TEF1 = $TLE0;
10915 // goto L181;
10916 // L180:
10917 // $TLE77 = $this->getcachetime();
10918 // $TEF1 = ($TLE77 < $touched);
10919 // goto L181;
10920 // L181:
10921 // $TLE2 = (bool) $TEF1;
10922 // if (TLE2) goto L182 else goto L183;
10923 // L182:
10924 // $TEF3 = $TLE2;
10925 // goto L184;
10926 // L183:
10927 // $TLE78 = $this->getcachetime();
10928 // $TEF3 = ($TLE78 <= $wgCacheEpoch);
10929 // goto L184;
10930 // L184:
10931 // $TLE4 = (bool) $TEF3;
10932 // if (TLE4) goto L185 else goto L186;
10933 // L185:
10934 // $TEF5 = $TLE4;
10935 // goto L187;
10936 // L186:
10937 // $TMIt122 = $this->mVersion;
10938 // $TLE79 = isset($TMIt122);
10939 // $TEF5 = !$TLE79;
10940 // goto L187;
10941 // L187:
10942 // $TLE6 = (bool) $TEF5;
10943 // if (TLE6) goto L191 else goto L192;
10944 // L191:
10945 // $TEF7 = $TLE6;
10946 // goto L193;
10947 // L192:
10948 // $TLE80 = Parser::VERSION;
10949 // $TLE81 = 'lt';
10950 // $TLE124 = param_is_ref (NULL, "version_compare", 0);
10951 // ;
10952 // if (TLE124) goto L188 else goto L189;
10953 // L188:
10954 // $TMIt123 =& $this->mVersion;
10955 // goto L190;
10956 // L189:
10957 // $TMIt123 = $this->mVersion;
10958 // goto L190;
10959 // L190:
10960 // $TEF7 = version_compare($TMIt123, $TLE80, $TLE81);
10961 // goto L193;
10962 // L193:
10963 // $TLE82 = (bool) $TEF7;
10964 // return $TLE82;
10965 // }
10966 PHP_METHOD(ParserOutput, expired)
10967 {
10968 zval* local_TEF1 = NULL;
10969 zval* local_TEF3 = NULL;
10970 zval* local_TEF5 = NULL;
10971 zval* local_TEF7 = NULL;
10972 zval* local_TLE0 = NULL;
10973 zval* local_TLE124 = NULL;
10974 zval* local_TLE2 = NULL;
10975 zval* local_TLE4 = NULL;
10976 zval* local_TLE6 = NULL;
10977 zval* local_TLE75 = NULL;
10978 zval* local_TLE76 = NULL;
10979 zval* local_TLE77 = NULL;
10980 zval* local_TLE78 = NULL;
10981 zval* local_TLE79 = NULL;
10982 zval* local_TLE80 = NULL;
10983 zval* local_TLE81 = NULL;
10984 zval* local_TLE82 = NULL;
10985 zval* local_TMIt122 = NULL;
10986 zval* local_TMIt123 = NULL;
10987 zval* local_this = getThis();
10988 zval* local_touched = NULL;
10989 zval* local_wgCacheEpoch = NULL;
10990 // Add all parameters as local variables
10991 {
10992 int num_args = ZEND_NUM_ARGS ();
10993 zval* params[1];
10994 zend_get_parameters_array(0, num_args, params);
10995 // param 0
10996 params[0]->refcount++;
10997 if (local_touched != NULL)
10998 {
10999 zval_ptr_dtor (&local_touched);
11000 }
11001 local_touched = params[0];
11002 }
11003 // Function body
11004 // global $wgCacheEpoch;
11005 {
11006 if (local_wgCacheEpoch == NULL)
11007 {
11008 local_wgCacheEpoch = EG (uninitialized_zval_ptr);
11009 local_wgCacheEpoch->refcount++;
11010 }
11011 zval** p_local = &local_wgCacheEpoch;
11012
11013 zval** p_global = get_st_entry (&EG(symbol_table), "wgCacheEpoch", 12 + 1, 2181899014u TSRMLS_CC);
11014
11015 sep_copy_on_write (p_global);
11016 copy_into_ref (p_local, p_global);
11017 phc_check_invariants (TSRMLS_C);
11018 }
11019 // $TLE75 = $this->getcachetime();
11020 {
11021 if (local_this == NULL)
11022 {
11023 local_this = EG (uninitialized_zval_ptr);
11024 local_this->refcount++;
11025 }
11026 zval** p_obj = &local_this;
11027
11028 zend_fcall_info fci_object;
11029 zend_fcall_info_cache fcic_object = {0, NULL, NULL, NULL};
11030 initialize_method_call (&fci_object, &fcic_object, p_obj, "getcachetime", "/home/mdupont/2009/02/introspector/rdfintrospector/mediawiki/trunk/phase3/includes/parser/ParserOutput.php", 138 TSRMLS_CC);
11031 zend_function* signature = fcic_object.function_handler;
11032 zend_arg_info* arg_info = signature->common.arg_info; // optional
11033
11034 int by_ref[0];
11035 int abr_index = 0;
11036
11037
11038 // Setup array of arguments
11039 // TODO: i think arrays of size 0 is an error
11040 int destruct [0];
11041 zval* args [0];
11042 zval** args_ind [0];
11043
11044 int af_index = 0;
11045
11046
11047 phc_setup_error (1, "/home/mdupont/2009/02/introspector/rdfintrospector/mediawiki/trunk/phase3/includes/parser/ParserOutput.php", 138, NULL TSRMLS_CC);
11048
11049 // save existing parameters, in case of recursion
11050 int param_count_save = fci_object.param_count;
11051 zval*** params_save = fci_object.params;
11052 zval** retval_save = fci_object.retval_ptr_ptr;
11053
11054 zval* rhs = NULL;
11055
11056 // set up params
11057 fci_object.params = args_ind;
11058 fci_object.param_count = 0;
11059 fci_object.retval_ptr_ptr = &rhs;
11060
11061 // call the function
11062 int success = zend_call_function (&fci_object, &fcic_object TSRMLS_CC);
11063 assert(success == SUCCESS);
11064
11065 // restore params
11066 fci_object.params = params_save;
11067 fci_object.param_count = param_count_save;
11068 fci_object.retval_ptr_ptr = retval_save;
11069
11070 // unset the errors
11071 phc_setup_error (0, NULL, 0, NULL TSRMLS_CC);
11072
11073 int i;
11074 for (i = 0; i < 0; i++)
11075 {
11076 if (destruct[i])
11077 {
11078 assert (destruct[i]);
11079 zval_ptr_dtor (args_ind[i]);
11080 }
11081 }
11082
11083
11084 // When the Zend engine returns by reference, it allocates a zval into
11085 // retval_ptr_ptr. To return by reference, the callee writes into the
11086 // retval_ptr_ptr, freeing the allocated value as it does. (Note, it may
11087 // not actually return anything). So the zval returned - whether we return
11088 // it, or it is the allocated zval - has a refcount of 1.
11089
11090 // The caller is responsible for cleaning that up (note, this is unaffected
11091 // by whether it is added to some COW set).
11092
11093 // For reasons unknown, the Zend API resets the refcount and is_ref fields
11094 // of the return value after the function returns (unless the callee is
11095 // interpreted). If the function is supposed to return by reference, this
11096 // loses the refcount. This only happens when non-interpreted code is
11097 // called. We work around it, when compiled code is called, by saving the
11098 // refcount into SAVED_REFCOUNT, in the return statement. The downside is
11099 // that we may create an error if our code is called by a callback, and
11100 // returns by reference, and the callback returns by reference. At least
11101 // this is an obscure case.
11102 if(signature->common.return_reference && signature->type != ZEND_USER_FUNCTION)
11103 {
11104 assert (rhs != EG(uninitialized_zval_ptr));
11105 rhs->is_ref = 1;
11106 if (saved_refcount != 0)
11107 {
11108 rhs->refcount = saved_refcount;
11109 }
11110 rhs->refcount++;
11111 }
11112 saved_refcount = 0; // for 'obscure cases'
11113
11114 if (local_TLE75 == NULL)
11115 {
11116 local_TLE75 = EG (uninitialized_zval_ptr);
11117 local_TLE75->refcount++;
11118 }
11119 zval** p_lhs = &local_TLE75;
11120
11121 write_var (p_lhs, rhs);
11122
11123
11124 zval_ptr_dtor (&rhs);
11125 if(signature->common.return_reference && signature->type != ZEND_USER_FUNCTION)
11126 zval_ptr_dtor (&rhs);
11127
11128 phc_check_invariants (TSRMLS_C);
11129 }
11130 // $TLE76 = -1;
11131 {
11132 if (local_TLE76 == NULL)
11133 {
11134 local_TLE76 = EG (uninitialized_zval_ptr);
11135 local_TLE76->refcount++;
11136 }
11137 zval** p_lhs = &local_TLE76;
11138
11139 zval* value;
11140 if ((*p_lhs)->is_ref)
11141 {
11142 // Always overwrite the current value
11143 value = *p_lhs;
11144 zval_dtor (value);
11145 }
11146 else
11147 {
11148 ALLOC_INIT_ZVAL (value);
11149 zval_ptr_dtor (p_lhs);
11150 *p_lhs = value;
11151 }
11152
11153 ZVAL_LONG (value, -1);
11154
11155 phc_check_invariants (TSRMLS_C);
11156 }
11157 // $TLE0 = ($TLE75 == $TLE76);
11158 {
11159 if (local_TLE0 == NULL)
11160 {
11161 local_TLE0 = EG (uninitialized_zval_ptr);
11162 local_TLE0->refcount++;
11163 }
11164 zval** p_lhs = &local_TLE0;
11165
11166 zval* left;
11167 if (local_TLE75 == NULL)
11168 left = EG (uninitialized_zval_ptr);
11169 else
11170 left = local_TLE75;
11171
11172 zval* right;
11173 if (local_TLE76 == NULL)
11174 right = EG (uninitialized_zval_ptr);
11175 else
11176 right = local_TLE76;
11177
11178 if (in_copy_on_write (*p_lhs))
11179 {
11180 zval_ptr_dtor (p_lhs);
11181 ALLOC_INIT_ZVAL (*p_lhs);
11182 }
11183
11184 zval old = **p_lhs;
11185 int result_is_operand = (*p_lhs == left || *p_lhs == right);
11186 is_equal_function (*p_lhs, left, right TSRMLS_CC);
11187
11188 // If the result is one of the operands, the operator function
11189 // will already have cleaned up the result
11190 if (!result_is_operand)
11191 zval_dtor (&old);
11192 phc_check_invariants (TSRMLS_C);
11193 }
11194 // if (TLE0) goto L179 else goto L180;
11195 {
11196 zval* p_cond;
11197 if (local_TLE0 == NULL)
11198 p_cond = EG (uninitialized_zval_ptr);
11199 else
11200 p_cond = local_TLE0;
11201
11202 zend_bool bcond = zend_is_true (p_cond);
11203 if (bcond)
11204 goto L179;
11205 else
11206 goto L180;
11207 phc_check_invariants (TSRMLS_C);
11208 }
11209 // L179:
11210 L179:;
11211 // $TEF1 = $TLE0;
11212 {
11213 if (local_TEF1 == NULL)
11214 {
11215 local_TEF1 = EG (uninitialized_zval_ptr);
11216 local_TEF1->refcount++;
11217 }
11218 zval** p_lhs = &local_TEF1;
11219
11220 zval* rhs;
11221 if (local_TLE0 == NULL)
11222 rhs = EG (uninitialized_zval_ptr);
11223 else
11224 rhs = local_TLE0;
11225
11226 if (*p_lhs != rhs)
11227 {
11228 if ((*p_lhs)->is_ref)
11229 overwrite_lhs (*p_lhs, rhs);
11230 else
11231 {
11232 zval_ptr_dtor (p_lhs);
11233 if (rhs->is_ref)
11234 {
11235 // Take a copy of RHS for LHS
11236 *p_lhs = zvp_clone_ex (rhs);
11237 }
11238 else
11239 {
11240 // Share a copy
11241 rhs->refcount++;
11242 *p_lhs = rhs;
11243 }
11244
11245 }
11246
11247 }
11248 phc_check_invariants (TSRMLS_C);
11249 }
11250 // goto L181;
11251 {
11252 goto L181;
11253 phc_check_invariants (TSRMLS_C);
11254 }
11255 // L180:
11256 L180:;
11257 // $TLE77 = $this->getcachetime();
11258 {
11259 if (local_this == NULL)
11260 {
11261 local_this = EG (uninitialized_zval_ptr);
11262 local_this->refcount++;
11263 }
11264 zval** p_obj = &local_this;
11265
11266 zend_fcall_info fci_object;
11267 zend_fcall_info_cache fcic_object = {0, NULL, NULL, NULL};
11268 initialize_method_call (&fci_object, &fcic_object, p_obj, "getcachetime", "/home/mdupont/2009/02/introspector/rdfintrospector/mediawiki/trunk/phase3/includes/parser/ParserOutput.php", 139 TSRMLS_CC);
11269 zend_function* signature = fcic_object.function_handler;
11270 zend_arg_info* arg_info = signature->common.arg_info; // optional
11271
11272 int by_ref[0];
11273 int abr_index = 0;
11274
11275
11276 // Setup array of arguments
11277 // TODO: i think arrays of size 0 is an error
11278 int destruct [0];
11279 zval* args [0];
11280 zval** args_ind [0];
11281
11282 int af_index = 0;
11283
11284
11285 phc_setup_error (1, "/home/mdupont/2009/02/introspector/rdfintrospector/mediawiki/trunk/phase3/includes/parser/ParserOutput.php", 139, NULL TSRMLS_CC);
11286
11287 // save existing parameters, in case of recursion
11288 int param_count_save = fci_object.param_count;
11289 zval*** params_save = fci_object.params;
11290 zval** retval_save = fci_object.retval_ptr_ptr;
11291
11292 zval* rhs = NULL;
11293
11294 // set up params
11295 fci_object.params = args_ind;
11296 fci_object.param_count = 0;
11297 fci_object.retval_ptr_ptr = &rhs;
11298
11299 // call the function
11300 int success = zend_call_function (&fci_object, &fcic_object TSRMLS_CC);
11301 assert(success == SUCCESS);
11302
11303 // restore params
11304 fci_object.params = params_save;
11305 fci_object.param_count = param_count_save;
11306 fci_object.retval_ptr_ptr = retval_save;
11307
11308 // unset the errors
11309 phc_setup_error (0, NULL, 0, NULL TSRMLS_CC);
11310
11311 int i;
11312 for (i = 0; i < 0; i++)
11313 {
11314 if (destruct[i])
11315 {
11316 assert (destruct[i]);
11317 zval_ptr_dtor (args_ind[i]);
11318 }
11319 }
11320
11321
11322 // When the Zend engine returns by reference, it allocates a zval into
11323 // retval_ptr_ptr. To return by reference, the callee writes into the
11324 // retval_ptr_ptr, freeing the allocated value as it does. (Note, it may
11325 // not actually return anything). So the zval returned - whether we return
11326 // it, or it is the allocated zval - has a refcount of 1.
11327
11328 // The caller is responsible for cleaning that up (note, this is unaffected
11329 // by whether it is added to some COW set).
11330
11331 // For reasons unknown, the Zend API resets the refcount and is_ref fields
11332 // of the return value after the function returns (unless the callee is
11333 // interpreted). If the function is supposed to return by reference, this
11334 // loses the refcount. This only happens when non-interpreted code is
11335 // called. We work around it, when compiled code is called, by saving the
11336 // refcount into SAVED_REFCOUNT, in the return statement. The downside is
11337 // that we may create an error if our code is called by a callback, and
11338 // returns by reference, and the callback returns by reference. At least
11339 // this is an obscure case.
11340 if(signature->common.return_reference && signature->type != ZEND_USER_FUNCTION)
11341 {
11342 assert (rhs != EG(uninitialized_zval_ptr));
11343 rhs->is_ref = 1;
11344 if (saved_refcount != 0)
11345 {
11346 rhs->refcount = saved_refcount;
11347 }
11348 rhs->refcount++;
11349 }
11350 saved_refcount = 0; // for 'obscure cases'
11351
11352 if (local_TLE77 == NULL)
11353 {
11354 local_TLE77 = EG (uninitialized_zval_ptr);
11355 local_TLE77->refcount++;
11356 }
11357 zval** p_lhs = &local_TLE77;
11358
11359 write_var (p_lhs, rhs);
11360
11361
11362 zval_ptr_dtor (&rhs);
11363 if(signature->common.return_reference && signature->type != ZEND_USER_FUNCTION)
11364 zval_ptr_dtor (&rhs);
11365
11366 phc_check_invariants (TSRMLS_C);
11367 }
11368 // $TEF1 = ($TLE77 < $touched);
11369 {
11370 if (local_TEF1 == NULL)
11371 {
11372 local_TEF1 = EG (uninitialized_zval_ptr);
11373 local_TEF1->refcount++;
11374 }
11375 zval** p_lhs = &local_TEF1;
11376
11377 zval* left;
11378 if (local_TLE77 == NULL)
11379 left = EG (uninitialized_zval_ptr);
11380 else
11381 left = local_TLE77;
11382
11383 zval* right;
11384 if (local_touched == NULL)
11385 right = EG (uninitialized_zval_ptr);
11386 else
11387 right = local_touched;
11388
11389 if (in_copy_on_write (*p_lhs))
11390 {
11391 zval_ptr_dtor (p_lhs);
11392 ALLOC_INIT_ZVAL (*p_lhs);
11393 }
11394
11395 zval old = **p_lhs;
11396 int result_is_operand = (*p_lhs == left || *p_lhs == right);
11397 is_smaller_function (*p_lhs, left, right TSRMLS_CC);
11398
11399 // If the result is one of the operands, the operator function
11400 // will already have cleaned up the result
11401 if (!result_is_operand)
11402 zval_dtor (&old);
11403 phc_check_invariants (TSRMLS_C);
11404 }
11405 // goto L181;
11406 {
11407 goto L181;
11408 phc_check_invariants (TSRMLS_C);
11409 }
11410 // L181:
11411 L181:;
11412 // $TLE2 = (bool) $TEF1;
11413 {
11414 if (local_TLE2 == NULL)
11415 {
11416 local_TLE2 = EG (uninitialized_zval_ptr);
11417 local_TLE2->refcount++;
11418 }
11419 zval** p_lhs = &local_TLE2;
11420
11421 zval* rhs;
11422 if (local_TEF1 == NULL)
11423 rhs = EG (uninitialized_zval_ptr);
11424 else
11425 rhs = local_TEF1;
11426
11427 if (*p_lhs != rhs)
11428 {
11429 if ((*p_lhs)->is_ref)
11430 overwrite_lhs (*p_lhs, rhs);
11431 else
11432 {
11433 zval_ptr_dtor (p_lhs);
11434 if (rhs->is_ref)
11435 {
11436 // Take a copy of RHS for LHS
11437 *p_lhs = zvp_clone_ex (rhs);
11438 }
11439 else
11440 {
11441 // Share a copy
11442 rhs->refcount++;
11443 *p_lhs = rhs;
11444 }
11445
11446 }
11447
11448 }
11449
11450 assert (IS_BOOL >= 0 && IS_BOOL <= 6);
11451 if ((*p_lhs)->type != IS_BOOL)
11452 {
11453 sep_copy_on_write (p_lhs);
11454 convert_to_boolean (*p_lhs);
11455 }
11456
11457 phc_check_invariants (TSRMLS_C);
11458 }
11459 // if (TLE2) goto L182 else goto L183;
11460 {
11461 zval* p_cond;
11462 if (local_TLE2 == NULL)
11463 p_cond = EG (uninitialized_zval_ptr);
11464 else
11465 p_cond = local_TLE2;
11466
11467 zend_bool bcond = zend_is_true (p_cond);
11468 if (bcond)
11469 goto L182;
11470 else
11471 goto L183;
11472 phc_check_invariants (TSRMLS_C);
11473 }
11474 // L182:
11475 L182:;
11476 // $TEF3 = $TLE2;
11477 {
11478 if (local_TEF3 == NULL)
11479 {
11480 local_TEF3 = EG (uninitialized_zval_ptr);
11481 local_TEF3->refcount++;
11482 }
11483 zval** p_lhs = &local_TEF3;
11484
11485 zval* rhs;
11486 if (local_TLE2 == NULL)
11487 rhs = EG (uninitialized_zval_ptr);
11488 else
11489 rhs = local_TLE2;
11490
11491 if (*p_lhs != rhs)
11492 {
11493 if ((*p_lhs)->is_ref)
11494 overwrite_lhs (*p_lhs, rhs);
11495 else
11496 {
11497 zval_ptr_dtor (p_lhs);
11498 if (rhs->is_ref)
11499 {
11500 // Take a copy of RHS for LHS
11501 *p_lhs = zvp_clone_ex (rhs);
11502 }
11503 else
11504 {
11505 // Share a copy
11506 rhs->refcount++;
11507 *p_lhs = rhs;
11508 }
11509
11510 }
11511
11512 }
11513 phc_check_invariants (TSRMLS_C);
11514 }
11515 // goto L184;
11516 {
11517 goto L184;
11518 phc_check_invariants (TSRMLS_C);
11519 }
11520 // L183:
11521 L183:;
11522 // $TLE78 = $this->getcachetime();
11523 {
11524 if (local_this == NULL)
11525 {
11526 local_this = EG (uninitialized_zval_ptr);
11527 local_this->refcount++;
11528 }
11529 zval** p_obj = &local_this;
11530
11531 zend_fcall_info fci_object;
11532 zend_fcall_info_cache fcic_object = {0, NULL, NULL, NULL};
11533 initialize_method_call (&fci_object, &fcic_object, p_obj, "getcachetime", "/home/mdupont/2009/02/introspector/rdfintrospector/mediawiki/trunk/phase3/includes/parser/ParserOutput.php", 140 TSRMLS_CC);
11534 zend_function* signature = fcic_object.function_handler;
11535 zend_arg_info* arg_info = signature->common.arg_info; // optional
11536
11537 int by_ref[0];
11538 int abr_index = 0;
11539
11540
11541 // Setup array of arguments
11542 // TODO: i think arrays of size 0 is an error
11543 int destruct [0];
11544 zval* args [0];
11545 zval** args_ind [0];
11546
11547 int af_index = 0;
11548
11549
11550 phc_setup_error (1, "/home/mdupont/2009/02/introspector/rdfintrospector/mediawiki/trunk/phase3/includes/parser/ParserOutput.php", 140, NULL TSRMLS_CC);
11551
11552 // save existing parameters, in case of recursion
11553 int param_count_save = fci_object.param_count;
11554 zval*** params_save = fci_object.params;
11555 zval** retval_save = fci_object.retval_ptr_ptr;
11556
11557 zval* rhs = NULL;
11558
11559 // set up params
11560 fci_object.params = args_ind;
11561 fci_object.param_count = 0;
11562 fci_object.retval_ptr_ptr = &rhs;
11563
11564 // call the function
11565 int success = zend_call_function (&fci_object, &fcic_object TSRMLS_CC);
11566 assert(success == SUCCESS);
11567
11568 // restore params
11569 fci_object.params = params_save;
11570 fci_object.param_count = param_count_save;
11571 fci_object.retval_ptr_ptr = retval_save;
11572
11573 // unset the errors
11574 phc_setup_error (0, NULL, 0, NULL TSRMLS_CC);
11575
11576 int i;
11577 for (i = 0; i < 0; i++)
11578 {
11579 if (destruct[i])
11580 {
11581 assert (destruct[i]);
11582 zval_ptr_dtor (args_ind[i]);
11583 }
11584 }
11585
11586
11587 // When the Zend engine returns by reference, it allocates a zval into
11588 // retval_ptr_ptr. To return by reference, the callee writes into the
11589 // retval_ptr_ptr, freeing the allocated value as it does. (Note, it may
11590 // not actually return anything). So the zval returned - whether we return
11591 // it, or it is the allocated zval - has a refcount of 1.
11592
11593 // The caller is responsible for cleaning that up (note, this is unaffected
11594 // by whether it is added to some COW set).
11595
11596 // For reasons unknown, the Zend API resets the refcount and is_ref fields
11597 // of the return value after the function returns (unless the callee is
11598 // interpreted). If the function is supposed to return by reference, this
11599 // loses the refcount. This only happens when non-interpreted code is
11600 // called. We work around it, when compiled code is called, by saving the
11601 // refcount into SAVED_REFCOUNT, in the return statement. The downside is
11602 // that we may create an error if our code is called by a callback, and
11603 // returns by reference, and the callback returns by reference. At least
11604 // this is an obscure case.
11605 if(signature->common.return_reference && signature->type != ZEND_USER_FUNCTION)
11606 {
11607 assert (rhs != EG(uninitialized_zval_ptr));
11608 rhs->is_ref = 1;
11609 if (saved_refcount != 0)
11610 {
11611 rhs->refcount = saved_refcount;
11612 }
11613 rhs->refcount++;
11614 }
11615 saved_refcount = 0; // for 'obscure cases'
11616
11617 if (local_TLE78 == NULL)
11618 {
11619 local_TLE78 = EG (uninitialized_zval_ptr);
11620 local_TLE78->refcount++;
11621 }
11622 zval** p_lhs = &local_TLE78;
11623
11624 write_var (p_lhs, rhs);
11625
11626
11627 zval_ptr_dtor (&rhs);
11628 if(signature->common.return_reference && signature->type != ZEND_USER_FUNCTION)
11629 zval_ptr_dtor (&rhs);
11630
11631 phc_check_invariants (TSRMLS_C);
11632 }
11633 // $TEF3 = ($TLE78 <= $wgCacheEpoch);
11634 {
11635 if (local_TEF3 == NULL)
11636 {
11637 local_TEF3 = EG (uninitialized_zval_ptr);
11638 local_TEF3->refcount++;
11639 }
11640 zval** p_lhs = &local_TEF3;
11641
11642 zval* left;
11643 if (local_TLE78 == NULL)
11644 left = EG (uninitialized_zval_ptr);
11645 else
11646 left = local_TLE78;
11647
11648 zval* right;
11649 if (local_wgCacheEpoch == NULL)
11650 right = EG (uninitialized_zval_ptr);
11651 else
11652 right = local_wgCacheEpoch;
11653
11654 if (in_copy_on_write (*p_lhs))
11655 {
11656 zval_ptr_dtor (p_lhs);
11657 ALLOC_INIT_ZVAL (*p_lhs);
11658 }
11659
11660 zval old = **p_lhs;
11661 int result_is_operand = (*p_lhs == left || *p_lhs == right);
11662 is_smaller_or_equal_function (*p_lhs, left, right TSRMLS_CC);
11663
11664 // If the result is one of the operands, the operator function
11665 // will already have cleaned up the result
11666 if (!result_is_operand)
11667 zval_dtor (&old);
11668 phc_check_invariants (TSRMLS_C);
11669 }
11670 // goto L184;
11671 {
11672 goto L184;
11673 phc_check_invariants (TSRMLS_C);
11674 }
11675 // L184:
11676 L184:;
11677 // $TLE4 = (bool) $TEF3;
11678 {
11679 if (local_TLE4 == NULL)
11680 {
11681 local_TLE4 = EG (uninitialized_zval_ptr);
11682 local_TLE4->refcount++;
11683 }
11684 zval** p_lhs = &local_TLE4;
11685
11686 zval* rhs;
11687 if (local_TEF3 == NULL)
11688 rhs = EG (uninitialized_zval_ptr);
11689 else
11690 rhs = local_TEF3;
11691
11692 if (*p_lhs != rhs)
11693 {
11694 if ((*p_lhs)->is_ref)
11695 overwrite_lhs (*p_lhs, rhs);
11696 else
11697 {
11698 zval_ptr_dtor (p_lhs);
11699 if (rhs->is_ref)
11700 {
11701 // Take a copy of RHS for LHS
11702 *p_lhs = zvp_clone_ex (rhs);
11703 }
11704 else
11705 {
11706 // Share a copy
11707 rhs->refcount++;
11708 *p_lhs = rhs;
11709 }
11710
11711 }
11712
11713 }
11714
11715 assert (IS_BOOL >= 0 && IS_BOOL <= 6);
11716 if ((*p_lhs)->type != IS_BOOL)
11717 {
11718 sep_copy_on_write (p_lhs);
11719 convert_to_boolean (*p_lhs);
11720 }
11721
11722 phc_check_invariants (TSRMLS_C);
11723 }
11724 // if (TLE4) goto L185 else goto L186;
11725 {
11726 zval* p_cond;
11727 if (local_TLE4 == NULL)
11728 p_cond = EG (uninitialized_zval_ptr);
11729 else
11730 p_cond = local_TLE4;
11731
11732 zend_bool bcond = zend_is_true (p_cond);
11733 if (bcond)
11734 goto L185;
11735 else
11736 goto L186;
11737 phc_check_invariants (TSRMLS_C);
11738 }
11739 // L185:
11740 L185:;
11741 // $TEF5 = $TLE4;
11742 {
11743 if (local_TEF5 == NULL)
11744 {
11745 local_TEF5 = EG (uninitialized_zval_ptr);
11746 local_TEF5->refcount++;
11747 }
11748 zval** p_lhs = &local_TEF5;
11749
11750 zval* rhs;
11751 if (local_TLE4 == NULL)
11752 rhs = EG (uninitialized_zval_ptr);
11753 else
11754 rhs = local_TLE4;
11755
11756 if (*p_lhs != rhs)
11757 {
11758 if ((*p_lhs)->is_ref)
11759 overwrite_lhs (*p_lhs, rhs);
11760 else
11761 {
11762 zval_ptr_dtor (p_lhs);
11763 if (rhs->is_ref)
11764 {
11765 // Take a copy of RHS for LHS
11766 *p_lhs = zvp_clone_ex (rhs);
11767 }
11768 else
11769 {
11770 // Share a copy
11771 rhs->refcount++;
11772 *p_lhs = rhs;
11773 }
11774
11775 }
11776
11777 }
11778 phc_check_invariants (TSRMLS_C);
11779 }
11780 // goto L187;
11781 {
11782 goto L187;
11783 phc_check_invariants (TSRMLS_C);
11784 }
11785 // L186:
11786 L186:;
11787 // $TMIt122 = $this->mVersion;
11788 {
11789 if (local_this == NULL)
11790 {
11791 local_this = EG (uninitialized_zval_ptr);
11792 local_this->refcount++;
11793 }
11794 zval** p_obj = &local_this;
11795
11796 zval field_name;
11797 INIT_ZVAL (field_name);
11798 ZVAL_STRING (&field_name, "mVersion", 0);
11799
11800 // I *think* this is correct, but documentation of the Zend API is scarce :)
11801 zval* field = Z_OBJ_HT_PP(p_obj)->read_property(*p_obj, &field_name, BP_VAR_R TSRMLS_CC);
11802 if (local_TMIt122 == NULL)
11803 {
11804 local_TMIt122 = EG (uninitialized_zval_ptr);
11805 local_TMIt122->refcount++;
11806 }
11807 zval** p_lhs = &local_TMIt122;
11808
11809 write_var (p_lhs, field);
11810 phc_check_invariants (TSRMLS_C);
11811 }
11812 // $TLE79 = isset($TMIt122);
11813 {
11814 if (local_TLE79 == NULL)
11815 {
11816 local_TLE79 = EG (uninitialized_zval_ptr);
11817 local_TLE79->refcount++;
11818 }
11819 zval** p_lhs = &local_TLE79;
11820 zval* value;
11821 if ((*p_lhs)->is_ref)
11822 {
11823 // Always overwrite the current value
11824 value = *p_lhs;
11825 zval_dtor (value);
11826 }
11827 else
11828 {
11829 ALLOC_INIT_ZVAL (value);
11830 zval_ptr_dtor (p_lhs);
11831 *p_lhs = value;
11832 }
11833 ZVAL_BOOL(value, local_TMIt122 != NULL && !ZVAL_IS_NULL(local_TMIt122));
11834 phc_check_invariants (TSRMLS_C);
11835 }
11836 // $TEF5 = !$TLE79;
11837 {
11838 if (local_TEF5 == NULL)
11839 {
11840 local_TEF5 = EG (uninitialized_zval_ptr);
11841 local_TEF5->refcount++;
11842 }
11843 zval** p_lhs = &local_TEF5;
11844
11845 zval* rhs;
11846 if (local_TLE79 == NULL)
11847 rhs = EG (uninitialized_zval_ptr);
11848 else
11849 rhs = local_TLE79;
11850
11851 if (in_copy_on_write (*p_lhs))
11852 {
11853 zval_ptr_dtor (p_lhs);
11854 ALLOC_INIT_ZVAL (*p_lhs);
11855 }
11856
11857 zval old = **p_lhs;
11858 int result_is_operand = (*p_lhs == rhs);
11859 boolean_not_function (*p_lhs, rhs TSRMLS_CC);
11860 if (!result_is_operand)
11861 zval_dtor (&old);
11862 phc_check_invariants (TSRMLS_C);
11863 }
11864 // goto L187;
11865 {
11866 goto L187;
11867 phc_check_invariants (TSRMLS_C);
11868 }
11869 // L187:
11870 L187:;
11871 // $TLE6 = (bool) $TEF5;
11872 {
11873 if (local_TLE6 == NULL)
11874 {
11875 local_TLE6 = EG (uninitialized_zval_ptr);
11876 local_TLE6->refcount++;
11877 }
11878 zval** p_lhs = &local_TLE6;
11879
11880 zval* rhs;
11881 if (local_TEF5 == NULL)
11882 rhs = EG (uninitialized_zval_ptr);
11883 else
11884 rhs = local_TEF5;
11885
11886 if (*p_lhs != rhs)
11887 {
11888 if ((*p_lhs)->is_ref)
11889 overwrite_lhs (*p_lhs, rhs);
11890 else
11891 {
11892 zval_ptr_dtor (p_lhs);
11893 if (rhs->is_ref)
11894 {
11895 // Take a copy of RHS for LHS
11896 *p_lhs = zvp_clone_ex (rhs);
11897 }
11898 else
11899 {
11900 // Share a copy
11901 rhs->refcount++;
11902 *p_lhs = rhs;
11903 }
11904
11905 }
11906
11907 }
11908
11909 assert (IS_BOOL >= 0 && IS_BOOL <= 6);
11910 if ((*p_lhs)->type != IS_BOOL)
11911 {
11912 sep_copy_on_write (p_lhs);
11913 convert_to_boolean (*p_lhs);
11914 }
11915
11916 phc_check_invariants (TSRMLS_C);
11917 }
11918 // if (TLE6) goto L191 else goto L192;
11919 {
11920 zval* p_cond;
11921 if (local_TLE6 == NULL)
11922 p_cond = EG (uninitialized_zval_ptr);
11923 else
11924 p_cond = local_TLE6;
11925
11926 zend_bool bcond = zend_is_true (p_cond);
11927 if (bcond)
11928 goto L191;
11929 else
11930 goto L192;
11931 phc_check_invariants (TSRMLS_C);
11932 }
11933 // L191:
11934 L191:;
11935 // $TEF7 = $TLE6;
11936 {
11937 if (local_TEF7 == NULL)
11938 {
11939 local_TEF7 = EG (uninitialized_zval_ptr);
11940 local_TEF7->refcount++;
11941 }
11942 zval** p_lhs = &local_TEF7;
11943
11944 zval* rhs;
11945 if (local_TLE6 == NULL)
11946 rhs = EG (uninitialized_zval_ptr);
11947 else
11948 rhs = local_TLE6;
11949
11950 if (*p_lhs != rhs)
11951 {
11952 if ((*p_lhs)->is_ref)
11953 overwrite_lhs (*p_lhs, rhs);
11954 else
11955 {
11956 zval_ptr_dtor (p_lhs);
11957 if (rhs->is_ref)
11958 {
11959 // Take a copy of RHS for LHS
11960 *p_lhs = zvp_clone_ex (rhs);
11961 }
11962 else
11963 {
11964 // Share a copy
11965 rhs->refcount++;
11966 *p_lhs = rhs;
11967 }
11968
11969 }
11970
11971 }
11972 phc_check_invariants (TSRMLS_C);
11973 }
11974 // goto L193;
11975 {
11976 goto L193;
11977 phc_check_invariants (TSRMLS_C);
11978 }
11979 // L192:
11980 L192:;
11981 // $TLE80 = Parser::VERSION;
11982 {
11983 // No null-terminator in length for get_constant.
11984 // zend_get_constant always returns a copy of the constant.
11985 if (local_TLE80 == NULL)
11986 {
11987 local_TLE80 = EG (uninitialized_zval_ptr);
11988 local_TLE80->refcount++;
11989 }
11990 zval** p_lhs = &local_TLE80;
11991
11992 if (!(*p_lhs)->is_ref)
11993 {
11994 zval_ptr_dtor (p_lhs);
11995 get_constant ("Parser::VERSION", 15, p_lhs TSRMLS_CC);
11996
11997 }
11998 else
11999 {
12000 zval* constant;
12001 get_constant ("Parser::VERSION", 15, p_lhs TSRMLS_CC);
12002 overwrite_lhs_no_copy (*p_lhs, constant);
12003 safe_free_zval_ptr (constant);
12004
12005 }
12006 phc_check_invariants (TSRMLS_C);
12007 }
12008 // $TLE81 = 'lt';
12009 {
12010 if (local_TLE81 == NULL)
12011 {
12012 local_TLE81 = EG (uninitialized_zval_ptr);
12013 local_TLE81->refcount++;
12014 }
12015 zval** p_lhs = &local_TLE81;
12016
12017 zval* value;
12018 if ((*p_lhs)->is_ref)
12019 {
12020 // Always overwrite the current value
12021 value = *p_lhs;
12022 zval_dtor (value);
12023 }
12024 else
12025 {
12026 ALLOC_INIT_ZVAL (value);
12027 zval_ptr_dtor (p_lhs);
12028 *p_lhs = value;
12029 }
12030
12031 ZVAL_STRINGL(value, "lt", 2, 1);
12032
12033 phc_check_invariants (TSRMLS_C);
12034 }
12035 // $TLE124 = param_is_ref (NULL, "version_compare", 0);
12036 // ;
12037 {
12038 initialize_function_call (&version_compare_fci, &version_compare_fcic, "version_compare", "<unknown>", 0 TSRMLS_CC);
12039 zend_function* signature = version_compare_fcic.function_handler;
12040 zend_arg_info* arg_info = signature->common.arg_info;
12041 int count = 0;
12042 while (arg_info && count < 0)
12043 {
12044 count++;
12045 arg_info++;
12046 }
12047
12048 if (local_TLE124 == NULL)
12049 {
12050 local_TLE124 = EG (uninitialized_zval_ptr);
12051 local_TLE124->refcount++;
12052 }
12053 zval** p_lhs = &local_TLE124;
12054
12055 zval* rhs;
12056 ALLOC_INIT_ZVAL (rhs);
12057 if (arg_info && count == 0)
12058 {
12059 ZVAL_BOOL (rhs, arg_info->pass_by_reference);
12060 }
12061 else
12062 {
12063 ZVAL_BOOL (rhs, signature->common.pass_rest_by_reference);
12064 }
12065 write_var (p_lhs, rhs);
12066 zval_ptr_dtor (&rhs);
12067 phc_check_invariants (TSRMLS_C);
12068 }
12069 // if (TLE124) goto L188 else goto L189;
12070 {
12071 zval* p_cond;
12072 if (local_TLE124 == NULL)
12073 p_cond = EG (uninitialized_zval_ptr);
12074 else
12075 p_cond = local_TLE124;
12076
12077 zend_bool bcond = zend_is_true (p_cond);
12078 if (bcond)
12079 goto L188;
12080 else
12081 goto L189;
12082 phc_check_invariants (TSRMLS_C);
12083 }
12084 // L188:
12085 L188:;
12086 // $TMIt123 =& $this->mVersion;
12087 {
12088 if (local_this == NULL)
12089 {
12090 local_this = EG (uninitialized_zval_ptr);
12091 local_this->refcount++;
12092 }
12093 zval** p_obj = &local_this;
12094
12095 zval field_name;
12096 INIT_ZVAL (field_name);
12097 ZVAL_STRING (&field_name, "mVersion", 0);
12098
12099 zval** field = Z_OBJ_HT_PP(p_obj)->get_property_ptr_ptr(*p_obj, &field_name TSRMLS_CC);
12100 sep_copy_on_write (field);
12101 if (local_TMIt123 == NULL)
12102 {
12103 local_TMIt123 = EG (uninitialized_zval_ptr);
12104 local_TMIt123->refcount++;
12105 }
12106 zval** p_lhs = &local_TMIt123;
12107
12108 copy_into_ref (p_lhs, field);
12109 phc_check_invariants (TSRMLS_C);
12110 }
12111 // goto L190;
12112 {
12113 goto L190;
12114 phc_check_invariants (TSRMLS_C);
12115 }
12116 // L189:
12117 L189:;
12118 // $TMIt123 = $this->mVersion;
12119 {
12120 if (local_this == NULL)
12121 {
12122 local_this = EG (uninitialized_zval_ptr);
12123 local_this->refcount++;
12124 }
12125 zval** p_obj = &local_this;
12126
12127 zval field_name;
12128 INIT_ZVAL (field_name);
12129 ZVAL_STRING (&field_name, "mVersion", 0);
12130
12131 // I *think* this is correct, but documentation of the Zend API is scarce :)
12132 zval* field = Z_OBJ_HT_PP(p_obj)->read_property(*p_obj, &field_name, BP_VAR_R TSRMLS_CC);
12133 if (local_TMIt123 == NULL)
12134 {
12135 local_TMIt123 = EG (uninitialized_zval_ptr);
12136 local_TMIt123->refcount++;
12137 }
12138 zval** p_lhs = &local_TMIt123;
12139
12140 write_var (p_lhs, field);
12141 phc_check_invariants (TSRMLS_C);
12142 }
12143 // goto L190;
12144 {
12145 goto L190;
12146 phc_check_invariants (TSRMLS_C);
12147 }
12148 // L190:
12149 L190:;
12150 // $TEF7 = version_compare($TMIt123, $TLE80, $TLE81);
12151 {
12152 initialize_function_call (&version_compare_fci, &version_compare_fcic, "version_compare", "/home/mdupont/2009/02/introspector/rdfintrospector/mediawiki/trunk/phase3/includes/parser/ParserOutput.php", 142 TSRMLS_CC);
12153 zend_function* signature = version_compare_fcic.function_handler;
12154 zend_arg_info* arg_info = signature->common.arg_info; // optional
12155
12156 int by_ref[3];
12157 int abr_index = 0;
12158 // TODO: find names to replace index
12159 if (arg_info)
12160 {
12161 by_ref[abr_index] = arg_info->pass_by_reference;
12162 arg_info++;
12163 }
12164 else
12165 by_ref[abr_index] = signature->common.pass_rest_by_reference;
12166
12167 abr_index++;
12168 // TODO: find names to replace index
12169 if (arg_info)
12170 {
12171 by_ref[abr_index] = arg_info->pass_by_reference;
12172 arg_info++;
12173 }
12174 else
12175 by_ref[abr_index] = signature->common.pass_rest_by_reference;
12176
12177 abr_index++;
12178 // TODO: find names to replace index
12179 if (arg_info)
12180 {
12181 by_ref[abr_index] = arg_info->pass_by_reference;
12182 arg_info++;
12183 }
12184 else
12185 by_ref[abr_index] = signature->common.pass_rest_by_reference;
12186
12187 abr_index++;
12188
12189
12190 // Setup array of arguments
12191 // TODO: i think arrays of size 0 is an error
12192 int destruct [3];
12193 zval* args [3];
12194 zval** args_ind [3];
12195
12196 int af_index = 0;
12197 destruct[af_index] = 0;
12198 if (by_ref[af_index])
12199 {
12200 if (local_TMIt123 == NULL)
12201 {
12202 local_TMIt123 = EG (uninitialized_zval_ptr);
12203 local_TMIt123->refcount++;
12204 }
12205 zval** p_arg = &local_TMIt123;
12206
12207 args_ind[af_index] = fetch_var_arg_by_ref (p_arg);
12208 assert (!in_copy_on_write (*args_ind[af_index]));
12209 args[af_index] = *args_ind[af_index];
12210 }
12211 else
12212 {
12213 zval* arg;
12214 if (local_TMIt123 == NULL)
12215 arg = EG (uninitialized_zval_ptr);
12216 else
12217 arg = local_TMIt123;
12218
12219 args[af_index] = fetch_var_arg (arg, &destruct[af_index]);
12220 args_ind[af_index] = &args[af_index];
12221 }
12222 af_index++;
12223 destruct[af_index] = 0;
12224 if (by_ref[af_index])
12225 {
12226 if (local_TLE80 == NULL)
12227 {
12228 local_TLE80 = EG (uninitialized_zval_ptr);
12229 local_TLE80->refcount++;
12230 }
12231 zval** p_arg = &local_TLE80;
12232
12233 args_ind[af_index] = fetch_var_arg_by_ref (p_arg);
12234 assert (!in_copy_on_write (*args_ind[af_index]));
12235 args[af_index] = *args_ind[af_index];
12236 }
12237 else
12238 {
12239 zval* arg;
12240 if (local_TLE80 == NULL)
12241 arg = EG (uninitialized_zval_ptr);
12242 else
12243 arg = local_TLE80;
12244
12245 args[af_index] = fetch_var_arg (arg, &destruct[af_index]);
12246 args_ind[af_index] = &args[af_index];
12247 }
12248 af_index++;
12249 destruct[af_index] = 0;
12250 if (by_ref[af_index])
12251 {
12252 if (local_TLE81 == NULL)
12253 {
12254 local_TLE81 = EG (uninitialized_zval_ptr);
12255 local_TLE81->refcount++;
12256 }
12257 zval** p_arg = &local_TLE81;
12258
12259 args_ind[af_index] = fetch_var_arg_by_ref (p_arg);
12260 assert (!in_copy_on_write (*args_ind[af_index]));
12261 args[af_index] = *args_ind[af_index];
12262 }
12263 else
12264 {
12265 zval* arg;
12266 if (local_TLE81 == NULL)
12267 arg = EG (uninitialized_zval_ptr);
12268 else
12269 arg = local_TLE81;
12270
12271 args[af_index] = fetch_var_arg (arg, &destruct[af_index]);
12272 args_ind[af_index] = &args[af_index];
12273 }
12274 af_index++;
12275
12276
12277 phc_setup_error (1, "/home/mdupont/2009/02/introspector/rdfintrospector/mediawiki/trunk/phase3/includes/parser/ParserOutput.php", 142, NULL TSRMLS_CC);
12278
12279 // save existing parameters, in case of recursion
12280 int param_count_save = version_compare_fci.param_count;
12281 zval*** params_save = version_compare_fci.params;
12282 zval** retval_save = version_compare_fci.retval_ptr_ptr;
12283
12284 zval* rhs = NULL;
12285
12286 // set up params
12287 version_compare_fci.params = args_ind;
12288 version_compare_fci.param_count = 3;
12289 version_compare_fci.retval_ptr_ptr = &rhs;
12290
12291 // call the function
12292 int success = zend_call_function (&version_compare_fci, &version_compare_fcic TSRMLS_CC);
12293 assert(success == SUCCESS);
12294
12295 // restore params
12296 version_compare_fci.params = params_save;
12297 version_compare_fci.param_count = param_count_save;
12298 version_compare_fci.retval_ptr_ptr = retval_save;
12299
12300 // unset the errors
12301 phc_setup_error (0, NULL, 0, NULL TSRMLS_CC);
12302
12303 int i;
12304 for (i = 0; i < 3; i++)
12305 {
12306 if (destruct[i])
12307 {
12308 assert (destruct[i]);
12309 zval_ptr_dtor (args_ind[i]);
12310 }
12311 }
12312
12313
12314 // When the Zend engine returns by reference, it allocates a zval into
12315 // retval_ptr_ptr. To return by reference, the callee writes into the
12316 // retval_ptr_ptr, freeing the allocated value as it does. (Note, it may
12317 // not actually return anything). So the zval returned - whether we return
12318 // it, or it is the allocated zval - has a refcount of 1.
12319
12320 // The caller is responsible for cleaning that up (note, this is unaffected
12321 // by whether it is added to some COW set).
12322
12323 // For reasons unknown, the Zend API resets the refcount and is_ref fields
12324 // of the return value after the function returns (unless the callee is
12325 // interpreted). If the function is supposed to return by reference, this
12326 // loses the refcount. This only happens when non-interpreted code is
12327 // called. We work around it, when compiled code is called, by saving the
12328 // refcount into SAVED_REFCOUNT, in the return statement. The downside is
12329 // that we may create an error if our code is called by a callback, and
12330 // returns by reference, and the callback returns by reference. At least
12331 // this is an obscure case.
12332 if(signature->common.return_reference && signature->type != ZEND_USER_FUNCTION)
12333 {
12334 assert (rhs != EG(uninitialized_zval_ptr));
12335 rhs->is_ref = 1;
12336 if (saved_refcount != 0)
12337 {
12338 rhs->refcount = saved_refcount;
12339 }
12340 rhs->refcount++;
12341 }
12342 saved_refcount = 0; // for 'obscure cases'
12343
12344 if (local_TEF7 == NULL)
12345 {
12346 local_TEF7 = EG (uninitialized_zval_ptr);
12347 local_TEF7->refcount++;
12348 }
12349 zval** p_lhs = &local_TEF7;
12350
12351 write_var (p_lhs, rhs);
12352
12353
12354 zval_ptr_dtor (&rhs);
12355 if(signature->common.return_reference && signature->type != ZEND_USER_FUNCTION)
12356 zval_ptr_dtor (&rhs);
12357
12358 phc_check_invariants (TSRMLS_C);
12359 }
12360 // goto L193;
12361 {
12362 goto L193;
12363 phc_check_invariants (TSRMLS_C);
12364 }
12365 // L193:
12366 L193:;
12367 // $TLE82 = (bool) $TEF7;
12368 {
12369 if (local_TLE82 == NULL)
12370 {
12371 local_TLE82 = EG (uninitialized_zval_ptr);
12372 local_TLE82->refcount++;
12373 }
12374 zval** p_lhs = &local_TLE82;
12375
12376 zval* rhs;
12377 if (local_TEF7 == NULL)
12378 rhs = EG (uninitialized_zval_ptr);
12379 else
12380 rhs = local_TEF7;
12381
12382 if (*p_lhs != rhs)
12383 {
12384 if ((*p_lhs)->is_ref)
12385 overwrite_lhs (*p_lhs, rhs);
12386 else
12387 {
12388 zval_ptr_dtor (p_lhs);
12389 if (rhs->is_ref)
12390 {
12391 // Take a copy of RHS for LHS
12392 *p_lhs = zvp_clone_ex (rhs);
12393 }
12394 else
12395 {
12396 // Share a copy
12397 rhs->refcount++;
12398 *p_lhs = rhs;
12399 }
12400
12401 }
12402
12403 }
12404
12405 assert (IS_BOOL >= 0 && IS_BOOL <= 6);
12406 if ((*p_lhs)->type != IS_BOOL)
12407 {
12408 sep_copy_on_write (p_lhs);
12409 convert_to_boolean (*p_lhs);
12410 }
12411
12412 phc_check_invariants (TSRMLS_C);
12413 }
12414 // return $TLE82;
12415 {
12416 zval* rhs;
12417 if (local_TLE82 == NULL)
12418 rhs = EG (uninitialized_zval_ptr);
12419 else
12420 rhs = local_TLE82;
12421
12422 // Run-time return by reference has different semantics to compile-time.
12423 // If the function has CTRBR and RTRBR, the the assignment will be
12424 // reference. If one or the other is return-by-copy, the result will be
12425 // by copy. Its a question of whether its separated at return-time (which
12426 // we do here) or at the call-site.
12427 return_value->value = rhs->value;
12428 return_value->type = rhs->type;
12429 zval_copy_ctor (return_value);
12430 goto end_of_function;
12431 phc_check_invariants (TSRMLS_C);
12432 }
12433 // Method exit
12434 end_of_function:__attribute__((unused));
12435 if (local_TEF1 != NULL)
12436 {
12437 zval_ptr_dtor (&local_TEF1);
12438 }
12439 if (local_TEF3 != NULL)
12440 {
12441 zval_ptr_dtor (&local_TEF3);
12442 }
12443 if (local_TEF5 != NULL)
12444 {
12445 zval_ptr_dtor (&local_TEF5);
12446 }
12447 if (local_TEF7 != NULL)
12448 {
12449 zval_ptr_dtor (&local_TEF7);
12450 }
12451 if (local_TLE0 != NULL)
12452 {
12453 zval_ptr_dtor (&local_TLE0);
12454 }
12455 if (local_TLE124 != NULL)
12456 {
12457 zval_ptr_dtor (&local_TLE124);
12458 }
12459 if (local_TLE2 != NULL)
12460 {
12461 zval_ptr_dtor (&local_TLE2);
12462 }
12463 if (local_TLE4 != NULL)
12464 {
12465 zval_ptr_dtor (&local_TLE4);
12466 }
12467 if (local_TLE6 != NULL)
12468 {
12469 zval_ptr_dtor (&local_TLE6);
12470 }
12471 if (local_TLE75 != NULL)
12472 {
12473 zval_ptr_dtor (&local_TLE75);
12474 }
12475 if (local_TLE76 != NULL)
12476 {
12477 zval_ptr_dtor (&local_TLE76);
12478 }
12479 if (local_TLE77 != NULL)
12480 {
12481 zval_ptr_dtor (&local_TLE77);
12482 }
12483 if (local_TLE78 != NULL)
12484 {
12485 zval_ptr_dtor (&local_TLE78);
12486 }
12487 if (local_TLE79 != NULL)
12488 {
12489 zval_ptr_dtor (&local_TLE79);
12490 }
12491 if (local_TLE80 != NULL)
12492 {
12493 zval_ptr_dtor (&local_TLE80);
12494 }
12495 if (local_TLE81 != NULL)
12496 {
12497 zval_ptr_dtor (&local_TLE81);
12498 }
12499 if (local_TLE82 != NULL)
12500 {
12501 zval_ptr_dtor (&local_TLE82);
12502 }
12503 if (local_TMIt122 != NULL)
12504 {
12505 zval_ptr_dtor (&local_TMIt122);
12506 }
12507 if (local_TMIt123 != NULL)
12508 {
12509 zval_ptr_dtor (&local_TMIt123);
12510 }
12511 if (local_touched != NULL)
12512 {
12513 zval_ptr_dtor (&local_touched);
12514 }
12515 if (local_wgCacheEpoch != NULL)
12516 {
12517 zval_ptr_dtor (&local_wgCacheEpoch);
12518 }
12519 }
12520 // function addheaditem($section, $tag = False)
12521 // {
12522 // $TLE83 = False;
12523 // $TLE84 = ($tag !== $TLE83);
12524 // if (TLE84) goto L194 else goto L195;
12525 // L194:
12526 // $TSt85 =& $this->mHeadItems;
12527 // $TSt85[$tag] = $section;
12528 // goto L196;
12529 // L195:
12530 // $TSt86 =& $this->mHeadItems;
12531 // $TSt86[] = $section;
12532 // goto L196;
12533 // L196:
12534 // }
12535 PHP_METHOD(ParserOutput, addheaditem)
12536 {
12537 zval* local_TLE83 = NULL;
12538 zval* local_TLE84 = NULL;
12539 zval* local_TSt85 = NULL;
12540 zval* local_TSt86 = NULL;
12541 zval* local_section = NULL;
12542 zval* local_tag = NULL;
12543 zval* local_this = getThis();
12544 // Add all parameters as local variables
12545 {
12546 int num_args = ZEND_NUM_ARGS ();
12547 zval* params[2];
12548 zend_get_parameters_array(0, num_args, params);
12549 // param 0
12550 params[0]->refcount++;
12551 if (local_section != NULL)
12552 {
12553 zval_ptr_dtor (&local_section);
12554 }
12555 local_section = params[0];
12556 // param 1
12557 if (num_args <= 1)
12558 {
12559 zval* default_value;
12560 {
12561 zval* local___static_value__ = NULL;
12562 // $__static_value__ = False;
12563 {
12564 if (local___static_value__ == NULL)
12565 {
12566 local___static_value__ = EG (uninitialized_zval_ptr);
12567 local___static_value__->refcount++;
12568 }
12569 zval** p_lhs = &local___static_value__;
12570
12571 zval* value;
12572 if ((*p_lhs)->is_ref)
12573 {
12574 // Always overwrite the current value
12575 value = *p_lhs;
12576 zval_dtor (value);
12577 }
12578 else
12579 {
12580 ALLOC_INIT_ZVAL (value);
12581 zval_ptr_dtor (p_lhs);
12582 *p_lhs = value;
12583 }
12584
12585 ZVAL_BOOL (value, 0);
12586
12587 phc_check_invariants (TSRMLS_C);
12588 }
12589 default_value = local___static_value__;
12590 assert(!default_value->is_ref);
12591 default_value->refcount++;
12592 if (local___static_value__ != NULL)
12593 {
12594 zval_ptr_dtor (&local___static_value__);
12595 }
12596 }
12597 default_value->refcount--;
12598 params[1] = default_value;
12599 }
12600 params[1]->refcount++;
12601 if (local_tag != NULL)
12602 {
12603 zval_ptr_dtor (&local_tag);
12604 }
12605 local_tag = params[1];
12606 }
12607 // Function body
12608 // $TLE83 = False;
12609 {
12610 if (local_TLE83 == NULL)
12611 {
12612 local_TLE83 = EG (uninitialized_zval_ptr);
12613 local_TLE83->refcount++;
12614 }
12615 zval** p_lhs = &local_TLE83;
12616
12617 zval* value;
12618 if ((*p_lhs)->is_ref)
12619 {
12620 // Always overwrite the current value
12621 value = *p_lhs;
12622 zval_dtor (value);
12623 }
12624 else
12625 {
12626 ALLOC_INIT_ZVAL (value);
12627 zval_ptr_dtor (p_lhs);
12628 *p_lhs = value;
12629 }
12630
12631 ZVAL_BOOL (value, 0);
12632
12633 phc_check_invariants (TSRMLS_C);
12634 }
12635 // $TLE84 = ($tag !== $TLE83);
12636 {
12637 if (local_TLE84 == NULL)
12638 {
12639 local_TLE84 = EG (uninitialized_zval_ptr);
12640 local_TLE84->refcount++;
12641 }
12642 zval** p_lhs = &local_TLE84;
12643
12644 zval* left;
12645 if (local_tag == NULL)
12646 left = EG (uninitialized_zval_ptr);
12647 else
12648 left = local_tag;
12649
12650 zval* right;
12651 if (local_TLE83 == NULL)
12652 right = EG (uninitialized_zval_ptr);
12653 else
12654 right = local_TLE83;
12655
12656 if (in_copy_on_write (*p_lhs))
12657 {
12658 zval_ptr_dtor (p_lhs);
12659 ALLOC_INIT_ZVAL (*p_lhs);
12660 }
12661
12662 zval old = **p_lhs;
12663 int result_is_operand = (*p_lhs == left || *p_lhs == right);
12664 is_not_identical_function (*p_lhs, left, right TSRMLS_CC);
12665
12666 // If the result is one of the operands, the operator function
12667 // will already have cleaned up the result
12668 if (!result_is_operand)
12669 zval_dtor (&old);
12670 phc_check_invariants (TSRMLS_C);
12671 }
12672 // if (TLE84) goto L194 else goto L195;
12673 {
12674 zval* p_cond;
12675 if (local_TLE84 == NULL)
12676 p_cond = EG (uninitialized_zval_ptr);
12677 else
12678 p_cond = local_TLE84;
12679
12680 zend_bool bcond = zend_is_true (p_cond);
12681 if (bcond)
12682 goto L194;
12683 else
12684 goto L195;
12685 phc_check_invariants (TSRMLS_C);
12686 }
12687 // L194:
12688 L194:;
12689 // $TSt85 =& $this->mHeadItems;
12690 {
12691 if (local_this == NULL)
12692 {
12693 local_this = EG (uninitialized_zval_ptr);
12694 local_this->refcount++;
12695 }
12696 zval** p_obj = &local_this;
12697
12698 zval field_name;
12699 INIT_ZVAL (field_name);
12700 ZVAL_STRING (&field_name, "mHeadItems", 0);
12701
12702 zval** field = Z_OBJ_HT_PP(p_obj)->get_property_ptr_ptr(*p_obj, &field_name TSRMLS_CC);
12703 sep_copy_on_write (field);
12704 if (local_TSt85 == NULL)
12705 {
12706 local_TSt85 = EG (uninitialized_zval_ptr);
12707 local_TSt85->refcount++;
12708 }
12709 zval** p_lhs = &local_TSt85;
12710
12711 copy_into_ref (p_lhs, field);
12712 phc_check_invariants (TSRMLS_C);
12713 }
12714 // $TSt85[$tag] = $section;
12715 {
12716 if (local_TSt85 == NULL)
12717 {
12718 local_TSt85 = EG (uninitialized_zval_ptr);
12719 local_TSt85->refcount++;
12720 }
12721 zval** p_array = &local_TSt85;
12722
12723 check_array_type (p_array TSRMLS_CC);
12724
12725 zval* index;
12726 if (local_tag == NULL)
12727 index = EG (uninitialized_zval_ptr);
12728 else
12729 index = local_tag;
12730
12731
12732 // String indexing
12733 if (Z_TYPE_PP (p_array) == IS_STRING && Z_STRLEN_PP (p_array) > 0)
12734 {
12735 zval* rhs;
12736 if (local_section == NULL)
12737 rhs = EG (uninitialized_zval_ptr);
12738 else
12739 rhs = local_section;
12740
12741 write_string_index (p_array, index, rhs TSRMLS_CC);
12742 }
12743 else if (Z_TYPE_PP (p_array) == IS_ARRAY)
12744 {
12745 zval** p_lhs = get_ht_entry (p_array, index TSRMLS_CC);
12746 zval* rhs;
12747 if (local_section == NULL)
12748 rhs = EG (uninitialized_zval_ptr);
12749 else
12750 rhs = local_section;
12751
12752 if (*p_lhs != rhs)
12753 {
12754 write_var (p_lhs, rhs);
12755 }
12756 }
12757 phc_check_invariants (TSRMLS_C);
12758 }
12759 // goto L196;
12760 {
12761 goto L196;
12762 phc_check_invariants (TSRMLS_C);
12763 }
12764 // L195:
12765 L195:;
12766 // $TSt86 =& $this->mHeadItems;
12767 {
12768 if (local_this == NULL)
12769 {
12770 local_this = EG (uninitialized_zval_ptr);
12771 local_this->refcount++;
12772 }
12773 zval** p_obj = &local_this;
12774
12775 zval field_name;
12776 INIT_ZVAL (field_name);
12777 ZVAL_STRING (&field_name, "mHeadItems", 0);
12778
12779 zval** field = Z_OBJ_HT_PP(p_obj)->get_property_ptr_ptr(*p_obj, &field_name TSRMLS_CC);
12780 sep_copy_on_write (field);
12781 if (local_TSt86 == NULL)
12782 {
12783 local_TSt86 = EG (uninitialized_zval_ptr);
12784 local_TSt86->refcount++;
12785 }
12786 zval** p_lhs = &local_TSt86;
12787
12788 copy_into_ref (p_lhs, field);
12789 phc_check_invariants (TSRMLS_C);
12790 }
12791 // $TSt86[] = $section;
12792 {
12793 if (local_TSt86 == NULL)
12794 {
12795 local_TSt86 = EG (uninitialized_zval_ptr);
12796 local_TSt86->refcount++;
12797 }
12798 zval** p_array = &local_TSt86;
12799
12800 // Push EG(uninit) and get a pointer to the symtable entry
12801 zval** p_lhs = push_and_index_ht (p_array TSRMLS_CC);
12802 if (p_lhs != NULL)
12803 {
12804 zval* rhs;
12805 if (local_section == NULL)
12806 rhs = EG (uninitialized_zval_ptr);
12807 else
12808 rhs = local_section;
12809
12810 if (*p_lhs != rhs)
12811 write_var (p_lhs, rhs);
12812 }
12813 // I think if this is NULL, then the LHS is a bool or similar, and you cant
12814 // push onto it.
12815 phc_check_invariants (TSRMLS_C);
12816 }
12817 // goto L196;
12818 {
12819 goto L196;
12820 phc_check_invariants (TSRMLS_C);
12821 }
12822 // L196:
12823 L196:;
12824 // Method exit
12825 end_of_function:__attribute__((unused));
12826 if (local_TLE83 != NULL)
12827 {
12828 zval_ptr_dtor (&local_TLE83);
12829 }
12830 if (local_TLE84 != NULL)
12831 {
12832 zval_ptr_dtor (&local_TLE84);
12833 }
12834 if (local_TSt85 != NULL)
12835 {
12836 zval_ptr_dtor (&local_TSt85);
12837 }
12838 if (local_TSt86 != NULL)
12839 {
12840 zval_ptr_dtor (&local_TSt86);
12841 }
12842 if (local_section != NULL)
12843 {
12844 zval_ptr_dtor (&local_section);
12845 }
12846 if (local_tag != NULL)
12847 {
12848 zval_ptr_dtor (&local_tag);
12849 }
12850 }
12851 // public function setdisplaytitle($text)
12852 // {
12853 // $this->displayTitle = $text;
12854 // }
12855 PHP_METHOD(ParserOutput, setdisplaytitle)
12856 {
12857 zval* local_text = NULL;
12858 zval* local_this = getThis();
12859 // Add all parameters as local variables
12860 {
12861 int num_args = ZEND_NUM_ARGS ();
12862 zval* params[1];
12863 zend_get_parameters_array(0, num_args, params);
12864 // param 0
12865 params[0]->refcount++;
12866 if (local_text != NULL)
12867 {
12868 zval_ptr_dtor (&local_text);
12869 }
12870 local_text = params[0];
12871 }
12872 // Function body
12873 // $this->displayTitle = $text;
12874 {
12875 if (local_this == NULL)
12876 {
12877 local_this = EG (uninitialized_zval_ptr);
12878 local_this->refcount++;
12879 }
12880 zval** p_obj = &local_this;
12881
12882 zval* rhs;
12883 if (local_text == NULL)
12884 rhs = EG (uninitialized_zval_ptr);
12885 else
12886 rhs = local_text;
12887
12888 zval field_name;
12889 INIT_ZVAL (field_name);
12890 ZVAL_STRING (&field_name, "displayTitle", 0);
12891
12892 Z_OBJ_HT_PP(p_obj)->write_property(*p_obj, &field_name, rhs TSRMLS_CC);
12893 phc_check_invariants (TSRMLS_C);
12894 }
12895 // Method exit
12896 end_of_function:__attribute__((unused));
12897 if (local_text != NULL)
12898 {
12899 zval_ptr_dtor (&local_text);
12900 }
12901 }
12902 // public function getdisplaytitle()
12903 // {
12904 // $TSt87 = $this->displayTitle;
12905 // return $TSt87;
12906 // }
12907 PHP_METHOD(ParserOutput, getdisplaytitle)
12908 {
12909 zval* local_TSt87 = NULL;
12910 zval* local_this = getThis();
12911 // Function body
12912 // $TSt87 = $this->displayTitle;
12913 {
12914 if (local_this == NULL)
12915 {
12916 local_this = EG (uninitialized_zval_ptr);
12917 local_this->refcount++;
12918 }
12919 zval** p_obj = &local_this;
12920
12921 zval field_name;
12922 INIT_ZVAL (field_name);
12923 ZVAL_STRING (&field_name, "displayTitle", 0);
12924
12925 // I *think* this is correct, but documentation of the Zend API is scarce :)
12926 zval* field = Z_OBJ_HT_PP(p_obj)->read_property(*p_obj, &field_name, BP_VAR_R TSRMLS_CC);
12927 if (local_TSt87 == NULL)
12928 {
12929 local_TSt87 = EG (uninitialized_zval_ptr);
12930 local_TSt87->refcount++;
12931 }
12932 zval** p_lhs = &local_TSt87;
12933
12934 write_var (p_lhs, field);
12935 phc_check_invariants (TSRMLS_C);
12936 }
12937 // return $TSt87;
12938 {
12939 zval* rhs;
12940 if (local_TSt87 == NULL)
12941 rhs = EG (uninitialized_zval_ptr);
12942 else
12943 rhs = local_TSt87;
12944
12945 // Run-time return by reference has different semantics to compile-time.
12946 // If the function has CTRBR and RTRBR, the the assignment will be
12947 // reference. If one or the other is return-by-copy, the result will be
12948 // by copy. Its a question of whether its separated at return-time (which
12949 // we do here) or at the call-site.
12950 return_value->value = rhs->value;
12951 return_value->type = rhs->type;
12952 zval_copy_ctor (return_value);
12953 goto end_of_function;
12954 phc_check_invariants (TSRMLS_C);
12955 }
12956 // Method exit
12957 end_of_function:__attribute__((unused));
12958 if (local_TSt87 != NULL)
12959 {
12960 zval_ptr_dtor (&local_TSt87);
12961 }
12962 }
12963 // public function setflag($flag)
12964 // {
12965 // $TSt88 =& $this->mFlags;
12966 // $TLE89 = True;
12967 // $TSt88[$flag] = $TLE89;
12968 // }
12969 PHP_METHOD(ParserOutput, setflag)
12970 {
12971 zval* local_TLE89 = NULL;
12972 zval* local_TSt88 = NULL;
12973 zval* local_flag = NULL;
12974 zval* local_this = getThis();
12975 // Add all parameters as local variables
12976 {
12977 int num_args = ZEND_NUM_ARGS ();
12978 zval* params[1];
12979 zend_get_parameters_array(0, num_args, params);
12980 // param 0
12981 params[0]->refcount++;
12982 if (local_flag != NULL)
12983 {
12984 zval_ptr_dtor (&local_flag);
12985 }
12986 local_flag = params[0];
12987 }
12988 // Function body
12989 // $TSt88 =& $this->mFlags;
12990 {
12991 if (local_this == NULL)
12992 {
12993 local_this = EG (uninitialized_zval_ptr);
12994 local_this->refcount++;
12995 }
12996 zval** p_obj = &local_this;
12997
12998 zval field_name;
12999 INIT_ZVAL (field_name);
13000 ZVAL_STRING (&field_name, "mFlags", 0);
13001
13002 zval** field = Z_OBJ_HT_PP(p_obj)->get_property_ptr_ptr(*p_obj, &field_name TSRMLS_CC);
13003 sep_copy_on_write (field);
13004 if (local_TSt88 == NULL)
13005 {
13006 local_TSt88 = EG (uninitialized_zval_ptr);
13007 local_TSt88->refcount++;
13008 }
13009 zval** p_lhs = &local_TSt88;
13010
13011 copy_into_ref (p_lhs, field);
13012 phc_check_invariants (TSRMLS_C);
13013 }
13014 // $TLE89 = True;
13015 {
13016 if (local_TLE89 == NULL)
13017 {
13018 local_TLE89 = EG (uninitialized_zval_ptr);
13019 local_TLE89->refcount++;
13020 }
13021 zval** p_lhs = &local_TLE89;
13022
13023 zval* value;
13024 if ((*p_lhs)->is_ref)
13025 {
13026 // Always overwrite the current value
13027 value = *p_lhs;
13028 zval_dtor (value);
13029 }
13030 else
13031 {
13032 ALLOC_INIT_ZVAL (value);
13033 zval_ptr_dtor (p_lhs);
13034 *p_lhs = value;
13035 }
13036
13037 ZVAL_BOOL (value, 1);
13038
13039 phc_check_invariants (TSRMLS_C);
13040 }
13041 // $TSt88[$flag] = $TLE89;
13042 {
13043 if (local_TSt88 == NULL)
13044 {
13045 local_TSt88 = EG (uninitialized_zval_ptr);
13046 local_TSt88->refcount++;
13047 }
13048 zval** p_array = &local_TSt88;
13049
13050 check_array_type (p_array TSRMLS_CC);
13051
13052 zval* index;
13053 if (local_flag == NULL)
13054 index = EG (uninitialized_zval_ptr);
13055 else
13056 index = local_flag;
13057
13058
13059 // String indexing
13060 if (Z_TYPE_PP (p_array) == IS_STRING && Z_STRLEN_PP (p_array) > 0)
13061 {
13062 zval* rhs;
13063 if (local_TLE89 == NULL)
13064 rhs = EG (uninitialized_zval_ptr);
13065 else
13066 rhs = local_TLE89;
13067
13068 write_string_index (p_array, index, rhs TSRMLS_CC);
13069 }
13070 else if (Z_TYPE_PP (p_array) == IS_ARRAY)
13071 {
13072 zval** p_lhs = get_ht_entry (p_array, index TSRMLS_CC);
13073 zval* rhs;
13074 if (local_TLE89 == NULL)
13075 rhs = EG (uninitialized_zval_ptr);
13076 else
13077 rhs = local_TLE89;
13078
13079 if (*p_lhs != rhs)
13080 {
13081 write_var (p_lhs, rhs);
13082 }
13083 }
13084 phc_check_invariants (TSRMLS_C);
13085 }
13086 // Method exit
13087 end_of_function:__attribute__((unused));
13088 if (local_TLE89 != NULL)
13089 {
13090 zval_ptr_dtor (&local_TLE89);
13091 }
13092 if (local_TSt88 != NULL)
13093 {
13094 zval_ptr_dtor (&local_TSt88);
13095 }
13096 if (local_flag != NULL)
13097 {
13098 zval_ptr_dtor (&local_flag);
13099 }
13100 }
13101 // public function getflag($flag)
13102 // {
13103 // $TMIt125 = $this->mFlags;
13104 // $TLE90 = isset($TMIt125[$flag]);
13105 // return $TLE90;
13106 // }
13107 PHP_METHOD(ParserOutput, getflag)
13108 {
13109 zval* local_TLE90 = NULL;
13110 zval* local_TMIt125 = NULL;
13111 zval* local_flag = NULL;
13112 zval* local_this = getThis();
13113 // Add all parameters as local variables
13114 {
13115 int num_args = ZEND_NUM_ARGS ();
13116 zval* params[1];
13117 zend_get_parameters_array(0, num_args, params);
13118 // param 0
13119 params[0]->refcount++;
13120 if (local_flag != NULL)
13121 {
13122 zval_ptr_dtor (&local_flag);
13123 }
13124 local_flag = params[0];
13125 }
13126 // Function body
13127 // $TMIt125 = $this->mFlags;
13128 {
13129 if (local_this == NULL)
13130 {
13131 local_this = EG (uninitialized_zval_ptr);
13132 local_this->refcount++;
13133 }
13134 zval** p_obj = &local_this;
13135
13136 zval field_name;
13137 INIT_ZVAL (field_name);
13138 ZVAL_STRING (&field_name, "mFlags", 0);
13139
13140 // I *think* this is correct, but documentation of the Zend API is scarce :)
13141 zval* field = Z_OBJ_HT_PP(p_obj)->read_property(*p_obj, &field_name, BP_VAR_R TSRMLS_CC);
13142 if (local_TMIt125 == NULL)
13143 {
13144 local_TMIt125 = EG (uninitialized_zval_ptr);
13145 local_TMIt125->refcount++;
13146 }
13147 zval** p_lhs = &local_TMIt125;
13148
13149 write_var (p_lhs, field);
13150 phc_check_invariants (TSRMLS_C);
13151 }
13152 // $TLE90 = isset($TMIt125[$flag]);
13153 {
13154 if (local_TLE90 == NULL)
13155 {
13156 local_TLE90 = EG (uninitialized_zval_ptr);
13157 local_TLE90->refcount++;
13158 }
13159 zval** p_lhs = &local_TLE90;
13160 zval* value;
13161 if ((*p_lhs)->is_ref)
13162 {
13163 // Always overwrite the current value
13164 value = *p_lhs;
13165 zval_dtor (value);
13166 }
13167 else
13168 {
13169 ALLOC_INIT_ZVAL (value);
13170 zval_ptr_dtor (p_lhs);
13171 *p_lhs = value;
13172 }
13173 if (local_TMIt125 == NULL)
13174 {
13175 local_TMIt125 = EG (uninitialized_zval_ptr);
13176 local_TMIt125->refcount++;
13177 }
13178 zval** u_array = &local_TMIt125;
13179 zval* u_index;
13180 if (local_flag == NULL)
13181 {
13182 u_index = EG (uninitialized_zval_ptr);
13183 }
13184 else
13185 {
13186 u_index = local_flag;
13187 }
13188 ZVAL_BOOL(value, isset_array (u_array, u_index));
13189 phc_check_invariants (TSRMLS_C);
13190 }
13191 // return $TLE90;
13192 {
13193 zval* rhs;
13194 if (local_TLE90 == NULL)
13195 rhs = EG (uninitialized_zval_ptr);
13196 else
13197 rhs = local_TLE90;
13198
13199 // Run-time return by reference has different semantics to compile-time.
13200 // If the function has CTRBR and RTRBR, the the assignment will be
13201 // reference. If one or the other is return-by-copy, the result will be
13202 // by copy. Its a question of whether its separated at return-time (which
13203 // we do here) or at the call-site.
13204 return_value->value = rhs->value;
13205 return_value->type = rhs->type;
13206 zval_copy_ctor (return_value);
13207 goto end_of_function;
13208 phc_check_invariants (TSRMLS_C);
13209 }
13210 // Method exit
13211 end_of_function:__attribute__((unused));
13212 if (local_TLE90 != NULL)
13213 {
13214 zval_ptr_dtor (&local_TLE90);
13215 }
13216 if (local_TMIt125 != NULL)
13217 {
13218 zval_ptr_dtor (&local_TMIt125);
13219 }
13220 if (local_flag != NULL)
13221 {
13222 zval_ptr_dtor (&local_flag);
13223 }
13224 }
13225 // public function setproperty($name, $value)
13226 // {
13227 // $TSt91 =& $this->mProperties;
13228 // $TSt91[$name] = $value;
13229 // }
13230 PHP_METHOD(ParserOutput, setproperty)
13231 {
13232 zval* local_TSt91 = NULL;
13233 zval* local_name = NULL;
13234 zval* local_this = getThis();
13235 zval* local_value = NULL;
13236 // Add all parameters as local variables
13237 {
13238 int num_args = ZEND_NUM_ARGS ();
13239 zval* params[2];
13240 zend_get_parameters_array(0, num_args, params);
13241 // param 0
13242 params[0]->refcount++;
13243 if (local_name != NULL)
13244 {
13245 zval_ptr_dtor (&local_name);
13246 }
13247 local_name = params[0];
13248 // param 1
13249 params[1]->refcount++;
13250 if (local_value != NULL)
13251 {
13252 zval_ptr_dtor (&local_value);
13253 }
13254 local_value = params[1];
13255 }
13256 // Function body
13257 // $TSt91 =& $this->mProperties;
13258 {
13259 if (local_this == NULL)
13260 {
13261 local_this = EG (uninitialized_zval_ptr);
13262 local_this->refcount++;
13263 }
13264 zval** p_obj = &local_this;
13265
13266 zval field_name;
13267 INIT_ZVAL (field_name);
13268 ZVAL_STRING (&field_name, "mProperties", 0);
13269
13270 zval** field = Z_OBJ_HT_PP(p_obj)->get_property_ptr_ptr(*p_obj, &field_name TSRMLS_CC);
13271 sep_copy_on_write (field);
13272 if (local_TSt91 == NULL)
13273 {
13274 local_TSt91 = EG (uninitialized_zval_ptr);
13275 local_TSt91->refcount++;
13276 }
13277 zval** p_lhs = &local_TSt91;
13278
13279 copy_into_ref (p_lhs, field);
13280 phc_check_invariants (TSRMLS_C);
13281 }
13282 // $TSt91[$name] = $value;
13283 {
13284 if (local_TSt91 == NULL)
13285 {
13286 local_TSt91 = EG (uninitialized_zval_ptr);
13287 local_TSt91->refcount++;
13288 }
13289 zval** p_array = &local_TSt91;
13290
13291 check_array_type (p_array TSRMLS_CC);
13292
13293 zval* index;
13294 if (local_name == NULL)
13295 index = EG (uninitialized_zval_ptr);
13296 else
13297 index = local_name;
13298
13299
13300 // String indexing
13301 if (Z_TYPE_PP (p_array) == IS_STRING && Z_STRLEN_PP (p_array) > 0)
13302 {
13303 zval* rhs;
13304 if (local_value == NULL)
13305 rhs = EG (uninitialized_zval_ptr);
13306 else
13307 rhs = local_value;
13308
13309 write_string_index (p_array, index, rhs TSRMLS_CC);
13310 }
13311 else if (Z_TYPE_PP (p_array) == IS_ARRAY)
13312 {
13313 zval** p_lhs = get_ht_entry (p_array, index TSRMLS_CC);
13314 zval* rhs;
13315 if (local_value == NULL)
13316 rhs = EG (uninitialized_zval_ptr);
13317 else
13318 rhs = local_value;
13319
13320 if (*p_lhs != rhs)
13321 {
13322 write_var (p_lhs, rhs);
13323 }
13324 }
13325 phc_check_invariants (TSRMLS_C);
13326 }
13327 // Method exit
13328 end_of_function:__attribute__((unused));
13329 if (local_TSt91 != NULL)
13330 {
13331 zval_ptr_dtor (&local_TSt91);
13332 }
13333 if (local_name != NULL)
13334 {
13335 zval_ptr_dtor (&local_name);
13336 }
13337 if (local_value != NULL)
13338 {
13339 zval_ptr_dtor (&local_value);
13340 }
13341 }
13342 // public function getproperty($name)
13343 // {
13344 // $TMIt126 = $this->mProperties;
13345 // $TLE92 = isset($TMIt126[$name]);
13346 // if (TLE92) goto L197 else goto L198;
13347 // L197:
13348 // $TSt93 = $this->mProperties;
13349 // $TSi94 = $TSt93[$name];
13350 // $TEF8 = $TSi94;
13351 // goto L199;
13352 // L198:
13353 // $TEF8 = False;
13354 // goto L199;
13355 // L199:
13356 // return $TEF8;
13357 // }
13358 PHP_METHOD(ParserOutput, getproperty)
13359 {
13360 zval* local_TEF8 = NULL;
13361 zval* local_TLE92 = NULL;
13362 zval* local_TMIt126 = NULL;
13363 zval* local_TSi94 = NULL;
13364 zval* local_TSt93 = NULL;
13365 zval* local_name = NULL;
13366 zval* local_this = getThis();
13367 // Add all parameters as local variables
13368 {
13369 int num_args = ZEND_NUM_ARGS ();
13370 zval* params[1];
13371 zend_get_parameters_array(0, num_args, params);
13372 // param 0
13373 params[0]->refcount++;
13374 if (local_name != NULL)
13375 {
13376 zval_ptr_dtor (&local_name);
13377 }
13378 local_name = params[0];
13379 }
13380 // Function body
13381 // $TMIt126 = $this->mProperties;
13382 {
13383 if (local_this == NULL)
13384 {
13385 local_this = EG (uninitialized_zval_ptr);
13386 local_this->refcount++;
13387 }
13388 zval** p_obj = &local_this;
13389
13390 zval field_name;
13391 INIT_ZVAL (field_name);
13392 ZVAL_STRING (&field_name, "mProperties", 0);
13393
13394 // I *think* this is correct, but documentation of the Zend API is scarce :)
13395 zval* field = Z_OBJ_HT_PP(p_obj)->read_property(*p_obj, &field_name, BP_VAR_R TSRMLS_CC);
13396 if (local_TMIt126 == NULL)
13397 {
13398 local_TMIt126 = EG (uninitialized_zval_ptr);
13399 local_TMIt126->refcount++;
13400 }
13401 zval** p_lhs = &local_TMIt126;
13402
13403 write_var (p_lhs, field);
13404 phc_check_invariants (TSRMLS_C);
13405 }
13406 // $TLE92 = isset($TMIt126[$name]);
13407 {
13408 if (local_TLE92 == NULL)
13409 {
13410 local_TLE92 = EG (uninitialized_zval_ptr);
13411 local_TLE92->refcount++;
13412 }
13413 zval** p_lhs = &local_TLE92;
13414 zval* value;
13415 if ((*p_lhs)->is_ref)
13416 {
13417 // Always overwrite the current value
13418 value = *p_lhs;
13419 zval_dtor (value);
13420 }
13421 else
13422 {
13423 ALLOC_INIT_ZVAL (value);
13424 zval_ptr_dtor (p_lhs);
13425 *p_lhs = value;
13426 }
13427 if (local_TMIt126 == NULL)
13428 {
13429 local_TMIt126 = EG (uninitialized_zval_ptr);
13430 local_TMIt126->refcount++;
13431 }
13432 zval** u_array = &local_TMIt126;
13433 zval* u_index;
13434 if (local_name == NULL)
13435 {
13436 u_index = EG (uninitialized_zval_ptr);
13437 }
13438 else
13439 {
13440 u_index = local_name;
13441 }
13442 ZVAL_BOOL(value, isset_array (u_array, u_index));
13443 phc_check_invariants (TSRMLS_C);
13444 }
13445 // if (TLE92) goto L197 else goto L198;
13446 {
13447 zval* p_cond;
13448 if (local_TLE92 == NULL)
13449 p_cond = EG (uninitialized_zval_ptr);
13450 else
13451 p_cond = local_TLE92;
13452
13453 zend_bool bcond = zend_is_true (p_cond);
13454 if (bcond)
13455 goto L197;
13456 else
13457 goto L198;
13458 phc_check_invariants (TSRMLS_C);
13459 }
13460 // L197:
13461 L197:;
13462 // $TSt93 = $this->mProperties;
13463 {
13464 if (local_this == NULL)
13465 {
13466 local_this = EG (uninitialized_zval_ptr);
13467 local_this->refcount++;
13468 }
13469 zval** p_obj = &local_this;
13470
13471 zval field_name;
13472 INIT_ZVAL (field_name);
13473 ZVAL_STRING (&field_name, "mProperties", 0);
13474
13475 // I *think* this is correct, but documentation of the Zend API is scarce :)
13476 zval* field = Z_OBJ_HT_PP(p_obj)->read_property(*p_obj, &field_name, BP_VAR_R TSRMLS_CC);
13477 if (local_TSt93 == NULL)
13478 {
13479 local_TSt93 = EG (uninitialized_zval_ptr);
13480 local_TSt93->refcount++;
13481 }
13482 zval** p_lhs = &local_TSt93;
13483
13484 write_var (p_lhs, field);
13485 phc_check_invariants (TSRMLS_C);
13486 }
13487 // $TSi94 = $TSt93[$name];
13488 {
13489 if (local_TSi94 == NULL)
13490 {
13491 local_TSi94 = EG (uninitialized_zval_ptr);
13492 local_TSi94->refcount++;
13493 }
13494 zval** p_lhs = &local_TSi94;
13495
13496 zval* r_array;
13497 if (local_TSt93 == NULL)
13498 r_array = EG (uninitialized_zval_ptr);
13499 else
13500 r_array = local_TSt93;
13501
13502 zval* r_index;
13503 if (local_name == NULL)
13504 r_index = EG (uninitialized_zval_ptr);
13505 else
13506 r_index = local_name;
13507
13508
13509 zval* rhs;
13510 int is_rhs_new = 0;
13511 if (Z_TYPE_P (r_array) != IS_ARRAY)
13512 {
13513 if (Z_TYPE_P (r_array) == IS_STRING)
13514 {
13515 is_rhs_new = 1;
13516 rhs = read_string_index (r_array, r_index TSRMLS_CC);
13517 }
13518 else
13519 // TODO: warning here?
13520 rhs = EG (uninitialized_zval_ptr);
13521 }
13522 else
13523 {
13524 if (check_array_index_type (r_index TSRMLS_CC))
13525 {
13526 // Read array variable
13527 read_array (&rhs, r_array, r_index TSRMLS_CC);
13528 }
13529 else
13530 rhs = *p_lhs; // HACK to fail *p_lhs != rhs
13531 }
13532
13533 if (*p_lhs != rhs)
13534 write_var (p_lhs, rhs);
13535
13536 if (is_rhs_new) zval_ptr_dtor (&rhs);
13537 phc_check_invariants (TSRMLS_C);
13538 }
13539 // $TEF8 = $TSi94;
13540 {
13541 if (local_TEF8 == NULL)
13542 {
13543 local_TEF8 = EG (uninitialized_zval_ptr);
13544 local_TEF8->refcount++;
13545 }
13546 zval** p_lhs = &local_TEF8;
13547
13548 zval* rhs;
13549 if (local_TSi94 == NULL)
13550 rhs = EG (uninitialized_zval_ptr);
13551 else
13552 rhs = local_TSi94;
13553
13554 if (*p_lhs != rhs)
13555 {
13556 if ((*p_lhs)->is_ref)
13557 overwrite_lhs (*p_lhs, rhs);
13558 else
13559 {
13560 zval_ptr_dtor (p_lhs);
13561 if (rhs->is_ref)
13562 {
13563 // Take a copy of RHS for LHS
13564 *p_lhs = zvp_clone_ex (rhs);
13565 }
13566 else
13567 {
13568 // Share a copy
13569 rhs->refcount++;
13570 *p_lhs = rhs;
13571 }
13572
13573 }
13574
13575 }
13576 phc_check_invariants (TSRMLS_C);
13577 }
13578 // goto L199;
13579 {
13580 goto L199;
13581 phc_check_invariants (TSRMLS_C);
13582 }
13583 // L198:
13584 L198:;
13585 // $TEF8 = False;
13586 {
13587 if (local_TEF8 == NULL)
13588 {
13589 local_TEF8 = EG (uninitialized_zval_ptr);
13590 local_TEF8->refcount++;
13591 }
13592 zval** p_lhs = &local_TEF8;
13593
13594 zval* value;
13595 if ((*p_lhs)->is_ref)
13596 {
13597 // Always overwrite the current value
13598 value = *p_lhs;
13599 zval_dtor (value);
13600 }
13601 else
13602 {
13603 ALLOC_INIT_ZVAL (value);
13604 zval_ptr_dtor (p_lhs);
13605 *p_lhs = value;
13606 }
13607
13608 ZVAL_BOOL (value, 0);
13609
13610 phc_check_invariants (TSRMLS_C);
13611 }
13612 // goto L199;
13613 {
13614 goto L199;
13615 phc_check_invariants (TSRMLS_C);
13616 }
13617 // L199:
13618 L199:;
13619 // return $TEF8;
13620 {
13621 zval* rhs;
13622 if (local_TEF8 == NULL)
13623 rhs = EG (uninitialized_zval_ptr);
13624 else
13625 rhs = local_TEF8;
13626
13627 // Run-time return by reference has different semantics to compile-time.
13628 // If the function has CTRBR and RTRBR, the the assignment will be
13629 // reference. If one or the other is return-by-copy, the result will be
13630 // by copy. Its a question of whether its separated at return-time (which
13631 // we do here) or at the call-site.
13632 return_value->value = rhs->value;
13633 return_value->type = rhs->type;
13634 zval_copy_ctor (return_value);
13635 goto end_of_function;
13636 phc_check_invariants (TSRMLS_C);
13637 }
13638 // Method exit
13639 end_of_function:__attribute__((unused));
13640 if (local_TEF8 != NULL)
13641 {
13642 zval_ptr_dtor (&local_TEF8);
13643 }
13644 if (local_TLE92 != NULL)
13645 {
13646 zval_ptr_dtor (&local_TLE92);
13647 }
13648 if (local_TMIt126 != NULL)
13649 {
13650 zval_ptr_dtor (&local_TMIt126);
13651 }
13652 if (local_TSi94 != NULL)
13653 {
13654 zval_ptr_dtor (&local_TSi94);
13655 }
13656 if (local_TSt93 != NULL)
13657 {
13658 zval_ptr_dtor (&local_TSt93);
13659 }
13660 if (local_name != NULL)
13661 {
13662 zval_ptr_dtor (&local_name);
13663 }
13664 }
13665 // public function getproperties()
13666 // {
13667 // $TMIt127 = $this->mProperties;
13668 // $TLE95 = isset($TMIt127);
13669 // $TLE96 = !$TLE95;
13670 // if (TLE96) goto L200 else goto L201;
13671 // L200:
13672 // unset($TSa97);
13673 // $TSa97 = (array) $TSa97;
13674 // $this->mProperties = $TSa97;
13675 // goto L202;
13676 // L201:
13677 // goto L202;
13678 // L202:
13679 // $TSt98 = $this->mProperties;
13680 // return $TSt98;
13681 // }
13682 PHP_METHOD(ParserOutput, getproperties)
13683 {
13684 zval* local_TLE95 = NULL;
13685 zval* local_TLE96 = NULL;
13686 zval* local_TMIt127 = NULL;
13687 zval* local_TSa97 = NULL;
13688 zval* local_TSt98 = NULL;
13689 zval* local_this = getThis();
13690 // Function body
13691 // $TMIt127 = $this->mProperties;
13692 {
13693 if (local_this == NULL)
13694 {
13695 local_this = EG (uninitialized_zval_ptr);
13696 local_this->refcount++;
13697 }
13698 zval** p_obj = &local_this;
13699
13700 zval field_name;
13701 INIT_ZVAL (field_name);
13702 ZVAL_STRING (&field_name, "mProperties", 0);
13703
13704 // I *think* this is correct, but documentation of the Zend API is scarce :)
13705 zval* field = Z_OBJ_HT_PP(p_obj)->read_property(*p_obj, &field_name, BP_VAR_R TSRMLS_CC);
13706 if (local_TMIt127 == NULL)
13707 {
13708 local_TMIt127 = EG (uninitialized_zval_ptr);
13709 local_TMIt127->refcount++;
13710 }
13711 zval** p_lhs = &local_TMIt127;
13712
13713 write_var (p_lhs, field);
13714 phc_check_invariants (TSRMLS_C);
13715 }
13716 // $TLE95 = isset($TMIt127);
13717 {
13718 if (local_TLE95 == NULL)
13719 {
13720 local_TLE95 = EG (uninitialized_zval_ptr);
13721 local_TLE95->refcount++;
13722 }
13723 zval** p_lhs = &local_TLE95;
13724 zval* value;
13725 if ((*p_lhs)->is_ref)
13726 {
13727 // Always overwrite the current value
13728 value = *p_lhs;
13729 zval_dtor (value);
13730 }
13731 else
13732 {
13733 ALLOC_INIT_ZVAL (value);
13734 zval_ptr_dtor (p_lhs);
13735 *p_lhs = value;
13736 }
13737 ZVAL_BOOL(value, local_TMIt127 != NULL && !ZVAL_IS_NULL(local_TMIt127));
13738 phc_check_invariants (TSRMLS_C);
13739 }
13740 // $TLE96 = !$TLE95;
13741 {
13742 if (local_TLE96 == NULL)
13743 {
13744 local_TLE96 = EG (uninitialized_zval_ptr);
13745 local_TLE96->refcount++;
13746 }
13747 zval** p_lhs = &local_TLE96;
13748
13749 zval* rhs;
13750 if (local_TLE95 == NULL)
13751 rhs = EG (uninitialized_zval_ptr);
13752 else
13753 rhs = local_TLE95;
13754
13755 if (in_copy_on_write (*p_lhs))
13756 {
13757 zval_ptr_dtor (p_lhs);
13758 ALLOC_INIT_ZVAL (*p_lhs);
13759 }
13760
13761 zval old = **p_lhs;
13762 int result_is_operand = (*p_lhs == rhs);
13763 boolean_not_function (*p_lhs, rhs TSRMLS_CC);
13764 if (!result_is_operand)
13765 zval_dtor (&old);
13766 phc_check_invariants (TSRMLS_C);
13767 }
13768 // if (TLE96) goto L200 else goto L201;
13769 {
13770 zval* p_cond;
13771 if (local_TLE96 == NULL)
13772 p_cond = EG (uninitialized_zval_ptr);
13773 else
13774 p_cond = local_TLE96;
13775
13776 zend_bool bcond = zend_is_true (p_cond);
13777 if (bcond)
13778 goto L200;
13779 else
13780 goto L201;
13781 phc_check_invariants (TSRMLS_C);
13782 }
13783 // L200:
13784 L200:;
13785 // unset($TSa97);
13786 {
13787 if (local_TSa97 != NULL)
13788 {
13789 zval_ptr_dtor (&local_TSa97);
13790 local_TSa97 = NULL;
13791 }
13792 phc_check_invariants (TSRMLS_C);
13793 }
13794 // $TSa97 = (array) $TSa97;
13795 {
13796 if (local_TSa97 == NULL)
13797 {
13798 local_TSa97 = EG (uninitialized_zval_ptr);
13799 local_TSa97->refcount++;
13800 }
13801 zval** p_lhs = &local_TSa97;
13802
13803 zval* rhs;
13804 if (local_TSa97 == NULL)
13805 rhs = EG (uninitialized_zval_ptr);
13806 else
13807 rhs = local_TSa97;
13808
13809 if (*p_lhs != rhs)
13810 {
13811 if ((*p_lhs)->is_ref)
13812 overwrite_lhs (*p_lhs, rhs);
13813 else
13814 {
13815 zval_ptr_dtor (p_lhs);
13816 if (rhs->is_ref)
13817 {
13818 // Take a copy of RHS for LHS
13819 *p_lhs = zvp_clone_ex (rhs);
13820 }
13821 else
13822 {
13823 // Share a copy
13824 rhs->refcount++;
13825 *p_lhs = rhs;
13826 }
13827
13828 }
13829
13830 }
13831
13832 assert (IS_ARRAY >= 0 && IS_ARRAY <= 6);
13833 if ((*p_lhs)->type != IS_ARRAY)
13834 {
13835 sep_copy_on_write (p_lhs);
13836 convert_to_array (*p_lhs);
13837 }
13838
13839 phc_check_invariants (TSRMLS_C);
13840 }
13841 // $this->mProperties = $TSa97;
13842 {
13843 if (local_this == NULL)
13844 {
13845 local_this = EG (uninitialized_zval_ptr);
13846 local_this->refcount++;
13847 }
13848 zval** p_obj = &local_this;
13849
13850 zval* rhs;
13851 if (local_TSa97 == NULL)
13852 rhs = EG (uninitialized_zval_ptr);
13853 else
13854 rhs = local_TSa97;
13855
13856 zval field_name;
13857 INIT_ZVAL (field_name);
13858 ZVAL_STRING (&field_name, "mProperties", 0);
13859
13860 Z_OBJ_HT_PP(p_obj)->write_property(*p_obj, &field_name, rhs TSRMLS_CC);
13861 phc_check_invariants (TSRMLS_C);
13862 }
13863 // goto L202;
13864 {
13865 goto L202;
13866 phc_check_invariants (TSRMLS_C);
13867 }
13868 // L201:
13869 L201:;
13870 // goto L202;
13871 {
13872 goto L202;
13873 phc_check_invariants (TSRMLS_C);
13874 }
13875 // L202:
13876 L202:;
13877 // $TSt98 = $this->mProperties;
13878 {
13879 if (local_this == NULL)
13880 {
13881 local_this = EG (uninitialized_zval_ptr);
13882 local_this->refcount++;
13883 }
13884 zval** p_obj = &local_this;
13885
13886 zval field_name;
13887 INIT_ZVAL (field_name);
13888 ZVAL_STRING (&field_name, "mProperties", 0);
13889
13890 // I *think* this is correct, but documentation of the Zend API is scarce :)
13891 zval* field = Z_OBJ_HT_PP(p_obj)->read_property(*p_obj, &field_name, BP_VAR_R TSRMLS_CC);
13892 if (local_TSt98 == NULL)
13893 {
13894 local_TSt98 = EG (uninitialized_zval_ptr);
13895 local_TSt98->refcount++;
13896 }
13897 zval** p_lhs = &local_TSt98;
13898
13899 write_var (p_lhs, field);
13900 phc_check_invariants (TSRMLS_C);
13901 }
13902 // return $TSt98;
13903 {
13904 zval* rhs;
13905 if (local_TSt98 == NULL)
13906 rhs = EG (uninitialized_zval_ptr);
13907 else
13908 rhs = local_TSt98;
13909
13910 // Run-time return by reference has different semantics to compile-time.
13911 // If the function has CTRBR and RTRBR, the the assignment will be
13912 // reference. If one or the other is return-by-copy, the result will be
13913 // by copy. Its a question of whether its separated at return-time (which
13914 // we do here) or at the call-site.
13915 return_value->value = rhs->value;
13916 return_value->type = rhs->type;
13917 zval_copy_ctor (return_value);
13918 goto end_of_function;
13919 phc_check_invariants (TSRMLS_C);
13920 }
13921 // Method exit
13922 end_of_function:__attribute__((unused));
13923 if (local_TLE95 != NULL)
13924 {
13925 zval_ptr_dtor (&local_TLE95);
13926 }
13927 if (local_TLE96 != NULL)
13928 {
13929 zval_ptr_dtor (&local_TLE96);
13930 }
13931 if (local_TMIt127 != NULL)
13932 {
13933 zval_ptr_dtor (&local_TMIt127);
13934 }
13935 if (local_TSa97 != NULL)
13936 {
13937 zval_ptr_dtor (&local_TSa97);
13938 }
13939 if (local_TSt98 != NULL)
13940 {
13941 zval_ptr_dtor (&local_TSt98);
13942 }
13943 }
13944 // ArgInfo structures (necessary to support compile time pass-by-reference)
13945 ZEND_BEGIN_ARG_INFO_EX(ParserOutput_parseroutput_arg_info, 0, 0, 0)
13946 ZEND_ARG_INFO(0, "text")
13947 ZEND_ARG_INFO(0, "languageLinks")
13948 ZEND_ARG_INFO(0, "categoryLinks")
13949 ZEND_ARG_INFO(0, "containsOldMagic")
13950 ZEND_ARG_INFO(0, "titletext")
13951 ZEND_END_ARG_INFO()
13952
13953 ZEND_BEGIN_ARG_INFO_EX(ParserOutput_gettext_arg_info, 0, 0, 0)
13954 ZEND_END_ARG_INFO()
13955
13956 ZEND_BEGIN_ARG_INFO_EX(ParserOutput_getlanguagelinks_arg_info, 0, 1, 0)
13957 ZEND_END_ARG_INFO()
13958
13959 ZEND_BEGIN_ARG_INFO_EX(ParserOutput_getcategorylinks_arg_info, 0, 0, 0)
13960 ZEND_END_ARG_INFO()
13961
13962 ZEND_BEGIN_ARG_INFO_EX(ParserOutput_getcategories_arg_info, 0, 1, 0)
13963 ZEND_END_ARG_INFO()
13964
13965 ZEND_BEGIN_ARG_INFO_EX(ParserOutput_getcachetime_arg_info, 0, 0, 0)
13966 ZEND_END_ARG_INFO()
13967
13968 ZEND_BEGIN_ARG_INFO_EX(ParserOutput_gettitletext_arg_info, 0, 0, 0)
13969 ZEND_END_ARG_INFO()
13970
13971 ZEND_BEGIN_ARG_INFO_EX(ParserOutput_getsections_arg_info, 0, 0, 0)
13972 ZEND_END_ARG_INFO()
13973
13974 ZEND_BEGIN_ARG_INFO_EX(ParserOutput_getlinks_arg_info, 0, 1, 0)
13975 ZEND_END_ARG_INFO()
13976
13977 ZEND_BEGIN_ARG_INFO_EX(ParserOutput_gettemplates_arg_info, 0, 1, 0)
13978 ZEND_END_ARG_INFO()
13979
13980 ZEND_BEGIN_ARG_INFO_EX(ParserOutput_getimages_arg_info, 0, 1, 0)
13981 ZEND_END_ARG_INFO()
13982
13983 ZEND_BEGIN_ARG_INFO_EX(ParserOutput_getexternallinks_arg_info, 0, 1, 0)
13984 ZEND_END_ARG_INFO()
13985
13986 ZEND_BEGIN_ARG_INFO_EX(ParserOutput_getnogallery_arg_info, 0, 0, 0)
13987 ZEND_END_ARG_INFO()
13988
13989 ZEND_BEGIN_ARG_INFO_EX(ParserOutput_getsubtitle_arg_info, 0, 0, 0)
13990 ZEND_END_ARG_INFO()
13991
13992 ZEND_BEGIN_ARG_INFO_EX(ParserOutput_getoutputhooks_arg_info, 0, 0, 0)
13993 ZEND_END_ARG_INFO()
13994
13995 ZEND_BEGIN_ARG_INFO_EX(ParserOutput_getwarnings_arg_info, 0, 0, 0)
13996 ZEND_END_ARG_INFO()
13997
13998 ZEND_BEGIN_ARG_INFO_EX(ParserOutput_getindexpolicy_arg_info, 0, 0, 0)
13999 ZEND_END_ARG_INFO()
14000
14001 ZEND_BEGIN_ARG_INFO_EX(ParserOutput_containsoldmagic_arg_info, 0, 0, 0)
14002 ZEND_END_ARG_INFO()
14003
14004 ZEND_BEGIN_ARG_INFO_EX(ParserOutput_settext_arg_info, 0, 0, 0)
14005 ZEND_ARG_INFO(0, "text")
14006 ZEND_END_ARG_INFO()
14007
14008 ZEND_BEGIN_ARG_INFO_EX(ParserOutput_setlanguagelinks_arg_info, 0, 0, 0)
14009 ZEND_ARG_INFO(0, "ll")
14010 ZEND_END_ARG_INFO()
14011
14012 ZEND_BEGIN_ARG_INFO_EX(ParserOutput_setcategorylinks_arg_info, 0, 0, 0)
14013 ZEND_ARG_INFO(0, "cl")
14014 ZEND_END_ARG_INFO()
14015
14016 ZEND_BEGIN_ARG_INFO_EX(ParserOutput_setcontainsoldmagic_arg_info, 0, 0, 0)
14017 ZEND_ARG_INFO(0, "com")
14018 ZEND_END_ARG_INFO()
14019
14020 ZEND_BEGIN_ARG_INFO_EX(ParserOutput_setcachetime_arg_info, 0, 0, 0)
14021 ZEND_ARG_INFO(0, "t")
14022 ZEND_END_ARG_INFO()
14023
14024 ZEND_BEGIN_ARG_INFO_EX(ParserOutput_settitletext_arg_info, 0, 0, 0)
14025 ZEND_ARG_INFO(0, "t")
14026 ZEND_END_ARG_INFO()
14027
14028 ZEND_BEGIN_ARG_INFO_EX(ParserOutput_setsections_arg_info, 0, 0, 0)
14029 ZEND_ARG_INFO(0, "toc")
14030 ZEND_END_ARG_INFO()
14031
14032 ZEND_BEGIN_ARG_INFO_EX(ParserOutput_setindexpolicy_arg_info, 0, 0, 0)
14033 ZEND_ARG_INFO(0, "policy")
14034 ZEND_END_ARG_INFO()
14035
14036 ZEND_BEGIN_ARG_INFO_EX(ParserOutput_addcategory_arg_info, 0, 0, 0)
14037 ZEND_ARG_INFO(0, "c")
14038 ZEND_ARG_INFO(0, "sort")
14039 ZEND_END_ARG_INFO()
14040
14041 ZEND_BEGIN_ARG_INFO_EX(ParserOutput_addlanguagelink_arg_info, 0, 0, 0)
14042 ZEND_ARG_INFO(0, "t")
14043 ZEND_END_ARG_INFO()
14044
14045 ZEND_BEGIN_ARG_INFO_EX(ParserOutput_addexternallink_arg_info, 0, 0, 0)
14046 ZEND_ARG_INFO(0, "url")
14047 ZEND_END_ARG_INFO()
14048
14049 ZEND_BEGIN_ARG_INFO_EX(ParserOutput_addwarning_arg_info, 0, 0, 0)
14050 ZEND_ARG_INFO(0, "s")
14051 ZEND_END_ARG_INFO()
14052
14053 ZEND_BEGIN_ARG_INFO_EX(ParserOutput_addoutputhook_arg_info, 0, 0, 0)
14054 ZEND_ARG_INFO(0, "hook")
14055 ZEND_ARG_INFO(0, "data")
14056 ZEND_END_ARG_INFO()
14057
14058 ZEND_BEGIN_ARG_INFO_EX(ParserOutput_setnewsection_arg_info, 0, 0, 0)
14059 ZEND_ARG_INFO(0, "value")
14060 ZEND_END_ARG_INFO()
14061
14062 ZEND_BEGIN_ARG_INFO_EX(ParserOutput_getnewsection_arg_info, 0, 0, 0)
14063 ZEND_END_ARG_INFO()
14064
14065 ZEND_BEGIN_ARG_INFO_EX(ParserOutput_addlink_arg_info, 0, 0, 0)
14066 ZEND_ARG_INFO(0, "title")
14067 ZEND_ARG_INFO(0, "id")
14068 ZEND_END_ARG_INFO()
14069
14070 ZEND_BEGIN_ARG_INFO_EX(ParserOutput_addimage_arg_info, 0, 0, 0)
14071 ZEND_ARG_INFO(0, "name")
14072 ZEND_END_ARG_INFO()
14073
14074 ZEND_BEGIN_ARG_INFO_EX(ParserOutput_addtemplate_arg_info, 0, 0, 0)
14075 ZEND_ARG_INFO(0, "title")
14076 ZEND_ARG_INFO(0, "page_id")
14077 ZEND_ARG_INFO(0, "rev_id")
14078 ZEND_END_ARG_INFO()
14079
14080 ZEND_BEGIN_ARG_INFO_EX(ParserOutput_expired_arg_info, 0, 0, 0)
14081 ZEND_ARG_INFO(0, "touched")
14082 ZEND_END_ARG_INFO()
14083
14084 ZEND_BEGIN_ARG_INFO_EX(ParserOutput_addheaditem_arg_info, 0, 0, 0)
14085 ZEND_ARG_INFO(0, "section")
14086 ZEND_ARG_INFO(0, "tag")
14087 ZEND_END_ARG_INFO()
14088
14089 ZEND_BEGIN_ARG_INFO_EX(ParserOutput_setdisplaytitle_arg_info, 0, 0, 0)
14090 ZEND_ARG_INFO(0, "text")
14091 ZEND_END_ARG_INFO()
14092
14093 ZEND_BEGIN_ARG_INFO_EX(ParserOutput_getdisplaytitle_arg_info, 0, 0, 0)
14094 ZEND_END_ARG_INFO()
14095
14096 ZEND_BEGIN_ARG_INFO_EX(ParserOutput_setflag_arg_info, 0, 0, 0)
14097 ZEND_ARG_INFO(0, "flag")
14098 ZEND_END_ARG_INFO()
14099
14100 ZEND_BEGIN_ARG_INFO_EX(ParserOutput_getflag_arg_info, 0, 0, 0)
14101 ZEND_ARG_INFO(0, "flag")
14102 ZEND_END_ARG_INFO()
14103
14104 ZEND_BEGIN_ARG_INFO_EX(ParserOutput_setproperty_arg_info, 0, 0, 0)
14105 ZEND_ARG_INFO(0, "name")
14106 ZEND_ARG_INFO(0, "value")
14107 ZEND_END_ARG_INFO()
14108
14109 ZEND_BEGIN_ARG_INFO_EX(ParserOutput_getproperty_arg_info, 0, 0, 0)
14110 ZEND_ARG_INFO(0, "name")
14111 ZEND_END_ARG_INFO()
14112
14113 ZEND_BEGIN_ARG_INFO_EX(ParserOutput_getproperties_arg_info, 0, 0, 0)
14114 ZEND_END_ARG_INFO()
14115
14116 static function_entry ParserOutput_functions[] = {
14117 PHP_ME(ParserOutput, parseroutput, ParserOutput_parseroutput_arg_info, ZEND_ACC_PUBLIC)
14118 PHP_ME(ParserOutput, gettext, ParserOutput_gettext_arg_info, ZEND_ACC_PUBLIC)
14119 PHP_ME(ParserOutput, getlanguagelinks, ParserOutput_getlanguagelinks_arg_info, ZEND_ACC_PUBLIC)
14120 PHP_ME(ParserOutput, getcategorylinks, ParserOutput_getcategorylinks_arg_info, ZEND_ACC_PUBLIC)
14121 PHP_ME(ParserOutput, getcategories, ParserOutput_getcategories_arg_info, ZEND_ACC_PUBLIC)
14122 PHP_ME(ParserOutput, getcachetime, ParserOutput_getcachetime_arg_info, ZEND_ACC_PUBLIC)
14123 PHP_ME(ParserOutput, gettitletext, ParserOutput_gettitletext_arg_info, ZEND_ACC_PUBLIC)
14124 PHP_ME(ParserOutput, getsections, ParserOutput_getsections_arg_info, ZEND_ACC_PUBLIC)
14125 PHP_ME(ParserOutput, getlinks, ParserOutput_getlinks_arg_info, ZEND_ACC_PUBLIC)
14126 PHP_ME(ParserOutput, gettemplates, ParserOutput_gettemplates_arg_info, ZEND_ACC_PUBLIC)
14127 PHP_ME(ParserOutput, getimages, ParserOutput_getimages_arg_info, ZEND_ACC_PUBLIC)
14128 PHP_ME(ParserOutput, getexternallinks, ParserOutput_getexternallinks_arg_info, ZEND_ACC_PUBLIC)
14129 PHP_ME(ParserOutput, getnogallery, ParserOutput_getnogallery_arg_info, ZEND_ACC_PUBLIC)
14130 PHP_ME(ParserOutput, getsubtitle, ParserOutput_getsubtitle_arg_info, ZEND_ACC_PUBLIC)
14131 PHP_ME(ParserOutput, getoutputhooks, ParserOutput_getoutputhooks_arg_info, ZEND_ACC_PUBLIC)
14132 PHP_ME(ParserOutput, getwarnings, ParserOutput_getwarnings_arg_info, ZEND_ACC_PUBLIC)
14133 PHP_ME(ParserOutput, getindexpolicy, ParserOutput_getindexpolicy_arg_info, ZEND_ACC_PUBLIC)
14134 PHP_ME(ParserOutput, containsoldmagic, ParserOutput_containsoldmagic_arg_info, ZEND_ACC_PUBLIC)
14135 PHP_ME(ParserOutput, settext, ParserOutput_settext_arg_info, ZEND_ACC_PUBLIC)
14136 PHP_ME(ParserOutput, setlanguagelinks, ParserOutput_setlanguagelinks_arg_info, ZEND_ACC_PUBLIC)
14137 PHP_ME(ParserOutput, setcategorylinks, ParserOutput_setcategorylinks_arg_info, ZEND_ACC_PUBLIC)
14138 PHP_ME(ParserOutput, setcontainsoldmagic, ParserOutput_setcontainsoldmagic_arg_info, ZEND_ACC_PUBLIC)
14139 PHP_ME(ParserOutput, setcachetime, ParserOutput_setcachetime_arg_info, ZEND_ACC_PUBLIC)
14140 PHP_ME(ParserOutput, settitletext, ParserOutput_settitletext_arg_info, ZEND_ACC_PUBLIC)
14141 PHP_ME(ParserOutput, setsections, ParserOutput_setsections_arg_info, ZEND_ACC_PUBLIC)
14142 PHP_ME(ParserOutput, setindexpolicy, ParserOutput_setindexpolicy_arg_info, ZEND_ACC_PUBLIC)
14143 PHP_ME(ParserOutput, addcategory, ParserOutput_addcategory_arg_info, ZEND_ACC_PUBLIC)
14144 PHP_ME(ParserOutput, addlanguagelink, ParserOutput_addlanguagelink_arg_info, ZEND_ACC_PUBLIC)
14145 PHP_ME(ParserOutput, addexternallink, ParserOutput_addexternallink_arg_info, ZEND_ACC_PUBLIC)
14146 PHP_ME(ParserOutput, addwarning, ParserOutput_addwarning_arg_info, ZEND_ACC_PUBLIC)
14147 PHP_ME(ParserOutput, addoutputhook, ParserOutput_addoutputhook_arg_info, ZEND_ACC_PUBLIC)
14148 PHP_ME(ParserOutput, setnewsection, ParserOutput_setnewsection_arg_info, ZEND_ACC_PUBLIC)
14149 PHP_ME(ParserOutput, getnewsection, ParserOutput_getnewsection_arg_info, ZEND_ACC_PUBLIC)
14150 PHP_ME(ParserOutput, addlink, ParserOutput_addlink_arg_info, ZEND_ACC_PUBLIC)
14151 PHP_ME(ParserOutput, addimage, ParserOutput_addimage_arg_info, ZEND_ACC_PUBLIC)
14152 PHP_ME(ParserOutput, addtemplate, ParserOutput_addtemplate_arg_info, ZEND_ACC_PUBLIC)
14153 PHP_ME(ParserOutput, expired, ParserOutput_expired_arg_info, ZEND_ACC_PUBLIC)
14154 PHP_ME(ParserOutput, addheaditem, ParserOutput_addheaditem_arg_info, ZEND_ACC_PUBLIC)
14155 PHP_ME(ParserOutput, setdisplaytitle, ParserOutput_setdisplaytitle_arg_info, ZEND_ACC_PUBLIC)
14156 PHP_ME(ParserOutput, getdisplaytitle, ParserOutput_getdisplaytitle_arg_info, ZEND_ACC_PUBLIC)
14157 PHP_ME(ParserOutput, setflag, ParserOutput_setflag_arg_info, ZEND_ACC_PUBLIC)
14158 PHP_ME(ParserOutput, getflag, ParserOutput_getflag_arg_info, ZEND_ACC_PUBLIC)
14159 PHP_ME(ParserOutput, setproperty, ParserOutput_setproperty_arg_info, ZEND_ACC_PUBLIC)
14160 PHP_ME(ParserOutput, getproperty, ParserOutput_getproperty_arg_info, ZEND_ACC_PUBLIC)
14161 PHP_ME(ParserOutput, getproperties, ParserOutput_getproperties_arg_info, ZEND_ACC_PUBLIC)
14162 { NULL, NULL, NULL }
14163 };
14164 // function __MAIN__()
14165 // {
14166 // }
14167 PHP_FUNCTION(__MAIN__)
14168 {
14169 // Function body
14170 // Method exit
14171 end_of_function:__attribute__((unused));
14172 }
14173 // Module initialization
14174 PHP_MINIT_FUNCTION(app)
14175 {
14176 {
14177 zend_class_entry ce; // temp
14178 zend_class_entry* ce_reg; // once registered, ce_ptr should be used
14179 INIT_CLASS_ENTRY(ce, "ParserOutput", ParserOutput_functions);
14180 ce_reg = zend_register_internal_class(&ce TSRMLS_CC);
14181 ce_reg->type &= ~ZEND_INTERNAL_CLASS;
14182 {
14183 zval* default_value;
14184 {
14185 zval* local___static_value__ = NULL;
14186 // $__static_value__ = NULL;
14187 {
14188 if (local___static_value__ == NULL)
14189 {
14190 local___static_value__ = EG (uninitialized_zval_ptr);
14191 local___static_value__->refcount++;
14192 }
14193 zval** p_lhs = &local___static_value__;
14194
14195 zval* value;
14196 if ((*p_lhs)->is_ref)
14197 {
14198 // Always overwrite the current value
14199 value = *p_lhs;
14200 zval_dtor (value);
14201 }
14202 else
14203 {
14204 ALLOC_INIT_ZVAL (value);
14205 zval_ptr_dtor (p_lhs);
14206 *p_lhs = value;
14207 }
14208
14209 ZVAL_NULL (value);
14210
14211 phc_check_invariants (TSRMLS_C);
14212 }
14213 default_value = local___static_value__;
14214 assert(!default_value->is_ref);
14215 default_value->refcount++;
14216 if (local___static_value__ != NULL)
14217 {
14218 zval_ptr_dtor (&local___static_value__);
14219 }
14220 }
14221 phc_declare_property(ce_reg, "mText", 5, default_value, ZEND_ACC_PUBLIC TSRMLS_CC);}{
14222 zval* default_value;
14223 {
14224 zval* local___static_value__ = NULL;
14225 // $__static_value__ = NULL;
14226 {
14227 if (local___static_value__ == NULL)
14228 {
14229 local___static_value__ = EG (uninitialized_zval_ptr);
14230 local___static_value__->refcount++;
14231 }
14232 zval** p_lhs = &local___static_value__;
14233
14234 zval* value;
14235 if ((*p_lhs)->is_ref)
14236 {
14237 // Always overwrite the current value
14238 value = *p_lhs;
14239 zval_dtor (value);
14240 }
14241 else
14242 {
14243 ALLOC_INIT_ZVAL (value);
14244 zval_ptr_dtor (p_lhs);
14245 *p_lhs = value;
14246 }
14247
14248 ZVAL_NULL (value);
14249
14250 phc_check_invariants (TSRMLS_C);
14251 }
14252 default_value = local___static_value__;
14253 assert(!default_value->is_ref);
14254 default_value->refcount++;
14255 if (local___static_value__ != NULL)
14256 {
14257 zval_ptr_dtor (&local___static_value__);
14258 }
14259 }
14260 phc_declare_property(ce_reg, "mLanguageLinks", 14, default_value, ZEND_ACC_PUBLIC TSRMLS_CC);}{
14261 zval* default_value;
14262 {
14263 zval* local___static_value__ = NULL;
14264 // $__static_value__ = NULL;
14265 {
14266 if (local___static_value__ == NULL)
14267 {
14268 local___static_value__ = EG (uninitialized_zval_ptr);
14269 local___static_value__->refcount++;
14270 }
14271 zval** p_lhs = &local___static_value__;
14272
14273 zval* value;
14274 if ((*p_lhs)->is_ref)
14275 {
14276 // Always overwrite the current value
14277 value = *p_lhs;
14278 zval_dtor (value);
14279 }
14280 else
14281 {
14282 ALLOC_INIT_ZVAL (value);
14283 zval_ptr_dtor (p_lhs);
14284 *p_lhs = value;
14285 }
14286
14287 ZVAL_NULL (value);
14288
14289 phc_check_invariants (TSRMLS_C);
14290 }
14291 default_value = local___static_value__;
14292 assert(!default_value->is_ref);
14293 default_value->refcount++;
14294 if (local___static_value__ != NULL)
14295 {
14296 zval_ptr_dtor (&local___static_value__);
14297 }
14298 }
14299 phc_declare_property(ce_reg, "mCategories", 11, default_value, ZEND_ACC_PUBLIC TSRMLS_CC);}{
14300 zval* default_value;
14301 {
14302 zval* local___static_value__ = NULL;
14303 // $__static_value__ = NULL;
14304 {
14305 if (local___static_value__ == NULL)
14306 {
14307 local___static_value__ = EG (uninitialized_zval_ptr);
14308 local___static_value__->refcount++;
14309 }
14310 zval** p_lhs = &local___static_value__;
14311
14312 zval* value;
14313 if ((*p_lhs)->is_ref)
14314 {
14315 // Always overwrite the current value
14316 value = *p_lhs;
14317 zval_dtor (value);
14318 }
14319 else
14320 {
14321 ALLOC_INIT_ZVAL (value);
14322 zval_ptr_dtor (p_lhs);
14323 *p_lhs = value;
14324 }
14325
14326 ZVAL_NULL (value);
14327
14328 phc_check_invariants (TSRMLS_C);
14329 }
14330 default_value = local___static_value__;
14331 assert(!default_value->is_ref);
14332 default_value->refcount++;
14333 if (local___static_value__ != NULL)
14334 {
14335 zval_ptr_dtor (&local___static_value__);
14336 }
14337 }
14338 phc_declare_property(ce_reg, "mContainsOldMagic", 17, default_value, ZEND_ACC_PUBLIC TSRMLS_CC);}{
14339 zval* default_value;
14340 {
14341 zval* local___static_value__ = NULL;
14342 // $__static_value__ = NULL;
14343 {
14344 if (local___static_value__ == NULL)
14345 {
14346 local___static_value__ = EG (uninitialized_zval_ptr);
14347 local___static_value__->refcount++;
14348 }
14349 zval** p_lhs = &local___static_value__;
14350
14351 zval* value;
14352 if ((*p_lhs)->is_ref)
14353 {
14354 // Always overwrite the current value
14355 value = *p_lhs;
14356 zval_dtor (value);
14357 }
14358 else
14359 {
14360 ALLOC_INIT_ZVAL (value);
14361 zval_ptr_dtor (p_lhs);
14362 *p_lhs = value;
14363 }
14364
14365 ZVAL_NULL (value);
14366
14367 phc_check_invariants (TSRMLS_C);
14368 }
14369 default_value = local___static_value__;
14370 assert(!default_value->is_ref);
14371 default_value->refcount++;
14372 if (local___static_value__ != NULL)
14373 {
14374 zval_ptr_dtor (&local___static_value__);
14375 }
14376 }
14377 phc_declare_property(ce_reg, "mTitleText", 10, default_value, ZEND_ACC_PUBLIC TSRMLS_CC);}{
14378 zval* default_value;
14379 {
14380 zval* local___static_value__ = NULL;
14381 // $__static_value__ = '';
14382 {
14383 if (local___static_value__ == NULL)
14384 {
14385 local___static_value__ = EG (uninitialized_zval_ptr);
14386 local___static_value__->refcount++;
14387 }
14388 zval** p_lhs = &local___static_value__;
14389
14390 zval* value;
14391 if ((*p_lhs)->is_ref)
14392 {
14393 // Always overwrite the current value
14394 value = *p_lhs;
14395 zval_dtor (value);
14396 }
14397 else
14398 {
14399 ALLOC_INIT_ZVAL (value);
14400 zval_ptr_dtor (p_lhs);
14401 *p_lhs = value;
14402 }
14403
14404 ZVAL_STRINGL(value, "", 0, 1);
14405
14406 phc_check_invariants (TSRMLS_C);
14407 }
14408 default_value = local___static_value__;
14409 assert(!default_value->is_ref);
14410 default_value->refcount++;
14411 if (local___static_value__ != NULL)
14412 {
14413 zval_ptr_dtor (&local___static_value__);
14414 }
14415 }
14416 phc_declare_property(ce_reg, "mCacheTime", 10, default_value, ZEND_ACC_PUBLIC TSRMLS_CC);}{
14417 zval* default_value;
14418 {
14419 zval* local___static_value__ = NULL;
14420 // $__static_value__ = Parser::VERSION;
14421 {
14422 // No null-terminator in length for get_constant.
14423 // zend_get_constant always returns a copy of the constant.
14424 if (local___static_value__ == NULL)
14425 {
14426 local___static_value__ = EG (uninitialized_zval_ptr);
14427 local___static_value__->refcount++;
14428 }
14429 zval** p_lhs = &local___static_value__;
14430
14431 if (!(*p_lhs)->is_ref)
14432 {
14433 zval_ptr_dtor (p_lhs);
14434 get_constant ("Parser::VERSION", 15, p_lhs TSRMLS_CC);
14435
14436 }
14437 else
14438 {
14439 zval* constant;
14440 get_constant ("Parser::VERSION", 15, p_lhs TSRMLS_CC);
14441 overwrite_lhs_no_copy (*p_lhs, constant);
14442 safe_free_zval_ptr (constant);
14443
14444 }
14445 phc_check_invariants (TSRMLS_C);
14446 }
14447 default_value = local___static_value__;
14448 assert(!default_value->is_ref);
14449 default_value->refcount++;
14450 if (local___static_value__ != NULL)
14451 {
14452 zval_ptr_dtor (&local___static_value__);
14453 }
14454 }
14455 phc_declare_property(ce_reg, "mVersion", 8, default_value, ZEND_ACC_PUBLIC TSRMLS_CC);}{
14456 zval* default_value;
14457 {
14458 zval* local_TSa205 = NULL;
14459 zval* local___static_value__ = NULL;
14460 // unset($TSa205);
14461 {
14462 if (local_TSa205 != NULL)
14463 {
14464 zval_ptr_dtor (&local_TSa205);
14465 local_TSa205 = NULL;
14466 }
14467 phc_check_invariants (TSRMLS_C);
14468 }
14469 // $TSa205 = (array) $TSa205;
14470 {
14471 if (local_TSa205 == NULL)
14472 {
14473 local_TSa205 = EG (uninitialized_zval_ptr);
14474 local_TSa205->refcount++;
14475 }
14476 zval** p_lhs = &local_TSa205;
14477
14478 zval* rhs;
14479 if (local_TSa205 == NULL)
14480 rhs = EG (uninitialized_zval_ptr);
14481 else
14482 rhs = local_TSa205;
14483
14484 if (*p_lhs != rhs)
14485 {
14486 if ((*p_lhs)->is_ref)
14487 overwrite_lhs (*p_lhs, rhs);
14488 else
14489 {
14490 zval_ptr_dtor (p_lhs);
14491 if (rhs->is_ref)
14492 {
14493 // Take a copy of RHS for LHS
14494 *p_lhs = zvp_clone_ex (rhs);
14495 }
14496 else
14497 {
14498 // Share a copy
14499 rhs->refcount++;
14500 *p_lhs = rhs;
14501 }
14502
14503 }
14504
14505 }
14506
14507 assert (IS_ARRAY >= 0 && IS_ARRAY <= 6);
14508 if ((*p_lhs)->type != IS_ARRAY)
14509 {
14510 sep_copy_on_write (p_lhs);
14511 convert_to_array (*p_lhs);
14512 }
14513
14514 phc_check_invariants (TSRMLS_C);
14515 }
14516 // $__static_value__ = $TSa205;
14517 {
14518 if (local___static_value__ == NULL)
14519 {
14520 local___static_value__ = EG (uninitialized_zval_ptr);
14521 local___static_value__->refcount++;
14522 }
14523 zval** p_lhs = &local___static_value__;
14524
14525 zval* rhs;
14526 if (local_TSa205 == NULL)
14527 rhs = EG (uninitialized_zval_ptr);
14528 else
14529 rhs = local_TSa205;
14530
14531 if (*p_lhs != rhs)
14532 {
14533 if ((*p_lhs)->is_ref)
14534 overwrite_lhs (*p_lhs, rhs);
14535 else
14536 {
14537 zval_ptr_dtor (p_lhs);
14538 if (rhs->is_ref)
14539 {
14540 // Take a copy of RHS for LHS
14541 *p_lhs = zvp_clone_ex (rhs);
14542 }
14543 else
14544 {
14545 // Share a copy
14546 rhs->refcount++;
14547 *p_lhs = rhs;
14548 }
14549
14550 }
14551
14552 }
14553 phc_check_invariants (TSRMLS_C);
14554 }
14555 default_value = local___static_value__;
14556 assert(!default_value->is_ref);
14557 default_value->refcount++;
14558 if (local_TSa205 != NULL)
14559 {
14560 zval_ptr_dtor (&local_TSa205);
14561 }
14562 if (local___static_value__ != NULL)
14563 {
14564 zval_ptr_dtor (&local___static_value__);
14565 }
14566 }
14567 phc_declare_property(ce_reg, "mLinks", 6, default_value, ZEND_ACC_PUBLIC TSRMLS_CC);}{
14568 zval* default_value;
14569 {
14570 zval* local_TSa206 = NULL;
14571 zval* local___static_value__ = NULL;
14572 // unset($TSa206);
14573 {
14574 if (local_TSa206 != NULL)
14575 {
14576 zval_ptr_dtor (&local_TSa206);
14577 local_TSa206 = NULL;
14578 }
14579 phc_check_invariants (TSRMLS_C);
14580 }
14581 // $TSa206 = (array) $TSa206;
14582 {
14583 if (local_TSa206 == NULL)
14584 {
14585 local_TSa206 = EG (uninitialized_zval_ptr);
14586 local_TSa206->refcount++;
14587 }
14588 zval** p_lhs = &local_TSa206;
14589
14590 zval* rhs;
14591 if (local_TSa206 == NULL)
14592 rhs = EG (uninitialized_zval_ptr);
14593 else
14594 rhs = local_TSa206;
14595
14596 if (*p_lhs != rhs)
14597 {
14598 if ((*p_lhs)->is_ref)
14599 overwrite_lhs (*p_lhs, rhs);
14600 else
14601 {
14602 zval_ptr_dtor (p_lhs);
14603 if (rhs->is_ref)
14604 {
14605 // Take a copy of RHS for LHS
14606 *p_lhs = zvp_clone_ex (rhs);
14607 }
14608 else
14609 {
14610 // Share a copy
14611 rhs->refcount++;
14612 *p_lhs = rhs;
14613 }
14614
14615 }
14616
14617 }
14618
14619 assert (IS_ARRAY >= 0 && IS_ARRAY <= 6);
14620 if ((*p_lhs)->type != IS_ARRAY)
14621 {
14622 sep_copy_on_write (p_lhs);
14623 convert_to_array (*p_lhs);
14624 }
14625
14626 phc_check_invariants (TSRMLS_C);
14627 }
14628 // $__static_value__ = $TSa206;
14629 {
14630 if (local___static_value__ == NULL)
14631 {
14632 local___static_value__ = EG (uninitialized_zval_ptr);
14633 local___static_value__->refcount++;
14634 }
14635 zval** p_lhs = &local___static_value__;
14636
14637 zval* rhs;
14638 if (local_TSa206 == NULL)
14639 rhs = EG (uninitialized_zval_ptr);
14640 else
14641 rhs = local_TSa206;
14642
14643 if (*p_lhs != rhs)
14644 {
14645 if ((*p_lhs)->is_ref)
14646 overwrite_lhs (*p_lhs, rhs);
14647 else
14648 {
14649 zval_ptr_dtor (p_lhs);
14650 if (rhs->is_ref)
14651 {
14652 // Take a copy of RHS for LHS
14653 *p_lhs = zvp_clone_ex (rhs);
14654 }
14655 else
14656 {
14657 // Share a copy
14658 rhs->refcount++;
14659 *p_lhs = rhs;
14660 }
14661
14662 }
14663
14664 }
14665 phc_check_invariants (TSRMLS_C);
14666 }
14667 default_value = local___static_value__;
14668 assert(!default_value->is_ref);
14669 default_value->refcount++;
14670 if (local_TSa206 != NULL)
14671 {
14672 zval_ptr_dtor (&local_TSa206);
14673 }
14674 if (local___static_value__ != NULL)
14675 {
14676 zval_ptr_dtor (&local___static_value__);
14677 }
14678 }
14679 phc_declare_property(ce_reg, "mTemplates", 10, default_value, ZEND_ACC_PUBLIC TSRMLS_CC);}{
14680 zval* default_value;
14681 {
14682 zval* local_TSa207 = NULL;
14683 zval* local___static_value__ = NULL;
14684 // unset($TSa207);
14685 {
14686 if (local_TSa207 != NULL)
14687 {
14688 zval_ptr_dtor (&local_TSa207);
14689 local_TSa207 = NULL;
14690 }
14691 phc_check_invariants (TSRMLS_C);
14692 }
14693 // $TSa207 = (array) $TSa207;
14694 {
14695 if (local_TSa207 == NULL)
14696 {
14697 local_TSa207 = EG (uninitialized_zval_ptr);
14698 local_TSa207->refcount++;
14699 }
14700 zval** p_lhs = &local_TSa207;
14701
14702 zval* rhs;
14703 if (local_TSa207 == NULL)
14704 rhs = EG (uninitialized_zval_ptr);
14705 else
14706 rhs = local_TSa207;
14707
14708 if (*p_lhs != rhs)
14709 {
14710 if ((*p_lhs)->is_ref)
14711 overwrite_lhs (*p_lhs, rhs);
14712 else
14713 {
14714 zval_ptr_dtor (p_lhs);
14715 if (rhs->is_ref)
14716 {
14717 // Take a copy of RHS for LHS
14718 *p_lhs = zvp_clone_ex (rhs);
14719 }
14720 else
14721 {
14722 // Share a copy
14723 rhs->refcount++;
14724 *p_lhs = rhs;
14725 }
14726
14727 }
14728
14729 }
14730
14731 assert (IS_ARRAY >= 0 && IS_ARRAY <= 6);
14732 if ((*p_lhs)->type != IS_ARRAY)
14733 {
14734 sep_copy_on_write (p_lhs);
14735 convert_to_array (*p_lhs);
14736 }
14737
14738 phc_check_invariants (TSRMLS_C);
14739 }
14740 // $__static_value__ = $TSa207;
14741 {
14742 if (local___static_value__ == NULL)
14743 {
14744 local___static_value__ = EG (uninitialized_zval_ptr);
14745 local___static_value__->refcount++;
14746 }
14747 zval** p_lhs = &local___static_value__;
14748
14749 zval* rhs;
14750 if (local_TSa207 == NULL)
14751 rhs = EG (uninitialized_zval_ptr);
14752 else
14753 rhs = local_TSa207;
14754
14755 if (*p_lhs != rhs)
14756 {
14757 if ((*p_lhs)->is_ref)
14758 overwrite_lhs (*p_lhs, rhs);
14759 else
14760 {
14761 zval_ptr_dtor (p_lhs);
14762 if (rhs->is_ref)
14763 {
14764 // Take a copy of RHS for LHS
14765 *p_lhs = zvp_clone_ex (rhs);
14766 }
14767 else
14768 {
14769 // Share a copy
14770 rhs->refcount++;
14771 *p_lhs = rhs;
14772 }
14773
14774 }
14775
14776 }
14777 phc_check_invariants (TSRMLS_C);
14778 }
14779 default_value = local___static_value__;
14780 assert(!default_value->is_ref);
14781 default_value->refcount++;
14782 if (local_TSa207 != NULL)
14783 {
14784 zval_ptr_dtor (&local_TSa207);
14785 }
14786 if (local___static_value__ != NULL)
14787 {
14788 zval_ptr_dtor (&local___static_value__);
14789 }
14790 }
14791 phc_declare_property(ce_reg, "mTemplateIds", 12, default_value, ZEND_ACC_PUBLIC TSRMLS_CC);}{
14792 zval* default_value;
14793 {
14794 zval* local_TSa208 = NULL;
14795 zval* local___static_value__ = NULL;
14796 // unset($TSa208);
14797 {
14798 if (local_TSa208 != NULL)
14799 {
14800 zval_ptr_dtor (&local_TSa208);
14801 local_TSa208 = NULL;
14802 }
14803 phc_check_invariants (TSRMLS_C);
14804 }
14805 // $TSa208 = (array) $TSa208;
14806 {
14807 if (local_TSa208 == NULL)
14808 {
14809 local_TSa208 = EG (uninitialized_zval_ptr);
14810 local_TSa208->refcount++;
14811 }
14812 zval** p_lhs = &local_TSa208;
14813
14814 zval* rhs;
14815 if (local_TSa208 == NULL)
14816 rhs = EG (uninitialized_zval_ptr);
14817 else
14818 rhs = local_TSa208;
14819
14820 if (*p_lhs != rhs)
14821 {
14822 if ((*p_lhs)->is_ref)
14823 overwrite_lhs (*p_lhs, rhs);
14824 else
14825 {
14826 zval_ptr_dtor (p_lhs);
14827 if (rhs->is_ref)
14828 {
14829 // Take a copy of RHS for LHS
14830 *p_lhs = zvp_clone_ex (rhs);
14831 }
14832 else
14833 {
14834 // Share a copy
14835 rhs->refcount++;
14836 *p_lhs = rhs;
14837 }
14838
14839 }
14840
14841 }
14842
14843 assert (IS_ARRAY >= 0 && IS_ARRAY <= 6);
14844 if ((*p_lhs)->type != IS_ARRAY)
14845 {
14846 sep_copy_on_write (p_lhs);
14847 convert_to_array (*p_lhs);
14848 }
14849
14850 phc_check_invariants (TSRMLS_C);
14851 }
14852 // $__static_value__ = $TSa208;
14853 {
14854 if (local___static_value__ == NULL)
14855 {
14856 local___static_value__ = EG (uninitialized_zval_ptr);
14857 local___static_value__->refcount++;
14858 }
14859 zval** p_lhs = &local___static_value__;
14860
14861 zval* rhs;
14862 if (local_TSa208 == NULL)
14863 rhs = EG (uninitialized_zval_ptr);
14864 else
14865 rhs = local_TSa208;
14866
14867 if (*p_lhs != rhs)
14868 {
14869 if ((*p_lhs)->is_ref)
14870 overwrite_lhs (*p_lhs, rhs);
14871 else
14872 {
14873 zval_ptr_dtor (p_lhs);
14874 if (rhs->is_ref)
14875 {
14876 // Take a copy of RHS for LHS
14877 *p_lhs = zvp_clone_ex (rhs);
14878 }
14879 else
14880 {
14881 // Share a copy
14882 rhs->refcount++;
14883 *p_lhs = rhs;
14884 }
14885
14886 }
14887
14888 }
14889 phc_check_invariants (TSRMLS_C);
14890 }
14891 default_value = local___static_value__;
14892 assert(!default_value->is_ref);
14893 default_value->refcount++;
14894 if (local_TSa208 != NULL)
14895 {
14896 zval_ptr_dtor (&local_TSa208);
14897 }
14898 if (local___static_value__ != NULL)
14899 {
14900 zval_ptr_dtor (&local___static_value__);
14901 }
14902 }
14903 phc_declare_property(ce_reg, "mImages", 7, default_value, ZEND_ACC_PUBLIC TSRMLS_CC);}{
14904 zval* default_value;
14905 {
14906 zval* local_TSa209 = NULL;
14907 zval* local___static_value__ = NULL;
14908 // unset($TSa209);
14909 {
14910 if (local_TSa209 != NULL)
14911 {
14912 zval_ptr_dtor (&local_TSa209);
14913 local_TSa209 = NULL;
14914 }
14915 phc_check_invariants (TSRMLS_C);
14916 }
14917 // $TSa209 = (array) $TSa209;
14918 {
14919 if (local_TSa209 == NULL)
14920 {
14921 local_TSa209 = EG (uninitialized_zval_ptr);
14922 local_TSa209->refcount++;
14923 }
14924 zval** p_lhs = &local_TSa209;
14925
14926 zval* rhs;
14927 if (local_TSa209 == NULL)
14928 rhs = EG (uninitialized_zval_ptr);
14929 else
14930 rhs = local_TSa209;
14931
14932 if (*p_lhs != rhs)
14933 {
14934 if ((*p_lhs)->is_ref)
14935 overwrite_lhs (*p_lhs, rhs);
14936 else
14937 {
14938 zval_ptr_dtor (p_lhs);
14939 if (rhs->is_ref)
14940 {
14941 // Take a copy of RHS for LHS
14942 *p_lhs = zvp_clone_ex (rhs);
14943 }
14944 else
14945 {
14946 // Share a copy
14947 rhs->refcount++;
14948 *p_lhs = rhs;
14949 }
14950
14951 }
14952
14953 }
14954
14955 assert (IS_ARRAY >= 0 && IS_ARRAY <= 6);
14956 if ((*p_lhs)->type != IS_ARRAY)
14957 {
14958 sep_copy_on_write (p_lhs);
14959 convert_to_array (*p_lhs);
14960 }
14961
14962 phc_check_invariants (TSRMLS_C);
14963 }
14964 // $__static_value__ = $TSa209;
14965 {
14966 if (local___static_value__ == NULL)
14967 {
14968 local___static_value__ = EG (uninitialized_zval_ptr);
14969 local___static_value__->refcount++;
14970 }
14971 zval** p_lhs = &local___static_value__;
14972
14973 zval* rhs;
14974 if (local_TSa209 == NULL)
14975 rhs = EG (uninitialized_zval_ptr);
14976 else
14977 rhs = local_TSa209;
14978
14979 if (*p_lhs != rhs)
14980 {
14981 if ((*p_lhs)->is_ref)
14982 overwrite_lhs (*p_lhs, rhs);
14983 else
14984 {
14985 zval_ptr_dtor (p_lhs);
14986 if (rhs->is_ref)
14987 {
14988 // Take a copy of RHS for LHS
14989 *p_lhs = zvp_clone_ex (rhs);
14990 }
14991 else
14992 {
14993 // Share a copy
14994 rhs->refcount++;
14995 *p_lhs = rhs;
14996 }
14997
14998 }
14999
15000 }
15001 phc_check_invariants (TSRMLS_C);
15002 }
15003 default_value = local___static_value__;
15004 assert(!default_value->is_ref);
15005 default_value->refcount++;
15006 if (local_TSa209 != NULL)
15007 {
15008 zval_ptr_dtor (&local_TSa209);
15009 }
15010 if (local___static_value__ != NULL)
15011 {
15012 zval_ptr_dtor (&local___static_value__);
15013 }
15014 }
15015 phc_declare_property(ce_reg, "mExternalLinks", 14, default_value, ZEND_ACC_PUBLIC TSRMLS_CC);}{
15016 zval* default_value;
15017 {
15018 zval* local___static_value__ = NULL;
15019 // $__static_value__ = False;
15020 {
15021 if (local___static_value__ == NULL)
15022 {
15023 local___static_value__ = EG (uninitialized_zval_ptr);
15024 local___static_value__->refcount++;
15025 }
15026 zval** p_lhs = &local___static_value__;
15027
15028 zval* value;
15029 if ((*p_lhs)->is_ref)
15030 {
15031 // Always overwrite the current value
15032 value = *p_lhs;
15033 zval_dtor (value);
15034 }
15035 else
15036 {
15037 ALLOC_INIT_ZVAL (value);
15038 zval_ptr_dtor (p_lhs);
15039 *p_lhs = value;
15040 }
15041
15042 ZVAL_BOOL (value, 0);
15043
15044 phc_check_invariants (TSRMLS_C);
15045 }
15046 default_value = local___static_value__;
15047 assert(!default_value->is_ref);
15048 default_value->refcount++;
15049 if (local___static_value__ != NULL)
15050 {
15051 zval_ptr_dtor (&local___static_value__);
15052 }
15053 }
15054 phc_declare_property(ce_reg, "mNewSection", 11, default_value, ZEND_ACC_PUBLIC TSRMLS_CC);}{
15055 zval* default_value;
15056 {
15057 zval* local___static_value__ = NULL;
15058 // $__static_value__ = False;
15059 {
15060 if (local___static_value__ == NULL)
15061 {
15062 local___static_value__ = EG (uninitialized_zval_ptr);
15063 local___static_value__->refcount++;
15064 }
15065 zval** p_lhs = &local___static_value__;
15066
15067 zval* value;
15068 if ((*p_lhs)->is_ref)
15069 {
15070 // Always overwrite the current value
15071 value = *p_lhs;
15072 zval_dtor (value);
15073 }
15074 else
15075 {
15076 ALLOC_INIT_ZVAL (value);
15077 zval_ptr_dtor (p_lhs);
15078 *p_lhs = value;
15079 }
15080
15081 ZVAL_BOOL (value, 0);
15082
15083 phc_check_invariants (TSRMLS_C);
15084 }
15085 default_value = local___static_value__;
15086 assert(!default_value->is_ref);
15087 default_value->refcount++;
15088 if (local___static_value__ != NULL)
15089 {
15090 zval_ptr_dtor (&local___static_value__);
15091 }
15092 }
15093 phc_declare_property(ce_reg, "mNoGallery", 10, default_value, ZEND_ACC_PUBLIC TSRMLS_CC);}{
15094 zval* default_value;
15095 {
15096 zval* local_TSa210 = NULL;
15097 zval* local___static_value__ = NULL;
15098 // unset($TSa210);
15099 {
15100 if (local_TSa210 != NULL)
15101 {
15102 zval_ptr_dtor (&local_TSa210);
15103 local_TSa210 = NULL;
15104 }
15105 phc_check_invariants (TSRMLS_C);
15106 }
15107 // $TSa210 = (array) $TSa210;
15108 {
15109 if (local_TSa210 == NULL)
15110 {
15111 local_TSa210 = EG (uninitialized_zval_ptr);
15112 local_TSa210->refcount++;
15113 }
15114 zval** p_lhs = &local_TSa210;
15115
15116 zval* rhs;
15117 if (local_TSa210 == NULL)
15118 rhs = EG (uninitialized_zval_ptr);
15119 else
15120 rhs = local_TSa210;
15121
15122 if (*p_lhs != rhs)
15123 {
15124 if ((*p_lhs)->is_ref)
15125 overwrite_lhs (*p_lhs, rhs);
15126 else
15127 {
15128 zval_ptr_dtor (p_lhs);
15129 if (rhs->is_ref)
15130 {
15131 // Take a copy of RHS for LHS
15132 *p_lhs = zvp_clone_ex (rhs);
15133 }
15134 else
15135 {
15136 // Share a copy
15137 rhs->refcount++;
15138 *p_lhs = rhs;
15139 }
15140
15141 }
15142
15143 }
15144
15145 assert (IS_ARRAY >= 0 && IS_ARRAY <= 6);
15146 if ((*p_lhs)->type != IS_ARRAY)
15147 {
15148 sep_copy_on_write (p_lhs);
15149 convert_to_array (*p_lhs);
15150 }
15151
15152 phc_check_invariants (TSRMLS_C);
15153 }
15154 // $__static_value__ = $TSa210;
15155 {
15156 if (local___static_value__ == NULL)
15157 {
15158 local___static_value__ = EG (uninitialized_zval_ptr);
15159 local___static_value__->refcount++;
15160 }
15161 zval** p_lhs = &local___static_value__;
15162
15163 zval* rhs;
15164 if (local_TSa210 == NULL)
15165 rhs = EG (uninitialized_zval_ptr);
15166 else
15167 rhs = local_TSa210;
15168
15169 if (*p_lhs != rhs)
15170 {
15171 if ((*p_lhs)->is_ref)
15172 overwrite_lhs (*p_lhs, rhs);
15173 else
15174 {
15175 zval_ptr_dtor (p_lhs);
15176 if (rhs->is_ref)
15177 {
15178 // Take a copy of RHS for LHS
15179 *p_lhs = zvp_clone_ex (rhs);
15180 }
15181 else
15182 {
15183 // Share a copy
15184 rhs->refcount++;
15185 *p_lhs = rhs;
15186 }
15187
15188 }
15189
15190 }
15191 phc_check_invariants (TSRMLS_C);
15192 }
15193 default_value = local___static_value__;
15194 assert(!default_value->is_ref);
15195 default_value->refcount++;
15196 if (local_TSa210 != NULL)
15197 {
15198 zval_ptr_dtor (&local_TSa210);
15199 }
15200 if (local___static_value__ != NULL)
15201 {
15202 zval_ptr_dtor (&local___static_value__);
15203 }
15204 }
15205 phc_declare_property(ce_reg, "mHeadItems", 10, default_value, ZEND_ACC_PUBLIC TSRMLS_CC);}{
15206 zval* default_value;
15207 {
15208 zval* local_TSa211 = NULL;
15209 zval* local___static_value__ = NULL;
15210 // unset($TSa211);
15211 {
15212 if (local_TSa211 != NULL)
15213 {
15214 zval_ptr_dtor (&local_TSa211);
15215 local_TSa211 = NULL;
15216 }
15217 phc_check_invariants (TSRMLS_C);
15218 }
15219 // $TSa211 = (array) $TSa211;
15220 {
15221 if (local_TSa211 == NULL)
15222 {
15223 local_TSa211 = EG (uninitialized_zval_ptr);
15224 local_TSa211->refcount++;
15225 }
15226 zval** p_lhs = &local_TSa211;
15227
15228 zval* rhs;
15229 if (local_TSa211 == NULL)
15230 rhs = EG (uninitialized_zval_ptr);
15231 else
15232 rhs = local_TSa211;
15233
15234 if (*p_lhs != rhs)
15235 {
15236 if ((*p_lhs)->is_ref)
15237 overwrite_lhs (*p_lhs, rhs);
15238 else
15239 {
15240 zval_ptr_dtor (p_lhs);
15241 if (rhs->is_ref)
15242 {
15243 // Take a copy of RHS for LHS
15244 *p_lhs = zvp_clone_ex (rhs);
15245 }
15246 else
15247 {
15248 // Share a copy
15249 rhs->refcount++;
15250 *p_lhs = rhs;
15251 }
15252
15253 }
15254
15255 }
15256
15257 assert (IS_ARRAY >= 0 && IS_ARRAY <= 6);
15258 if ((*p_lhs)->type != IS_ARRAY)
15259 {
15260 sep_copy_on_write (p_lhs);
15261 convert_to_array (*p_lhs);
15262 }
15263
15264 phc_check_invariants (TSRMLS_C);
15265 }
15266 // $__static_value__ = $TSa211;
15267 {
15268 if (local___static_value__ == NULL)
15269 {
15270 local___static_value__ = EG (uninitialized_zval_ptr);
15271 local___static_value__->refcount++;
15272 }
15273 zval** p_lhs = &local___static_value__;
15274
15275 zval* rhs;
15276 if (local_TSa211 == NULL)
15277 rhs = EG (uninitialized_zval_ptr);
15278 else
15279 rhs = local_TSa211;
15280
15281 if (*p_lhs != rhs)
15282 {
15283 if ((*p_lhs)->is_ref)
15284 overwrite_lhs (*p_lhs, rhs);
15285 else
15286 {
15287 zval_ptr_dtor (p_lhs);
15288 if (rhs->is_ref)
15289 {
15290 // Take a copy of RHS for LHS
15291 *p_lhs = zvp_clone_ex (rhs);
15292 }
15293 else
15294 {
15295 // Share a copy
15296 rhs->refcount++;
15297 *p_lhs = rhs;
15298 }
15299
15300 }
15301
15302 }
15303 phc_check_invariants (TSRMLS_C);
15304 }
15305 default_value = local___static_value__;
15306 assert(!default_value->is_ref);
15307 default_value->refcount++;
15308 if (local_TSa211 != NULL)
15309 {
15310 zval_ptr_dtor (&local_TSa211);
15311 }
15312 if (local___static_value__ != NULL)
15313 {
15314 zval_ptr_dtor (&local___static_value__);
15315 }
15316 }
15317 phc_declare_property(ce_reg, "mOutputHooks", 12, default_value, ZEND_ACC_PUBLIC TSRMLS_CC);}{
15318 zval* default_value;
15319 {
15320 zval* local_TSa212 = NULL;
15321 zval* local___static_value__ = NULL;
15322 // unset($TSa212);
15323 {
15324 if (local_TSa212 != NULL)
15325 {
15326 zval_ptr_dtor (&local_TSa212);
15327 local_TSa212 = NULL;
15328 }
15329 phc_check_invariants (TSRMLS_C);
15330 }
15331 // $TSa212 = (array) $TSa212;
15332 {
15333 if (local_TSa212 == NULL)
15334 {
15335 local_TSa212 = EG (uninitialized_zval_ptr);
15336 local_TSa212->refcount++;
15337 }
15338 zval** p_lhs = &local_TSa212;
15339
15340 zval* rhs;
15341 if (local_TSa212 == NULL)
15342 rhs = EG (uninitialized_zval_ptr);
15343 else
15344 rhs = local_TSa212;
15345
15346 if (*p_lhs != rhs)
15347 {
15348 if ((*p_lhs)->is_ref)
15349 overwrite_lhs (*p_lhs, rhs);
15350 else
15351 {
15352 zval_ptr_dtor (p_lhs);
15353 if (rhs->is_ref)
15354 {
15355 // Take a copy of RHS for LHS
15356 *p_lhs = zvp_clone_ex (rhs);
15357 }
15358 else
15359 {
15360 // Share a copy
15361 rhs->refcount++;
15362 *p_lhs = rhs;
15363 }
15364
15365 }
15366
15367 }
15368
15369 assert (IS_ARRAY >= 0 && IS_ARRAY <= 6);
15370 if ((*p_lhs)->type != IS_ARRAY)
15371 {
15372 sep_copy_on_write (p_lhs);
15373 convert_to_array (*p_lhs);
15374 }
15375
15376 phc_check_invariants (TSRMLS_C);
15377 }
15378 // $__static_value__ = $TSa212;
15379 {
15380 if (local___static_value__ == NULL)
15381 {
15382 local___static_value__ = EG (uninitialized_zval_ptr);
15383 local___static_value__->refcount++;
15384 }
15385 zval** p_lhs = &local___static_value__;
15386
15387 zval* rhs;
15388 if (local_TSa212 == NULL)
15389 rhs = EG (uninitialized_zval_ptr);
15390 else
15391 rhs = local_TSa212;
15392
15393 if (*p_lhs != rhs)
15394 {
15395 if ((*p_lhs)->is_ref)
15396 overwrite_lhs (*p_lhs, rhs);
15397 else
15398 {
15399 zval_ptr_dtor (p_lhs);
15400 if (rhs->is_ref)
15401 {
15402 // Take a copy of RHS for LHS
15403 *p_lhs = zvp_clone_ex (rhs);
15404 }
15405 else
15406 {
15407 // Share a copy
15408 rhs->refcount++;
15409 *p_lhs = rhs;
15410 }
15411
15412 }
15413
15414 }
15415 phc_check_invariants (TSRMLS_C);
15416 }
15417 default_value = local___static_value__;
15418 assert(!default_value->is_ref);
15419 default_value->refcount++;
15420 if (local_TSa212 != NULL)
15421 {
15422 zval_ptr_dtor (&local_TSa212);
15423 }
15424 if (local___static_value__ != NULL)
15425 {
15426 zval_ptr_dtor (&local___static_value__);
15427 }
15428 }
15429 phc_declare_property(ce_reg, "mWarnings", 9, default_value, ZEND_ACC_PUBLIC TSRMLS_CC);}{
15430 zval* default_value;
15431 {
15432 zval* local_TSa213 = NULL;
15433 zval* local___static_value__ = NULL;
15434 // unset($TSa213);
15435 {
15436 if (local_TSa213 != NULL)
15437 {
15438 zval_ptr_dtor (&local_TSa213);
15439 local_TSa213 = NULL;
15440 }
15441 phc_check_invariants (TSRMLS_C);
15442 }
15443 // $TSa213 = (array) $TSa213;
15444 {
15445 if (local_TSa213 == NULL)
15446 {
15447 local_TSa213 = EG (uninitialized_zval_ptr);
15448 local_TSa213->refcount++;
15449 }
15450 zval** p_lhs = &local_TSa213;
15451
15452 zval* rhs;
15453 if (local_TSa213 == NULL)
15454 rhs = EG (uninitialized_zval_ptr);
15455 else
15456 rhs = local_TSa213;
15457
15458 if (*p_lhs != rhs)
15459 {
15460 if ((*p_lhs)->is_ref)
15461 overwrite_lhs (*p_lhs, rhs);
15462 else
15463 {
15464 zval_ptr_dtor (p_lhs);
15465 if (rhs->is_ref)
15466 {
15467 // Take a copy of RHS for LHS
15468 *p_lhs = zvp_clone_ex (rhs);
15469 }
15470 else
15471 {
15472 // Share a copy
15473 rhs->refcount++;
15474 *p_lhs = rhs;
15475 }
15476
15477 }
15478
15479 }
15480
15481 assert (IS_ARRAY >= 0 && IS_ARRAY <= 6);
15482 if ((*p_lhs)->type != IS_ARRAY)
15483 {
15484 sep_copy_on_write (p_lhs);
15485 convert_to_array (*p_lhs);
15486 }
15487
15488 phc_check_invariants (TSRMLS_C);
15489 }
15490 // $__static_value__ = $TSa213;
15491 {
15492 if (local___static_value__ == NULL)
15493 {
15494 local___static_value__ = EG (uninitialized_zval_ptr);
15495 local___static_value__->refcount++;
15496 }
15497 zval** p_lhs = &local___static_value__;
15498
15499 zval* rhs;
15500 if (local_TSa213 == NULL)
15501 rhs = EG (uninitialized_zval_ptr);
15502 else
15503 rhs = local_TSa213;
15504
15505 if (*p_lhs != rhs)
15506 {
15507 if ((*p_lhs)->is_ref)
15508 overwrite_lhs (*p_lhs, rhs);
15509 else
15510 {
15511 zval_ptr_dtor (p_lhs);
15512 if (rhs->is_ref)
15513 {
15514 // Take a copy of RHS for LHS
15515 *p_lhs = zvp_clone_ex (rhs);
15516 }
15517 else
15518 {
15519 // Share a copy
15520 rhs->refcount++;
15521 *p_lhs = rhs;
15522 }
15523
15524 }
15525
15526 }
15527 phc_check_invariants (TSRMLS_C);
15528 }
15529 default_value = local___static_value__;
15530 assert(!default_value->is_ref);
15531 default_value->refcount++;
15532 if (local_TSa213 != NULL)
15533 {
15534 zval_ptr_dtor (&local_TSa213);
15535 }
15536 if (local___static_value__ != NULL)
15537 {
15538 zval_ptr_dtor (&local___static_value__);
15539 }
15540 }
15541 phc_declare_property(ce_reg, "mSections", 9, default_value, ZEND_ACC_PUBLIC TSRMLS_CC);}{
15542 zval* default_value;
15543 {
15544 zval* local_TSa214 = NULL;
15545 zval* local___static_value__ = NULL;
15546 // unset($TSa214);
15547 {
15548 if (local_TSa214 != NULL)
15549 {
15550 zval_ptr_dtor (&local_TSa214);
15551 local_TSa214 = NULL;
15552 }
15553 phc_check_invariants (TSRMLS_C);
15554 }
15555 // $TSa214 = (array) $TSa214;
15556 {
15557 if (local_TSa214 == NULL)
15558 {
15559 local_TSa214 = EG (uninitialized_zval_ptr);
15560 local_TSa214->refcount++;
15561 }
15562 zval** p_lhs = &local_TSa214;
15563
15564 zval* rhs;
15565 if (local_TSa214 == NULL)
15566 rhs = EG (uninitialized_zval_ptr);
15567 else
15568 rhs = local_TSa214;
15569
15570 if (*p_lhs != rhs)
15571 {
15572 if ((*p_lhs)->is_ref)
15573 overwrite_lhs (*p_lhs, rhs);
15574 else
15575 {
15576 zval_ptr_dtor (p_lhs);
15577 if (rhs->is_ref)
15578 {
15579 // Take a copy of RHS for LHS
15580 *p_lhs = zvp_clone_ex (rhs);
15581 }
15582 else
15583 {
15584 // Share a copy
15585 rhs->refcount++;
15586 *p_lhs = rhs;
15587 }
15588
15589 }
15590
15591 }
15592
15593 assert (IS_ARRAY >= 0 && IS_ARRAY <= 6);
15594 if ((*p_lhs)->type != IS_ARRAY)
15595 {
15596 sep_copy_on_write (p_lhs);
15597 convert_to_array (*p_lhs);
15598 }
15599
15600 phc_check_invariants (TSRMLS_C);
15601 }
15602 // $__static_value__ = $TSa214;
15603 {
15604 if (local___static_value__ == NULL)
15605 {
15606 local___static_value__ = EG (uninitialized_zval_ptr);
15607 local___static_value__->refcount++;
15608 }
15609 zval** p_lhs = &local___static_value__;
15610
15611 zval* rhs;
15612 if (local_TSa214 == NULL)
15613 rhs = EG (uninitialized_zval_ptr);
15614 else
15615 rhs = local_TSa214;
15616
15617 if (*p_lhs != rhs)
15618 {
15619 if ((*p_lhs)->is_ref)
15620 overwrite_lhs (*p_lhs, rhs);
15621 else
15622 {
15623 zval_ptr_dtor (p_lhs);
15624 if (rhs->is_ref)
15625 {
15626 // Take a copy of RHS for LHS
15627 *p_lhs = zvp_clone_ex (rhs);
15628 }
15629 else
15630 {
15631 // Share a copy
15632 rhs->refcount++;
15633 *p_lhs = rhs;
15634 }
15635
15636 }
15637
15638 }
15639 phc_check_invariants (TSRMLS_C);
15640 }
15641 default_value = local___static_value__;
15642 assert(!default_value->is_ref);
15643 default_value->refcount++;
15644 if (local_TSa214 != NULL)
15645 {
15646 zval_ptr_dtor (&local_TSa214);
15647 }
15648 if (local___static_value__ != NULL)
15649 {
15650 zval_ptr_dtor (&local___static_value__);
15651 }
15652 }
15653 phc_declare_property(ce_reg, "mProperties", 11, default_value, ZEND_ACC_PUBLIC TSRMLS_CC);}{
15654 zval* default_value;
15655 {
15656 zval* local___static_value__ = NULL;
15657 // $__static_value__ = '';
15658 {
15659 if (local___static_value__ == NULL)
15660 {
15661 local___static_value__ = EG (uninitialized_zval_ptr);
15662 local___static_value__->refcount++;
15663 }
15664 zval** p_lhs = &local___static_value__;
15665
15666 zval* value;
15667 if ((*p_lhs)->is_ref)
15668 {
15669 // Always overwrite the current value
15670 value = *p_lhs;
15671 zval_dtor (value);
15672 }
15673 else
15674 {
15675 ALLOC_INIT_ZVAL (value);
15676 zval_ptr_dtor (p_lhs);
15677 *p_lhs = value;
15678 }
15679
15680 ZVAL_STRINGL(value, "", 0, 1);
15681
15682 phc_check_invariants (TSRMLS_C);
15683 }
15684 default_value = local___static_value__;
15685 assert(!default_value->is_ref);
15686 default_value->refcount++;
15687 if (local___static_value__ != NULL)
15688 {
15689 zval_ptr_dtor (&local___static_value__);
15690 }
15691 }
15692 phc_declare_property(ce_reg, "mIndexPolicy", 12, default_value, ZEND_ACC_PRIVATE TSRMLS_CC);}{
15693 zval* default_value;
15694 {
15695 zval* local___static_value__ = NULL;
15696 // $__static_value__ = False;
15697 {
15698 if (local___static_value__ == NULL)
15699 {
15700 local___static_value__ = EG (uninitialized_zval_ptr);
15701 local___static_value__->refcount++;
15702 }
15703 zval** p_lhs = &local___static_value__;
15704
15705 zval* value;
15706 if ((*p_lhs)->is_ref)
15707 {
15708 // Always overwrite the current value
15709 value = *p_lhs;
15710 zval_dtor (value);
15711 }
15712 else
15713 {
15714 ALLOC_INIT_ZVAL (value);
15715 zval_ptr_dtor (p_lhs);
15716 *p_lhs = value;
15717 }
15718
15719 ZVAL_BOOL (value, 0);
15720
15721 phc_check_invariants (TSRMLS_C);
15722 }
15723 default_value = local___static_value__;
15724 assert(!default_value->is_ref);
15725 default_value->refcount++;
15726 if (local___static_value__ != NULL)
15727 {
15728 zval_ptr_dtor (&local___static_value__);
15729 }
15730 }
15731 phc_declare_property(ce_reg, "displayTitle", 12, default_value, ZEND_ACC_PRIVATE TSRMLS_CC);}}return SUCCESS;}// ArgInfo structures (necessary to support compile time pass-by-reference)
15732 ZEND_BEGIN_ARG_INFO_EX(app___MAIN___arg_info, 0, 0, 0)
15733 ZEND_END_ARG_INFO()
15734
15735 static function_entry app_functions[] = {
15736 PHP_FE(__MAIN__, app___MAIN___arg_info)
15737 { NULL, NULL, NULL }
15738 };
15739 // Register the module itself with PHP
15740 zend_module_entry app_module_entry = {
15741 STANDARD_MODULE_HEADER,
15742 "app",
15743 app_functions,
15744 PHP_MINIT(app), /* MINIT */
15745 NULL, /* MSHUTDOWN */
15746 NULL, /* RINIT */
15747 NULL, /* RSHUTDOWN */
15748 NULL, /* MINFO */
15749 "1.0",
15750 STANDARD_MODULE_PROPERTIES
15751 };
15752 #include <sapi/embed/php_embed.h>
15753 #include <signal.h>
15754
15755 void sighandler(int signum)
15756 {
15757 switch(signum)
15758 {
15759 case SIGABRT:
15760 printf("SIGABRT received!\n");
15761 break;
15762 case SIGSEGV:
15763 printf("SIGSEGV received!\n");
15764 break;
15765 default:
15766 printf("Unknown signal received!\n");
15767 break;
15768 }
15769
15770 printf("This could be a bug in phc. If you suspect it is, please email\n");
15771 printf("a bug report to phc-general@phpcompiler.org.\n");
15772 exit(-1);
15773 }
15774
15775 int
15776 main (int argc, char* argv[])
15777 {
15778 int phc_exit_status;
15779 signal(SIGABRT, sighandler);
15780 signal(SIGSEGV, sighandler);
15781
15782 TSRMLS_D;
15783 int dealloc_pools = 1;
15784 php_embed_init (argc, argv PTSRMLS_CC);
15785 zend_first_try
15786 {
15787
15788 // initialize the phc runtime
15789 init_runtime();
15790
15791 // load the compiled extension
15792 zend_startup_module (&app_module_entry);
15793
15794 zval main_name;
15795 ZVAL_STRING (&main_name, "__MAIN__", NULL);
15796
15797 zval retval;
15798
15799 // Use standard errors, on stdout
15800 zend_alter_ini_entry ("report_zend_debug", sizeof("report_zend_debug"), "0", sizeof("0") - 1, PHP_INI_ALL, PHP_INI_STAGE_RUNTIME);
15801 zend_alter_ini_entry ("display_startup_errors", sizeof("display_startup_errors"), "1", sizeof("1") - 1, PHP_INI_ALL, PHP_INI_STAGE_RUNTIME);
15802
15803 // initialize all the constants
15804 saved_refcount = 0;
15805
15806 // call __MAIN__
15807 int success = call_user_function(
15808 EG (function_table),
15809 NULL,
15810 &main_name,
15811 &retval,
15812 0,
15813 NULL
15814 TSRMLS_CC);
15815
15816 assert (success == SUCCESS);
15817
15818 // finalize the runtime
15819 finalize_runtime();
15820
15821 }
15822 zend_catch
15823 {
15824 dealloc_pools = 0;
15825 }
15826 zend_end_try ();
15827 if (dealloc_pools)
15828 {
15829 }
15830 phc_exit_status = EG(exit_status);
15831 php_embed_shutdown (TSRMLS_C);
15832
15833 return phc_exit_status;
15834 }
compile the mediawiki parser as c++ with hphp hiphop-php