OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [ecos-2.0/] [tools/] [src/] [tools/] [configtool/] [common/] [win32/] [CTCommonDoc.cpp] - Blame information for rev 174

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 26 unneback 
//####COPYRIGHTBEGIN####
2 
//
3 
// ----------------------------------------------------------------------------
4 
// Copyright (C) 1998, 1999, 2000 Red Hat, Inc.
5 
//
6 
// This program is part of the eCos host tools.
7 
//
8 
// This program is free software; you can redistribute it and/or modify it
9 
// under the terms of the GNU General Public License as published by the Free
10 
// Software Foundation; either version 2 of the License, or (at your option)
11 
// any later version.
12 
//
13 
// This program is distributed in the hope that it will be useful, but WITHOUT
14 
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 
// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
16 
// more details.
17 
//
18 
// You should have received a copy of the GNU General Public License along with
19 
// this program; if not, write to the Free Software Foundation, Inc.,
20 
// 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
21 
//
22 
// ----------------------------------------------------------------------------
23 
//
24 
//####COPYRIGHTEND####
25 
#include "stdafx.h"
26 
 
27 
#include "ConfigToolDoc.h"
28 
 
29 
#ifdef PLUGIN
30 
  #include "CTMain.h"
31 
  #include "Project.h"
32 
  #include "ProjectManager.h"
33 
#else
34 
  #include "MainFrm.h"
35 
#endif
36 
 
37 
#include "CTUtils.h"
38 
#include "CdlPackagesDialog.h"
39 
#include "ConfigItem.h"
40 
#include "ConfigTool.h"
41 
#include "ControlView.h"
42 
#include "FailingRulesDialog.h"
43 
#include "FolderDialog.h"
44 
#include "IdleMessage.h"
45 
#include "MLTView.h"
46 
#include "NotePage.h"
47 
#include "RegionGeneralPage.h"
48 
#include "RegKeyEx.h"
49 
#include "RulesView.h"
50 
#include "SectionGeneralPage.h"
51 
#include "SectionRelocationPage.h"
52 
 
53 
#include <htmlhelp.h>
54 
#include <shlobj.h>
55 
 
56 
#define INCLUDEFILE <string>
57 
#include "IncludeSTL.h"
58 
#define INCLUDEFILE "build.hxx"
59 
#include "IncludeSTL.h"
60 
 
61 
#ifdef _DEBUG
62 
  #define new DEBUG_NEW
63 
  #undef THIS_FILE
64 
  static char THIS_FILE[] = __FILE__;
65 
#endif
66 
 
67 
const CFileName &CConfigToolDoc::DefaultExternalBrowser()
68 
{
69 
  static bool bFirstTime=true;
70 
  if(bFirstTime){
71 
    const CFileName strFile(CFileName::GetTempPath()+_T("index.html"));
72 
    CFile f;
73 
    if(f.Open(strFile,CFile::modeCreate|CFile::modeWrite)){
74 
      f.Close();
75 
      bool rc=((int)FindExecutable(strFile,_T("."),m_strDefaultExternalBrowser.GetBuffer(MAX_PATH))>32);
76 
      m_strDefaultExternalBrowser.ReleaseBuffer();
77 
      if(!rc){
78 
        m_strDefaultExternalBrowser=_T("");
79 
      }
80 
      ::DeleteFile(strFile);
81 
    }
82 
    bFirstTime=false;
83 
  }
84 
  return m_strDefaultExternalBrowser;
85 
}
86 
 
87 
CFileName CConfigToolDoc::m_strDefaultExternalBrowser;
88 
 
89 
void CConfigToolDoc::CheckRadios()
90 
{
91 
  for(int nItem=0;nItem<ItemCount();nItem++){
92 
    CConfigItem *pItem=Item(nItem);
93 
    if(pItem->HasRadio () && pItem==pItem->FirstRadio()){
94 
      CString strMsg;
95 
      CConfigItem *pFirstSet=NULL;
96 
      for(CConfigItem *pSibItem=pItem;pSibItem;pSibItem=pSibItem->NextRadio()){
97 
        if(pSibItem->IsEnabled ()){
98 
          if(pFirstSet){
99 
            strMsg+=_T(" ");
100 
            strMsg+=pSibItem->Macro ();
101 
          } else {
102 
            pFirstSet=pSibItem;
103 
          }
104 
        }
105 
      }
106 
      if(!strMsg.IsEmpty()){
107 
        CConfigTool::Log(_T("%s, multiple radio buttons are set: %s%s"),
108 
          pItem->Macro(),pFirstSet->Macro(),strMsg);
109 
      } else if(!pFirstSet){
110 
        CConfigTool::Log(_T("%s, no radio buttons are set"),pItem->Macro());
111 
      }
112 
    }
113 
  }
114 
}
115 
 
116 
// Find the ConfigItem referencing the given CdlValuable
117 
CConfigItem * CConfigToolDoc::Find (CdlValuable v)
118 
{
119 
  for(int nItem=0;nItem<ItemCount();nItem++){
120 
    CConfigItem *pItem=Item(nItem);
121 
    if(v==pItem->GetCdlValuable()){
122 
      return pItem;
123 
    }
124 
  }
125 
  return NULL;
126 
}
127 
 
128 
CConfigItem * CConfigToolDoc::Find(const CString & strWhat,WhereType where)
129 
{
130 
  for(int nItem=0;nItem<ItemCount();nItem++){
131 
    CConfigItem *pItem=Item(nItem);
132 
    if(0==pItem->StringValue(where).Compare(strWhat)){
133 
      return pItem;
134 
    }
135 
  }
136 
  return NULL;
137 
}
138 
 
139 
void CConfigToolDoc::OnMLTNewRegion()
140 
{
141 
  // create the property sheet
142 
 
143 
  CPropertySheet prsRegionSheet (IDS_NEW_REGION_SHEET_TITLE, CConfigTool::GetMLTView());
144 
 
145 
  // add the property pages
146 
 
147 
  CRegionGeneralPage prpGeneral;
148 
  CNotePage prpNote;
149 
 
150 
  prsRegionSheet.AddPage (&prpGeneral);
151 
  prsRegionSheet.AddPage (&prpNote);
152 
 
153 
  // setup initial values
154 
 
155 
  prpGeneral.m_strRegionName = _T("");
156 
  prpGeneral.m_dwRegionStartAddress = 0;
157 
  prpGeneral.m_dwRegionSize = 0;
158 
 
159 
  // show property sheet
160 
 
161 
  if (prsRegionSheet.DoModal () == IDOK)
162 
  {
163 
    if (int nErrorCode = MemoryMap.create_memory_region (CUtils::UnicodeToStdStr(prpGeneral.m_strRegionName), prpGeneral.m_dwRegionStartAddress, prpGeneral.m_dwRegionSize, (prpGeneral.m_bRegionReadOnly ? read_only : read_write), CUtils::UnicodeToStdStr(prpNote.m_strNote)))
164 
      ErrorBox (IDS_ERR_MEMMAP_REGION_CREATE, IDS_ERR_MEMMAP_BASE + nErrorCode);
165 
    else // no errors
166 
    {
167 
      SetModifiedFlag ();
168 
      UpdateAllViews (NULL, MemLayoutChanged);
169 
    }
170 
  }
171 
}
172 
 
173 
void CConfigToolDoc::ErrorBox (UINT uIDSIntro, UINT uIDSError)
174 
{
175 
  CString strIntro, strError;
176 
  strIntro.LoadString (uIDSIntro);
177 
  strError.LoadString (uIDSError);
178 
  AfxMessageBox (strIntro + _T("\n\n") + strError);
179 
}
180 
 
181 
void CConfigToolDoc::OnMLTNewSection()
182 
{
183 
  // create the property sheet
184 
 
185 
  CPropertySheet prsSectionSheet (IDS_NEW_SECTION_SHEET_TITLE, CConfigTool::GetMLTView());
186 
 
187 
  // add the property pages
188 
 
189 
  CSectionGeneralPage prpGeneral;
190 
  CSectionRelocationPage prpRelocation;
191 
  CNotePage prpNote;
192 
 
193 
  prsSectionSheet.AddPage (&prpGeneral);
194 
  prsSectionSheet.AddPage (&prpRelocation);
195 
  prsSectionSheet.AddPage (&prpNote);
196 
 
197 
  // initialise for a new section
198 
 
199 
  prpGeneral.m_bNameLinkerDefined = TRUE;
200 
  prpGeneral.m_strNameLinker = _T("");
201 
  prpRelocation.m_bRelocates = FALSE;
202 
  prpRelocation.m_bNewSection = TRUE;
203 
 
204 
  // show property sheet
205 
 
206 
  if (prsSectionSheet.DoModal () == IDOK)
207 
  {
208 
    mem_anchor initial_anchor, final_anchor;
209 
    mem_address initial_address;
210 
    CString strInitialRelativeName = _T("");
211 
 
212 
    if (prpGeneral.m_bFinalAbsolute) // final location is an absolute location
213 
      final_anchor = absolute;
214 
    else // final location is a relative location
215 
      final_anchor = relative;
216 
 
217 
    if (prpRelocation.m_bRelocates) // if the section relocates
218 
    {
219 
      if (prpRelocation.m_bInitialAbsolute) // initial location is an absolute location
220 
      {
221 
        initial_anchor = absolute;
222 
      }
223 
      else // initial location is a relative location
224 
      {
225 
        strInitialRelativeName = prpRelocation.m_strInitialRelativeName;
226 
        initial_anchor = relative;
227 
      }
228 
      initial_address = prpRelocation.m_dwInitialAddress;
229 
    }
230 
    else
231 
    {
232 
      strInitialRelativeName = prpGeneral.m_strFinalRelativeName;
233 
      initial_anchor = final_anchor;
234 
      initial_address = prpGeneral.m_dwFinalAddress;
235 
    }
236 
 
237 
 
238 
    if (int nErrorCode = MemoryMap.create_memory_section (CUtils::UnicodeToStdStr(prpGeneral.m_bNameLinkerDefined ? prpGeneral.m_strNameLinker : prpGeneral.m_strNameUser), prpGeneral.m_dwSectionSize, prpGeneral.m_dwAlignment, initial_anchor, CUtils::UnicodeToStdStr(strInitialRelativeName), initial_address, final_anchor, CUtils::UnicodeToStdStr(prpGeneral.m_strFinalRelativeName), prpGeneral.m_dwFinalAddress, prpRelocation.m_bRelocates, false, prpGeneral.m_bNameLinkerDefined, CUtils::UnicodeToStdStr(prpNote.m_strNote)))
239 
      ErrorBox (IDS_ERR_MEMMAP_SECTION_CREATE, IDS_ERR_MEMMAP_BASE + nErrorCode);
240 
    else // no errors
241 
    {
242 
      SetModifiedFlag ();
243 
      UpdateAllViews (NULL, MemLayoutChanged);
244 
    }
245 
  }
246 
}
247 
 
248 
void CConfigToolDoc::OnMLTDelete()
249 
{
250 
  if (strSelectedSection != _T("")) // a section is selected
251 
  {
252 
    if (MemoryMap.delete_memory_section (CUtils::UnicodeToStdStr(strSelectedSection)))
253 
    {
254 
      strSelectedSection = _T("");
255 
      SetModifiedFlag ();
256 
      UpdateAllViews (NULL, MemLayoutChanged);
257 
    }
258 
    else
259 
      AfxMessageBox (_T("Could not delete memory section.\n\nMake sure there are no other sections defined relative to this one."));
260 
  }
261 
  else if (strSelectedRegion != _T("")) // a region is selected
262 
  {
263 
    if (MemoryMap.delete_memory_region (CUtils::UnicodeToStdStr(strSelectedRegion)))
264 
    {
265 
      strSelectedRegion = _T("");
266 
      SetModifiedFlag ();
267 
      UpdateAllViews (NULL, MemLayoutChanged);
268 
    }
269 
    else
270 
      AfxMessageBox (_T("Could not delete memory region.\n\nMake sure it is not in use.")); // FIXME
271 
  }
272 
}
273 
 
