cmLocalVisualStudio6Generator.cxx 55.5 KB
Newer Older
Ken Martin's avatar
Ken Martin committed
1
2
/*=========================================================================

3
  Program:   CMake - Cross-Platform Makefile Generator
Ken Martin's avatar
Ken Martin committed
4
5
6
7
8
  Module:    $RCSfile$
  Language:  C++
  Date:      $Date$
  Version:   $Revision$

9
10
  Copyright (c) 2002 Kitware, Inc., Insight Consortium.  All rights reserved.
  See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
Ken Martin's avatar
Ken Martin committed
11
12
13
14
15
16
17
18
19
20
21
22

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#include "cmGlobalGenerator.h"
#include "cmLocalVisualStudio6Generator.h"
#include "cmMakefile.h"
#include "cmSystemTools.h"
#include "cmSourceFile.h"
#include "cmCacheManager.h"
23
#include "cmake.h"
Ken Martin's avatar
Ken Martin committed
24

25
26
#include <cmsys/RegularExpression.hxx>

Ken Martin's avatar
Ken Martin committed
27
28
29
30
31
32
33
34
cmLocalVisualStudio6Generator::cmLocalVisualStudio6Generator()
{
}

cmLocalVisualStudio6Generator::~cmLocalVisualStudio6Generator()
{
}

Alexander Neundorf's avatar
   
Alexander Neundorf committed
35
36
void cmLocalVisualStudio6Generator::AddHelperCommands()
{
37
38
39
40
  std::set<cmStdString> lang;
  lang.insert("C");
  lang.insert("CXX");
  this->CreateCustomTargetsAndCommands(lang);
Alexander Neundorf's avatar
   
Alexander Neundorf committed
41
42
43
44
}

void cmLocalVisualStudio6Generator::Generate()
{
Ken Martin's avatar
Ken Martin committed
45
46
47
48
49
50
  this->OutputDSPFile();
}

void cmLocalVisualStudio6Generator::OutputDSPFile()
{ 
  // If not an in source build, then create the output directory
Ken Martin's avatar
Ken Martin committed
51
52
  if(strcmp(this->Makefile->GetStartOutputDirectory(),
            this->Makefile->GetHomeDirectory()) != 0)
Ken Martin's avatar
Ken Martin committed
53
    {
Ken Martin's avatar
Ken Martin committed
54
55
    if(!cmSystemTools::MakeDirectory
       (this->Makefile->GetStartOutputDirectory()))
Ken Martin's avatar
Ken Martin committed
56
57
      {
      cmSystemTools::Error("Error creating directory ",
Ken Martin's avatar
Ken Martin committed
58
                           this->Makefile->GetStartOutputDirectory());
Ken Martin's avatar
Ken Martin committed
59
60
61
      }
    }

62
63
64
65
66
67
  // Setup /I and /LIBPATH options for the resulting DSP file.  VS 6
  // truncates long include paths so make it as short as possible if
  // the length threatents this problem.
  unsigned int maxIncludeLength = 3000;
  bool useShortPath = false;
  for(int j=0; j < 2; ++j)
Ken Martin's avatar
Ken Martin committed
68
    {
69
70
71
72
73
    std::vector<std::string> includes;
    this->GetIncludeDirectories(includes);
    std::vector<std::string>::iterator i;
    for(i = includes.begin(); i != includes.end(); ++i)
      {
Ken Martin's avatar
Ken Martin committed
74
75
      std::string tmp = 
        this->ConvertToOptionallyRelativeOutputPath(i->c_str());
76
77
78
79
      if(useShortPath)
        {
        cmSystemTools::GetShortPath(tmp.c_str(), tmp);
        }
Ken Martin's avatar
Ken Martin committed
80
      this->IncludeOptions +=  " /I ";
Ken Martin's avatar
Ken Martin committed
81

82
83
84
      // quote if not already quoted
      if (tmp[0] != '"')
        {
Ken Martin's avatar
Ken Martin committed
85
86
87
        this->IncludeOptions += "\"";
        this->IncludeOptions += tmp;
        this->IncludeOptions += "\"";
88
89
90
        }
      else
        {
Ken Martin's avatar
Ken Martin committed
91
        this->IncludeOptions += tmp;
92
93
        }
      }
Ken Martin's avatar
Ken Martin committed
94
    if(j == 0 && this->IncludeOptions.size() > maxIncludeLength)
Ken Martin's avatar
Ken Martin committed
95
      {
Ken Martin's avatar
Ken Martin committed
96
      this->IncludeOptions = "";
97
      useShortPath = true;
Ken Martin's avatar
Ken Martin committed
98
99
100
      }
    else
      {
101
      break;
Ken Martin's avatar
Ken Martin committed
102
103
104
105
106
107
      }
    }
  
  // Create the DSP or set of DSP's for libraries and executables

  // clear project names
Ken Martin's avatar
Ken Martin committed
108
109
  this->CreatedProjectNames.clear();
  cmTargets &tgts = this->Makefile->GetTargets(); 
110
111
112
  for(cmTargets::iterator l = tgts.begin(); 
      l != tgts.end(); l++)
    {
113
114
115
    // Add a rule to regenerate the build system when the target
    // specification source changes.
    const char* suppRegenRule =
Ken Martin's avatar
Ken Martin committed
116
      this->Makefile->GetDefinition("CMAKE_SUPPRESS_REGENERATION");
117
118
119
120
    if (!cmSystemTools::IsOn(suppRegenRule))
      {
      this->AddDSPBuildRule(l->second);
      }
121
    }
122

Ken Martin's avatar
Ken Martin committed
123
124
125
126
127
128
129
  // build any targets
  for(cmTargets::iterator l = tgts.begin(); 
      l != tgts.end(); l++)
    {
    switch(l->second.GetType())
      {
      case cmTarget::STATIC_LIBRARY:
Brad King's avatar
Brad King committed
130
        this->SetBuildType(STATIC_LIBRARY, l->first.c_str(), l->second);
Ken Martin's avatar
Ken Martin committed
131
132
        break;
      case cmTarget::SHARED_LIBRARY:
Ken Martin's avatar
Ken Martin committed
133
      case cmTarget::MODULE_LIBRARY:
Brad King's avatar
Brad King committed
134
        this->SetBuildType(DLL, l->first.c_str(), l->second);
Ken Martin's avatar
Ken Martin committed
135
136
        break;
      case cmTarget::EXECUTABLE:
Brad King's avatar
Brad King committed
137
        this->SetBuildType(EXECUTABLE,l->first.c_str(), l->second);
Ken Martin's avatar
Ken Martin committed
138
139
        break;
      case cmTarget::UTILITY:
140
      case cmTarget::GLOBAL_TARGET:
Brad King's avatar
Brad King committed
141
        this->SetBuildType(UTILITY, l->first.c_str(), l->second);
Ken Martin's avatar
Ken Martin committed
142
143
        break;
      default:
144
145
        cmSystemTools::Error("Bad target type", l->first.c_str());
        break;
Ken Martin's avatar
Ken Martin committed
146
147
148
      }
    // INCLUDE_EXTERNAL_MSPROJECT command only affects the workspace
    // so don't build a projectfile for it
149
    if (strncmp(l->first.c_str(), "INCLUDE_EXTERNAL_MSPROJECT", 26) != 0)
Ken Martin's avatar
Ken Martin committed
150
151
152
153
154
      {
      // check to see if the dsp is going into a sub-directory
      std::string::size_type pos = l->first.rfind('/');
      if(pos != std::string::npos)
        {
Ken Martin's avatar
Ken Martin committed
155
        std::string dir = this->Makefile->GetStartOutputDirectory();
Ken Martin's avatar
Ken Martin committed
156
157
158
159
160
161
162
163
164
165
166
167
        dir += "/";
        dir += l->first.substr(0, pos);
        if(!cmSystemTools::MakeDirectory(dir.c_str()))
          {
          cmSystemTools::Error("Error creating directory ", dir.c_str());
          }
        }
      this->CreateSingleDSP(l->first.c_str(),l->second);
      }
    }
}

Ken Martin's avatar
Ken Martin committed
168
169
void cmLocalVisualStudio6Generator::CreateSingleDSP(const char *lname, 
                                                    cmTarget &target)
Ken Martin's avatar
Ken Martin committed
170
171
172
{
  // add to the list of projects
  std::string pname = lname;
Ken Martin's avatar
Ken Martin committed
173
  this->CreatedProjectNames.push_back(pname);
Ken Martin's avatar
Ken Martin committed
174
175
  // create the dsp.cmake file
  std::string fname;
Ken Martin's avatar
Ken Martin committed
176
  fname = this->Makefile->GetStartOutputDirectory();
Ken Martin's avatar
Ken Martin committed
177
178
179
180
181
182
183
184
185
186
  fname += "/";
  fname += lname;
  fname += ".dsp";
  // save the name of the real dsp file
  std::string realDSP = fname;
  fname += ".cmake";
  std::ofstream fout(fname.c_str());
  if(!fout)
    {
    cmSystemTools::Error("Error Writing ", fname.c_str());
187
    cmSystemTools::ReportLastSystemError("");
Ken Martin's avatar
Ken Martin committed
188
189
190
191
192
193
194
195
    }
  this->WriteDSPFile(fout,lname,target);
  fout.close();
  // if the dsp file has changed, then write it.
  cmSystemTools::CopyFileIfDifferent(fname.c_str(), realDSP.c_str());
}


196
void cmLocalVisualStudio6Generator::AddDSPBuildRule(cmTarget& tgt)
Ken Martin's avatar
Ken Martin committed
197
{
198
  std::string dspname = tgt.GetName();
Ken Martin's avatar
Ken Martin committed
199
  dspname += ".dsp.cmake";
Ken Martin's avatar
Ken Martin committed
200
201
  const char* dsprule = 
    this->Makefile->GetRequiredDefinition("CMAKE_COMMAND");
202
203
  cmCustomCommandLine commandLine;
  commandLine.push_back(dsprule);
Ken Martin's avatar
Ken Martin committed
204
  std::string makefileIn = this->Makefile->GetStartDirectory();
205
206
  makefileIn += "/";
  makefileIn += "CMakeLists.txt";
207
208
  std::string comment = "Building Custom Rule ";
  comment += makefileIn;
209
210
  std::string args;
  args = "-H";
Ken Martin's avatar
Ken Martin committed
211
  args += this->Convert(this->Makefile->GetHomeDirectory(),
212
                        START_OUTPUT, UNCHANGED, true);
213
  commandLine.push_back(args);
214
  args = "-B";
Ken Martin's avatar
Ken Martin committed
215
  args += 
Ken Martin's avatar
Ken Martin committed
216
    this->Convert(this->Makefile->GetHomeOutputDirectory(), 
217
                  START_OUTPUT, UNCHANGED, true);
218
  commandLine.push_back(args);
Ken Martin's avatar
Ken Martin committed
219

220
  std::vector<std::string> const& listFiles = this->Makefile->GetListFiles();
221
222
223

  cmCustomCommandLines commandLines;
  commandLines.push_back(commandLine);
224
  const char* no_working_directory = 0;
225
226
227
228
  this->Makefile->AddCustomCommandToOutput(dspname.c_str(), listFiles,
                                           makefileIn.c_str(), commandLines,
                                           comment.c_str(),
                                           no_working_directory, true);
Ken Martin's avatar
Ken Martin committed
229
  if(cmSourceFile* file = this->Makefile->GetSource(makefileIn.c_str()))
230
    {
231
    tgt.AddSourceFile(file);
232
233
234
235
236
    }
  else
    {
    cmSystemTools::Error("Error adding rule for ", makefileIn.c_str());
    }
Ken Martin's avatar
Ken Martin committed
237
238
239
240
}


void cmLocalVisualStudio6Generator::WriteDSPFile(std::ostream& fout, 
Bill Hoffman's avatar
Bill Hoffman committed
241
242
                                                 const char *libName,
                                                 cmTarget &target)
Ken Martin's avatar
Ken Martin committed
243
{
244
245
246
247
248
249
  // For utility targets need custom command since pre- and post-
  // build does not do anything in Visual Studio 6.  In order for the
  // rules to run in the correct order as custom commands, we need
  // special care for dependencies.  The first rule must depend on all
  // the dependencies of all the rules.  The later rules must each
  // depend only on the previous rule.
250
251
  if ((target.GetType() == cmTarget::UTILITY ||
      target.GetType() == cmTarget::GLOBAL_TARGET) &&
252
253
      (!target.GetPreBuildCommands().empty() ||
       !target.GetPostBuildCommands().empty()))
254
    {
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
    // Accumulate the dependencies of all the commands.
    std::vector<std::string> depends;
    for (std::vector<cmCustomCommand>::const_iterator cr =
           target.GetPreBuildCommands().begin();
         cr != target.GetPreBuildCommands().end(); ++cr)
      {
      depends.insert(depends.end(),
                     cr->GetDepends().begin(), cr->GetDepends().end());
      }
    for (std::vector<cmCustomCommand>::const_iterator cr =
           target.GetPostBuildCommands().begin();
         cr != target.GetPostBuildCommands().end(); ++cr)
      {
      depends.insert(depends.end(),
                     cr->GetDepends().begin(), cr->GetDepends().end());
      }

    // Add the pre- and post-build commands in order.
273
    int count = 1;
274
275
276
277
    for (std::vector<cmCustomCommand>::const_iterator cr =
           target.GetPreBuildCommands().begin();
         cr != target.GetPreBuildCommands().end(); ++cr)
      {
278
      this->AddUtilityCommandHack(target, count++, depends, *cr);
279
280
281
      }
    for (std::vector<cmCustomCommand>::const_iterator cr =
           target.GetPostBuildCommands().begin();
282
283
         cr != target.GetPostBuildCommands().end(); ++cr)
      {
284
      this->AddUtilityCommandHack(target, count++, depends, *cr);
285
286
      }
    }
Ken Martin's avatar
Ken Martin committed
287
288
289
290
  
  // trace the visual studio dependencies
  std::string name = libName;
  name += ".dsp.cmake";
291

Ken Martin's avatar
Ken Martin committed
292
  // We may be modifying the source groups temporarily, so make a copy.
Ken Martin's avatar
Ken Martin committed
293
  std::vector<cmSourceGroup> sourceGroups = this->Makefile->GetSourceGroups();
Ken Martin's avatar
Ken Martin committed
294
  
Ken Martin's avatar
Ken Martin committed
295
  // get the classes from the source lists then add them to the groups
296
  std::vector<cmSourceFile*> const & classes = target.GetSourceFiles();
297

Ken Martin's avatar
Ken Martin committed
298
299
  // now all of the source files have been properly assigned to the target
  // now stick them into source groups using the reg expressions
300
  for(std::vector<cmSourceFile*>::const_iterator i = classes.begin(); 
Ken Martin's avatar
Ken Martin committed
301
302
303
304
      i != classes.end(); i++)
    {
    // Add the file to the list of sources.
    std::string source = (*i)->GetFullPath();
Ken Martin's avatar
Ken Martin committed
305
306
    cmSourceGroup& sourceGroup = 
      this->Makefile->FindSourceGroup(source.c_str(), sourceGroups);
307
    sourceGroup.AssignSource(*i);
Ken Martin's avatar
Ken Martin committed
308
309
    // while we are at it, if it is a .rule file then for visual studio 6 we
    // must generate it
310
    if ((*i)->GetExtension() == "rule")
Ken Martin's avatar
Ken Martin committed
311
312
313
      {
      if(!cmSystemTools::FileExists(source.c_str()))
        {
314
        cmSystemTools::ReplaceString(source, "$(IntDir)/", "");
Ken Martin's avatar
Ken Martin committed
315
316
#if defined(_WIN32) || defined(__CYGWIN__)
        std::ofstream fout(source.c_str(), 
Ken Martin's avatar
Ken Martin committed
317
318
                           std::ios::binary | std::ios::out 
                           | std::ios::trunc);
Ken Martin's avatar
Ken Martin committed
319
320
321
322
323
324
325
326
327
328
329
330
#else
        std::ofstream fout(source.c_str(), 
                           std::ios::out | std::ios::trunc);
#endif
        if(fout)
          {
          fout.write("# generated from CMake",22);
          fout.flush();
          fout.close();
          }
        }
      }
Ken Martin's avatar
Ken Martin committed
331
    }
332
333
334

  // Compute which sources need unique object computation.
  this->ComputeObjectNameRequirements(sourceGroups);
Ken Martin's avatar
Ken Martin committed
335
336
337
338
  
  // Write the DSP file's header.
  this->WriteDSPHeader(fout, libName, target, sourceGroups);
  
339

Ken Martin's avatar
Ken Martin committed
340
341
342
343
  // Loop through every source group.
  for(std::vector<cmSourceGroup>::const_iterator sg = sourceGroups.begin();
      sg != sourceGroups.end(); ++sg)
    {
Bill Hoffman's avatar
Bill Hoffman committed
344
345
346
347
348
349
350
    this->WriteGroup(&(*sg), target, fout, libName);
    }  

  // Write the DSP file's footer.
  this->WriteDSPFooter(fout);
}

Ken Martin's avatar
Ken Martin committed
351
352
353
void cmLocalVisualStudio6Generator
::WriteGroup(const cmSourceGroup *sg, cmTarget target, 
             std::ostream &fout, const char *libName)
Bill Hoffman's avatar
Bill Hoffman committed
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
{
  const std::vector<const cmSourceFile *> &sourceFiles = 
    sg->GetSourceFiles();
  // If the group is empty, don't write it at all.
        
  if(sourceFiles.empty())
    { 
    return; 
    }
    
  // If the group has a name, write the header.
  std::string name = sg->GetName();
  if(name != "")
    {
    this->WriteDSPBeginGroup(fout, name.c_str(), "");
    }
370
371
372
373
374
375
376

  // Compute the maximum length of a configuration name.
  std::string::size_type config_len_max = 0;
  for(std::vector<std::string>::iterator i = this->Configurations.begin();
      i != this->Configurations.end(); ++i)
    {
    // Strip the subdirectory name out of the configuration name.
377
    std::string config = this->GetConfigName(*i);
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
    if(config.size() > config_len_max)
      {
      config_len_max = config.size();
      }
    }

  // Compute the maximum length of the full path to the intermediate
  // files directory for any configuration.  This is used to construct
  // object file names that do not produce paths that are too long.
  std::string::size_type dir_len = 0;
  dir_len += strlen(this->Makefile->GetCurrentOutputDirectory());
  dir_len += 1;
  dir_len += config_len_max;
  dir_len += 1;

Bill Hoffman's avatar
Bill Hoffman committed
393
394
395
396
397
398
399
400
401
  // Loop through each source in the source group.
  for(std::vector<const cmSourceFile *>::const_iterator sf =
        sourceFiles.begin(); sf != sourceFiles.end(); ++sf)
    {
    std::string source = (*sf)->GetFullPath();
    const cmCustomCommand *command = 
      (*sf)->GetCustomCommand();
    std::string compileFlags;
    std::vector<std::string> depends;
402
403
404
405
406
    std::string objectNameDir;
    if(this->NeedObjectName.find(*sf) != this->NeedObjectName.end())
      {
      objectNameDir =
        cmSystemTools::GetFilenamePath(
407
          this->GetObjectFileNameWithoutTarget(*(*sf), dir_len));
408
      }
409
410
411

    // Add per-source file flags.
    if(const char* cflags = (*sf)->GetProperty("COMPILE_FLAGS"))
412
      {
413
      compileFlags += cflags;
414
415
      }

416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
    // Add per-source and per-configuration preprocessor definitions.
    std::map<cmStdString, cmStdString> cdmap;
    this->AppendDefines(compileFlags,
                        (*sf)->GetProperty("COMPILE_DEFINITIONS"));
    if(const char* cdefs = (*sf)->GetProperty("DEBUG_COMPILE_DEFINITIONS"))
      {
      this->AppendDefines(cdmap["DEBUG"], cdefs);
      }
    if(const char* cdefs = (*sf)->GetProperty("RELEASE_COMPILE_DEFINITIONS"))
      {
      this->AppendDefines(cdmap["RELEASE"], cdefs);
      }
    if(const char* cdefs =
       (*sf)->GetProperty("MINSIZEREL_COMPILE_DEFINITIONS"))
      {
      this->AppendDefines(cdmap["MINSIZEREL"], cdefs);
      }
    if(const char* cdefs =
       (*sf)->GetProperty("RELWITHDEBINFO_COMPILE_DEFINITIONS"))
      {
      this->AppendDefines(cdmap["RELWITHDEBINFO"], cdefs);
      }

439
    const char* lang = this->GetSourceFileLanguage(*(*sf));
Bill Hoffman's avatar
Bill Hoffman committed
440
    if(lang)
Ken Martin's avatar
Ken Martin committed
441
      {
Bill Hoffman's avatar
Bill Hoffman committed
442
443
444
445
446
447
448
449
450
451
      if(strcmp(lang, "CXX") == 0)
        {
        // force a C++ file type
        compileFlags += " /TP ";
        } 
      else if(strcmp(lang, "C") == 0)
        {
        // force to c file type
        compileFlags += " /TC ";
        }
Bill Hoffman's avatar
Bill Hoffman committed
452
      }
453
454
455

    bool excludedFromBuild =
      (lang && (*sf)->GetPropertyAsBool("HEADER_FILE_ONLY"));
Bill Hoffman's avatar
Bill Hoffman committed
456
457
458
459
460
461
462
      
    // Check for extra object-file dependencies.
    const char* dependsValue = (*sf)->GetProperty("OBJECT_DEPENDS");
    if(dependsValue)
      {
      cmSystemTools::ExpandListArgument(dependsValue, depends);
      }
463
464
    if (source != libName || target.GetType() == cmTarget::UTILITY ||
      target.GetType() == cmTarget::GLOBAL_TARGET)
Bill Hoffman's avatar
Bill Hoffman committed
465
466
467
468
469
470
471
472
      {
      fout << "# Begin Source File\n\n";
        
      // Tell MS-Dev what the source is.  If the compiler knows how to
      // build it, then it will.
      fout << "SOURCE=" << 
        this->ConvertToOptionallyRelativeOutputPath(source.c_str()) << "\n\n";
      if(!depends.empty())
473
        {
Bill Hoffman's avatar
Bill Hoffman committed
474
475
476
477
478
479
480
481
482
        // Write out the dependencies for the rule.
        fout << "USERDEP__HACK=";
        for(std::vector<std::string>::const_iterator d = depends.begin();
            d != depends.end(); ++d)
          { 
          fout << "\\\n\t" << 
            this->ConvertToOptionallyRelativeOutputPath(d->c_str());
          }
        fout << "\n";
483
        }
Bill Hoffman's avatar
Bill Hoffman committed
484
      if (command)
485
        {
Bill Hoffman's avatar
Bill Hoffman committed
486
        const char* flags = compileFlags.size() ? compileFlags.c_str(): 0;
Alexander Neundorf's avatar
   
Alexander Neundorf committed
487
        this->WriteCustomRule(fout, source.c_str(), *command, flags);
Ken Martin's avatar
Ken Martin committed
488
        }
489
      else if(!compileFlags.empty() || !objectNameDir.empty() ||
490
              excludedFromBuild || !cdmap.empty())
Ken Martin's avatar
Ken Martin committed
491
        {
Bill Hoffman's avatar
Bill Hoffman committed
492
        for(std::vector<std::string>::iterator i
Ken Martin's avatar
Ken Martin committed
493
494
              = this->Configurations.begin(); 
            i != this->Configurations.end(); ++i)
Bill Hoffman's avatar
Bill Hoffman committed
495
          { 
496
497
          // Strip the subdirectory name out of the configuration name.
          std::string config = this->GetConfigName(*i);
Ken Martin's avatar
Ken Martin committed
498
          if (i == this->Configurations.begin())
Bill Hoffman's avatar
Bill Hoffman committed
499
500
            {
            fout << "!IF  \"$(CFG)\" == " << i->c_str() << std::endl;
501
            }
Bill Hoffman's avatar
Bill Hoffman committed
502
503
504
505
          else 
            {
            fout << "!ELSEIF  \"$(CFG)\" == " << i->c_str() << std::endl;
            }
506
507
508
509
          if(excludedFromBuild)
            {
            fout << "# PROP Exclude_From_Build 1\n";
            }
510
511
512
513
          if(!compileFlags.empty())
            {
            fout << "\n# ADD CPP " << compileFlags << "\n\n";
            }
514
515
516
517
518
519
          std::map<cmStdString, cmStdString>::iterator cdi =
            cdmap.find(cmSystemTools::UpperCase(config));
          if(cdi != cdmap.end() && !cdi->second.empty())
            {
            fout << "\n# ADD CPP " << cdi->second << "\n\n";
            }
520
521
522
523
524
525
          if(!objectNameDir.empty())
            {
            // Setup an alternate object file directory.
            fout << "\n# PROP Intermediate_Dir \""
                 << config << "/" << objectNameDir << "\"\n\n";
            }
Bill Hoffman's avatar
Bill Hoffman committed
526
527
          } 
        fout << "!ENDIF\n\n";
Ken Martin's avatar
Ken Martin committed
528
        }
Bill Hoffman's avatar
Bill Hoffman committed
529
      fout << "# End Source File\n";
Ken Martin's avatar
Ken Martin committed
530
      }
Bill Hoffman's avatar
Bill Hoffman committed
531
532
533
534
535
536
537
538
539
540
541
    }

  std::vector<cmSourceGroup> children  = sg->GetGroupChildren();

  for(unsigned int i=0;i<children.size();++i)
    {
    this->WriteGroup(&children[i], target, fout, libName);
    }



Ken Martin's avatar
Ken Martin committed
542
    
Bill Hoffman's avatar
Bill Hoffman committed
543
544
545
546
547
  // If the group has a name, write the footer.
  if(name != "")
    {
    this->WriteDSPEndGroup(fout);
    }
Ken Martin's avatar
Ken Martin committed
548
549
550
551

}


552
553
554
555
void
cmLocalVisualStudio6Generator
::AddUtilityCommandHack(cmTarget& target, int count,
                        std::vector<std::string>& depends,
556
                        const cmCustomCommand& origCommand)
557
558
{
  // Create a fake output that forces the rule to run.
Ken Martin's avatar
Ken Martin committed
559
  char* output = new char[(strlen(this->Makefile->GetStartOutputDirectory()) +
560
                           strlen(target.GetName()) + 30)];
Ken Martin's avatar
Ken Martin committed
561
  sprintf(output,"%s/%s_force_%i", this->Makefile->GetStartOutputDirectory(),
562
          target.GetName(), count);
563
  std::string comment = this->ConstructComment(origCommand, "<hack>");
564
565
566

  // Add the rule with the given dependencies and commands.
  const char* no_main_dependency = 0;
Ken Martin's avatar
Ken Martin committed
567
  this->Makefile->AddCustomCommandToOutput(output,
568
569
                                       depends,
                                       no_main_dependency,
570
                                       origCommand.GetCommandLines(),
571
                                       comment.c_str(),
572
                                       origCommand.GetWorkingDirectory());
573
574
575
576
577
578
579

  // Replace the dependencies with the output of this rule so that the
  // next rule added will run after this one.
  depends.clear();
  depends.push_back(output);

  // Add a source file representing this output to the project.
Ken Martin's avatar
Ken Martin committed
580
  cmSourceFile* outsf = this->Makefile->GetSourceFileWithOutput(output);
581
  target.AddSourceFile(outsf);
582
583
584
585
586

  // Free the fake output name.
  delete [] output;
}

587
588
589
590
void
cmLocalVisualStudio6Generator
::WriteCustomRule(std::ostream& fout,
                  const char* source,
Alexander Neundorf's avatar
   
Alexander Neundorf committed
591
                  const cmCustomCommand& command,
592
                  const char* flags)
Ken Martin's avatar
Ken Martin committed
593
{
Alexander Neundorf's avatar
   
Alexander Neundorf committed
594
595
596
597
598
599
600
  std::string comment =
    this->ConstructComment(command, "Building Custom Rule $(InputPath)");
  if(comment == "<hack>")
    {
    comment = "";
    }
  
601
  // Write the rule for each configuration.
Ken Martin's avatar
Ken Martin committed
602
  std::vector<std::string>::iterator i;
Ken Martin's avatar
Ken Martin committed
603
  for(i = this->Configurations.begin(); i != this->Configurations.end(); ++i)
Ken Martin's avatar
Ken Martin committed
604
    {
605
    std::string config = this->GetConfigName(*i);
Alexander Neundorf's avatar
   
Alexander Neundorf committed
606
607
608
    std::string script =
      this->ConstructScript(command.GetCommandLines(), 
                            command.GetWorkingDirectory(),
609
                            config.c_str(),
Alexander Neundorf's avatar
   
Alexander Neundorf committed
610
611
612
613
                            command.GetEscapeOldStyle(),
                            command.GetEscapeAllowMakeVars(),
                            "\\\n\t");
      
Ken Martin's avatar
Ken Martin committed
614
    if (i == this->Configurations.begin())
Ken Martin's avatar
Ken Martin committed
615
616
617
618
619
620
621
622
623
624
625
626
627
      {
      fout << "!IF  \"$(CFG)\" == " << i->c_str() << std::endl;
      }
    else 
      {
      fout << "!ELSEIF  \"$(CFG)\" == " << i->c_str() << std::endl;
      }
    if(flags)
      {
      fout << "\n# ADD CPP " << flags << "\n\n";
      }
    // Write out the dependencies for the rule.
    fout << "USERDEP__HACK=";
Alexander Neundorf's avatar
   
Alexander Neundorf committed
628
629
    for(std::vector<std::string>::const_iterator d = 
          command.GetDepends().begin();
Alexander Neundorf's avatar
   
Alexander Neundorf committed
630
631
        d != command.GetDepends().end(); 
        ++d)
Ken Martin's avatar
Ken Martin committed
632
      {
633
      // Lookup the real name of the dependency in case it is a CMake target.
634
635
      std::string dep = this->GetRealDependency(d->c_str(),
                                                config.c_str());
636
637
      fout << "\\\n\t" <<
        this->ConvertToOptionallyRelativeOutputPath(dep.c_str());
Ken Martin's avatar
Ken Martin committed
638
639
640
641
      }
    fout << "\n";

    fout << "# PROP Ignore_Default_Tool 1\n";
642
    fout << "# Begin Custom Build -";
Alexander Neundorf's avatar
   
Alexander Neundorf committed
643
    if(!comment.empty())
644
      {
Alexander Neundorf's avatar
   
Alexander Neundorf committed
645
      fout << " " << comment.c_str();
646
647
      }
    fout << "\n\n";
Alexander Neundorf's avatar
   
Alexander Neundorf committed
648
    if(command.GetOutputs().empty())
Ken Martin's avatar
Ken Martin committed
649
      {
Ken Martin's avatar
Ken Martin committed
650
651
      fout << source 
           << "_force :  \"$(SOURCE)\" \"$(INTDIR)\" \"$(OUTDIR)\"\n\t";
Alexander Neundorf's avatar
   
Alexander Neundorf committed
652
      fout << script.c_str() << "\n\n";
Ken Martin's avatar
Ken Martin committed
653
      }
654
655
    else
      {
Alexander Neundorf's avatar
   
Alexander Neundorf committed
656
657
658
659
      for(std::vector<std::string>::const_iterator o = 
          command.GetOutputs().begin();
          o != command.GetOutputs().end(); 
          ++o)
660
661
662
663
        {
        // Write a rule for every output generated by this command.
        fout << this->ConvertToOptionallyRelativeOutputPath(o->c_str())
             << " :  \"$(SOURCE)\" \"$(INTDIR)\" \"$(OUTDIR)\"\n\t";
Alexander Neundorf's avatar
   
Alexander Neundorf committed
664
        fout << script.c_str() << "\n\n";
665
666
        }
      }
Ken Martin's avatar
Ken Martin committed
667
668
669
670
671
672
673
674
    fout << "# End Custom Build\n\n";
    }
  
  fout << "!ENDIF\n\n";
}


void cmLocalVisualStudio6Generator::WriteDSPBeginGroup(std::ostream& fout, 
Bill Hoffman's avatar
Bill Hoffman committed
675
676
                                                       const char* group,
                                                       const char* filter)
Ken Martin's avatar
Ken Martin committed
677
678
679
680
681
682
683
684
685
686
687
688
689
690
{
  fout << "# Begin Group \"" << group << "\"\n"
    "# PROP Default_Filter \"" << filter << "\"\n";
}


void cmLocalVisualStudio6Generator::WriteDSPEndGroup(std::ostream& fout)
{
  fout << "# End Group\n";
}




Brad King's avatar
Brad King committed
691
692
void cmLocalVisualStudio6Generator::SetBuildType(BuildType b,
                                                 const char* libName,
693
                                                 cmTarget& target)
Ken Martin's avatar
Ken Martin committed
694
{
Ken Martin's avatar
Ken Martin committed
695
  std::string root= this->Makefile->GetRequiredDefinition("CMAKE_ROOT");
Ken Martin's avatar
Ken Martin committed
696
697
  const char *def= 
    this->Makefile->GetDefinition( "MSPROJECT_TEMPLATE_DIRECTORY");
Ken Martin's avatar
Ken Martin committed
698
699
700
701
702
703
704
705
706
707
708
709
710

  if( def)
    {
    root = def;
    }
  else
    {
    root += "/Templates";
    }
  
  switch(b)
    {
    case STATIC_LIBRARY:
Ken Martin's avatar
Ken Martin committed
711
712
713
714
      this->DSPHeaderTemplate = root;
      this->DSPHeaderTemplate += "/staticLibHeader.dsptemplate";
      this->DSPFooterTemplate = root;
      this->DSPFooterTemplate += "/staticLibFooter.dsptemplate";
Ken Martin's avatar
Ken Martin committed
715
716
      break;
    case DLL:
Ken Martin's avatar
Ken Martin committed
717
718
719
720
      this->DSPHeaderTemplate =  root;
      this->DSPHeaderTemplate += "/DLLHeader.dsptemplate";
      this->DSPFooterTemplate =  root;
      this->DSPFooterTemplate += "/DLLFooter.dsptemplate";
Ken Martin's avatar
Ken Martin committed
721
722
      break;
    case EXECUTABLE:
723
724
      if ( target.GetPropertyAsBool("WIN32_EXECUTABLE") )
        {
Ken Martin's avatar
Ken Martin committed
725
726
727
728
        this->DSPHeaderTemplate = root;
        this->DSPHeaderTemplate += "/EXEWinHeader.dsptemplate";
        this->DSPFooterTemplate = root;
        this->DSPFooterTemplate += "/EXEFooter.dsptemplate";
729
730
731
        }
      else
        {
Ken Martin's avatar
Ken Martin committed
732
733
734
735
        this->DSPHeaderTemplate = root;
        this->DSPHeaderTemplate += "/EXEHeader.dsptemplate";
        this->DSPFooterTemplate = root;
        this->DSPFooterTemplate += "/EXEFooter.dsptemplate";
736
        }
Ken Martin's avatar
Ken Martin committed
737
738
      break;
    case UTILITY:
Ken Martin's avatar
Ken Martin committed
739
740
741
742
      this->DSPHeaderTemplate = root;
      this->DSPHeaderTemplate += "/UtilityHeader.dsptemplate";
      this->DSPFooterTemplate = root;
      this->DSPFooterTemplate += "/UtilityFooter.dsptemplate";
Ken Martin's avatar
Ken Martin committed
743
744
745
746
747
      break;
    }

  // once the build type is set, determine what configurations are
  // possible
Ken Martin's avatar
Ken Martin committed
748
  std::ifstream fin(this->DSPHeaderTemplate.c_str());
Ken Martin's avatar
Ken Martin committed
749

750
  cmsys::RegularExpression reg("# Name ");
Ken Martin's avatar
Ken Martin committed
751
752
  if(!fin)
    {
Ken Martin's avatar
Ken Martin committed
753
    cmSystemTools::Error("Error Reading ", this->DSPHeaderTemplate.c_str());
Ken Martin's avatar
Ken Martin committed
754
755
    }

Ken Martin's avatar
Ken Martin committed
756
  // reset this->Configurations
Ken Martin's avatar
Ken Martin committed
757
758
  this->Configurations.erase(this->Configurations.begin(), 
                             this->Configurations.end());
Ken Martin's avatar
Ken Martin committed
759
  // now add all the configurations possible
760
761
  std::string line;
  while(cmSystemTools::GetLineFromStream(fin, line))
Ken Martin's avatar
Ken Martin committed
762
763
764
765
    {
    cmSystemTools::ReplaceString(line, "OUTPUT_LIBNAME",libName);
    if (reg.find(line))
      {
Ken Martin's avatar
Ken Martin committed
766
      this->Configurations.push_back(line.substr(reg.end()));
Ken Martin's avatar
Ken Martin committed
767
768
769
770
771
772
      }
    }
}

// look for custom rules on a target and collect them together
std::string 
773
cmLocalVisualStudio6Generator::CreateTargetRules(cmTarget &target, 
Alexander Neundorf's avatar
   
Alexander Neundorf committed
774
                                                 const char* configName, 
Ken Martin's avatar
Ken Martin committed
775
                                                 const char * /* libName */)
