1 # =======================================================================
2 # Created on: 2014-07-24
4 # Copyright (c) 2014 OPEN CASCADE SAS
6 # This file is part of Open CASCADE Technology software library.
8 # This library is free software; you can redistribute it and/or modify it under
9 # the terms of the GNU Lesser General Public License version 2.1 as published
10 # by the Free Software Foundation, with special exception defined in the file
11 # OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12 # distribution for complete text of the license and disclaimer of any warranty.
14 # Alternatively, this file may be used under the terms of Open CASCADE
15 # commercial license or contractual agreement.
17 # =======================================================================
18 # This script defines Tcl command genproj generating project files for
19 # different IDEs and platforms. Run it with -help to get synopsis.
20 # =======================================================================
22 source [file join [file dirname [info script]] genconfdeps.tcl]
24 # the script is assumed to be run from CASROOT (or dependent Products root)
25 set path [file normalize .]
28 if { [info exists ::env(CASROOT)] } {
29 set THE_CASROOT "$::env(CASROOT)"
32 proc _get_options { platform type branch } {
34 if {[file exists "$::THE_CASROOT/adm/CMPLRS"]} {
35 set fd [open "$::THE_CASROOT/adm/CMPLRS" rb]
36 set opts [split [read $fd] "\n"]
39 if {[regexp "^${platform} ${type} ${branch} (.+)$" $line dummy res]} {
40 while {[regexp {\(([^\(\)]+) ([^\(\)]+) ([^\(\)]+)\)(.+)} $res dummy p t b oldres]} {
41 set res "[_get_options $p $t $b] $oldres"
49 proc _get_type { name } {
51 if {[file exists "$::path/adm/UDLIST"]} {
52 set fd [open "$::path/adm/UDLIST" rb]
53 set UDLIST [concat $UDLIST [split [read $fd] "\n"]]
56 if { "$::path/adm/UDLIST" != "$::THE_CASROOT/adm/UDLIST" && [file exists "$::THE_CASROOT/adm/UDLIST"] } {
57 set fd [open "$::THE_CASROOT/adm/UDLIST" rb]
58 set UDLIST [concat $UDLIST [split [read $fd] "\n"]]
62 foreach uitem $UDLIST {
63 set line [split $uitem]
64 if {[lindex $line 1] == "$name"} {
65 return [lindex $line 0]
71 proc _get_used_files { pk {inc true} {src true} } {
73 set type [_get_type $pk]
75 set pk_path "$path/src/$pk"
76 set FILES_path "$path/src/$pk/FILES"
78 if {[file exists $FILES_path]} {
79 set fd [open $FILES_path rb]
80 set FILES [split [read $fd] "\n"]
83 set FILES [lsearch -inline -all -not -exact $FILES ""]
88 if {$inc && ([regexp {([^:\s]*\.[hgl]xx)$} $line dummy name] || [regexp {([^:\s]*\.h)$} $line dummy name]) && [file exists $pk_path/$name]} {
89 lappend lret "pubinclude $name $pk_path/$name"
92 if {[regexp {:} $line]} {
93 regexp {[^:]*:+([^\s]*)} $line dummy line
95 regexp {([^\s]*)} $line dummy line
96 if {$src && [file exists $pk_path/$line]} {
97 lappend lret "source $line $pk_path/$line"
103 # return location of the path within src directory
104 proc osutils:findSrcSubPath {theSubPath} {
105 if {[file exists "$::path/src/$theSubPath"]} {
106 return "$::path/src/$theSubPath"
108 return "$::THE_CASROOT/src/$theSubPath"
111 # Auxiliary tool comparing content of two files line-by-line.
112 proc osutils:isEqualContent { theContent1 theContent2 } {
113 set aLen1 [llength $theContent1]
114 set aLen2 [llength $theContent2]
115 if { $aLen1 != $aLen2 } {
119 for {set aLineIter 0} {$aLineIter < $aLen1} {incr aLineIter} {
120 set aLine1 [lindex $theContent1 $aLineIter]
121 set aLine2 [lindex $theContent2 $aLineIter]
122 if { $aLine1 != $aLine2 } {
129 # Auxiliary function for writing new file content only if it has been actually changed
130 # (e.g. to preserve file timestamp on no change).
131 # Useful for automatically (re)generated files.
132 proc osutils:writeTextFile { theFile theContent {theEol lf} } {
133 if {[file exists "${theFile}"]} {
134 set aFileOld [open "${theFile}" rb]
135 fconfigure $aFileOld -translation crlf
136 set aLineListOld [split [read $aFileOld] "\n"]
139 # append empty line for proper comparison (which will be implicitly added by last puts below)
140 set aContent $theContent
142 if { [osutils:isEqualContent $aLineListOld $aContent] == true } {
146 file delete -force "${theFile}"
149 set anOutFile [open "$theFile" "w"]
150 fconfigure $anOutFile -translation $theEol
151 foreach aLine ${theContent} {
152 puts $anOutFile "${aLine}"
158 # Function re-generating header files for specified text resource
159 proc genResources { theResource } {
163 set aResourceAbsPath [file normalize "${path}/src/${theResource}"]
164 set aResourceDirectory ""
165 set isResDirectory false
167 if {[file isdirectory "${aResourceAbsPath}"]} {
168 if {[file exists "${aResourceAbsPath}/FILES"]} {
169 set aFilesFile [open "${aResourceAbsPath}/FILES" rb]
170 set aResFileList [split [read $aFilesFile] "\n"]
173 set aResFileList [lsearch -inline -all -not -exact $aResFileList ""]
174 set aResourceDirectory "${theResource}"
175 set isResDirectory true
177 set aResourceName [file tail "${theResource}"]
178 lappend aResFileList "res:::${aResourceName}"
179 set aResourceDirectory [file dirname "${theResource}"]
182 foreach aResFileIter ${aResFileList} {
183 if {![regexp {^[^:]+:::(.+)} "${aResFileIter}" dump aResFileIter]} {
187 set aResFileName [file tail "${aResFileIter}"]
188 regsub -all {\.} "${aResFileName}" {_} aResFileName
189 set aHeaderFileName "${aResourceDirectory}_${aResFileName}.pxx"
190 if { $isResDirectory == true && [lsearch $aResFileList $aHeaderFileName] == -1 } {
196 lappend aContent "// This file has been automatically generated from resource file src/${aResourceDirectory}/${aResFileIter}"
199 # generate necessary structures
201 if {[file exists "${path}/src/${aResourceDirectory}/${aResFileIter}"]} {
202 set anInputFile [open "${path}/src/${aResourceDirectory}/${aResFileIter}" rb]
203 fconfigure $anInputFile -translation crlf
204 set aLineList [split [read $anInputFile] "\n"]
208 # drop empty trailing line
210 if { [lindex $aLineList end] == "" } {
211 set aLineList [lreplace $aLineList end end]
212 set anEndOfFile "\\n"
215 lappend aContent "static const char ${aResourceDirectory}_${aResFileName}\[\] ="
216 set aNbLines [llength $aLineList]
217 set aLastLine [expr $aNbLines - 1]
218 for {set aLineIter 0} {$aLineIter < $aNbLines} {incr aLineIter} {
219 set aLine [lindex $aLineList $aLineIter]
220 regsub -all {\"} "${aLine}" {\\"} aLine
221 if { $aLineIter == $aLastLine } {
222 lappend aContent " \"${aLine}${anEndOfFile}\";"
224 lappend aContent " \"${aLine}\\n\""
228 # Save generated content to header file
229 set aHeaderFilePath "${path}/src/${aResourceDirectory}/${aHeaderFileName}"
230 if { [osutils:writeTextFile $aHeaderFilePath $aContent] == true } {
231 puts "Generating header file from resource file: ${path}/src/${aResourceDirectory}/${aResFileIter}"
233 #puts "Header file from resource ${path}/src/${aResourceDirectory}/${aResFileIter} is up-to-date"
238 # Function re-generating header files for all text resources
239 proc genAllResources {} {
241 set aCasRoot [file normalize $path]
242 if {![file exists "$aCasRoot/adm/RESOURCES"]} {
243 puts "OCCT directory is not defined correctly: $aCasRoot"
247 set aFileResources [open "$aCasRoot/adm/RESOURCES" rb]
248 set anAdmResources [split [read $aFileResources] "\r\n"]
249 close $aFileResources
250 set anAdmResources [lsearch -inline -all -not -exact $anAdmResources ""]
252 foreach line $anAdmResources {
253 genResources "${line}"
257 # Wrapper-function to generate VS project files
258 proc genproj {theIDE args} {
259 set aSupportedIDEs { "vc7" "vc8" "vc9" "vc10" "vc11" "vc12" "vc14" "cbp" "xcd" }
260 set aSupportedPlatforms { "wnt" "lin" "mac" "ios" "qnx" }
261 set isHelpRequire false
264 if { $theIDE == "-h" || $theIDE == "-help" || $theIDE == "--help" } {
265 set isHelpRequire true
266 } elseif { [lsearch -exact $aSupportedIDEs $theIDE] < 0 } {
267 puts "Error: genproj: unrecognized IDE \"$theIDE\""
268 set isHelpRequire true
271 # choice of compiler for Code::Blocks, currently hard-coded
274 # Determine default platform: wnt for vc*, mac for xcd, current for cbp
275 if { [regexp "^vc" $theIDE] } {
277 } elseif { $theIDE == "xcd" || $::tcl_platform(os) == "Darwin" } {
279 } elseif { $::tcl_platform(platform) == "windows" } {
281 } elseif { $::tcl_platform(platform) == "unix" } {
285 # Check optional arguments
286 set aLibType "dynamic"
288 if { $arg == "-h" || $arg == "-help" || $arg == "--help" } {
289 set isHelpRequire true
290 } elseif { [lsearch -exact $aSupportedPlatforms $arg] >= 0 } {
292 } elseif { $arg == "-static" } {
293 set aLibType "static"
294 puts "Static build has been selected"
295 } elseif { $arg == "-dynamic" } {
296 set aLibType "dynamic"
297 puts "Dynamic build has been selected"
299 puts "Error: genproj: unrecognized option \"$arg\""
300 set isHelpRequire true
304 if { $isHelpRequire == true } {
305 puts "usage: genproj IDE \[Platform\] \[-static\] \[-h|-help|--help\]
308 vc8 - Visual Studio 2005
309 vc9 - Visual Studio 2008
310 vc10 - Visual Studio 2010
311 vc11 - Visual Studio 2012
312 vc12 - Visual Studio 2013
313 vc14 - Visual Studio 2015
317 Platform (optional, only for CodeBlocks and XCode):
324 Option -static can be used with XCode to build static libraries
329 if { ! [info exists aPlatform] } {
330 puts "Error: genproj: Cannon identify default platform, please specify!"
334 puts "Preparing to generate $theIDE projects for $aPlatform platform..."
336 # path to where to generate projects, hardcoded from current dir
337 set anAdmPath [file normalize "${::path}/adm"]
339 OS:MKPRC "$anAdmPath" "$theIDE" "$aLibType" "$aPlatform" "$aCmpl"
341 genprojbat "$theIDE" $aPlatform
345 proc genprojbat {theIDE thePlatform} {
346 set aTargetPlatformExt sh
347 if { $thePlatform == "wnt" } {
348 set aTargetPlatformExt bat
351 if {"$theIDE" != "cmake"} {
352 # copy env.bat/sh only if not yet present
353 if { ! [file exists "$::path/env.${aTargetPlatformExt}"] } {
354 set anEnvTmplFile [open "$::THE_CASROOT/adm/templates/env.${aTargetPlatformExt}" "r"]
355 set anEnvTmpl [read $anEnvTmplFile]
359 if { [file normalize "$::path"] != [file normalize "$::THE_CASROOT"] } {
360 set aCasRoot [relativePath "$::path" "$::THE_CASROOT"]
363 regsub -all -- {__CASROOT__} $anEnvTmpl "$aCasRoot" anEnvTmpl
365 set anEnvFile [open "$::path/env.${aTargetPlatformExt}" "w"]
366 puts $anEnvFile $anEnvTmpl
370 file copy -force -- "$::THE_CASROOT/adm/templates/draw.${aTargetPlatformExt}" "$::path/draw.${aTargetPlatformExt}"
373 if {[regexp {(vc)[0-9]*$} $theIDE] == 1} {
374 file copy -force -- "$::THE_CASROOT/adm/templates/msvc.bat" "$::path/msvc.bat"
376 switch -exact -- "$theIDE" {
378 file copy -force -- "$::THE_CASROOT/adm/templates/codeblocks.sh" "$::path/codeblocks.sh"
379 file copy -force -- "$::THE_CASROOT/adm/templates/codeblocks.bat" "$::path/codeblocks.bat"
380 # Code::Blocks 16.01 does not create directory for import libs, help him
381 file mkdir "$::path/$thePlatform/cbp/lib"
382 file mkdir "$::path/$thePlatform/cbp/libd"
384 "xcd" { file copy -force -- "$::THE_CASROOT/adm/templates/xcode.sh" "$::path/xcode.sh" }
389 ###### MSVC #############################################################33
390 proc removeAllOccurrencesOf { theObject theList } {
391 set aSortIndices [lsort -decreasing [lsearch -all -nocase $theList $theObject]]
392 foreach anIndex $aSortIndices {
393 set theList [lreplace $theList $anIndex $anIndex]
398 set aTKNullKey "TKNull"
399 set THE_GUIDS_LIST($aTKNullKey) "{00000000-0000-0000-0000-000000000000}"
401 # Entry function to generate project files and solutions for IDE
402 # @param theOutDir Root directory for project files
403 # @param theIDE IDE code name (vc10 for Visual Studio 2010, cbp for Code::Blocks, xcd for XCode)
404 # @param theLibType Library type - dynamic or static
405 # @param thePlatform Optional target platform for cross-compiling, e.g. ios for iOS
406 # @param theCmpl Compiler option (msvc or gcc)
407 proc OS:MKPRC { theOutDir theIDE theLibType thePlatform theCmpl } {
409 set anOutRoot $theOutDir
410 if { $anOutRoot == "" } {
411 error "Error : \"theOutDir\" is not initialized"
414 # Create output directory
415 set aWokStation "$thePlatform"
416 if { [lsearch -exact {vc7 vc8 vc9 vc10 vc11 vc12 vc14} $theIDE] != -1 } {
417 set aWokStation "msvc"
420 set anOutDir "${anOutRoot}/${aWokStation}/${theIDE}"
422 # read map of already generated GUIDs
423 set aGuidsFilePath [file join $anOutDir "wok_${theIDE}_guids.txt"]
424 if [file exists "$aGuidsFilePath"] {
425 set aFileIn [open "$aGuidsFilePath" r]
426 set aFileDataRaw [read $aFileIn]
428 set aFileData [split $aFileDataRaw "\n"]
429 foreach aLine $aFileData {
430 set aLineSplt [split $aLine "="]
431 if { [llength $aLineSplt] == 2 } {
432 set ::THE_GUIDS_LIST([lindex $aLineSplt 0]) [lindex $aLineSplt 1]
437 # make list of modules and platforms
438 set aModules [OS:init]
439 if { "$thePlatform" == "ios" } {
440 set goaway [list Draw]
441 set aModules [osutils:juststation $goaway $aModules]
444 # generate one solution for all projects if complete OS or VAS is processed
445 set anAllSolution "OCCT"
447 wokUtils:FILES:mkdir $anOutDir
448 if { ![file exists $anOutDir] } {
449 puts stderr "Error: Could not create output directory \"$anOutDir\""
453 # create the out dir if it does not exist
454 if (![file isdirectory $path/inc]) {
455 puts "$path/inc folder does not exists and will be created"
456 wokUtils:FILES:mkdir $path/inc
459 # collect all required header files
460 puts "Collecting required header files into $path/inc ..."
461 osutils:collectinc $aModules $path/inc
463 # Generating project files for the selected IDE
464 switch -exact -- "$theIDE" {
471 "vc14" { OS:MKVC $anOutDir $aModules $anAllSolution $theIDE }
472 "cbp" { OS:MKCBP $anOutDir $aModules $anAllSolution $thePlatform $theCmpl }
474 set ::THE_GUIDS_LIST($::aTKNullKey) "000000000000000000000000"
475 OS:MKXCD $anOutDir $aModules $anAllSolution $theLibType $thePlatform
479 # Store generated GUIDs map
480 set anOutFile [open "$aGuidsFilePath" "w"]
481 fconfigure $anOutFile -translation lf
482 foreach aKey [array names ::THE_GUIDS_LIST] {
483 set aValue $::THE_GUIDS_LIST($aKey)
484 puts $anOutFile "${aKey}=${aValue}"
489 # Function to generate Visual Studio solution and project files
490 proc OS:MKVC { theOutDir {theModules {}} {theAllSolution ""} {theVcVer "vc8"} } {
492 puts stderr "Generating VS project files for $theVcVer"
494 # generate projects for toolkits and separate solution for each module
495 foreach aModule $theModules {
496 OS:vcsolution $theVcVer $aModule $aModule $theOutDir ::THE_GUIDS_LIST
497 OS:vcproj $theVcVer $aModule $theOutDir ::THE_GUIDS_LIST
500 # generate single solution "OCCT" containing projects from all modules
501 if { "$theAllSolution" != "" } {
502 OS:vcsolution $theVcVer $theAllSolution $theModules $theOutDir ::THE_GUIDS_LIST
505 puts "The Visual Studio solution and project files are stored in the $theOutDir directory"
508 proc OS:init {{os {}}} {
512 set os $::tcl_platform(os)
515 if [file exists "$::path/src/VAS/Products.tcl"] {
516 source "$::path/src/VAS/Products.tcl"
517 foreach aModuleIter [VAS:Products] {
518 set aFileTcl "$::path/src/VAS/${aModuleIter}.tcl"
519 if [file exists $aFileTcl] {
521 lappend aModules $aModuleIter
523 puts stderr "Definition file for module $aModuleIter is not found in unit VAS"
529 # Load list of OCCT modules and their definitions
530 source "$::path/src/OS/Modules.tcl"
531 foreach aModuleIter [OS:Modules] {
532 set aFileTcl "$::path/src/OS/${aModuleIter}.tcl"
533 if [file exists $aFileTcl] {
535 lappend aModules $aModuleIter
537 puts stderr "Definition file for module $aModuleIter is not found in unit OS"
544 # topological sort. returns a list { {a h} {b g} {c f} {c h} {d i} } => { d a b c i g f h }
545 proc wokUtils:EASY:tsort { listofpairs } {
546 foreach x $listofpairs {
549 if ![info exists pcnt($e1)] {
552 if ![ info exists pcnt($e2)] {
557 if ![info exists scnt($e1)] {
563 if [info exists slist($e1)] {
571 foreach node [array names pcnt] {
573 if { $pcnt($node) == 0 } {
577 if ![info exists scnt($node)] {
582 for {set front 1} { $front <= $back } { incr front } {
583 lappend res [set node $q($front)]
584 for {set i 1} {$i <= $scnt($node) } { incr i } {
586 set j [expr {$i - 1}]
587 set u [expr { $pcnt([lindex $ll $j]) - 1 }]
588 if { [set pcnt([lindex $ll $j]) $u] == 0 } {
590 set q($back) [lindex $ll $j]
594 if { $back != $nodecnt } {
595 puts stderr "input contains a cycle"
602 proc wokUtils:LIST:Purge { l } {
605 if ![info exist tab($e)] {
613 # Read file pointed to by path
615 # 2. trim = 1 plusieurs blancs => 1 seul blanc
616 # 3. purge= not yet implemented.
617 # 4. emptl= dont process blank lines
618 proc wokUtils:FILES:FileToList { path {sort 0} {trim 0} {purge 0} {emptl 1} } {
619 if ![ catch { set id [ open $path r ] } ] {
621 while {[gets $id line] >= 0 } {
623 regsub -all {[ ]+} $line " " line
626 if { [string length ${line}] != 0 } {
644 # retorn the list of executables in module.
645 proc OS:executable { module } {
647 foreach XXX [${module}:ressources] {
648 if { "[lindex $XXX 1]" == "x" } {
649 lappend lret [lindex $XXX 2]
655 # Topological sort of toolkits in tklm
656 proc osutils:tk:sort { tklm } {
658 foreach tkloc $tklm {
659 set lprg [wokUtils:LIST:Purge [osutils:tk:close $tkloc]]
661 if { [lsearch $tklm $tkx] != -1 } {
662 lappend tkby2 [list $tkx $tkloc]
664 lappend tkby2 [list $tkloc {}]
669 foreach e [wokUtils:EASY:tsort $tkby2] {
677 # close dependencies of ltk. (full wok pathes of toolkits)
678 # The CURRENT WOK LOCATION MUST contains ALL TOOLKITS required.
679 # (locate not performed.)
680 proc osutils:tk:close { ltk } {
684 set ids [LibToLink $dir]
685 # puts "osutils:tk:close($ltk) ids='$ids'"
686 set eated [osutils:tk:eatpk $ids]
687 set result [concat $result $eated]
688 set ids [LibToLink $dir]
689 set result [concat $result $ids]
691 foreach file $eated {
692 set kds [osutils:findSrcSubPath "$file/EXTERNLIB"]
693 if { [osutils:tk:eatpk $kds] != {} } {
694 lappend recurse $file
698 if { $recurse != {} } {
699 set result [concat $result [osutils:tk:close $recurse]]
704 proc osutils:tk:eatpk { EXTERNLIB } {
705 set l [wokUtils:FILES:FileToList $EXTERNLIB]
708 if ![regexp -- {(CSF_[^ ]*)} $str csf] {
714 # Define libraries to link using only EXTERNLIB file
716 proc LibToLink {theTKit} {
717 regexp {^.*:([^:]+)$} $theTKit dummy theTKit
718 set type [_get_type $theTKit]
719 if {$type != "t" && $type != "x"} {
723 set anExtLibList [osutils:tk:eatpk [osutils:findSrcSubPath "$theTKit/EXTERNLIB"]]
724 foreach anExtLib $anExtLibList {
725 set aFullPath [LocateRecur $anExtLib]
726 if { "$aFullPath" != "" && [_get_type $anExtLib] == "t" } {
727 lappend aToolkits $anExtLib
732 # Search unit recursively
734 proc LocateRecur {theName} {
735 set theNamePath [osutils:findSrcSubPath "$theName"]
736 if {[file isdirectory $theNamePath]} {
742 proc OS:genGUID { {theIDE "vc"} } {
743 if { "$theIDE" == "vc" } {
744 set p1 "[format %07X [expr { int(rand() * 268435456) }]][format %X [expr { int(rand() * 16) }]]"
745 set p2 "[format %04X [expr { int(rand() * 6536) }]]"
746 set p3 "[format %04X [expr { int(rand() * 6536) }]]"
747 set p4 "[format %04X [expr { int(rand() * 6536) }]]"
748 set p5 "[format %06X [expr { int(rand() * 16777216) }]][format %06X [expr { int(rand() * 16777216) }]]"
749 return "{$p1-$p2-$p3-$p4-$p5}"
751 set p1 "[format %04X [expr { int(rand() * 6536) }]]"
752 set p2 "[format %04X [expr { int(rand() * 6536) }]]"
753 set p3 "[format %04X [expr { int(rand() * 6536) }]]"
754 set p4 "[format %04X [expr { int(rand() * 6536) }]]"
755 set p5 "[format %04X [expr { int(rand() * 6536) }]]"
756 set p6 "[format %04X [expr { int(rand() * 6536) }]]"
757 return "$p1$p2$p3$p4$p5$p6"
761 # collect all include file that required for theModules in theOutDir
762 proc osutils:collectinc {theModules theIncPath} {
764 set aCasRoot [file normalize $path]
765 set anIncPath [file normalize $theIncPath]
767 if {![file isdirectory $aCasRoot]} {
768 puts "OCCT directory is not defined correctly: $aCasRoot"
772 set anUsedToolKits {}
773 foreach aModule $theModules {
774 foreach aToolKit [${aModule}:toolkits] {
775 lappend anUsedToolKits $aToolKit
777 foreach aDependency [LibToLink $aToolKit] {
778 lappend anUsedToolKits $aDependency
781 foreach anExecutable [OS:executable ${aModule}] {
782 lappend anUsedToolKits $anExecutable
784 foreach aDependency [LibToLink $anExecutable] {
785 lappend anUsedToolKits $aDependency
789 set anUsedToolKits [lsort -unique $anUsedToolKits]
792 foreach anUsedToolKit $anUsedToolKits {
793 set anUnits [concat $anUnits [osutils:tk:units $anUsedToolKit]]
795 set anUnits [lsort -unique $anUnits]
797 # define copying style
799 if { [info exists ::env(SHORTCUT_HEADERS)] } {
800 if { [string equal -nocase $::env(SHORTCUT_HEADERS) "hard"]
801 || [string equal -nocase $::env(SHORTCUT_HEADERS) "hardlink"] } {
802 set aCopyType "hardlink"
803 } elseif { [string equal -nocase $::env(SHORTCUT_HEADERS) "true"]
804 || [string equal -nocase $::env(SHORTCUT_HEADERS) "shortcut"] } {
805 set aCopyType "shortcut"
809 if { $aCopyType == "shortcut" } {
810 # template preparation
811 if { ![file exists $::THE_CASROOT/adm/templates/header.in] } {
812 puts "template file does not exist: $::THE_CASROOT/adm/templates/header.in"
815 set aHeaderTmpl [wokUtils:FILES:FileToString $::THE_CASROOT/adm/templates/header.in]
817 # relative anIncPath in connection with aCasRoot/src
818 set aFromBuildIncToSrcPath [relativePath "$anIncPath" "$aCasRoot/src"]
820 # create and copy short-cut header files
821 foreach anUnit $anUnits {
822 set aHFiles [glob -nocomplain -dir $aCasRoot/src/$anUnit "*.h"]
823 foreach aHeaderFile [concat [glob -nocomplain -dir $aCasRoot/src/$anUnit "*.\[hgl\]xx"] $aHFiles] {
824 set aHeaderFileName [file tail $aHeaderFile]
826 regsub -all -- {@OCCT_HEADER_FILE_CONTENT@} $aHeaderTmpl "#include \"$aFromBuildIncToSrcPath/$anUnit/$aHeaderFileName\"" aShortCutHeaderFileContent
828 if {[file exists "$theIncPath/$aHeaderFileName"] && [file readable "$theIncPath/$aHeaderFileName"]} {
829 set fp [open "$theIncPath/$aHeaderFileName" r]
830 set aHeaderContent [read $fp]
834 set aHeaderLenght [expr [string length $aHeaderContent] - 1]
836 if {$aHeaderLenght == [string length $aShortCutHeaderFileContent]} {
837 # remove eof from string
838 set aHeaderContent [string range $aHeaderContent 0 [expr $aHeaderLenght - 1]]
840 if {[string compare $aShortCutHeaderFileContent $aHeaderContent] == 0} {
844 file delete -force "$theIncPath/$aHeaderFileName"
847 set aShortCutHeaderFile [open "$theIncPath/$aHeaderFileName" "w"]
848 fconfigure $aShortCutHeaderFile -translation lf
849 puts $aShortCutHeaderFile $aShortCutHeaderFileContent
850 close $aShortCutHeaderFile
855 foreach anUnit $anUnits {
856 set aHFiles [glob -nocomplain -dir $aCasRoot/src/$anUnit "*.h"]
857 foreach aHeaderFile [concat [glob -nocomplain -dir $aCasRoot/src/$anUnit "*.\[hgl\]xx"] $aHFiles] {
858 set aHeaderFileName [file tail $aHeaderFile]
860 # copy file only if target does not exist or is older than original
861 set torig [file mtime $aHeaderFile]
863 if { [file isfile $anIncPath/$aHeaderFileName] } {
864 set tcopy [file mtime $anIncPath/$aHeaderFileName]
866 if { $tcopy < $torig } {
868 if { $aCopyType == "hardlink" } {
870 file delete -force "$theIncPath/$aHeaderFileName"
872 file link -hard $anIncPath/$aHeaderFileName $aHeaderFile
874 file copy -force $aHeaderFile $anIncPath/$aHeaderFileName
876 } elseif { $tcopy != $torig } {
877 puts "Warning: file $anIncPath/$aHeaderFileName is newer than $aHeaderFile, not changed!"
881 puts "Info: $nbcopied files updated"
885 # Generate header for VS solution file
886 proc osutils:vcsolution:header { vcversion } {
887 if { "$vcversion" == "vc7" } {
889 "Microsoft Visual Studio Solution File, Format Version 8.00\n"
890 } elseif { "$vcversion" == "vc8" } {
892 "Microsoft Visual Studio Solution File, Format Version 9.00\n" \
893 "# Visual Studio 2005\n"
894 } elseif { "$vcversion" == "vc9" } {
896 "Microsoft Visual Studio Solution File, Format Version 10.00\n" \
897 "# Visual Studio 2008\n"
898 } elseif { "$vcversion" == "vc10" } {
900 "Microsoft Visual Studio Solution File, Format Version 11.00\n" \
901 "# Visual Studio 2010\n"
902 } elseif { "$vcversion" == "vc11" } {
904 "Microsoft Visual Studio Solution File, Format Version 12.00\n" \
905 "# Visual Studio 2012\n"
906 } elseif { "$vcversion" == "vc12" } {
908 "Microsoft Visual Studio Solution File, Format Version 13.00\n" \
909 "# Visual Studio 2013\n"
910 } elseif { "$vcversion" == "vc14" } {
912 "Microsoft Visual Studio Solution File, Format Version 12.00\n" \
913 "# Visual Studio 14\n"
915 puts stderr "Error: Visual Studio version $vcversion is not supported by this function!"
919 # Returns extension (without dot) for project files of given version of VC
921 proc osutils:vcproj:ext { vcversion } {
922 if { "$vcversion" == "vc7" || "$vcversion" == "vc8" || "$vcversion" == "vc9" } {
928 # Generate start of configuration section of VS solution file
930 proc osutils:vcsolution:config:begin { vcversion } {
931 if { "$vcversion" == "vc7" } {
934 "\tGlobalSection(SolutionConfiguration) = preSolution\n" \
935 "\t\tDebug = Debug\n" \
936 "\t\tRelease = Release\n" \
937 "\tEndGlobalSection\n" \
938 "\tGlobalSection(ProjectConfiguration) = postSolution\n"
942 "\tGlobalSection(SolutionConfigurationPlatforms) = preSolution\n" \
943 "\t\tDebug|Win32 = Debug|Win32\n" \
944 "\t\tRelease|Win32 = Release|Win32\n" \
945 "\t\tDebug|x64 = Debug|x64\n" \
946 "\t\tRelease|x64 = Release|x64\n" \
947 "\tEndGlobalSection\n" \
948 "\tGlobalSection(ProjectConfigurationPlatforms) = postSolution\n"
952 # Generate part of configuration section of VS solution file describing one project
954 proc osutils:vcsolution:config:project { vcversion guid } {
955 if { "$vcversion" == "vc7" } {
957 "\t\t$guid.Debug.ActiveCfg = Debug|Win32\n" \
958 "\t\t$guid.Debug.Build.0 = Debug|Win32\n" \
959 "\t\t$guid.Release.ActiveCfg = Release|Win32\n" \
960 "\t\t$guid.Release.Build.0 = Release|Win32\n"
963 "\t\t$guid.Debug|Win32.ActiveCfg = Debug|Win32\n" \
964 "\t\t$guid.Debug|Win32.Build.0 = Debug|Win32\n" \
965 "\t\t$guid.Release|Win32.ActiveCfg = Release|Win32\n" \
966 "\t\t$guid.Release|Win32.Build.0 = Release|Win32\n" \
967 "\t\t$guid.Debug|x64.ActiveCfg = Debug|x64\n" \
968 "\t\t$guid.Debug|x64.Build.0 = Debug|x64\n" \
969 "\t\t$guid.Release|x64.ActiveCfg = Release|x64\n" \
970 "\t\t$guid.Release|x64.Build.0 = Release|x64\n"
974 # Generate start of configuration section of VS solution file
976 proc osutils:vcsolution:config:end { vcversion } {
977 if { "$vcversion" == "vc7" } {
979 "\tEndGlobalSection\n" \
980 "\tGlobalSection(ExtensibilityGlobals) = postSolution\n" \
981 "\tEndGlobalSection\n" \
982 "\tGlobalSection(ExtensibilityAddIns) = postSolution\n" \
983 "\tEndGlobalSection\n"
986 "\tEndGlobalSection\n" \
987 "\tGlobalSection(SolutionProperties) = preSolution\n" \
988 "\t\tHideSolutionNode = FALSE\n" \
989 "\tEndGlobalSection\n"
993 # generate Visual Studio solution file
994 # if module is empty, generates one solution for all known modules
996 proc OS:vcsolution { theVcVer theSolName theModules theOutDir theGuidsMap } {
998 upvar $theGuidsMap aGuidsMap
1000 # collect list of projects to be created
1002 set aDependencies {}
1003 foreach aModule $theModules {
1005 foreach aToolKit [osutils:tk:sort [${aModule}:toolkits]] {
1006 lappend aProjects $aToolKit
1007 lappend aProjectsInModule($aModule) $aToolKit
1008 lappend aDependencies [LibToLink $aToolKit]
1010 # executables, assume one project per cxx file...
1011 foreach aUnit [OS:executable ${aModule}] {
1013 set src_files [_get_used_files $aUnit false]
1015 foreach s $src_files {
1016 regexp {source ([^\s]+)} $s dummy name
1017 lappend aSrcFiles $name
1019 foreach aSrcFile $aSrcFiles {
1020 set aFileExtension [file extension $aSrcFile]
1021 if { $aFileExtension == ".cxx" } {
1022 set aPrjName [file rootname $aSrcFile]
1023 lappend aProjects $aPrjName
1024 lappend aProjectsInModule($aModule) $aPrjName
1025 if {[file isdirectory $path/src/$aUnitLoc]} {
1026 lappend aDependencies [LibToLinkX $aUnitLoc [file rootname $aSrcFile]]
1028 lappend aDependencies {}
1035 # generate GUIDs for projects (unless already known)
1036 foreach aProject $aProjects {
1037 if { ! [info exists aGuidsMap($aProject)] } {
1038 set aGuidsMap($aProject) [OS:genGUID]
1042 # generate solution file
1043 # puts "Generating Visual Studio ($theVcVer) solution file for $theSolName ($aProjects)"
1044 append aFileBuff [osutils:vcsolution:header $theVcVer]
1046 # GUID identifying group projects in Visual Studio
1047 set VC_GROUP_GUID "{2150E333-8FDC-42A3-9474-1A3956D46DE8}"
1049 # generate group projects -- one per module
1050 if { "$theVcVer" != "vc7" && [llength "$theModules"] > 1 } {
1051 foreach aModule $theModules {
1052 if { ! [info exists aGuidsMap(_$aModule)] } {
1053 set aGuidsMap(_$aModule) [OS:genGUID]
1055 set aGuid $aGuidsMap(_$aModule)
1056 append aFileBuff "Project(\"${VC_GROUP_GUID}\") = \"$aModule\", \"$aModule\", \"$aGuid\"\nEndProject\n"
1060 # extension of project files
1061 set aProjExt [osutils:vcproj:ext $theVcVer]
1063 # GUID identifying C++ projects in Visual Studio
1064 set VC_CPP_GUID "{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}"
1066 # generate normal projects
1067 set aProjsNb [llength $aProjects]
1068 for {set aProjId 0} {$aProjId < $aProjsNb} {incr aProjId} {
1069 set aProj [lindex $aProjects $aProjId]
1070 set aGuid $aGuidsMap($aProj)
1071 append aFileBuff "Project(\"${VC_CPP_GUID}\") = \"$aProj\", \"$aProj.${aProjExt}\", \"$aGuid\"\n"
1072 # write projects dependencies information (vc7 to vc9)
1074 foreach aDepLib [lindex $aDependencies $aProjId] {
1075 if { $aDepLib != $aProj && [lsearch $aProjects $aDepLib] != "-1" } {
1076 set depGUID $aGuidsMap($aDepLib)
1077 append aDepGuids "\t\t$depGUID = $depGUID\n"
1080 if { "$aDepGuids" != "" } {
1081 append aFileBuff "\tProjectSection(ProjectDependencies) = postProject\n"
1082 append aFileBuff "$aDepGuids"
1083 append aFileBuff "\tEndProjectSection\n"
1085 append aFileBuff "EndProject\n"
1088 # generate configuration section
1089 append aFileBuff [osutils:vcsolution:config:begin $theVcVer]
1090 foreach aProj $aProjects {
1091 append aFileBuff [osutils:vcsolution:config:project $theVcVer $aGuidsMap($aProj)]
1093 append aFileBuff [osutils:vcsolution:config:end $theVcVer]
1095 # write information of grouping of projects by module
1096 if { "$theVcVer" != "vc7" && [llength "$theModules"] > 1 } {
1097 append aFileBuff " GlobalSection(NestedProjects) = preSolution\n"
1098 foreach aModule $theModules {
1099 if { ! [info exists aProjectsInModule($aModule)] } { continue }
1100 foreach aProject $aProjectsInModule($aModule) {
1101 append aFileBuff " $aGuidsMap($aProject) = $aGuidsMap(_$aModule)\n"
1104 append aFileBuff " EndGlobalSection\n"
1107 # final word (footer)
1108 append aFileBuff "EndGlobal"
1111 set aFile [open [set fdsw [file join $theOutDir ${theSolName}.sln]] w]
1112 fconfigure $aFile -translation crlf
1113 puts $aFile $aFileBuff
1115 return [file join $theOutDir ${theSolName}.sln]
1117 # Generate Visual Studio projects for specified version
1119 proc OS:vcproj { theVcVer theModules theOutDir theGuidsMap } {
1120 upvar $theGuidsMap aGuidsMap
1122 set aProjectFiles {}
1124 foreach aModule $theModules {
1125 foreach aToolKit [${aModule}:toolkits] {
1126 lappend aProjectFiles [osutils:vcproj $theVcVer $theOutDir $aToolKit aGuidsMap]
1128 foreach anExecutable [OS:executable ${aModule}] {
1129 lappend aProjectFiles [osutils:vcprojx $theVcVer $theOutDir $anExecutable aGuidsMap]
1132 return $aProjectFiles
1134 # generate template name and load it for given version of Visual Studio and platform
1136 proc osutils:vcproj:readtemplate {theVcVer isexec} {
1138 if { "$theVcVer" != "vc7" && "$theVcVer" != "vc8" && "$theVcVer" != "vc9" } {
1142 set what "$theVcVer"
1143 set aVerExt [string range $theVcVer 2 end]
1144 set aVerExt "v${aVerExt}0"
1148 set anExt "${anExt}x"
1149 set what "$what executable"
1151 if { "$theVcVer" == "vc10" } {
1152 # SSE2 is enabled by default in vc11+, but not in vc10 for 32-bit target
1153 set aCmpl32 "\n <EnableEnhancedInstructionSet>StreamingSIMDExtensions2</EnableEnhancedInstructionSet>"
1155 set aTmpl [osutils:readtemplate $anExt "MS VC++ project ($what)"]
1156 regsub -all -- {__VCVER__} $aTmpl $theVcVer aTmpl
1157 regsub -all -- {__VCVEREXT__} $aTmpl $aVerExt aTmpl
1158 regsub -all -- {__VCMPL32__} $aTmpl $aCmpl32 aTmpl
1159 regsub -all -- {__VCMPL64__} $aTmpl $aCmpl64 aTmpl
1163 proc osutils:readtemplate {ext what} {
1164 set loc "$::THE_CASROOT/adm/templates/template.$ext"
1165 return [wokUtils:FILES:FileToString $loc]
1167 # Read a file in a string as is.
1169 proc wokUtils:FILES:FileToString { fin } {
1170 if { [catch { set in [ open $fin r ] } errin] == 0 } {
1171 set strin [read $in [file size $fin]]
1179 # List extensions of compilable files in OCCT
1180 proc osutils:compilable {thePlatform} {
1181 if { "$thePlatform" == "mac" || "$thePlatform" == "ios" } {
1182 return [list .c .cxx .cpp .mm]
1184 return [list .c .cxx .cpp]
1187 proc osutils:commonUsedTK { theToolKit } {
1188 set anUsedToolKits [list]
1189 set aDepToolkits [LibToLink $theToolKit]
1190 foreach tkx $aDepToolkits {
1191 if {[_get_type $tkx] == "t"} {
1192 lappend anUsedToolKits "${tkx}"
1195 return $anUsedToolKits
1198 # Return the list of name *CSF_ in a EXTERNLIB description of a toolkit
1199 proc osutils:tk:csfInExternlib { EXTERNLIB } {
1200 set l [wokUtils:FILES:FileToList $EXTERNLIB]
1203 if [regexp -- {(CSF_[^ ]*)} $str csf] {
1210 # Collect dependencies map depending on target OS (libraries for CSF_ codenames used in EXTERNLIB) .
1211 # @param theOS - target OS
1212 # @param theCsfLibsMap - libraries map
1213 # @param theCsfFrmsMap - frameworks map, OS X specific
1214 proc osutils:csfList { theOS theCsfLibsMap theCsfFrmsMap } {
1215 upvar $theCsfLibsMap aLibsMap
1216 upvar $theCsfFrmsMap aFrmsMap
1221 set aLibsMap(CSF_FREETYPE) "freetype"
1222 set aLibsMap(CSF_TclLibs) "tcl8.6"
1223 set aLibsMap(CSF_TclTkLibs) "tk8.6"
1224 if { "$::HAVE_FREEIMAGE" == "true" } {
1225 if { "$theOS" == "wnt" } {
1226 set aLibsMap(CSF_FreeImagePlus) "FreeImage"
1228 set aLibsMap(CSF_FreeImagePlus) "freeimage"
1231 if { "$::HAVE_GL2PS" == "true" } {
1232 set aLibsMap(CSF_GL2PS) "gl2ps"
1234 if { "$::HAVE_TBB" == "true" } {
1235 set aLibsMap(CSF_TBB) "tbb tbbmalloc"
1237 if { "$::HAVE_VTK" == "true" } {
1238 if { "$theOS" == "wnt" } {
1239 set aLibsMap(CSF_VTK) [osutils:vtkCsf "wnt"]
1241 set aLibsMap(CSF_VTK) [osutils:vtkCsf "unix"]
1245 if { "$theOS" == "wnt" } {
1247 set aLibsMap(CSF_kernel32) "kernel32"
1248 set aLibsMap(CSF_advapi32) "advapi32"
1249 set aLibsMap(CSF_gdi32) "gdi32"
1250 set aLibsMap(CSF_user32) "user32 comdlg32"
1251 set aLibsMap(CSF_opengl32) "opengl32"
1252 set aLibsMap(CSF_wsock32) "wsock32"
1253 set aLibsMap(CSF_netapi32) "netapi32"
1254 set aLibsMap(CSF_AviLibs) "ws2_32 vfw32"
1255 set aLibsMap(CSF_OpenGlLibs) "opengl32"
1256 if { "$::HAVE_GLES2" == "true" } {
1257 set aLibsMap(CSF_OpenGlLibs) "libEGL libGLESv2"
1259 set aLibsMap(CSF_psapi) "Psapi"
1260 set aLibsMap(CSF_d3d9) "d3d9"
1262 # the naming is different on Windows
1263 set aLibsMap(CSF_TclLibs) "tcl86"
1264 set aLibsMap(CSF_TclTkLibs) "tk86"
1266 set aLibsMap(CSF_QT) "QtCore4 QtGui4"
1268 # tbb headers define different pragma lib depending on debug/release
1269 set aLibsMap(CSF_TBB) ""
1271 if { "$theOS" == "mac" } {
1272 set aLibsMap(CSF_objc) "objc"
1273 set aFrmsMap(CSF_Appkit) "Appkit"
1274 set aFrmsMap(CSF_IOKit) "IOKit"
1275 set aFrmsMap(CSF_OpenGlLibs) "OpenGL"
1276 set aFrmsMap(CSF_TclLibs) "Tcl"
1277 set aLibsMap(CSF_TclLibs) ""
1278 set aFrmsMap(CSF_TclTkLibs) "Tk"
1279 set aLibsMap(CSF_TclTkLibs) ""
1281 if { "$theOS" == "qnx" } {
1282 # CSF_ThreadLibs - pthread API is part of libc on QNX
1283 set aLibsMap(CSF_OpenGlLibs) "EGL GLESv2"
1285 set aLibsMap(CSF_ThreadLibs) "pthread rt"
1286 set aLibsMap(CSF_OpenGlLibs) "GL"
1287 set aLibsMap(CSF_TclTkLibs) "X11 tk8.6"
1288 set aLibsMap(CSF_XwLibs) "X11 Xext Xmu Xi"
1289 set aLibsMap(CSF_MotifLibs) "X11"
1292 if { "$::HAVE_GLES2" == "true" } {
1293 set aLibsMap(CSF_OpenGlLibs) "EGL GLESv2"
1299 # Returns string of library dependencies for generation of Visual Studio project or make lists.
1300 proc osutils:vtkCsf {{theOS ""}} {
1303 set aPathSplitter ":"
1304 if {"$theOS" == "wnt"} {
1305 set aPathSplitter ";"
1308 set anOptIncs [split $::env(CSF_OPT_INC) "$aPathSplitter"]
1309 foreach anIncItem $anOptIncs {
1310 if {[regexp -- "vtk-(.*)$" [file tail $anIncItem] dummy aFoundVtkVer]} {
1311 set aVtkVer $aFoundVtkVer
1315 set aLibArray [list vtkCommonCore vtkCommonDataModel vtkCommonExecutionModel vtkCommonMath vtkCommonTransforms vtkRenderingCore \
1316 vtkRenderingOpenGL vtkFiltersGeneral vtkIOCore vtkIOImage vtkImagingCore vtkInteractionStyle]
1318 # Additional suffices for the libraries
1320 foreach anItem $aLibArray {
1321 lset aLibArray $anIdx $anItem-$aVtkVer
1325 return [join $aLibArray " "]
1328 # @param theLibsList - dependencies (libraries list)
1329 # @param theFrameworks - dependencies (frameworks list, OS X specific)
1330 proc osutils:usedOsLibs { theToolKit theOS theLibsList theFrameworks } {
1332 upvar $theLibsList aLibsList
1333 upvar $theFrameworks aFrameworks
1334 set aLibsList [list]
1335 set aFrameworks [list]
1337 osutils:csfList $theOS aLibsMap aFrmsMap
1339 foreach aCsfElem [osutils:tk:csfInExternlib "$path/src/${theToolKit}/EXTERNLIB"] {
1340 if [info exists aLibsMap($aCsfElem)] {
1341 foreach aLib [split "$aLibsMap($aCsfElem)"] {
1342 if { [lsearch $aLibsList $aLib] == "-1" } {
1343 lappend aLibsList $aLib
1347 if [info exists aFrmsMap($aCsfElem)] {
1348 foreach aFrm [split "$aFrmsMap($aCsfElem)"] {
1349 if { [lsearch $aFrameworks $aFrm] == "-1" } {
1350 lappend aFrameworks $aFrm
1357 # Returns liste of UD in a toolkit. tkloc is a full path wok.
1358 proc osutils:tk:units { tkloc } {
1361 set PACKAGES "$path/src/$tkloc/PACKAGES"
1362 foreach u [wokUtils:FILES:FileToList $PACKAGES] {
1363 if {[file isdirectory "$path/src/$u"]} {
1368 ;#puts stderr "Warning. No devunit included in $tkloc"
1373 proc osutils:justwnt { listloc } {
1374 # ImageUtility is required for support for old (<6.5.4) versions of OCCT
1375 set goaway [list Xdps Xw ImageUtility WOKUnix]
1376 return [osutils:juststation $goaway $listloc]
1379 # remove from listloc OpenCascade units indesirables on NT
1380 proc osutils:juststation {goaway listloc} {
1383 foreach u $listloc {
1384 if {([file isdirectory "$path/src/$u"] && [lsearch $goaway $u] == -1 )
1385 || (![file isdirectory "$path/src/$u"] && [lsearch $goaway $u] == -1 ) } {
1392 # intersect3 - perform the intersecting of two lists, returning a list containing three lists.
1393 # The first list is everything in the first list that wasn't in the second,
1394 # the second list contains the intersection of the two lists, the third list contains everything
1395 # in the second list that wasn't in the first.
1396 proc osutils:intersect3 {list1 list2} {
1397 set la1(0) {} ; unset la1(0)
1398 set lai(0) {} ; unset lai(0)
1399 set la2(0) {} ; unset la2(0)
1406 foreach elem [concat $list1 $list2] {
1407 if {[info exists la1($elem)] && [info exists la2($elem)]} {
1413 list [lsort [array names la1]] [lsort [array names lai]] [lsort [array names la2]]
1416 # Prepare relative path
1417 proc relativePath {thePathFrom thePathTo} {
1418 if { [file isdirectory "$thePathFrom"] == 0 } {
1422 set aPathFrom [file normalize "$thePathFrom"]
1423 set aPathTo [file normalize "$thePathTo"]
1425 set aCutedPathFrom "${aPathFrom}/dummy"
1426 set aRelatedDeepPath ""
1428 while { "$aCutedPathFrom" != [file normalize "$aCutedPathFrom/.."] } {
1429 set aCutedPathFrom [file normalize "$aCutedPathFrom/.."]
1430 # does aPathTo contain aCutedPathFrom?
1431 regsub -all $aCutedPathFrom $aPathTo "" aPathFromAfterCut
1432 if { "$aPathFromAfterCut" != "$aPathTo" } { # if so
1433 if { "$aCutedPathFrom" == "$aPathFrom" } { # just go higher, for example, ./somefolder/someotherfolder
1434 set aPathTo ".${aPathTo}"
1435 } elseif { "$aCutedPathFrom" == "$aPathTo" } { # remove the last "/"
1436 set aRelatedDeepPath [string replace $aRelatedDeepPath end end ""]
1438 regsub -all $aCutedPathFrom $aPathTo $aRelatedDeepPath aPathToAfterCut
1439 regsub -all "//" $aPathToAfterCut "/" aPathToAfterCut
1440 return $aPathToAfterCut
1442 set aRelatedDeepPath "$aRelatedDeepPath../"
1449 proc wokUtils:EASY:bs1 { s } {
1450 regsub -all {/} $s {\\} r
1454 # Returs for a full path the liste of n last directory part
1456 # n = 2 => dir/file.c
1457 # n = 3 => sdir/dir/file.c
1459 proc wokUtils:FILES:wtail { f n } {
1460 set ll [expr [llength [set lif [file split $f]]] -$n]
1461 return [join [lrange $lif $ll end] /]
1464 # Generate entry for one source file in Visual Studio 10 project file
1465 proc osutils:vcxproj:file { vcversion file params } {
1466 append text " <ClCompile Include=\"..\\..\\..\\[wokUtils:EASY:bs1 [wokUtils:FILES:wtail $file 3]]\">\n"
1467 if { $params != "" } {
1468 append text " <AdditionalOptions Condition=\"\'\$(Configuration)|\$(Platform)\'==\'Debug|Win32\'\">[string trim ${params}] %(AdditionalOptions)</AdditionalOptions>\n"
1471 if { $params != "" } {
1472 append text " <AdditionalOptions Condition=\"\'\$(Configuration)|\$(Platform)\'==\'Release|Win32\'\">[string trim ${params}] %(AdditionalOptions)</AdditionalOptions>\n"
1475 if { $params != "" } {
1476 append text " <AdditionalOptions Condition=\"\'\$(Configuration)|\$(Platform)\'==\'Debug|x64\'\">[string trim ${params}] %(AdditionalOptions)</AdditionalOptions>\n"
1479 if { $params != "" } {
1480 append text " <AdditionalOptions Condition=\"\'\$(Configuration)|\$(Platform)\'==\'Release|x64\'\">[string trim ${params}] %(AdditionalOptions)</AdditionalOptions>\n"
1483 append text " </ClCompile>\n"
1487 # Generate Visual Studio 2010 project filters file
1488 proc osutils:vcxproj:filters { dir proj theFilesMap } {
1489 upvar $theFilesMap aFilesMap
1492 append text "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
1493 append text "<Project ToolsVersion=\"4.0\" xmlns=\"http://schemas.microsoft.com/developer/msbuild/2003\">\n"
1495 # list of "filters" (units)
1496 append text " <ItemGroup>\n"
1497 append text " <Filter Include=\"Source files\">\n"
1498 append text " <UniqueIdentifier>[OS:genGUID]</UniqueIdentifier>\n"
1499 append text " </Filter>\n"
1500 foreach unit $aFilesMap(units) {
1501 append text " <Filter Include=\"Source files\\${unit}\">\n"
1502 append text " <UniqueIdentifier>[OS:genGUID]</UniqueIdentifier>\n"
1503 append text " </Filter>\n"
1505 append text " </ItemGroup>\n"
1508 append text " <ItemGroup>\n"
1509 foreach unit $aFilesMap(units) {
1510 foreach file $aFilesMap($unit) {
1511 append text " <ClCompile Include=\"..\\..\\..\\[wokUtils:EASY:bs1 [wokUtils:FILES:wtail $file 3]]\">\n"
1512 append text " <Filter>Source files\\${unit}</Filter>\n"
1513 append text " </ClCompile>\n"
1516 append text " </ItemGroup>\n"
1519 append text "</Project>"
1522 set fp [open [set fvcproj [file join $dir ${proj}.vcxproj.filters]] w]
1523 fconfigure $fp -translation crlf
1527 return ${proj}.vcxproj.filters
1530 # Generate Visual Studio 2011 project filters file
1531 proc osutils:vcx1proj:filters { dir proj theFilesMap } {
1532 upvar $theFilesMap aFilesMap
1535 append text "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
1536 append text "<Project ToolsVersion=\"4.0\" xmlns=\"http://schemas.microsoft.com/developer/msbuild/2003\">\n"
1538 # list of "filters" (units)
1539 append text " <ItemGroup>\n"
1540 append text " <Filter Include=\"Source files\">\n"
1541 append text " <UniqueIdentifier>[OS:genGUID]</UniqueIdentifier>\n"
1542 append text " </Filter>\n"
1543 foreach unit $aFilesMap(units) {
1544 append text " <Filter Include=\"Source files\\${unit}\">\n"
1545 append text " <UniqueIdentifier>[OS:genGUID]</UniqueIdentifier>\n"
1546 append text " </Filter>\n"
1548 append text " </ItemGroup>\n"
1551 append text " <ItemGroup>\n"
1552 foreach unit $aFilesMap(units) {
1553 foreach file $aFilesMap($unit) {
1554 append text " <ClCompile Include=\"..\\..\\..\\[wokUtils:EASY:bs1 [wokUtils:FILES:wtail $file 3]]\">\n"
1555 append text " <Filter>Source files\\${unit}</Filter>\n"
1556 append text " </ClCompile>\n"
1559 append text " </ItemGroup>\n"
1561 append text " <ItemGroup>\n"
1562 append text " <ResourceCompile Include=\"${proj}.rc\" />"
1563 append text " </ItemGroup>\n"
1566 append text "</Project>"
1569 set fp [open [set fvcproj [file join $dir ${proj}.vcxproj.filters]] w]
1570 fconfigure $fp -translation crlf
1574 return ${proj}.vcxproj.filters
1577 # Generate RC file content for ToolKit from template
1578 proc osutils:readtemplate:rc {theOutDir theToolKit} {
1579 set aLoc "$::THE_CASROOT/adm/templates/template_dll.rc"
1580 set aBody [wokUtils:FILES:FileToString $aLoc]
1581 regsub -all -- {__TKNAM__} $aBody $theToolKit aBody
1583 set aFile [open "${theOutDir}/${theToolKit}.rc" "w"]
1584 fconfigure $aFile -translation lf
1587 return "${theOutDir}/${theToolKit}.rc"
1590 # Generate Visual Studio project file for ToolKit
1591 proc osutils:vcproj { theVcVer theOutDir theToolKit theGuidsMap {theProjTmpl {} } } {
1592 if { $theProjTmpl == {} } {set theProjTmpl [osutils:vcproj:readtemplate $theVcVer 0]}
1594 set l_compilable [osutils:compilable wnt]
1595 regsub -all -- {__TKNAM__} $theProjTmpl $theToolKit theProjTmpl
1597 upvar $theGuidsMap aGuidsMap
1598 if { ! [info exists aGuidsMap($theToolKit)] } {
1599 set aGuidsMap($theToolKit) [OS:genGUID]
1601 regsub -all -- {__PROJECT_GUID__} $theProjTmpl $aGuidsMap($theToolKit) theProjTmpl
1603 set aUsedLibs [list]
1604 foreach tkx [osutils:commonUsedTK $theToolKit] {
1605 lappend aUsedLibs "${tkx}.lib"
1608 osutils:usedOsLibs $theToolKit "wnt" aLibs aFrameworks
1609 foreach aLibIter $aLibs {
1610 lappend aUsedLibs "${aLibIter}.lib"
1613 # correct names of referred third-party libraries that are named with suffix
1614 # depending on VC version
1615 regsub -all -- {vc[0-9]+} $aUsedLibs $theVcVer aUsedLibs
1617 # and put this list to project file
1618 #puts "$theToolKit requires $aUsedLibs"
1619 if { "$theVcVer" != "vc7" && "$theVcVer" != "vc8" && "$theVcVer" != "vc9" } {
1620 set aUsedLibs [join $aUsedLibs {;}]
1622 regsub -all -- {__TKDEP__} $theProjTmpl $aUsedLibs theProjTmpl
1624 set anIncPaths "..\\..\\..\\inc"
1626 set aFilesSection ""
1627 set aVcFilesX(units) ""
1628 set listloc [osutils:tk:units $theToolKit]
1629 set resultloc [osutils:justwnt $listloc]
1630 if [array exists written] { unset written }
1631 #puts "\t1 [wokparam -v %CMPLRS_CXX_Options [w_info -f]] father"
1632 #puts "\t2 [wokparam -v %CMPLRS_CXX_Options] branch"
1633 #puts "\t1 [wokparam -v %CMPLRS_C_Options [w_info -f]] father"
1634 #puts "\t2 [wokparam -v %CMPLRS_C_Options] branch"
1635 set fxloparamfcxx [lindex [osutils:intersect3 [_get_options wnt cmplrs_cxx f] [_get_options wnt cmplrs_cxx b]] 2]
1636 set fxloparamfc [lindex [osutils:intersect3 [_get_options wnt cmplrs_c f] [_get_options wnt cmplrs_c b]] 2]
1638 foreach fxlo $resultloc {
1640 set aSrcFiles [osutils:tk:files $xlo wnt]
1641 set fxlo_cmplrs_options_cxx [_get_options wnt cmplrs_cxx $fxlo]
1642 if {$fxlo_cmplrs_options_cxx == ""} {
1643 set fxlo_cmplrs_options_cxx [_get_options wnt cmplrs_cxx b]
1645 set fxlo_cmplrs_options_c [_get_options wnt cmplrs_c $fxlo]
1646 if {$fxlo_cmplrs_options_c == ""} {
1647 set fxlo_cmplrs_options_c [_get_options wnt cmplrs_c b]
1649 set fxloparam "$fxloparam [lindex [osutils:intersect3 [_get_options wnt cmplrs_cxx b] $fxlo_cmplrs_options_cxx] 2]"
1650 set fxloparam "$fxloparam [lindex [osutils:intersect3 [_get_options wnt cmplrs_c b] $fxlo_cmplrs_options_c] 2]"
1651 #puts "\t3 [wokparam -v %CMPLRS_CXX_Options] branch CXX "
1652 #puts "\t4 [wokparam -v %CMPLRS_CXX_Options $fxlo] $fxlo CXX"
1653 #puts "\t5 [wokparam -v %CMPLRS_C_Options] branch C"
1654 #puts "\t6 [wokparam -v %CMPLRS_C_Options $fxlo] $fxlo C"
1656 foreach partopt $fxloparam {
1657 if {[string first "-I" $partopt] == "0"} {
1658 # this is an additional includes search path
1661 set needparam "$needparam $partopt"
1664 # Format of projects in vc10+ is different from vc7-9
1665 if { "$theVcVer" != "vc7" && "$theVcVer" != "vc8" && "$theVcVer" != "vc9" } {
1666 foreach aSrcFile [lsort $aSrcFiles] {
1667 if { ![info exists written([file tail $aSrcFile])] } {
1668 set written([file tail $aSrcFile]) 1
1669 append aFilesSection [osutils:vcxproj:file $theVcVer $aSrcFile $needparam]
1671 puts "Warning : in vcproj more than one occurences for [file tail $aSrcFile]"
1673 if { ! [info exists aVcFilesX($xlo)] } { lappend aVcFilesX(units) $xlo }
1674 lappend aVcFilesX($xlo) $aSrcFile
1677 append aFilesSection "\t\t\t<Filter\n"
1678 append aFilesSection "\t\t\t\tName=\"${xlo}\"\n"
1679 append aFilesSection "\t\t\t\t>\n"
1680 foreach aSrcFile [lsort $aSrcFiles] {
1681 if { ![info exists written([file tail $aSrcFile])] } {
1682 set written([file tail $aSrcFile]) 1
1683 append aFilesSection [osutils:vcproj:file $theVcVer $aSrcFile $needparam]
1685 puts "Warning : in vcproj more than one occurences for [file tail $aSrcFile]"
1688 append aFilesSection "\t\t\t</Filter>\n"
1692 append aTKDefines ";__${xlo}_DLL"
1694 # append anIncPaths ";..\\..\\..\\src\\${xlo}"
1697 regsub -all -- {__TKINC__} $theProjTmpl $anIncPaths theProjTmpl
1698 regsub -all -- {__TKDEFS__} $theProjTmpl $aTKDefines theProjTmpl
1699 regsub -all -- {__FILES__} $theProjTmpl $aFilesSection theProjTmpl
1702 set aFile [open [set aVcFiles [file join $theOutDir ${theToolKit}.[osutils:vcproj:ext $theVcVer]]] w]
1703 fconfigure $aFile -translation crlf
1704 puts $aFile $theProjTmpl
1707 # write filters file for vc10+
1708 if { "$theVcVer" == "vc7" || "$theVcVer" == "vc8" || "$theVcVer" == "vc9" } {
1710 } elseif { "$theVcVer" == "vc10" } {
1711 lappend aVcFiles [osutils:vcxproj:filters $theOutDir $theToolKit aVcFilesX]
1713 lappend aVcFiles [osutils:vcx1proj:filters $theOutDir $theToolKit aVcFilesX]
1716 # write resource file
1717 lappend aVcFiles [osutils:readtemplate:rc $theOutDir $theToolKit]
1722 # for a unit returns a map containing all its file in the current
1724 # local = 1 only local files
1725 proc osutils:tk:loadunit { loc map } {
1728 catch { unset TLOC }
1729 set lfiles [_get_used_files $loc]
1734 if [info exists TLOC($t)] {
1745 # Returns the list of all compilable files name in a toolkit, or devunit of any type
1746 # Tfiles lists for each unit the type of file that can be compiled.
1747 proc osutils:tk:files { tkloc thePlatform } {
1748 set Tfiles(source,nocdlpack) {source pubinclude}
1749 set Tfiles(source,toolkit) {}
1750 set Tfiles(source,executable) {source pubinclude}
1751 set listloc [concat [osutils:tk:units $tkloc] $tkloc]
1752 #puts " listloc = $listloc"
1754 set l_comp [osutils:compilable $thePlatform]
1755 set resultloc $listloc
1757 foreach loc $resultloc {
1758 set utyp [_get_type $loc]
1759 #puts "\"$utyp\" \"$loc\""
1761 "t" { set utyp "toolkit" }
1762 "n" { set utyp "nocdlpack" }
1763 "x" { set utyp "executable" }
1765 if [array exists map] { unset map }
1766 osutils:tk:loadunit $loc map
1767 #puts " loc = $loc === > [array names map]"
1768 set LType $Tfiles(source,${utyp})
1769 foreach typ [array names map] {
1770 if { [lsearch $LType $typ] == -1 } {
1774 foreach type [array names map] {
1776 foreach f $map($type) {
1778 if { [lsearch $l_comp [file extension $f]] != -1 } {
1787 # Generate Visual Studio project file for executable
1788 proc osutils:vcprojx { theVcVer theOutDir theToolKit theGuidsMap {theProjTmpl {} } } {
1790 foreach f [osutils:tk:files $theToolKit wnt] {
1791 if { $theProjTmpl == {} } {
1792 set aProjTmpl [osutils:vcproj:readtemplate $theVcVer 1]
1794 set aProjTmpl $theProjTmpl
1796 set aProjName [file rootname [file tail $f]]
1797 set l_compilable [osutils:compilable wnt]
1798 regsub -all -- {__XQTNAM__} $aProjTmpl $aProjName aProjTmpl
1800 upvar $theGuidsMap aGuidsMap
1801 if { ! [info exists aGuidsMap($aProjName)] } {
1802 set aGuidsMap($aProjName) [OS:genGUID]
1804 regsub -all -- {__PROJECT_GUID__} $aProjTmpl $aGuidsMap($aProjName) aProjTmpl
1806 set aUsedLibs [list]
1807 foreach tkx [osutils:commonUsedTK $theToolKit] {
1808 lappend aUsedLibs "${tkx}.lib"
1811 osutils:usedOsLibs $theToolKit "wnt" aLibs aFrameworks
1812 foreach aLibIter $aLibs {
1813 lappend aUsedLibs "${aLibIter}.lib"
1816 # correct names of referred third-party libraries that are named with suffix
1817 # depending on VC version
1818 regsub -all -- {vc[0-9]+} $aUsedLibs $theVcVer aUsedLibs
1820 # puts "$aProjName requires $aUsedLibs"
1821 if { "$theVcVer" != "vc7" && "$theVcVer" != "vc8" && "$theVcVer" != "vc9" } {
1822 set aUsedLibs [join $aUsedLibs {;}]
1824 regsub -all -- {__TKDEP__} $aProjTmpl $aUsedLibs aProjTmpl
1826 set aFilesSection ""
1827 set aVcFilesX(units) ""
1829 if { ![info exists written([file tail $f])] } {
1830 set written([file tail $f]) 1
1832 if { "$theVcVer" != "vc7" && "$theVcVer" != "vc8" && "$theVcVer" != "vc9" } {
1833 append aFilesSection [osutils:vcxproj:file $theVcVer $f ""]
1834 if { ! [info exists aVcFilesX($theToolKit)] } { lappend aVcFilesX(units) $theToolKit }
1835 lappend aVcFilesX($theToolKit) $f
1837 append aFilesSection "\t\t\t<Filter\n"
1838 append aFilesSection "\t\t\t\tName=\"$theToolKit\"\n"
1839 append aFilesSection "\t\t\t\t>\n"
1840 append aFilesSection [osutils:vcproj:file $theVcVer $f ""]
1841 append aFilesSection "\t\t\t</Filter>"
1844 puts "Warning : in vcproj there are than one occurences for [file tail $f]"
1846 #puts "$aProjTmpl $aFilesSection"
1847 set aTKDefines ";__${theToolKit}_DLL"
1848 set anIncPaths "..\\..\\..\\inc"
1849 regsub -all -- {__TKINC__} $aProjTmpl $anIncPaths aProjTmpl
1850 regsub -all -- {__TKDEFS__} $aProjTmpl $aTKDefines aProjTmpl
1851 regsub -all -- {__FILES__} $aProjTmpl $aFilesSection aProjTmpl
1852 regsub -all -- {__CONF__} $aProjTmpl Application aProjTmpl
1854 regsub -all -- {__XQTEXT__} $aProjTmpl "exe" aProjTmpl
1856 set aFile [open [set aVcFilePath [file join $theOutDir ${aProjName}.[osutils:vcproj:ext $theVcVer]]] w]
1857 fconfigure $aFile -translation crlf
1858 puts $aFile $aProjTmpl
1861 set aCommonSettingsFile "$aVcFilePath.user"
1862 lappend aVcFiles $aVcFilePath
1864 # write filters file for vc10
1865 if { "$theVcVer" != "vc7" && "$theVcVer" != "vc8" && "$theVcVer" != "vc9" } {
1866 lappend aVcFiles [osutils:vcxproj:filters $theOutDir $aProjName aVcFilesX]
1869 set aCommonSettingsFileTmpl ""
1870 if { "$theVcVer" == "vc7" || "$theVcVer" == "vc8" } {
1872 } elseif { "$theVcVer" == "vc9" } {
1873 set aCommonSettingsFileTmpl [wokUtils:FILES:FileToString "$::THE_CASROOT/adm/templates/vcproj.user.vc9x"]
1875 set aCommonSettingsFileTmpl [wokUtils:FILES:FileToString "$::THE_CASROOT/adm/templates/vcxproj.user.vc10x"]
1877 if { "$aCommonSettingsFileTmpl" != "" } {
1878 regsub -all -- {__VCVER__} $aCommonSettingsFileTmpl $theVcVer aCommonSettingsFileTmpl
1880 set aFile [open [set aVcFilePath "$aCommonSettingsFile"] w]
1881 fconfigure $aFile -translation crlf
1882 puts $aFile $aCommonSettingsFileTmpl
1885 lappend aVcFiles "$aCommonSettingsFile"
1891 # Generate entry for one source file in Visual Studio 7 - 9 project file
1892 proc osutils:vcproj:file { theVcVer theFile theOptions } {
1893 append aText "\t\t\t\t<File\n"
1894 append aText "\t\t\t\t\tRelativePath=\"..\\..\\..\\[wokUtils:EASY:bs1 [wokUtils:FILES:wtail $theFile 3]]\">\n"
1895 if { $theOptions == "" } {
1896 append aText "\t\t\t\t</File>\n"
1900 append aText "\t\t\t\t\t<FileConfiguration\n"
1901 append aText "\t\t\t\t\t\tName=\"Release\|Win32\">\n"
1902 append aText "\t\t\t\t\t\t<Tool\n"
1903 append aText "\t\t\t\t\t\t\tName=\"VCCLCompilerTool\"\n"
1904 append aText "\t\t\t\t\t\t\tAdditionalOptions=\""
1905 foreach aParam $theOptions {
1906 append aText "$aParam "
1909 append aText "\t\t\t\t\t\t/>\n"
1910 append aText "\t\t\t\t\t</FileConfiguration>\n"
1912 append aText "\t\t\t\t\t<FileConfiguration\n"
1913 append aText "\t\t\t\t\t\tName=\"Debug\|Win32\">\n"
1914 append aText "\t\t\t\t\t\t<Tool\n"
1915 append aText "\t\t\t\t\t\t\tName=\"VCCLCompilerTool\"\n"
1916 append aText "\t\t\t\t\t\t\tAdditionalOptions=\""
1917 foreach aParam $theOptions {
1918 append aText "$aParam "
1921 append aText "\t\t\t\t\t\t/>\n"
1922 append aText "\t\t\t\t\t</FileConfiguration>\n"
1923 if { "$theVcVer" == "vc7" } {
1924 append aText "\t\t\t\t</File>\n"
1928 append aText "\t\t\t\t\t<FileConfiguration\n"
1929 append aText "\t\t\t\t\t\tName=\"Release\|x64\">\n"
1930 append aText "\t\t\t\t\t\t<Tool\n"
1931 append aText "\t\t\t\t\t\t\tName=\"VCCLCompilerTool\"\n"
1932 append aText "\t\t\t\t\t\t\tAdditionalOptions=\""
1933 foreach aParam $theOptions {
1934 append aText "$aParam "
1937 append aText "\t\t\t\t\t\t/>\n"
1938 append aText "\t\t\t\t\t</FileConfiguration>\n"
1940 append aText "\t\t\t\t\t<FileConfiguration\n"
1941 append aText "\t\t\t\t\t\tName=\"Debug\|x64\">\n"
1942 append aText "\t\t\t\t\t\t<Tool\n"
1943 append aText "\t\t\t\t\t\t\tName=\"VCCLCompilerTool\"\n"
1944 append aText "\t\t\t\t\t\t\tAdditionalOptions=\""
1945 foreach aParam $theOptions {
1946 append aText "$aParam "
1949 append aText "\t\t\t\t\t\t/>\n"
1950 append aText "\t\t\t\t\t</FileConfiguration>\n"
1952 append aText "\t\t\t\t</File>\n"
1956 proc wokUtils:FILES:mkdir { d } {
1958 regsub -all {\.[^.]*} $tcl_version "" major
1959 if { $major == 8 } {
1962 if ![file exists $d] {
1963 if { "[info command mkdir]" == "mkdir" } {
1966 puts stderr "wokUtils:FILES:mkdir : Error unable to find a mkdir command."
1970 if [file exists $d] {
1977 # remove from listloc OpenCascade units indesirables on Unix
1978 proc osutils:justunix { listloc } {
1979 if { "$::tcl_platform(os)" == "Darwin" } {
1980 set goaway [list Xw WNT]
1982 set goaway [list WNT]
1984 return [osutils:juststation $goaway $listloc]
1988 ####### CODEBLOCK ###################################################################
1989 # Function to generate Code Blocks workspace and project files
1990 proc OS:MKCBP { theOutDir theModules theAllSolution thePlatform theCmpl } {
1991 puts stderr "Generating project files for Code Blocks"
1993 # Generate projects for toolkits and separate workspace for each module
1994 foreach aModule $theModules {
1995 OS:cworkspace $aModule $aModule $theOutDir
1996 OS:cbp $theCmpl $aModule $theOutDir $thePlatform
1999 # Generate single workspace "OCCT" containing projects from all modules
2000 if { "$theAllSolution" != "" } {
2001 OS:cworkspace $theAllSolution $theModules $theOutDir
2004 puts "The Code Blocks workspace and project files are stored in the $theOutDir directory"
2007 # Generate Code Blocks projects
2008 proc OS:cbp { theCmpl theModules theOutDir thePlatform } {
2009 set aProjectFiles {}
2010 foreach aModule $theModules {
2011 foreach aToolKit [${aModule}:toolkits] {
2012 lappend aProjectFiles [osutils:cbptk $theCmpl $theOutDir $aToolKit $thePlatform]
2014 foreach anExecutable [OS:executable ${aModule}] {
2015 lappend aProjectFiles [osutils:cbpx $theCmpl $theOutDir $anExecutable $thePlatform]
2018 return $aProjectFiles
2021 # Generate Code::Blocks project file for ToolKit
2022 proc osutils:cbptk { theCmpl theOutDir theToolKit thePlatform} {
2023 set aUsedLibs [list]
2024 set aFrameworks [list]
2025 set anIncPaths [list]
2026 set aTKDefines [list]
2027 set aTKSrcFiles [list]
2029 # collect list of referred libraries to link with
2030 osutils:usedOsLibs $theToolKit $thePlatform aUsedLibs aFrameworks
2031 set aDepToolkits [wokUtils:LIST:Purge [osutils:tk:close $theToolKit]]
2032 foreach tkx $aDepToolkits {
2033 lappend aUsedLibs "${tkx}"
2036 lappend anIncPaths "../../../inc"
2037 set listloc [osutils:tk:units $theToolKit]
2039 if { [llength $listloc] == 0 } {
2040 set listloc $theToolKit
2043 if { $thePlatform == "wnt" } {
2044 set resultloc [osutils:justwnt $listloc]
2046 set resultloc [osutils:justunix $listloc]
2048 if [array exists written] { unset written }
2049 foreach fxlo $resultloc {
2051 set aSrcFiles [osutils:tk:files $xlo $thePlatform]
2052 foreach aSrcFile [lsort $aSrcFiles] {
2053 if { ![info exists written([file tail $aSrcFile])] } {
2054 set written([file tail $aSrcFile]) 1
2055 lappend aTKSrcFiles "../../../[wokUtils:FILES:wtail $aSrcFile 3]"
2057 puts "Warning : more than one occurences for [file tail $aSrcFile]"
2061 # macros for correct DLL exports
2062 if { $thePlatform == "wnt" } {
2063 lappend aTKDefines "__${xlo}_DLL"
2067 return [osutils:cbp $theCmpl $theOutDir $theToolKit $thePlatform $aTKSrcFiles $aUsedLibs $aFrameworks $anIncPaths $aTKDefines]
2070 # Generates Code Blocks workspace.
2071 proc OS:cworkspace { theSolName theModules theOutDir } {
2073 set aWsFilePath "${theOutDir}/${theSolName}.workspace"
2074 set aFile [open $aWsFilePath "w"]
2076 puts $aFile "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>"
2077 puts $aFile "<CodeBlocks_workspace_file>"
2078 puts $aFile "\t<Workspace title=\"${theSolName}\">"
2080 # collect list of projects to be created
2081 foreach aModule $theModules {
2083 foreach aToolKit [osutils:tk:sort [${aModule}:toolkits]] {
2084 set aDependencies [LibToLink $aToolKit]
2085 if { [llength $aDependencies] == 0 } {
2086 puts $aFile "\t\t<Project filename=\"${aToolKit}.cbp\" />"
2088 puts $aFile "\t\t<Project filename=\"${aToolKit}.cbp\" >"
2089 foreach aDepTk $aDependencies {
2090 puts $aFile "\t\t\t<Depends filename=\"${aDepTk}.cbp\" />"
2092 puts $aFile "\t\t</Project>"
2096 # executables, assume one project per cxx file...
2097 foreach aUnit [OS:executable ${aModule}] {
2099 set src_files [_get_used_files $aUnit false]
2101 foreach s $src_files {
2102 regexp {source ([^\s]+)} $s dummy name
2103 lappend aSrcFiles $name
2105 foreach aSrcFile $aSrcFiles {
2106 set aFileExtension [file extension $aSrcFile]
2107 if { $aFileExtension == ".cxx" } {
2108 set aPrjName [file rootname $aSrcFile]
2109 set aDependencies [list]
2110 if {[file isdirectory $path/src/$aUnitLoc]} {
2111 set aDependencies [LibToLinkX $aUnitLoc [file rootname $aSrcFile]]
2113 set anActiveState ""
2114 if { $isActiveSet == 0 } {
2115 set anActiveState " active=\"1\""
2118 if { [llength $aDependencies] == 0 } {
2119 puts $aFile "\t\t<Project filename=\"${aPrjName}.cbp\"${anActiveState}/>"
2121 puts $aFile "\t\t<Project filename=\"${aPrjName}.cbp\"${anActiveState}>"
2122 foreach aDepTk $aDependencies {
2123 puts $aFile "\t\t\t<Depends filename=\"${aDepTk}.cbp\" />"
2125 puts $aFile "\t\t</Project>"
2132 puts $aFile "\t</Workspace>"
2133 puts $aFile "</CodeBlocks_workspace_file>"
2139 # Generate Code::Blocks project file for Executable
2140 proc osutils:cbpx { theCmpl theOutDir theToolKit thePlatform } {
2142 set aWokArch "$::env(ARCH)"
2145 foreach aSrcFile [osutils:tk:files $theToolKit $thePlatform] {
2146 # collect list of referred libraries to link with
2147 set aUsedLibs [list]
2148 set aFrameworks [list]
2149 set anIncPaths [list]
2150 set aTKDefines [list]
2151 set aTKSrcFiles [list]
2152 set aProjName [file rootname [file tail $aSrcFile]]
2154 osutils:usedOsLibs $theToolKit $thePlatform aUsedLibs aFrameworks
2156 set aDepToolkits [LibToLinkX $theToolKit $aProjName]
2157 foreach tkx $aDepToolkits {
2158 if {[_get_type $tkx] == "t"} {
2159 lappend aUsedLibs "${tkx}"
2161 if {[lsearch [glob -tails -directory "$path/src" -types d *] $tkx] == "-1"} {
2162 lappend aUsedLibs "${tkx}"
2166 set WOKSteps_exec_link [_get_options lin WOKSteps_exec_link $theToolKit]
2167 if { [regexp {WOKStep_DLLink} $WOKSteps_exec_link] || [regexp {WOKStep_Libink} $WOKSteps_exec_link] } {
2168 set isExecutable "false"
2170 set isExecutable "true"
2173 if { ![info exists written([file tail $aSrcFile])] } {
2174 set written([file tail $aSrcFile]) 1
2175 lappend aTKSrcFiles "../../../[wokUtils:FILES:wtail $aSrcFile 3]"
2177 puts "Warning : in cbp there are more than one occurences for [file tail $aSrcFile]"
2180 # macros for correct DLL exports
2181 if { $thePlatform == "wnt" } {
2182 lappend aTKDefines "__${theToolKit}_DLL"
2185 # common include paths
2186 lappend anIncPaths "../../../inc"
2188 lappend aCbpFiles [osutils:cbp $theCmpl $theOutDir $aProjName $thePlatform $aTKSrcFiles $aUsedLibs $aFrameworks $anIncPaths $aTKDefines $isExecutable]
2194 # This function intended to generate Code::Blocks project file
2195 # @param theCmpl - the compiler (gcc or msvc)
2196 # @param theOutDir - output directory to place project file
2197 # @param theProjName - project name
2198 # @param theSrcFiles - list of source files
2199 # @param theLibsList - dependencies (libraries list)
2200 # @param theFrameworks - dependencies (frameworks list, Mac OS X specific)
2201 # @param theIncPaths - header search paths
2202 # @param theDefines - compiler macro definitions
2203 # @param theIsExe - flag to indicate executable / library target
2204 proc osutils:cbp { theCmpl theOutDir theProjName thePlatform theSrcFiles theLibsList theFrameworks theIncPaths theDefines {theIsExe "false"} } {
2205 set aWokStation $thePlatform
2206 set aWokArch "$::env(ARCH)"
2209 set aCmplFlags [list]
2210 set aCmplFlagsRelease [list]
2211 set aCmplFlagsDebug [list]
2212 set toPassArgsByFile 0
2213 set aLibPrefix "lib"
2214 if { "$aWokStation" == "wnt" || "$aWokStation" == "qnx" } {
2215 set toPassArgsByFile 1
2217 if { "$theCmpl" == "msvc" } {
2218 set aCmplCbp "msvc8"
2222 if { "$theCmpl" == "msvc" } {
2223 set aCmplFlags "-arch:SSE2 -EHsc -W4 -MP"
2224 set aCmplFlagsRelease "-MD -O2"
2225 set aCmplFlagsDebug "-MDd -Od -Zi"
2226 lappend aCmplFlags "-D_CRT_SECURE_NO_WARNINGS"
2227 lappend aCmplFlags "-D_CRT_NONSTDC_NO_DEPRECATE"
2228 } elseif { "$theCmpl" == "gcc" } {
2229 if { "$aWokStation" != "qnx" } {
2230 set aCmplFlags "-mmmx -msse -msse2 -mfpmath=sse"
2232 set aCmplFlagsRelease "-O2"
2233 set aCmplFlagsDebug "-O0 -g"
2234 if { "$aWokStation" == "wnt" } {
2235 lappend aCmplFlags "-std=gnu++0x"
2236 lappend aCmplFlags "-D_WIN32_WINNT=0x0501"
2238 lappend aCmplFlags "-std=c++0x"
2239 lappend aCmplFlags "-fPIC"
2240 lappend aCmplFlags "-DOCC_CONVERT_SIGNALS"
2242 lappend aCmplFlags "-Wall"
2243 lappend aCmplFlags "-fexceptions"
2245 lappend aCmplFlagsRelease "-DNDEBUG"
2246 lappend aCmplFlagsRelease "-DNo_Exception"
2247 lappend aCmplFlagsDebug "-D_DEBUG"
2248 if { "$aWokStation" == "qnx" } {
2249 lappend aCmplFlags "-D_QNX_SOURCE"
2252 set aCbpFilePath "${theOutDir}/${theProjName}.cbp"
2253 set aLnkFileName "${theProjName}_obj.link"
2254 set aLnkDebFileName "${theProjName}_objd.link"
2255 set aLnkFilePath "${theOutDir}/${aLnkFileName}"
2256 set aLnkDebFilePath "${theOutDir}/${aLnkDebFileName}"
2257 set aFile [open $aCbpFilePath "w"]
2258 puts $aFile "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>"
2259 puts $aFile "<CodeBlocks_project_file>"
2260 puts $aFile "\t<FileVersion major=\"1\" minor=\"6\" />"
2261 puts $aFile "\t<Project>"
2262 puts $aFile "\t\t<Option title=\"$theProjName\" />"
2263 puts $aFile "\t\t<Option pch_mode=\"2\" />"
2264 puts $aFile "\t\t<Option compiler=\"$aCmplCbp\" />"
2265 puts $aFile "\t\t<Build>"
2267 # Release target configuration
2268 puts $aFile "\t\t\t<Target title=\"Release\">"
2269 if { "$theIsExe" == "true" } {
2270 puts $aFile "\t\t\t\t<Option output=\"../../../${aWokStation}/cbp/bin/${theProjName}\" prefix_auto=\"0\" extension_auto=\"0\" />"
2271 puts $aFile "\t\t\t\t<Option type=\"1\" />"
2273 if { "$aWokStation" == "wnt" } {
2274 puts $aFile "\t\t\t\t<Option output=\"../../../${aWokStation}/cbp/bin/${aLibPrefix}${theProjName}\" imp_lib=\"../../../${aWokStation}/cbp/lib/\$(TARGET_OUTPUT_BASENAME)\" prefix_auto=\"1\" extension_auto=\"1\" />"
2276 puts $aFile "\t\t\t\t<Option output=\"../../../${aWokStation}/cbp/lib/lib${theProjName}.so\" prefix_auto=\"0\" extension_auto=\"0\" />"
2278 puts $aFile "\t\t\t\t<Option type=\"3\" />"
2280 puts $aFile "\t\t\t\t<Option object_output=\"../../../${aWokStation}/cbp/obj\" />"
2281 puts $aFile "\t\t\t\t<Option compiler=\"$aCmplCbp\" />"
2282 puts $aFile "\t\t\t\t<Option createDefFile=\"0\" />"
2283 if { "$aWokStation" == "wnt" } {
2284 puts $aFile "\t\t\t\t<Option createStaticLib=\"1\" />"
2286 puts $aFile "\t\t\t\t<Option createStaticLib=\"0\" />"
2289 # compiler options per TARGET (including defines)
2290 puts $aFile "\t\t\t\t<Compiler>"
2291 foreach aFlagIter $aCmplFlagsRelease {
2292 puts $aFile "\t\t\t\t\t<Add option=\"$aFlagIter\" />"
2294 foreach aMacro $theDefines {
2295 puts $aFile "\t\t\t\t\t<Add option=\"-D${aMacro}\" />"
2297 puts $aFile "\t\t\t\t</Compiler>"
2299 puts $aFile "\t\t\t\t<Linker>"
2300 if { $toPassArgsByFile == 1 } {
2301 puts $aFile "\t\t\t\t\t<Add option=\"\@$aLnkFileName\" />"
2303 puts $aFile "\t\t\t\t\t<Add directory=\"../../../${aWokStation}/cbp/lib\" />"
2304 if { "$aWokStation" == "mac" } {
2305 if { [ lsearch $theLibsList X11 ] >= 0} {
2306 puts $aFile "\t\t\t\t\t<Add directory=\"/usr/X11/lib\" />"
2309 puts $aFile "\t\t\t\t\t<Add option=\"\$(CSF_OPT_LNK${aWokArch})\" />"
2310 if { "$aWokStation" == "lin" } {
2311 puts $aFile "\t\t\t\t\t<Add option=\"-Wl,-rpath-link=../../../${aWokStation}/cbp/lib\" />"
2313 puts $aFile "\t\t\t\t</Linker>"
2315 puts $aFile "\t\t\t</Target>"
2317 # Debug target configuration
2318 puts $aFile "\t\t\t<Target title=\"Debug\">"
2319 if { "$theIsExe" == "true" } {
2320 puts $aFile "\t\t\t\t<Option output=\"../../../${aWokStation}/cbp/bind/${theProjName}\" prefix_auto=\"0\" extension_auto=\"0\" />"
2321 puts $aFile "\t\t\t\t<Option type=\"1\" />"
2323 if { "$aWokStation" == "wnt" } {
2324 puts $aFile "\t\t\t\t<Option output=\"../../../${aWokStation}/cbp/bind/${aLibPrefix}${theProjName}\" imp_lib=\"../../../${aWokStation}/cbp/libd/\$(TARGET_OUTPUT_BASENAME)\" prefix_auto=\"1\" extension_auto=\"1\" />"
2326 puts $aFile "\t\t\t\t<Option output=\"../../../${aWokStation}/cbp/libd/lib${theProjName}.so\" prefix_auto=\"0\" extension_auto=\"0\" />"
2328 puts $aFile "\t\t\t\t<Option type=\"3\" />"
2330 puts $aFile "\t\t\t\t<Option object_output=\"../../../${aWokStation}/cbp/objd\" />"
2331 puts $aFile "\t\t\t\t<Option compiler=\"$aCmplCbp\" />"
2332 puts $aFile "\t\t\t\t<Option createDefFile=\"0\" />"
2333 if { "$aWokStation" == "wnt" } {
2334 puts $aFile "\t\t\t\t<Option createStaticLib=\"1\" />"
2336 puts $aFile "\t\t\t\t<Option createStaticLib=\"0\" />"
2339 # compiler options per TARGET (including defines)
2340 puts $aFile "\t\t\t\t<Compiler>"
2341 foreach aFlagIter $aCmplFlagsDebug {
2342 puts $aFile "\t\t\t\t\t<Add option=\"$aFlagIter\" />"
2344 foreach aMacro $theDefines {
2345 puts $aFile "\t\t\t\t\t<Add option=\"-D${aMacro}\" />"
2347 puts $aFile "\t\t\t\t</Compiler>"
2349 puts $aFile "\t\t\t\t<Linker>"
2350 if { $toPassArgsByFile == 1 } {
2351 puts $aFile "\t\t\t\t\t<Add option=\"\@$aLnkDebFileName\" />"
2353 puts $aFile "\t\t\t\t\t<Add directory=\"../../../${aWokStation}/cbp/libd\" />"
2354 if { "$aWokStation" == "mac" } {
2355 if { [ lsearch $theLibsList X11 ] >= 0} {
2356 puts $aFile "\t\t\t\t\t<Add directory=\"/usr/X11/lib\" />"
2359 puts $aFile "\t\t\t\t\t<Add option=\"\$(CSF_OPT_LNK${aWokArch}D)\" />"
2360 if { "$aWokStation" == "lin" } {
2361 puts $aFile "\t\t\t\t\t<Add option=\"-Wl,-rpath-link=../../../${aWokStation}/cbp/libd\" />"
2363 puts $aFile "\t\t\t\t</Linker>"
2365 puts $aFile "\t\t\t</Target>"
2367 puts $aFile "\t\t</Build>"
2369 # COMMON compiler options
2370 puts $aFile "\t\t<Compiler>"
2371 foreach aFlagIter $aCmplFlags {
2372 puts $aFile "\t\t\t<Add option=\"$aFlagIter\" />"
2374 puts $aFile "\t\t\t<Add option=\"\$(CSF_OPT_CMPL)\" />"
2375 foreach anIncPath $theIncPaths {
2376 puts $aFile "\t\t\t<Add directory=\"$anIncPath\" />"
2378 puts $aFile "\t\t</Compiler>"
2380 # COMMON linker options
2381 puts $aFile "\t\t<Linker>"
2382 if { "$aWokStation" == "wnt" && "$theCmpl" == "gcc" } {
2383 puts $aFile "\t\t\t<Add option=\"-Wl,--export-all-symbols\" />"
2385 foreach aFrameworkName $theFrameworks {
2386 if { "$aFrameworkName" != "" } {
2387 puts $aFile "\t\t\t<Add option=\"-framework $aFrameworkName\" />"
2390 foreach aLibName $theLibsList {
2391 if { "$aLibName" != "" } {
2392 if { "$theCmpl" == "msvc" } {
2393 puts $aFile "\t\t\t<Add library=\"${aLibName}.lib\" />"
2395 puts $aFile "\t\t\t<Add library=\"${aLibName}\" />"
2399 puts $aFile "\t\t</Linker>"
2405 set isFirstSrcFile 1
2406 if { $toPassArgsByFile == 1 } {
2407 set aFileLnkObj [open $aLnkFilePath "w"]
2408 set aFileLnkObjd [open $aLnkDebFilePath "w"]
2411 foreach aSrcFile $theSrcFiles {
2412 if {[string equal -nocase [file extension $aSrcFile] ".mm"]} {
2413 puts $aFile "\t\t<Unit filename=\"$aSrcFile\">"
2414 puts $aFile "\t\t\t<Option compile=\"1\" />"
2415 puts $aFile "\t\t\t<Option link=\"1\" />"
2416 puts $aFile "\t\t</Unit>"
2417 } elseif {[string equal -nocase [file extension $aSrcFile] ".c"]} {
2418 puts $aFile "\t\t<Unit filename=\"$aSrcFile\">"
2419 puts $aFile "\t\t\t<Option compilerVar=\"CC\" />"
2420 puts $aFile "\t\t</Unit>"
2421 } elseif { $toPassArgsByFile == 1 && $isFirstSrcFile == 0 && [string equal -nocase [file extension $aSrcFile] ".cxx" ] } {
2422 # pass at list single source file to Code::Blocks as is
2423 # and pack the list of other files into the dedicated file to workaround process arguments limits on systems like Windows
2424 puts $aFile "\t\t<Unit filename=\"$aSrcFile\">"
2425 puts $aFile "\t\t\t<Option link=\"0\" />"
2426 puts $aFile "\t\t</Unit>"
2428 set aFileObj [string map {.cxx .o} [string map [list "/src/" "/$aWokStation/cbp/obj/src/"] $aSrcFile]]
2429 set aFileObjd [string map {.cxx .o} [string map [list "/src/" "/$aWokStation/cbp/objd/src/"] $aSrcFile]]
2430 puts -nonewline $aFileLnkObj "$aFileObj "
2431 puts -nonewline $aFileLnkObjd "$aFileObjd "
2433 puts $aFile "\t\t<Unit filename=\"$aSrcFile\" />"
2434 set isFirstSrcFile 0
2438 if { "$aWokStation" == "wnt" } {
2443 puts $aFile "\t</Project>"
2444 puts $aFile "</CodeBlocks_project_file>"
2447 return $aCbpFilePath
2450 # Define libraries to link using only EXTERNLIB file
2451 proc LibToLinkX {thePackage theDummyName} {
2452 set aToolKits [LibToLink $thePackage]
2456 # Function to generate Xcode workspace and project files
2457 proc OS:MKXCD { theOutDir {theModules {}} {theAllSolution ""} {theLibType "dynamic"} {thePlatform ""} } {
2459 puts stderr "Generating project files for Xcode"
2461 # Generate projects for toolkits and separate workspace for each module
2462 foreach aModule $theModules {
2463 OS:xcworkspace $aModule $aModule $theOutDir
2464 OS:xcodeproj $aModule $theOutDir ::THE_GUIDS_LIST $theLibType $thePlatform
2467 # Generate single workspace "OCCT" containing projects from all modules
2468 if { "$theAllSolution" != "" } {
2469 OS:xcworkspace $theAllSolution $theModules $theOutDir
2473 # Generates toolkits sections for Xcode workspace file.
2474 proc OS:xcworkspace:toolkits { theModule } {
2477 # Adding toolkits for module in workspace.
2478 foreach aToolKit [osutils:tk:sort [${theModule}:toolkits]] {
2479 append aBuff " <FileRef\n"
2480 append aBuff " location = \"group:${aToolKit}.xcodeproj\">\n"
2481 append aBuff " </FileRef>\n"
2484 # Adding executables for module, assume one project per cxx file...
2485 foreach aUnit [OS:executable ${theModule}] {
2487 set src_files [_get_used_files $aUnit false]
2489 foreach s $src_files {
2490 regexp {source ([^\s]+)} $s dummy name
2491 lappend aSrcFiles $name
2493 foreach aSrcFile $aSrcFiles {
2494 set aFileExtension [file extension $aSrcFile]
2495 if { $aFileExtension == ".cxx" } {
2496 set aPrjName [file rootname $aSrcFile]
2497 append aBuff " <FileRef\n"
2498 append aBuff " location = \"group:${aPrjName}.xcodeproj\">\n"
2499 append aBuff " </FileRef>\n"
2504 # Removing unnecessary newline character from the end.
2505 set aBuff [string replace $aBuff end end]
2509 # Generates workspace files for Xcode.
2510 proc OS:xcworkspace { theWorkspaceName theModules theOutDir } {
2511 # Creating workspace directory for Xcode.
2512 set aWorkspaceDir "${theOutDir}/${theWorkspaceName}.xcworkspace"
2513 wokUtils:FILES:mkdir $aWorkspaceDir
2514 if { ! [file exists $aWorkspaceDir] } {
2515 puts stderr "Error: Could not create workspace directory \"$aWorkspaceDir\""
2519 # Creating workspace file.
2520 set aWsFilePath "${aWorkspaceDir}/contents.xcworkspacedata"
2521 set aFile [open $aWsFilePath "w"]
2523 # Adding header and section for main Group.
2524 puts $aFile "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
2525 puts $aFile "<Workspace"
2526 puts $aFile " version = \"1.0\">"
2527 puts $aFile " <Group"
2528 puts $aFile " location = \"container:\""
2529 puts $aFile " name = \"${theWorkspaceName}\">"
2532 if { [llength "$theModules"] > 1 } {
2533 foreach aModule $theModules {
2534 puts $aFile " <Group"
2535 puts $aFile " location = \"container:\""
2536 puts $aFile " name = \"${aModule}\">"
2537 puts $aFile [OS:xcworkspace:toolkits $aModule]
2538 puts $aFile " </Group>"
2541 puts $aFile [OS:xcworkspace:toolkits $theModules]
2545 puts $aFile " </Group>"
2546 puts $aFile "</Workspace>"
2550 # Generates Xcode project files.
2551 proc OS:xcodeproj { theModules theOutDir theGuidsMap theLibType thePlatform} {
2552 upvar $theGuidsMap aGuidsMap
2555 if { "$theLibType" == "static" } {
2557 } elseif { "$thePlatform" == "ios" } {
2561 set aProjectFiles {}
2562 foreach aModule $theModules {
2563 foreach aToolKit [${aModule}:toolkits] {
2564 lappend aProjectFiles [osutils:xcdtk $theOutDir $aToolKit aGuidsMap $isStatic $thePlatform "dylib"]
2566 foreach anExecutable [OS:executable ${aModule}] {
2567 lappend aProjectFiles [osutils:xcdtk $theOutDir $anExecutable aGuidsMap $isStatic $thePlatform "executable"]
2570 return $aProjectFiles
2573 # Generates dependencies section for Xcode project files.
2574 proc osutils:xcdtk:deps {theToolKit theTargetType theGuidsMap theFileRefSection theDepsGuids theDepsRefGuids theIsStatic} {
2575 upvar $theGuidsMap aGuidsMap
2576 upvar $theFileRefSection aFileRefSection
2577 upvar $theDepsGuids aDepsGuids
2578 upvar $theDepsRefGuids aDepsRefGuids
2580 set aBuildFileSection ""
2581 set aUsedLibs [wokUtils:LIST:Purge [osutils:tk:close $theToolKit]]
2582 set aDepToolkits [lappend [wokUtils:LIST:Purge [osutils:tk:close $theToolKit]] $theToolKit]
2584 if { "$theTargetType" == "executable" } {
2585 set aFile [osutils:tk:files $theToolKit mac]
2586 set aProjName [file rootname [file tail $aFile]]
2587 set aDepToolkits [LibToLinkX $theToolKit $aProjName]
2591 if { $theIsStatic == 1 } {
2593 if { "$theTargetType" != "executable" } {
2594 return $aBuildFileSection
2598 osutils:usedOsLibs $theToolKit "mac" aLibs aFrameworks
2599 set aUsedLibs [concat $aUsedLibs $aLibs]
2600 set aUsedLibs [concat $aUsedLibs $aFrameworks]
2601 foreach tkx $aUsedLibs {
2602 set aDepLib "${tkx}_Dep"
2603 set aDepLibRef "${tkx}_DepRef"
2605 if { ! [info exists aGuidsMap($aDepLib)] } {
2606 set aGuidsMap($aDepLib) [OS:genGUID "xcd"]
2608 if { ! [info exists aGuidsMap($aDepLibRef)] } {
2609 set aGuidsMap($aDepLibRef) [OS:genGUID "xcd"]
2612 append aBuildFileSection "\t\t$aGuidsMap($aDepLib) = \{isa = PBXBuildFile; fileRef = $aGuidsMap($aDepLibRef) ; \};\n"
2613 if {[lsearch -nocase $aFrameworks $tkx] == -1} {
2614 append aFileRefSection "\t\t$aGuidsMap($aDepLibRef) = \{isa = PBXFileReference; lastKnownFileType = file; name = lib${tkx}.${aLibExt}; path = lib${tkx}.${aLibExt}; sourceTree = \"<group>\"; \};\n"
2616 append aFileRefSection "\t\t$aGuidsMap($aDepLibRef) = \{isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = ${tkx}.framework; path = /System/Library/Frameworks/${tkx}.framework; sourceTree = \"<absolute>\"; \};\n"
2618 append aDepsGuids "\t\t\t\t$aGuidsMap($aDepLib) ,\n"
2619 append aDepsRefGuids "\t\t\t\t$aGuidsMap($aDepLibRef) ,\n"
2622 return $aBuildFileSection
2625 # Generates PBXBuildFile and PBXGroup sections for project file.
2626 proc osutils:xcdtk:sources {theToolKit theTargetType theSrcFileRefSection theGroupSection thePackageGuids theSrcFileGuids theGuidsMap theIncPaths} {
2627 upvar $theSrcFileRefSection aSrcFileRefSection
2628 upvar $theGroupSection aGroupSection
2629 upvar $thePackageGuids aPackagesGuids
2630 upvar $theSrcFileGuids aSrcFileGuids
2631 upvar $theGuidsMap aGuidsMap
2632 upvar $theIncPaths anIncPaths
2634 set listloc [osutils:tk:units $theToolKit]
2635 set resultloc [osutils:justunix $listloc]
2636 set aBuildFileSection ""
2637 set aPackages [lsort -nocase $resultloc]
2638 if { "$theTargetType" == "executable" } {
2639 set aPackages [list "$theToolKit"]
2642 # Generating PBXBuildFile, PBXGroup sections and groups for each package.
2643 foreach fxlo $aPackages {
2645 set aPackage "${xlo}_Package"
2646 set aSrcFileRefGuids ""
2647 if { ! [info exists aGuidsMap($aPackage)] } {
2648 set aGuidsMap($aPackage) [OS:genGUID "xcd"]
2651 set aSrcFiles [osutils:tk:files $xlo mac]
2652 foreach aSrcFile [lsort $aSrcFiles] {
2653 set aFileExt "sourcecode.cpp.cpp"
2655 if { [file extension $aSrcFile] == ".c" } {
2656 set aFileExt "sourcecode.c.c"
2657 } elseif { [file extension $aSrcFile] == ".mm" } {
2658 set aFileExt "sourcecode.cpp.objcpp"
2661 if { ! [info exists aGuidsMap($aSrcFile)] } {
2662 set aGuidsMap($aSrcFile) [OS:genGUID "xcd"]
2664 set aSrcFileRef "${aSrcFile}_Ref"
2665 if { ! [info exists aGuidsMap($aSrcFileRef)] } {
2666 set aGuidsMap($aSrcFileRef) [OS:genGUID "xcd"]
2668 if { ! [info exists written([file tail $aSrcFile])] } {
2669 set written([file tail $aSrcFile]) 1
2670 append aBuildFileSection "\t\t$aGuidsMap($aSrcFile) = \{isa = PBXBuildFile; fileRef = $aGuidsMap($aSrcFileRef) ;\};\n"
2671 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"
2672 append aSrcFileGuids "\t\t\t\t$aGuidsMap($aSrcFile) ,\n"
2673 append aSrcFileRefGuids "\t\t\t\t$aGuidsMap($aSrcFileRef) ,\n"
2675 puts "Warning : more than one occurences for [file tail $aSrcFile]"
2679 append aGroupSection "\t\t$aGuidsMap($aPackage) = \{\n"
2680 append aGroupSection "\t\t\tisa = PBXGroup;\n"
2681 append aGroupSection "\t\t\tchildren = (\n"
2682 append aGroupSection $aSrcFileRefGuids
2683 append aGroupSection "\t\t\t);\n"
2684 append aGroupSection "\t\t\tname = $xlo;\n"
2685 append aGroupSection "\t\t\tsourceTree = \"<group>\";\n"
2686 append aGroupSection "\t\t\};\n"
2688 # Storing packages IDs for adding them later as a child of toolkit
2689 append aPackagesGuids "\t\t\t\t$aGuidsMap($aPackage) ,\n"
2692 # Removing unnecessary newline character from the end.
2693 set aPackagesGuids [string replace $aPackagesGuids end end]
2695 return $aBuildFileSection
2698 # Creates folders structure and all necessary files for Xcode project.
2699 proc osutils:xcdtk { theOutDir theToolKit theGuidsMap theIsStatic thePlatform {theTargetType "dylib"} } {
2700 set aPBXBuildPhase "Headers"
2701 set aRunOnlyForDeployment "0"
2702 set aProductType "library.dynamic"
2703 set anExecExtension "\t\t\t\tEXECUTABLE_EXTENSION = dylib;"
2704 set anExecPrefix "\t\t\t\tEXECUTABLE_PREFIX = lib;"
2705 set aWrapperExtension "\t\t\t\tWRAPPER_EXTENSION = dylib;"
2706 set aTKDefines [list "OCC_CONVERT_SIGNALS"]
2707 if { $theIsStatic == 1 } {
2708 lappend aTKDefines "OCCT_NO_PLUGINS"
2711 if { "$theTargetType" == "executable" } {
2712 set aPBXBuildPhase "CopyFiles"
2713 set aRunOnlyForDeployment "1"
2714 set aProductType "tool"
2715 set anExecExtension ""
2717 set aWrapperExtension ""
2718 } elseif { $theIsStatic == 1 } {
2719 set aProductType "library.static"
2720 set anExecExtension "\t\t\t\tEXECUTABLE_EXTENSION = a;"
2721 set aWrapperExtension "\t\t\t\tWRAPPER_EXTENSION = a;"
2724 set aUsername [exec whoami]
2726 # Creation of folders for Xcode projectP.
2727 set aToolkitDir "${theOutDir}/${theToolKit}.xcodeproj"
2728 wokUtils:FILES:mkdir $aToolkitDir
2729 if { ! [file exists $aToolkitDir] } {
2730 puts stderr "Error: Could not create project directory \"$aToolkitDir\""
2734 set aUserDataDir "${aToolkitDir}/xcuserdata"
2735 wokUtils:FILES:mkdir $aUserDataDir
2736 if { ! [file exists $aUserDataDir] } {
2737 puts stderr "Error: Could not create xcuserdata directorty in \"$aToolkitDir\""
2741 set aUserDataDir "${aUserDataDir}/${aUsername}.xcuserdatad"
2742 wokUtils:FILES:mkdir $aUserDataDir
2743 if { ! [file exists $aUserDataDir] } {
2744 puts stderr "Error: Could not create ${aUsername}.xcuserdatad directorty in \"$aToolkitDir\"/xcuserdata"
2748 set aSchemesDir "${aUserDataDir}/xcschemes"
2749 wokUtils:FILES:mkdir $aSchemesDir
2750 if { ! [file exists $aSchemesDir] } {
2751 puts stderr "Error: Could not create xcschemes directorty in \"$aUserDataDir\""
2754 # End of folders creation.
2756 # Generating GUID for tookit.
2757 upvar $theGuidsMap aGuidsMap
2758 if { ! [info exists aGuidsMap($theToolKit)] } {
2759 set aGuidsMap($theToolKit) [OS:genGUID "xcd"]
2762 # Creating xcscheme file for toolkit from template.
2763 set aXcschemeTmpl [osutils:readtemplate "xcscheme" "xcd"]
2764 regsub -all -- {__TOOLKIT_NAME__} $aXcschemeTmpl $theToolKit aXcschemeTmpl
2765 regsub -all -- {__TOOLKIT_GUID__} $aXcschemeTmpl $aGuidsMap($theToolKit) aXcschemeTmpl
2766 set aXcschemeFile [open "$aSchemesDir/${theToolKit}.xcscheme" "w"]
2767 puts $aXcschemeFile $aXcschemeTmpl
2768 close $aXcschemeFile
2770 # Creating xcschememanagement.plist file for toolkit from template.
2771 set aPlistTmpl [osutils:readtemplate "plist" "xcd"]
2772 regsub -all -- {__TOOLKIT_NAME__} $aPlistTmpl $theToolKit aPlistTmpl
2773 regsub -all -- {__TOOLKIT_GUID__} $aPlistTmpl $aGuidsMap($theToolKit) aPlistTmpl
2774 set aPlistFile [open "$aSchemesDir/xcschememanagement.plist" "w"]
2775 puts $aPlistFile $aPlistTmpl
2778 # Creating project.pbxproj file for toolkit.
2779 set aPbxprojFile [open "$aToolkitDir/project.pbxproj" "w"]
2780 puts $aPbxprojFile "// !\$*UTF8*\$!"
2781 puts $aPbxprojFile "\{"
2782 puts $aPbxprojFile "\tarchiveVersion = 1;"
2783 puts $aPbxprojFile "\tclasses = \{"
2784 puts $aPbxprojFile "\t\};"
2785 puts $aPbxprojFile "\tobjectVersion = 46;"
2786 puts $aPbxprojFile "\tobjects = \{\n"
2788 # Begin PBXBuildFile section
2789 set aPackagesGuids ""
2790 set aGroupSection ""
2791 set aSrcFileRefSection ""
2792 set aSrcFileGuids ""
2793 set aDepsFileRefSection ""
2795 set aDepsRefGuids ""
2796 set anIncPaths [list "../../../inc"]
2799 if { [info exists ::env(CSF_OPT_INC)] } {
2800 set anIncCfg [split "$::env(CSF_OPT_INC)" ":"]
2801 foreach anIncCfgPath $anIncCfg {
2802 lappend anIncPaths $anIncCfgPath
2805 if { [info exists ::env(CSF_OPT_LIB64)] } {
2806 set anLibCfg [split "$::env(CSF_OPT_LIB64)" ":"]
2807 foreach anLibCfgPath $anLibCfg {
2808 lappend anLibPaths $anLibCfgPath
2812 puts $aPbxprojFile [osutils:xcdtk:sources $theToolKit $theTargetType aSrcFileRefSection aGroupSection aPackagesGuids aSrcFileGuids aGuidsMap anIncPaths]
2813 puts $aPbxprojFile [osutils:xcdtk:deps $theToolKit $theTargetType aGuidsMap aDepsFileRefSection aDepsGuids aDepsRefGuids $theIsStatic]
2814 # End PBXBuildFile section
2816 # Begin PBXFileReference section
2817 set aToolkitLib "lib${theToolKit}.dylib"
2818 set aPath "$aToolkitLib"
2819 if { "$theTargetType" == "executable" } {
2820 set aPath "$theToolKit"
2821 } elseif { $theIsStatic == 1 } {
2822 set aToolkitLib "lib${theToolKit}.a"
2825 if { ! [info exists aGuidsMap($aToolkitLib)] } {
2826 set aGuidsMap($aToolkitLib) [OS:genGUID "xcd"]
2829 puts $aPbxprojFile "\t\t$aGuidsMap($aToolkitLib) = {isa = PBXFileReference; explicitFileType = \"compiled.mach-o.${theTargetType}\"; includeInIndex = 0; path = $aPath; sourceTree = BUILT_PRODUCTS_DIR; };\n"
2830 puts $aPbxprojFile $aSrcFileRefSection
2831 puts $aPbxprojFile $aDepsFileRefSection
2832 # End PBXFileReference section
2835 # Begin PBXFrameworksBuildPhase section
2836 set aTkFrameworks "${theToolKit}_Frameworks"
2837 if { ! [info exists aGuidsMap($aTkFrameworks)] } {
2838 set aGuidsMap($aTkFrameworks) [OS:genGUID "xcd"]
2841 puts $aPbxprojFile "\t\t$aGuidsMap($aTkFrameworks) = \{"
2842 puts $aPbxprojFile "\t\t\tisa = PBXFrameworksBuildPhase;"
2843 puts $aPbxprojFile "\t\t\tbuildActionMask = 2147483647;"
2844 puts $aPbxprojFile "\t\t\tfiles = ("
2845 puts $aPbxprojFile $aDepsGuids
2846 puts $aPbxprojFile "\t\t\t);"
2847 puts $aPbxprojFile "\t\t\trunOnlyForDeploymentPostprocessing = 0;"
2848 puts $aPbxprojFile "\t\t\};\n"
2849 # End PBXFrameworksBuildPhase section
2851 # Begin PBXGroup section
2852 set aTkPBXGroup "${theToolKit}_PBXGroup"
2853 if { ! [info exists aGuidsMap($aTkPBXGroup)] } {
2854 set aGuidsMap($aTkPBXGroup) [OS:genGUID "xcd"]
2857 set aTkSrcGroup "${theToolKit}_SrcGroup"
2858 if { ! [info exists aGuidsMap($aTkSrcGroup)] } {
2859 set aGuidsMap($aTkSrcGroup) [OS:genGUID "xcd"]
2862 puts $aPbxprojFile $aGroupSection
2863 puts $aPbxprojFile "\t\t$aGuidsMap($aTkPBXGroup) = \{"
2864 puts $aPbxprojFile "\t\t\tisa = PBXGroup;"
2865 puts $aPbxprojFile "\t\t\tchildren = ("
2866 puts $aPbxprojFile $aDepsRefGuids
2867 puts $aPbxprojFile "\t\t\t\t$aGuidsMap($aTkSrcGroup) ,"
2868 puts $aPbxprojFile "\t\t\t\t$aGuidsMap($aToolkitLib) ,"
2869 puts $aPbxprojFile "\t\t\t);"
2870 puts $aPbxprojFile "\t\t\tsourceTree = \"<group>\";"
2871 puts $aPbxprojFile "\t\t\};"
2872 puts $aPbxprojFile "\t\t$aGuidsMap($aTkSrcGroup) = \{"
2873 puts $aPbxprojFile "\t\t\tisa = PBXGroup;"
2874 puts $aPbxprojFile "\t\t\tchildren = ("
2875 puts $aPbxprojFile $aPackagesGuids
2876 puts $aPbxprojFile "\t\t\t);"
2877 puts $aPbxprojFile "\t\t\tname = \"Source files\";"
2878 puts $aPbxprojFile "\t\t\tsourceTree = \"<group>\";"
2879 puts $aPbxprojFile "\t\t\};\n"
2880 # End PBXGroup section
2882 # Begin PBXHeadersBuildPhase section
2883 set aTkHeaders "${theToolKit}_Headers"
2884 if { ! [info exists aGuidsMap($aTkHeaders)] } {
2885 set aGuidsMap($aTkHeaders) [OS:genGUID "xcd"]
2888 puts $aPbxprojFile "\t\t$aGuidsMap($aTkHeaders) = \{"
2889 puts $aPbxprojFile "\t\t\tisa = PBX${aPBXBuildPhase}BuildPhase;"
2890 puts $aPbxprojFile "\t\t\tbuildActionMask = 2147483647;"
2891 puts $aPbxprojFile "\t\t\tfiles = ("
2892 puts $aPbxprojFile "\t\t\t);"
2893 puts $aPbxprojFile "\t\t\trunOnlyForDeploymentPostprocessing = ${aRunOnlyForDeployment};"
2894 puts $aPbxprojFile "\t\t\};\n"
2895 # End PBXHeadersBuildPhase section
2897 # Begin PBXNativeTarget section
2898 set aTkBuildCfgListNativeTarget "${theToolKit}_BuildCfgListNativeTarget"
2899 if { ! [info exists aGuidsMap($aTkBuildCfgListNativeTarget)] } {
2900 set aGuidsMap($aTkBuildCfgListNativeTarget) [OS:genGUID "xcd"]
2903 set aTkSources "${theToolKit}_Sources"
2904 if { ! [info exists aGuidsMap($aTkSources)] } {
2905 set aGuidsMap($aTkSources) [OS:genGUID "xcd"]
2908 puts $aPbxprojFile "\t\t$aGuidsMap($theToolKit) = \{"
2909 puts $aPbxprojFile "\t\t\tisa = PBXNativeTarget;"
2910 puts $aPbxprojFile "\t\t\tbuildConfigurationList = $aGuidsMap($aTkBuildCfgListNativeTarget) ;"
2911 puts $aPbxprojFile "\t\t\tbuildPhases = ("
2912 puts $aPbxprojFile "\t\t\t\t$aGuidsMap($aTkSources) ,"
2913 puts $aPbxprojFile "\t\t\t\t$aGuidsMap($aTkFrameworks) ,"
2914 puts $aPbxprojFile "\t\t\t\t$aGuidsMap($aTkHeaders) ,"
2915 puts $aPbxprojFile "\t\t\t);"
2916 puts $aPbxprojFile "\t\t\tbuildRules = ("
2917 puts $aPbxprojFile "\t\t\t);"
2918 puts $aPbxprojFile "\t\t\tdependencies = ("
2919 puts $aPbxprojFile "\t\t\t);"
2920 puts $aPbxprojFile "\t\t\tname = $theToolKit;"
2921 puts $aPbxprojFile "\t\t\tproductName = $theToolKit;"
2922 puts $aPbxprojFile "\t\t\tproductReference = $aGuidsMap($aToolkitLib) ;"
2923 puts $aPbxprojFile "\t\t\tproductType = \"com.apple.product-type.${aProductType}\";"
2924 puts $aPbxprojFile "\t\t\};\n"
2925 # End PBXNativeTarget section
2927 # Begin PBXProject section
2928 set aTkProjectObj "${theToolKit}_ProjectObj"
2929 if { ! [info exists aGuidsMap($aTkProjectObj)] } {
2930 set aGuidsMap($aTkProjectObj) [OS:genGUID "xcd"]
2933 set aTkBuildCfgListProj "${theToolKit}_BuildCfgListProj"
2934 if { ! [info exists aGuidsMap($aTkBuildCfgListProj)] } {
2935 set aGuidsMap($aTkBuildCfgListProj) [OS:genGUID "xcd"]
2938 puts $aPbxprojFile "\t\t$aGuidsMap($aTkProjectObj) = \{"
2939 puts $aPbxprojFile "\t\t\tisa = PBXProject;"
2940 puts $aPbxprojFile "\t\t\tattributes = \{"
2941 puts $aPbxprojFile "\t\t\t\tLastUpgradeCheck = 0430;"
2942 puts $aPbxprojFile "\t\t\t\};"
2943 puts $aPbxprojFile "\t\t\tbuildConfigurationList = $aGuidsMap($aTkBuildCfgListProj) ;"
2944 puts $aPbxprojFile "\t\t\tcompatibilityVersion = \"Xcode 3.2\";"
2945 puts $aPbxprojFile "\t\t\tdevelopmentRegion = English;"
2946 puts $aPbxprojFile "\t\t\thasScannedForEncodings = 0;"
2947 puts $aPbxprojFile "\t\t\tknownRegions = ("
2948 puts $aPbxprojFile "\t\t\t\ten,"
2949 puts $aPbxprojFile "\t\t\t);"
2950 puts $aPbxprojFile "\t\t\tmainGroup = $aGuidsMap($aTkPBXGroup);"
2951 puts $aPbxprojFile "\t\t\tproductRefGroup = $aGuidsMap($aTkPBXGroup);"
2952 puts $aPbxprojFile "\t\t\tprojectDirPath = \"\";"
2953 puts $aPbxprojFile "\t\t\tprojectRoot = \"\";"
2954 puts $aPbxprojFile "\t\t\ttargets = ("
2955 puts $aPbxprojFile "\t\t\t\t$aGuidsMap($theToolKit) ,"
2956 puts $aPbxprojFile "\t\t\t);"
2957 puts $aPbxprojFile "\t\t\};\n"
2958 # End PBXProject section
2960 # Begin PBXSourcesBuildPhase section
2961 puts $aPbxprojFile "\t\t$aGuidsMap($aTkSources) = \{"
2962 puts $aPbxprojFile "\t\t\tisa = PBXSourcesBuildPhase;"
2963 puts $aPbxprojFile "\t\t\tbuildActionMask = 2147483647;"
2964 puts $aPbxprojFile "\t\t\tfiles = ("
2965 puts $aPbxprojFile $aSrcFileGuids
2966 puts $aPbxprojFile "\t\t\t);"
2967 puts $aPbxprojFile "\t\t\trunOnlyForDeploymentPostprocessing = 0;"
2968 puts $aPbxprojFile "\t\t\};\n"
2969 # End PBXSourcesBuildPhase section
2971 # Begin XCBuildConfiguration section
2972 set aTkDebugProject "${theToolKit}_DebugProject"
2973 if { ! [info exists aGuidsMap($aTkDebugProject)] } {
2974 set aGuidsMap($aTkDebugProject) [OS:genGUID "xcd"]
2977 set aTkReleaseProject "${theToolKit}_ReleaseProject"
2978 if { ! [info exists aGuidsMap($aTkReleaseProject)] } {
2979 set aGuidsMap($aTkReleaseProject) [OS:genGUID "xcd"]
2982 set aTkDebugNativeTarget "${theToolKit}_DebugNativeTarget"
2983 if { ! [info exists aGuidsMap($aTkDebugNativeTarget)] } {
2984 set aGuidsMap($aTkDebugNativeTarget) [OS:genGUID "xcd"]
2987 set aTkReleaseNativeTarget "${theToolKit}_ReleaseNativeTarget"
2988 if { ! [info exists aGuidsMap($aTkReleaseNativeTarget)] } {
2989 set aGuidsMap($aTkReleaseNativeTarget) [OS:genGUID "xcd"]
2993 puts $aPbxprojFile "\t\t$aGuidsMap($aTkDebugProject) = \{"
2994 puts $aPbxprojFile "\t\t\tisa = XCBuildConfiguration;"
2995 puts $aPbxprojFile "\t\t\tbuildSettings = \{"
2997 puts $aPbxprojFile "\t\t\t\tDEBUG_INFORMATION_FORMAT = dwarf;"
2998 puts $aPbxprojFile "\t\t\t\tALWAYS_SEARCH_USER_PATHS = NO;"
2999 if { "$thePlatform" == "ios" } {
3000 puts $aPbxprojFile "\t\t\t\t\"ARCHS\[sdk=iphoneos\*\]\" = \"\$(ARCHS_STANDARD)\";";
3001 puts $aPbxprojFile "\t\t\t\t\"ARCHS\[sdk=iphonesimulator\*\]\" = \"x86_64\";";
3002 puts $aPbxprojFile "\t\t\t\tCLANG_CXX_LIBRARY = \"libc++\";"
3003 puts $aPbxprojFile "\t\t\t\tCLANG_ENABLE_MODULES = YES;"
3004 puts $aPbxprojFile "\t\t\t\tCLANG_ENABLE_OBJC_ARC = YES;"
3006 puts $aPbxprojFile "\t\t\t\tARCHS = \"\$(ARCHS_STANDARD_64_BIT)\";"
3007 puts $aPbxprojFile "\t\t\t\tCLANG_CXX_LANGUAGE_STANDARD = \"gnu++0x\";"
3008 puts $aPbxprojFile "\t\t\t\tCOPY_PHASE_STRIP = NO;"
3009 puts $aPbxprojFile "\t\t\t\tGCC_C_LANGUAGE_STANDARD = gnu99;"
3010 puts $aPbxprojFile "\t\t\t\tGCC_DYNAMIC_NO_PIC = NO;"
3011 puts $aPbxprojFile "\t\t\t\tGCC_ENABLE_OBJC_EXCEPTIONS = YES;"
3012 puts $aPbxprojFile "\t\t\t\tGCC_OPTIMIZATION_LEVEL = 0;"
3013 puts $aPbxprojFile "\t\t\t\tGCC_PREPROCESSOR_DEFINITIONS = ("
3014 puts $aPbxprojFile "\t\t\t\t\t\"DEBUG=1\","
3015 puts $aPbxprojFile "\t\t\t\t\t\"\$\(inherited\)\","
3016 puts $aPbxprojFile "\t\t\t\t);"
3017 puts $aPbxprojFile "\t\t\t\tGCC_SYMBOLS_PRIVATE_EXTERN = NO;"
3018 puts $aPbxprojFile "\t\t\t\tGCC_VERSION = com.apple.compilers.llvm.clang.1_0;"
3019 puts $aPbxprojFile "\t\t\t\tGCC_WARN_64_TO_32_BIT_CONVERSION = YES;"
3020 puts $aPbxprojFile "\t\t\t\tGCC_WARN_ABOUT_RETURN_TYPE = YES;"
3021 puts $aPbxprojFile "\t\t\t\tGCC_WARN_UNINITIALIZED_AUTOS = YES;"
3022 puts $aPbxprojFile "\t\t\t\tGCC_WARN_UNUSED_VARIABLE = YES;"
3023 puts $aPbxprojFile "\t\t\t\tOTHER_LDFLAGS = \"\$(CSF_OPT_LNK64D)\"; "
3024 if { "$thePlatform" == "ios" } {
3025 puts $aPbxprojFile "\t\t\t\tONLY_ACTIVE_ARCH = NO;"
3026 puts $aPbxprojFile "\t\t\t\tSDKROOT = iphoneos;"
3028 puts $aPbxprojFile "\t\t\t\tONLY_ACTIVE_ARCH = YES;"
3030 puts $aPbxprojFile "\t\t\t\};"
3032 puts $aPbxprojFile "\t\t\tname = Debug;"
3033 puts $aPbxprojFile "\t\t\};"
3036 puts $aPbxprojFile "\t\t$aGuidsMap($aTkReleaseProject) = \{"
3037 puts $aPbxprojFile "\t\t\tisa = XCBuildConfiguration;"
3038 puts $aPbxprojFile "\t\t\tbuildSettings = \{"
3040 puts $aPbxprojFile "\t\t\t\tDEBUG_INFORMATION_FORMAT = \"dwarf-with-dsym\";"
3041 puts $aPbxprojFile "\t\t\t\tALWAYS_SEARCH_USER_PATHS = NO;"
3042 if { "$thePlatform" == "ios" } {
3043 puts $aPbxprojFile "\t\t\t\t\"ARCHS\[sdk=iphoneos\*\]\" = \"\$(ARCHS_STANDARD)\";";
3044 puts $aPbxprojFile "\t\t\t\t\"ARCHS\[sdk=iphonesimulator\*\]\" = \"x86_64\";";
3045 puts $aPbxprojFile "\t\t\t\tCLANG_CXX_LIBRARY = \"libc++\";"
3046 puts $aPbxprojFile "\t\t\t\tCLANG_ENABLE_MODULES = YES;"
3047 puts $aPbxprojFile "\t\t\t\tCLANG_ENABLE_OBJC_ARC = YES;"
3049 puts $aPbxprojFile "\t\t\t\tARCHS = \"\$(ARCHS_STANDARD_64_BIT)\";"
3050 puts $aPbxprojFile "\t\t\t\tCLANG_CXX_LANGUAGE_STANDARD = \"gnu++0x\";"
3051 puts $aPbxprojFile "\t\t\t\tCOPY_PHASE_STRIP = YES;"
3052 puts $aPbxprojFile "\t\t\t\tGCC_C_LANGUAGE_STANDARD = gnu99;"
3053 puts $aPbxprojFile "\t\t\t\tGCC_ENABLE_OBJC_EXCEPTIONS = YES;"
3054 puts $aPbxprojFile "\t\t\t\tDEAD_CODE_STRIPPING = NO;"
3055 puts $aPbxprojFile "\t\t\t\tGCC_OPTIMIZATION_LEVEL = 2;"
3056 puts $aPbxprojFile "\t\t\t\tGCC_VERSION = com.apple.compilers.llvm.clang.1_0;"
3057 puts $aPbxprojFile "\t\t\t\tGCC_WARN_64_TO_32_BIT_CONVERSION = YES;"
3058 puts $aPbxprojFile "\t\t\t\tGCC_WARN_ABOUT_RETURN_TYPE = YES;"
3059 puts $aPbxprojFile "\t\t\t\tGCC_WARN_UNINITIALIZED_AUTOS = YES;"
3060 puts $aPbxprojFile "\t\t\t\tGCC_WARN_UNUSED_VARIABLE = YES;"
3061 puts $aPbxprojFile "\t\t\t\tOTHER_LDFLAGS = \"\$(CSF_OPT_LNK64)\";"
3062 if { "$thePlatform" == "ios" } {
3063 puts $aPbxprojFile "\t\t\t\tIPHONEOS_DEPLOYMENT_TARGET = 7.0;"
3064 puts $aPbxprojFile "\t\t\t\tSDKROOT = iphoneos;"
3066 puts $aPbxprojFile "\t\t\t\};"
3067 puts $aPbxprojFile "\t\t\tname = Release;"
3068 puts $aPbxprojFile "\t\t\};"
3069 puts $aPbxprojFile "\t\t$aGuidsMap($aTkDebugNativeTarget) = \{"
3070 puts $aPbxprojFile "\t\t\tisa = XCBuildConfiguration;"
3071 puts $aPbxprojFile "\t\t\tbuildSettings = \{"
3072 puts $aPbxprojFile "${anExecExtension}"
3073 puts $aPbxprojFile "${anExecPrefix}"
3074 puts $aPbxprojFile "\t\t\t\tGCC_PREPROCESSOR_DEFINITIONS = ("
3075 foreach aMacro $aTKDefines {
3076 puts $aPbxprojFile "\t\t\t\t\t${aMacro} ,"
3078 puts $aPbxprojFile "\t\t\t\t);"
3080 puts $aPbxprojFile "\t\t\t\tHEADER_SEARCH_PATHS = ("
3081 foreach anIncPath $anIncPaths {
3082 puts $aPbxprojFile "\t\t\t\t\t${anIncPath},"
3084 puts $aPbxprojFile "\t\t\t\t\t\"\$(CSF_OPT_INC)\","
3085 puts $aPbxprojFile "\t\t\t\t);"
3087 puts $aPbxprojFile "\t\t\t\tLIBRARY_SEARCH_PATHS = ("
3088 foreach anLibPath $anLibPaths {
3089 puts $aPbxprojFile "\t\t\t\t\t${anLibPath},"
3091 puts $aPbxprojFile "\t\t\t\t);"
3093 puts $aPbxprojFile "\t\t\t\tOTHER_CFLAGS = ("
3094 puts $aPbxprojFile "\t\t\t\t\t\"\$(CSF_OPT_CMPL)\","
3095 puts $aPbxprojFile "\t\t\t\t);"
3096 puts $aPbxprojFile "\t\t\t\tOTHER_CPLUSPLUSFLAGS = ("
3097 puts $aPbxprojFile "\t\t\t\t\t\"\$(OTHER_CFLAGS)\","
3098 puts $aPbxprojFile "\t\t\t\t);"
3099 puts $aPbxprojFile "\t\t\t\tPRODUCT_NAME = \"\$(TARGET_NAME)\";"
3100 set anUserHeaderSearchPath "\t\t\t\tUSER_HEADER_SEARCH_PATHS = \""
3101 foreach anIncPath $anIncPaths {
3102 append anUserHeaderSearchPath " ${anIncPath}"
3104 append anUserHeaderSearchPath "\";"
3105 puts $aPbxprojFile $anUserHeaderSearchPath
3106 puts $aPbxprojFile "${aWrapperExtension}"
3107 puts $aPbxprojFile "\t\t\t\};"
3108 puts $aPbxprojFile "\t\t\tname = Debug;"
3109 puts $aPbxprojFile "\t\t\};"
3110 puts $aPbxprojFile "\t\t$aGuidsMap($aTkReleaseNativeTarget) = \{"
3111 puts $aPbxprojFile "\t\t\tisa = XCBuildConfiguration;"
3112 puts $aPbxprojFile "\t\t\tbuildSettings = \{"
3113 puts $aPbxprojFile "${anExecExtension}"
3114 puts $aPbxprojFile "${anExecPrefix}"
3115 puts $aPbxprojFile "\t\t\t\tGCC_PREPROCESSOR_DEFINITIONS = ("
3116 foreach aMacro $aTKDefines {
3117 puts $aPbxprojFile "\t\t\t\t\t${aMacro} ,"
3119 puts $aPbxprojFile "\t\t\t\t);"
3120 puts $aPbxprojFile "\t\t\t\tHEADER_SEARCH_PATHS = ("
3121 foreach anIncPath $anIncPaths {
3122 puts $aPbxprojFile "\t\t\t\t\t${anIncPath},"
3124 puts $aPbxprojFile "\t\t\t\t\t\"\$(CSF_OPT_INC)\","
3125 puts $aPbxprojFile "\t\t\t\t);"
3127 puts $aPbxprojFile "\t\t\t\tLIBRARY_SEARCH_PATHS = ("
3128 foreach anLibPath $anLibPaths {
3129 puts $aPbxprojFile "\t\t\t\t\t${anLibPath},"
3131 puts $aPbxprojFile "\t\t\t\t);"
3133 puts $aPbxprojFile "\t\t\t\tOTHER_CFLAGS = ("
3134 puts $aPbxprojFile "\t\t\t\t\t\"\$(CSF_OPT_CMPL)\","
3135 puts $aPbxprojFile "\t\t\t\t);"
3136 puts $aPbxprojFile "\t\t\t\tOTHER_CPLUSPLUSFLAGS = ("
3137 puts $aPbxprojFile "\t\t\t\t\t\"\$(OTHER_CFLAGS)\","
3138 puts $aPbxprojFile "\t\t\t\t);"
3139 puts $aPbxprojFile "\t\t\t\tPRODUCT_NAME = \"\$(TARGET_NAME)\";"
3140 puts $aPbxprojFile $anUserHeaderSearchPath
3141 puts $aPbxprojFile "${aWrapperExtension}"
3142 puts $aPbxprojFile "\t\t\t\};"
3143 puts $aPbxprojFile "\t\t\tname = Release;"
3144 puts $aPbxprojFile "\t\t\};\n"
3145 # End XCBuildConfiguration section
3147 # Begin XCConfigurationList section
3148 puts $aPbxprojFile "\t\t$aGuidsMap($aTkBuildCfgListProj) = \{"
3149 puts $aPbxprojFile "\t\t\tisa = XCConfigurationList;"
3150 puts $aPbxprojFile "\t\tbuildConfigurations = ("
3151 puts $aPbxprojFile "\t\t\t\t$aGuidsMap($aTkDebugProject) ,"
3152 puts $aPbxprojFile "\t\t\t\t$aGuidsMap($aTkReleaseProject) ,"
3153 puts $aPbxprojFile "\t\t\t);"
3154 puts $aPbxprojFile "\t\t\tdefaultConfigurationIsVisible = 0;"
3155 puts $aPbxprojFile "\t\t\tdefaultConfigurationName = Release;"
3156 puts $aPbxprojFile "\t\t\};"
3157 puts $aPbxprojFile "\t\t$aGuidsMap($aTkBuildCfgListNativeTarget) = \{"
3158 puts $aPbxprojFile "\t\t\tisa = XCConfigurationList;"
3159 puts $aPbxprojFile "\t\t\tbuildConfigurations = ("
3160 puts $aPbxprojFile "\t\t\t\t$aGuidsMap($aTkDebugNativeTarget) ,"
3161 puts $aPbxprojFile "\t\t\t\t$aGuidsMap($aTkReleaseNativeTarget) ,"
3162 puts $aPbxprojFile "\t\t\t);"
3163 puts $aPbxprojFile "\t\t\tdefaultConfigurationIsVisible = 0;"
3164 puts $aPbxprojFile "\t\t\tdefaultConfigurationName = Release;"
3165 puts $aPbxprojFile "\t\t\};\n"
3166 # End XCConfigurationList section
3168 puts $aPbxprojFile "\t\};"
3169 puts $aPbxprojFile "\trootObject = $aGuidsMap($aTkProjectObj) ;"
3170 puts $aPbxprojFile "\}"
3175 proc osutils:xcdx { theOutDir theExecutable theGuidsMap } {
3176 set aUsername [exec whoami]
3178 # Creating folders for Xcode project file.
3179 set anExecutableDir "${theOutDir}/${theExecutable}.xcodeproj"
3180 wokUtils:FILES:mkdir $anExecutableDir
3181 if { ! [file exists $anExecutableDir] } {
3182 puts stderr "Error: Could not create project directory \"$anExecutableDir\""
3186 set aUserDataDir "${anExecutableDir}/xcuserdata"
3187 wokUtils:FILES:mkdir $aUserDataDir
3188 if { ! [file exists $aUserDataDir] } {
3189 puts stderr "Error: Could not create xcuserdata directorty in \"$anExecutableDir\""
3193 set aUserDataDir "${aUserDataDir}/${aUsername}.xcuserdatad"
3194 wokUtils:FILES:mkdir $aUserDataDir
3195 if { ! [file exists $aUserDataDir] } {
3196 puts stderr "Error: Could not create ${aUsername}.xcuserdatad directorty in \"$anExecutableDir\"/xcuserdata"
3200 set aSchemesDir "${aUserDataDir}/xcschemes"
3201 wokUtils:FILES:mkdir $aSchemesDir
3202 if { ! [file exists $aSchemesDir] } {
3203 puts stderr "Error: Could not create xcschemes directorty in \"$aUserDataDir\""
3206 # End folders creation.
3208 # Generating GUID for tookit.
3209 upvar $theGuidsMap aGuidsMap
3210 if { ! [info exists aGuidsMap($theExecutable)] } {
3211 set aGuidsMap($theExecutable) [OS:genGUID "xcd"]
3214 # Creating xcscheme file for toolkit from template.
3215 set aXcschemeTmpl [osutils:readtemplate "xcscheme" "xcode"]
3216 regsub -all -- {__TOOLKIT_NAME__} $aXcschemeTmpl $theExecutable aXcschemeTmpl
3217 regsub -all -- {__TOOLKIT_GUID__} $aXcschemeTmpl $aGuidsMap($theExecutable) aXcschemeTmpl
3218 set aXcschemeFile [open "$aSchemesDir/${theExecutable}.xcscheme" "w"]
3219 puts $aXcschemeFile $aXcschemeTmpl
3220 close $aXcschemeFile
3222 # Creating xcschememanagement.plist file for toolkit from template.
3223 set aPlistTmpl [osutils:readtemplate "plist" "xcode"]
3224 regsub -all -- {__TOOLKIT_NAME__} $aPlistTmpl $theExecutable aPlistTmpl
3225 regsub -all -- {__TOOLKIT_GUID__} $aPlistTmpl $aGuidsMap($theExecutable) aPlistTmpl
3226 set aPlistFile [open "$aSchemesDir/xcschememanagement.plist" "w"]
3227 puts $aPlistFile $aPlistTmpl