274 
void CConfigToolDoc::ShowRegionProperties()
275 
{
276 
  // create the property sheet
277 
 
278 
  CString strTitle;
279 
  strTitle.LoadString (IDS_REGION_PROPERTIES_SHEET_TITLE);
280 
  CPropertySheet prsRegionSheet (strSelectedRegion + _T(" - ") + strTitle, CConfigTool::GetMLTView());
281 
 
282 
  // add the property pages
283 
 
284 
  CRegionGeneralPage prpGeneral;
285 
  CNotePage prpNote;
286 
 
287 
  prsRegionSheet.AddPage (&prpGeneral);
288 
  prsRegionSheet.AddPage (&prpNote);
289 
 
290 
  // set up property sheet values
291 
 
292 
  mem_type type;
293 
  std::string note;
294 
  MemoryMap.get_memory_region (CUtils::UnicodeToStdStr(strSelectedRegion), &prpGeneral.m_dwRegionStartAddress, &prpGeneral.m_dwRegionSize, &type, &note);
295 
  prpGeneral.m_strRegionName = strSelectedRegion;
296 
  prpGeneral.m_bRegionReadOnly = (type == read_only);
297 
  prpNote.m_strNote = note.c_str ();
298 
 
299 
  // show property sheet
300 
 
301 
  if (prsRegionSheet.DoModal () == IDOK)
302 
  {
303 
    if (int nErrorCode = MemoryMap.edit_memory_region (CUtils::UnicodeToStdStr(strSelectedRegion), CUtils::UnicodeToStdStr(prpGeneral.m_strRegionName), prpGeneral.m_dwRegionStartAddress, prpGeneral.m_dwRegionSize, (prpGeneral.m_bRegionReadOnly ? read_only : read_write), CUtils::UnicodeToStdStr(prpNote.m_strNote)))
304 
      ErrorBox (IDS_ERR_MEMMAP_REGION_MODIFY, IDS_ERR_MEMMAP_BASE + nErrorCode);
305 
    else // no errors
306 
    {
307 
      SetModifiedFlag ();
308 
      UpdateAllViews (NULL, MemLayoutChanged);
309 
    }
310 
  }
311 
}
312 
 
313 
void CConfigToolDoc::ShowSectionProperties()
314 
{
315 
  // create the property sheet
316 
 
317 
  CString strTitle;
318 
  strTitle.LoadString (IDS_SECTION_PROPERTIES_SHEET_TITLE);
319 
  CPropertySheet prsSectionSheet (strSelectedSection + _T(" - ") + strTitle, CConfigTool::GetMLTView());
320 
 
321 
  // add the property pages
322 
 
323 
  CSectionGeneralPage prpGeneral;
324 
  CSectionRelocationPage prpRelocation;
325 
  CNotePage prpNote;
326 
 
327 
  prsSectionSheet.AddPage (&prpGeneral);
328 
  prsSectionSheet.AddPage (&prpRelocation);
329 
  prsSectionSheet.AddPage (&prpNote);
330 
 
331 
  // setup initial values
332 
 
333 
  std::list <mem_section>::iterator section = MemoryMap.find_memory_section (CUtils::UnicodeToStdStr(strSelectedSection));
334 
  prpGeneral.m_bNameLinkerDefined = (section->linker_defined);
335 
  if (prpGeneral.m_bNameLinkerDefined)
336 
    prpGeneral.m_strNameLinker = section->name.c_str ();
337 
  else
338 
  {
339 
    prpGeneral.m_strNameUser = section->name.c_str ();
340 
    prpGeneral.m_dwSectionSize = section->size;
341 
  }
342 
 
343 
  prpGeneral.m_bFinalAbsolute = (section->final_location->anchor == absolute);
344 
  if (prpGeneral.m_bFinalAbsolute)
345 
    prpGeneral.m_dwFinalAddress = section->final_location->address;
346 
  else
347 
  {
348 
    prpGeneral.m_strFinalRelativeName = MemoryMap.find_preceding_section (section, false)->name.c_str ();
349 
    prpGeneral.m_dwAlignment = section->alignment;
350 
  }
351 
 
352 
  prpRelocation.m_bRelocates = section->relocates;
353 
  if (prpRelocation.m_bRelocates)
354 
  {
355 
    prpRelocation.m_bInitialAbsolute = (section->initial_location->anchor == absolute);
356 
    if (prpRelocation.m_bInitialAbsolute)
357 
      prpRelocation.m_dwInitialAddress = section->initial_location->address;
358 
    else
359 
      prpRelocation.m_strInitialRelativeName = MemoryMap.find_preceding_section (section, true)->name.c_str ();
360 
  }
361 
 
362 
  prpNote.m_strNote = section->note.c_str ();
363 
 
364 
  // show property sheet
365 
 
366 
  if (prsSectionSheet.DoModal () == IDOK)
367 
  {
368 
    mem_anchor initial_anchor, final_anchor;
369 
    mem_address initial_address;
370 
    CString strInitialRelativeName = _T("");
371 
 
372 
    if (prpGeneral.m_bFinalAbsolute) // final location is an absolute location
373 
      final_anchor = absolute;
374 
    else // final location is a relative location
375 
      final_anchor = relative;
376 
 
377 
    if (prpRelocation.m_bRelocates) // if the section relocates
378 
    {
379 
      if (prpRelocation.m_bInitialAbsolute) // initial location is an absolute location
380 
      {
381 
        initial_anchor = absolute;
382 
      }
383 
      else // initial location is a relative location
384 
      {
385 
        strInitialRelativeName = prpRelocation.m_strInitialRelativeName;
386 
        initial_anchor = relative;
387 
      }
388 
      initial_address = prpRelocation.m_dwInitialAddress;
389 
    }
390 
    else
391 
    {
392 
      strInitialRelativeName = prpGeneral.m_strFinalRelativeName;
393 
      initial_anchor = final_anchor;
394 
      initial_address = prpGeneral.m_dwFinalAddress;
395 
    }
396 
 
397 
 
398 
    if (int nErrorCode = MemoryMap.edit_memory_section (CUtils::UnicodeToStdStr(strSelectedSection), CUtils::UnicodeToStdStr(prpGeneral.m_bNameLinkerDefined ? prpGeneral.m_strNameLinker : prpGeneral.m_strNameUser), prpGeneral.m_dwSectionSize, prpGeneral.m_dwAlignment, initial_anchor, CUtils::UnicodeToStdStr(strInitialRelativeName), initial_address, final_anchor, CUtils::UnicodeToStdStr(prpGeneral.m_strFinalRelativeName), prpGeneral.m_dwFinalAddress, prpRelocation.m_bRelocates, false, prpGeneral.m_bNameLinkerDefined, CUtils::UnicodeToStdStr(prpNote.m_strNote)))
399 
      ErrorBox (IDS_ERR_MEMMAP_SECTION_MODIFY, IDS_ERR_MEMMAP_BASE + nErrorCode);
400 
    else // no errors
401 
    {
402 
      SetModifiedFlag ();
403 
      UpdateAllViews (NULL, MemLayoutChanged);
404 
    }
405 
  }
406 
}
407 
 
408 
void CConfigToolDoc::OnMLTProperties()
409 
{
410 
  if (strSelectedRegion != _T(""))
411 
    ShowRegionProperties ();
412 
  else if (strSelectedSection != _T(""))
413 
    ShowSectionProperties ();
414 
}
415 
 
416 
// Choose a default Hal.  Do this using clues the installer may have helpfully left behind (PR 18050)
417 
// or else if there is only one possible choice, by choosing that one :-).
418 
/*
419 
void CConfigToolDoc::ChooseDefaultHal()
420 
{
421 
bool bFound=false;
422 
// Has the installer told us?
423 
LPCTSTR pszRegPath=_T("SOFTWARE\\Red Hat\\eCos\\1.2.8");
424 
HKEY hKey;
425 
if(ERROR_SUCCESS==RegOpenKeyEx (HKEY_LOCAL_MACHINE, pszRegPath, 0L, KEY_READ, &hKey)){
426 
DWORD dwSizePath=MAX_PATH;
427 
CString str;
428 
PTCHAR psz=str.GetBuffer(dwSizePath);
429 
if(ERROR_SUCCESS==RegQueryValueEx(hKey, _T("Default Architecture"), NULL, NULL, (LPBYTE)psz, &dwSizePath)){
430 
str.MakeLower();
431 
for(int nItem=0;nItem<ItemCount();nItem++){
432 
CConfigItem *pItem=Item(nItem);
433 
if(pItem->m_pTarget){
434 
CString strTarget(pItem->m_pTarget->Name());
435 
strTarget.MakeLower();
436 
if(-1!=str.Find(strTarget)){
437 
bFound=true;
438 
dwSizePath=MAX_PATH;
439 
if(ERROR_SUCCESS==::RegQueryValueEx(hKey, _T("Default Build Tools Path"), NULL, NULL, (LPBYTE)psz, &dwSizePath)){
440 
pItem->m_pTarget->SetBinDir(psz);
441 
for(CConfigItem *pSib=pItem->FirstRadio();pSib;pSib=pSib->NextRadio()){
442 
pSib->SetValue((ItemIntegerType) (pSib==pItem));
443 
}
444 
//                            pItem->EnableAncestors();
445 
}
446 
break;
447 
}
448 
}
449 
}
450 
}
451 
RegCloseKey(hKey);
452 
}
453 
 
454 
  if(!bFound){
455 
  // No - choose the Hal according to toolchain
456 
  for(int nItem=0;nItem<ItemCount();nItem++){
457 
  CConfigItem *pItem=Item(nItem);
458 
  if(pItem->m_pTarget){
459 
  CString strTarget(pItem->m_pTarget->Name());
460 
  strTarget.MakeLower();
461 
  for(int j=0;j<m_arstrToolChainPaths.GetSize();j++){
462 
  CString strTools(m_arstrToolChainPaths[j]);
463 
  strTools.MakeLower();
464 
  if(-1!=strTools.Find(strTarget)){
465 
  for(CConfigItem *pSib=pItem->FirstRadio();pSib;pSib=pSib->NextRadio()){
466 
  pSib->SetValue((ItemIntegerType) (pSib==pItem));
467 
  }
468 
  return;
469 
  }
470 
  }
471 
  }
472 
  }
473 
  }
474 
  }
475 
*/
476 
 
477 
bool CConfigToolDoc::SetValue (CConfigItem &ti, double dValue, CdlTransaction transaction/*=NULL*/)
478 
{
479 
  ASSERT (ti.Type () == CConfigItem::Double);
480 
 
481 
  // test if the new double value is in range
482 
  const CdlValuable valuable = ti.GetCdlValuable();
483 
  CdlListValue list_value;
484 
  CdlEvalContext context (NULL, ti.GetCdlItem (), ti.GetCdlItem ()->get_property (CdlPropertyId_LegalValues));
485 
  valuable->get_legal_values ()->eval (context, list_value);
486 
  if (! list_value.is_member (dValue))
487 
  {
488 
    if (dValue==valuable->get_double_value(CdlValueSource_Current) || IDNO == CUtils::MessageBoxFT (MB_YESNO, _T("%s is not a legal value for %s.\n\nDo you want to use this value anyway?"),
489 
      CUtils::DoubleToStr (dValue), ti.Macro ()))
490 
      return false;
491 
  }
492 
 
493 
  if (! ti.SetValue (dValue,transaction))
494 
    return false;
495 
 
496 
  SetModifiedFlag ();
497 
  return true;
498 
}
499 
bool CConfigToolDoc::SetValue(CConfigItem &ti,const CString &strValue, CdlTransaction transaction/*=NULL*/)
500 
{
501 
  // warn the user if a modified memory layout is about to be discarded
502 
  if (MemoryMap.map_modified () && (ti.Macro () == _T("CYG_HAL_STARTUP")) &&
503 
    (IDCANCEL == CUtils::MessageBoxFT (MB_OKCANCEL, _T("Changes to the current memory layout will be lost."))))
504 
    return false;
505 
 
506 
  bool rc=false;
507 
  switch(ti.Type()){
508 
                case CConfigItem::None:
509 
      break;
510 
    case CConfigItem::Enum:
511 
    case CConfigItem::String:
512 
      rc=ti.SetValue(strValue,transaction);
513 
      break;
514 
    case CConfigItem::Integer:
515 
      {
516 
        ItemIntegerType n;
517 
        rc=CUtils::StrToItemIntegerType(strValue,n) && SetValue(ti,n,transaction);
518 
      }
519 
      break;
520 
    case CConfigItem::Double:
521 
      {
522 
        double dValue;
523 
        rc = CUtils::StrToDouble (strValue, dValue) && SetValue (ti, dValue,transaction);
524 
      }
525 
      break;
526 
    default:
527 
      ASSERT(FALSE);
528 
      break;
529 
 
530 
  }
531 
  if(rc){
532 
    SetModifiedFlag();
533 
    UpdateAllViews (NULL, CConfigToolDoc::ValueChanged, (CObject *)&ti);
534 
  }
535 
  return rc;
536 
}
537 
 