Ken Martin's avatar
Ken Martin committed
776
777
778
{
  std::string customRuleCode = "";

779
  if (target.GetType() >= cmTarget::UTILITY )
Ken Martin's avatar
Ken Martin committed
780
781
782
    {
    return customRuleCode;
    }
783
784
785
786
787
788
789
790
791
792

  // are there any rules?
  if (target.GetPreBuildCommands().size() + 
      target.GetPreLinkCommands().size() + 
      target.GetPostBuildCommands().size() == 0)
    {
    return customRuleCode;
    }
    
  customRuleCode = "# Begin Special Build Tool\n";
793
794
795
796
797
798
799
800
801
802
803
804
805
806

  // Write the pre-build and pre-link together (VS6 does not support
  // both).  Make sure no continuation character is put on the last
  // line.
  int prelink_total = (static_cast<int>(target.GetPreBuildCommands().size())+
                       static_cast<int>(target.GetPreLinkCommands().size()));
  int prelink_count = 0;
  if(prelink_total > 0)
    {
    // header stuff
    customRuleCode += "PreLink_Cmds=";
    }
  for (std::vector<cmCustomCommand>::const_iterator cr =
         target.GetPreBuildCommands().begin();
807
       cr != target.GetPreBuildCommands().end(); ++cr)
Ken Martin's avatar
Ken Martin committed
808
    {
809
    if(prelink_count++ > 0)
Ken Martin's avatar
Ken Martin committed
810
      {
811
      customRuleCode += "\\\n\t";
812
      }
813
    customRuleCode += this->ConstructScript(cr->GetCommandLines(),
814
                                            cr->GetWorkingDirectory(),
Alexander Neundorf's avatar
   
Alexander Neundorf committed
815
                                            configName, 
816
817
                                            cr->GetEscapeOldStyle(),
                                            cr->GetEscapeAllowMakeVars(),
818
                                            "\\\n\t");
Ken Martin's avatar
Ken Martin committed
819
    }
820
821
  for (std::vector<cmCustomCommand>::const_iterator cr =
         target.GetPreLinkCommands().begin();
822
       cr != target.GetPreLinkCommands().end(); ++cr)
Ken Martin's avatar
Ken Martin committed
823
    {
824
    if(prelink_count++ > 0)
825
      {
826
      customRuleCode += "\\\n\t";
827
      }
828
    customRuleCode += this->ConstructScript(cr->GetCommandLines(),
829
                                            cr->GetWorkingDirectory(),
Alexander Neundorf's avatar
   
Alexander Neundorf committed
830
                                            configName,
831
832
                                            cr->GetEscapeOldStyle(),
                                            cr->GetEscapeAllowMakeVars(),
833
                                            "\\\n\t");
Ken Martin's avatar
Ken Martin committed
834
    }
835
  if(prelink_total > 0)
Ken Martin's avatar
Ken Martin committed
836
837
838
    {
    customRuleCode += "\n";
    }
839
840
841

  // Write the post-build rules.  Make sure no continuation character
  // is put on the last line.
Ken Martin's avatar
Ken Martin committed
842
843
  int postbuild_total = 
    static_cast<int>(target.GetPostBuildCommands().size());
844
845
846
847
848
849
850
  int postbuild_count = 0;
  if(postbuild_total > 0)
    {
    customRuleCode += "PostBuild_Cmds=";
    }
  for (std::vector<cmCustomCommand>::const_iterator cr =
         target.GetPostBuildCommands().begin();
851
852
       cr != target.GetPostBuildCommands().end(); ++cr)
    {
853
    if(postbuild_count++ > 0)
854
      {
855
      customRuleCode += "\\\n\t";
856
      }
857
    customRuleCode += this->ConstructScript(cr->GetCommandLines(),
858
                                            cr->GetWorkingDirectory(),
Alexander Neundorf's avatar
   
Alexander Neundorf committed
859
                                            configName,
860
861
                                            cr->GetEscapeOldStyle(),
                                            cr->GetEscapeAllowMakeVars(),
862
                                            "\\\n\t");
863
864
865
866
    }
  if(postbuild_total > 0)
    {
    customRuleCode += "\n";
867
868
    }

869
  customRuleCode += "# End Special Build Tool\n";
Ken Martin's avatar
Ken Martin committed
870
871
872
873
874
875
876
877
878
879
880
881
882
  return customRuleCode;
}


