CMakeLua/Source/cmCPluginAPI.cxx

   1 /*=========================================================================
   2
   3   Program:   CMake - Cross-Platform Makefile Generator
   4   Module:    $RCSfile: cmCPluginAPI.cxx,v $
   5   Language:  C++
   6 <<<<<<< cmCPluginAPI.cxx
   7   Date:      $Date: 2008/01/23 15:27:59 $
   8   Version:   $Revision: 1.42 $
   9 =======
  10   Date:      $Date: 2009-03-16 18:30:24 $
  11   Version:   $Revision: 1.43 $
  12 >>>>>>> 1.43
  13
  14   Copyright (c) 2002 Kitware, Inc., Insight Consortium.  All rights reserved.
  15   See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
  16
  17      This software is distributed WITHOUT ANY WARRANTY; without even
  18      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  19      PURPOSE.  See the above copyright notices for more information.
  20
  21 =========================================================================*/
  22 /*
  23    this file contains the implementation of the C API to CMake. Generally
  24    these routines just manipulate arguments and then call the associated
  25    methods on the CMake classes. */
  26
  27 #include "cmMakefile.h"
  28 #include "cmCPluginAPI.h"
  29 #include "cmVersion.h"
  30
  31 #include "cmSourceFile.h"
  32
  33 #include <stdlib.h>
  34
  35 #ifdef __QNX__
  36 # include <malloc.h> /* for malloc/free on QNX */
  37 #endif
  38
  39 extern "C"
  40 {
  41
  42 void CCONV *cmGetClientData(void *info)
  43 {
  44   return ((cmLoadedCommandInfo *)info)->ClientData;
  45 }
  46
  47 void CCONV cmSetClientData(void *info, void *cd)
  48 {
  49   ((cmLoadedCommandInfo *)info)->ClientData = cd;
  50 }
  51
  52 void CCONV cmSetError(void *info, const char *err)
  53 {
  54   if (((cmLoadedCommandInfo *)info)->Error)
  55     {
  56     free(((cmLoadedCommandInfo *)info)->Error);
  57     }
  58   ((cmLoadedCommandInfo *)info)->Error = strdup(err);
  59 }
  60
  61 unsigned int CCONV  cmGetCacheMajorVersion(void *arg)
  62 {
  63   cmMakefile *mf = static_cast<cmMakefile *>(arg);
  64   return mf->GetCacheMajorVersion();
  65 }
  66 unsigned int CCONV cmGetCacheMinorVersion(void *arg)
  67 {
  68   cmMakefile *mf = static_cast<cmMakefile *>(arg);
  69   return mf->GetCacheMinorVersion();
  70 }
  71
  72 unsigned int CCONV cmGetMajorVersion(void *)
  73 {
  74   return cmVersion::GetMajorVersion();
  75 }
  76
  77 unsigned int CCONV cmGetMinorVersion(void *)
  78 {
  79   return cmVersion::GetMinorVersion();
  80 }
  81
  82 void CCONV cmAddDefinition(void *arg, const char* name, const char* value)
  83 {
  84   cmMakefile *mf = static_cast<cmMakefile *>(arg);
  85   mf->AddDefinition(name,value);
  86 }
  87
  88 /* Add a definition to this makefile and the global cmake cache. */
  89 void CCONV cmAddCacheDefinition(void *arg, const char* name,
  90   const char* value, const char* doc, int type)
  91 {
  92   cmMakefile *mf = static_cast<cmMakefile *>(arg);
  93
  94   switch (type)
  95     {
  96     case CM_CACHE_BOOL:
  97       mf->AddCacheDefinition(name,value,doc,
  98                              cmCacheManager::BOOL);
  99       break;
 100     case CM_CACHE_PATH:
 101       mf->AddCacheDefinition(name,value,doc,
 102                              cmCacheManager::PATH);
 103       break;
 104     case CM_CACHE_FILEPATH:
 105       mf->AddCacheDefinition(name,value,doc,
 106                              cmCacheManager::FILEPATH);
 107       break;
 108     case CM_CACHE_STRING:
 109       mf->AddCacheDefinition(name,value,doc,
 110                              cmCacheManager::STRING);
 111       break;
 112     case CM_CACHE_INTERNAL:
 113       mf->AddCacheDefinition(name,value,doc,
 114                              cmCacheManager::INTERNAL);
 115       break;
 116     case CM_CACHE_STATIC:
 117       mf->AddCacheDefinition(name,value,doc,
 118                              cmCacheManager::STATIC);
 119       break;
 120     }
 121 }
 122
 123 const char* CCONV cmGetProjectName(void *arg)
 124 {
 125   cmMakefile *mf = static_cast<cmMakefile *>(arg);
 126   return mf->GetProjectName();
 127 }
 128
 129 const char* CCONV cmGetHomeDirectory(void *arg)
 130 {
 131   cmMakefile *mf = static_cast<cmMakefile *>(arg);
 132   return mf->GetHomeDirectory();
 133 }
 134 const char* CCONV cmGetHomeOutputDirectory(void *arg)
 135 {
 136   cmMakefile *mf = static_cast<cmMakefile *>(arg);
 137   return mf->GetHomeOutputDirectory();
 138 }
 139 const char* CCONV cmGetStartDirectory(void *arg)
 140 {
 141   cmMakefile *mf = static_cast<cmMakefile *>(arg);
 142   return mf->GetStartDirectory();
 143 }
 144 const char* CCONV cmGetStartOutputDirectory(void *arg)
 145 {
 146   cmMakefile *mf = static_cast<cmMakefile *>(arg);
 147   return mf->GetStartOutputDirectory();
 148 }
 149 const char* CCONV cmGetCurrentDirectory(void *arg)
 150 {
 151   cmMakefile *mf = static_cast<cmMakefile *>(arg);
 152   return mf->GetCurrentDirectory();
 153 }
 154 const char* CCONV cmGetCurrentOutputDirectory(void *arg)
 155 {
 156   cmMakefile *mf = static_cast<cmMakefile *>(arg);
 157   return mf->GetCurrentOutputDirectory();
 158 }
 159 const char* CCONV cmGetDefinition(void *arg,const char*def)
 160 {
 161   cmMakefile *mf = static_cast<cmMakefile *>(arg);
 162   return mf->GetDefinition(def);
 163 }
 164
 165 int CCONV cmIsOn(void *arg, const char* name)
 166 {
 167   cmMakefile *mf = static_cast<cmMakefile *>(arg);
 168   return static_cast<int>(mf->IsOn(name));
 169 }
 170
 171 /** Check if a command exists. */
 172 int CCONV cmCommandExists(void *arg, const char* name)
 173 {
 174   cmMakefile *mf = static_cast<cmMakefile *>(arg);
 175   return static_cast<int>(mf->CommandExists(name));
 176 }
 177
 178 void CCONV cmAddDefineFlag(void *arg, const char* definition)
 179 {
 180   cmMakefile *mf = static_cast<cmMakefile *>(arg);
 181   mf->AddDefineFlag(definition);
 182 }
 183
 184 void CCONV cmAddLinkDirectoryForTarget(void *arg, const char *tgt,
 185   const char* d)
 186 {
 187   cmMakefile *mf = static_cast<cmMakefile *>(arg);
 188   mf->AddLinkDirectoryForTarget(tgt,d);
 189 }
 190
 191
 192 void CCONV cmAddExecutable(void *arg, const char *exename,
 193                      int numSrcs, const char **srcs, int win32)
 194 {
 195   cmMakefile *mf = static_cast<cmMakefile *>(arg);
 196   std::vector<std::string> srcs2;
 197   int i;
 198   for (i = 0; i < numSrcs; ++i)
 199     {
 200     srcs2.push_back(srcs[i]);
 201     }
 202  cmTarget* tg =  mf->AddExecutable(exename, srcs2);
 203  if ( win32 )
 204    {
 205    tg->SetProperty("WIN32_EXECUTABLE", "ON");
 206    }
 207 }
 208
 209 void CCONV cmAddUtilityCommand(void *arg, const char* utilityName,
 210                          const char* command,
 211                          const char* arguments,
 212                          int all,
 213                          int numDepends,
 214                          const char **depends,
 215                          int,
 216                          const char **)
 217 {
 218   // Get the makefile instance.  Perform an extra variable expansion
 219   // now because the API caller expects it.
 220   cmMakefile* mf = static_cast<cmMakefile*>(arg);
 221
 222   // Construct the command line for the command.
 223   cmCustomCommandLine commandLine;
 224   std::string expand = command;
 225   commandLine.push_back(mf->ExpandVariablesInString(expand));
 226   if(arguments && arguments[0])
 227     {
 228     // TODO: Parse arguments!
 229     expand = arguments;
 230     commandLine.push_back(mf->ExpandVariablesInString(expand));
 231     }
 232   cmCustomCommandLines commandLines;
 233   commandLines.push_back(commandLine);
 234
 235   // Accumulate the list of dependencies.
 236   std::vector<std::string> depends2;
 237   for(int i = 0; i < numDepends; ++i)
 238     {
 239     expand = depends[i];
 240     depends2.push_back(mf->ExpandVariablesInString(expand));
 241     }
 242
 243   // Pass the call to the makefile instance.
 244   mf->AddUtilityCommand(utilityName, (all ? false : true),
 245                         0, depends2, commandLines);
 246 }
 247 void CCONV cmAddCustomCommand(void *arg, const char* source,
 248                         const char* command,
 249                         int numArgs, const char **args,
 250                         int numDepends, const char **depends,
 251                         int numOutputs, const char **outputs,
 252                         const char *target)
 253 {
 254   // Get the makefile instance.  Perform an extra variable expansion
 255   // now because the API caller expects it.
 256   cmMakefile* mf = static_cast<cmMakefile*>(arg);
 257
 258   // Construct the command line for the command.
 259   cmCustomCommandLine commandLine;
 260   std::string expand = command;
 261   commandLine.push_back(mf->ExpandVariablesInString(expand));
 262   for(int i=0; i < numArgs; ++i)
 263     {
 264     expand = args[i];
 265     commandLine.push_back(mf->ExpandVariablesInString(expand));
 266     }
 267   cmCustomCommandLines commandLines;
 268   commandLines.push_back(commandLine);
 269
 270   // Accumulate the list of dependencies.
 271   std::vector<std::string> depends2;
 272   for(int i = 0; i < numDepends; ++i)
 273     {
 274     expand = depends[i];
 275     depends2.push_back(mf->ExpandVariablesInString(expand));
 276     }
 277
 278   // Accumulate the list of outputs.
 279   std::vector<std::string> outputs2;
 280   for(int i = 0; i < numOutputs; ++i)
 281     {
 282     expand = outputs[i];
 283     outputs2.push_back(mf->ExpandVariablesInString(expand));
 284     }
 285
 286   // Pass the call to the makefile instance.
 287   const char* no_comment = 0;
 288   mf->AddCustomCommandOldStyle(target, outputs2, depends2, source,
 289                                commandLines, no_comment);
 290 }
 291
 292 void CCONV cmAddCustomCommandToOutput(void *arg, const char* output,
 293                                 const char* command,
 294                                 int numArgs, const char **args,
 295                                 const char* main_dependency,
 296                                 int numDepends, const char **depends)
 297 {
 298   // Get the makefile instance.  Perform an extra variable expansion
 299   // now because the API caller expects it.
 300   cmMakefile* mf = static_cast<cmMakefile*>(arg);
 301
 302   // Construct the command line for the command.
 303   cmCustomCommandLine commandLine;
 304   std::string expand = command;
 305   commandLine.push_back(mf->ExpandVariablesInString(expand));
 306   for(int i=0; i < numArgs; ++i)
 307     {
 308     expand = args[i];
 309     commandLine.push_back(mf->ExpandVariablesInString(expand));
 310     }
 311   cmCustomCommandLines commandLines;
 312   commandLines.push_back(commandLine);
 313
 314   // Accumulate the list of dependencies.
 315   std::vector<std::string> depends2;
 316   for(int i = 0; i < numDepends; ++i)
 317     {
 318     expand = depends[i];
 319     depends2.push_back(mf->ExpandVariablesInString(expand));
 320     }
 321
 322   // Pass the call to the makefile instance.
 323   const char* no_comment = 0;
 324   const char* no_working_dir = 0;
 325   mf->AddCustomCommandToOutput(output, depends2, main_dependency,
 326                                commandLines, no_comment, no_working_dir);
 327 }
 328
 329 void CCONV cmAddCustomCommandToTarget(void *arg, const char* target,
 330                                 const char* command,
 331                                 int numArgs, const char **args,
 332                                 int commandType)
 333 {
 334   // Get the makefile instance.
 335   cmMakefile* mf = static_cast<cmMakefile*>(arg);
 336
 337   // Construct the command line for the command.  Perform an extra
 338   // variable expansion now because the API caller expects it.
 339   cmCustomCommandLine commandLine;
 340   std::string expand = command;
 341   commandLine.push_back(mf->ExpandVariablesInString(expand));
 342   for(int i=0; i < numArgs; ++i)
 343     {
 344     expand = args[i];
 345     commandLine.push_back(mf->ExpandVariablesInString(expand));
 346     }
 347   cmCustomCommandLines commandLines;
 348   commandLines.push_back(commandLine);
 349
 350   // Select the command type.
 351   cmTarget::CustomCommandType cctype = cmTarget::POST_BUILD;
 352   switch (commandType)
 353     {
 354     case CM_PRE_BUILD:
 355       cctype = cmTarget::PRE_BUILD;
 356       break;
 357     case CM_PRE_LINK:
 358       cctype = cmTarget::PRE_LINK;
 359       break;
 360     case CM_POST_BUILD:
 361       cctype = cmTarget::POST_BUILD;
 362       break;
 363     }
 364
 365   // Pass the call to the makefile instance.
 366   std::vector<std::string> no_depends;
 367   const char* no_comment = 0;
 368   const char* no_working_dir = 0;
 369   mf->AddCustomCommandToTarget(target, no_depends, commandLines,
 370                                cctype, no_comment, no_working_dir);
 371 }
 372
 373 void CCONV cmAddLinkLibraryForTarget(void *arg, const char *tgt,
 374   const char*value, int libtype)
 375 {
 376   cmMakefile *mf = static_cast<cmMakefile *>(arg);
 377
 378   switch (libtype)
 379     {
 380     case CM_LIBRARY_GENERAL:
 381       mf->AddLinkLibraryForTarget(tgt,value, cmTarget::GENERAL);
 382       break;
 383     case CM_LIBRARY_DEBUG:
 384       mf->AddLinkLibraryForTarget(tgt,value, cmTarget::DEBUG);
 385       break;
 386     case CM_LIBRARY_OPTIMIZED:
 387       mf->AddLinkLibraryForTarget(tgt,value, cmTarget::OPTIMIZED);
 388       break;
 389     }
 390 }
 391
 392 void CCONV cmAddLibrary(void *arg, const char *libname, int shared,
 393                   int numSrcs, const char **srcs)
 394 {
 395   cmMakefile *mf = static_cast<cmMakefile *>(arg);
 396   std::vector<std::string> srcs2;
 397   int i;
 398   for (i = 0; i < numSrcs; ++i)
 399     {
 400     srcs2.push_back(srcs[i]);
 401     }
 402   mf->AddLibrary(libname,
 403                  (shared? cmTarget::SHARED_LIBRARY : cmTarget::STATIC_LIBRARY),
 404                   srcs2);
 405 }
 406
 407 char CCONV *cmExpandVariablesInString(void *arg, const char *source,
 408                                 int escapeQuotes, int atOnly)
 409 {
 410   cmMakefile *mf = static_cast<cmMakefile *>(arg);
 411   std::string barf = source;
 412   std::string result =
 413     mf->ExpandVariablesInString(barf,
 414                                 (escapeQuotes ? true : false),
 415                                 (atOnly ? true : false));
 416   char *res = static_cast<char *>(malloc(result.size() + 1));
 417   if (result.size())
 418     {
 419     strcpy(res,result.c_str());
 420     }
 421   res[result.size()] = '\0';
 422   return res;
 423 }
 424
 425
 426 int CCONV cmExecuteCommand(void *arg, const char *name,
 427                      int numArgs, const char **args)
 428 {
 429   cmMakefile *mf = static_cast<cmMakefile *>(arg);
 430   cmListFileFunction lff;
 431   lff.Name = name;
 432   for(int i = 0; i < numArgs; ++i)
 433     {
 434     // Assume all arguments are quoted.
 435     lff.Arguments.push_back(cmListFileArgument(args[i], true,
 436                                                "[CMake-Plugin]", 0));
 437     }
 438   cmExecutionStatus status;
 439   return mf->ExecuteCommand(lff,status);
 440 }
 441
 442 void CCONV cmExpandSourceListArguments(void *arg,
 443                                  int numArgs,
 444                                  const char **args,
 445                                  int *resArgc,
 446                                  char ***resArgv,
 447                                  unsigned int startArgumentIndex)
 448 {
 449   cmMakefile *mf = static_cast<cmMakefile *>(arg);
 450   std::vector<std::string> result;
 451   std::vector<std::string> args2;
 452   int i;
 453   for (i = 0; i < numArgs; ++i)
 454     {
 455     args2.push_back(args[i]);
 456     }
 457   mf->ExpandSourceListArguments(args2, result, startArgumentIndex);
 458   int resargc = static_cast<int>(result.size());
 459   char **resargv = 0;
 460   if (resargc)
 461     {
 462     resargv = (char **)malloc(resargc*sizeof(char *));
 463     }
 464   for (i = 0; i < resargc; ++i)
 465     {
 466     resargv[i] = strdup(result[i].c_str());
 467     }
 468   *resArgc = resargc;
 469   *resArgv = resargv;
 470 }
 471
 472 void CCONV cmFreeArguments(int argc, char **argv)
 473 {
 474   int i;
 475   for (i = 0; i < argc; ++i)
 476     {
 477     free(argv[i]);
 478     }
 479   if (argv)
 480     {
 481     free(argv);
 482     }
 483 }
 484
 485 int CCONV cmGetTotalArgumentSize(int argc, char **argv)
 486 {
 487   int i;
 488   int result = 0;
 489   for (i = 0; i < argc; ++i)
 490     {
 491     if (argv[i])
 492       {
 493       result = result + static_cast<int>(strlen(argv[i]));
 494       }
 495     }
 496   return result;
 497 }
 498
 499 // Source file proxy object to support the old cmSourceFile/cmMakefile
 500 // API for source files.
 501 struct cmCPluginAPISourceFile
 502 {
 503   cmCPluginAPISourceFile(): RealSourceFile(0) {}
 504   cmSourceFile* RealSourceFile;
 505   std::string SourceName;
 506   std::string SourceExtension;
 507   std::string FullPath;
 508   std::vector<std::string> Depends;
 509   cmPropertyMap Properties;
 510 };
 511
 512 // Keep a map from real cmSourceFile instances stored in a makefile to
 513 // the CPluginAPI proxy source file.
 514 class cmCPluginAPISourceFileMap:
 515   public std::map<cmSourceFile*, cmCPluginAPISourceFile*>
 516 {
 517 public:
 518   typedef std::map<cmSourceFile*, cmCPluginAPISourceFile*> derived;
 519   typedef derived::iterator iterator;
 520   typedef derived::value_type value_type;
 521   ~cmCPluginAPISourceFileMap()
 522     {
 523     for(iterator i=this->begin(); i != this->end(); ++i)
 524       {
 525       delete i->second;
 526       }
 527     }
 528 };
 529 cmCPluginAPISourceFileMap cmCPluginAPISourceFiles;
 530
 531 void * CCONV cmCreateSourceFile()
 532 {
 533   return (void*)new cmCPluginAPISourceFile;
 534 }
 535
 536 void * CCONV cmCreateNewSourceFile(void *arg)
 537 {
 538   cmMakefile *mf = static_cast<cmMakefile *>(arg);
 539   cmCPluginAPISourceFile *sf = new cmCPluginAPISourceFile;
 540   sf->Properties.SetCMakeInstance(mf->GetCMakeInstance());
 541   return (void*)sf;
 542 }
 543
 544 void CCONV cmDestroySourceFile(void *arg)
 545 {
 546   cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
 547   // Only delete if it was created by cmCreateSourceFile or
 548   // cmCreateNewSourceFile and is therefore not in the map.
 549   if(!sf->RealSourceFile)
 550     {
 551     delete sf;
 552     }
 553 }
 554
 555 void CCONV *cmGetSource(void *arg, const char *name)
 556 {
 557   cmMakefile *mf = static_cast<cmMakefile *>(arg);
 558   if(cmSourceFile* rsf = mf->GetSource(name))
 559     {
 560     // Lookup the proxy source file object for this source.
 561     cmCPluginAPISourceFileMap::iterator i = cmCPluginAPISourceFiles.find(rsf);
 562     if(i == cmCPluginAPISourceFiles.end())
 563       {
 564       // Create a proxy source file object for this source.
 565       cmCPluginAPISourceFile* sf = new cmCPluginAPISourceFile;
 566       sf->RealSourceFile = rsf;
 567       sf->FullPath = rsf->GetFullPath();
 568       sf->SourceName =
 569         cmSystemTools::GetFilenameWithoutLastExtension(sf->FullPath.c_str());
 570       sf->SourceExtension =
 571         cmSystemTools::GetFilenameLastExtension(sf->FullPath.c_str());
 572
 573       // Store the proxy in the map so it can be re-used and deleted later.
 574       cmCPluginAPISourceFileMap::value_type entry(rsf, sf);
 575       i = cmCPluginAPISourceFiles.insert(entry).first;
 576       }
 577     return (void *)i->second;
 578     }
 579   else
 580     {
 581     return 0;
 582     }
 583 }
 584
 585 void * CCONV cmAddSource(void *arg, void *arg2)
 586 {
 587   cmMakefile *mf = static_cast<cmMakefile *>(arg);
 588   cmCPluginAPISourceFile* osf = static_cast<cmCPluginAPISourceFile*>(arg2);
 589   if(osf->FullPath.empty())
 590     {
 591     return 0;
 592     }
 593
 594   // Create the real cmSourceFile instance and copy over saved information.
 595   cmSourceFile* rsf = mf->GetOrCreateSource(osf->FullPath.c_str());
 596   rsf->GetProperties() = osf->Properties;
 597   for(std::vector<std::string>::iterator i = osf->Depends.begin();
 598       i != osf->Depends.end(); ++i)
 599     {
 600     rsf->AddDepend(i->c_str());
 601     }
 602
 603   // Create the proxy for the real source file.
 604   cmCPluginAPISourceFile* sf = new cmCPluginAPISourceFile;
 605   sf->RealSourceFile = rsf;
 606   sf->FullPath = osf->FullPath;
 607   sf->SourceName = osf->SourceName;
 608   sf->SourceExtension = osf->SourceExtension;
 609
 610   // Store the proxy in the map so it can be re-used and deleted later.
 611   cmCPluginAPISourceFiles[rsf] = sf;
 612   return (void *)sf;
 613 }
 614
 615 const char * CCONV cmSourceFileGetSourceName(void *arg)
 616 {
 617   cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
 618   return sf->SourceName.c_str();
 619 }
 620
 621 const char * CCONV  cmSourceFileGetFullPath(void *arg)
 622 {
 623   cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
 624   return sf->FullPath.c_str();
 625 }
 626
 627 const char * CCONV  cmSourceFileGetProperty(void *arg,const char *prop)
 628 {
 629   cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
 630   if(cmSourceFile* rsf = sf->RealSourceFile)
 631     {
 632     return rsf->GetProperty(prop);
 633     }
 634   else
 635     {
 636     if(!strcmp(prop,"LOCATION"))
 637       {
 638       return sf->FullPath.c_str();
 639       }
 640     bool chain = false;
 641     // Ignore chain because old code will not expect it and it is a
 642     // pain to implement here anyway.
 643     return sf->Properties.GetPropertyValue(prop, cmProperty::SOURCE_FILE,
 644                                            chain);
 645     }
 646 }
 647
 648 int CCONV cmSourceFileGetPropertyAsBool(void *arg,const char *prop)
 649 {
 650   cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
 651   if(cmSourceFile* rsf = sf->RealSourceFile)
 652     {
 653     return rsf->GetPropertyAsBool(prop) ? 1:0;
 654     }
 655   else
 656     {
 657     return cmSystemTools::IsOn(cmSourceFileGetProperty(arg, prop))? 1:0;
 658     }
 659 }
 660
 661 void CCONV cmSourceFileSetProperty(void *arg,const char *prop,
 662                                    const char *value)
 663 {
 664   cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
 665   if(cmSourceFile* rsf = sf->RealSourceFile)
 666     {
 667     rsf->SetProperty(prop, value);
 668     }
 669   else if(prop)
 670     {
 671     if(!value) { value = "NOTFOUND"; }
 672     sf->Properties.SetProperty(prop, value, cmProperty::SOURCE_FILE);
 673     }
 674 }
 675
 676 void CCONV cmSourceFileAddDepend(void *arg, const char *depend)
 677 {
 678   cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
 679   if(cmSourceFile* rsf = sf->RealSourceFile)
 680     {
 681     rsf->AddDepend(depend);
 682     }
 683   else
 684     {
 685     sf->Depends.push_back(depend);
 686     }
 687 }
 688
 689 void CCONV cmSourceFileSetName(void *arg, const char* name, const char* dir,
 690                                int numSourceExtensions,
 691                                const char **sourceExtensions,
 692                                int numHeaderExtensions,
 693                                const char **headerExtensions)
 694 {
 695   cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
 696   if(sf->RealSourceFile)
 697     {
 698     // SetName is allowed only on temporary source files created by
 699     // the command for building and passing to AddSource.
 700     return;
 701     }
 702   std::vector<std::string> sourceExts;
 703   std::vector<std::string> headerExts;
 704   int i;
 705   for (i = 0; i < numSourceExtensions; ++i)
 706     {
 707     sourceExts.push_back(sourceExtensions[i]);
 708     }
 709   for (i = 0; i < numHeaderExtensions; ++i)
 710     {
 711     headerExts.push_back(headerExtensions[i]);
 712     }
 713
 714   // Save the original name given.
 715   sf->SourceName = name;
 716
 717   // Convert the name to a full path in case the given name is a
 718   // relative path.
 719   std::string pathname = cmSystemTools::CollapseFullPath(name, dir);
 720
 721   // First try and see whether the listed file can be found
 722   // as is without extensions added on.
 723   std::string hname = pathname;
 724   if(cmSystemTools::FileExists(hname.c_str()))
 725     {
 726     sf->SourceName = cmSystemTools::GetFilenamePath(name);
 727     if ( sf->SourceName.size() > 0 )
 728       {
 729       sf->SourceName += "/";
 730       }
 731     sf->SourceName += cmSystemTools::GetFilenameWithoutLastExtension(name);
 732     std::string::size_type pos = hname.rfind('.');
 733     if(pos != std::string::npos)
 734       {
 735       sf->SourceExtension = hname.substr(pos+1, hname.size()-pos);
 736       if ( cmSystemTools::FileIsFullPath(name) )
 737         {
 738         std::string::size_type pos2 = hname.rfind('/');
 739         if(pos2 != std::string::npos)
 740           {
 741           sf->SourceName = hname.substr(pos2+1, pos - pos2-1);
 742           }
 743         }
 744       }
 745
 746     sf->FullPath = hname;
 747     return;
 748     }
 749
 750   // Next, try the various source extensions
 751   for( std::vector<std::string>::const_iterator ext = sourceExts.begin();
 752        ext != sourceExts.end(); ++ext )
 753     {
 754     hname = pathname;
 755     hname += ".";
 756     hname += *ext;
 757     if(cmSystemTools::FileExists(hname.c_str()))
 758       {
 759       sf->SourceExtension = *ext;
 760       sf->FullPath = hname;
 761       return;
 762       }
 763     }
 764
 765   // Finally, try the various header extensions
 766   for( std::vector<std::string>::const_iterator ext = headerExts.begin();
 767        ext != headerExts.end(); ++ext )
 768     {
 769     hname = pathname;
 770     hname += ".";
 771     hname += *ext;
 772     if(cmSystemTools::FileExists(hname.c_str()))
 773       {
 774       sf->SourceExtension = *ext;
 775       sf->FullPath = hname;
 776       return;
 777       }
 778     }
 779
 780   cmOStringStream e;
 781   e << "Cannot find source file \"" << pathname << "\"";
 782   e << "\n\nTried extensions";
 783   for( std::vector<std::string>::const_iterator ext = sourceExts.begin();
 784        ext != sourceExts.end(); ++ext )
 785     {
 786     e << " ." << *ext;
 787     }
 788   for( std::vector<std::string>::const_iterator ext = headerExts.begin();
 789        ext != headerExts.end(); ++ext )
 790     {
 791     e << " ." << *ext;
 792     }
 793   cmSystemTools::Error(e.str().c_str());
 794   return;
 795 }
 796
 797 void CCONV cmSourceFileSetName2(void *arg, const char* name, const char* dir,
 798                                 const char *ext, int headerFileOnly)
 799 {
 800   cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
 801   if(sf->RealSourceFile)
 802     {
 803     // SetName is allowed only on temporary source files created by
 804     // the command for building and passing to AddSource.
 805     return;
 806     }
 807
 808   // Implement the old SetName method code here.
 809   if(headerFileOnly)
 810     {
 811     sf->Properties.SetProperty("HEADER_FILE_ONLY", "1",
 812                                cmProperty::SOURCE_FILE);
 813     }
 814   sf->SourceName = name;
 815   std::string fname = sf->SourceName;
 816   if(ext && strlen(ext))
 817     {
 818     fname += ".";
 819     fname += ext;
 820     }
 821   sf->FullPath = cmSystemTools::CollapseFullPath(fname.c_str(), dir);
 822   cmSystemTools::ConvertToUnixSlashes(sf->FullPath);
 823   sf->SourceExtension = ext;
 824 }
 825
 826 char * CCONV cmGetFilenameWithoutExtension(const char *name)
 827 {
 828   std::string sres = cmSystemTools::GetFilenameWithoutExtension(name);
 829   char *result = (char *)malloc(sres.size()+1);
 830   strcpy(result,sres.c_str());
 831   return result;
 832 }
 833
 834 char * CCONV cmGetFilenamePath(const char *name)
 835 {
 836   std::string sres = cmSystemTools::GetFilenamePath(name);
 837   char *result = (char *)malloc(sres.size()+1);
 838   strcpy(result,sres.c_str());
 839   return result;
 840 }
 841
 842 char * CCONV cmCapitalized(const char *name)
 843 {
 844   std::string sres = cmSystemTools::Capitalized(name);
 845   char *result = (char *)malloc(sres.size()+1);
 846   strcpy(result,sres.c_str());
 847   return result;
 848 }
 849
 850 void CCONV cmCopyFileIfDifferent(const char *name1, const char *name2)
 851 {
 852   cmSystemTools::CopyFileIfDifferent(name1,name2);
 853 }
 854
 855 void CCONV cmRemoveFile(const char *name)
 856 {
 857   cmSystemTools::RemoveFile(name);
 858 }
 859
 860 void CCONV cmDisplayStatus(void *arg, const char* message)
 861 {
 862   cmMakefile *mf = static_cast<cmMakefile *>(arg);
 863   mf->DisplayStatus(message, -1);
 864 }
 865
 866 void CCONV cmFree(void *data)
 867 {
 868   free(data);
 869 }
 870
 871 void CCONV DefineSourceFileProperty (void *arg, const char *name,
 872   const char *briefDocs,
 873   const char *longDocs,
 874   int chained)
 875 {
 876   cmMakefile *mf = static_cast<cmMakefile *>(arg);
 877   mf->GetCMakeInstance()->DefineProperty(name,cmProperty::SOURCE_FILE,
 878                                          briefDocs, longDocs,
 879                                          chained != 0);
 880 }
 881
 882 } // close the extern "C" scope
 883
 884 cmCAPI cmStaticCAPI =
 885 {
 886   cmGetClientData,
 887   cmGetTotalArgumentSize,
 888   cmFreeArguments,
 889   cmSetClientData,
 890   cmSetError,
 891   cmAddCacheDefinition,
 892   cmAddCustomCommand,
 893   cmAddDefineFlag,
 894   cmAddDefinition,
 895   cmAddExecutable,
 896   cmAddLibrary,
 897   cmAddLinkDirectoryForTarget,
 898   cmAddLinkLibraryForTarget,
 899   cmAddUtilityCommand,
 900   cmCommandExists,
 901   cmExecuteCommand,
 902   cmExpandSourceListArguments,
 903   cmExpandVariablesInString,
 904   cmGetCacheMajorVersion,
 905   cmGetCacheMinorVersion,
 906   cmGetCurrentDirectory,
 907   cmGetCurrentOutputDirectory,
 908   cmGetDefinition,
 909   cmGetHomeDirectory,
 910   cmGetHomeOutputDirectory,
 911   cmGetMajorVersion,
 912   cmGetMinorVersion,
 913   cmGetProjectName,
 914   cmGetStartDirectory,
 915   cmGetStartOutputDirectory,
 916   cmIsOn,
 917
 918   cmAddSource,
 919   cmCreateSourceFile,
 920   cmDestroySourceFile,
 921   cmGetSource,
 922   cmSourceFileAddDepend,
 923   cmSourceFileGetProperty,
 924   cmSourceFileGetPropertyAsBool,
 925   cmSourceFileGetSourceName,
 926   cmSourceFileGetFullPath,
 927   cmSourceFileSetName,
 928   cmSourceFileSetName2,
 929   cmSourceFileSetProperty,
 930
 931   cmCapitalized,
 932   cmCopyFileIfDifferent,
 933   cmGetFilenameWithoutExtension,
 934   cmGetFilenamePath,
 935   cmRemoveFile,
 936   cmFree,
 937
 938   cmAddCustomCommandToOutput,
 939   cmAddCustomCommandToTarget,
 940   cmDisplayStatus,
 941   cmCreateNewSourceFile,
 942   DefineSourceFileProperty,
 943 };
 944