538 
// Look in registry to match prefixes CYGPKG_HAL_ and CYGHWR_HAL_:
539 
//
540 
bool CConfigToolDoc::GetRunPlatform(CString &strTarget)
541 
{
542 
  CRegKeyEx k1(HKEY_CURRENT_USER,_T("Software\\Red Hat\\eCos\\Platforms"), KEY_READ);
543 
  CString strKey;
544 
  for(int i=0;k1.QueryKey(i,strKey);i++){
545 
    CRegKeyEx k2((HKEY)k1,strKey,KEY_READ);
546 
    // Subkeys' names are the target image names [one of which we aim to return]
547 
    // Subkeys's values of interest are:
548 
    //      Prefix  String
549 
    //      Sim     DWORD  [optional]
550 
    //      Macro   String
551 
    DWORD dwSim=0;
552 
    CString strPrefix,strMacro;
553 
    k2.QueryValue(_T("Sim"),dwSim);
554 
    k2.QueryValue(_T("Prefix"),strPrefix);
555 
    k2.QueryValue(_T("Macro"),strMacro);
556 
 
557 
    CConfigItem *pItem=Find(_T("CYGPKG_HAL_")+strMacro);
558 
    if(pItem && pItem->IsEnabled()){
559 
      // We have found what we are looking for - probably
560 
      pItem=Find(_T("CYGHWR_HAL_")+strMacro+_T("_STARTUP"));
561 
      if(pItem){
562 
        // Two platforms apply - choose this one only if the ram startup attribute fits
563 
        if( (dwSim==0) == (0==pItem->StringValue().CompareNoCase(_T("ram"))) ) {
564 
          strTarget=strKey;
565 
        }
566 
      } else {
567 
        // Only one platform applies
568 
        strTarget=strKey;
569 
      }
570 
 
571 
    }
572 
  }
573 
  return !strTarget.IsEmpty();
574 
}
575 
 
576 
bool CConfigToolDoc::SetEnabled(CConfigItem &ti, bool bEnabled, CdlTransaction transaction/*=NULL*/)
577 
{
578 
  const bool bStatus = ti.SetEnabled (bEnabled,transaction);
579 
 
580 
  if (bStatus) {
581 
    SetModifiedFlag();
582 
    UpdateAllViews (NULL, CConfigToolDoc::ValueChanged, (CObject *) &ti);
583 
  }
584 
  return bStatus;
585 
}
586 
 
587 
void CConfigToolDoc::AddContents (const CdlContainer container, CConfigItem *pParent)
588 
{
589 
 
590 
  // determine the container contents
591 
 
592 
  const std::vector<CdlNode>& contents = container->get_contents ();
593 
  std::vector<CdlNode>::const_iterator node_i;
594 
  for (node_i = contents.begin (); node_i != contents.end (); node_i++)
595 
  {
596 
    const CdlNode node = * node_i;
597 
    const CdlPackage pkg = dynamic_cast<CdlPackage> (node);
598 
    const CdlComponent comp = dynamic_cast<CdlComponent> (node);
599 
    const CdlOption opt = dynamic_cast<CdlOption> (node);
600 
    const CdlContainer contnr = dynamic_cast<CdlContainer> (node);
601 
 
602 
    // if the node in the container is a package, component or option
603 
    // then it is visible and should be added to the tree
604 
    if  (0 != pkg) // the node is a package
605 
    {
606 
      CConfigItem * pItem = AddItem (pkg, pParent); // add the package
607 
      AddContents (pkg, pItem); // add the package contents
608 
    }
609 
    else if (0 != comp) // the node is a component
610 
    {
611 
      CConfigItem * pItem = AddItem (comp, pParent); // add the component
612 
      AddContents (comp, pItem); // add the component contents
613 
    }
614 
    else if (0 != opt) // the node is an option
615 
      AddItem (opt, pParent); // add the option
616 
 
617 
    else if (0 != contnr) // if the node is a container
618 
      AddContents (contnr, pParent); // add the container contents
619 
 
620 
    // ignore nodes of any other class
621 
  }
622 
}
623 
 
624 
// Three hack functions.
625 
 
626 
const CString CConfigToolDoc::CurrentPlatform()
627 
{
628 
/*
629 
for(int nItem=0;nItem<ItemCount();nItem++){
630 
CConfigItem *pItem=Item(nItem);
631 
if(pItem->IsEnabled() && !pItem->Platform().IsEmpty()){
632 
return pItem->Platform();
633 
}
634 
}
635 
  */
636 
  return _T("");
637 
}
638 
 
639 
// a trivial CDL parse error handler
640 
void CConfigToolDoc::CdlParseErrorHandler (std::string message)
641 
{
642 
  CConfigToolDoc *pDoc=CConfigTool::GetConfigToolDoc();
643 
  pDoc->m_strCdlErrorMessage = message.c_str ();
644 
  TRACE (_T("CdlParseError: %s\n"), pDoc->m_strCdlErrorMessage);
645 
  CConfigTool::Log (CUtils::StripExtraWhitespace (pDoc->m_strCdlErrorMessage)); // display the message in the output window
646 
};
647 
 
648 
// a trivial CDL parse warning handler
649 
void CConfigToolDoc::CdlParseWarningHandler (std::string message)
650 
{
651 
  CConfigToolDoc *pDoc=CConfigTool::GetConfigToolDoc();
652 
  pDoc->m_strCdlErrorMessage = message.c_str ();
653 
  TRACE (_T("CdlParseWarning: %s\n"), pDoc->m_strCdlErrorMessage);
654 
  CConfigTool::Log (CUtils::StripExtraWhitespace (pDoc->m_strCdlErrorMessage)); // display the message in the output window
655 
};
656 
 
657 
// a trivial CDL load error handler
658 
void CConfigToolDoc::CdlLoadErrorHandler (std::string message)
659 
{
660 
  CConfigToolDoc *pDoc=CConfigTool::GetConfigToolDoc();
661 
  pDoc->m_strCdlErrorMessage = message.c_str ();
662 
  TRACE (_T("CdlLoadError: %s\n"), pDoc->m_strCdlErrorMessage);
663 
  CConfigTool::Log (CUtils::StripExtraWhitespace (pDoc->m_strCdlErrorMessage)); // display the message in the output window
664 
};
665 
 
666 
// a trivial CDL load warning handler
667 
void CConfigToolDoc::CdlLoadWarningHandler (std::string message)
668 
{
669 
  CConfigToolDoc *pDoc=CConfigTool::GetConfigToolDoc();
670 
  pDoc->m_strCdlErrorMessage = message.c_str ();
671 
  TRACE (_T("CdlLoadWarning: %s\n"), pDoc->m_strCdlErrorMessage);
672 
  CConfigTool::Log (CUtils::StripExtraWhitespace (pDoc->m_strCdlErrorMessage)); // display the message in the output window
673 
};
674 
 
675 
CdlInferenceCallbackResult CConfigToolDoc::CdlGlobalInferenceHandler(CdlTransaction transaction)
676 
{
677 
  CConfigToolDoc *pDoc=CConfigTool::GetConfigToolDoc();
678 
  pDoc->m_ConflictsOutcome=NotDone;  // prepare for the case that there are no solutions
679 
  CdlInferenceCallbackResult rc=CdlInferenceCallbackResult_Continue;
680 
  /*
681 
  std::list<CdlConflict>conflicts1(transaction->get_global_conflicts_with_solutions());
682 
  const std::vector<CdlConflict>&conflicts2=transaction->get_resolved_conflicts();
683 
        for (unsigned int i = 0; i < conflicts2.size (); i++) {
684 
                conflicts1.push_back(conflicts2 [i]);
685 
        }
686 
  if(conflicts1.size()>0){
687 
    CFailingRulesDialog dlg(conflicts1,transaction,&pDoc->m_arConflictsOfInterest);
688 
    rc=(IDOK==dlg.DoModal())?CdlInferenceCallbackResult_Continue:CdlInferenceCallbackResult_Cancel;
689 
    pDoc->m_ConflictsOutcome=(CdlInferenceCallbackResult_Continue==rc)?OK:Cancel;
690 
  }
691 
  */
692 
  const std::list<CdlConflict>& conflicts=pDoc->GetCdlConfig()->get_all_conflicts();
693 
  CFailingRulesDialog dlg(conflicts,transaction,&pDoc->m_arConflictsOfInterest);
694 
  rc=(IDOK==dlg.DoModal())?CdlInferenceCallbackResult_Continue:CdlInferenceCallbackResult_Cancel;
695 
  pDoc->m_ConflictsOutcome=(CdlInferenceCallbackResult_Continue==rc)?OK:Cancel;
696 
 
697 
  return rc;
698 
}
699 
 
700 
CdlInferenceCallbackResult CConfigToolDoc::CdlInferenceHandler (CdlTransaction transaction)
701 
{
702 
  CConfigToolDoc *pDoc=CConfigTool::GetConfigToolDoc();
703 
  CdlInferenceCallbackResult rc=CdlInferenceCallbackResult_Continue;
704 
  const std::list<CdlConflict>&conflicts=transaction->get_new_conflicts();
705 
  if((pDoc->m_nRuleChecking&Immediate) && conflicts.size()>0){
706 
    if(pDoc->m_nRuleChecking&SuggestFixes){
707 
      std::list<CdlConflict> s_conflicts;
708 
      for (std::list<CdlConflict>::const_iterator conf_i= conflicts.begin (); conf_i != conflicts.end (); conf_i++) { // for each conflict
709 
        if((*conf_i)->has_known_solution()){
710 
          s_conflicts.push_back(*conf_i);
711 
        }
712 
      }
713 
      if(s_conflicts.size()>0){
714 
        CFailingRulesDialog dlg(s_conflicts,transaction);
715 
        return(IDOK==dlg.DoModal()?CdlInferenceCallbackResult_Continue:CdlInferenceCallbackResult_Cancel);
716 
      }
717 
    }
718 
    CString strMsg;
719 
    if(1==conflicts.size()){
720 
      strMsg=(_T("There is 1 unresolved conflict."));
721 
    } else {
722 
      strMsg.Format(_T("There are %d unresolved conflict%s."),conflicts.size(),1==conflicts.size()?_T(""):_T("s"));
723 
    }
724 
    rc=(IDYES==CUtils::MessageBoxFT(MB_YESNO|MB_DEFBUTTON2,_T("%s  Make the change anyway?"),strMsg))?CdlInferenceCallbackResult_Continue:CdlInferenceCallbackResult_Cancel;
725 
  }
726 
  return rc;
727 
}
728 
 
729 
 
