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