0027055: Configuration, genconf.tcl - reduce window height to fit into smaller screens
[occt.git] / adm / genproj.tcl
CommitLineData
910970ab 1# =======================================================================
d1a67b9d 2# Created on: 2014-07-24
3# Created by: SKI
4# Copyright (c) 2014 OPEN CASCADE SAS
5#
6# This file is part of Open CASCADE Technology software library.
7#
8# This library is free software; you can redistribute it and/or modify it under
9# the terms of the GNU Lesser General Public License version 2.1 as published
10# by the Free Software Foundation, with special exception defined in the file
11# OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12# distribution for complete text of the license and disclaimer of any warranty.
13#
14# Alternatively, this file may be used under the terms of Open CASCADE
15# commercial license or contractual agreement.
16
17# =======================================================================
18# This script defines Tcl command genproj generating project files for
19# different IDEs:
cb6a2fbc 20# "vc7" "vc8" "vc9" "vc10" "vc11" "vc12" "vc14" "cbp" "xcd"
910970ab 21#
22# Example:
23# genproj -path=D:/occt -target=vc10
c7d774c5 24# genproj -target=xcd -ios -static
910970ab 25# =======================================================================
26
d1a67b9d 27source [file join [file dirname [info script]] genconfdeps.tcl]
28
910970ab 29set path ""
30set fBranch ""
31switch -exact -- "$tcl_platform(platform)" {
c7d774c5 32 "windows" {set targetStation "wnt"}
33 "unix" {set targetStation "lin"}
910970ab 34}
35
c7d774c5 36switch -exact -- "$tcl_platform(os)" {
37 "Darwin" {set targetStation "mac"}
38}
39
910970ab 40proc _get_options { platform type branch } {
41 global path
42 set res ""
43 if {[file exists "$path/adm/CMPLRS"]} {
44 set fd [open "$path/adm/CMPLRS" rb]
45 set opts [split [read $fd] "\n"]
46 close $fd
47 foreach line $opts {
48 if {[regexp "^${platform} ${type} ${branch} (.+)$" $line dummy res]} {
49 while {[regexp {\(([^\(\)]+) ([^\(\)]+) ([^\(\)]+)\)(.+)} $res dummy p t b oldres]} {
50 set res "[_get_options $p $t $b] $oldres"
51 }
52 }
53 }
54 }
55 return $res
56}
57
58proc _get_type { name } {
59 global path
60 if {[file exists "$path/adm/UDLIST"]} {
61 set fd [open "$path/adm/UDLIST" rb]
62 set UDLIST [split [read $fd] "\n"]
63 close $fd
64 foreach uitem $UDLIST {
65 set line [split $uitem]
66 if {[lindex $line 1] == "$name"} {
67 return [lindex $line 0]
68 }
69 }
70 }
71 return ""
72}
73
74proc _get_used_files { pk {inc true} {src true} } {
75 global path
76 set type [_get_type $pk]
77 set lret {}
78 set pk_path "$path/src/$pk"
79 set FILES_path "$path/src/$pk/FILES"
80 set FILES {}
81 if {[file exists $FILES_path]} {
82 set fd [open $FILES_path rb]
83 set FILES [split [read $fd] "\n"]
84 close $fd
85 }
86 set FILES [lsearch -inline -all -not -exact $FILES ""]
87
88 set index -1
89 foreach line $FILES {
90 incr index
91 if {$inc && ([regexp {([^:\s]*\.[hgl]xx)$} $line dummy name] || [regexp {([^:\s]*\.h)$} $line dummy name]) && [file exists $pk_path/$name]} {
92 lappend lret "pubinclude $name $pk_path/$name"
93 continue
94 }
95 if {[regexp {:} $line]} {
96 regexp {[^:]*:+([^\s]*)} $line dummy line
97 }
98 regexp {([^\s]*)} $line dummy line
99 if {$src && [file exists $pk_path/$line]} {
100 lappend lret "source $line $pk_path/$line"
101 }
102 }
103 return $lret
104}
105
106# Wrapper-function to generate VS project files
107proc genproj { args } {
108 global path targetStation
cb6a2fbc 109 set aSupportedTargets { "vc7" "vc8" "vc9" "vc10" "vc11" "vc12" "vc14" "cbp" "xcd" }
910970ab 110 set anArgs $args
111
112 # Setting default IDE.
113 set anTarget ""
114 switch -exact -- "$targetStation" {
115 "wnt" {set anTarget "$::env(VCVER)"}
cb6a2fbc 116 "lin" {set anTarget "cbp"}
c7d774c5 117 "mac" {set anTarget "xcd"}
910970ab 118 }
119
120 set isTargetDefault true
910970ab 121 if { [set anIndex [lsearch -nocase $anArgs -target=*]] != -1 } {
122 regsub -nocase "\\-target=" [lindex $anArgs $anIndex] "" anTarget
123 set anArgs [removeAllOccurrencesOf -target=* $anArgs]
124 set isTargetDefault false
125 }
126
127 if { [set anIndex [lsearch -nocase $anArgs -path=*]] != -1} {
128 regsub -nocase "\\-path=" [lindex $anArgs $anIndex] "" path
129 set anArgs [removeAllOccurrencesOf -path=* $anArgs]
130 puts "Starting work with \"$path\""
131 }
132
133 if { [llength $anArgs] == 0 && $isTargetDefault == true } {
134 puts "the default \'$anTarget\' target has been applied"
135 }
136
137 set isHelpRequire false
138 if { [lsearch -nocase $anArgs -h] != -1} {
139 set anArgs [removeAllOccurrencesOf -h $anArgs]
140 set isHelpRequire true
141 }
142
143 if {$path == ""} {
144 set isHelpRequire true
145 }
146
c7d774c5 147 set aLibType "dynamic"
148 if { [lsearch -nocase $anArgs "-static"] != -1} {
149 set anArgs [removeAllOccurrencesOf "-static" $anArgs]
150 set aLibType "static"
151 puts "static build has been selected"
152 } elseif { [lsearch -nocase $anArgs "-dynamic"] != -1} {
153 set anArgs [removeAllOccurrencesOf "-dynamic" $anArgs]
154 set aLibType "dynamic"
155 puts "dynamic build has been selected"
156 }
157
158 set aPlatform ""
159 if { [lsearch -nocase $anArgs "-ios"] != -1} {
160 set anArgs [removeAllOccurrencesOf "-ios" $anArgs]
161 set aPlatform "ios"
162 }
163
910970ab 164 if { [lsearch -nocase $aSupportedTargets $anTarget] == -1} {
165 puts "the \'$anTarget\' is wrong TARGET"
166 set isHelpRequire true
167 }
168
169 if {[llength $anArgs] > 0} {
170 set isHelpRequire true
171
172 foreach anArg $anArgs {
173 puts "genproj: unrecognized option \'$anArg\'"
174 }
175 }
176
177 if { $isHelpRequire == true } {
178 puts "usage: genproj \[ -target=<TARGET> \] \[ -path=<PATH> \]
179
180 PATH:
181 path to the project
182
183 TARGET:
184 vc8 - Visual Studio 2005
185 vc9 - Visual Studio 2008
186 vc10 - Visual Studio 2010
187 vc11 - Visual Studio 2012
188 vc12 - Visual Studio 2013
39bff09c 189 vc14 - Visual Studio 2015
910970ab 190 cbp - CodeBlocks
cb6a2fbc 191 xcd - XCode"
910970ab 192 return
193 }
194
195 if {!$isTargetDefault} {
196 puts "the \'$anTarget\' target has been applied"
197 }
cb6a2fbc 198
910970ab 199 set anAdmPath "$path/adm"
200
c7d774c5 201 OS:MKPRC "$anAdmPath" "$anTarget" "$aLibType" "$aPlatform"
910970ab 202
203 genprojbat "$anAdmPath" "$anTarget"
204}
205
206proc genprojbat {thePath theIDE} {
207 global path
208
209 set anOsIncPath "$path/src/OS"
210 set anOsRootPath "$path"
211
212 set aTargetPlatform "lin"
213 if { "$::tcl_platform(platform)" == "windows" } {
214 set aTargetPlatform "wnt"
215 }
216
217 if {[regexp {(vc)[0-9]*$} $theIDE] == 1} {
218 set aTargetPlatform wnt
c7d774c5 219 } elseif {"$theIDE" == "xcd"} {
220 set aTargetPlatform mac
910970ab 221 }
222
223 set aTargetPlatformExt sh
224 if { "$aTargetPlatform" == "wnt" } {
225 set aTargetPlatformExt bat
226 }
227
228 set aBox [file normalize "$thePath/.."]
229
910970ab 230 if {"$theIDE" != "cmake"} {
231 set anEnvTmplFile [open "$path/adm/templates/env.${aTargetPlatformExt}" "r"]
232 set anEnvTmpl [read $anEnvTmplFile]
233 close $anEnvTmplFile
234
235 set aCasRoot ""
236 if { [file normalize "$anOsRootPath"] != "$aBox" } {
237 set aCasRoot [relativePath "$aBox" "$anOsRootPath"]
238 }
239 set anOsIncPath [relativePath "$aBox" "$anOsRootPath"]
240
241 regsub -all -- {__CASROOT__} $anEnvTmpl "$aCasRoot" anEnvTmpl
242
243 set anEnvFile [open "$aBox/env.${aTargetPlatformExt}" "w"]
244 puts $anEnvFile $anEnvTmpl
245 close $anEnvFile
246
247 file copy -force -- "$path/adm/templates/draw.${aTargetPlatformExt}" "$aBox/draw.${aTargetPlatformExt}"
248 }
249
250 if {[regexp {(vc)[0-9]*$} $theIDE] == 1} {
251 file copy -force -- "$path/adm/templates/msvc.bat" "$aBox/msvc.bat"
252 } else {
253 switch -exact -- "$theIDE" {
254 "cbp" { file copy -force -- "$path/adm/templates/codeblocks.sh" "$aBox/codeblocks.sh" }
c7d774c5 255 "xcd" { file copy -force -- "$path/adm/templates/xcode.sh" "$aBox/xcode.sh" }
910970ab 256 }
257 }
258}
259
260###### MSVC #############################################################33
261proc removeAllOccurrencesOf { theObject theList } {
262 set aSortIndices [lsort -decreasing [lsearch -all -nocase $theList $theObject]]
263 foreach anIndex $aSortIndices {
264 set theList [lreplace $theList $anIndex $anIndex]
265 }
266 return $theList
267}
268
c7d774c5 269set aTKNullKey "TKNull"
270set THE_GUIDS_LIST($aTKNullKey) "{00000000-0000-0000-0000-000000000000}"
910970ab 271
272# Entry function to generate project files and solutions for IDE
c7d774c5 273proc OS:MKPRC { {theOutDir {}} {theIDE ""} {theLibType "dynamic"} {thePlatform ""} } {
910970ab 274 global path targetStation
cb6a2fbc 275 set aSupportedIDE { "vc7" "vc8" "vc9" "vc10" "vc11" "vc12" "vc14" "cbp" "xcd" }
910970ab 276
277 if { [lsearch $aSupportedIDE $theIDE] < 0 } {
278 puts stderr "WOK does not support generation of project files for the selected IDE: $theIDE\nSupported IDEs: [join ${aSupportedIDE} " "]"
279 return
280 }
281
282 set anOutRoot $theOutDir
283 if { $anOutRoot == "" } {
284 error "Error : \"theOutDir\" is not initialized"
285 }
286
287 # Create output directory
288 set aWokStation "$targetStation"
289
39bff09c 290 if { [lsearch -exact {vc7 vc8 vc9 vc10 vc11 vc12 vc14} $theIDE] != -1 } {
910970ab 291 set aWokStation "msvc"
292 }
293
294 set anOutDir "${anOutRoot}/${aWokStation}/${theIDE}"
295
296 # read map of already generated GUIDs
297 set aGuidsFilePath [file join $anOutDir "wok_${theIDE}_guids.txt"]
298 if [file exists "$aGuidsFilePath"] {
299 set aFileIn [open "$aGuidsFilePath" r]
300 set aFileDataRaw [read $aFileIn]
301 close $aFileIn
302 set aFileData [split $aFileDataRaw "\n"]
303 foreach aLine $aFileData {
304 set aLineSplt [split $aLine "="]
305 if { [llength $aLineSplt] == 2 } {
306 set ::THE_GUIDS_LIST([lindex $aLineSplt 0]) [lindex $aLineSplt 1]
307 }
308 }
309 }
310
311 # make list of modules and platforms
312 set aModules [OS:init]
c7d774c5 313 if { "$thePlatform" == "ios" } {
314 set goaway [list Draw]
315 set aModules [osutils:juststation $goaway $aModules]
316 }
910970ab 317
318 # generate one solution for all projects if complete OS or VAS is processed
319 set anAllSolution "OCCT"
320
c7d774c5 321 wokUtils:FILES:mkdir $anOutDir
910970ab 322 if { ![file exists $anOutDir] } {
323 puts stderr "Error: Could not create output directory \"$anOutDir\""
324 return
325 }
326
327 # create the out dir if it does not exist
328 if (![file isdirectory $path/inc]) {
329 puts "$path/inc folder does not exists and will be created"
330 wokUtils:FILES:mkdir $path/inc
331 }
332
333 # collect all required header files
334 puts "Collecting required header files into $path/inc ..."
335 osutils:collectinc $aModules $path/inc $targetStation
336
337 # Generating project files for the selected IDE
338 switch -exact -- "$theIDE" {
339 "vc7" -
340 "vc8" -
341 "vc9" -
342 "vc10" -
343 "vc11" -
39bff09c 344 "vc12" -
345 "vc14" { OS:MKVC $anOutDir $aModules $anAllSolution $theIDE }
910970ab 346 "cbp" { OS:MKCBP $anOutDir $aModules $anAllSolution }
c7d774c5 347 "xcd" {
348 set ::THE_GUIDS_LIST($::aTKNullKey) "000000000000000000000000"
349 OS:MKXCD $anOutDir $aModules $anAllSolution $theLibType $thePlatform
350 }
910970ab 351 }
910970ab 352
353 # Store generated GUIDs map
354 set anOutFile [open "$aGuidsFilePath" "w"]
355 fconfigure $anOutFile -translation lf
356 foreach aKey [array names ::THE_GUIDS_LIST] {
357 set aValue $::THE_GUIDS_LIST($aKey)
358 puts $anOutFile "${aKey}=${aValue}"
359 }
360 close $anOutFile
361}
362
363# Function to generate Visual Studio solution and project files
364proc OS:MKVC { theOutDir {theModules {}} {theAllSolution ""} {theVcVer "vc8"} } {
365
366 puts stderr "Generating VS project files for $theVcVer"
367
368 # generate projects for toolkits and separate solution for each module
369 foreach aModule $theModules {
370 OS:vcsolution $theVcVer $aModule $aModule $theOutDir ::THE_GUIDS_LIST
371 OS:vcproj $theVcVer $aModule $theOutDir ::THE_GUIDS_LIST
372 }
373
374 # generate single solution "OCCT" containing projects from all modules
375 if { "$theAllSolution" != "" } {
376 OS:vcsolution $theVcVer $theAllSolution $theModules $theOutDir ::THE_GUIDS_LIST
377 }
378
379 puts "The Visual Studio solution and project files are stored in the $theOutDir directory"
380}
381
382proc OS:init {{os {}}} {
383 global path
384 global env
385 global tcl_platform
386
387 set askplat $os
388 if { "$os" == "" } {
389 set os $tcl_platform(os)
390 }
391
392 ;# Load list of OCCT modules and their definitions
393 source "$path/src/OS/Modules.tcl"
394 set Modules {}
395 foreach module [OS:Modules] {
396 set f "$path/src/OS/${module}.tcl"
397 if [file exists $f] {
398 source $f
399 lappend Modules $module
400 } else {
401 puts stderr "Definition file for module $module is not found in unit OS"
402 }
403 }
404
405 # Load list of products and their definitions
406# set Products [woklocate -p VAS:source:Products.tcl]
407 #if { "$Products" != "" } {
408 #source "$Products"
409 #foreach product [VAS:Products] {
410 #set f [woklocate -p VAS:source:${product}.tcl]
411 #if [file exists $f] {
412 #source $f
413 #} else {
414 #puts stderr "Definition file for product $product is not found in unit VAS"
415 #}
416 #}
417 #}
418
419 return $Modules
420}
421
422# topological sort. returns a list { {a h} {b g} {c f} {c h} {d i} } => { d a b c i g f h }
423proc wokUtils:EASY:tsort { listofpairs } {
424 foreach x $listofpairs {
425 set e1 [lindex $x 0]
426 set e2 [lindex $x 1]
427 if ![info exists pcnt($e1)] {
428 set pcnt($e1) 0
429 }
430 if ![ info exists pcnt($e2)] {
431 set pcnt($e2) 1
432 } else {
433 incr pcnt($e2)
434 }
435 if ![info exists scnt($e1)] {
436 set scnt($e1) 1
437 } else {
438 incr scnt($e1)
439 }
440 set l {}
441 if [info exists slist($e1)] {
442 set l $slist($e1)
443 }
444 lappend l $e2
445 set slist($e1) $l
446 }
447 set nodecnt 0
448 set back 0
449 foreach node [array names pcnt] {
450 incr nodecnt
451 if { $pcnt($node) == 0 } {
452 incr back
453 set q($back) $node
454 }
455 if ![info exists scnt($node)] {
456 set scnt($node) 0
457 }
458 }
459 set res {}
460 for {set front 1} { $front <= $back } { incr front } {
461 lappend res [set node $q($front)]
462 for {set i 1} {$i <= $scnt($node) } { incr i } {
463 set ll $slist($node)
464 set j [expr {$i - 1}]
465 set u [expr { $pcnt([lindex $ll $j]) - 1 }]
466 if { [set pcnt([lindex $ll $j]) $u] == 0 } {
467 incr back
468 set q($back) [lindex $ll $j]
469 }
470 }
471 }
472 if { $back != $nodecnt } {
473 puts stderr "input contains a cycle"
474 return {}
475 } else {
476 return $res
477 }
478}
479
480proc wokUtils:LIST:Purge { l } {
481 set r {}
482 foreach e $l {
483 if ![info exist tab($e)] {
484 lappend r $e
485 set tab($e) {}
486 }
487 }
488 return $r
489}
490
491# Read file pointed to by path
492# 1. sort = 1 tri
493# 2. trim = 1 plusieurs blancs => 1 seul blanc
494# 3. purge= not yet implemented.
495# 4. emptl= dont process blank lines
496proc wokUtils:FILES:FileToList { path {sort 0} {trim 0} {purge 0} {emptl 1} } {
497 if ![ catch { set id [ open $path r ] } ] {
498 set l {}
499 while {[gets $id line] >= 0 } {
500 if { $trim } {
501 regsub -all {[ ]+} $line " " line
502 }
503 if { $emptl } {
504 if { [string length ${line}] != 0 } {
505 lappend l $line
506 }
507 } else {
508 lappend l $line
509 }
510 }
511 close $id
512 if { $sort } {
513 return [lsort $l]
514 } else {
515 return $l
516 }
517 } else {
518 return {}
519 }
520}
521
522# retorn the list of executables in module.
523proc OS:executable { module } {
524 set lret {}
525 foreach XXX [${module}:ressources] {
526 if { "[lindex $XXX 1]" == "x" } {
527 lappend lret [lindex $XXX 2]
528 }
529 }
530 return $lret
531}
532
533# Topological sort of toolkits in tklm
534proc osutils:tk:sort { tklm } {
535 set tkby2 {}
536 foreach tkloc $tklm {
537 set lprg [wokUtils:LIST:Purge [osutils:tk:close $tkloc]]
538 foreach tkx $lprg {
539 if { [lsearch $tklm $tkx] != -1 } {
540 lappend tkby2 [list $tkx $tkloc]
541 } else {
542 lappend tkby2 [list $tkloc {}]
543 }
544 }
545 }
546 set lret {}
547 foreach e [wokUtils:EASY:tsort $tkby2] {
548 if { $e != {} } {
549 lappend lret $e
550 }
551 }
552 return $lret
553}
554
555# close dependencies of ltk. (full wok pathes of toolkits)
556# The CURRENT WOK LOCATION MUST contains ALL TOOLKITS required.
557# (locate not performed.)
558proc osutils:tk:close { ltk } {
559 set result {}
560 set recurse {}
561 foreach dir $ltk {
562 set ids [LibToLink $dir]
563 set eated [osutils:tk:eatpk $ids]
564 set result [concat $result $eated]
565 set ids [LibToLink $dir]
566 set result [concat $result $ids]
567
568 foreach file $eated {
569 set kds "$path/src/$file/EXTERNLIB"
570 if { [osutils:tk:eatpk $kds] != {} } {
571 lappend recurse $file
572 }
573 }
574 }
575 if { $recurse != {} } {
576 set result [concat $result [osutils:tk:close $recurse]]
577 }
578 return $result
579}
580
581proc osutils:tk:eatpk { EXTERNLIB } {
582 set l [wokUtils:FILES:FileToList $EXTERNLIB]
583 set lret {}
584 foreach str $l {
585 if ![regexp -- {(CSF_[^ ]*)} $str csf] {
586 lappend lret $str
587 }
588 }
589 return $lret
590}
591# Define libraries to link using only EXTERNLIB file
592
593proc LibToLink {theTKit} {
594 global path
595 regexp {^.*:([^:]+)$} $theTKit dummy theTKit
596 set type [_get_type $theTKit]
597 if {$type != "t" && $type != "x"} {
598 return
599 }
600 set aToolkits {}
601 set anExtLibList [osutils:tk:eatpk "$path/src/$theTKit/EXTERNLIB"]
602 foreach anExtLib $anExtLibList {
603 set aFullPath [LocateRecur $anExtLib]
604 if { "$aFullPath" != "" && [_get_type $anExtLib] == "t" } {
605 lappend aToolkits $anExtLib
606 }
607 }
608 return $aToolkits
609}
610# Search unit recursively
611
612proc LocateRecur {theName} {
613 global path
614 set theNamePath "$path/src/$theName"
615 if {[file isdirectory $theNamePath]} {
616 return $theNamePath
617 }
618 return ""
619}
620
621proc OS:genGUID { {theIDE "vc"} } {
622 if { "$theIDE" == "vc" } {
623 set p1 "[format %07X [expr { int(rand() * 268435456) }]][format %X [expr { int(rand() * 16) }]]"
624 set p2 "[format %04X [expr { int(rand() * 6536) }]]"
625 set p3 "[format %04X [expr { int(rand() * 6536) }]]"
626 set p4 "[format %04X [expr { int(rand() * 6536) }]]"
627 set p5 "[format %06X [expr { int(rand() * 16777216) }]][format %06X [expr { int(rand() * 16777216) }]]"
628 return "{$p1-$p2-$p3-$p4-$p5}"
629 } else {
630 set p1 "[format %04X [expr { int(rand() * 6536) }]]"
631 set p2 "[format %04X [expr { int(rand() * 6536) }]]"
632 set p3 "[format %04X [expr { int(rand() * 6536) }]]"
633 set p4 "[format %04X [expr { int(rand() * 6536) }]]"
634 set p5 "[format %04X [expr { int(rand() * 6536) }]]"
635 set p6 "[format %04X [expr { int(rand() * 6536) }]]"
636 return "$p1$p2$p3$p4$p5$p6"
637 }
638}
639
640# collect all include file that required for theModules in theOutDir
641proc osutils:collectinc {theModules theIncPath theTargetStation} {
642 global path
643
644 set aCasRoot [file normalize $path]
645 set anIncPath [file normalize $theIncPath]
646
647 if {![file isdirectory $aCasRoot]} {
648 puts "OCCT directory is not defined correctly: $aCasRoot"
649 return
650 }
651
652 set anUsedToolKits {}
653 foreach aModule $theModules {
654 foreach aToolKit [${aModule}:toolkits] {
655 lappend anUsedToolKits $aToolKit
656
657 foreach aDependency [LibToLink $aToolKit] {
658 lappend anUsedToolKits $aDependency
659 }
660 }
661 foreach anExecutable [OS:executable ${aModule}] {
662 lappend anUsedToolKits $anExecutable
663
664 foreach aDependency [LibToLink $anExecutable] {
665 lappend anUsedToolKits $aDependency
666 }
667 }
668 }
669 lsort -unique $anUsedToolKits
670
671 set anUnits {}
672 foreach anUsedToolKit $anUsedToolKits {
673 set anUnits [concat $anUnits [osutils:tk:units $anUsedToolKit]]
674 }
675 lsort -unique $anUnits
676
677 if { [info exists ::env(SHORTCUT_HEADERS)] &&
678 $::env(SHORTCUT_HEADERS) == "true" } {
679 # template preparation
680 if { ![file exists $aCasRoot/adm/templates/header.in] } {
681 puts "template file does not exist: $aCasRoot/adm/templates/header.in"
682 return
683 }
684 set aHeaderTmpl [wokUtils:FILES:FileToString $aCasRoot/adm/templates/header.in]
685
686 # relative anIncPath in connection with aCasRoot/src
687 set aFromBuildIncToSrcPath [relativePath "$anIncPath" "$aCasRoot/src"]
688
689 # create and copy short-cut header files
690 foreach anUnit $anUnits {
691 set aHFiles [glob -nocomplain -dir $aCasRoot/src/$anUnit "*.h"]
692 foreach aHeaderFile [concat [glob -nocomplain -dir $aCasRoot/src/$anUnit "*.\[hgl\]xx"] $aHFiles] {
693 set aHeaderFileName [file tail $aHeaderFile]
694
695 regsub -all -- {@OCCT_HEADER_FILE@} $aHeaderTmpl "$aFromBuildIncToSrcPath/$anUnit/$aHeaderFileName" aShortCutHeaderFileContent
696
697 if {[file exists "$theIncPath/$aHeaderFileName"] && [file readable "$theIncPath/$aHeaderFileName"]} {
698 set fp [open "$theIncPath/$aHeaderFileName" r]
699 set aHeaderContent [read $fp]
700 close $fp
701
702 # minus eof
703 set aHeaderLenght [expr [string length $aHeaderContent] - 1]
704
705 if {$aHeaderLenght == [string length $aShortCutHeaderFileContent]} {
706 # remove eof from string
707 set aHeaderContent [string range $aHeaderContent 0 [expr $aHeaderLenght - 1]]
708
709 if {[string compare $aShortCutHeaderFileContent $aHeaderContent] == 0} {
710 continue
711 }
712 }
713 }
714
715 set aShortCutHeaderFile [open "$theIncPath/$aHeaderFileName" "w"]
716 fconfigure $aShortCutHeaderFile -translation lf
717 puts $aShortCutHeaderFile $aShortCutHeaderFileContent
718 close $aShortCutHeaderFile
719 }
720 }
721 } else {
722 set nbcopied 0
723 foreach anUnit $anUnits {
724 set aHFiles [glob -nocomplain -dir $aCasRoot/src/$anUnit "*.h"]
725 foreach aHeaderFile [concat [glob -nocomplain -dir $aCasRoot/src/$anUnit "*.\[hgl\]xx"] $aHFiles] {
726 set aHeaderFileName [file tail $aHeaderFile]
727
728 # copy file only if target does not exist or is older than original
729 set torig [file mtime $aHeaderFile]
730 if { ! [file isfile $anIncPath/$aHeaderFileName] } {
731 set tcopy 0
732 } else {
733 set tcopy [file mtime $anIncPath/$aHeaderFileName]
734 }
735 if { $tcopy < $torig } {
736 incr nbcopied
737 file copy -force $aHeaderFile $anIncPath/$aHeaderFileName
738 } elseif { $tcopy != $torig } {
739 puts "Warning: file $anIncPath/$aHeaderFileName is newer than $aHeaderFile, not changed!"
740 }
741 }
742 }
743 puts "Info: $nbcopied files updated"
744 }
745}
746
747# Generate header for VS solution file
748proc osutils:vcsolution:header { vcversion } {
749 if { "$vcversion" == "vc7" } {
750 append var \
751 "Microsoft Visual Studio Solution File, Format Version 8.00\n"
752 } elseif { "$vcversion" == "vc8" } {
753 append var \
754 "Microsoft Visual Studio Solution File, Format Version 9.00\n" \
755 "# Visual Studio 2005\n"
756 } elseif { "$vcversion" == "vc9" } {
757 append var \
758 "Microsoft Visual Studio Solution File, Format Version 10.00\n" \
759 "# Visual Studio 2008\n"
760 } elseif { "$vcversion" == "vc10" } {
761 append var \
762 "Microsoft Visual Studio Solution File, Format Version 11.00\n" \
763 "# Visual Studio 2010\n"
764 } elseif { "$vcversion" == "vc11" } {
765 append var \
766 "Microsoft Visual Studio Solution File, Format Version 12.00\n" \
767 "# Visual Studio 2012\n"
768 } elseif { "$vcversion" == "vc12" } {
769 append var \
770 "Microsoft Visual Studio Solution File, Format Version 13.00\n" \
771 "# Visual Studio 2013\n"
39bff09c 772 } elseif { "$vcversion" == "vc14" } {
773 append var \
774 "Microsoft Visual Studio Solution File, Format Version 12.00\n" \
775 "# Visual Studio 14\n"
910970ab 776 } else {
777 puts stderr "Error: Visual Studio version $vcversion is not supported by this function!"
778 }
779 return $var
780}
781# Returns extension (without dot) for project files of given version of VC
782
783proc osutils:vcproj:ext { vcversion } {
784 if { "$vcversion" == "vc7" || "$vcversion" == "vc8" || "$vcversion" == "vc9" } {
785 return "vcproj"
910970ab 786 } else {
39bff09c 787 return "vcxproj"
910970ab 788 }
789}
790# Generate start of configuration section of VS solution file
791
792proc osutils:vcsolution:config:begin { vcversion } {
793 if { "$vcversion" == "vc7" } {
794 append var \
795 "Global\n" \
796 "\tGlobalSection(SolutionConfiguration) = preSolution\n" \
797 "\t\tDebug = Debug\n" \
798 "\t\tRelease = Release\n" \
799 "\tEndGlobalSection\n" \
800 "\tGlobalSection(ProjectConfiguration) = postSolution\n"
39bff09c 801 } else {
910970ab 802 append var \
803 "Global\n" \
804 "\tGlobalSection(SolutionConfigurationPlatforms) = preSolution\n" \
805 "\t\tDebug|Win32 = Debug|Win32\n" \
806 "\t\tRelease|Win32 = Release|Win32\n" \
807 "\t\tDebug|x64 = Debug|x64\n" \
808 "\t\tRelease|x64 = Release|x64\n" \
809 "\tEndGlobalSection\n" \
810 "\tGlobalSection(ProjectConfigurationPlatforms) = postSolution\n"
910970ab 811 }
812 return $var
813}
814# Generate part of configuration section of VS solution file describing one project
815
816proc osutils:vcsolution:config:project { vcversion guid } {
817 if { "$vcversion" == "vc7" } {
818 append var \
819 "\t\t$guid.Debug.ActiveCfg = Debug|Win32\n" \
820 "\t\t$guid.Debug.Build.0 = Debug|Win32\n" \
821 "\t\t$guid.Release.ActiveCfg = Release|Win32\n" \
822 "\t\t$guid.Release.Build.0 = Release|Win32\n"
39bff09c 823 } else {
910970ab 824 append var \
825 "\t\t$guid.Debug|Win32.ActiveCfg = Debug|Win32\n" \
826 "\t\t$guid.Debug|Win32.Build.0 = Debug|Win32\n" \
827 "\t\t$guid.Release|Win32.ActiveCfg = Release|Win32\n" \
828 "\t\t$guid.Release|Win32.Build.0 = Release|Win32\n" \
829 "\t\t$guid.Debug|x64.ActiveCfg = Debug|x64\n" \
830 "\t\t$guid.Debug|x64.Build.0 = Debug|x64\n" \
831 "\t\t$guid.Release|x64.ActiveCfg = Release|x64\n" \
832 "\t\t$guid.Release|x64.Build.0 = Release|x64\n"
910970ab 833 }
834 return $var
835}
836# Generate start of configuration section of VS solution file
837
838proc osutils:vcsolution:config:end { vcversion } {
839 if { "$vcversion" == "vc7" } {
840 append var \
841 "\tEndGlobalSection\n" \
842 "\tGlobalSection(ExtensibilityGlobals) = postSolution\n" \
843 "\tEndGlobalSection\n" \
844 "\tGlobalSection(ExtensibilityAddIns) = postSolution\n" \
845 "\tEndGlobalSection\n"
39bff09c 846 } else {
910970ab 847 append var \
848 "\tEndGlobalSection\n" \
849 "\tGlobalSection(SolutionProperties) = preSolution\n" \
850 "\t\tHideSolutionNode = FALSE\n" \
851 "\tEndGlobalSection\n"
910970ab 852 }
853 return $var
854}
855# generate Visual Studio solution file
856# if module is empty, generates one solution for all known modules
857
858proc OS:vcsolution { theVcVer theSolName theModules theOutDir theGuidsMap } {
859 global path
860 upvar $theGuidsMap aGuidsMap
861
862 # collect list of projects to be created
863 set aProjects {}
864 set aDependencies {}
865 foreach aModule $theModules {
866 # toolkits
867 foreach aToolKit [osutils:tk:sort [${aModule}:toolkits]] {
868 lappend aProjects $aToolKit
869 lappend aProjectsInModule($aModule) $aToolKit
870 lappend aDependencies [LibToLink $aToolKit]
871 }
872 # executables, assume one project per cxx file...
873 foreach aUnit [OS:executable ${aModule}] {
874 set aUnitLoc $aUnit
875 set src_files [_get_used_files $aUnit false]
876 set aSrcFiles {}
877 foreach s $src_files {
878 regexp {source ([^\s]+)} $s dummy name
879 lappend aSrcFiles $name
880 }
881 foreach aSrcFile $aSrcFiles {
882 set aFileExtension [file extension $aSrcFile]
883 if { $aFileExtension == ".cxx" } {
884 set aPrjName [file rootname $aSrcFile]
885 lappend aProjects $aPrjName
886 lappend aProjectsInModule($aModule) $aPrjName
887 if {[file isdirectory $path/src/$aUnitLoc]} {
888 lappend aDependencies [LibToLinkX $aUnitLoc [file rootname $aSrcFile]]
889 } else {
890 lappend aDependencies {}
891 }
892 }
893 }
894 }
895 }
896
897# generate GUIDs for projects (unless already known)
898 foreach aProject $aProjects {
899 if { ! [info exists aGuidsMap($aProject)] } {
900 set aGuidsMap($aProject) [OS:genGUID]
901 }
902 }
903
904 # generate solution file
905# puts "Generating Visual Studio ($theVcVer) solution file for $theSolName ($aProjects)"
906 append aFileBuff [osutils:vcsolution:header $theVcVer]
907
908 # GUID identifying group projects in Visual Studio
909 set VC_GROUP_GUID "{2150E333-8FDC-42A3-9474-1A3956D46DE8}"
910
911 # generate group projects -- one per module
912 if { "$theVcVer" != "vc7" && [llength "$theModules"] > 1 } {
913 foreach aModule $theModules {
914 if { ! [info exists aGuidsMap(_$aModule)] } {
915 set aGuidsMap(_$aModule) [OS:genGUID]
916 }
917 set aGuid $aGuidsMap(_$aModule)
918 append aFileBuff "Project(\"${VC_GROUP_GUID}\") = \"$aModule\", \"$aModule\", \"$aGuid\"\nEndProject\n"
919 }
920 }
921
922 # extension of project files
923 set aProjExt [osutils:vcproj:ext $theVcVer]
924
925 # GUID identifying C++ projects in Visual Studio
926 set VC_CPP_GUID "{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}"
927
928 # generate normal projects
929 set aProjsNb [llength $aProjects]
930 for {set aProjId 0} {$aProjId < $aProjsNb} {incr aProjId} {
931 set aProj [lindex $aProjects $aProjId]
932 set aGuid $aGuidsMap($aProj)
933 append aFileBuff "Project(\"${VC_CPP_GUID}\") = \"$aProj\", \"$aProj.${aProjExt}\", \"$aGuid\"\n"
934 # write projects dependencies information (vc7 to vc9)
935 set aDepGuids ""
936 foreach aDepLib [lindex $aDependencies $aProjId] {
937 if { $aDepLib != $aProj && [lsearch $aProjects $aDepLib] != "-1" } {
938 set depGUID $aGuidsMap($aDepLib)
939 append aDepGuids "\t\t$depGUID = $depGUID\n"
940 }
941 }
942 if { "$aDepGuids" != "" } {
943 append aFileBuff "\tProjectSection(ProjectDependencies) = postProject\n"
944 append aFileBuff "$aDepGuids"
945 append aFileBuff "\tEndProjectSection\n"
946 }
947 append aFileBuff "EndProject\n"
948 }
949
950 # generate configuration section
951 append aFileBuff [osutils:vcsolution:config:begin $theVcVer]
952 foreach aProj $aProjects {
953 append aFileBuff [osutils:vcsolution:config:project $theVcVer $aGuidsMap($aProj)]
954 }
955 append aFileBuff [osutils:vcsolution:config:end $theVcVer]
956
957 # write information of grouping of projects by module
958 if { "$theVcVer" != "vc7" && [llength "$theModules"] > 1 } {
959 append aFileBuff " GlobalSection(NestedProjects) = preSolution\n"
960 foreach aModule $theModules {
961 if { ! [info exists aProjectsInModule($aModule)] } { continue }
962 foreach aProject $aProjectsInModule($aModule) {
963 append aFileBuff " $aGuidsMap($aProject) = $aGuidsMap(_$aModule)\n"
964 }
965 }
966 append aFileBuff " EndGlobalSection\n"
967 }
968
969 # final word (footer)
970 append aFileBuff "EndGlobal"
971
972 # write solution
973 set aFile [open [set fdsw [file join $theOutDir ${theSolName}.sln]] w]
974 fconfigure $aFile -translation crlf
975 puts $aFile $aFileBuff
976 close $aFile
977 return [file join $theOutDir ${theSolName}.sln]
978}
979# Generate Visual Studio projects for specified version
980
981proc OS:vcproj { theVcVer theModules theOutDir theGuidsMap } {
982 upvar $theGuidsMap aGuidsMap
983
984 set aProjectFiles {}
985
986 foreach aModule $theModules {
987 foreach aToolKit [${aModule}:toolkits] {
988 lappend aProjectFiles [osutils:vcproj $theVcVer $theOutDir $aToolKit aGuidsMap]
989 }
990 foreach anExecutable [OS:executable ${aModule}] {
991 lappend aProjectFiles [osutils:vcprojx $theVcVer $theOutDir $anExecutable aGuidsMap]
992 }
993 }
994 return $aProjectFiles
995}
996# generate template name and load it for given version of Visual Studio and platform
997
39bff09c 998proc osutils:vcproj:readtemplate {theVcVer isexec} {
999 set anExt $theVcVer
1000 if { "$theVcVer" != "vc7" && "$theVcVer" != "vc8" && "$theVcVer" != "vc9" } {
1001 set anExt vc10
1002 }
1003
1004 set what "$theVcVer"
1005 set aVerExt [string range $theVcVer 2 end]
1006 set aVerExt "v${aVerExt}0"
1007 set aCmpl32 ""
1008 set aCmpl64 ""
910970ab 1009 if { $isexec } {
39bff09c 1010 set anExt "${anExt}x"
910970ab 1011 set what "$what executable"
1012 }
39bff09c 1013 if { "$theVcVer" == "vc10" } {
1014 # SSE2 is enabled by default in vc11+, but not in vc10 for 32-bit target
1015 set aCmpl32 "\n <EnableEnhancedInstructionSet>StreamingSIMDExtensions2</EnableEnhancedInstructionSet>"
1016 }
1017 set aTmpl [osutils:readtemplate $anExt "MS VC++ project ($what)"]
1018 regsub -all -- {__VCVER__} $aTmpl $theVcVer aTmpl
1019 regsub -all -- {__VCVEREXT__} $aTmpl $aVerExt aTmpl
1020 regsub -all -- {__VCMPL32__} $aTmpl $aCmpl32 aTmpl
1021 regsub -all -- {__VCMPL64__} $aTmpl $aCmpl64 aTmpl
1022 return $aTmpl
910970ab 1023}
1024
1025proc osutils:readtemplate {ext what} {
1026 global env
1027 global path
1028 set loc "$path/adm/templates/template.$ext"
1029 return [wokUtils:FILES:FileToString $loc]
1030}
1031# Read a file in a string as is.
1032
1033proc wokUtils:FILES:FileToString { fin } {
1034 if { [catch { set in [ open $fin r ] } errin] == 0 } {
1035 set strin [read $in [file size $fin]]
1036 close $in
1037 return $strin
1038 } else {
1039 return {}
1040 }
1041}
1042# List extensions of compilable files in OCCT
1043
1044proc osutils:compilable { } {
1045 global targetStation
1046 set aWokStation "$targetStation"
1047 if { "$aWokStation" == "mac" } {
1048 return [list .c .cxx .cpp .mm]
1049 }
1050 return [list .c .cxx .cpp]
1051}
1052
1053proc osutils:commonUsedTK { theToolKit } {
1054 global path
1055 set anUsedToolKits [list]
1056 set aDepToolkits [LibToLink $theToolKit]
1057 foreach tkx $aDepToolkits {
1058 if {[_get_type $tkx] == "t"} {
1059 lappend anUsedToolKits "${tkx}"
1060 }
1061 }
1062 return $anUsedToolKits
1063}
910970ab 1064
c7d774c5 1065# Return the list of name *CSF_ in a EXTERNLIB description of a toolkit
1066proc osutils:tk:csfInExternlib { EXTERNLIB } {
910970ab 1067 set l [wokUtils:FILES:FileToList $EXTERNLIB]
1068 set lret {STLPort}
1069 foreach str $l {
1070 if [regexp -- {(CSF_[^ ]*)} $str csf] {
1071 lappend lret $csf
1072 }
1073 }
1074 return $lret
1075}
1076
c7d774c5 1077# @param theCsfLibsMap - libraries map
1078# @param theCsfFrmsMap - frameworks map, OS X specific
1079proc osutils:csfList { theOS theCsfLibsMap theCsfFrmsMap } {
1080 upvar $theCsfLibsMap aLibsMap
1081 upvar $theCsfFrmsMap aFrmsMap
910970ab 1082
c7d774c5 1083 unset theCsfLibsMap
1084 unset theCsfFrmsMap
910970ab 1085
1086 if { "$theOS" == "wnt" } {
c7d774c5 1087 # WinAPI libraries
1088 set aLibsMap(CSF_kernel32) "kernel32.lib"
1089 set aLibsMap(CSF_advapi32) "advapi32.lib"
1090 set aLibsMap(CSF_gdi32) "gdi32.lib"
1091 set aLibsMap(CSF_user32) "user32.lib"
c7d774c5 1092 set aLibsMap(CSF_opengl32) "opengl32.lib"
1093 set aLibsMap(CSF_wsock32) "wsock32.lib"
1094 set aLibsMap(CSF_netapi32) "netapi32.lib"
1095 set aLibsMap(CSF_AviLibs) "ws2_32.lib vfw32.lib"
fa4dcbe0 1096 set aLibsMap(CSF_OpenGlLibs) "opengl32.lib"
c7d774c5 1097
1098 set aLibsMap(CSF_QT) "QtCore4.lib QtGui4.lib"
1099
1100 # VTK
1e75b579 1101 set aLibsMap(CSF_VTK) [osutils:vtkCsf "wnt"]
910970ab 1102 } else {
c7d774c5 1103 set aLibsMap(CSF_FREETYPE) "freetype"
1104 if { "$theOS" == "mac" } {
1105 set aLibsMap(CSF_objc) "objc"
1106 set aFrmsMap(CSF_Appkit) "Appkit"
1107 set aFrmsMap(CSF_IOKit) "IOKit"
1108 set aFrmsMap(CSF_OpenGlLibs) "OpenGL"
1109 set aFrmsMap(CSF_TclLibs) "Tcl"
1110 set aFrmsMap(CSF_TclTkLibs) "Tk"
1111 } else {
d8d01f6e 1112 if { "$theOS" == "qnx" } {
1113 # CSF_ThreadLibs - pthread API is part og libc on QNX
1114 set aLibsMap(CSF_OpenGlLibs) "EGL GLESv2"
1115 set aLibsMap(CSF_TclLibs) "tcl8.6"
1116 set aLibsMap(CSF_TclTkLibs) "tk8.6"
1117 } else {
1118 set aLibsMap(CSF_ThreadLibs) "pthread rt"
1119 set aLibsMap(CSF_OpenGlLibs) "GL"
1120 set aLibsMap(CSF_TclLibs) "tcl8.6"
1121 set aLibsMap(CSF_TclTkLibs) "X11 tk8.6"
1122 set aLibsMap(CSF_XwLibs) "X11 Xext Xmu Xi"
1123 set aLibsMap(CSF_MotifLibs) "X11"
1124 }
910970ab 1125 }
1126
c7d774c5 1127 # optional 3rd-parties
1128 if { "$::HAVE_TBB" == "true" } {
1129 set aLibsMap(CSF_TBB) "tbb tbbmalloc"
1130 }
1131 if { "$::HAVE_FREEIMAGE" == "true" } {
1132 set aLibsMap(CSF_FreeImagePlus) "freeimage"
1133 }
1134 if { "$::HAVE_GL2PS" == "true" } {
1135 set aLibsMap(CSF_GL2PS) "gl2ps"
1136 }
1137 if { "$::HAVE_VTK" == "true" } {
1e75b579 1138 set aLibsMap(CSF_VTK) [osutils:vtkCsf "unix"]
c7d774c5 1139 }
910970ab 1140 }
1141}
1142
1c29294e 1143# Returns string of library dependencies for generation of Visual Studio project or make lists.
1144proc osutils:vtkCsf {{theOS ""}} {
1145 set aVtkVer "6.1"
1146
1147 set aLibSuffix ""
1148 set aPathSplitter ":"
1149
1150 if {"$theOS" == "wnt"} {
1151 set aPathSplitter ";"
1152 set aLibSuffix ".lib"
1153 }
1154
1155 set anOptIncs [split $::env(CSF_OPT_INC) "$aPathSplitter"]
1156 foreach anIncItem $anOptIncs {
1157 if {[regexp -- "vtk-(.*)$" [file tail $anIncItem] dummy aFoundVtkVer]} {
1158 set aVtkVer $aFoundVtkVer
1159 }
1160 }
1161
1162 set aLibArray [list vtkCommonCore vtkCommonDataModel vtkCommonExecutionModel vtkCommonMath vtkCommonTransforms vtkRenderingCore \
1163 vtkRenderingOpenGL vtkFiltersGeneral vtkIOCore vtkIOImage vtkImagingCore vtkInteractionStyle]
1164
1165 # Additional suffices for the libraries
1166 set anIdx 0
1167 foreach anItem $aLibArray {
1168 lset aLibArray $anIdx $anItem-$aVtkVer$aLibSuffix
1169 incr anIdx
1170 }
1171
1172 return [join $aLibArray " "]
1173}
1174
c7d774c5 1175# @param theLibsList - dependencies (libraries list)
1176# @param theFrameworks - dependencies (frameworks list, OS X specific)
1177proc osutils:usedOsLibs { theToolKit theOS theLibsList theFrameworks } {
910970ab 1178 global path
c7d774c5 1179 upvar $theLibsList aLibsList
1180 upvar $theFrameworks aFrameworks
1181 set aLibsList [list]
1182 set aFrameworks [list]
910970ab 1183
c7d774c5 1184 osutils:csfList $theOS aLibsMap aFrmsMap
910970ab 1185
c7d774c5 1186 foreach aCsfElem [osutils:tk:csfInExternlib "$path/src/${theToolKit}/EXTERNLIB"] {
1187 if [info exists aLibsMap($aCsfElem)] {
1188 foreach aLib [split "$aLibsMap($aCsfElem)"] {
1189 if { [lsearch $aLibsList $aLib] == "-1" } {
1190 lappend aLibsList $aLib
1191 }
1192 }
910970ab 1193 }
c7d774c5 1194 if [info exists aFrmsMap($aCsfElem)] {
1195 foreach aFrm [split "$aFrmsMap($aCsfElem)"] {
1196 if { [lsearch $aFrameworks $aFrm] == "-1" } {
1197 lappend aFrameworks $aFrm
1198 }
910970ab 1199 }
1200 }
1201 }
910970ab 1202}
1203
1204# Returns liste of UD in a toolkit. tkloc is a full path wok.
1205proc osutils:tk:units { tkloc } {
1206 global path
1207 set l {}
1208 set PACKAGES "$path/src/$tkloc/PACKAGES"
1209 foreach u [wokUtils:FILES:FileToList $PACKAGES] {
1210 if {[file isdirectory "$path/src/$u"]} {
1211 lappend l $u
1212 }
1213 }
1214 if { $l == {} } {
1215 ;#puts stderr "Warning. No devunit included in $tkloc"
1216 }
1217 return $l
1218}
1219
1220proc osutils:justwnt { listloc } {
1221 # ImageUtility is required for support for old (<6.5.4) versions of OCCT
1222 set goaway [list Xdps Xw ImageUtility WOKUnix]
1223 return [osutils:juststation $goaway $listloc]
1224}
1225
1226# remove from listloc OpenCascade units indesirables on NT
1227proc osutils:juststation {goaway listloc} {
1228 global path
1229 set lret {}
1230 foreach u $listloc {
1231 if {([file isdirectory "$path/src/$u"] && [lsearch $goaway $u] == -1 )
1232 || (![file isdirectory "$path/src/$u"] && [lsearch $goaway $u] == -1 ) } {
1233 lappend lret $u
1234 }
1235 }
1236 return $lret
1237}
1238
1239# intersect3 - perform the intersecting of two lists, returning a list containing three lists.
1240# The first list is everything in the first list that wasn't in the second,
1241# the second list contains the intersection of the two lists, the third list contains everything
1242# in the second list that wasn't in the first.
1243proc osutils:intersect3 {list1 list2} {
1244 set la1(0) {} ; unset la1(0)
1245 set lai(0) {} ; unset lai(0)
1246 set la2(0) {} ; unset la2(0)
1247 foreach v $list1 {
1248 set la1($v) {}
1249 }
1250 foreach v $list2 {
1251 set la2($v) {}
1252 }
1253 foreach elem [concat $list1 $list2] {
1254 if {[info exists la1($elem)] && [info exists la2($elem)]} {
1255 unset la1($elem)
1256 unset la2($elem)
1257 set lai($elem) {}
1258 }
1259 }
1260 list [lsort [array names la1]] [lsort [array names lai]] [lsort [array names la2]]
1261}
1262
1263# Prepare relative path
1264proc relativePath {thePathFrom thePathTo} {
1265 if { [file isdirectory "$thePathFrom"] == 0 } {
1266 return ""
1267 }
1268
1269 set aPathFrom [file normalize "$thePathFrom"]
1270 set aPathTo [file normalize "$thePathTo"]
1271
1272 set aCutedPathFrom "${aPathFrom}/dummy"
1273 set aRelatedDeepPath ""
1274
1275 while { "$aCutedPathFrom" != [file normalize "$aCutedPathFrom/.."] } {
1276 set aCutedPathFrom [file normalize "$aCutedPathFrom/.."]
1277 # does aPathTo contain aCutedPathFrom?
1278 regsub -all $aCutedPathFrom $aPathTo "" aPathFromAfterCut
1279 if { "$aPathFromAfterCut" != "$aPathTo" } { # if so
1280 if { "$aCutedPathFrom" == "$aPathFrom" } { # just go higher, for example, ./somefolder/someotherfolder
1281 set aPathTo ".${aPathTo}"
1282 } elseif { "$aCutedPathFrom" == "$aPathTo" } { # remove the last "/"
1283 set aRelatedDeepPath [string replace $aRelatedDeepPath end end ""]
1284 }
1285 regsub -all $aCutedPathFrom $aPathTo $aRelatedDeepPath aPathToAfterCut
1286 regsub -all "//" $aPathToAfterCut "/" aPathToAfterCut
1287 return $aPathToAfterCut
1288 }
1289 set aRelatedDeepPath "$aRelatedDeepPath../"
1290
1291 }
1292
1293 return $thePathTo
1294}
1295
1296proc wokUtils:EASY:bs1 { s } {
1297 regsub -all {/} $s {\\} r
1298 return $r
1299}
1300
1301# Returs for a full path the liste of n last directory part
1302# n = 1 => tail
1303# n = 2 => dir/file.c
1304# n = 3 => sdir/dir/file.c
1305# etc..
1306proc wokUtils:FILES:wtail { f n } {
1307 set ll [expr [llength [set lif [file split $f]]] -$n]
1308 return [join [lrange $lif $ll end] /]
1309}
1310
1311# Generate entry for one source file in Visual Studio 10 project file
1312proc osutils:vcxproj:file { vcversion file params } {
1313 append text " <ClCompile Include=\"..\\..\\..\\[wokUtils:EASY:bs1 [wokUtils:FILES:wtail $file 3]]\">\n"
1314 if { $params != "" } {
1315 append text " <AdditionalOptions Condition=\"\'\$(Configuration)|\$(Platform)\'==\'Debug|Win32\'\">[string trim ${params}] %(AdditionalOptions)</AdditionalOptions>\n"
1316 }
1317
1318 if { $params != "" } {
1319 append text " <AdditionalOptions Condition=\"\'\$(Configuration)|\$(Platform)\'==\'Release|Win32\'\">[string trim ${params}] %(AdditionalOptions)</AdditionalOptions>\n"
1320 }
1321
1322 if { $params != "" } {
1323 append text " <AdditionalOptions Condition=\"\'\$(Configuration)|\$(Platform)\'==\'Debug|x64\'\">[string trim ${params}] %(AdditionalOptions)</AdditionalOptions>\n"
1324 }
1325
1326 if { $params != "" } {
1327 append text " <AdditionalOptions Condition=\"\'\$(Configuration)|\$(Platform)\'==\'Release|x64\'\">[string trim ${params}] %(AdditionalOptions)</AdditionalOptions>\n"
1328 }
1329
1330 append text " </ClCompile>\n"
1331 return $text
1332}
1333
1334# Generate Visual Studio 2010 project filters file
1335proc osutils:vcxproj:filters { dir proj theFilesMap } {
1336 upvar $theFilesMap aFilesMap
1337
1338 # header
1339 append text "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
1340 append text "<Project ToolsVersion=\"4.0\" xmlns=\"http://schemas.microsoft.com/developer/msbuild/2003\">\n"
1341
1342 # list of "filters" (units)
1343 append text " <ItemGroup>\n"
1344 append text " <Filter Include=\"Source files\">\n"
1345 append text " <UniqueIdentifier>[OS:genGUID]</UniqueIdentifier>\n"
1346 append text " </Filter>\n"
1347 foreach unit $aFilesMap(units) {
1348 append text " <Filter Include=\"Source files\\${unit}\">\n"
1349 append text " <UniqueIdentifier>[OS:genGUID]</UniqueIdentifier>\n"
1350 append text " </Filter>\n"
1351 }
1352 append text " </ItemGroup>\n"
1353
1354 # list of files
1355 append text " <ItemGroup>\n"
1356 foreach unit $aFilesMap(units) {
1357 foreach file $aFilesMap($unit) {
1358 append text " <ClCompile Include=\"..\\..\\..\\[wokUtils:EASY:bs1 [wokUtils:FILES:wtail $file 3]]\">\n"
1359 append text " <Filter>Source files\\${unit}</Filter>\n"
1360 append text " </ClCompile>\n"
1361 }
1362 }
1363 append text " </ItemGroup>\n"
1364
1365 # end
1366 append text "</Project>"
1367
1368 # write file
1369 set fp [open [set fvcproj [file join $dir ${proj}.vcxproj.filters]] w]
1370 fconfigure $fp -translation crlf
1371 puts $fp $text
1372 close $fp
1373
1374 return ${proj}.vcxproj.filters
1375}
1376
1377# Generate Visual Studio 2011 project filters file
1378proc osutils:vcx1proj:filters { dir proj theFilesMap } {
1379 upvar $theFilesMap aFilesMap
1380
1381 # header
1382 append text "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
1383 append text "<Project ToolsVersion=\"4.0\" xmlns=\"http://schemas.microsoft.com/developer/msbuild/2003\">\n"
1384
1385 # list of "filters" (units)
1386 append text " <ItemGroup>\n"
1387 append text " <Filter Include=\"Source files\">\n"
1388 append text " <UniqueIdentifier>[OS:genGUID]</UniqueIdentifier>\n"
1389 append text " </Filter>\n"
1390 foreach unit $aFilesMap(units) {
1391 append text " <Filter Include=\"Source files\\${unit}\">\n"
1392 append text " <UniqueIdentifier>[OS:genGUID]</UniqueIdentifier>\n"
1393 append text " </Filter>\n"
1394 }
1395 append text " </ItemGroup>\n"
1396
1397 # list of files
1398 append text " <ItemGroup>\n"
1399 foreach unit $aFilesMap(units) {
1400 foreach file $aFilesMap($unit) {
1401 append text " <ClCompile Include=\"..\\..\\..\\[wokUtils:EASY:bs1 [wokUtils:FILES:wtail $file 3]]\">\n"
1402 append text " <Filter>Source files\\${unit}</Filter>\n"
1403 append text " </ClCompile>\n"
1404 }
1405 }
1406 append text " </ItemGroup>\n"
1407
1408 append text " <ItemGroup>\n"
1409 append text " <ResourceCompile Include=\"${proj}.rc\" />"
1410 append text " </ItemGroup>\n"
1411
1412 # end
1413 append text "</Project>"
1414
1415 # write file
1416 set fp [open [set fvcproj [file join $dir ${proj}.vcxproj.filters]] w]
1417 fconfigure $fp -translation crlf
1418 puts $fp $text
1419 close $fp
1420
1421 return ${proj}.vcxproj.filters
1422}
1423
1424# Generate RC file content for ToolKit from template
1425proc osutils:readtemplate:rc {theOutDir theToolKit} {
1426 global path
1427 set aLoc "$path/adm/templates/template_dll.rc"
1428 set aBody [wokUtils:FILES:FileToString $aLoc]
1429 regsub -all -- {__TKNAM__} $aBody $theToolKit aBody
1430
1431 set aFile [open "${theOutDir}/${theToolKit}.rc" "w"]
1432 fconfigure $aFile -translation lf
1433 puts $aFile $aBody
1434 close $aFile
1435 return "${theOutDir}/${theToolKit}.rc"
1436}
1437
1438# Generate Visual Studio project file for ToolKit
1439proc osutils:vcproj { theVcVer theOutDir theToolKit theGuidsMap {theProjTmpl {} } } {
1440 if { $theProjTmpl == {} } {set theProjTmpl [osutils:vcproj:readtemplate $theVcVer 0]}
1441
1442 set l_compilable [osutils:compilable]
1443 regsub -all -- {__TKNAM__} $theProjTmpl $theToolKit theProjTmpl
1444
1445 upvar $theGuidsMap aGuidsMap
1446 if { ! [info exists aGuidsMap($theToolKit)] } {
1447 set aGuidsMap($theToolKit) [OS:genGUID]
1448 }
1449 regsub -all -- {__PROJECT_GUID__} $theProjTmpl $aGuidsMap($theToolKit) theProjTmpl
1450
1451 set aCommonUsedTK [list]
1452 foreach tkx [osutils:commonUsedTK $theToolKit] {
1453 lappend aCommonUsedTK "${tkx}.lib"
1454 }
1455
c7d774c5 1456 osutils:usedOsLibs $theToolKit "wnt" aLibs aFrameworks
1457 set aUsedToolKits [concat $aCommonUsedTK $aLibs]
910970ab 1458
1459 # correct names of referred third-party libraries that are named with suffix
1460 # depending on VC version
1461 regsub -all -- {vc[0-9]+} $aUsedToolKits $theVcVer aUsedToolKits
1462
1463 # and put this list to project file
1464 #puts "$theToolKit requires $aUsedToolKits"
39bff09c 1465 if { "$theVcVer" != "vc7" && "$theVcVer" != "vc8" && "$theVcVer" != "vc9" } {
910970ab 1466 set aUsedToolKits [join $aUsedToolKits {;}]
1467 }
1468 regsub -all -- {__TKDEP__} $theProjTmpl $aUsedToolKits theProjTmpl
1469
1470 set anIncPaths "..\\..\\..\\inc"
1471 set aTKDefines ""
1472 set aFilesSection ""
1473 set aVcFilesX(units) ""
1474 set listloc [osutils:tk:units $theToolKit]
1475 set resultloc [osutils:justwnt $listloc]
1476 if [array exists written] { unset written }
1477 #puts "\t1 [wokparam -v %CMPLRS_CXX_Options [w_info -f]] father"
1478 #puts "\t2 [wokparam -v %CMPLRS_CXX_Options] branch"
1479 #puts "\t1 [wokparam -v %CMPLRS_C_Options [w_info -f]] father"
1480 #puts "\t2 [wokparam -v %CMPLRS_C_Options] branch"
1481 set fxloparamfcxx [lindex [osutils:intersect3 [_get_options wnt cmplrs_cxx f] [_get_options wnt cmplrs_cxx b]] 2]
1482 set fxloparamfc [lindex [osutils:intersect3 [_get_options wnt cmplrs_c f] [_get_options wnt cmplrs_c b]] 2]
1483 set fxloparam ""
1484 foreach fxlo $resultloc {
1485 set xlo $fxlo
1486 set aSrcFiles [osutils:tk:files $xlo osutils:compilable 0]
1487 set fxlo_cmplrs_options_cxx [_get_options wnt cmplrs_cxx $fxlo]
1488 if {$fxlo_cmplrs_options_cxx == ""} {
1489 set fxlo_cmplrs_options_cxx [_get_options wnt cmplrs_cxx b]
1490 }
1491 set fxlo_cmplrs_options_c [_get_options wnt cmplrs_c $fxlo]
1492 if {$fxlo_cmplrs_options_c == ""} {
1493 set fxlo_cmplrs_options_c [_get_options wnt cmplrs_c b]
1494 }
1495 set fxloparam "$fxloparam [lindex [osutils:intersect3 [_get_options wnt cmplrs_cxx b] $fxlo_cmplrs_options_cxx] 2]"
1496 set fxloparam "$fxloparam [lindex [osutils:intersect3 [_get_options wnt cmplrs_c b] $fxlo_cmplrs_options_c] 2]"
1497 #puts "\t3 [wokparam -v %CMPLRS_CXX_Options] branch CXX "
1498 #puts "\t4 [wokparam -v %CMPLRS_CXX_Options $fxlo] $fxlo CXX"
1499 #puts "\t5 [wokparam -v %CMPLRS_C_Options] branch C"
1500 #puts "\t6 [wokparam -v %CMPLRS_C_Options $fxlo] $fxlo C"
1501 set needparam ""
1502 foreach partopt $fxloparam {
1503 if {[string first "-I" $partopt] == "0"} {
1504 # this is an additional includes search path
1505 continue
1506 }
1507 set needparam "$needparam $partopt"
1508 }
1509
39bff09c 1510 # Format of projects in vc10+ is different from vc7-9
1511 if { "$theVcVer" != "vc7" && "$theVcVer" != "vc8" && "$theVcVer" != "vc9" } {
910970ab 1512 foreach aSrcFile [lsort $aSrcFiles] {
1513 if { ![info exists written([file tail $aSrcFile])] } {
1514 set written([file tail $aSrcFile]) 1
1515 append aFilesSection [osutils:vcxproj:file $theVcVer $aSrcFile $needparam]
1516 } else {
1517 puts "Warning : in vcproj more than one occurences for [file tail $aSrcFile]"
1518 }
1519 if { ! [info exists aVcFilesX($xlo)] } { lappend aVcFilesX(units) $xlo }
1520 lappend aVcFilesX($xlo) $aSrcFile
1521 }
1522 } else {
1523 append aFilesSection "\t\t\t<Filter\n"
1524 append aFilesSection "\t\t\t\tName=\"${xlo}\"\n"
1525 append aFilesSection "\t\t\t\t>\n"
1526 foreach aSrcFile [lsort $aSrcFiles] {
1527 if { ![info exists written([file tail $aSrcFile])] } {
1528 set written([file tail $aSrcFile]) 1
1529 append aFilesSection [osutils:vcproj:file $theVcVer $aSrcFile $needparam]
1530 } else {
1531 puts "Warning : in vcproj more than one occurences for [file tail $aSrcFile]"
1532 }
1533 }
1534 append aFilesSection "\t\t\t</Filter>\n"
1535 }
1536
1537 # macros
1538 append aTKDefines ";__${xlo}_DLL"
1539 # common includes
1540# append anIncPaths ";..\\..\\..\\src\\${xlo}"
1541 }
1542
1543 regsub -all -- {__TKINC__} $theProjTmpl $anIncPaths theProjTmpl
1544 regsub -all -- {__TKDEFS__} $theProjTmpl $aTKDefines theProjTmpl
1545 regsub -all -- {__FILES__} $theProjTmpl $aFilesSection theProjTmpl
1546
1547 # write file
1548 set aFile [open [set aVcFiles [file join $theOutDir ${theToolKit}.[osutils:vcproj:ext $theVcVer]]] w]
1549 fconfigure $aFile -translation crlf
1550 puts $aFile $theProjTmpl
1551 close $aFile
1552
39bff09c 1553 # write filters file for vc10+
1554 if { "$theVcVer" == "vc7" || "$theVcVer" == "vc8" || "$theVcVer" == "vc9" } {
1555 # nothing
1556 } elseif { "$theVcVer" == "vc10" } {
910970ab 1557 lappend aVcFiles [osutils:vcxproj:filters $theOutDir $theToolKit aVcFilesX]
39bff09c 1558 } else {
910970ab 1559 lappend aVcFiles [osutils:vcx1proj:filters $theOutDir $theToolKit aVcFilesX]
1560 }
1561
1562 # write resource file
1563 lappend aVcFiles [osutils:readtemplate:rc $theOutDir $theToolKit]
1564
1565 return $aVcFiles
1566}
1567
1568# for a unit returns a map containing all its file in the current
1569# workbench
1570# local = 1 only local files
1571proc osutils:tk:loadunit { loc map } {
1572 #puts $loc
1573 upvar $map TLOC
1574 catch { unset TLOC }
1575 set lfiles [_get_used_files $loc]
1576 foreach f $lfiles {
1577 #puts "\t$f"
1578 set t [lindex $f 0]
1579 set p [lindex $f 2]
1580 if [info exists TLOC($t)] {
1581 set l $TLOC($t)
1582 lappend l $p
1583 set TLOC($t) $l
1584 } else {
1585 set TLOC($t) $p
1586 }
1587 }
1588 return
1589}
1590
1591# Returns the list of all compilable files name in a toolkit, or devunit of any type
1592# Call unit filter on units name to accept or reject a unit
1593# Tfiles lists for each unit the type of file that can be compiled.
1594proc osutils:tk:files { tkloc {l_compilable {} } {justail 1} {unitfilter {}} } {
1595 global path
1596 set Tfiles(source,nocdlpack) {source pubinclude}
1597 set Tfiles(source,toolkit) {}
1598 set Tfiles(source,executable) {source pubinclude}
1599 set listloc [concat [osutils:tk:units $tkloc] $tkloc]
1600 #puts " listloc = $listloc"
1601 if { $l_compilable == {} } {
1602 set l_comp [list .c .cxx .cpp]
1603 } else {
1604 set l_comp [$l_compilable]
1605 }
1606 if { $unitfilter == {} } {
1607 set resultloc $listloc
1608 } else {
1609 set resultloc [$unitfilter $listloc]
1610 }
1611 set lret {}
1612 foreach loc $resultloc {
1613 set utyp [_get_type $loc]
1614 #puts "\"$utyp\" \"$loc\""
1615 switch $utyp {
1616 "t" { set utyp "toolkit" }
1617 "n" { set utyp "nocdlpack" }
1618 "x" { set utyp "executable" }
1619 }
1620 if [array exists map] { unset map }
1621 osutils:tk:loadunit $loc map
1622 #puts " loc = $loc === > [array names map]"
1623 set LType $Tfiles(source,${utyp})
1624 foreach typ [array names map] {
1625 if { [lsearch $LType $typ] == -1 } {
1626 unset map($typ)
1627 }
1628 }
1629 foreach type [array names map] {
1630 #puts $type
1631 foreach f $map($type) {
1632 #puts $f
1633 if { [lsearch $l_comp [file extension $f]] != -1 } {
1634 if { $justail == 1 } {
1635 if {$type == "source"} {
1636 if {[lsearch $lret "@top_srcdir@/src/$loc/[file tail $f]"] == -1} {
1637 lappend lret @top_srcdir@/src/$loc/[file tail $f]
1638 }
1639 }
1640 } else {
1641 lappend lret $f
1642 }
1643 }
1644 }
1645 }
1646 }
1647 return $lret
1648}
1649
1650# Generate Visual Studio project file for executable
1651proc osutils:vcprojx { theVcVer theOutDir theToolKit theGuidsMap {theProjTmpl {} } } {
1652 global path
1653 set aVcFiles {}
1654 foreach f [osutils:tk:files $theToolKit osutils:compilable 0] {
1655 if { $theProjTmpl == {} } {
1656 set aProjTmpl [osutils:vcproj:readtemplate $theVcVer 1]
1657 } else {
1658 set aProjTmpl $theProjTmpl
1659 }
1660 set aProjName [file rootname [file tail $f]]
1661 set l_compilable [osutils:compilable]
1662 regsub -all -- {__XQTNAM__} $aProjTmpl $aProjName aProjTmpl
1663
1664 upvar $theGuidsMap aGuidsMap
1665 if { ! [info exists aGuidsMap($aProjName)] } {
1666 set aGuidsMap($aProjName) [OS:genGUID]
1667 }
1668 regsub -all -- {__PROJECT_GUID__} $aProjTmpl $aGuidsMap($aProjName) aProjTmpl
1669
1670 set aCommonUsedTK [list]
1671 foreach tkx [osutils:commonUsedTK $theToolKit] {
1672 lappend aCommonUsedTK "${tkx}.lib"
1673 }
1674
c7d774c5 1675 osutils:usedOsLibs $theToolKit "wnt" aLibs aFrameworks
1676 set aUsedToolKits [concat $aCommonUsedTK $aLibs]
910970ab 1677
1678 # correct names of referred third-party libraries that are named with suffix
1679 # depending on VC version
1680 regsub -all -- {vc[0-9]+} $aUsedToolKits $theVcVer aUsedToolKits
1681
1682# puts "$aProjName requires $aUsedToolKits"
39bff09c 1683 if { "$theVcVer" != "vc7" && "$theVcVer" != "vc8" && "$theVcVer" != "vc9" } {
910970ab 1684 set aUsedToolKits [join $aUsedToolKits {;}]
1685 }
1686 regsub -all -- {__TKDEP__} $aProjTmpl $aUsedToolKits aProjTmpl
1687
1688 set aFilesSection ""
1689 set aVcFilesX(units) ""
1690
1691 if { ![info exists written([file tail $f])] } {
1692 set written([file tail $f]) 1
1693
39bff09c 1694 if { "$theVcVer" != "vc7" && "$theVcVer" != "vc8" && "$theVcVer" != "vc9" } {
910970ab 1695 append aFilesSection [osutils:vcxproj:file $theVcVer $f ""]
1696 if { ! [info exists aVcFilesX($theToolKit)] } { lappend aVcFilesX(units) $theToolKit }
1697 lappend aVcFilesX($theToolKit) $f
1698 } else {
1699 append aFilesSection "\t\t\t<Filter\n"
1700 append aFilesSection "\t\t\t\tName=\"$theToolKit\"\n"
1701 append aFilesSection "\t\t\t\t>\n"
1702 append aFilesSection [osutils:vcproj:file $theVcVer $f ""]
1703 append aFilesSection "\t\t\t</Filter>"
1704 }
1705 } else {
1706 puts "Warning : in vcproj there are than one occurences for [file tail $f]"
1707 }
1708 #puts "$aProjTmpl $aFilesSection"
1709 set aTKDefines ";__${theToolKit}_DLL"
1710 set anIncPaths "..\\..\\..\\inc"
1711 regsub -all -- {__TKINC__} $aProjTmpl $anIncPaths aProjTmpl
1712 regsub -all -- {__TKDEFS__} $aProjTmpl $aTKDefines aProjTmpl
1713 regsub -all -- {__FILES__} $aProjTmpl $aFilesSection aProjTmpl
1c29294e 1714 regsub -all -- {__CONF__} $aProjTmpl Application aProjTmpl
1715
1716 regsub -all -- {__XQTEXT__} $aProjTmpl "exe" aProjTmpl
910970ab 1717
1718 set aFile [open [set aVcFilePath [file join $theOutDir ${aProjName}.[osutils:vcproj:ext $theVcVer]]] w]
1719 fconfigure $aFile -translation crlf
1720 puts $aFile $aProjTmpl
1721 close $aFile
1722
1723 set aCommonSettingsFile "$aVcFilePath.user"
1724 lappend aVcFiles $aVcFilePath
1725
1726 # write filters file for vc10
39bff09c 1727 if { "$theVcVer" != "vc7" && "$theVcVer" != "vc8" && "$theVcVer" != "vc9" } {
910970ab 1728 lappend aVcFiles [osutils:vcxproj:filters $theOutDir $aProjName aVcFilesX]
1729 }
1730
1731 set aCommonSettingsFileTmpl ""
39bff09c 1732 if { "$theVcVer" == "vc7" || "$theVcVer" == "vc8" } {
1733 # nothing
1734 } elseif { "$theVcVer" == "vc9" } {
1735 set aCommonSettingsFileTmpl [wokUtils:FILES:FileToString "$path/adm/templates/vcproj.user.vc9x"]
1736 } else {
1737 set aCommonSettingsFileTmpl [wokUtils:FILES:FileToString "$path/adm/templates/vcxproj.user.vc10x"]
910970ab 1738 }
1739 if { "$aCommonSettingsFileTmpl" != "" } {
39bff09c 1740 regsub -all -- {__VCVER__} $aCommonSettingsFileTmpl $theVcVer aCommonSettingsFileTmpl
1741
1742 set aFile [open [set aVcFilePath "$aCommonSettingsFile"] w]
1743 fconfigure $aFile -translation crlf
1744 puts $aFile $aCommonSettingsFileTmpl
1745 close $aFile
1746
910970ab 1747 lappend aVcFiles "$aCommonSettingsFile"
1748 }
1749 }
1750 return $aVcFiles
1751}
1752
1753# Generate entry for one source file in Visual Studio 7 - 9 project file
1754proc osutils:vcproj:file { theVcVer theFile theOptions } {
1755 append aText "\t\t\t\t<File\n"
1756 append aText "\t\t\t\t\tRelativePath=\"..\\..\\..\\[wokUtils:EASY:bs1 [wokUtils:FILES:wtail $theFile 3]]\">\n"
1757 if { $theOptions == "" } {
1758 append aText "\t\t\t\t</File>\n"
1759 return $aText
1760 }
1761
1762 append aText "\t\t\t\t\t<FileConfiguration\n"
1763 append aText "\t\t\t\t\t\tName=\"Release\|Win32\">\n"
1764 append aText "\t\t\t\t\t\t<Tool\n"
1765 append aText "\t\t\t\t\t\t\tName=\"VCCLCompilerTool\"\n"
1766 append aText "\t\t\t\t\t\t\tAdditionalOptions=\""
1767 foreach aParam $theOptions {
1768 append aText "$aParam "
1769 }
1770 append aText "\"\n"
1771 append aText "\t\t\t\t\t\t/>\n"
1772 append aText "\t\t\t\t\t</FileConfiguration>\n"
1773
1774 append aText "\t\t\t\t\t<FileConfiguration\n"
1775 append aText "\t\t\t\t\t\tName=\"Debug\|Win32\">\n"
1776 append aText "\t\t\t\t\t\t<Tool\n"
1777 append aText "\t\t\t\t\t\t\tName=\"VCCLCompilerTool\"\n"
1778 append aText "\t\t\t\t\t\t\tAdditionalOptions=\""
1779 foreach aParam $theOptions {
1780 append aText "$aParam "
1781 }
1782 append aText "\"\n"
1783 append aText "\t\t\t\t\t\t/>\n"
1784 append aText "\t\t\t\t\t</FileConfiguration>\n"
1785 if { "$theVcVer" == "vc7" } {
1786 append aText "\t\t\t\t</File>\n"
1787 return $aText
1788 }
1789
1790 append aText "\t\t\t\t\t<FileConfiguration\n"
1791 append aText "\t\t\t\t\t\tName=\"Release\|x64\">\n"
1792 append aText "\t\t\t\t\t\t<Tool\n"
1793 append aText "\t\t\t\t\t\t\tName=\"VCCLCompilerTool\"\n"
1794 append aText "\t\t\t\t\t\t\tAdditionalOptions=\""
1795 foreach aParam $theOptions {
1796 append aText "$aParam "
1797 }
1798 append aText "\"\n"
1799 append aText "\t\t\t\t\t\t/>\n"
1800 append aText "\t\t\t\t\t</FileConfiguration>\n"
1801
1802 append aText "\t\t\t\t\t<FileConfiguration\n"
1803 append aText "\t\t\t\t\t\tName=\"Debug\|x64\">\n"
1804 append aText "\t\t\t\t\t\t<Tool\n"
1805 append aText "\t\t\t\t\t\t\tName=\"VCCLCompilerTool\"\n"
1806 append aText "\t\t\t\t\t\t\tAdditionalOptions=\""
1807 foreach aParam $theOptions {
1808 append aText "$aParam "
1809 }
1810 append aText "\"\n"
1811 append aText "\t\t\t\t\t\t/>\n"
1812 append aText "\t\t\t\t\t</FileConfiguration>\n"
1813
1814 append aText "\t\t\t\t</File>\n"
1815 return $aText
1816}
1817
910970ab 1818proc wokUtils:FILES:mkdir { d } {
1819 global tcl_version
1820 regsub -all {\.[^.]*} $tcl_version "" major
1821 if { $major == 8 } {
1822 file mkdir $d
1823 } else {
1824 if ![file exists $d] {
1825 if { "[info command mkdir]" == "mkdir" } {
1826 mkdir -path $d
1827 } else {
1828 puts stderr "wokUtils:FILES:mkdir : Error unable to find a mkdir command."
1829 }
1830 }
1831 }
1832 if [file exists $d] {
1833 return $d
1834 } else {
1835 return {}
1836 }
1837}
1838
910970ab 1839# remove from listloc OpenCascade units indesirables on Unix
1840proc osutils:justunix { listloc } {
c7d774c5 1841 if { "$::tcl_platform(os)" == "Darwin" } {
910970ab 1842 set goaway [list Xw WNT]
1843 } else {
1844 set goaway [list WNT]
1845 }
1846 return [osutils:juststation $goaway $listloc]
1847}
1848
910970ab 1849
1850####### CODEBLOCK ###################################################################
1851# Function to generate Code Blocks workspace and project files
1852proc OS:MKCBP { theOutDir {theModules {}} {theAllSolution ""} } {
1853 puts stderr "Generating project files for Code Blocks"
1854
1855 # Generate projects for toolkits and separate workspace for each module
1856 foreach aModule $theModules {
1857 OS:cworkspace $aModule $aModule $theOutDir
1858 OS:cbp $aModule $theOutDir
1859 }
1860
1861 # Generate single workspace "OCCT" containing projects from all modules
1862 if { "$theAllSolution" != "" } {
1863 OS:cworkspace $theAllSolution $theModules $theOutDir
1864 }
1865
1866 puts "The Code Blocks workspace and project files are stored in the $theOutDir directory"
1867}
1868
1869# Generate Code Blocks projects
1870proc OS:cbp { theModules theOutDir } {
1871 set aProjectFiles {}
1872 foreach aModule $theModules {
1873 foreach aToolKit [${aModule}:toolkits] {
1874 lappend aProjectFiles [osutils:cbptk $theOutDir $aToolKit ]
1875 }
1876 foreach anExecutable [OS:executable ${aModule}] {
1877 lappend aProjectFiles [osutils:cbpx $theOutDir $anExecutable]
1878 }
1879 }
1880 return $aProjectFiles
1881}
1882
1883# Generate Code::Blocks project file for ToolKit
1884proc osutils:cbptk { theOutDir theToolKit } {
1885 set aUsedToolKits [list]
1886 set aFrameworks [list]
1887 set anIncPaths [list]
1888 set aTKDefines [list]
1889 set aTKSrcFiles [list]
1890
1891 osutils:tkinfo "../../.." $theToolKit aUsedToolKits aFrameworks anIncPaths aTKDefines aTKSrcFiles
1892
1893 return [osutils:cbp $theOutDir $theToolKit $aTKSrcFiles $aUsedToolKits $aFrameworks $anIncPaths $aTKDefines]
1894}
1895
1896# Generates Code Blocks workspace.
1897proc OS:cworkspace { theSolName theModules theOutDir } {
1898 global path
1899 set aWsFilePath "${theOutDir}/${theSolName}.workspace"
1900 set aFile [open $aWsFilePath "w"]
1901 set isActiveSet 0
1902 puts $aFile "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>"
1903 puts $aFile "<CodeBlocks_workspace_file>"
1904 puts $aFile "\t<Workspace title=\"${theSolName}\">"
1905
1906 # collect list of projects to be created
1907 foreach aModule $theModules {
1908 # toolkits
1909 foreach aToolKit [osutils:tk:sort [${aModule}:toolkits]] {
1910 set aDependencies [LibToLink $aToolKit]
1911 if { [llength $aDependencies] == 0 } {
1912 puts $aFile "\t\t<Project filename=\"${aToolKit}.cbp\" />"
1913 } else {
1914 puts $aFile "\t\t<Project filename=\"${aToolKit}.cbp\" >"
1915 foreach aDepTk $aDependencies {
1916 puts $aFile "\t\t\t<Depends filename=\"${aDepTk}.cbp\" />"
1917 }
1918 puts $aFile "\t\t</Project>"
1919 }
1920 }
1921
1922 # executables, assume one project per cxx file...
1923 foreach aUnit [OS:executable ${aModule}] {
1924 set aUnitLoc $aUnit
1925 set src_files [_get_used_files $aUnit false]
1926 set aSrcFiles {}
1927 foreach s $src_files {
1928 regexp {source ([^\s]+)} $s dummy name
1929 lappend aSrcFiles $name
1930 }
1931 foreach aSrcFile $aSrcFiles {
1932 set aFileExtension [file extension $aSrcFile]
1933 if { $aFileExtension == ".cxx" } {
1934 set aPrjName [file rootname $aSrcFile]
1935 set aDependencies [list]
1936 if {[file isdirectory $path/src/$aUnitLoc]} {
1937 set aDependencies [LibToLinkX $aUnitLoc [file rootname $aSrcFile]]
1938 }
1939 set anActiveState ""
1940 if { $isActiveSet == 0 } {
1941 set anActiveState " active=\"1\""
1942 set isActiveSet 1
1943 }
1944 if { [llength $aDependencies] == 0 } {
1945 puts $aFile "\t\t<Project filename=\"${aPrjName}.cbp\"${anActiveState}/>"
1946 } else {
1947 puts $aFile "\t\t<Project filename=\"${aPrjName}.cbp\"${anActiveState}>"
1948 foreach aDepTk $aDependencies {
1949 puts $aFile "\t\t\t<Depends filename=\"${aDepTk}.cbp\" />"
1950 }
1951 puts $aFile "\t\t</Project>"
1952 }
1953 }
1954 }
1955 }
1956 }
1957
1958 puts $aFile "\t</Workspace>"
1959 puts $aFile "</CodeBlocks_workspace_file>"
1960 close $aFile
1961
1962 return $aWsFilePath
1963}
1964
1965# Generate Code::Blocks project file for Executable
1966proc osutils:cbpx { theOutDir theToolKit } {
1967 global path targetStation
1968 set aWokStation "$targetStation"
1969 set aWokArch "$::env(ARCH)"
1970
1971 set aCbpFiles {}
1972 foreach aSrcFile [osutils:tk:files $theToolKit osutils:compilable 0] {
1973 # collect list of referred libraries to link with
1974 set aUsedToolKits [list]
1975 set aFrameworks [list]
1976 set anIncPaths [list]
1977 set aTKDefines [list]
1978 set aTKSrcFiles [list]
1979 set aProjName [file rootname [file tail $aSrcFile]]
1980
c7d774c5 1981 osutils:usedOsLibs $theToolKit "$aWokStation" aUsedToolKits aFrameworks
910970ab 1982 set aDepToolkits [LibToLinkX $theToolKit $aProjName]
1983 foreach tkx $aDepToolkits {
1984 if {[_get_type $tkx] == "t"} {
1985 lappend aUsedToolKits "${tkx}"
1986 }
1987 if {[lsearch [glob -tails -directory "$path/src" -types d *] $tkx] == "-1"} {
1988 lappend aUsedToolKits "${tkx}"
1989 }
1990 }
1991
910970ab 1992 set WOKSteps_exec_link [_get_options lin WOKSteps_exec_link $theToolKit]
1993 if { [regexp {WOKStep_DLLink} $WOKSteps_exec_link] || [regexp {WOKStep_Libink} $WOKSteps_exec_link] } {
1994 set isExecutable "false"
1995 } else {
1996 set isExecutable "true"
1997 }
1998
1999 if { ![info exists written([file tail $aSrcFile])] } {
2000 set written([file tail $aSrcFile]) 1
2001 lappend aTKSrcFiles $aSrcFile
2002 } else {
2003 puts "Warning : in cbp there are more than one occurences for [file tail $aSrcFile]"
2004 }
2005
2006 # macros for correct DLL exports
2007 if { "$aWokStation" == "wnt" } {
2008 lappend aTKDefines "__${theToolKit}_DLL"
2009 }
2010
2011 # common include paths
2012 lappend anIncPaths "../../../inc"
2013
c7d774c5 2014 # extra macros
910970ab 2015 if { "$aWokStation" == "wnt" } {
910970ab 2016 lappend aTKDefines "_CRT_SECURE_NO_DEPRECATE"
2017 } else {
910970ab 2018 lappend aTKDefines "OCC_CONVERT_SIGNALS"
2019 #lappend aTKDefines "_GNU_SOURCE=1"
2020 }
2021
2022 lappend aCbpFiles [osutils:cbp $theOutDir $aProjName $aTKSrcFiles $aUsedToolKits $aFrameworks $anIncPaths $aTKDefines $isExecutable]
2023 }
2024
2025 return $aCbpFiles
2026}
2027
2028proc osutils:optinal_libs { } {
2029 return [list tbb.lib tbbmalloc.lib FreeImage.lib FreeImagePlus.lib gl2ps.lib]
2030}
2031
2032# This function intended to generate Code::Blocks project file
2033# @param theOutDir - output directory to place project file
2034# @param theProjName - project name
2035# @param theSrcFiles - list of source files
2036# @param theLibsList - dependencies (libraries list)
2037# @param theFrameworks - dependencies (frameworks list, Mac OS X specific)
2038# @param theIncPaths - header search paths
2039# @param theDefines - compiler macro definitions
2040# @param theIsExe - flag to indicate executable / library target
2041proc osutils:cbp { theOutDir theProjName theSrcFiles theLibsList theFrameworks theIncPaths theDefines {theIsExe "false"} } {
2042 global targetStation
2043 set aWokStation "$targetStation"
2044 set aWokArch "$::env(ARCH)"
2045
2046 set aCbpFilePath "${theOutDir}/${theProjName}.cbp"
2047 set aFile [open $aCbpFilePath "w"]
2048 puts $aFile "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>"
2049 puts $aFile "<CodeBlocks_project_file>"
2050 puts $aFile "\t<FileVersion major=\"1\" minor=\"6\" />"
2051 puts $aFile "\t<Project>"
2052 puts $aFile "\t\t<Option title=\"$theProjName\" />"
2053 puts $aFile "\t\t<Option pch_mode=\"2\" />"
2054 if { "$aWokStation" == "wnt" } {
2055 puts $aFile "\t\t<Option compiler=\"msvc8\" />"
2056 } else {
2057 puts $aFile "\t\t<Option compiler=\"gcc\" />"
2058 }
2059 puts $aFile "\t\t<Build>"
2060
2061 # Release target configuration
2062 puts $aFile "\t\t\t<Target title=\"Release\">"
2063 if { "$theIsExe" == "true" } {
d8d01f6e 2064 puts $aFile "\t\t\t\t<Option output=\"../../../${aWokStation}/cbp/bin/${theProjName}\" prefix_auto=\"0\" extension_auto=\"0\" />"
910970ab 2065 puts $aFile "\t\t\t\t<Option type=\"1\" />"
2066 } else {
2067 if { "$aWokStation" == "wnt" } {
2068 puts $aFile "\t\t\t\t<Option output=\"../../../${aWokStation}/cbp/lib/${theProjName}\" prefix_auto=\"1\" extension_auto=\"1\" />"
2069 } else {
d8d01f6e 2070 puts $aFile "\t\t\t\t<Option output=\"../../../${aWokStation}/cbp/lib/lib${theProjName}.so\" prefix_auto=\"0\" extension_auto=\"0\" />"
910970ab 2071 }
2072 puts $aFile "\t\t\t\t<Option type=\"3\" />"
2073 }
2074 puts $aFile "\t\t\t\t<Option object_output=\"../../../${aWokStation}/cbp/obj\" />"
2075 if { "$aWokStation" == "wnt" } {
2076 puts $aFile "\t\t\t\t<Option compiler=\"msvc8\" />"
2077 } else {
2078 puts $aFile "\t\t\t\t<Option compiler=\"gcc\" />"
2079 }
d8d01f6e 2080 puts $aFile "\t\t\t\t<Option createDefFile=\"0\" />"
2081 puts $aFile "\t\t\t\t<Option createStaticLib=\"0\" />"
910970ab 2082
2083 # compiler options per TARGET (including defines)
2084 puts $aFile "\t\t\t\t<Compiler>"
2085 if { "$aWokStation" == "wnt" } {
2086 puts $aFile "\t\t\t\t\t<Add option=\"-MD\" />"
2087 puts $aFile "\t\t\t\t\t<Add option=\"-arch:SSE2\" />"
2088 puts $aFile "\t\t\t\t\t<Add option=\"-EHsc\" />"
2089 puts $aFile "\t\t\t\t\t<Add option=\"-O2\" />"
2090 puts $aFile "\t\t\t\t\t<Add option=\"-W4\" />"
2091 puts $aFile "\t\t\t\t\t<Add option=\"-MP\" />"
2092 } else {
2093 puts $aFile "\t\t\t\t\t<Add option=\"-O2\" />"
59b19beb 2094 puts $aFile "\t\t\t\t\t<Add option=\"-std=c++0x\" />"
d8d01f6e 2095 if { "$aWokStation" != "qnx" } {
2096 puts $aFile "\t\t\t\t\t<Add option=\"-mmmx\" />"
2097 puts $aFile "\t\t\t\t\t<Add option=\"-msse\" />"
2098 puts $aFile "\t\t\t\t\t<Add option=\"-msse2\" />"
2099 puts $aFile "\t\t\t\t\t<Add option=\"-mfpmath=sse\" />"
2100 }
910970ab 2101 }
2102 foreach aMacro $theDefines {
2103 puts $aFile "\t\t\t\t\t<Add option=\"-D${aMacro}\" />"
2104 }
2105 puts $aFile "\t\t\t\t\t<Add option=\"-DNDEBUG\" />"
d8d01f6e 2106 if { "$aWokStation" == "qnx" } {
2107 puts $aFile "\t\t\t\t\t<Add option=\"-D_QNX_SOURCE\" />"
2108 }
910970ab 2109 puts $aFile "\t\t\t\t\t<Add option=\"-DNo_Exception\" />"
2110
2111 puts $aFile "\t\t\t\t</Compiler>"
2112
2113 puts $aFile "\t\t\t\t<Linker>"
2114 puts $aFile "\t\t\t\t\t<Add directory=\"../../../${aWokStation}/cbp/lib\" />"
2115 if { "$aWokStation" == "mac" && [ lsearch $theLibsList X11 ] >= 0} {
2116 puts $aFile "\t\t\t\t\t<Add directory=\"/usr/X11/lib\" />"
2117 }
2118 puts $aFile "\t\t\t\t\t<Add option=\"\$(CSF_OPT_LNK${aWokArch})\" />"
2119 puts $aFile "\t\t\t\t</Linker>"
2120
2121 puts $aFile "\t\t\t</Target>"
2122
2123 # Debug target configuration
2124 puts $aFile "\t\t\t<Target title=\"Debug\">"
2125 if { "$theIsExe" == "true" } {
d8d01f6e 2126 puts $aFile "\t\t\t\t<Option output=\"../../../${aWokStation}/cbp/bind/${theProjName}\" prefix_auto=\"0\" extension_auto=\"0\" />"
910970ab 2127 puts $aFile "\t\t\t\t<Option type=\"1\" />"
2128 } else {
2129 if { "$aWokStation" == "wnt" } {
2130 puts $aFile "\t\t\t\t<Option output=\"../../../${aWokStation}/cbp/libd/${theProjName}\" prefix_auto=\"1\" extension_auto=\"1\" />"
2131 } else {
d8d01f6e 2132 puts $aFile "\t\t\t\t<Option output=\"../../../${aWokStation}/cbp/libd/lib${theProjName}.so\" prefix_auto=\"0\" extension_auto=\"0\" />"
910970ab 2133 }
2134 puts $aFile "\t\t\t\t<Option type=\"3\" />"
2135 }
2136 puts $aFile "\t\t\t\t<Option object_output=\"../../../${aWokStation}/cbp/objd\" />"
2137 if { "$aWokStation" == "wnt" } {
2138 puts $aFile "\t\t\t\t<Option compiler=\"msvc8\" />"
2139 } else {
2140 puts $aFile "\t\t\t\t<Option compiler=\"gcc\" />"
2141 }
d8d01f6e 2142 puts $aFile "\t\t\t\t<Option createDefFile=\"0\" />"
2143 puts $aFile "\t\t\t\t<Option createStaticLib=\"0\" />"
910970ab 2144
2145 # compiler options per TARGET (including defines)
2146 puts $aFile "\t\t\t\t<Compiler>"
2147 if { "$aWokStation" == "wnt" } {
2148 puts $aFile "\t\t\t\t\t<Add option=\"-MDd\" />"
2149 puts $aFile "\t\t\t\t\t<Add option=\"-arch:SSE2\" />"
2150 puts $aFile "\t\t\t\t\t<Add option=\"-EHsc\" />"
2151 puts $aFile "\t\t\t\t\t<Add option=\"-Od\" />"
2152 puts $aFile "\t\t\t\t\t<Add option=\"-Zi\" />"
2153 puts $aFile "\t\t\t\t\t<Add option=\"-W4\" />"
2154 puts $aFile "\t\t\t\t\t<Add option=\"-MP\" />"
2155 } else {
2156 puts $aFile "\t\t\t\t\t<Add option=\"-O0\" />"
59b19beb 2157 puts $aFile "\t\t\t\t\t<Add option=\"-std=c++0x\" />"
910970ab 2158 puts $aFile "\t\t\t\t\t<Add option=\"-g\" />"
d8d01f6e 2159 if { "$aWokStation" != "qnx" } {
2160 puts $aFile "\t\t\t\t\t<Add option=\"-mmmx\" />"
2161 puts $aFile "\t\t\t\t\t<Add option=\"-msse\" />"
2162 puts $aFile "\t\t\t\t\t<Add option=\"-msse2\" />"
2163 puts $aFile "\t\t\t\t\t<Add option=\"-mfpmath=sse\" />"
2164 }
910970ab 2165 }
2166 foreach aMacro $theDefines {
2167 puts $aFile "\t\t\t\t\t<Add option=\"-D${aMacro}\" />"
2168 }
2169 puts $aFile "\t\t\t\t\t<Add option=\"-D_DEBUG\" />"
d8d01f6e 2170 if { "$aWokStation" == "qnx" } {
2171 puts $aFile "\t\t\t\t\t<Add option=\"-D_QNX_SOURCE\" />"
2172 }
910970ab 2173 puts $aFile "\t\t\t\t\t<Add option=\"-DDEB\" />"
2174 puts $aFile "\t\t\t\t</Compiler>"
2175
2176 puts $aFile "\t\t\t\t<Linker>"
2177 puts $aFile "\t\t\t\t\t<Add directory=\"../../../${aWokStation}/cbp/libd\" />"
2178 if { "$aWokStation" == "mac" && [ lsearch $theLibsList X11 ] >= 0} {
2179 puts $aFile "\t\t\t\t\t<Add directory=\"/usr/X11/lib\" />"
2180 }
2181 puts $aFile "\t\t\t\t\t<Add option=\"\$(CSF_OPT_LNK${aWokArch}D)\" />"
2182 puts $aFile "\t\t\t\t</Linker>"
2183
2184 puts $aFile "\t\t\t</Target>"
2185
2186 puts $aFile "\t\t</Build>"
2187
2188 # COMMON compiler options
2189 puts $aFile "\t\t<Compiler>"
2190 puts $aFile "\t\t\t<Add option=\"-Wall\" />"
2191 puts $aFile "\t\t\t<Add option=\"-fexceptions\" />"
2192 puts $aFile "\t\t\t<Add option=\"-fPIC\" />"
2193 puts $aFile "\t\t\t<Add option=\"\$(CSF_OPT_CMPL)\" />"
2194 foreach anIncPath $theIncPaths {
2195 puts $aFile "\t\t\t<Add directory=\"$anIncPath\" />"
2196 }
2197 puts $aFile "\t\t</Compiler>"
2198
2199 # COMMON linker options
2200 puts $aFile "\t\t<Linker>"
2201 foreach aFrameworkName $theFrameworks {
2202 if { "$aFrameworkName" != "" } {
2203 puts $aFile "\t\t\t<Add option=\"-framework $aFrameworkName\" />"
2204 }
2205 }
2206 foreach aLibName $theLibsList {
2207 if { "$aLibName" != "" } {
2208 puts $aFile "\t\t\t<Add library=\"$aLibName\" />"
2209 }
2210 }
2211 puts $aFile "\t\t</Linker>"
2212
2213 # list of sources
2214 foreach aSrcFile $theSrcFiles {
2215 if {[string equal -nocase [file extension $aSrcFile] ".mm"]} {
2216 puts $aFile "\t\t<Unit filename=\"$aSrcFile\">"
2217 puts $aFile "\t\t\t<Option compile=\"1\" />"
2218 puts $aFile "\t\t\t<Option link=\"1\" />"
2219 puts $aFile "\t\t</Unit>"
2220 } elseif {[string equal -nocase [file extension $aSrcFile] ".c"]} {
2221 puts $aFile "\t\t<Unit filename=\"$aSrcFile\">"
2222 puts $aFile "\t\t\t<Option compilerVar=\"CC\" />"
2223 puts $aFile "\t\t</Unit>"
2224 } else {
2225 puts $aFile "\t\t<Unit filename=\"$aSrcFile\" />"
2226 }
2227 }
2228
2229 puts $aFile "\t</Project>"
2230 puts $aFile "</CodeBlocks_project_file>"
2231 close $aFile
2232
2233 return $aCbpFilePath
2234}
2235
2236# Auxiliary function to achieve complete information to build Toolkit
2237# @param theRelativePath - relative path to CASROOT
2238# @param theToolKit - Toolkit name
2239# @param theUsedLib - dependencies (libraries list)
2240# @param theFrameworks - dependencies (frameworks list, Mac OS X specific)
2241# @param theIncPaths - header search paths
2242# @param theTKDefines - compiler macro definitions
2243# @param theTKSrcFiles - list of source files
2244proc osutils:tkinfo { theRelativePath theToolKit theUsedLib theFrameworks theIncPaths theTKDefines theTKSrcFiles } {
2245 global path targetStation
2246 set aWokStation "$targetStation"
2247
2248 # collect list of referred libraries to link with
2249 upvar $theUsedLib aUsedLibs
2250 upvar $theFrameworks aFrameworks
2251 upvar $theIncPaths anIncPaths
2252 upvar $theTKDefines aTKDefines
2253 upvar $theTKSrcFiles aTKSrcFiles
2254
c7d774c5 2255 osutils:usedOsLibs $theToolKit "$aWokStation" aUsedLibs aFrameworks
910970ab 2256 set aDepToolkits [wokUtils:LIST:Purge [osutils:tk:close $theToolKit]]
2257 foreach tkx $aDepToolkits {
2258 lappend aUsedLibs "${tkx}"
2259 }
2260
910970ab 2261 lappend anIncPaths "$theRelativePath/inc"
2262 set listloc [osutils:tk:units $theToolKit]
2263
2264 if { [llength $listloc] == 0 } {
2265 set listloc $theToolKit
2266 }
2267
2268 if { "$aWokStation" == "wnt" } {
2269 set resultloc [osutils:justwnt $listloc]
2270 } else {
2271 set resultloc [osutils:justunix $listloc]
2272 }
2273 if [array exists written] { unset written }
2274 foreach fxlo $resultloc {
2275 set xlo $fxlo
2276 set aSrcFiles [osutils:tk:files $xlo osutils:compilable 0]
2277 foreach aSrcFile [lsort $aSrcFiles] {
2278 if { ![info exists written([file tail $aSrcFile])] } {
2279 set written([file tail $aSrcFile]) 1
2280 lappend aTKSrcFiles "${theRelativePath}/[wokUtils:FILES:wtail $aSrcFile 3]"
2281 } else {
2282 puts "Warning : more than one occurences for [file tail $aSrcFile]"
2283 }
2284 }
2285
2286 # macros for correct DLL exports
2287 if { "$aWokStation" == "wnt" } {
2288 lappend aTKDefines "__${xlo}_DLL"
2289 }
2290
2291 # common include paths
2292# lappend anIncPaths "${theRelativePath}/src/${xlo}"
2293 }
2294
c7d774c5 2295 # extra macros
910970ab 2296 if { "$aWokStation" == "wnt" } {
910970ab 2297 lappend aTKDefines "_CRT_SECURE_NO_DEPRECATE"
2298 } else {
910970ab 2299 lappend aTKDefines "OCC_CONVERT_SIGNALS"
2300 #lappend aTKDefines "_GNU_SOURCE=1"
2301 }
2302}
2303
2304# Define libraries to link using only EXTERNLIB file
2305proc LibToLinkX {thePackage theDummyName} {
2306 set aToolKits [LibToLink $thePackage]
2307 return $aToolKits
2308}
2309
c7d774c5 2310# Function to generate Xcode workspace and project files
2311proc OS:MKXCD { theOutDir {theModules {}} {theAllSolution ""} {theLibType "dynamic"} {thePlatform ""} } {
2312
2313 puts stderr "Generating project files for Xcode"
2314
2315 # Generate projects for toolkits and separate workspace for each module
2316 foreach aModule $theModules {
2317 OS:xcworkspace $aModule $aModule $theOutDir
2318 OS:xcodeproj $aModule $theOutDir ::THE_GUIDS_LIST $theLibType $thePlatform
2319 }
2320
2321 # Generate single workspace "OCCT" containing projects from all modules
2322 if { "$theAllSolution" != "" } {
2323 OS:xcworkspace $theAllSolution $theModules $theOutDir
2324 }
2325}
2326
2327# Generates toolkits sections for Xcode workspace file.
2328proc OS:xcworkspace:toolkits { theModule } {
2329 set aBuff ""
2330
2331 # Adding toolkits for module in workspace.
2332 foreach aToolKit [osutils:tk:sort [${theModule}:toolkits]] {
2333 append aBuff " <FileRef\n"
2334 append aBuff " location = \"group:${aToolKit}.xcodeproj\">\n"
2335 append aBuff " </FileRef>\n"
2336 }
2337
2338 # Adding executables for module, assume one project per cxx file...
2339 foreach aUnit [OS:executable ${theModule}] {
2340 set aUnitLoc $aUnit
2341 set src_files [_get_used_files $aUnit false]
2342 set aSrcFiles {}
2343 foreach s $src_files {
2344 regexp {source ([^\s]+)} $s dummy name
2345 lappend aSrcFiles $name
2346 }
2347 foreach aSrcFile $aSrcFiles {
2348 set aFileExtension [file extension $aSrcFile]
2349 if { $aFileExtension == ".cxx" } {
2350 set aPrjName [file rootname $aSrcFile]
2351 append aBuff " <FileRef\n"
2352 append aBuff " location = \"group:${aPrjName}.xcodeproj\">\n"
2353 append aBuff " </FileRef>\n"
2354 }
2355 }
2356 }
2357
2358 # Removing unnecessary newline character from the end.
2359 set aBuff [string replace $aBuff end end]
2360 return $aBuff
2361}
2362
2363# Generates workspace files for Xcode.
2364proc OS:xcworkspace { theWorkspaceName theModules theOutDir } {
2365 # Creating workspace directory for Xcode.
2366 set aWorkspaceDir "${theOutDir}/${theWorkspaceName}.xcworkspace"
2367 wokUtils:FILES:mkdir $aWorkspaceDir
2368 if { ! [file exists $aWorkspaceDir] } {
2369 puts stderr "Error: Could not create workspace directory \"$aWorkspaceDir\""
2370 return
2371 }
2372
2373 # Creating workspace file.
2374 set aWsFilePath "${aWorkspaceDir}/contents.xcworkspacedata"
2375 set aFile [open $aWsFilePath "w"]
2376
2377 # Adding header and section for main Group.
2378 puts $aFile "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
2379 puts $aFile "<Workspace"
2380 puts $aFile " version = \"1.0\">"
2381 puts $aFile " <Group"
2382 puts $aFile " location = \"container:\""
2383 puts $aFile " name = \"${theWorkspaceName}\">"
2384
2385 # Adding modules.
2386 if { [llength "$theModules"] > 1 } {
2387 foreach aModule $theModules {
2388 puts $aFile " <Group"
2389 puts $aFile " location = \"container:\""
2390 puts $aFile " name = \"${aModule}\">"
2391 puts $aFile [OS:xcworkspace:toolkits $aModule]
2392 puts $aFile " </Group>"
2393 }
2394 } else {
2395 puts $aFile [OS:xcworkspace:toolkits $theModules]
2396 }
2397
2398 # Adding footer.
2399 puts $aFile " </Group>"
2400 puts $aFile "</Workspace>"
2401 close $aFile
2402}
2403
2404# Generates Xcode project files.
2405proc OS:xcodeproj { theModules theOutDir theGuidsMap theLibType thePlatform} {
2406 upvar $theGuidsMap aGuidsMap
2407
2408 set isStatic 0
2409 if { "$theLibType" == "static" } {
2410 set isStatic 1
2411 } elseif { "$thePlatform" == "ios" } {
2412 set isStatic 1
2413 }
2414
2415 set aProjectFiles {}
2416 foreach aModule $theModules {
2417 foreach aToolKit [${aModule}:toolkits] {
2418 lappend aProjectFiles [osutils:xcdtk $theOutDir $aToolKit aGuidsMap $isStatic $thePlatform "dylib"]
2419 }
2420 foreach anExecutable [OS:executable ${aModule}] {
2421 lappend aProjectFiles [osutils:xcdtk $theOutDir $anExecutable aGuidsMap $isStatic $thePlatform "executable"]
2422 }
2423 }
2424 return $aProjectFiles
2425}
2426
2427# Generates dependencies section for Xcode project files.
2428proc osutils:xcdtk:deps {theToolKit theTargetType theGuidsMap theFileRefSection theDepsGuids theDepsRefGuids theIsStatic} {
2429 global path
2430 upvar $theGuidsMap aGuidsMap
2431 upvar $theFileRefSection aFileRefSection
2432 upvar $theDepsGuids aDepsGuids
2433 upvar $theDepsRefGuids aDepsRefGuids
2434
2435 set aBuildFileSection ""
2436 set aUsedToolKits [wokUtils:LIST:Purge [osutils:tk:close $theToolKit]]
2437 set aDepToolkits [lappend [wokUtils:LIST:Purge [osutils:tk:close $theToolKit]] $theToolKit]
2438
2439 if { "$theTargetType" == "executable" } {
2440 set aFile [osutils:tk:files $theToolKit osutils:compilable 0]
2441 set aProjName [file rootname [file tail $aFile]]
2442 set aDepToolkits [LibToLinkX $theToolKit $aProjName]
2443 }
2444
2445 set aLibExt "dylib"
2446 if { $theIsStatic == 1 } {
2447 set aLibExt "a"
2448 if { "$theTargetType" != "executable" } {
2449 return $aBuildFileSection
2450 }
2451 }
2452
2453 osutils:usedOsLibs $theToolKit "mac" aLibs aFrameworks
2454 set aUsedToolKits [concat $aUsedToolKits $aLibs]
2455 set aUsedToolKits [concat $aUsedToolKits $aFrameworks]
2456 foreach tkx $aUsedToolKits {
2457 set aDepLib "${tkx}_Dep"
2458 set aDepLibRef "${tkx}_DepRef"
2459
2460 if { ! [info exists aGuidsMap($aDepLib)] } {
2461 set aGuidsMap($aDepLib) [OS:genGUID "xcd"]
2462 }
2463 if { ! [info exists aGuidsMap($aDepLibRef)] } {
2464 set aGuidsMap($aDepLibRef) [OS:genGUID "xcd"]
2465 }
2466
2467 append aBuildFileSection "\t\t$aGuidsMap($aDepLib) = \{isa = PBXBuildFile; fileRef = $aGuidsMap($aDepLibRef) ; \};\n"
2468 if {[lsearch -nocase $aFrameworks $tkx] == -1} {
2469 append aFileRefSection "\t\t$aGuidsMap($aDepLibRef) = \{isa = PBXFileReference; lastKnownFileType = file; name = lib${tkx}.${aLibExt}; path = lib${tkx}.${aLibExt}; sourceTree = \"<group>\"; \};\n"
2470 } else {
2471 append aFileRefSection "\t\t$aGuidsMap($aDepLibRef) = \{isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = ${tkx}.framework; path = /System/Library/Frameworks/${tkx}.framework; sourceTree = \"<absolute>\"; \};\n"
2472 }
2473 append aDepsGuids "\t\t\t\t$aGuidsMap($aDepLib) ,\n"
2474 append aDepsRefGuids "\t\t\t\t$aGuidsMap($aDepLibRef) ,\n"
2475 }
2476
2477 return $aBuildFileSection
2478}
2479
2480# Generates PBXBuildFile and PBXGroup sections for project file.
2481proc osutils:xcdtk:sources {theToolKit theTargetType theSrcFileRefSection theGroupSection thePackageGuids theSrcFileGuids theGuidsMap theIncPaths} {
2482 upvar $theSrcFileRefSection aSrcFileRefSection
2483 upvar $theGroupSection aGroupSection
2484 upvar $thePackageGuids aPackagesGuids
2485 upvar $theSrcFileGuids aSrcFileGuids
2486 upvar $theGuidsMap aGuidsMap
2487 upvar $theIncPaths anIncPaths
2488
2489 set listloc [osutils:tk:units $theToolKit]
2490 set resultloc [osutils:justunix $listloc]
2491 set aBuildFileSection ""
2492 set aPackages [lsort -nocase $resultloc]
2493 if { "$theTargetType" == "executable" } {
2494 set aPackages [list "$theToolKit"]
2495 }
2496
2497 # Generating PBXBuildFile, PBXGroup sections and groups for each package.
2498 foreach fxlo $aPackages {
2499 set xlo $fxlo
2500 set aPackage "${xlo}_Package"
2501 set aSrcFileRefGuids ""
2502 if { ! [info exists aGuidsMap($aPackage)] } {
2503 set aGuidsMap($aPackage) [OS:genGUID "xcd"]
2504 }
2505
2506 set aSrcFiles [osutils:tk:files $xlo osutils:compilable 0]
2507 foreach aSrcFile [lsort $aSrcFiles] {
2508 set aFileExt "sourcecode.cpp.cpp"
2509
2510 if { [file extension $aSrcFile] == ".c" } {
2511 set aFileExt "sourcecode.c.c"
2512 } elseif { [file extension $aSrcFile] == ".mm" } {
2513 set aFileExt "sourcecode.cpp.objcpp"
2514 }
2515
2516 if { ! [info exists aGuidsMap($aSrcFile)] } {
2517 set aGuidsMap($aSrcFile) [OS:genGUID "xcd"]
2518 }
2519 set aSrcFileRef "${aSrcFile}_Ref"
2520 if { ! [info exists aGuidsMap($aSrcFileRef)] } {
2521 set aGuidsMap($aSrcFileRef) [OS:genGUID "xcd"]
2522 }
2523 if { ! [info exists written([file tail $aSrcFile])] } {
2524 set written([file tail $aSrcFile]) 1
2525 append aBuildFileSection "\t\t$aGuidsMap($aSrcFile) = \{isa = PBXBuildFile; fileRef = $aGuidsMap($aSrcFileRef) ;\};\n"
2526 append aSrcFileRefSection "\t\t$aGuidsMap($aSrcFileRef) = \{isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = ${aFileExt}; name = [wokUtils:FILES:wtail $aSrcFile 1]; path = ../../../[wokUtils:FILES:wtail $aSrcFile 3]; sourceTree = \"<group>\"; \};\n"
2527 append aSrcFileGuids "\t\t\t\t$aGuidsMap($aSrcFile) ,\n"
2528 append aSrcFileRefGuids "\t\t\t\t$aGuidsMap($aSrcFileRef) ,\n"
2529 } else {
2530 puts "Warning : more than one occurences for [file tail $aSrcFile]"
2531 }
2532 }
2533
2534 append aGroupSection "\t\t$aGuidsMap($aPackage) = \{\n"
2535 append aGroupSection "\t\t\tisa = PBXGroup;\n"
2536 append aGroupSection "\t\t\tchildren = (\n"
2537 append aGroupSection $aSrcFileRefGuids
2538 append aGroupSection "\t\t\t);\n"
2539 append aGroupSection "\t\t\tname = $xlo;\n"
2540 append aGroupSection "\t\t\tsourceTree = \"<group>\";\n"
2541 append aGroupSection "\t\t\};\n"
2542
2543 # Storing packages IDs for adding them later as a child of toolkit
2544 append aPackagesGuids "\t\t\t\t$aGuidsMap($aPackage) ,\n"
2545 }
2546
2547 # Removing unnecessary newline character from the end.
2548 set aPackagesGuids [string replace $aPackagesGuids end end]
2549
2550 return $aBuildFileSection
2551}
2552
2553# Creates folders structure and all necessary files for Xcode project.
2554proc osutils:xcdtk { theOutDir theToolKit theGuidsMap theIsStatic thePlatform {theTargetType "dylib"} } {
2555 set aPBXBuildPhase "Headers"
2556 set aRunOnlyForDeployment "0"
2557 set aProductType "library.dynamic"
2558 set anExecExtension "\t\t\t\tEXECUTABLE_EXTENSION = dylib;"
2559 set anExecPrefix "\t\t\t\tEXECUTABLE_PREFIX = lib;"
2560 set aWrapperExtension "\t\t\t\tWRAPPER_EXTENSION = dylib;"
050c18ac 2561 set aTKDefines [list "OCC_CONVERT_SIGNALS"]
c7d774c5 2562
2563 if { "$theTargetType" == "executable" } {
2564 set aPBXBuildPhase "CopyFiles"
2565 set aRunOnlyForDeployment "1"
2566 set aProductType "tool"
2567 set anExecExtension ""
2568 set anExecPrefix ""
2569 set aWrapperExtension ""
2570 } elseif { $theIsStatic == 1 } {
2571 set aProductType "library.static"
2572 set anExecExtension "\t\t\t\tEXECUTABLE_EXTENSION = a;"
2573 set aWrapperExtension "\t\t\t\tWRAPPER_EXTENSION = a;"
2574 }
2575
2576 set aUsername [exec whoami]
2577
2578 # Creation of folders for Xcode projectP.
2579 set aToolkitDir "${theOutDir}/${theToolKit}.xcodeproj"
2580 wokUtils:FILES:mkdir $aToolkitDir
2581 if { ! [file exists $aToolkitDir] } {
2582 puts stderr "Error: Could not create project directory \"$aToolkitDir\""
2583 return
2584 }
2585
2586 set aUserDataDir "${aToolkitDir}/xcuserdata"
2587 wokUtils:FILES:mkdir $aUserDataDir
2588 if { ! [file exists $aUserDataDir] } {
2589 puts stderr "Error: Could not create xcuserdata directorty in \"$aToolkitDir\""
2590 return
2591 }
2592
2593 set aUserDataDir "${aUserDataDir}/${aUsername}.xcuserdatad"
2594 wokUtils:FILES:mkdir $aUserDataDir
2595 if { ! [file exists $aUserDataDir] } {
2596 puts stderr "Error: Could not create ${aUsername}.xcuserdatad directorty in \"$aToolkitDir\"/xcuserdata"
2597 return
2598 }
2599
2600 set aSchemesDir "${aUserDataDir}/xcschemes"
2601 wokUtils:FILES:mkdir $aSchemesDir
2602 if { ! [file exists $aSchemesDir] } {
2603 puts stderr "Error: Could not create xcschemes directorty in \"$aUserDataDir\""
2604 return
2605 }
2606 # End of folders creation.
2607
2608 # Generating GUID for tookit.
2609 upvar $theGuidsMap aGuidsMap
2610 if { ! [info exists aGuidsMap($theToolKit)] } {
2611 set aGuidsMap($theToolKit) [OS:genGUID "xcd"]
2612 }
2613
2614 # Creating xcscheme file for toolkit from template.
2615 set aXcschemeTmpl [osutils:readtemplate "xcscheme" "xcd"]
2616 regsub -all -- {__TOOLKIT_NAME__} $aXcschemeTmpl $theToolKit aXcschemeTmpl
2617 regsub -all -- {__TOOLKIT_GUID__} $aXcschemeTmpl $aGuidsMap($theToolKit) aXcschemeTmpl
2618 set aXcschemeFile [open "$aSchemesDir/${theToolKit}.xcscheme" "w"]
2619 puts $aXcschemeFile $aXcschemeTmpl
2620 close $aXcschemeFile
2621
2622 # Creating xcschememanagement.plist file for toolkit from template.
2623 set aPlistTmpl [osutils:readtemplate "plist" "xcd"]
2624 regsub -all -- {__TOOLKIT_NAME__} $aPlistTmpl $theToolKit aPlistTmpl
2625 regsub -all -- {__TOOLKIT_GUID__} $aPlistTmpl $aGuidsMap($theToolKit) aPlistTmpl
2626 set aPlistFile [open "$aSchemesDir/xcschememanagement.plist" "w"]
2627 puts $aPlistFile $aPlistTmpl
2628 close $aPlistFile
2629
2630 # Creating project.pbxproj file for toolkit.
2631 set aPbxprojFile [open "$aToolkitDir/project.pbxproj" "w"]
2632 puts $aPbxprojFile "// !\$*UTF8*\$!"
2633 puts $aPbxprojFile "\{"
2634 puts $aPbxprojFile "\tarchiveVersion = 1;"
2635 puts $aPbxprojFile "\tclasses = \{"
2636 puts $aPbxprojFile "\t\};"
2637 puts $aPbxprojFile "\tobjectVersion = 46;"
2638 puts $aPbxprojFile "\tobjects = \{\n"
2639
2640 # Begin PBXBuildFile section
2641 set aPackagesGuids ""
2642 set aGroupSection ""
2643 set aSrcFileRefSection ""
2644 set aSrcFileGuids ""
2645 set aDepsFileRefSection ""
2646 set aDepsGuids ""
2647 set aDepsRefGuids ""
2648 set anIncPaths [list "../../../inc"]
2649 set anLibPaths ""
2650
2651 if { [info exists ::env(CSF_OPT_INC)] } {
2652 set anIncCfg [split "$::env(CSF_OPT_INC)" ":"]
2653 foreach anIncCfgPath $anIncCfg {
2654 lappend anIncPaths $anIncCfgPath
2655 }
2656 }
2657 if { [info exists ::env(CSF_OPT_LIB64)] } {
2658 set anLibCfg [split "$::env(CSF_OPT_LIB64)" ":"]
2659 foreach anLibCfgPath $anLibCfg {
2660 lappend anLibPaths $anLibCfgPath
2661 }
2662 }
2663
2664 puts $aPbxprojFile [osutils:xcdtk:sources $theToolKit $theTargetType aSrcFileRefSection aGroupSection aPackagesGuids aSrcFileGuids aGuidsMap anIncPaths]
2665 puts $aPbxprojFile [osutils:xcdtk:deps $theToolKit $theTargetType aGuidsMap aDepsFileRefSection aDepsGuids aDepsRefGuids $theIsStatic]
2666 # End PBXBuildFile section
2667
2668 # Begin PBXFileReference section
2669 set aToolkitLib "lib${theToolKit}.dylib"
2670 set aPath "$aToolkitLib"
2671 if { "$theTargetType" == "executable" } {
2672 set aPath "$theToolKit"
2673 } elseif { $theIsStatic == 1 } {
2674 set aToolkitLib "lib${theToolKit}.a"
2675 }
2676
2677 if { ! [info exists aGuidsMap($aToolkitLib)] } {
2678 set aGuidsMap($aToolkitLib) [OS:genGUID "xcd"]
2679 }
2680
2681 puts $aPbxprojFile "\t\t$aGuidsMap($aToolkitLib) = {isa = PBXFileReference; explicitFileType = \"compiled.mach-o.${theTargetType}\"; includeInIndex = 0; path = $aPath; sourceTree = BUILT_PRODUCTS_DIR; };\n"
2682 puts $aPbxprojFile $aSrcFileRefSection
2683 puts $aPbxprojFile $aDepsFileRefSection
2684 # End PBXFileReference section
2685
2686
2687 # Begin PBXFrameworksBuildPhase section
2688 set aTkFrameworks "${theToolKit}_Frameworks"
2689 if { ! [info exists aGuidsMap($aTkFrameworks)] } {
2690 set aGuidsMap($aTkFrameworks) [OS:genGUID "xcd"]
2691 }
2692
2693 puts $aPbxprojFile "\t\t$aGuidsMap($aTkFrameworks) = \{"
2694 puts $aPbxprojFile "\t\t\tisa = PBXFrameworksBuildPhase;"
2695 puts $aPbxprojFile "\t\t\tbuildActionMask = 2147483647;"
2696 puts $aPbxprojFile "\t\t\tfiles = ("
2697 puts $aPbxprojFile $aDepsGuids
2698 puts $aPbxprojFile "\t\t\t);"
2699 puts $aPbxprojFile "\t\t\trunOnlyForDeploymentPostprocessing = 0;"
2700 puts $aPbxprojFile "\t\t\};\n"
2701 # End PBXFrameworksBuildPhase section
2702
2703 # Begin PBXGroup section
2704 set aTkPBXGroup "${theToolKit}_PBXGroup"
2705 if { ! [info exists aGuidsMap($aTkPBXGroup)] } {
2706 set aGuidsMap($aTkPBXGroup) [OS:genGUID "xcd"]
2707 }
2708
2709 set aTkSrcGroup "${theToolKit}_SrcGroup"
2710 if { ! [info exists aGuidsMap($aTkSrcGroup)] } {
2711 set aGuidsMap($aTkSrcGroup) [OS:genGUID "xcd"]
2712 }
2713
2714 puts $aPbxprojFile $aGroupSection
2715 puts $aPbxprojFile "\t\t$aGuidsMap($aTkPBXGroup) = \{"
2716 puts $aPbxprojFile "\t\t\tisa = PBXGroup;"
2717 puts $aPbxprojFile "\t\t\tchildren = ("
2718 puts $aPbxprojFile $aDepsRefGuids
2719 puts $aPbxprojFile "\t\t\t\t$aGuidsMap($aTkSrcGroup) ,"
2720 puts $aPbxprojFile "\t\t\t\t$aGuidsMap($aToolkitLib) ,"
2721 puts $aPbxprojFile "\t\t\t);"
2722 puts $aPbxprojFile "\t\t\tsourceTree = \"<group>\";"
2723 puts $aPbxprojFile "\t\t\};"
2724 puts $aPbxprojFile "\t\t$aGuidsMap($aTkSrcGroup) = \{"
2725 puts $aPbxprojFile "\t\t\tisa = PBXGroup;"
2726 puts $aPbxprojFile "\t\t\tchildren = ("
2727 puts $aPbxprojFile $aPackagesGuids
2728 puts $aPbxprojFile "\t\t\t);"
2729 puts $aPbxprojFile "\t\t\tname = \"Source files\";"
2730 puts $aPbxprojFile "\t\t\tsourceTree = \"<group>\";"
2731 puts $aPbxprojFile "\t\t\};\n"
2732 # End PBXGroup section
2733
2734 # Begin PBXHeadersBuildPhase section
2735 set aTkHeaders "${theToolKit}_Headers"
2736 if { ! [info exists aGuidsMap($aTkHeaders)] } {
2737 set aGuidsMap($aTkHeaders) [OS:genGUID "xcd"]
2738 }
2739
2740 puts $aPbxprojFile "\t\t$aGuidsMap($aTkHeaders) = \{"
2741 puts $aPbxprojFile "\t\t\tisa = PBX${aPBXBuildPhase}BuildPhase;"
2742 puts $aPbxprojFile "\t\t\tbuildActionMask = 2147483647;"
2743 puts $aPbxprojFile "\t\t\tfiles = ("
2744 puts $aPbxprojFile "\t\t\t);"
2745 puts $aPbxprojFile "\t\t\trunOnlyForDeploymentPostprocessing = ${aRunOnlyForDeployment};"
2746 puts $aPbxprojFile "\t\t\};\n"
2747 # End PBXHeadersBuildPhase section
2748
2749 # Begin PBXNativeTarget section
2750 set aTkBuildCfgListNativeTarget "${theToolKit}_BuildCfgListNativeTarget"
2751 if { ! [info exists aGuidsMap($aTkBuildCfgListNativeTarget)] } {
2752 set aGuidsMap($aTkBuildCfgListNativeTarget) [OS:genGUID "xcd"]
2753 }
2754
2755 set aTkSources "${theToolKit}_Sources"
2756 if { ! [info exists aGuidsMap($aTkSources)] } {
2757 set aGuidsMap($aTkSources) [OS:genGUID "xcd"]
2758 }
2759
2760 puts $aPbxprojFile "\t\t$aGuidsMap($theToolKit) = \{"
2761 puts $aPbxprojFile "\t\t\tisa = PBXNativeTarget;"
2762 puts $aPbxprojFile "\t\t\tbuildConfigurationList = $aGuidsMap($aTkBuildCfgListNativeTarget) ;"
2763 puts $aPbxprojFile "\t\t\tbuildPhases = ("
2764 puts $aPbxprojFile "\t\t\t\t$aGuidsMap($aTkSources) ,"
2765 puts $aPbxprojFile "\t\t\t\t$aGuidsMap($aTkFrameworks) ,"
2766 puts $aPbxprojFile "\t\t\t\t$aGuidsMap($aTkHeaders) ,"
2767 puts $aPbxprojFile "\t\t\t);"
2768 puts $aPbxprojFile "\t\t\tbuildRules = ("
2769 puts $aPbxprojFile "\t\t\t);"
2770 puts $aPbxprojFile "\t\t\tdependencies = ("
2771 puts $aPbxprojFile "\t\t\t);"
2772 puts $aPbxprojFile "\t\t\tname = $theToolKit;"
2773 puts $aPbxprojFile "\t\t\tproductName = $theToolKit;"
2774 puts $aPbxprojFile "\t\t\tproductReference = $aGuidsMap($aToolkitLib) ;"
2775 puts $aPbxprojFile "\t\t\tproductType = \"com.apple.product-type.${aProductType}\";"
2776 puts $aPbxprojFile "\t\t\};\n"
2777 # End PBXNativeTarget section
2778
2779 # Begin PBXProject section
2780 set aTkProjectObj "${theToolKit}_ProjectObj"
2781 if { ! [info exists aGuidsMap($aTkProjectObj)] } {
2782 set aGuidsMap($aTkProjectObj) [OS:genGUID "xcd"]
2783 }
2784
2785 set aTkBuildCfgListProj "${theToolKit}_BuildCfgListProj"
2786 if { ! [info exists aGuidsMap($aTkBuildCfgListProj)] } {
2787 set aGuidsMap($aTkBuildCfgListProj) [OS:genGUID "xcd"]
2788 }
2789
2790 puts $aPbxprojFile "\t\t$aGuidsMap($aTkProjectObj) = \{"
2791 puts $aPbxprojFile "\t\t\tisa = PBXProject;"
2792 puts $aPbxprojFile "\t\t\tattributes = \{"
2793 puts $aPbxprojFile "\t\t\t\tLastUpgradeCheck = 0430;"
2794 puts $aPbxprojFile "\t\t\t\};"
2795 puts $aPbxprojFile "\t\t\tbuildConfigurationList = $aGuidsMap($aTkBuildCfgListProj) ;"
2796 puts $aPbxprojFile "\t\t\tcompatibilityVersion = \"Xcode 3.2\";"
2797 puts $aPbxprojFile "\t\t\tdevelopmentRegion = English;"
2798 puts $aPbxprojFile "\t\t\thasScannedForEncodings = 0;"
2799 puts $aPbxprojFile "\t\t\tknownRegions = ("
2800 puts $aPbxprojFile "\t\t\t\ten,"
2801 puts $aPbxprojFile "\t\t\t);"
2802 puts $aPbxprojFile "\t\t\tmainGroup = $aGuidsMap($aTkPBXGroup);"
2803 puts $aPbxprojFile "\t\t\tproductRefGroup = $aGuidsMap($aTkPBXGroup);"
2804 puts $aPbxprojFile "\t\t\tprojectDirPath = \"\";"
2805 puts $aPbxprojFile "\t\t\tprojectRoot = \"\";"
2806 puts $aPbxprojFile "\t\t\ttargets = ("
2807 puts $aPbxprojFile "\t\t\t\t$aGuidsMap($theToolKit) ,"
2808 puts $aPbxprojFile "\t\t\t);"
2809 puts $aPbxprojFile "\t\t\};\n"
2810 # End PBXProject section
2811
2812 # Begin PBXSourcesBuildPhase section
2813 puts $aPbxprojFile "\t\t$aGuidsMap($aTkSources) = \{"
2814 puts $aPbxprojFile "\t\t\tisa = PBXSourcesBuildPhase;"
2815 puts $aPbxprojFile "\t\t\tbuildActionMask = 2147483647;"
2816 puts $aPbxprojFile "\t\t\tfiles = ("
2817 puts $aPbxprojFile $aSrcFileGuids
2818 puts $aPbxprojFile "\t\t\t);"
2819 puts $aPbxprojFile "\t\t\trunOnlyForDeploymentPostprocessing = 0;"
2820 puts $aPbxprojFile "\t\t\};\n"
2821 # End PBXSourcesBuildPhase section
2822
2823 # Begin XCBuildConfiguration section
2824 set aTkDebugProject "${theToolKit}_DebugProject"
2825 if { ! [info exists aGuidsMap($aTkDebugProject)] } {
2826 set aGuidsMap($aTkDebugProject) [OS:genGUID "xcd"]
2827 }
2828
2829 set aTkReleaseProject "${theToolKit}_ReleaseProject"
2830 if { ! [info exists aGuidsMap($aTkReleaseProject)] } {
2831 set aGuidsMap($aTkReleaseProject) [OS:genGUID "xcd"]
2832 }
2833
2834 set aTkDebugNativeTarget "${theToolKit}_DebugNativeTarget"
2835 if { ! [info exists aGuidsMap($aTkDebugNativeTarget)] } {
2836 set aGuidsMap($aTkDebugNativeTarget) [OS:genGUID "xcd"]
2837 }
2838
2839 set aTkReleaseNativeTarget "${theToolKit}_ReleaseNativeTarget"
2840 if { ! [info exists aGuidsMap($aTkReleaseNativeTarget)] } {
2841 set aGuidsMap($aTkReleaseNativeTarget) [OS:genGUID "xcd"]
2842 }
2843
2844 # Debug target
2845 puts $aPbxprojFile "\t\t$aGuidsMap($aTkDebugProject) = \{"
2846 puts $aPbxprojFile "\t\t\tisa = XCBuildConfiguration;"
2847 puts $aPbxprojFile "\t\t\tbuildSettings = \{"
2848
2849 puts $aPbxprojFile "\t\t\t\tDEBUG_INFORMATION_FORMAT = dwarf;"
2850 puts $aPbxprojFile "\t\t\t\tALWAYS_SEARCH_USER_PATHS = NO;"
2851 if { "$thePlatform" == "ios" } {
2852 puts $aPbxprojFile "\t\t\t\t\"ARCHS\[sdk=iphoneos\*\]\" = \"\$(ARCHS_STANDARD)\";";
2853 puts $aPbxprojFile "\t\t\t\t\"ARCHS\[sdk=iphonesimulator\*\]\" = \"x86_64\";";
2854 puts $aPbxprojFile "\t\t\t\tCLANG_CXX_LIBRARY = \"libc++\";"
2855 puts $aPbxprojFile "\t\t\t\tCLANG_ENABLE_MODULES = YES;"
2856 puts $aPbxprojFile "\t\t\t\tCLANG_ENABLE_OBJC_ARC = YES;"
2857 }
2858 puts $aPbxprojFile "\t\t\t\tARCHS = \"\$(ARCHS_STANDARD_64_BIT)\";"
2859 puts $aPbxprojFile "\t\t\t\tCLANG_CXX_LANGUAGE_STANDARD = \"gnu++0x\";"
2860 puts $aPbxprojFile "\t\t\t\tCOPY_PHASE_STRIP = NO;"
2861 puts $aPbxprojFile "\t\t\t\tGCC_C_LANGUAGE_STANDARD = gnu99;"
2862 puts $aPbxprojFile "\t\t\t\tGCC_DYNAMIC_NO_PIC = NO;"
2863 puts $aPbxprojFile "\t\t\t\tGCC_ENABLE_OBJC_EXCEPTIONS = YES;"
2864 puts $aPbxprojFile "\t\t\t\tGCC_OPTIMIZATION_LEVEL = 0;"
2865 puts $aPbxprojFile "\t\t\t\tGCC_PREPROCESSOR_DEFINITIONS = ("
2866 puts $aPbxprojFile "\t\t\t\t\t\"DEBUG=1\","
2867 puts $aPbxprojFile "\t\t\t\t\t\"\$\(inherited\)\","
2868 puts $aPbxprojFile "\t\t\t\t);"
2869 puts $aPbxprojFile "\t\t\t\tGCC_SYMBOLS_PRIVATE_EXTERN = NO;"
2870 puts $aPbxprojFile "\t\t\t\tGCC_VERSION = com.apple.compilers.llvm.clang.1_0;"
2871 puts $aPbxprojFile "\t\t\t\tGCC_WARN_64_TO_32_BIT_CONVERSION = YES;"
2872 puts $aPbxprojFile "\t\t\t\tGCC_WARN_ABOUT_RETURN_TYPE = YES;"
2873 puts $aPbxprojFile "\t\t\t\tGCC_WARN_UNINITIALIZED_AUTOS = YES;"
2874 puts $aPbxprojFile "\t\t\t\tGCC_WARN_UNUSED_VARIABLE = YES;"
2875 puts $aPbxprojFile "\t\t\t\tOTHER_LDFLAGS = \"\$(CSF_OPT_LNK64D)\"; "
2876 if { "$thePlatform" == "ios" } {
2877 puts $aPbxprojFile "\t\t\t\tONLY_ACTIVE_ARCH = NO;"
2878 puts $aPbxprojFile "\t\t\t\tSDKROOT = iphoneos;"
2879 } else {
2880 puts $aPbxprojFile "\t\t\t\tONLY_ACTIVE_ARCH = YES;"
2881 }
2882 puts $aPbxprojFile "\t\t\t\};"
2883
2884 puts $aPbxprojFile "\t\t\tname = Debug;"
2885 puts $aPbxprojFile "\t\t\};"
2886
2887 # Release target
2888 puts $aPbxprojFile "\t\t$aGuidsMap($aTkReleaseProject) = \{"
2889 puts $aPbxprojFile "\t\t\tisa = XCBuildConfiguration;"
2890 puts $aPbxprojFile "\t\t\tbuildSettings = \{"
2891
2892 puts $aPbxprojFile "\t\t\t\tDEBUG_INFORMATION_FORMAT = \"dwarf-with-dsym\";"
2893 puts $aPbxprojFile "\t\t\t\tALWAYS_SEARCH_USER_PATHS = NO;"
2894 if { "$thePlatform" == "ios" } {
2895 puts $aPbxprojFile "\t\t\t\t\"ARCHS\[sdk=iphoneos\*\]\" = \"\$(ARCHS_STANDARD)\";";
2896 puts $aPbxprojFile "\t\t\t\t\"ARCHS\[sdk=iphonesimulator\*\]\" = \"x86_64\";";
2897 puts $aPbxprojFile "\t\t\t\tCLANG_CXX_LIBRARY = \"libc++\";"
2898 puts $aPbxprojFile "\t\t\t\tCLANG_ENABLE_MODULES = YES;"
2899 puts $aPbxprojFile "\t\t\t\tCLANG_ENABLE_OBJC_ARC = YES;"
2900 }
2901 puts $aPbxprojFile "\t\t\t\tARCHS = \"\$(ARCHS_STANDARD_64_BIT)\";"
2902 puts $aPbxprojFile "\t\t\t\tCLANG_CXX_LANGUAGE_STANDARD = \"gnu++0x\";"
2903 puts $aPbxprojFile "\t\t\t\tCOPY_PHASE_STRIP = YES;"
2904 puts $aPbxprojFile "\t\t\t\tGCC_C_LANGUAGE_STANDARD = gnu99;"
2905 puts $aPbxprojFile "\t\t\t\tGCC_ENABLE_OBJC_EXCEPTIONS = YES;"
2906 puts $aPbxprojFile "\t\t\t\tDEAD_CODE_STRIPPING = NO;"
2907 puts $aPbxprojFile "\t\t\t\tGCC_OPTIMIZATION_LEVEL = 2;"
2908 puts $aPbxprojFile "\t\t\t\tGCC_VERSION = com.apple.compilers.llvm.clang.1_0;"
2909 puts $aPbxprojFile "\t\t\t\tGCC_WARN_64_TO_32_BIT_CONVERSION = YES;"
2910 puts $aPbxprojFile "\t\t\t\tGCC_WARN_ABOUT_RETURN_TYPE = YES;"
2911 puts $aPbxprojFile "\t\t\t\tGCC_WARN_UNINITIALIZED_AUTOS = YES;"
2912 puts $aPbxprojFile "\t\t\t\tGCC_WARN_UNUSED_VARIABLE = YES;"
2913 puts $aPbxprojFile "\t\t\t\tOTHER_LDFLAGS = \"\$(CSF_OPT_LNK64)\";"
2914 if { "$thePlatform" == "ios" } {
2915 puts $aPbxprojFile "\t\t\t\tIPHONEOS_DEPLOYMENT_TARGET = 7.0;"
2916 puts $aPbxprojFile "\t\t\t\tSDKROOT = iphoneos;"
2917 }
2918 puts $aPbxprojFile "\t\t\t\};"
2919 puts $aPbxprojFile "\t\t\tname = Release;"
2920 puts $aPbxprojFile "\t\t\};"
2921 puts $aPbxprojFile "\t\t$aGuidsMap($aTkDebugNativeTarget) = \{"
2922 puts $aPbxprojFile "\t\t\tisa = XCBuildConfiguration;"
2923 puts $aPbxprojFile "\t\t\tbuildSettings = \{"
2924 puts $aPbxprojFile "${anExecExtension}"
2925 puts $aPbxprojFile "${anExecPrefix}"
2926 puts $aPbxprojFile "\t\t\t\tGCC_PREPROCESSOR_DEFINITIONS = ("
2927 foreach aMacro $aTKDefines {
2928 puts $aPbxprojFile "\t\t\t\t\t${aMacro} ,"
2929 }
2930 puts $aPbxprojFile "\t\t\t\t);"
2931
2932 puts $aPbxprojFile "\t\t\t\tHEADER_SEARCH_PATHS = ("
2933 foreach anIncPath $anIncPaths {
2934 puts $aPbxprojFile "\t\t\t\t\t${anIncPath},"
2935 }
2936 puts $aPbxprojFile "\t\t\t\t\t\"\$(CSF_OPT_INC)\","
2937 puts $aPbxprojFile "\t\t\t\t);"
2938
2939 puts $aPbxprojFile "\t\t\t\tLIBRARY_SEARCH_PATHS = ("
2940 foreach anLibPath $anLibPaths {
2941 puts $aPbxprojFile "\t\t\t\t\t${anLibPath},"
2942 }
2943 puts $aPbxprojFile "\t\t\t\t);"
2944
2945 puts $aPbxprojFile "\t\t\t\tOTHER_CFLAGS = ("
2946 puts $aPbxprojFile "\t\t\t\t\t\"\$(CSF_OPT_CMPL)\","
2947 puts $aPbxprojFile "\t\t\t\t);"
2948 puts $aPbxprojFile "\t\t\t\tOTHER_CPLUSPLUSFLAGS = ("
2949 puts $aPbxprojFile "\t\t\t\t\t\"\$(OTHER_CFLAGS)\","
2950 puts $aPbxprojFile "\t\t\t\t);"
2951 puts $aPbxprojFile "\t\t\t\tPRODUCT_NAME = \"\$(TARGET_NAME)\";"
2952 set anUserHeaderSearchPath "\t\t\t\tUSER_HEADER_SEARCH_PATHS = \""
2953 foreach anIncPath $anIncPaths {
2954 append anUserHeaderSearchPath " ${anIncPath}"
2955 }
2956 append anUserHeaderSearchPath "\";"
2957 puts $aPbxprojFile $anUserHeaderSearchPath
2958 puts $aPbxprojFile "${aWrapperExtension}"
2959 puts $aPbxprojFile "\t\t\t\};"
2960 puts $aPbxprojFile "\t\t\tname = Debug;"
2961 puts $aPbxprojFile "\t\t\};"
2962 puts $aPbxprojFile "\t\t$aGuidsMap($aTkReleaseNativeTarget) = \{"
2963 puts $aPbxprojFile "\t\t\tisa = XCBuildConfiguration;"
2964 puts $aPbxprojFile "\t\t\tbuildSettings = \{"
2965 puts $aPbxprojFile "${anExecExtension}"
2966 puts $aPbxprojFile "${anExecPrefix}"
2967 puts $aPbxprojFile "\t\t\t\tGCC_PREPROCESSOR_DEFINITIONS = ("
2968 foreach aMacro $aTKDefines {
2969 puts $aPbxprojFile "\t\t\t\t\t${aMacro} ,"
2970 }
2971 puts $aPbxprojFile "\t\t\t\t);"
2972 puts $aPbxprojFile "\t\t\t\tHEADER_SEARCH_PATHS = ("
2973 foreach anIncPath $anIncPaths {
2974 puts $aPbxprojFile "\t\t\t\t\t${anIncPath},"
2975 }
2976 puts $aPbxprojFile "\t\t\t\t\t\"\$(CSF_OPT_INC)\","
2977 puts $aPbxprojFile "\t\t\t\t);"
2978
2979 puts $aPbxprojFile "\t\t\t\tLIBRARY_SEARCH_PATHS = ("
2980 foreach anLibPath $anLibPaths {
2981 puts $aPbxprojFile "\t\t\t\t\t${anLibPath},"
2982 }
2983 puts $aPbxprojFile "\t\t\t\t);"
2984
2985 puts $aPbxprojFile "\t\t\t\tOTHER_CFLAGS = ("
2986 puts $aPbxprojFile "\t\t\t\t\t\"\$(CSF_OPT_CMPL)\","
2987 puts $aPbxprojFile "\t\t\t\t);"
2988 puts $aPbxprojFile "\t\t\t\tOTHER_CPLUSPLUSFLAGS = ("
2989 puts $aPbxprojFile "\t\t\t\t\t\"\$(OTHER_CFLAGS)\","
2990 puts $aPbxprojFile "\t\t\t\t);"
2991 puts $aPbxprojFile "\t\t\t\tPRODUCT_NAME = \"\$(TARGET_NAME)\";"
2992 puts $aPbxprojFile $anUserHeaderSearchPath
2993 puts $aPbxprojFile "${aWrapperExtension}"
2994 puts $aPbxprojFile "\t\t\t\};"
2995 puts $aPbxprojFile "\t\t\tname = Release;"
2996 puts $aPbxprojFile "\t\t\};\n"
2997 # End XCBuildConfiguration section
2998
2999 # Begin XCConfigurationList section
3000 puts $aPbxprojFile "\t\t$aGuidsMap($aTkBuildCfgListProj) = \{"
3001 puts $aPbxprojFile "\t\t\tisa = XCConfigurationList;"
3002 puts $aPbxprojFile "\t\tbuildConfigurations = ("
3003 puts $aPbxprojFile "\t\t\t\t$aGuidsMap($aTkDebugProject) ,"
3004 puts $aPbxprojFile "\t\t\t\t$aGuidsMap($aTkReleaseProject) ,"
3005 puts $aPbxprojFile "\t\t\t);"
3006 puts $aPbxprojFile "\t\t\tdefaultConfigurationIsVisible = 0;"
3007 puts $aPbxprojFile "\t\t\tdefaultConfigurationName = Release;"
3008 puts $aPbxprojFile "\t\t\};"
3009 puts $aPbxprojFile "\t\t$aGuidsMap($aTkBuildCfgListNativeTarget) = \{"
3010 puts $aPbxprojFile "\t\t\tisa = XCConfigurationList;"
3011 puts $aPbxprojFile "\t\t\tbuildConfigurations = ("
3012 puts $aPbxprojFile "\t\t\t\t$aGuidsMap($aTkDebugNativeTarget) ,"
3013 puts $aPbxprojFile "\t\t\t\t$aGuidsMap($aTkReleaseNativeTarget) ,"
3014 puts $aPbxprojFile "\t\t\t);"
3015 puts $aPbxprojFile "\t\t\tdefaultConfigurationIsVisible = 0;"
3016 puts $aPbxprojFile "\t\t\tdefaultConfigurationName = Release;"
3017 puts $aPbxprojFile "\t\t\};\n"
3018 # End XCConfigurationList section
3019
3020 puts $aPbxprojFile "\t\};"
3021 puts $aPbxprojFile "\trootObject = $aGuidsMap($aTkProjectObj) ;"
3022 puts $aPbxprojFile "\}"
3023
3024 close $aPbxprojFile
3025}
3026
3027proc osutils:xcdx { theOutDir theExecutable theGuidsMap } {
3028 set aUsername [exec whoami]
3029
3030 # Creating folders for Xcode project file.
3031 set anExecutableDir "${theOutDir}/${theExecutable}.xcodeproj"
3032 wokUtils:FILES:mkdir $anExecutableDir
3033 if { ! [file exists $anExecutableDir] } {
3034 puts stderr "Error: Could not create project directory \"$anExecutableDir\""
3035 return
3036 }
3037
3038 set aUserDataDir "${anExecutableDir}/xcuserdata"
3039 wokUtils:FILES:mkdir $aUserDataDir
3040 if { ! [file exists $aUserDataDir] } {
3041 puts stderr "Error: Could not create xcuserdata directorty in \"$anExecutableDir\""
3042 return
3043 }
3044
3045 set aUserDataDir "${aUserDataDir}/${aUsername}.xcuserdatad"
3046 wokUtils:FILES:mkdir $aUserDataDir
3047 if { ! [file exists $aUserDataDir] } {
3048 puts stderr "Error: Could not create ${aUsername}.xcuserdatad directorty in \"$anExecutableDir\"/xcuserdata"
3049 return
3050 }
3051
3052 set aSchemesDir "${aUserDataDir}/xcschemes"
3053 wokUtils:FILES:mkdir $aSchemesDir
3054 if { ! [file exists $aSchemesDir] } {
3055 puts stderr "Error: Could not create xcschemes directorty in \"$aUserDataDir\""
3056 return
3057 }
3058 # End folders creation.
3059
3060 # Generating GUID for tookit.
3061 upvar $theGuidsMap aGuidsMap
3062 if { ! [info exists aGuidsMap($theExecutable)] } {
3063 set aGuidsMap($theExecutable) [OS:genGUID "xcd"]
3064 }
3065
3066 # Creating xcscheme file for toolkit from template.
3067 set aXcschemeTmpl [osutils:readtemplate "xcscheme" "xcode"]
3068 regsub -all -- {__TOOLKIT_NAME__} $aXcschemeTmpl $theExecutable aXcschemeTmpl
3069 regsub -all -- {__TOOLKIT_GUID__} $aXcschemeTmpl $aGuidsMap($theExecutable) aXcschemeTmpl
3070 set aXcschemeFile [open "$aSchemesDir/${theExecutable}.xcscheme" "w"]
3071 puts $aXcschemeFile $aXcschemeTmpl
3072 close $aXcschemeFile
3073
3074 # Creating xcschememanagement.plist file for toolkit from template.
3075 set aPlistTmpl [osutils:readtemplate "plist" "xcode"]
3076 regsub -all -- {__TOOLKIT_NAME__} $aPlistTmpl $theExecutable aPlistTmpl
3077 regsub -all -- {__TOOLKIT_GUID__} $aPlistTmpl $aGuidsMap($theExecutable) aPlistTmpl
3078 set aPlistFile [open "$aSchemesDir/xcschememanagement.plist" "w"]
3079 puts $aPlistFile $aPlistTmpl
3080 close $aPlistFile
3081}