730 
// a CDL transaction handler to refresh the configuration tree
731 
void CConfigToolDoc::CdlTransactionHandler (const CdlTransactionCallback & data)
732 
{
733 
static int nNesting=0;
734 
TRACE(_T("Transaction handler: nesting level=%d\n"),nNesting++);
735 
  CConfigToolDoc *pDoc=CConfigTool::GetConfigToolDoc();
736 
  std::vector<CdlValuable>::const_iterator val_i;
737 
  std::vector<CdlNode>::const_iterator node_i;
738 
  std::list<CdlConflict>::const_iterator conf_i;
739 
  CControlView *pControlView=CConfigTool::GetControlView();
740 
  for (val_i = data.value_changes.begin(); val_i != data.value_changes.end(); val_i++)
741 
  {
742 
    const CString strName((*val_i)->get_name().c_str());
743 
    TRACE(_T("%s %s : value change\n"), CString ((*val_i)->get_class_name().c_str()), strName);
744 
    pControlView->Refresh(strName);
745 
    if (strName==_T("CYGHWR_MEMORY_LAYOUT")){               // the memory layout has changed...
746 
      pDoc->SwitchMemoryLayout (false); // ...so display a new one
747 
    }
748 
  }
749 
  for (node_i = data.active_changes.begin(); node_i != data.active_changes.end(); node_i++)
750 
  {
751 
    const CString strName((*node_i)->get_name().c_str());
752 
    TRACE(_T("%s %s : this has become active or inactive\n"), CString ((*node_i)->get_class_name().c_str()),
753 
      CString ((*node_i)->get_name().c_str()));
754 
    if (! dynamic_cast<CdlInterface> (*node_i)){ // if not an interface node
755 
      pControlView->Refresh(strName);
756 
    }
757 
  }
758 
  for (val_i = data.legal_values_changes.begin(); val_i != data.legal_values_changes.end(); val_i++)
759 
  {
760 
    const CString strName((*node_i)->get_class_name().c_str());
761 
    TRACE(_T("%s %s : the legal_values list has changed, a new widget may be needed.\n"),
762 
      CString ((*val_i)->get_class_name().c_str()), strName);
763 
  }
764 
 
765 
  for (val_i = data.value_source_changes.begin(); val_i != data.value_source_changes.end(); val_i++)
766 
  {
767 
    const CString strName((*val_i)->get_name().c_str());
768 
    CdlValueSource source = (*val_i)->get_source();
769 
    TRACE(_T("%s %s : the value source has changed to %s\n"),
770 
      CString ((*val_i)->get_class_name().c_str()), strName,
771 
      CString ((CdlValueSource_Default  == source) ? "default"  :
772 
    (CdlValueSource_Inferred == source) ? "inferred" :
773 
    (CdlValueSource_Wizard   == source) ? "wizard"   : "user"));
774 
    pControlView->Refresh (strName);
775 
  }
776 
 
777 
  pDoc->UpdateFailingRuleCount();
778 
nNesting--;
779 
}
780 
 
781 
// Three hack functions.
782 
 
783 
const CString CConfigToolDoc::CurrentMemoryLayout ()
784 
{
785 
  const CConfigItem * pItem = Find (_T("CYGHWR_MEMORY_LAYOUT"));
786 
#ifdef _DEBUG
787 
  if(NULL==pItem){
788 
    TRACE(_T("Warning - CurrentMemoryLayout() returning NULL\n"));
789 
  }
790 
#endif
791 
  return pItem ? pItem->StringValue () : _T("");
792 
}
793 
 
794 
const CString CConfigToolDoc::CurrentTestingIdentifier ()
795 
{
796 
  // use the CDL target as the default testing identifier
797 
  // override in the forthcoming testing identifier dialog as necessary
798 
  return GetCdlConfig()->get_hardware ().c_str ();
799 
 
800 
//  const CConfigItem * pItem = Find (_T("CYGTST_TESTING_IDENTIFIER"));
801 
//#ifdef _DEBUG
802 
//  if(NULL==pItem){
803 
//    TRACE(_T("Warning - CurrentTestingIdentifier() returning NULL\n"));
804 
//  }
805 
//#endif
806 
//  return pItem ? pItem->StringValue () : _T("");
807 
}
808 
 
809 
const CString CConfigToolDoc::CurrentStartup()
810 
{
811 
  const CConfigItem * pItem = Find (_T("CYG_HAL_STARTUP"));
812 
#ifdef _DEBUG
813 
  if(NULL==pItem){
814 
    TRACE(_T("Warning - CurrentStartup() returning NULL\n"));
815 
  }
816 
#endif
817 
  return pItem ? pItem->StringValue () : _T("");
818 
 
819 
  /*
820 
  for(int nItem=0;nItem<ItemCount();nItem++){
821 
                CConfigItem *pItem=Item(nItem);
822 
    const CString strName(pItem->Name());
823 
    if(0==strName.Compare(_T("Startup type")) && pItem->IsEnabled()){
824 
    return pItem->StringValue();
825 
    }
826 
    }
827 
    return _T("ram"); // FIXME - assume ram startup for now if no startup item
828 
  */
829 
}
830 
 
831 
void CConfigToolDoc::UpdateFailingRuleCount()
832 
{
833 
  int nCount=0;
834 
  if (GetCdlConfig ()){
835 
    // if configuration information
836 
 
837 
    // calculate the number of conflicts
838 
    nCount =
839 
      //                GetCdlConfig ()->get_structural_conflicts ().size () +    ignore for now
840 
      GetCdlConfig ()->get_all_conflicts ().size ();
841 
 
842 
    // update the conflicts view
843 
    if (CConfigTool::GetRulesView ()) {
844 
      CConfigTool::GetRulesView ()->FillRules ();
845 
    }
846 
  }
847 
  if(CConfigTool::GetMain()){
848 
    CConfigTool::GetMain()->SetFailRulePane(nCount);
849 
  }
850 
}
851 
 
852 
void CConfigToolDoc::LogConflicts (const std::list<CdlConflict> & conflicts)
853 
{
854 
  std::list<CdlConflict>::const_iterator conf_i;
855 
  for (conf_i = conflicts.begin (); conf_i != conflicts.end (); conf_i++) // for each conflict
856 
  {
857 
    CString strExplain = (* conf_i)->get_explanation ().c_str (); // get the conflict explanation
858 
    CConfigTool::Log (CUtils::StripExtraWhitespace (strExplain)); // display the message in the output window
859 
  }
860 
}
861 
 
862 
CString CConfigToolDoc::GetPackageName (const CString & strAlias)
863 
{
864 
  const std::vector<std::string> & packages = m_CdlPkgData->get_packages ();
865 
  std::vector<std::string>::const_iterator package_i;
866 
  for (package_i = packages.begin (); package_i != packages.end (); package_i++)
867 
  {
868 
    const std::vector<std::string> & aliases = m_CdlPkgData->get_package_aliases (* package_i);
869 
    CString strPackageAlias = aliases [0].c_str ();
870 
    if (aliases.size () && (0 == strAlias.Compare (strPackageAlias)))
871 
      return package_i->c_str ();
872 
  }
873 
  return _T("");
874 
}
875 
 
876 
void CConfigToolDoc::DeleteContents()
877 
{
878 
  TRACE(_T("###DeleteContents()\n"));
879 
#ifndef PLUGIN
880 
  CDocument::DeleteContents();
881 
#endif
882 
 
883 
  RemoveAllItems();
884 
  TRACE(_T("###DeleteContents done\n"));
885 
}
886 
 
887 
void CConfigToolDoc::SelectPackages ()
888 
{
889 
  CCdlPackagesDialog dlg;
890 
  // This map holds the CConfigItem pointers for the packages loaded before the dialog is invoked.
891 
  // We cannot use Find(), which traverses all items - potentially those that have been removed
892 
  CMapStringToPtr arLoadedPackages;
893 
 
894 
  // generate the contents of the add/remove list boxes
895 
  const std::vector<std::string> & packages = m_CdlPkgData->get_packages ();
896 
  std::vector<std::string>::const_iterator package_i;
897 
  for (package_i = packages.begin (); package_i != packages.end (); package_i++)
898 
  {
899 
    //          if (! m_CdlPkgData->is_hardware_package (* package_i)) // do not list hardware packages
900 
    {
901 
      const std::vector<std::string> & aliases = m_CdlPkgData->get_package_aliases (* package_i);
902 
      CString strMacroName = package_i->c_str ();
903 
 
904 
      // use the first alias (if any) as the package identifier
905 
      CString strPackageName = aliases.size () ? aliases [0].c_str () : strMacroName;
906 
      CConfigItem * pItem = Find (strMacroName);
907 
      if (pItem) // if the package is loaded
908 
      {
909 
        arLoadedPackages.SetAt(strMacroName,pItem);
910 
        // pass the currently selected package version string to the dialog box
911 
        const CdlValuable valuable = pItem->GetCdlValuable();
912 
        dlg.Insert (strPackageName, TRUE, NULL, valuable ? (LPCTSTR) CString (valuable->get_value ().c_str ()) : NULL);
913 
      }
914 
      else
915 
      {
916 
        // pass version string of the most latest version to the dialog box
917 
        dlg.Insert (strPackageName, FALSE, NULL, (LPCTSTR) CString (m_CdlPkgData->get_package_versions (* package_i) [0].c_str ()));
918 
      }
919 
    }
920 
  }
921 
 
922 
  if (IDOK == dlg.DoModal ())
923 
  {
924 
    bool bChanged = false; // until proved otherwise
925 
 
926 
    // determine whether each package has changed loaded/unloaded state
927 
    for (package_i = packages.begin (); package_i != packages.end (); package_i++)
928 
      //                        if (! m_CdlPkgData->is_hardware_package (* package_i)) // do not check hardware packages
929 
    {
930 
      const std::vector<std::string> & aliases = m_CdlPkgData->get_package_aliases (* package_i);
931 
      CString strMacroName = package_i->c_str ();
932 
 
933 
      // use the first alias (if any) as the package identifier
934 
      CString strPackageName = aliases.size () ? aliases [0].c_str () : strMacroName;
935 
 
936 
      CConfigItem *pItem=NULL;
937 
      bool bPreviouslyLoaded=arLoadedPackages.Lookup(strMacroName,(void *&)pItem);
938 
      bool bNowLoaded=dlg.IsAdded (strPackageName);
939 
 
940 
      // unload packages which are no longer required before
941 
      // loading new ones to avoid potential duplicate macro definitions
942 
      if (! bNowLoaded && bPreviouslyLoaded){
943 
        // The package was loaded but should now be unloaded:
944 
        bChanged|=pItem->Unload();
945 
      } else if (bNowLoaded) {// if the package should be loaded
946 
        const CString strVersion(dlg.GetVersion (strPackageName));
947 
        if (bPreviouslyLoaded) { // if the package is already loaded
948 
          CdlTransactionCallback::set_callback_fn (NULL); // avoid value refresh attempts during load/unload
949 
          bChanged|=pItem->ChangeVersion(strVersion);
950 
          CdlTransactionCallback::set_callback_fn (CdlTransactionHandler); // restore value refresh
951 
        } else {
952 
          // the package was not loaded but should now be loaded
953 
          TRACE (_T("Loading package %s\n"), strMacroName);
954 
          try
955 
          {
956 
            GetCdlConfig()->load_package (CUtils::UnicodeToStdStr(strMacroName), CUtils::UnicodeToStdStr (strVersion), CConfigToolDoc::CdlParseErrorHandler, CConfigToolDoc::CdlParseWarningHandler);
957 
            bChanged=true;
958 
          }
959 
          catch (CdlStringException exception)
960 
          {
961 
            CUtils::MessageBoxF(_T("Error loading package %s:\n\n%s"), strMacroName, CString (exception.get_message ().c_str ()));
962 
          }
963 
          catch (...)
964 
          {
965 
            CUtils::MessageBoxF(_T("Error loading package %s."), strMacroName);
966 
          }
967 
        }
968 
      }
969 
    }
970 
 
971 
    if (bChanged) {// at least one package was loaded, unloaded or changed version
972 
      SetModifiedFlag();
973 
      RegenerateData();
974 
    }
975 
  }
976 
}
977 
 
