1: <?php
   2: /**
   3:  * @author Jefferson González
   4:  * @license MIT
   5:  * @link http://github.com/peg-org/peg-src Source code.
   6:  */
   7: 
   8: namespace Peg\Lib\Generator;
   9: 
  10: use Peg\Lib\Utilities\FileSystem;
  11: 
  12: /**
  13:  * Class that implements a zend extension generator.
  14:  */
  15: class ZendPHP extends \Peg\Lib\Generator\Base
  16: {
  17:     public function __construct(
  18:         $templates, 
  19:         $output, 
  20:         \Peg\Lib\Definitions\Symbols &$symbols
  21:     )
  22:     {
  23:         parent::__construct($templates, $output, "zend_php", $symbols);
  24:     }
  25:     
  26:     /**
  27:      * Generate all the files that needed to build a zend php extension.
  28:      */
  29:     public function Start()
  30:     {
  31:         foreach($this->symbols->headers as $header_name=>$header_object)
  32:         {
  33:             // Skip disabled headers
  34:             if(!$header_object->enabled)
  35:             {
  36:                 $this->RemoveHeader($header_name);
  37:                 continue;
  38:             }
  39: 
  40:             // Generate header file
  41:             $header_content = $this->GenerateHeader($header_name);
  42: 
  43:             $this->AddHeader($header_name, $header_content);
  44:             
  45:             // Generate classes header file
  46:             $classes_header_content = $this->GenerateClassesHeader($header_name);
  47: 
  48:             $this->AddHeader(
  49:                 $header_name, 
  50:                 $classes_header_content, 
  51:                 "includes/classes"
  52:             );
  53: 
  54:             // Generate source file
  55:             $source_content = $this->GenerateSource($header_name);
  56: 
  57:             $this->AddSource($header_name, $source_content);
  58:         }
  59:         
  60:         $this->GenerateOtherSources();
  61:         
  62:         $this->GenerateCustomSources();
  63:         
  64:         $this->GenerateConfigs();
  65:     }
  66: 
  67:     /**
  68:      * Generates a specific header file.
  69:      * @param string $header_name
  70:      * @return string Source code.
  71:      */
  72:     public function GenerateHeader($header_name)
  73:     {
  74:         // Variables used by some template files.
  75:         $authors = \Peg\Lib\Settings::GetAuthors();
  76:         $contributors = \Peg\Lib\Settings::GetContributors();
  77:         $extension = \Peg\Lib\Settings::GetExtensionName();
  78:         $version = \Peg\Lib\Settings::GetVersion();
  79: 
  80:         $header_object = $this->symbols->headers[$header_name];
  81:         $header_define = $this->GetHeaderDefine($header_name);
  82: 
  83:         $header_content = "";
  84: 
  85:         // Get heading of header file
  86:         ob_start();
  87:             include($this->GetTemplatePath(
  88:                 $header_name, 
  89:                 "headers", 
  90:                 "header", 
  91:                 "helpers", 
  92:                 "header"
  93:             ));
  94:             $header_content .= ob_get_contents();
  95:         ob_end_clean();
  96: 
  97:         // Get constants function template content
  98:         if($header_object->HasConstants() || $header_object->HasGlobalVariables())
  99:         {
 100:             ob_start();
 101:                 include($this->GetTemplatePath(
 102:                     $header_name, 
 103:                     "constants", 
 104:                     "function_decl", 
 105:                     "helpers", 
 106:                     "constant"
 107:                 ));
 108:                 $header_content .= ob_get_contents();
 109:             ob_end_clean();
 110: 
 111:             $header_content .= "\n";
 112:         }
 113: 
 114:         // Get enums function template content
 115:         if($header_object->HasEnumerations())
 116:         {
 117:             ob_start();
 118:                 include($this->GetTemplatePath(
 119:                     $header_name, 
 120:                     "enums", 
 121:                     "function_decl", 
 122:                     "helpers", 
 123:                     "enum"
 124:                 ));
 125:                 $header_content .= ob_get_contents();
 126:             ob_end_clean();
 127: 
 128:             $header_content .= "\n";
 129:         }
 130: 
 131:         // Get functions function template content
 132:         if($header_object->HasFunctions())
 133:         {
 134:             ob_start();
 135:                 include($this->GetTemplatePath(
 136:                     $header_name, 
 137:                     "functions", 
 138:                     "function_decl", 
 139:                     "helpers", 
 140:                     "function"
 141:                 ));
 142:                 $header_content .= ob_get_contents();
 143:             ob_end_clean();
 144: 
 145:             $header_content .= "\n";
 146:         }
 147:         
 148:         // Get classes function template content
 149:         if($header_object->HasClasses())
 150:         {
 151:             foreach($header_object->namespaces as $namespace_name=>$namespace_object)
 152:             {
 153:                 if($namespace_name == "\\")
 154:                     $namespace_name = "";
 155: 
 156:                 $namespace_name_cpp = str_replace(
 157:                     "\\",
 158:                     "::",
 159:                     $namespace_name
 160:                 );
 161: 
 162:                 $namespace_name_var = str_replace(
 163:                     "\\",
 164:                     "_",
 165:                     $namespace_name
 166:                 );
 167:                 
 168:                 foreach($namespace_object->classes as $class_name=>$class_object)
 169:                 {
 170:                     ob_start();
 171:                         include($this->GetTemplatePath(
 172:                             $class_name, 
 173:                             "classes", 
 174:                             "function_decl", 
 175:                             "helpers", 
 176:                             "class"
 177:                         ));
 178:                         $header_content .= ob_get_contents();
 179:                     ob_end_clean();
 180: 
 181:                     $header_content .= "\n";
 182:                 }
 183:             }
 184:         }
 185: 
 186:         // Get footer of header file
 187:         ob_start();
 188:             include($this->GetTemplatePath(
 189:                 $header_name, 
 190:                 "headers", 
 191:                 "footer", 
 192:                 "helpers", 
 193:                 "header"
 194:             ));
 195:             $header_content .= ob_get_contents();
 196:         ob_end_clean();
 197: 
 198:         return $header_content;
 199:     }
 200:     
 201:     /**
 202:      * Generates a specific header file for classes.
 203:      * @param string $header_name
 204:      * @return string Source code.
 205:      */
 206:     public function GenerateClassesHeader($header_name)
 207:     {
 208:         // Variables used by some template files.
 209:         $authors = \Peg\Lib\Settings::GetAuthors();
 210:         $contributors = \Peg\Lib\Settings::GetContributors();
 211:         $extension = \Peg\Lib\Settings::GetExtensionName();
 212:         $version = \Peg\Lib\Settings::GetVersion();
 213: 
 214:         $header_object = $this->symbols->headers[$header_name];
 215:         $header_define = $this->GetHeaderDefine($header_name);
 216: 
 217:         $header_content = "";
 218:         
 219:         if($header_object->HasClasses())
 220:         {
 221:             // Get heading of header file
 222:             ob_start();
 223:                 include($this->GetTemplatePath(
 224:                     $header_name, 
 225:                     "headers", 
 226:                     "header", 
 227:                     "classes", 
 228:                     "header"
 229:                 ));
 230:                 $header_content .= ob_get_contents();
 231:             ob_end_clean();
 232:         
 233:             foreach($header_object->namespaces as $namespace_name=>$namespace_object)
 234:             {
 235:                 if($namespace_name == "\\")
 236:                     $namespace_name = "";
 237: 
 238:                 $namespace_name_cpp = str_replace(
 239:                     "\\",
 240:                     "::",
 241:                     $namespace_name
 242:                 );
 243: 
 244:                 $namespace_name_var = str_replace(
 245:                     "\\",
 246:                     "_",
 247:                     $namespace_name
 248:                 );
 249:                 
 250:                 foreach($namespace_object->classes as $class_name=>$class_object)
 251:                 {
 252:                     $constructor_code = "";
 253:                     $virtual_methods_code = "";
 254:                     $properties_init_code = "";
 255:                     $properties_uninit_code = "";
 256:                     
 257:                     // Get class declaration code
 258:                     ob_start();
 259:                         include($this->GetTemplatePath(
 260:                             $class_name, 
 261:                             "", 
 262:                             "declaration", 
 263:                             "classes", 
 264:                             "declaration"
 265:                         ));
 266:                         $header_content .= ob_get_contents();
 267:                     ob_end_clean();
 268: 
 269:                     $header_content .= "\n";
 270:                 }
 271:             }
 272:             
 273:             // Get footer of header file
 274:             ob_start();
 275:                 include($this->GetTemplatePath(
 276:                     $header_name, 
 277:                     "headers", 
 278:                     "footer", 
 279:                     "classes", 
 280:                     "header"
 281:                 ));
 282:                 $header_content .= ob_get_contents();
 283:             ob_end_clean();
 284:         }
 285: 
 286:         return $header_content;
 287:     }
 288: 
 289:     /**
 290:      * Generates a specific header source file.
 291:      * @param string $header_name
 292:      * @return string Source code.
 293:      */
 294:     public function GenerateSource($header_name)
 295:     {
 296:         // Variables used by some template files.
 297:         $authors = \Peg\Lib\Settings::GetAuthors();
 298:         $contributors = \Peg\Lib\Settings::GetContributors();
 299:         $extension = \Peg\Lib\Settings::GetExtensionName();
 300:         $version = \Peg\Lib\Settings::GetVersion();
 301: 
 302:         $header_object = $this->symbols->headers[$header_name];
 303:         $header_define = $this->GetHeaderDefine($header_name);
 304:         $php_header_name = $this->GetHeaderNamePHP($header_name);
 305: 
 306:         $source_content = "";
 307: 
 308:         // Get heading of source file
 309:         ob_start();
 310:             include($this->GetTemplatePath(
 311:                 $header_name, 
 312:                 "sources", 
 313:                 "header", 
 314:                 "helpers", 
 315:                 "source"
 316:             ));
 317:             $source_content .= ob_get_contents();
 318:         ob_end_clean();
 319: 
 320:         // Get constants function template content
 321:         if($header_object->HasConstants() || $header_object->HasGlobalVariables())
 322:         {
 323:             // Constants function heading
 324:             ob_start();
 325:                 include($this->GetTemplatePath(
 326:                     $header_name, 
 327:                     "constants", 
 328:                     "function_header", 
 329:                     "helpers", 
 330:                     "constant"
 331:                 ));
 332:                 $source_content .= ob_get_contents();
 333:             ob_end_clean();
 334: 
 335:             foreach($header_object->namespaces as $namespace_name=>$namespace_object)
 336:             {
 337:                 if($namespace_name == "\\")
 338:                     $namespace_name = "";
 339: 
 340:                 $namespace_name_cpp = str_replace(
 341:                     "\\",
 342:                     "::",
 343:                     $namespace_name
 344:                 );
 345: 
 346:                 $namespace_name_var = str_replace(
 347:                     "\\",
 348:                     "_",
 349:                     $namespace_name
 350:                 );
 351: 
 352:                 foreach($namespace_object->constants as $constant_name=>$constant_object)
 353:                 {
 354:                     ob_start();
 355:                         include($this->GetRegisterConstantTemplate($constant_name));
 356:                         $source_content .= $this->Indent(ob_get_contents(), 4);
 357:                     ob_end_clean();
 358:                 }
 359: 
 360:                 foreach($namespace_object->global_variables as $constant_name=>$constant_object)
 361:                 {
 362:                     ob_start();
 363:                         include($this->GetRegisterVarConstantTemplate($constant_object));
 364:                         $source_content .= $this->Indent(ob_get_contents(), 4);
 365:                     ob_end_clean();
 366:                 }
 367:             }
 368: 
 369:             // Constants function footer
 370:             ob_start();
 371:                 include($this->GetTemplatePath(
 372:                     $header_name, 
 373:                     "constants", 
 374:                     "function_footer", 
 375:                     "helpers", 
 376:                     "constant"
 377:                 ));
 378:                 $source_content .= ob_get_contents();
 379:             ob_end_clean();
 380: 
 381:             $source_content .= "\n";
 382:         }
 383: 
 384:         // Get enums function template content
 385:         if($header_object->HasEnumerations())
 386:         {
 387:             // Enums function heading
 388:             ob_start();
 389:                 include($this->GetTemplatePath(
 390:                     $header_name, 
 391:                     "enums", 
 392:                     "function_header", 
 393:                     "helpers", 
 394:                     "enum"
 395:                 ));
 396:                 $source_content .= ob_get_contents();
 397:             ob_end_clean();
 398: 
 399:             foreach($header_object->namespaces as $namespace_name=>$namespace_object)
 400:             {
 401:                 if($namespace_name == "\\")
 402:                     $namespace_name = "";
 403: 
 404:                 $namespace_name_cpp = str_replace(
 405:                     "\\",
 406:                     "::",
 407:                     $namespace_name
 408:                 );
 409: 
 410:                 $namespace_name_var = str_replace(
 411:                     "\\",
 412:                     "_",
 413:                     $namespace_name
 414:                 );
 415: 
 416:                 foreach($namespace_object->enumerations as $enum_name=>$enum_object)
 417:                 {
 418:                     ob_start();
 419:                         include($this->GetTemplatePath(
 420:                             $enum_name, 
 421:                             "enums", 
 422:                             "declare_class", 
 423:                             "helpers", 
 424:                             "enum",
 425:                             $namespace_name
 426:                         ));
 427:                         $source_content .= $this->Indent(ob_get_contents(), 4);
 428:                     ob_end_clean();
 429: 
 430:                     foreach($enum_object->options as $enum_option)
 431:                     {
 432:                         ob_start();
 433:                             include($this->GetTemplatePath(
 434:                                 $enum_name, 
 435:                                 "enums", 
 436:                                 "declare_constant", 
 437:                                 "helpers", 
 438:                                 "enum",
 439:                                 $namespace_name
 440:                             ));
 441:                             $source_content .= $this->Indent(ob_get_contents(), 4);
 442:                         ob_end_clean();
 443:                     }
 444:                 }
 445:             }
 446: 
 447:             // Enums function footer
 448:             ob_start();
 449:                 include($this->GetTemplatePath(
 450:                     $header_name, 
 451:                     "enums", 
 452:                     "function_footer", 
 453:                     "helpers", 
 454:                     "enum"
 455:                 ));
 456:                 $source_content .= ob_get_contents();
 457:             ob_end_clean();
 458: 
 459:             $source_content .= "\n";
 460:         }
 461: 
 462:         // Get functions function template content
 463:         if($header_object->HasFunctions())
 464:         {
 465:             // Generate function wrappers
 466:             foreach($header_object->namespaces as $namespace_name=>$namespace_object)
 467:             {
 468:                 foreach($namespace_object->functions as $function_name=>$function_object)
 469:                 {
 470:                     $source_content .= $this->GenerateFunction($function_object);
 471:                 }
 472:             }
 473: 
 474:             // Generate functions registration code
 475:             
 476:             // Functions registration heading
 477:             ob_start();
 478:                 include($this->GetTemplatePath(
 479:                     $header_name, 
 480:                     "functions", 
 481:                     "function_header", 
 482:                     "helpers", 
 483:                     "function"
 484:                 ));
 485:                 $source_content .= ob_get_contents();
 486:             ob_end_clean();
 487: 
 488:             ob_start();
 489:                 include($this->GetTemplatePath(
 490:                     $header_name, 
 491:                     "functions", 
 492:                     "table_begin", 
 493:                     "helpers", 
 494:                     "function"
 495:                 ));
 496:                 $source_content .= $this->Indent(ob_get_contents(), 4);
 497:             ob_end_clean();
 498: 
 499:             foreach($header_object->namespaces as $namespace_name=>$namespace_object)
 500:             {
 501:                 if($namespace_name == "\\")
 502:                     $namespace_name = "";
 503: 
 504:                 $namespace_name_cpp = str_replace(
 505:                     "\\",
 506:                     "::",
 507:                     $namespace_name
 508:                 );
 509: 
 510:                 $namespace_name_var = str_replace(
 511:                     "\\",
 512:                     "_",
 513:                     $namespace_name
 514:                 );
 515: 
 516:                 foreach($namespace_object->functions as $function_name=>$function_object)
 517:                 {
 518:                     ob_start();
 519:                         include($this->GetTemplatePath(
 520:                             $header_name, 
 521:                             "functions", 
 522:                             "table_entry", 
 523:                             "helpers", 
 524:                             "function"
 525:                         ));
 526:                         $source_content .= $this->Indent(ob_get_contents(), 8);
 527:                     ob_end_clean();
 528:                 }
 529:             }
 530: 
 531:             ob_start();
 532:                 include($this->GetTemplatePath(
 533:                     $header_name, 
 534:                     "functions", 
 535:                     "table_end", 
 536:                     "helpers", 
 537:                     "function"
 538:                 ));
 539:                 $source_content .= $this->Indent(ob_get_contents(), 4);
 540:             ob_end_clean();
 541: 
 542:             ob_start();
 543:                 include($this->GetTemplatePath(
 544:                     $header_name, 
 545:                     "functions", 
 546:                     "table_register", 
 547:                     "helpers", 
 548:                     "function"
 549:                 ));
 550:                 $source_content .= $this->Indent(ob_get_contents(), 4);
 551:             ob_end_clean();
 552: 
 553:             // Functions registration footer
 554:             ob_start();
 555:                 include($this->GetTemplatePath(
 556:                     $header_name, 
 557:                     "functions", 
 558:                     "function_footer", 
 559:                     "helpers", 
 560:                     "function"
 561:                 ));
 562:                 $source_content .= ob_get_contents();
 563:             ob_end_clean();
 564: 
 565:             $source_content .= "\n";
 566:         }
 567: 
 568:         // Get footer of source file
 569:         ob_start();
 570:             include($this->GetTemplatePath(
 571:                 $header_name, 
 572:                 "sources", 
 573:                 "footer", 
 574:                 "helpers", 
 575:                 "source"
 576:             ));
 577:             $source_content .= ob_get_contents();
 578:         ob_end_clean();
 579: 
 580:         return $source_content;
 581:     }
 582: 
 583:     /**
 584:      * Generates the PHP wrapping code from a C/C++ function.
 585:      * @param \Peg\Lib\Definitions\Element\FunctionElement $function_object
 586:      * @return string PHP C/C++ code.
 587:      */
 588:     function GenerateFunction(
 589:         \Peg\Lib\Definitions\Element\FunctionElement $function_object
 590:     )
 591:     {
 592:         // Variables used by some template files.
 593:         $authors = \Peg\Lib\Settings::GetAuthors();
 594:         $contributors = \Peg\Lib\Settings::GetContributors();
 595:         $extension = \Peg\Lib\Settings::GetExtensionName();
 596:         $version = \Peg\Lib\Settings::GetVersion();
 597: 
 598:         $namespace_name = $function_object->namespace->name;
 599: 
 600:         if($namespace_name == "\\")
 601:             $namespace_name = "";
 602: 
 603:         $namespace_name_cpp = str_replace(
 604:             "\\",
 605:             "::",
 606:             $namespace_name
 607:         );
 608: 
 609:         $namespace_name_var = str_replace(
 610:             "\\",
 611:             "_",
 612:             $namespace_name
 613:         );
 614: 
 615:         $function_name = $function_object->name;
 616:         $function_arginfo = $this->GenerateArgInfo($function_object);
 617:         $overloads_count = count($function_object->overloads);
 618: 
 619:         $function_content = "";
 620: 
 621:         $parameters_code = "";
 622:         $parse_code = "";
 623:         $return_code = "";
 624: 
 625:         $proto_header = $this->GetProtoHeader($function_object);
 626:         $proto_footer = $this->GetProtoFooter();
 627: 
 628:         // Get header of function
 629:         ob_start();
 630:             include($this->GetTemplatePath(
 631:                 $function_name, 
 632:                 "function", 
 633:                 "head", 
 634:                 "functions", 
 635:                 "",
 636:                 $namespace_name
 637:             ));
 638:             $function_content .= ob_get_contents();
 639:         ob_end_clean();
 640: 
 641:          // Parameters declaration 
 642:         foreach($function_object->overloads as $overload=>$overload_object)
 643:         {
 644:             // Overload parameters declaration header
 645:             ob_start();
 646:                 include($this->GetTemplatePath(
 647:                     $function_name, 
 648:                     "overloads", 
 649:                     "parameters_header", 
 650:                     "helpers", 
 651:                     "overload",
 652:                     $namespace_name
 653:                 ));
 654:                 $parameters_code .= ob_get_contents();
 655:             ob_end_clean();
 656: 
 657:             foreach($overload_object->parameters as $parameter_name=>$parameter_object)
 658:             {
 659:                 // Overload parameter declarations
 660:                 ob_start();
 661:                     include($this->GetParameterTemplate($parameter_object, $namespace_name, "declare"));
 662:                     $parameters_code .= ob_get_contents();
 663:                 ob_end_clean();
 664:             }
 665:             
 666:             // Overload parameters declaration footer
 667:             ob_start();
 668:                 include($this->GetTemplatePath(
 669:                     $function_name, 
 670:                     "overloads", 
 671:                     "parameters_footer", 
 672:                     "helpers", 
 673:                     "overload",
 674:                     $namespace_name
 675:                 ));
 676:                 $parameters_code .= ob_get_contents();
 677:             ob_end_clean();
 678:         }
 679:         
 680:         // Parse parameters code
 681:         foreach($function_object->overloads as $overload=>$overload_object)
 682:         {
 683:             $parameters_count = $overload_object->GetParametersCount();
 684:             $required_parameters = $overload_object->GetRequiredParametersCount();
 685:             
 686:             // Overload parse header
 687:             ob_start();
 688:                 include($this->GetTemplatePath(
 689:                     $function_name, 
 690:                     "overloads", 
 691:                     "parse_header", 
 692:                     "helpers", 
 693:                     "overload",
 694:                     $namespace_name
 695:                 ));
 696:                 $parse_code .= ob_get_contents();
 697:             ob_end_clean();
 698:             
 699:             $parse_string = "";
 700:             $parameters_optional = false;
 701:             $parse_parameters = "";
 702:             
 703:             $parse_references = "";
 704:             $parse_string_ref = "";
 705:             $parse_reference = "";
 706:             $references_found = false;
 707:             
 708:             $object_validate_code = "";
 709:             
 710:             $parameter_index = 0;
 711:             foreach($overload_object->parameters as $parameter_name=>$parameter_object)
 712:             {
 713:                 if($parameter_object->default_value && !$parameters_optional)
 714:                 {
 715:                     $parse_string .= "|";
 716:                     $parse_string_ref = "|";
 717:                     $parameters_optional = true;
 718:                 }
 719:             
 720:                 ob_start();
 721:                     include($this->GetParameterTemplate($parameter_object, $namespace_name, "parse_string"));
 722:                     $parse_string .= ob_get_contents();
 723:                 ob_end_clean();
 724:                 
 725:                 ob_start();
 726:                     include($this->GetParameterTemplate($parameter_object, $namespace_name, "parse"));
 727:                     $parse_parameters .= ob_get_contents();
 728:                 ob_end_clean();
 729:                 
 730:                 if(!$parameter_object->is_const && $parameter_object->is_reference)
 731:                     $references_found = true;
 732:                 
 733:                 ob_start();
 734:                     include($this->GetParameterTemplate($parameter_object, $namespace_name, "parse_string_ref"));
 735:                     $parse_string_ref .= ob_get_contents();
 736:                 ob_end_clean();
 737:                 
 738:                 ob_start();
 739:                     include($this->GetParameterTemplate($parameter_object, $namespace_name, "parse_reference"));
 740:                     $parse_reference .= ob_get_contents();
 741:                 ob_end_clean();
 742:                 
 743:                 if(
 744:                     $this->symbols->GetStandardType($parameter_object)
 745:                     ==
 746:                     \Peg\Lib\Definitions\StandardType::OBJECT
 747:                 )
 748:                 {
 749:                     ob_start();
 750:                         include($this->GetParameterTemplate($parameter_object, $namespace_name, "object_validate"));
 751:                         $object_validate_code .= $this->Indent(ob_get_contents(), 4);
 752:                     ob_end_clean();
 753:                 }
 754:                 
 755:                 $parameter_index++;
 756:             }
 757:             
 758:             // No parameters to parse
 759:             if($required_parameters == 0 && $parameters_count < 1)
 760:             {
 761:                 // Overload no parse body
 762:                 ob_start();
 763:                     include($this->GetTemplatePath(
 764:                         $function_name, 
 765:                         "overloads", 
 766:                         "parse_no_body", 
 767:                         "helpers", 
 768:                         "overload",
 769:                         $namespace_name
 770:                     ));
 771:                     $parse_code .= $this->Indent(ob_get_contents(), 4);
 772:                 ob_end_clean();
 773:             }
 774:             // There is parameters to parse
 775:             else
 776:             {
 777:                 if($references_found)
 778:                 {
 779:                     // Overload parse references
 780:                     ob_start();
 781:                         include($this->GetTemplatePath(
 782:                             $function_name, 
 783:                             "overloads", 
 784:                             "parse_references", 
 785:                             "helpers", 
 786:                             "overload"
 787:                         ));
 788:                         $parse_references .= $this->Indent(ob_get_contents(), 4);
 789:                     ob_end_clean();
 790:                 }
 791:                 
 792:                 // Overload parse body
 793:                 ob_start();
 794:                     include($this->GetTemplatePath(
 795:                         $function_name, 
 796:                         "overloads", 
 797:                         "parse_body", 
 798:                         "helpers", 
 799:                         "overload",
 800:                         $namespace_name
 801:                     ));
 802:                     $parse_code .= $this->Indent(ob_get_contents(), 4);
 803:                 ob_end_clean();
 804:             }
 805: 
 806:             // Overload parse footer
 807:             ob_start();
 808:                 include($this->GetTemplatePath(
 809:                     $function_name, 
 810:                     "overloads", 
 811:                     "parse_footer", 
 812:                     "helpers", 
 813:                     "overload",
 814:                     $namespace_name
 815:                 ));
 816:                 $parse_code .= ob_get_contents();
 817:             ob_end_clean();
 818:         }
 819:         
 820:         // Return code
 821:         foreach($function_object->overloads as $overload=>$overload_object)
 822:         {
 823:             $parameters_count = $overload_object->GetParametersCount();
 824:             $required_parameters = $overload_object->GetRequiredParametersCount();
 825:             
 826:             $call_declare_code = "";
 827:             
 828:             // Optional declarations before proceeding to call an overload
 829:             $parameter_index = 0;
 830:             foreach($overload_object->parameters as $parameter_name=>$parameter_object)
 831:             {
 832:                 ob_start();
 833:                     include($this->GetParameterTemplate($parameter_object, "", "call_declare"));
 834:                     $call_declare_code .= $this->Indent(ob_get_contents(), 4);
 835:                 ob_end_clean();
 836:                 
 837:                 $parameter_index++;
 838:             }
 839:             
 840:             // Generate the overload return heading
 841:             ob_start();
 842:                 include($this->GetTemplatePath(
 843:                     $function_name, 
 844:                     "overloads", 
 845:                     "return_header", 
 846:                     "helpers", 
 847:                     "overload",
 848:                     $namespace_name
 849:                 ));
 850:                 $return_code .= ob_get_contents();
 851:             ob_end_clean();
 852:             
 853:             // Variables used by after call object template.
 854:             $class_name = "";
 855:             $is_constructor = false;
 856:             
 857:             for(
 858:                 $required_parameters; 
 859:                 $required_parameters<=$parameters_count; 
 860:                 $required_parameters++
 861:             )
 862:             {
 863:                 // Overload return body header
 864:                 ob_start();
 865:                     include($this->GetTemplatePath(
 866:                         $function_name, 
 867:                         "overloads", 
 868:                         "return_body_header", 
 869:                         "helpers", 
 870:                         "overload",
 871:                         $namespace_name
 872:                     ));
 873:                     $return_code .= $this->Indent(ob_get_contents(), 8);
 874:                 ob_end_clean();
 875:             
 876:                 $parameter_index = 0;
 877:                 $parameters_string = "";
 878:                 $after_call = "";
 879:                 
 880:                 foreach($overload_object->parameters as $parameter_name=>$parameter_object)
 881:                 {
 882:                     if($parameter_index<$required_parameters)
 883:                     {
 884:                         ob_start();
 885:                             include($this->GetParameterTemplate($parameter_object, "", "before_call"));
 886:                             $before_call = $this->Indent(ob_get_contents(), 12);
 887:                         ob_end_clean();
 888:                         
 889:                         if(trim($before_call))
 890:                             $return_code .= $before_call;
 891:                         
 892:                         ob_start();
 893:                             include($this->GetParameterTemplate($parameter_object, "", "call"));
 894:                             $parameters_string .= ob_get_contents();
 895:                         ob_end_clean();
 896:                         
 897:                         ob_start();
 898:                             include($this->GetParameterTemplate($parameter_object, "", "after_call"));
 899:                             $after_call .= ob_get_contents();
 900:                         ob_end_clean();
 901:                     }
 902:                     else
 903:                     {
 904:                         break;
 905:                     }
 906:                     
 907:                     $parameter_index++;
 908:                 }
 909:                 
 910:                 ob_start();
 911:                     include($this->GetReturnTemplate($overload_object->return_type, "", "function"));
 912:                     $return_code .= $this->Indent(ob_get_contents(), 12);
 913:                 ob_end_clean();
 914:                 
 915:                 $return_code .= $after_call;
 916:                 
 917:                 // Overload return body footer
 918:                 ob_start();
 919:                     include($this->GetTemplatePath(
 920:                         $function_name, 
 921:                         "overloads", 
 922:                         "return_body_footer", 
 923:                         "helpers", 
 924:                         "overload",
 925:                         $namespace_name
 926:                     ));
 927:                     $return_code .= $this->Indent(ob_get_contents(), 8);
 928:                 ob_end_clean();
 929:             }
 930: 
 931:             // Generate the overload return footer
 932:             ob_start();
 933:                 include($this->GetTemplatePath(
 934:                     $function_name, 
 935:                     "overloads", 
 936:                     "return_footer", 
 937:                     "helpers", 
 938:                     "overload",
 939:                     $namespace_name
 940:                 ));
 941:                 $return_code .= ob_get_contents();
 942:             ob_end_clean();
 943:         }
 944: 
 945:         // Get body of function
 946:         ob_start();
 947:             include($this->GetTemplatePath(
 948:                 $function_name, 
 949:                 "function", 
 950:                 "body", 
 951:                 "functions", 
 952:                 "",
 953:                 $namespace_name
 954:             ));
 955:             $function_content .= $this->Indent(ob_get_contents(), 4);
 956:         ob_end_clean();
 957: 
 958:         // Get footer of function
 959:         ob_start();
 960:             include($this->GetTemplatePath(
 961:                 $function_name, 
 962:                 "function", 
 963:                 "footer", 
 964:                 "functions", 
 965:                 "",
 966:                 $namespace_name
 967:             ));
 968:             $function_content .= ob_get_contents();
 969:         ob_end_clean();
 970: 
 971:         return $function_content;
 972:     }
 973:     
 974:     /**
 975:      * Generates an arginfo php C structure which is basically used for
 976:      * reflection to work properly.
 977:      * @param \Peg\Lib\Definitions\Element\FunctionElement $function_object
 978:      */
 979:     public function GenerateArgInfo(
 980:         \Peg\Lib\Definitions\Element\FunctionElement $function_object
 981:     )
 982:     {   
 983:         $namespace_name = $function_object->namespace->name;
 984: 
 985:         if($namespace_name == "\\")
 986:             $namespace_name = "";
 987: 
 988:         $namespace_name_cpp = str_replace(
 989:             "\\",
 990:             "::",
 991:             $namespace_name
 992:         );
 993: 
 994:         $namespace_name_var = str_replace(
 995:             "\\",
 996:             "_",
 997:             $namespace_name
 998:         );
 999:         
1000:         $arginfo_code = "";
1001:         
1002:         $function_name = $function_object->name;
1003:         
1004:         // Get the amount of required parameters from the 
1005:         // overload which require less.
1006:         $required_parameters = 1000;
1007:         
1008:         foreach($function_object->overloads as $overload=>$overload_object)
1009:         {
1010:             if($required_parameters > $overload_object->GetRequiredParametersCount())
1011:                 $required_parameters = $overload_object->GetRequiredParametersCount();
1012:         }
1013:         
1014:         // Generate a list of argument objects from the overload
1015:         // with the longest amount of parameters.
1016:         $arguments_list = array();
1017:         foreach($function_object->overloads as $overload=>$overload_object)
1018:         {
1019:             if($overload_object->HasParameters())
1020:             {
1021:                 if(count($arguments_list) < count($overload_object->parameters))
1022:                 {
1023:                     $index = 0;
1024:                     
1025:                     foreach($overload_object->parameters as $parameter_object)
1026:                     {
1027:                         $arguments_list[$index] = $parameter_object;
1028:                         
1029:                         $index++;
1030:                     }
1031:                 }
1032:             }
1033:         }
1034:         
1035:         // Get Header
1036:         ob_start();
1037:             include($this->GetTemplatePath(
1038:                 $function_name, 
1039:                 "arginfo", 
1040:                 "header", 
1041:                 "helpers", 
1042:                 "arginfo",
1043:                 $namespace_name
1044:             ));
1045:             $arginfo_code .= ob_get_contents();
1046:         ob_end_clean();
1047:         
1048:         foreach($arguments_list as $parameter_object)
1049:         {
1050:             $parameter_name = $parameter_object->name;
1051:             
1052:             // Generate the entry of arguments
1053:             ob_start();
1054:                 include($this->GetParameterTemplate($parameter_object, "", "arginfo"));
1055:                 $arginfo_code .= $this->Indent(ob_get_contents(), 4);
1056:             ob_end_clean();
1057:         }
1058:         
1059:         // Get Header
1060:         ob_start();
1061:             include($this->GetTemplatePath(
1062:                 $function_name, 
1063:                 "arginfo", 
1064:                 "footer", 
1065:                 "helpers", 
1066:                 "arginfo",
1067:                 $namespace_name
1068:             ));
1069:             $arginfo_code .= ob_get_contents();
1070:         ob_end_clean();
1071:         
1072:         return $arginfo_code;
1073:     }
1074:     
1075:     /**
1076:      * Generates other sources required to build the extension, eg:
1077:      * php_extension.h, extension.c
1078:      */
1079:     public function GenerateOtherSources()
1080:     {
1081:         // Variables used by some template files.
1082:         $authors = \Peg\Lib\Settings::GetAuthors();
1083:         $contributors = \Peg\Lib\Settings::GetContributors();
1084:         $extension = \Peg\Lib\Settings::GetExtensionName();
1085:         $version = \Peg\Lib\Settings::GetVersion();
1086:         
1087:         // Variable to temporarily store a template file content.
1088:         $content = "";
1089:         
1090:         // Generate all_headers.h
1091:         $headers = "";
1092:         foreach($this->symbols->headers as $header_name=>$header_object)
1093:         {
1094:             if($header_object->enabled)
1095:             {
1096:                 $headers .= '#include "'
1097:                     . $this->GetHeaderNamePHP($header_name)
1098:                     . '"' 
1099:                     . "\n"
1100:                 ;
1101:             }
1102:         }
1103:         
1104:         ob_start();
1105:             include($this->GetGenericTemplate("all_headers.h", "sources"));
1106:             $content = ob_get_contents();
1107:         ob_end_clean();
1108:         
1109:         $this->AddGenericFile("all_headers.h", $content, "includes");
1110:         
1111:         // Generate functions.h/cpp
1112:         ob_start();
1113:             include($this->GetGenericTemplate("functions.h", "sources"));
1114:             $content = ob_get_contents();
1115:         ob_end_clean();
1116:         
1117:         $this->AddGenericFile("functions.h", $content, "includes");
1118:         
1119:         ob_start();
1120:             include($this->GetGenericTemplate("functions.cpp", "sources"));
1121:             $content = ob_get_contents();
1122:         ob_end_clean();
1123:         
1124:         $this->AddGenericFile("functions.cpp", $content, "src");
1125:         
1126:         // Generate enums.h/c
1127:         ob_start();
1128:             include($this->GetGenericTemplate("enums.h", "sources"));
1129:             $content = ob_get_contents();
1130:         ob_end_clean();
1131:         
1132:         $this->AddGenericFile("enums.h", $content, "includes");
1133:         
1134:         ob_start();
1135:             include($this->GetGenericTemplate("enums.c", "sources"));
1136:             $content = ob_get_contents();
1137:         ob_end_clean();
1138:         
1139:         $this->AddGenericFile("enums.c", $content, "src");
1140:         
1141:         // Generate references.h/cpp
1142:         ob_start();
1143:             include($this->GetGenericTemplate("references.h", "sources"));
1144:             $content = ob_get_contents();
1145:         ob_end_clean();
1146:         
1147:         $this->AddGenericFile("references.h", $content, "includes");
1148:         
1149:         ob_start();
1150:             include($this->GetGenericTemplate("references.cpp", "sources"));
1151:             $content = ob_get_contents();
1152:         ob_end_clean();
1153:         
1154:         $this->AddGenericFile("references.cpp", $content, "src");
1155:         
1156:         // Generate php_extension.h/c
1157:         $constants_register = "";
1158:         $enums_register = "";
1159:         $functions_register = "";
1160:         $classes_register = "";
1161:         
1162:         foreach($this->symbols->headers as $header_name=>$header_object)
1163:         {
1164:             $header_define = $this->GetHeaderDefine($header_name);
1165:             
1166:             if($header_object->enabled)
1167:             {
1168:                 if($header_object->HasConstants())
1169:                 {
1170:                     ob_start();
1171:                         include($this->GetTemplatePath(
1172:                             $header_name, 
1173:                             "constants", 
1174:                             "function_call", 
1175:                             "helpers", 
1176:                             "constant"
1177:                         ));
1178:                         $constants_register .= ob_get_contents();
1179:                     ob_end_clean();
1180:                 }
1181:                 
1182:                 if($header_object->HasEnumerations())
1183:                 {
1184:                     ob_start();
1185:                         include($this->GetTemplatePath(
1186:                             $header_name, 
1187:                             "enums", 
1188:                             "function_call", 
1189:                             "helpers", 
1190:                             "enum"
1191:                         ));
1192:                         $enums_register .= ob_get_contents();
1193:                     ob_end_clean();
1194:                 }
1195:                 
1196:                 if($header_object->HasEnumerations())
1197:                 {
1198:                     ob_start();
1199:                         include($this->GetTemplatePath(
1200:                             $header_name, 
1201:                             "functions", 
1202:                             "function_call", 
1203:                             "helpers", 
1204:                             "function"
1205:                         ));
1206:                         $functions_register .= ob_get_contents();
1207:                     ob_end_clean();
1208:                 }
1209:                 
1210:                 if($header_object->HasClasses())
1211:                 {
1212:                     foreach($header_object->namespaces as $namespace_name=>$namespace_object)
1213:                     {
1214:                         if($namespace_name == "\\")
1215:                             $namespace_name = "";
1216: 
1217:                         $namespace_name_cpp = str_replace(
1218:                             "\\",
1219:                             "::",
1220:                             $namespace_name
1221:                         );
1222: 
1223:                         $namespace_name_var = str_replace(
1224:                             "\\",
1225:                             "_",
1226:                             $namespace_name
1227:                         );
1228:                         
1229:                         foreach($namespace_object->classes as $class_name=>$class_object)
1230:                         {   
1231:                             ob_start();
1232:                                 include($this->GetTemplatePath(
1233:                                     $class_name, 
1234:                                     "classes", 
1235:                                     "function_call", 
1236:                                     "helpers", 
1237:                                     "class"
1238:                                 ));
1239:                                 $classes_register .= ob_get_contents();
1240:                             ob_end_clean();
1241:                         }
1242:                     }
1243:                 }
1244:             }
1245:         }
1246:         
1247:         $constants_register = $this->Indent($constants_register, 8);
1248:         $enums_register = $this->Indent($enums_register, 8);
1249:         $functions_register = $this->Indent($functions_register, 8);
1250:         $classes_register = $this->Indent($classes_register, 4);
1251:         
1252:         ob_start();
1253:             include($this->GetGenericTemplate("php_extension.h", "sources"));
1254:             $content = ob_get_contents();
1255:         ob_end_clean();
1256:         
1257:         $this->AddGenericFile("php_" . strtolower($extension) . ".h", $content);
1258:         
1259:         ob_start();
1260:             include($this->GetGenericTemplate("extension.c", "sources"));
1261:             $content = ob_get_contents();
1262:         ob_end_clean();
1263:         
1264:         $this->AddGenericFile(strtolower($extension) . ".c", $content);
1265:         
1266:         // Generate object_types.h
1267:         $object_types = "";
1268:         foreach($this->symbols->headers as $header_name=>$header_object)
1269:         {
1270:             foreach($header_object->namespaces as $namespace_name=>$namespace_object)
1271:             {
1272:                 if($namespace_name == "\\")
1273:                     $namespace_name = "";
1274: 
1275:                 $namespace_name_var = strtoupper(
1276:                         str_replace(
1277:                         "\\",
1278:                         "_",
1279:                         $namespace_name
1280:                     )
1281:                 );
1282:         
1283:                 foreach($namespace_object->classes as $class_name=>$class_object)
1284:                 {
1285:                     if($namespace_name)
1286:                     {
1287:                         $object_types .= "PHP_" 
1288:                             . $namespace_name_var . "_"
1289:                             . strtoupper($class_name) 
1290:                             . "_TYPE,"
1291:                             . "\n    "
1292:                         ;
1293:                     }
1294:                     else
1295:                     {
1296:                         $object_types .= "PHP_" 
1297:                             . strtoupper($class_name) 
1298:                             . "_TYPE,"
1299:                             . "\n    "
1300:                         ;
1301:                     }
1302:                 }
1303:             }
1304:         }
1305:         
1306:         $object_types = rtrim($object_types, "\n, ") . "\n";
1307:         
1308:         ob_start();
1309:             include($this->GetGenericTemplate("object_types.h", "sources"));
1310:             $content = ob_get_contents();
1311:         ob_end_clean();
1312:         
1313:         $this->AddGenericFile("object_types.h", $content, "includes");
1314:     }
1315:     
1316:     /**
1317:      * Generates config.m4 and config.w32.
1318:      */
1319:     public function GenerateConfigs()
1320:     {
1321:         // Variables used by some template files.
1322:         $authors = \Peg\Lib\Settings::GetAuthors();
1323:         $contributors = \Peg\Lib\Settings::GetContributors();
1324:         $extension = \Peg\Lib\Settings::GetExtensionName();
1325:         $version = \Peg\Lib\Settings::GetVersion();
1326:         
1327:         // Variable to temporarily store a template file content.
1328:         $content = "";
1329:         
1330:         // Generate sources list
1331:         $source_files = array(
1332:             "enums.c",
1333:             "functions.cpp",
1334:             "references.cpp"
1335:         );
1336:         
1337:         foreach($this->symbols->headers as $header_name=>$header_object)
1338:         {
1339:             if($header_object->enabled)
1340:             {
1341:                 $source_files[] = $this->GetSourceNamePHP($header_name);
1342:             }
1343:         }
1344:         
1345:         // Generate custom sources list
1346:         $custom_sources = $this->GetCustomSources();
1347:         
1348:         if(count($custom_sources) > 0)
1349:         {
1350:             foreach($custom_sources as $custom_source)
1351:             {
1352:                 if($custom_source != "." && $custom_source != "..")
1353:                 {
1354:                     if(
1355:                         (strpos($custom_source, ".c") !== false)
1356:                         ||
1357:                         (strpos($custom_source, ".cpp") !== false)
1358:                     )
1359:                     {
1360:                         $source_files[] = $custom_source;
1361:                     }
1362:                 }
1363:             }
1364:         }
1365:         
1366:         $source_files = implode(" ", $source_files);
1367:         
1368:         // Generate config.m4
1369:         ob_start();
1370:             include($this->GetGenericTemplate("config.m4", "configs"));
1371:             $content = ob_get_contents();
1372:         ob_end_clean();
1373:         
1374:         $this->AddGenericFile("config.m4", $content);
1375:         
1376:         // Generate config.w32
1377:         ob_start();
1378:             include($this->GetGenericTemplate("config.w32", "configs"));
1379:             $content = ob_get_contents();
1380:         ob_end_clean();
1381:         
1382:         $this->AddGenericFile("config.w32", $content);
1383:     }
1384:     
1385:     /**
1386:      * Generates sources from the custom_sources templates directory.
1387:      */
1388:     public function GenerateCustomSources()
1389:     {
1390:         // Variables used by some template files.
1391:         $authors = \Peg\Lib\Settings::GetAuthors();
1392:         $contributors = \Peg\Lib\Settings::GetContributors();
1393:         $extension = \Peg\Lib\Settings::GetExtensionName();
1394:         $version = \Peg\Lib\Settings::GetVersion();
1395:         
1396:         // Variable to temporarily store a template file content.
1397:         $content = "";
1398:         
1399:         // Generate custom sources list
1400:         $custom_sources = $this->GetCustomSources();
1401:         
1402:         if(count($custom_sources) > 0)
1403:         {
1404:             foreach($custom_sources as $custom_source)
1405:             {
1406:                 if($custom_source != "." && $custom_source != "..")
1407:                 {
1408:                     ob_start();
1409:                         include($this->GetGenericTemplate(
1410:                             $custom_source, "custom_sources"
1411:                         ));
1412:                         $content = ob_get_contents();
1413:                     ob_end_clean();
1414:         
1415:                     if(
1416:                         (strpos($custom_source, ".c") !== false)
1417:                         ||
1418:                         (strpos($custom_source, ".cpp") !== false)
1419:                     )
1420:                     {
1421:                         $this->AddGenericFile(
1422:                             $custom_source, 
1423:                             $content, 
1424:                             "src"
1425:                         );
1426:                     }
1427:                     elseif(
1428:                         (strpos($custom_source, ".h") !== false)
1429:                         ||
1430:                         (strpos($custom_source, ".hpp") !== false)
1431:                     )
1432:                     {
1433:                         $this->AddGenericFile(
1434:                             $custom_source, 
1435:                             $content, 
1436:                             "includes"
1437:                         );
1438:                     }
1439:                 }
1440:             }
1441:         }
1442:     }
1443:     
1444:     /**
1445:      * Generates proto doc comments header for a function.
1446:      * @param \Peg\Lib\Definitions\Element\FunctionElement $function
1447:      * @return string
1448:      */
1449:     public function GetProtoHeader(
1450:         \Peg\Lib\Definitions\Element\FunctionElement $function
1451:     )
1452:     {
1453:         $proto = "/* {{{ ";
1454:         
1455:         foreach($function->overloads as $overload)
1456:         {
1457:             $proto .= "proto ";
1458:             
1459:             $proto .= $this->symbols->GetPHPStandardType($overload->return_type);
1460:             
1461:             $proto .= " " . $overload->function->name . "(";
1462:             
1463:             foreach($overload->parameters as $parameter)
1464:             {
1465:                 $proto .= $this->symbols->GetPHPStandardType($parameter);
1466:                 
1467:                 if(!$parameter->is_const && ($parameter->is_pointer || $parameter->is_reference))
1468:                 {
1469:                     $proto .= " &" . $parameter->name;
1470:                 }
1471:                 else
1472:                 {
1473:                     $proto .= " " . $parameter->name;
1474:                 }
1475:                 
1476:                 if($parameter->default_value)
1477:                 {
1478:                     $proto .= " = " . $parameter->default_value; 
1479:                 }
1480:                 
1481:                 $proto .= ", ";
1482:             }
1483:             
1484:             $proto = rtrim($proto, ", ");
1485:             
1486:             $proto .= ")";
1487:             
1488:             if($overload->description)
1489:                 $proto .= "\n       " . $overload->description;
1490:             
1491:             $proto .= "\n       ";
1492:         }
1493:         
1494:         $proto = rtrim($proto, " \n");
1495:         
1496:         $proto .= " */\n";
1497:         
1498:         return $proto;
1499:     }
1500:     
1501:     /**
1502:      * Generates proto doc comments footer.
1503:      * @return string
1504:      */
1505:     public function GetProtoFooter()
1506:     {
1507:         return "/* }}} */\n";
1508:     }
1509: 
1510:     /**
1511:      * Retrieve the template path for registering constants, also checks
1512:      * if a valid override exists and returns that instead.
1513:      * @todo Improve this to handle various types.
1514:      * @param string $name Name of constant.
1515:      * @param string $namespace Namespace where resides the constant.
1516:      * @return string Path to template file.
1517:      */
1518:     public function GetRegisterConstantTemplate($name, $namespace="", $type="")
1519:     {
1520:         if($namespace)
1521:         {
1522:             $namespace = str_replace(
1523:                 array("\\", "::"),
1524:                 "_",
1525:                 $namespace
1526:             ) . "_";
1527:         }
1528: 
1529:         $override = $this->templates_path
1530:             . "constants/overrides/"
1531:             . "define_{$name}"
1532:             . ".php"
1533:         ;
1534: 
1535:         if(file_exists($override))
1536:         {
1537:             return $override;
1538:         }
1539: 
1540:         return $this->templates_path
1541:             . "constants/"
1542:             . "integer.php"
1543:         ;
1544:     }
1545: 
1546:     /**
1547:      * Retrieve the template path for registering constants registered as global
1548:      * variables, also checks if a valid override exists and returns that instead.
1549:      * @param \Peg\Lib\Definitions\Element\GlobalVariable $variable
1550:      * @param string $namespace Namespace where resides the constant.
1551:      * @return string Path to template file.
1552:      */
1553:     public function GetRegisterVarConstantTemplate(
1554:         \Peg\Lib\Definitions\Element\GlobalVariable $variable,
1555:         $namespace=""
1556:     )
1557:     {
1558:         if($namespace)
1559:         {
1560:             $namespace = str_replace(
1561:                 array("\\", "::"),
1562:                 "_",
1563:                 $namespace
1564:             ) . "_";
1565:         }
1566: 
1567:         $ptr = "";
1568:         if($variable->is_pointer)
1569:         {
1570:             for($i=0; $i<$variable->indirection_level; $i++)
1571:             {
1572:                 $ptr .= "_ptr";
1573:             }
1574:         }
1575: 
1576:         $ref = "";
1577:         if($variable->is_reference)
1578:         {
1579:             $ref .= "_ref";
1580:         }
1581: 
1582:         $array = "";
1583:         if($variable->is_array)
1584:         {
1585:             $array .= "_arr";
1586:         }
1587: 
1588:         $override = $this->templates_path
1589:             . "constants/overrides/"
1590:             . $variable->type
1591:             . $ptr
1592:             . $ref
1593:             . $array
1594:             . ".php"
1595:         ;
1596: 
1597:         if(file_exists($override))
1598:         {
1599:             return $override;
1600:         }
1601: 
1602:         $standard_type = $this->symbols->GetStandardType($variable);
1603: 
1604:         $template = $this->templates_path
1605:             . "constants/"
1606:             . $standard_type
1607:             . $ptr
1608:             . $ref
1609:             . $array
1610:             . ".php"
1611:         ;
1612: 
1613:         if(!file_exists($template))
1614:         {
1615:             return $this->templates_path
1616:                 . "constants/"
1617:                 . "default.php"
1618:             ;
1619:         }
1620: 
1621:         return $template;
1622:     }
1623: }