inline std::string removeQuotes(const std::string& s)
{
  if(s[0] == '\"' && s[s.size()-1] == '\"')
    {
    return s.substr(1, s.size()-2);
    }
  return s;
}

883
884
885
// Code in blocks surrounded by a test for this definition is needed
// only for compatibility with user project's replacement DSP
// templates.  The CMake templates no longer use them.
886
#define CM_USE_OLD_VS6
887

888
889
void cmLocalVisualStudio6Generator
::WriteDSPHeader(std::ostream& fout, 
890
                 const char *libName, cmTarget &target, 
891
                 std::vector<cmSourceGroup> &)
Ken Martin's avatar
Ken Martin committed
892
{
893
894
895
896
  // Lookup the output directory for the target.
  std::string outPath = target.GetDirectory();

#ifdef CM_USE_OLD_VS6
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
  // Lookup the library and executable output directories.
  std::string libPath;
  if(this->Makefile->GetDefinition("LIBRARY_OUTPUT_PATH"))
    {
    libPath = this->Makefile->GetDefinition("LIBRARY_OUTPUT_PATH");
    }
  std::string exePath;
  if(this->Makefile->GetDefinition("EXECUTABLE_OUTPUT_PATH"))
    {
    exePath = this->Makefile->GetDefinition("EXECUTABLE_OUTPUT_PATH");
    }

  // Make sure there are trailing slashes.
  if(!libPath.empty())
    {
    if(libPath[libPath.size()-1] != '/')
      {
      libPath += "/";
      }
    }
  if(!exePath.empty())
    {
    if(exePath[exePath.size()-1] != '/')
      {
      exePath += "/";
      }
    }

Ken Martin's avatar
Ken Martin committed
925
926
927
928
929
930
931
932
  std::set<std::string> pathEmitted;
  
  // determine the link directories
  std::string libOptions;
  std::string libDebugOptions;
  std::string libOptimizedOptions;

  std::string libMultiLineOptions;
933
  std::string libMultiLineOptionsForDebug;
Ken Martin's avatar
Ken Martin committed
934
935
936
937
938
939
  std::string libMultiLineDebugOptions;
  std::string libMultiLineOptimizedOptions;

  if(libPath.size())
    {
    std::string lpath = 
940
      this->ConvertToOptionallyRelativeOutputPath(libPath.c_str());
941
942
943
944
    if(lpath.size() == 0)
      {
      lpath = ".";
      }
Ken Martin's avatar
Ken Martin committed
945
    std::string lpathIntDir = libPath + "$(INTDIR)";
Ken Martin's avatar
Ken Martin committed
946
947
    lpathIntDir =  
      this->ConvertToOptionallyRelativeOutputPath(lpathIntDir.c_str());
Ken Martin's avatar
Ken Martin committed
948
949
950
951
952
953
954
955
956
957
958
959
960
961
    if(pathEmitted.insert(lpath).second)
      {
      libOptions += " /LIBPATH:";
      libOptions += lpathIntDir;
      libOptions += " ";
      libOptions += " /LIBPATH:";
      libOptions += lpath;
      libOptions += " ";
      libMultiLineOptions += "# ADD LINK32 /LIBPATH:";
      libMultiLineOptions += lpathIntDir;
      libMultiLineOptions += " ";
      libMultiLineOptions += " /LIBPATH:";
      libMultiLineOptions += lpath;
      libMultiLineOptions += " \n";
962
963
964
965
966
967
      libMultiLineOptionsForDebug += "# ADD LINK32 /LIBPATH:";
      libMultiLineOptionsForDebug += lpathIntDir;
      libMultiLineOptionsForDebug += " ";
      libMultiLineOptionsForDebug += " /LIBPATH:";
      libMultiLineOptionsForDebug += lpath;
      libMultiLineOptionsForDebug += " \n";
Ken Martin's avatar
Ken Martin committed
968
969
970
971
972
      }
    }
  if(exePath.size())
    {
    std::string lpath = 
973
      this->ConvertToOptionallyRelativeOutputPath(exePath.c_str());
974
975
976
977
    if(lpath.size() == 0)
      {
      lpath = ".";
      }
Ken Martin's avatar
Ken Martin committed
978
    std::string lpathIntDir = exePath + "$(INTDIR)";
Ken Martin's avatar
Ken Martin committed
979
980
    lpathIntDir =
      this->ConvertToOptionallyRelativeOutputPath(lpathIntDir.c_str());
Ken Martin's avatar
Ken Martin committed
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
    
    if(pathEmitted.insert(lpath).second)
      {
      libOptions += " /LIBPATH:";
      libOptions += lpathIntDir;
      libOptions += " ";
      libOptions += " /LIBPATH:";
      libOptions += lpath;
      libOptions += " ";
      libMultiLineOptions += "# ADD LINK32 /LIBPATH:";
      libMultiLineOptions += lpathIntDir;
      libMultiLineOptions += " ";
      libMultiLineOptions += " /LIBPATH:";
      libMultiLineOptions += lpath;
      libMultiLineOptions += " \n";
996
997
998
999
1000
1001
      libMultiLineOptionsForDebug += "# ADD LINK32 /LIBPATH:";
      libMultiLineOptionsForDebug += lpathIntDir;
      libMultiLineOptionsForDebug += " ";
      libMultiLineOptionsForDebug += " /LIBPATH:";
      libMultiLineOptionsForDebug += lpath;
      libMultiLineOptionsForDebug += " \n";
Ken Martin's avatar
Ken Martin committed
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
      }
    }
  std::vector<std::string>::const_iterator i;
  const std::vector<std::string>& libdirs = target.GetLinkDirectories();
  for(i = libdirs.begin(); i != libdirs.end(); ++i)
    {
    std::string path = *i;
    if(path[path.size()-1] != '/')
      {
      path += "/";
      }
    std::string lpath = 
1014
      this->ConvertToOptionallyRelativeOutputPath(path.c_str());
1015
1016
1017
1018
    if(lpath.size() == 0)
      {
      lpath = ".";
      }
Ken Martin's avatar
Ken Martin committed
1019
    std::string lpathIntDir = path + "$(INTDIR)";
Ken Martin's avatar
Ken Martin committed
1020
1021
    lpathIntDir =
      this->ConvertToOptionallyRelativeOutputPath(lpathIntDir.c_str());
Ken Martin's avatar
Ken Martin committed
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
    if(pathEmitted.insert(lpath).second)
      {
      libOptions += " /LIBPATH:";
      libOptions += lpathIntDir;
      libOptions += " ";
      libOptions += " /LIBPATH:";
      libOptions += lpath;
      libOptions += " ";
      
      libMultiLineOptions += "# ADD LINK32 /LIBPATH:";
      libMultiLineOptions += lpathIntDir;
      libMultiLineOptions += " ";
      libMultiLineOptions += " /LIBPATH:";
      libMultiLineOptions += lpath;
      libMultiLineOptions += " \n";
1037
1038
1039
1040
1041
1042
      libMultiLineOptionsForDebug += "# ADD LINK32 /LIBPATH:";
      libMultiLineOptionsForDebug += lpathIntDir;
      libMultiLineOptionsForDebug += " ";
      libMultiLineOptionsForDebug += " /LIBPATH:";
      libMultiLineOptionsForDebug += lpath;
      libMultiLineOptionsForDebug += " \n";
Ken Martin's avatar
Ken Martin committed
1043
1044
1045
      }
    }
  // find link libraries
Ken Martin's avatar
Ken Martin committed
1046
1047
  const cmTarget::LinkLibraryVectorType& libs = target.GetLinkLibraries();
  cmTarget::LinkLibraryVectorType::const_iterator j;
Ken Martin's avatar
Ken Martin committed
1048
1049
1050
1051
  for(j = libs.begin(); j != libs.end(); ++j)
    {
    // add libraries to executables and dlls (but never include
    // a library in a library, bad recursion)
1052
    // NEVER LINK STATIC LIBRARIES TO OTHER STATIC LIBRARIES
Ken Martin's avatar
Ken Martin committed
1053
    if ((target.GetType() != cmTarget::SHARED_LIBRARY
Ken Martin's avatar
Ken Martin committed
1054
1055
1056
1057
         && target.GetType() != cmTarget::STATIC_LIBRARY 
         && target.GetType() != cmTarget::MODULE_LIBRARY) || 
        (target.GetType()==cmTarget::SHARED_LIBRARY && libName != j->first) ||
        (target.GetType()==cmTarget::MODULE_LIBRARY && libName != j->first))
Ken Martin's avatar
Ken Martin committed
1058
      {
1059
1060
1061
      // Compute the proper name to use to link this library.
      std::string lib;
      std::string libDebug;
Alexander Neundorf's avatar
   
Alexander Neundorf committed
1062
      cmTarget* tgt = this->GlobalGenerator->FindTarget(0, j->first.c_str(),
Alexander Neundorf's avatar
   
Alexander Neundorf committed
1063
                                                        false);
1064
      if(tgt)
Ken Martin's avatar
Ken Martin committed
1065
        {
Ken Martin's avatar
Ken Martin committed
1066
1067
1068
1069
        lib = cmSystemTools::GetFilenameWithoutExtension
          (tgt->GetFullName().c_str());
        libDebug = cmSystemTools::GetFilenameWithoutExtension
          (tgt->GetFullName("Debug").c_str());
Ken Martin's avatar
Ken Martin committed
1070
        lib += ".lib";
1071
        libDebug += ".lib";
Ken Martin's avatar
Ken Martin committed
1072
        }
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
      else
        {
        lib = j->first.c_str();
        libDebug = j->first.c_str();
        if(j->first.find(".lib") == std::string::npos)
          {
          lib += ".lib";
          libDebug += ".lib";
          }
        }
1083
      lib = this->ConvertToOptionallyRelativeOutputPath(lib.c_str());
Ken Martin's avatar
Ken Martin committed
1084
1085
      libDebug = 
        this->ConvertToOptionallyRelativeOutputPath(libDebug.c_str());
1086

Ken Martin's avatar
Ken Martin committed
1087
1088
1089
1090
1091
1092
1093
      if (j->second == cmTarget::GENERAL)
        {
        libOptions += " ";
        libOptions += lib;
        libMultiLineOptions += "# ADD LINK32 ";
        libMultiLineOptions +=  lib;
        libMultiLineOptions += "\n";
1094
1095
1096
        libMultiLineOptionsForDebug += "# ADD LINK32 ";
        libMultiLineOptionsForDebug +=  libDebug;
        libMultiLineOptionsForDebug += "\n";
Ken Martin's avatar
Ken Martin committed
1097
1098
1099
1100
1101
1102
1103
        }
      if (j->second == cmTarget::DEBUG)
        {
        libDebugOptions += " ";
        libDebugOptions += lib;

        libMultiLineDebugOptions += "# ADD LINK32 ";
1104
        libMultiLineDebugOptions += libDebug;
Ken Martin's avatar
Ken Martin committed
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
        libMultiLineDebugOptions += "\n";
        }
      if (j->second == cmTarget::OPTIMIZED)
        {
        libOptimizedOptions += " ";
        libOptimizedOptions += lib;

        libMultiLineOptimizedOptions += "# ADD LINK32 ";
        libMultiLineOptimizedOptions += lib;
        libMultiLineOptimizedOptions += "\n";
        }      
      }
    }
1118
#endif
1119
1120

  // Get extra linker options for this target type.
1121
1122
1123
  std::string extraLinkOptions;
  if(target.GetType() == cmTarget::EXECUTABLE)
    {
Ken Martin's avatar
Ken Martin committed
1124
1125
    extraLinkOptions = 
      this->Makefile->GetRequiredDefinition("CMAKE_EXE_LINKER_FLAGS");
1126
1127