978 
bool CConfigToolDoc::SetValue(CConfigItem &ti,ItemIntegerType nValue, CdlTransaction transaction/*=NULL*/)
979 
{
980 
  switch(ti.Type()){
981 
                case CConfigItem::Enum:
982 
    case CConfigItem::Integer:
983 
      //                case CConfigItem::Boolean:
984 
      //                case CConfigItem::Radio:
985 
      break;
986 
    case CConfigItem::None:
987 
    case CConfigItem::String:
988 
    default:
989 
      ASSERT(FALSE);
990 
      break;
991 
  }
992 
 
993 
  bool rc=false;
994 
  bool bChangingMemmap=MemoryMap.map_modified () && ((ti.Macro ().Compare (_T ("CYG_HAL_STARTUP")) == 0));
995 
 
996 
  if(nValue==ti.Value()){
997 
    return true;
998 
  }
999 
 
1000 
  // test if the new integer value is in range
1001 
  if (CConfigItem::Integer == ti.Type ())
1002 
        {
1003 
    const CdlValuable valuable = ti.GetCdlValuable();
1004 
    CdlListValue list_value;
1005 
    CdlEvalContext context (NULL, ti.GetCdlItem (), ti.GetCdlItem ()->get_property (CdlPropertyId_LegalValues));
1006 
    valuable->get_legal_values ()->eval (context, list_value);
1007 
    if (! list_value.is_member ((cdl_int) nValue))
1008 
    {
1009 
      if (nValue==(ItemIntegerType) valuable->get_integer_value (CdlValueSource_Current) || IDNO == CUtils::MessageBoxFT (MB_YESNO, _T("%s is not a legal value for %s.\n\nDo you want to use this value anyway?"),
1010 
        CUtils::IntToStr (nValue, CConfigTool::GetConfigToolDoc ()->m_bHex), ti.Macro ()))
1011 
        goto Exit;
1012 
    };
1013 
        }
1014 
 
1015 
  //    if(!ti.CanSetValue(nValue))
1016 
  //    {
1017 
  //        if(bInteractive){
1018 
  //                    CString strExplanation;
1019 
  //                    if(CConfigItem::Integer==ti.Type()){
1020 
  //                            strExplanation.Format(_T(" [value must lie in the range %d..%d]"),
1021 
  //                                    CUtils::IntToStr(ti.Min(),m_bHex),
1022 
  //                    CUtils::IntToStr(ti.Max()),m_bHex);
1023 
  //                    }
1024 
  //                    CUtils::MessageBoxF(
1025 
  //                            _T("Cannot set '%s' to %s%s"),
1026 
  //                            ti.ItemNameOrMacro(), CUtils::IntToStr(nValue,m_bHex), strExplanation);
1027 
  //        }
1028 
  //            goto Exit;
1029 
  //    }
1030 
 
1031 
  // warn the user if the current memory layout has been changed and will be lost
1032 
  // this will happen when the layout has been modified and the target-platform-startup is changed
1033 
 
1034 
  if (bChangingMemmap && IDCANCEL==CUtils::MessageBoxFT(MB_OKCANCEL,_T("Changes to the current memory layout will be lost."))){
1035 
    goto Exit;
1036 
  }
1037 
 
1038 
  // Save state
1039 
  if(!ti.SetValue(nValue,transaction)){
1040 
    // CanSetValue above should have caught this
1041 
    CUtils::MessageBoxF(_T("Cannot set '%s' to %d"),ti.ItemNameOrMacro(), nValue);
1042 
    goto Exit;
1043 
  }
1044 
 
1045 
  rc=true;
1046 
Exit:
1047 
  if(rc){
1048 
    SetModifiedFlag();
1049 
    UpdateFailingRuleCount ();
1050 
    UpdateAllViews (NULL, CConfigToolDoc::ValueChanged, (CObject *)&ti);
1051 
    // switch to new memory layout when target, platform or startup changes
1052 
    // but ignore cases where a target or platform is being deactivated (PR 19363)
1053 
 
1054 
    //          if (((CurrentTarget () != pOldTarget) || (CurrentPlatform () != strOldPlatform) || (ti.Name ().Compare (_T ("Startup type")) == 0)) &&
1055 
    //                  ((ti.Type () != CConfigItem::Radio) || (nValue)))
1056 
    //                  SwitchMemoryLayout ((CurrentTarget () != pOldTarget) || (CurrentPlatform () != strOldPlatform));
1057 
  }
1058 
  return rc;
1059 
}
1060 
 
1061 
bool CConfigToolDoc::OpenRepository(LPCTSTR pszRepository/*=NULL*/,bool bPromptInitially/*=false*/)
1062 
{
1063 
  if(!m_bRepositoryOpen){
1064 
    CWaitCursor wait;
1065 
    CIdleMessage IM(_T("Opening repository"));
1066 
    UpdateFailingRuleCount();
1067 
 
1068 
    CFileName strNewRepository;
1069 
    while(!m_bRepositoryOpen){
1070 
 
1071 
      if(bPromptInitially){
1072 
        CFolderDialog dlg(/*BOOL bAllowCreation=*/false);
1073 
        dlg.m_strDesc=_T("Please specify the root of the eCos repository tree.");
1074 
        dlg.m_strTitle=_T("Choose folder for eCos repository");
1075 
        dlg.m_strFolder=strNewRepository;
1076 
        CConfigTool::DismissSplash();
1077 
        if(IDCANCEL==dlg.DoModal()){
1078 
          return false;
1079 
        }
1080 
        strNewRepository=dlg.m_strFolder;
1081 
      } else {
1082 
        // Use what came in as parameter or what was found in registry
1083 
        strNewRepository=pszRepository?pszRepository:m_strRepository;
1084 
        bPromptInitially=true;
1085 
      }
1086 
 
1087 
      IM.Set (_T("Opening repository ") + (CString) strNewRepository);
1088 
 
1089 
      CdlPackagesDatabase NewCdlPkgData = NULL;
1090 
      CdlInterpreter      NewCdlInterp  = NULL;
1091 
      CdlConfiguration    NewCdlConfig  = NULL;
1092 
      CFileName strNewPackagesDir;
1093 
 
1094 
      EnableCallbacks(false); // disable transaction callbacks until the config tree is regenerated
1095 
 
1096 
      if(OpenRepository(strNewRepository,NewCdlPkgData,NewCdlInterp,NewCdlConfig,strNewPackagesDir)){
1097 
        // Success
1098 
 
1099 
        // select the "default" template if it exists
1100 
        // otherwise select the first available template
1101 
        std::string default_template = "default";
1102 
        if (! NewCdlPkgData->is_known_template (default_template))
1103 
        {
1104 
          const std::vector<std::string>& templates = NewCdlPkgData->get_templates ();
1105 
          if (templates.size () != 0)
1106 
            default_template = templates [0];
1107 
        }
1108 
 
1109 
        m_template_version = "";
1110 
        try
1111 
        {
1112 
          const std::vector<std::string>& template_versions = NewCdlPkgData->get_template_versions (default_template);
1113 
          NewCdlConfig->set_template (default_template, template_versions [0], &CdlParseErrorHandler, &CdlParseWarningHandler);
1114 
          m_template_version = template_versions [0];
1115 
        }
1116 
        catch (CdlStringException exception) {
1117 
          CUtils::MessageBoxF(_T("Error loading package template '%s':\n\n%s"), CString (default_template.c_str ()), CString (exception.get_message ().c_str ()));
1118 
        }
1119 
        catch (...) {
1120 
          CUtils::MessageBoxF(_T("Error loading package template '%s'."), CString (default_template.c_str ()));
1121 
        }
1122 
 
1123 
        // check the configuration
1124 
        ASSERT (NewCdlConfig->check_this (cyg_extreme));
1125 
 
1126 
        // use the new package database, interpreter and configuration
1127 
        deleteZ(m_CdlConfig); // delete the previous configuration
1128 
        deleteZ(m_CdlInterp); // delete the previous interpreter
1129 
        deleteZ(m_CdlPkgData); // delete the previous package database
1130 
 
1131 
        m_CdlPkgData = NewCdlPkgData;
1132 
        m_CdlInterp  = NewCdlInterp;
1133 
        m_CdlConfig  = NewCdlConfig;
1134 
 
1135 
        // save the repository location
1136 
 
1137 
        SetRepository(strNewRepository);
1138 
        m_strPackagesDir = strNewPackagesDir;
1139 
 
1140 
#ifndef PLUGIN
1141 
        // clear the previously specified document file name (if any),
1142 
        // OnNewDocument() calls DeleteContents() so must be called
1143 
        // before AddAllItems()
1144 
        CDocument::OnNewDocument ();
1145 
#endif
1146 
 
1147 
        // generate the CConfigItems from their CDL descriptions
1148 
        AddAllItems ();
1149 
 
1150 
        m_bRepositoryOpen=true;
1151 
      } else {
1152 
        // failure
1153 
        deleteZ(NewCdlConfig);
1154 
        deleteZ(NewCdlInterp);
1155 
        deleteZ(NewCdlPkgData);
1156 
 
1157 
      }
1158 
 
1159 
      // install a transaction handler callback function now that the tree exists
1160 
      EnableCallbacks(true);
1161 
    }
1162 
 
1163 
    }
1164 
    return m_bRepositoryOpen;
1165 
}
1166 
 
1167 
// Helper fn for namesake above
1168 
bool CConfigToolDoc::OpenRepository (const CFileName strNewRepository,CdlPackagesDatabase &NewCdlPkgData,CdlInterpreter &NewCdlInterp,CdlConfiguration &NewCdlConfig,CFileName &strNewPackagesDir)
1169 
{
1170 
  bool rc=false;
1171 
  TRACE(_T("###Open repository %s\n"),strNewRepository);
1172 
  if(!strNewRepository.IsEmpty()){
1173 
    // Now strNewRepository is guaranteed non-empty, but does it exist?
1174 
    if(!strNewRepository.IsDir()) {
1175 
      CUtils::MessageBoxF(_T("Cannot open repository - the folder %s does not exist"), strNewRepository);
1176 
    } else {
1177 
 
1178 
      // Ok so it exists, but does it look right?
1179 
      strNewPackagesDir=strNewRepository+_T("ecc");
1180 
      if(!strNewPackagesDir.IsDir()){
1181 
        strNewPackagesDir=strNewRepository+_T("packages");
1182 
      }
1183 
 
1184 
      if(!strNewPackagesDir.IsDir()){
1185 
        // Don't mention the ecc\ attempt
1186 
        CUtils::MessageBoxF(_T("%s does not seem to be a source repository: the folder %s does not exist"),
1187 
          strNewRepository,strNewPackagesDir);
1188 
      } else {
1189 
 
1190 
        const CFileName strDatabase = strNewPackagesDir + _T("ecos.db");
1191 
        if(!strDatabase.Exists()) {
1192 
          CUtils::MessageBoxF(_T("%s does not seem to be a source repository: %s does not exist"), strNewRepository, strDatabase);
1193 
        } else {
1194 
 
1195 
          // create a CDL repository, interpreter and configuration
1196 
 
1197 
          try {// create a new package database, interpreter and configuration
1198 
            NewCdlPkgData = CdlPackagesDatabaseBody::make (CUtils::UnicodeToStdStr(strNewPackagesDir), &CdlParseErrorHandler, &CdlParseWarningHandler);
1199 
            NewCdlInterp = CdlInterpreterBody::make ();
1200 
            NewCdlConfig = CdlConfigurationBody::make ("eCos", NewCdlPkgData, NewCdlInterp);
1201 
          }
1202 
          catch (CdlStringException exception) {
1203 
            CUtils::MessageBoxF(_T("Error opening eCos repository:\n\n%s"), CString (exception.get_message ().c_str ()));
1204 
            return false;
1205 
          }
1206 
          catch (...) {
1207 
            CUtils::MessageBoxF(_T("Error opening eCos repository."));
1208 
            return false;
1209 
          }
1210 
 
1211 
          // select the default target if specified in the registry
1212 
          // otherwise select the first available target
1213 
          std::string default_hardware = CUtils::UnicodeToStdStr (GetDefaultHardware ());
1214 
          if (! NewCdlPkgData->is_known_target (default_hardware)) {
1215 
            const std::vector<std::string>& targets = NewCdlPkgData->get_targets ();
1216 
            if (targets.size () == 0){
1217 
              CUtils::MessageBoxF (_T("Error opening eCos repository:\n\nno hardware templates"));
1218 
              return false;
1219 
            } else {
1220 
              default_hardware = targets [0];
1221 
            }
1222 
          }
1223 
 
1224 
          try {
1225 
            m_strCdlErrorMessage = _T("");
1226 
            NewCdlConfig->set_hardware (default_hardware, &CdlParseErrorHandler, &CdlParseWarningHandler);
1227 
          }
1228 
          catch (CdlStringException exception) {
1229 
            if (m_strCdlErrorMessage.IsEmpty ())
1230 
            {
1231 
              CUtils::MessageBoxF (_T("Error loading the default hardware template '%s':\n\n%s"), CString (default_hardware.c_str ()), CString (exception.get_message ().c_str ()));
1232 
            }
1233 
            else // report the most recent parser message in the message box since there may be no output pane in which to view it
1234 
            {
1235 
              CUtils::MessageBoxF (_T("Error loading the default hardware template '%s':\n\n%s\n\nParser message:\n\n%s"), CString (default_hardware.c_str ()), CString (exception.get_message ().c_str ()), m_strCdlErrorMessage);
1236 
            }
1237 
            return false;
1238 
          }
1239 
          catch (...) {
1240 
            CUtils::MessageBoxF (_T("Error loading the default hardware template '%s':\n\n%s"), CString (default_hardware.c_str ()), m_strCdlErrorMessage);
1241 
            return false;
1242 
          }
1243 
          rc=true;
1244 
        }
1245 
      }
1246 
    }
1247 
  }
1248 
  return rc;
1249 
}
1250 
 
1251 
void CConfigToolDoc::CloseRepository()
1252 
{
1253 
  if(m_bRepositoryOpen){
1254 
    // delete the libCDL objects with the document
1255 
    EnableCallbacks(false); // first disable the transaction handler
1256 
    deleteZ(m_CdlConfig);
1257 
    deleteZ(m_CdlInterp);
1258 
    deleteZ(m_CdlPkgData);
1259 
    m_bRepositoryOpen=false;
1260 
  }
1261 
}
1262 
 
1263 
void CConfigToolDoc::SelectTemplate (std::string NewTemplate, std::string NewTemplateVersion)
1264 
{
1265 
  if ((NewTemplate != m_CdlConfig->get_template()) || (NewTemplateVersion != m_template_version)){
1266 
 
1267 
    CWaitCursor wait; // this may take a little while
1268 
    RemoveAllItems();
1269 
    m_template_version = "";
1270 
    try
1271 
    {
1272 
      m_CdlConfig->set_template (NewTemplate, NewTemplateVersion, CdlParseErrorHandler, CdlParseWarningHandler);
1273 
      m_template_version = NewTemplateVersion;
1274 
    }
1275 
    catch (CdlStringException exception)
1276 
    {
1277 
      CUtils::MessageBoxF(_T("Error loading package template '%s':\n\n%s"), CString (NewTemplate.c_str ()), CString (exception.get_message ().c_str ()));
1278 
    }
1279 
    catch (...)
1280 
    {
1281 
      CUtils::MessageBoxF(_T("Error loading package template '%s'."), CString (NewTemplate.c_str ()));
1282 
    }
1283 
    RegenerateData();
1284 
 
1285 
    if (!GetPathName().IsEmpty()){ // not a new document
1286 
      CopyMLTFiles (); // copy new MLT files to the build tree as necessary
1287 
    }
1288 
    SetModifiedFlag();
1289 
  }
1290 
}
1291 
 
1292 
void CConfigToolDoc::RegenerateData()
1293 
{
1294 
  CWaitCursor wait; // This may take a little while
1295 
  AddAllItems (); // regenerate all the config items since the topology may have changed
1296 
  if (m_strLinkerScriptFolder.IsEmpty ())
1297 
  {
1298 
    CUtils::MessageBoxF(_T("The eCos linker script macro CYGBLD_LINKER_SCRIPT is not defined."));
1299 
  }
1300 
  if (m_strMemoryLayoutFolder.IsEmpty ())
1301 
  {
1302 
    CUtils::MessageBoxF(_T("The eCos memory layout macro CYGHWR_MEMORY_LAYOUT is not defined."));
1303 
  }
1304 
  SwitchMemoryLayout (true); // the hardware template may have changed
1305 
  UpdateBuildInfo();
1306 
  CConfigTool::GetControlView()->SelectItem(Item(0));
1307 
}
1308 
 
1309 
void CConfigToolDoc::SelectHardware (std::string NewTemplate)
1310 
{
1311 
  const std::string OldTemplate=m_CdlConfig->get_hardware();
1312 
  if (NewTemplate != OldTemplate){
1313 
    RemoveAllItems();
1314 
 
1315 
    try
1316 
    {
1317 
      m_CdlConfig->set_hardware (NewTemplate, CdlParseErrorHandler, CdlParseWarningHandler);
1318 
    }
1319 
    catch (CdlStringException exception)
1320 
    {
1321 
      CUtils::MessageBoxF(_T("Error loading hardware template '%s':\n\n%s"), CString (NewTemplate.c_str ()), CString (exception.get_message ().c_str ()));
1322 
      m_CdlConfig->set_hardware (OldTemplate, CdlParseErrorHandler, CdlParseWarningHandler);
1323 
    }
1324 
    catch (...)
1325 
    {
1326 
      CUtils::MessageBoxF(_T("Error loading hardware template '%s'."), CString (NewTemplate.c_str ()));
1327 
      m_CdlConfig->set_hardware (OldTemplate, CdlParseErrorHandler, CdlParseWarningHandler);
1328 
    }
1329 
 
1330 
    RegenerateData();
1331 
    //EnableCallbacks(true); // re-enable the transaction handler
1332 
    if (!GetPathName().IsEmpty()){
1333 
      CopyMLTFiles (); // copy new MLT files to the build tree as necessary
1334 
    }
1335 
    SetModifiedFlag();
1336 
  }
1337 
}
1338 
 
1339 
bool CConfigToolDoc::SaveMemoryMap()
1340 
{
1341 
  const CString strSuffix(_T("mlt_") + CurrentMemoryLayout ());
1342 
  const CFileName strMLTInstallPkgconfDir(InstallTree() + _T("include\\pkgconf"));
1343 
  bool rc=false;
1344 
  if(strMLTInstallPkgconfDir.CreateDirectory(true)){
1345 
    const CString strMLTInstallBase(strMLTInstallPkgconfDir+CFileName(strSuffix));
1346 
    const CFileName strMLTDir (MLTDir());
1347 
    if(strMLTDir.CreateDirectory (true)){
1348 
      const CString strMLTBase (strMLTDir + CFileName (strSuffix));
1349 
      TRACE(_T("Saving memory layout to %s\n"), strMLTBase + _T(".mlt"));
1350 
      if(MemoryMap.save_memory_layout (strMLTBase + _T(".mlt"))){
1351 
        TRACE(_T("Exporting memory layout to %s\n"), strMLTInstallPkgconfDir);
1352 
        rc=MemoryMap.export_files (strMLTInstallBase + _T(".ldi"), strMLTInstallBase + _T(".h"));
1353 
      }
1354 
    }
1355 
  }
1356 
  return rc;
1357 
}
1358 
 
1359 
bool CConfigToolDoc::CopyMLTFiles()
1360 
{
1361 
  // copy default MLT files for the selected target/platform from the repository if they do not already exist
1362 
 
1363 
  TRACE (_T("Looking for MLT files at %s\n"), PackagesDir() + m_strMemoryLayoutFolder + _T("include\\pkgconf\\mlt_*.*"));
1364 
  const CFileName strInstallDestination(InstallTree () + _T("include\\pkgconf"));
1365 
  const CFileName strMLTDestination (MLTDir ());
1366 
  TRACE (_T("Copying .ldi and .h files to %s\n"), strInstallDestination);
1367 
  TRACE (_T("Copying .mlt files to %s\n"), strMLTDestination);
1368 
  bool rc=strInstallDestination.CreateDirectory (true) && strMLTDestination.CreateDirectory (true);
1369 
  if(rc){
1370 
    CFileFind ffFileFind;
1371 
    BOOL bLastFile = ffFileFind.FindFile (PackagesDir() + m_strMemoryLayoutFolder + _T("\\include\\pkgconf\\mlt_*.*"));
1372 
    while (bLastFile)
1373 
    {
1374 
      bLastFile = ffFileFind.FindNextFile ();
1375 
      if (_T(".mlt") == ffFileFind.GetFileName ().Right (4)) // if a .mlt file
1376 
      {
1377 
        if (! CFileName (strMLTDestination, CFileName (ffFileFind.GetFileName ())).Exists ())
1378 
        {
1379 
          if(!CUtils::CopyFile (ffFileFind.GetFilePath (), strMLTDestination + CFileName (ffFileFind.GetFileName ()))){
1380 
            return false; // message already emitted
1381 
          }
1382 
        }
1383 
      }
1384 
      else // a .h or .ldi file
1385 
      {
1386 
        if (! CFileName (strInstallDestination, CFileName (ffFileFind.GetFileName ())).Exists () &&
1387 
          !CUtils::CopyFile (ffFileFind.GetFilePath (), strInstallDestination + CFileName (ffFileFind.GetFileName ()))){
1388 
          return false; // message already emitted
1389 
        }
1390 
      }
1391 
    }
1392 
  }
1393 
  return rc; //FIXME
1394 
}
1395 
 
1396 
CString CConfigToolDoc::GetDefaultHardware ()
1397 
{
1398 
  CString strKey = _T("SOFTWARE\\Red Hat\\eCos");
1399 
  CString strVersionKey = _T("");
1400 
  CString rc = _T("");
1401 
  TCHAR pszBuffer [MAX_PATH + 1];
1402 
  HKEY hKey;
1403 
  LONG lStatus;
1404 
 
1405 
  // get the greatest eCos version subkey
1406 
  if (ERROR_SUCCESS == RegOpenKeyEx (HKEY_LOCAL_MACHINE, strKey, 0L, KEY_READ, &hKey))
1407 
  {
1408 
    DWORD dwIndex = 0;
1409 
    while (ERROR_SUCCESS == RegEnumKey (hKey, dwIndex++, (LPTSTR) pszBuffer, sizeof (pszBuffer)))
1410 
    {
1411 
      if (strVersionKey.Compare (pszBuffer) < 0)
1412 
        strVersionKey = pszBuffer;
1413 
    }
1414 
    RegCloseKey (hKey);
1415 
    if (! strVersionKey.IsEmpty ())
1416 
    {
1417 
      TRACE (_T("CConfigToolDoc::GetDefaultHardware(): version subkey = '%s'\n"), strVersionKey);
1418 
 
1419 
      // get the default hardware value
1420 
      strKey +=  _T("\\") + strVersionKey;
1421 
      if (ERROR_SUCCESS == RegOpenKeyEx (HKEY_LOCAL_MACHINE, strKey, 0L, KEY_READ, &hKey))
1422 
      {
1423 
        DWORD dwBufferSize = sizeof (pszBuffer);
1424 
        lStatus = RegQueryValueEx (hKey, _T("Default Hardware"), NULL, NULL, (LPBYTE) pszBuffer, &dwBufferSize);
1425 
        RegCloseKey (hKey);
1426 
        if (ERROR_SUCCESS == lStatus)
1427 
        {
1428 
          TRACE (_T("CConfigToolDoc::GetDefaultHardware(): default hardware = '%s'\n"), pszBuffer);
1429 
          rc=pszBuffer;
1430 
        }
1431 
      }
1432 
    }
1433 
  }
1434 
  return rc;
1435 
}
1436 
 
1437 
CConfigItem * CConfigToolDoc::AddItem (const CdlUserVisible vitem, CConfigItem * pParent)
1438 
{
1439 
  CConfigItem * pItem = new CConfigItem (pParent, vitem);
1440 
 
1441 
  m_arItem.Add(pItem);
1442 
  pItem->m_strDesc = CUtils::StripExtraWhitespace (CString (vitem->get_description ().c_str ()));
1443 
 
1444 
  if (vitem->get_name () == "CYGHWR_MEMORY_LAYOUT")
1445 
  {
1446 
    ASSERT (m_strMemoryLayoutFolder.IsEmpty ());
1447 
    m_strMemoryLayoutFolder = vitem->get_owner ()->get_directory().c_str ();
1448 
    m_strMemoryLayoutFolder.Replace(_TCHAR('/'),_TCHAR('\\'));
1449 
    TRACE (_T("Found memory layout folder: %s\n"), m_strMemoryLayoutFolder);
1450 
  }
1451 
 
1452 
  if (vitem->get_name () == "CYGBLD_LINKER_SCRIPT")
1453 
  {
1454 
    ASSERT (m_strLinkerScriptFolder.IsEmpty ());
1455 
    m_strLinkerScriptFolder = vitem->get_owner ()->get_directory().c_str ();
1456 
    m_strLinkerScriptFolder.Replace(_TCHAR('/'),_TCHAR('\\'));
1457 
    TRACE (_T("Found linker script folder: %s\n"), m_strLinkerScriptFolder);
1458 
 
1459 
    // the CDL hardware template name will eventually become the target name,
1460 
    // but for now we must deduce the target name from the linker script file name
1461 
 
1462 
    const CdlValuable valuable = dynamic_cast<CdlValuable> (vitem);
1463 
    CFileName strLinkerScript (m_strPackagesDir, m_strLinkerScriptFolder, CString (valuable->get_value ().c_str ()));
1464 
    strLinkerScript.Replace (_TCHAR('/'), _TCHAR('\\'));
1465 
    if(!strLinkerScript.Exists ()){
1466 
        CConfigTool::Log(_T("%s does not exist\n"),strLinkerScript);
1467 
    }
1468 
    TRACE (_T("Target '%s' selected\n"), strLinkerScript.Tail ().Root (), pItem->Macro());
1469 
    //CFileName strBinDir = AfxGetApp () -> GetProfileString (CUtils::LoadString (IDS_KEY_TOOLS_DIR), pTarget->Name (), _T(""));
1470 
    //if (! strBinDir.IsEmpty () && strBinDir.IsDir ())
1471 
    //{
1472 
    //  pTarget->SetBinDir (strBinDir);
1473 
    //}
1474 
  }
1475 
 
1476 
  //TRACE(_T("Created new item from cdl: "));
1477 
  //pItem->DumpItem();
1478 
  return pItem;
1479 
}
1480 
 
1481 
void CConfigToolDoc::AddAllItems ()
1482 
{
1483 
  // remove any old items and packages
1484 
  DeleteContents ();
1485 
  if(NULL!=CConfigTool::GetControlView()){ // may not be the case for plugin
1486 
 
1487 
    // add the root item
1488 
    CConfigItem * pItem = new CConfigItem (NULL, NULL);
1489 
    m_arItem.Add(pItem);
1490 
    pItem->m_strDesc = _T("The root node for all configurable items");
1491 
 
1492 
    // add the remaining items using their CDL descriptions
1493 
    m_strMemoryLayoutFolder = _T("");
1494 
    m_strLinkerScriptFolder = _T("");
1495 
    AddContents (m_CdlConfig, FirstItem ());
1496 
 
1497 
    // check that exactly one radio button in each group is enabled
1498 
    CheckRadios ();
1499 
 
1500 
    // update the rules (conflicts) view
1501 
    UpdateFailingRuleCount ();
1502 
 
1503 
    if(NULL==CConfigTool::GetRulesView() || !CConfigTool::GetRulesView()->IsWindowVisible()){
1504 
      // log all conflicts
1505 
      //        LogConflicts (m_CdlConfig->get_structural_conflicts ()); // relating to package availability - ignore for now
1506 
      LogConflicts (m_CdlConfig->get_all_conflicts ());
1507 
    }
1508 
 
1509 
    CConfigTool::GetControlView()->SelectItem(Item(0));
1510 
    UpdateAllViews (NULL, SelChanged, (CObject *)Item(0)); // refresh the display
1511 
    if(ItemCount()>0){
1512 
      CConfigTool::GetControlView()->GetTreeCtrl().Expand(Item(0)->HItem(),TVE_EXPAND);
1513 
    }
1514 
    CConfigTool::GetControlView()->SetFocus();
1515 
  }
1516 
}
1517 
 
1518 
const CFileName CConfigToolDoc::CurrentLinkerScript()
1519 
{
1520 
  const CConfigItem * pItem = Find (_T("CYGBLD_LINKER_SCRIPT"));
1521 
  return pItem ? CFileName (m_strPackagesDir, m_strLinkerScriptFolder, pItem->StringValue ()) : _T("");
1522 
}
1523 
 
1524 
bool CConfigToolDoc::GenerateHeaders()
1525 
{
1526 
// Copy non-config header files from the repository to the
1527 
// install tree for plugin only. The make system used by
1528 
// the standalone config tool does this for us.
1529 
#ifdef PLUGIN
1530 
  typedef std::vector<CdlBuildInfo_Loadable> EntriesArray;
1531 
  const EntriesArray &arEntries=BuildInfo().entries;
1532 
  typedef std::vector<CdlBuildInfo_Header> HeaderArray;
1533 
  for(EntriesArray::size_type j=0;j<arEntries.size();j++){
1534 
    const CdlBuildInfo_Loadable &e=arEntries[j];
1535 
    const CFileName strDir(CUtils::WPath(e.directory));
1536 
    const HeaderArray &arHeaders=e.headers;
1537 
    for(HeaderArray::size_type i=0;i<arHeaders.size();i++){
1538 
      const CdlBuildInfo_Header &h=arHeaders[i];
1539 
      const CFileName strSource(PackagesDir()+strDir+CUtils::WPath(h.source));
1540 
      const CFileName strDest(HeadersDir()/*+CUtils::WPath(e.directory)*/+CUtils::WPath(h.destination));
1541 
 
1542 
      if(!strDest.Head().CreateDirectory(true)){
1543 
        CUtils::MessageBoxF(_T("Failed to create %s - %s"),strDest.Head(),CUtils::GetLastErrorMessageString());
1544 
        return false;
1545 
      }
1546 
      if(!CUtils::CopyFile(strSource,strDest)){
1547 
        return false; // message already emitted
1548 
      }
1549 
    }
1550 
  }
1551 
#endif
1552 
 
1553 
  // Generate headers
1554 
  try {
1555 
    CFileName strPkfConfDir(InstallTree()+_T("include\\pkgconf"));
1556 
    if(!strPkfConfDir.CreateDirectory()){
1557 
      CUtils::MessageBoxF(_T("Failed to create %s - %s"),strPkfConfDir,CUtils::GetLastErrorMessageString());
1558 
      return false;
1559 
    }
1560 
    GetCdlConfig()->generate_config_headers(CUtils::UnicodeToStdStr(strPkfConfDir.ShortName()));
1561 
  }
1562 
  catch (CdlInputOutputException e) {
1563 
    const CString strMsg(e.get_message().c_str());
1564 
    TRACE(_T("!!! Exception thrown calling generate_config_headers - %s"),strMsg);
1565 
    CUtils::MessageBoxF(_T("Failed to generate header files - %s"),strMsg);
1566 
    return false;
1567 
  }
1568 
  return true;
1569 
}
1570 
 
1571 
const CFileName CConfigToolDoc::MLTDir ()
1572 
{
1573 
        CString strPathName (GetPathName ());
1574 
        ASSERT (! strPathName.IsEmpty ());
1575 
        return strPathName.Left (strPathName.ReverseFind (_TCHAR('.'))) + _T("_mlt");
1576 
}
1577 
 
1578 
bool CConfigToolDoc::UpdateBuildInfo(bool bFirstTime)
1579 
{
1580 
  try {
1581 
    GetCdlConfig()->get_build_info(m_BuildInfo);
1582 
    #ifdef PLUGIN
1583 
    // FIXME: this means anything not mentioned by AddFile in our scan below will be removed - including user-added items
1584 
    m_peCosProject->ClearItemFlags();
1585 
    m_peCosProject->UpdateeCosProject(bFirstTime);
1586 
    m_peCosProject->RemoveAllUnflaggedItems();
1587 
    #else
1588 
    UNUSED_ALWAYS(bFirstTime);
1589 
    generate_build_tree (GetCdlConfig(), CUtils::UnicodeToStdStr(BuildTree()), CUtils::UnicodeToStdStr(InstallTree()));
1590 
    #endif
1591 
    return true;
1592 
  }
1593 
  catch(...){
1594 
    return false;
1595 
  }
1596 
}
1597 
 
1598 
void CConfigToolDoc::RemoveAllItems()
1599 
{
1600 
  for(int nItem=0;nItem<ItemCount();nItem++){
1601 
    CConfigItem *pItem=Item(nItem);
1602 
    deleteZ(pItem);
1603 
  }
1604 
  m_arItem.RemoveAll();
1605 
 
1606 
  UpdateAllViews(NULL,Clear,0);
1607 
}
1608 
 
1609 
void CConfigToolDoc::EnableCallbacks (bool bEnable/*=true*/)
1610 
{
1611 
  CdlTransactionCallback::set_callback_fn(bEnable?&CdlTransactionHandler:0);
1612 
  CdlTransactionBody::set_inference_callback_fn(bEnable?&CdlInferenceHandler:0);
1613 
  CdlTransactionBody::set_inference_override(CdlValueSource_Invalid);
1614 
}
1615 
 
1616 
int CConfigToolDoc::GetTestExeNames (CFileNameArray &arTestExes,CFileNameArray &arMissing)
1617 
{
1618 
  arTestExes.RemoveAll();
1619 
  arMissing.RemoveAll();
1620 
 
1621 
  typedef std::vector<CdlBuildInfo_Loadable> EntriesArray;
1622 
  const EntriesArray &arEntries=BuildInfo().entries;
1623 
  for(EntriesArray::size_type j=0;j<arEntries.size();j++){
1624 
    const CdlBuildInfo_Loadable &e=arEntries[j];
1625 
    CStringArray ar;
1626 
    int n=CUtils::Chop(CString(get_tests(GetCdlConfig(),e).c_str()),ar);
1627 
    for(int i=0;i<n;i++){
1628 
      CFileName strFile;
1629 
      strFile.Format(_T("%s\\tests\\%s\\%s.exe"),InstallTree(),CString(e.directory.c_str()),ar[i]);
1630 
      strFile.Replace(_TCHAR('/'),_TCHAR('\\'));
1631 
      if(strFile.Exists()){
1632 
        arTestExes.Add(strFile);
1633 
      } else {
1634 
        arMissing.Add(strFile);
1635 
      }
1636 
    }
1637 
  }
1638 
  return arTestExes.GetSize();
1639 
}
1640 
 
1641 
CConfigToolDoc::GlobalConflictOutcome CConfigToolDoc::ResolveGlobalConflicts(CPtrArray *parConflictsOfInterest)
1642 
{
1643 
  m_ConflictsOutcome=NotDone;
1644 
  m_arConflictsOfInterest.RemoveAll();
1645 
  if(parConflictsOfInterest){
1646 
    m_arConflictsOfInterest.Copy(*parConflictsOfInterest);
1647 
  }
1648 
  CdlInferenceCallback fn=CdlTransactionBody::get_inference_callback_fn();
1649 
  CdlTransactionBody::set_inference_callback_fn(CdlGlobalInferenceHandler);
1650 
  GetCdlInterpreter()->get_toplevel()->resolve_all_conflicts();
1651 
  CdlTransactionBody::set_inference_callback_fn(fn);
1652 
  if(NotDone==m_ConflictsOutcome){
1653 
    // No solutions were available, but we'll run the dialog anyway
1654 
    const std::list<CdlConflict>& conflicts=GetCdlConfig()->get_all_conflicts();
1655 
    CFailingRulesDialog dlg(conflicts,NULL,&m_arConflictsOfInterest);
1656 
    m_ConflictsOutcome=(IDOK==dlg.DoModal())?OK:Cancel;
1657 
  }
1658 
  return m_ConflictsOutcome;
1659 
}
1660 
 
1661 
bool CConfigToolDoc::CheckConflictsBeforeSave()
1662 
{
1663 
  if(GetCdlInterpreter()->get_toplevel()->get_all_conflicts().size()>0){
1664 
    if(Deferred&m_nRuleChecking){
1665 
      if((SuggestFixes&m_nRuleChecking)&&(Cancel==ResolveGlobalConflicts())){
1666 
        return false;
1667 
      }
1668 
      int nConflicts=GetCdlInterpreter()->get_toplevel()->get_all_conflicts().size();
1669 
      switch(nConflicts){
1670 
      case 0:
1671 
        break;
1672 
      case 1:
1673 
        if(IDNO==CUtils::MessageBoxFT(MB_YESNO|MB_DEFBUTTON2,_T("There is 1 unresolved conflict.  Save anyway?"))){
1674 
          return false;
1675 
        }
1676 
      default:
1677 
        if(IDNO==CUtils::MessageBoxFT(MB_YESNO|MB_DEFBUTTON2,_T("There are %d unresolved conflicts.  Save anyway?"),nConflicts)){
1678 
          return false;
1679 
        }
1680 
      }
1681 
    }
1682 
  }
1683 
  return true;
1684 
}
1685 
 
1686 
BOOL CConfigToolDoc::IsModified()
1687 
{
1688 
  return m_bModified || MemoryMap.map_modified();
1689 
}
1690 
 
1691 
void CConfigToolDoc::OnFileExport()
1692 
{
1693 
  CFileDialog dlg (FALSE, _T("ecm"), NULL, OFN_OVERWRITEPROMPT | OFN_PATHMUSTEXIST | OFN_HIDEREADONLY, _T("eCos Minimal Configuration (*.ecm)|*.ecm||"), AfxGetMainWnd ());
1694 
  TCHAR szBuffer [MAX_PATH * 16] = _T("");
1695 
  dlg.m_ofn.lpstrFile = szBuffer;
1696 
  dlg.m_ofn.nMaxFile = MAX_PATH * 16;
1697 
  dlg.m_ofn.lpstrTitle = _T("Export eCos Minimal Configuration");
1698 
  if (IDOK == dlg.DoModal ()) {
1699 
    try {
1700 
      TRACE (_T("Exporting eCos minimal configuration '%s'\n"), dlg.GetPathName ());
1701 
      m_CdlConfig->save (CUtils::UnicodeToStdStr (dlg.GetPathName ()), /* minimal = */ true);
1702 
    }
1703 
    catch (CdlStringException exception) {
1704 
      CUtils::MessageBoxF (_T("Error exporting eCos minimal configuration:\n\n%s"), CString (exception.get_message ().c_str ()));
1705 
    }
1706 
    catch (...) {
1707 
      CUtils::MessageBoxF (_T("Error exporting eCos minimal configuration."));
1708 
    }
1709 
  }
1710 
}
1711 
 
1712 
void CConfigToolDoc::OnFileImport()
1713 
{
1714 
  CFileDialog dlg (TRUE, _T("ecm"), NULL, OFN_PATHMUSTEXIST | OFN_HIDEREADONLY, _T("eCos Minimal Configurations (*.ecm)|*.ecm||"), AfxGetMainWnd ());
1715 
  TCHAR szBuffer [MAX_PATH * 16] = _T("");
1716 
  dlg.m_ofn.lpstrFile = szBuffer;
1717 
  dlg.m_ofn.nMaxFile = MAX_PATH * 16;
1718 
  dlg.m_ofn.lpstrTitle = _T("Import eCos Minimal Configuration");
1719 
  if (IDOK == dlg.DoModal ()) {
1720 
    try {
1721 
      TRACE (_T("Importing eCos minimal configuration '%s'\n"), dlg.GetPathName ());
1722 
      m_CdlConfig->add (CUtils::UnicodeToStdStr (dlg.GetPathName ()), CConfigToolDoc::CdlParseErrorHandler, CConfigToolDoc::CdlParseWarningHandler);
1723 
    }
1724 
    catch (CdlStringException exception) {
1725 
      CUtils::MessageBoxF (_T("Error importing eCos minimal configuration:\n\n%s"), CString (exception.get_message ().c_str ()));
1726 
    }
1727 
    catch (...) {
1728 
      CUtils::MessageBoxF (_T("Error importing eCos minimal configuration."));
1729 
    }
1730 
 
1731 
    CWaitCursor wait;
1732 
    AddAllItems (); // regenerate all the config items since the topology may have changed
1733 
    if (m_strLinkerScriptFolder.IsEmpty ()) {
1734 
      CUtils::MessageBoxF (_T("The eCos linker script macro CYGBLD_LINKER_SCRIPT is not defined."));
1735 
    }
1736 
    if (m_strMemoryLayoutFolder.IsEmpty ()) {
1737 
      CUtils::MessageBoxF (_T("The eCos memory layout macro CYGHWR_MEMORY_LAYOUT is not defined."));
1738 
    }
1739 
    SwitchMemoryLayout (true); // the hardware template may have changed
1740 
    UpdateBuildInfo ();
1741 
    CConfigTool::GetControlView()->SelectItem (Item (0));
1742 
    SetModifiedFlag ();
1743 
  }
1744 
}
1745 
 
1746 
bool CConfigToolDoc::QualifyDocURL(CString &strURL)
1747 
{
1748 
  if(-1==strURL.Find(_T("://"))){
1749 
    strURL.Replace(_TCHAR('/'),_TCHAR('\\'));
1750 
    if (! CFileName (strURL).IsFile ()) { // if not an absolute filepath
1751 
      strURL = DocBase () + CFileName (strURL); // prepend the doc directory path
1752 
    }
1753 
    strURL=_T("file://")+strURL;
1754 
  }
1755 
 
1756 
  if(0==strURL.Find(_T("file://"))){
1757 
    CFileName strFile(strURL.Right(strURL.GetLength()-7));
1758 
    int nIndex=strFile.ReverseFind(_TCHAR('#'));
1759 
    if(-1!=nIndex){
1760 
      strFile=strFile.Left(nIndex);
1761 
    }
1762 
    strFile.Replace(_TCHAR('/'),_TCHAR('\\'));
1763 
    if(!strFile.Exists()){
1764 
      CUtils::MessageBoxF(_T("Cannot locate the file %s"),strFile);
1765 
      return false;
1766 
    }
1767 
  }
1768 
  return true;
1769 
}
1770 
 
1771 
bool CConfigToolDoc::NewMemoryLayout (const CString &strPrefix)
1772 
{
1773 
  CFileName strFileName = CurrentLinkerScript ();
1774 
  TRACE(_T("Reading linker-defined memory sections from %s\n"), strFileName);
1775 
  MemoryMap.new_memory_layout (); // delete the old memory layout regardless
1776 
  if (! strFileName.IsEmpty ())
1777 
    MemoryMap.import_linker_defined_sections (strFileName); // read the linker-defined section names from the repository (failure is silent)
1778 
 
1779 
  CString strMemoryLayoutFileName = strPrefix + _T("\\mlt_") + CurrentMemoryLayout () + _T(".mlt");
1780 
  TRACE(_T("Reading memory layout from %s\n"), strMemoryLayoutFileName);
1781 
  MemoryMap.load_memory_layout (strMemoryLayoutFileName); // load the new memory layout (failure is silent)
1782 
  strSelectedSection = _T("");
1783 
  strSelectedRegion = _T("");
1784 
  UpdateAllViews (NULL, MemLayoutChanged);
1785 
  return true; // FIXME
1786 
}
1787 
 
1788 
void CConfigToolDoc::SetPathName( LPCTSTR pszPath, BOOL bAddToMRU /*= TRUE*/ )
1789 
{
1790 
  if(_TCHAR('\0')==*pszPath){ // called like this after failed saves to put things back as they were
1791 
          // CDocument::SetPathName would assert given an empty string
1792 
          m_strPathName = _T("");
1793 
#ifndef PLUGIN
1794 
    SetTitle(_T("Untitled"));
1795 
#endif
1796 
    m_strBuildTree   = _T("");
1797 
    m_strInstallTree = _T("");
1798 
  } else {
1799 
#ifdef PLUGIN
1800 
    m_strPathName = CFileName (pszPath);
1801 
#else
1802 
    CDocument::SetPathName (pszPath, bAddToMRU);
1803 
#endif
1804 
    CString strFolder (pszPath);
1805 
    strFolder = strFolder.Left (strFolder.ReverseFind (_TCHAR('.'))); // extract folder from file path
1806 
    m_strBuildTree   = CFileName(strFolder + _T("_build"));
1807 
    m_strInstallTree = CFileName(strFolder + _T("_install"));
1808 
  }
1809 
}
1810 
 
1811 
bool CConfigToolDoc::ShowHtmlHelp (LPCTSTR pszURL)
1812 
{
1813 
 
1814 
  HWND hwndCaller=AfxGetMainWnd()->CWnd::GetDesktopWindow()->GetSafeHwnd();
1815 
  bool rc=false;
1816 
  const CFileName strFile(HTMLHelpLinkFileName());
1817 
  CStdioFile f;
1818 
  if(!CFileName(CConfigTool::strHelpFile).Exists()) {
1819 
    CUtils::MessageBoxF(_T("Cannot display help - %s does not exist\n"),CConfigTool::strHelpFile);
1820 
  } else if(!f.Open(strFile,CFile::typeText|CFile::modeCreate|CFile::modeWrite)){
1821 
    CUtils::MessageBoxF(_T("Cannot display help - error creating %s\n"),strFile);
1822 
  } else {
1823 
    CString str;
1824 
    str.Format(_T("<meta HTTP-EQUIV=\"refresh\" CONTENT=\"0;URL=%s\">"),pszURL);
1825 
    f.WriteString(str);
1826 
    f.Close();
1827 
    if(0==HtmlHelp(hwndCaller, CConfigTool::strHelpFile, HH_DISPLAY_TOPIC, 0)){
1828 
      CUtils::MessageBoxF(_T("Cannot display %s"),pszURL);
1829 
    } else {
1830 
      // FIXME: Do this the first time only?
1831 
      HH_WINTYPE WinType;
1832 
      HWND wnd;
1833 
      HH_WINTYPE *pWinType=NULL;
1834 
      wnd = HtmlHelp(hwndCaller, CConfigTool::strHelpFile+_T(">mainwin"), HH_GET_WIN_TYPE, (DWORD) &pWinType);
1835 
      WinType=*pWinType;
1836 
      WinType.hwndCaller=hwndCaller;
1837 
      WinType.fsWinProperties|=HHWIN_PROP_TRACKING;
1838 
      WinType.idNotify = ID_HHNOTIFICATION;
1839 
      wnd = HtmlHelp(hwndCaller, CConfigTool::strHelpFile, HH_SET_WIN_TYPE, (DWORD) &WinType);
1840 
      rc=true;
1841 
    }
1842 
    //::DeleteFile(strFile);
1843 
  }
1844 
  return rc;
1845 
}
1846 
 
1847 
const CString CConfigToolDoc::HTMLHelpLinkFileName()
1848 
{
1849 
  return CFileName(CConfigTool::strHelpFile).Head()+"link2.htm";
1850 
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.