Check-in [427a4ac4ce]
Not logged in
HomePackagesLeavesTimelineBranchesTagsTicketsWikiLogin
Bounty program for improvements to Tcl and certain Tcl packages.
Tcl 2018 Conference, Houston/TX, US, Oct 15-19
Send your abstracts to tclconference@googlegroups.com or submit via the online form
by Aug 20.

Many hyperlinks are disabled.
Use anonymous login to enable hyperlinks.

Overview
Comment:The toadkit.rc file now builds in the local project's build directory, allowing scripts to leverage what the kitbuild discovered/built Moved all of the odie specific config data to a specific section which is now only consulted if a project.rc is not present. Reimplemented the build project in stages, with rules at the top to determine which stage needs to run when. All paths referenced by the KIT are stored in the KIT array
Timelines: family | ancestors | descendants | both | gort
Files: files | file ages | folders
SHA1: 427a4ac4ce6279fad61c220e2fdad7b160d70185
User & Date: hypnotoad 2016-02-29 23:24:01
Context
2016-02-29
23:59
Upgraded to tcl 8.6.5 Fixed some "only works on windows-isms" check-in: 4ca3730f2d user: hypnotoad tags: gort
23:24
The toadkit.rc file now builds in the local project's build directory, allowing scripts to leverage what the kitbuild discovered/built Moved all of the odie specific config data to a specific section which is now only consulted if a project.rc is not present. Reimplemented the build project in stages, with rules at the top to determine which stage needs to run when. All paths referenced by the KIT are stored in the KIT array check-in: 427a4ac4ce user: hypnotoad tags: gort
2016-02-27
16:39
Re-jiggered the package indexer to handle TM files and to do a better balance of including code in the master pkgIndex.tcl file vs farming out the processing to package directory pkgIndex.tcl files. (Keeping the processing local really speeds up load time for VFS's) check-in: 4da2fe27db user: hypnotoad tags: gort
Changes
Unified Diff Ignore Whitespace Patch
Changes to build.tcl.
︙︙
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109


110
111
112
113
114
115
116
117
118

        set package [lindex $line 2]
        set version [lindex $line 3]
        break
      }
      append buffer "package ifneeded $package $version \[list source \[file join \$dir [file tail $file]\]\]" \n
    }
    foreach file [glob -nocomplain $path/*.tcl] {
      #set file [file normalize $file]
      #if { $file == [file join $base tcl8.6 package.tcl] } continue
      #if { $file == [file join $base packages.tcl] } continue
      #if { $file == [file join $base main.tcl] } continue
      if { [file tail $file] == "version_info.tcl" } continue
      set fin [open $file r]
      set dat [read $fin]
      close $fin
      if {![regexp "package provide" $dat]} continue
      set fname [file rootname [file tail $file]]
      set thisline {}
      foreach line [split $dat \n] {
        append thisline \n $line
        if {![info complete $thisline]} continue
        set thisline [string trim $thisline]              
        if { [string range $thisline 0 14] != "package provide" } continue
        set package [lindex $thisline 2]
        set version [lindex $thisline 3]


        append buffer "package ifneeded $package $version \[list source \[file join \$dir [file tail $file]\]\]" \n
        set thisline {}
        break
      }
    }
    return $buffer
  }
  set fin [open $pkgidxfile r]
  set dat [read $fin]








<
<
<
<






|

<
<
|
|
|
|
>
>

<








85
86
87
88
89
90
91




92
93
94
95
96
97
98
99


100
101
102
103
104
105
106

107
108
109
110
111
112
113

        set package [lindex $line 2]
        set version [lindex $line 3]
        break
      }
      append buffer "package ifneeded $package $version \[list source \[file join \$dir [file tail $file]\]\]" \n
    }
    foreach file [glob -nocomplain $path/*.tcl] {




      if { [file tail $file] == "version_info.tcl" } continue
      set fin [open $file r]
      set dat [read $fin]
      close $fin
      if {![regexp "package provide" $dat]} continue
      set fname [file rootname [file tail $file]]
      # Look for a package provide statement
      foreach line [split $dat \n] {


        set line [string trim $line]              
        if { [string range $line 0 14] != "package provide" } continue
        set package [lindex $line 2]
        set version [lindex $line 3]
        if {[string index $package 0] in "\$ \["} continue
        if {[string index $version 0] in "\$ \["} continue
        append buffer "package ifneeded $package $version \[list source \[file join \$dir [file tail $file]\]\]" \n

        break
      }
    }
    return $buffer
  }
  set fin [open $pkgidxfile r]
  set dat [read $fin]
︙︙
252
253
254
255
256
257
258
259
















260













261
262

263
264

265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281




282
283
284
























































285







286


287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302

303
304
305
306
307
308

309
310
311
312
313
314
315
316
317
318
319
320


321
322
323
324
325
326
327
328
329
330
331
332
333
334
335

336
337
338
339
340
341
342
343
344
345
346
347


348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425





426
427
428
429
430
431



432



433
434
435
436


437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494



495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510



511





512






513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567

568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591

}

#########################################
#
# BEGIN THE KITBUILDING PROCESS HERE
#
#########################################

















source [file join $::HERE odieConfig.tcl]













if { $::odie(platform) eq "windows" } {
  set ::KIT(EXEEXT) .exe

} else {
  set ::KIT(EXEEXT) {}

}
set PKGPREFIX /tcl

foreach dpath {
  {$PWD}
  {$PWD ..}
  {$::odie(sandbox)}
} {
  set path [file normalize [file join {*}[subst $dpath]]]
  set TCLSRCDIR  [file join $path toadkit$::odie_tcl(version)$::odie_tcl(patch_level) tcl]
  set TKSRCDIR   [file join $path toadkit$::odie_tcl(version)$::odie_tcl(patch_level) tk]
  set PKGROOT    [file join $path toadkit$::odie_tcl(version)$::odie_tcl(patch_level) pkg]
  set BASEKITVFS [file join $path toadkit$::odie_tcl(version)$::odie_tcl(patch_level) vfs]
  if {[file exists $TCLSRCDIR]} {
    break
  }
}




set _TclSrcDir [file join $TCLSRCDIR $::odie(tcl_src_dir)]
set _TkSrcDir  [file join $TKSRCDIR $::odie(tcl_src_dir)]

























































puts "BUILDING ZipVFS KITS"







if {"toadkit" in $argv || ![file exists tclkit_bare$::KIT(EXEEXT)]} {


  file mkdir build
  file mkdir [file join $BASEKITVFS boot]
  ###
  # Build a starter VFS for both Tcl and wish
  ###
  set USEMSVC [info exists env(VisualStudioVersion)]



  if {![file exists $TCLSRCDIR]} {
    copyDir $::odie_tcl(src_dir) $TCLSRCDIR
    cd $_TclSrcDir
    catch {domake distclean}
  }
  set tclConfig.sh [file join $_TclSrcDir tclConfig.sh]
  if {$USEMSVC} {

    cd $_TclSrcDir
    doexec nmake -f makefile.vc INSTALLDIR=$PKGROOT release
    doexec nmake -f makefile.vc INSTALLDIR=$PKGROOT install
    cd $PWD
  } else {
    if {![file exists ${tclConfig.sh}]} {

      cd $_TclSrcDir
      set opts {}
      if {$::odie(host) != $::odie(target)} {
        lappend opts --host=$::odie(target)
      }
      lappend opts {*}$::odie(tcl_config_flags) --prefix=$PKGPREFIX --exec_prefix=$PKGPREFIX --with-tzdata --enable-shared=no
      doexec sh configure {*}$opts
      domake binaries
      domake packages
      cd $PWD
    }
  }


  if {![file exists $TKSRCDIR]} {
    copyDir $::odie_tk(src_dir) $TKSRCDIR
    cd [file join $_TkSrcDir]
    catch {domake distclean}
  }

  set tkConfig.sh  [file join $_TkSrcDir tkConfig.sh]
  if {$USEMSVC} {
    cd $_TkSrcDir
    puts "BUILD TK"
    doexec nmake -f makefile.vc TCLDIR=[file nativename $TCLSRCDIR] INSTALLDIR=$PKGROOT release
    doexec nmake -f makefile.vc TCLDIR=[file nativename $TCLSRCDIR] INSTALLDIR=$PKGROOT install
    cd $PWD
  } else {
    if {![file exists ${tkConfig.sh}]} {

      set opts {}
      cd $_TkSrcDir
      if {$::odie(host) != $::odie(target)} {
        lappend opts --host=$::odie(target)
      }
      lappend opts {*}$::odie(tk_config_flags) --with-tcl=$_TclSrcDir --enable-shared=yes
      doexec sh configure {*}$opts
      domake binaries
      cd $PWD
    }
  }



  set ::KIT(OBJS) {}
  set ::KIT(INCLUDES) {}
  ###
  # Read tclConfig.sh and tkConfig.sh
  ###
  foreach {array pre file} [list ::TCL tcl ${tclConfig.sh} ::TK tk ${tkConfig.sh}] {
    set l [expr {[string length $pre]+1}]
    foreach {field dat} [read_Config.sh $file] {
      set field [string tolower $field]
      if {[string match ${pre}_* $field]} {
        set field [string range $field $l end]
      }
      set ${array}($field) $dat
      if {[info exists ::KIT($field)]} {
        if {$::KIT($field) ne $dat} {
          unset ::KIT($field)
        }
      } else {
        set ::KIT($field) $dat
      }
    }
  }

  ###
  # Add/synthesize bits
  ###
  lappend ::KIT(INCLUDES) [file join $TKSRCDIR generic]
  lappend ::KIT(INCLUDES) [file join $TKSRCDIR $::odie(tcl_src_dir)]
  lappend ::KIT(INCLUDES) [file join $TKSRCDIR bitmaps]
  lappend ::KIT(INCLUDES) [file join $TKSRCDIR xlib]
  
  lappend ::KIT(INCLUDES) [file join $TCLSRCDIR generic]
  lappend ::KIT(INCLUDES) [file join $TCLSRCDIR $::odie(tcl_src_dir)]
  #lappend ::KIT(INCLUDES) [file join $$TCLSRCDIR compat]
  lappend ::KIT(INCLUDES) [file join $TCLSRCDIR compat zlib]
  
  lappend ::KIT(INCLUDES) [file join $::HERE generic]
  lappend ::KIT(INCLUDES) [file join $::HERE $::odie(tcl_src_dir)]
  
  if { $::odie(platform) eq "windows" } {
    set ::KIT(EXEEXT) .exe
    set ::KIT(LDFLAGS_CONSOLE) {-mconsole -pipe -static-libgcc}
    set ::KIT(LDFLAGS_WINDOW) {-mwindows -pipe -static-libgcc}
    set ::KIT(EXTRA_CFLAGS) {-DTCL_TOMMATH -DMP_PREC=4 -DUNICODE -D_UNICODE -DBUILD_tcl -DBUILD_tk -DBUILD_ttk -DSTATIC_BUILD}

    if {[file exists [file join $PWD tclkit.rc]]} {
      set RCSRC [file join $PWD tclkit.rc]
    } else {
      set RCSRC [file join $_TkSrcDir rc wish.rc]
    }
    doexec windres -o [file join $PWD tclkit.res.o] -DSTATIC_BUILD \
      --include [file join $TCLSRCDIR generic] --include [file join $TKSRCDIR generic] \
      --include $_TkSrcDir \
      --include [file join $_TkSrcDir rc] $RCSRC

    lappend ::KIT(TCLSHELL_OBJS) [file join $PWD tclkit.res.o] 
    lappend ::KIT(WISHSHELL_OBJS) [file join $PWD tclkit.res.o]
    lappend ::KIT(INCLUDES) [file join $_TkSrcDir rc]
  } else {
    set ::KIT(EXEEXT) {}
    set ::KIT(LDFLAGS_CONSOLE) {}
    set ::KIT(LDFLAGS_WINDOW) {}
    set ::KIT(EXTRA_CFLAGS) {-DTCL_TOMMATH -DMP_PREC=4 -DBUILD_tk -DBUILD_ttk}
  }

  set ::KIT(LIBS) {}
  set ::KIT(defs) $::TK(defs)
  
  set fout [open toadkit.rc w]
  puts $fout "array set ::TCL \{"
  foreach {field value} [lsort -stride 2 [array get ::TCL]] {
    puts $fout "  [list $field $value]"
  }
  puts $fout "\}"
  puts $fout "array set ::TK \{"
  foreach {field value} [lsort -stride 2 [array get ::TK]] {
    puts $fout "  [list $field $value]"
  }





  puts $fout "\}"
  puts $fout "array set ::KIT \{"
  foreach {field value} [lsort -stride 2 [array get ::KIT]] {
    puts $fout "  [list $field $value]"
  }
  puts $fout "\}"



  



  ###
  # Compile our C bits
  ###
  


  
  ###
  # Rig ourselves to statically build the bits of
  # zlib we need
  ###
  set cdir [file join $TCLSRCDIR compat zlib]
  foreach file {
    adler32.c compress.c crc32.c
    deflate.c infback.c inffast.c
    inflate.c inftrees.c trees.c
    uncompr.c zutil.c
  } {
    COMPILE LIBTOADKIT [file join $cdir $file]
  }
  
  set cdir [file join $::HERE generic]
  foreach file {
    password.c rc4.c tclkit_init.c zvfs.c zvfsboot.c
  } {
    COMPILE LIBTOADKIT [file join $cdir $file]
  }
  
  set cdir [file join $::HERE $::odie(tcl_src_dir)]
  if { $::odie(platform) eq "windows" } {
    # tkwinico.c tlink32.c
    foreach file {
      tclsh_packages.c
    } {
      COMPILE LIBTOADKIT [file join $cdir $file]
    }
    COMPILE TCLSHELL [file join $_TclSrcDir tclAppInit.c] [list -DTCL_LOCAL_MAIN_HOOK=Toadkit_MainHook -DTCL_LOCAL_APPINIT=Toadkit_AppInit]
    COMPILE WISHSHELL [file join $_TkSrcDir winMain.c] [list -DTK_LOCAL_MAIN_HOOK=Toadkit_MainHook -DTK_LOCAL_APPINIT=Toadkit_AppInit]
  } else {
    foreach file {
      tclsh_packages.c
    } {
      COMPILE LIBTOADKIT [file join $cdir $file]
    }
    COMPILE TCLSHELL [file join $$_TclSrcDir tclAppInit.c] [list -DTCL_LOCAL_MAIN_HOOK=Toadkit_MainHook -DTCL_LOCAL_APPINIT=Toadkit_AppInit]
    COMPILE WISHSHELL [file join $_TkSrcDir tclAppInit.c] [list -DTK_LOCAL_MAIN_HOOK=Toadkit_MainHook -DTK_LOCAL_APPINIT=Toadkit_AppInit]
  }
  
  
  ###
  # Link together our executable
  ###
  doexec ar cr libtoadkit.a {*}$::KIT(LIBTOADKIT_OBJS) [file join $_TclSrcDir libtclstub86.a]
  doexec ranlib libtoadkit.a
  
  # Build a Tcl-only shell
  set cmd [list $::KIT(cc)  {*}$::KIT(cflags_optimize) {*}$::KIT(shlib_cflags)]
  lappend cmd {*}$::KIT(TCLSHELL_OBJS)
  foreach item [glob ${_TclSrcDir}/*.a] {
    lappend cmd $item
  }
  lappend cmd libtoadkit.a {*}$::TCL(libs)
  lappend cmd -o tclkit_bare$::KIT(EXEEXT) {*}$::KIT(LDFLAGS_CONSOLE)
  doexec {*}$cmd




  set pkg_paths [glob [file join $TCLSRCDIR pkgs *]]
  foreach pkgpath $pkg_paths {
    if {[string range [file tail $pkgpath] 0 3] eq "itcl"} continue
    if {![file isdirectory $pkgpath]} continue
    cd $pkgpath
    if {![file exists [file join $pkgpath Makefile]]} {
      if {[file exists [file join $pkgpath Makefile.in]]} {
        doexec sh configure --with-tcl=$_TclSrcDir --with-tclinclude=[file join $TCLSRCDIR generic] --with-tzdata --enable-shared --enable-threads
      } else {
        continue
      }
    }
    puts "INSTALLING to VFS [file tail $pkgpath]"
    domake install DESTDIR=$PKGROOT
  }



  cd $PWD












  if {[file exists $BASEKITVFS]} {
    file delete -force $BASEKITVFS
  }
  puts "***
*** BASE KIT VFS PACKAGES
***"
  puts [list COPY [file join $PKGROOT [string trimleft $PKGPREFIX /] lib]]
  copyDir [file join $PKGROOT [string trimleft $PKGPREFIX /] lib] [file join $BASEKITVFS pkgs]
  
  copyDir [file join $TCLSRCDIR library] [file join $BASEKITVFS boot tcl]
  if { $::odie(platform) eq "windows" } {
    set ddedll [glob -nocomplain [file join $_TclSrcDir tcldde*.dll]]
    if {$ddedll != {}} {
      file copy $ddedll [file join $BASEKITVFS boot tcl dde]
    }
    set regdll [glob -nocomplain [file join $_TclSrcDir tclreg*.dll]]
    if {$regdll != {}} {
      file copy $regdll [file join $BASEKITVFS boot tcl reg]
    }
  } else {
    file delete -force [file join $BASEKITVFS boot tcl dde]
    file delete -force [file join $BASEKITVFS boot tcl reg]
  }
  
  copyDir [file join $TKSRCDIR library] $BASEKITVFS/boot/tk
  set dllsrc [file join $_TkSrcDir [string trim $::TK(dll_file) \"]]
  file copy -force $dllsrc [file join $BASEKITVFS boot tk]
  
  
  # For the following packages, cat their pkgIndex files to tclIndex
  if {$::tcl_platform(platform) eq {unix}} {
      file attributes [file join $BASEKITVFS boot tcl tclIndex] -permissions 0744
  } else {
      file attributes [file join $BASEKITVFS boot tcl tclIndex] -readonly 0
  }

  
  set fout [open [file join $BASEKITVFS boot tcl tclIndex] a]
  puts $fout {#
# MANIFEST OF INCLUDED PACKAGES
#
}
  puts $fout [string map [list @TKVERSION@ $::TK(version)$::TK(patch_level) @TKDLL@ [string trim $::TK(dll_file) \"]] {
package ifneeded Tk @TKVERSION@ [list load $::tk_library/@TKDLL@ Tk]
  }]
  puts $fout {
if {[file exists /zvfs/pkgIndex.tcl]} {
  set dir /zvfs
  source /zvfs/pkgIndex.tcl
}
  }
  #close $fout
  close $fout
}
cd $PWD


if {[lindex $argv 0] eq "toadkit"} {
  package ifneeded zipfile::mkzip 1.2 [list source [file join $::HERE scripts mkzip.tcl]]
  package require zipfile::mkzip
  set fout [open [file join $BASEKITVFS pkgIndex.tcl] w]
  set buffer [::practcl::pkgindex_path $BASEKITVFS]
  puts $fout $buffer
  close $fout
  ::zipfile::mkzip::mkzip toadkit$::KIT(EXEEXT) -runtime tclkit_bare$::KIT(EXEEXT) -directory $BASEKITVFS 
}
cd $PWD

if {[lindex $argv 0] eq "wrap"} {
  set name [lindex $argv 1]
  set vfspath [lindex $argv 2]
  package ifneeded zipfile::mkzip 1.2 [list source [file join $::HERE scripts mkzip.tcl]]
  package require zipfile::mkzip
  copyDir $BASEKITVFS $vfspath
  set fout [open [file join $vfspath pkgIndex.tcl] w]
  set buffer [::practcl::pkgindex_path $vfspath]
  puts $fout $buffer
  close $fout
  ::zipfile::mkzip::mkzip ${name}$::KIT(EXEEXT) -runtime tclkit_bare$::KIT(EXEEXT) -directory $vfspath
}








|
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
|
>
>
>
>
>
>
>
>
>
>
>
>
>
|

>


>



|
<
<
<
<
|
|
|
|
|
|



>
>
>
>
|
|

>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
|
>
>
>
>
>
>
>
|
>
>

|




<
<
<
|
|



<

>

|
|


|
>


|
|

|






>
>
|
|



<
<



|
|


|
>


|
|

|





|
>
>





|




















|
|
|
|

|
|
|
|


|

|











|
















|









>
>
>
>
>






>
>
>
|
>
>
>

|

|
>
>
|




|
















|
|

















<
<



|
|
|
<
<
<
<
<
|
<
<
|
>
>
>
|
|






|





|

>
>
>

>
>
>
>
>
|
>
>
>
>
>
>
|
|




|
|

|
|


|



|


|
|


|

|




|

|



|

















>




|
|


|








|







247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294




295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383



384
385
386
387
388

389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416


417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582


583
584
585
586
587
588





589


590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705

}

#########################################
#
# BEGIN THE KITBUILDING PROCESS HERE
#
#########################################
set _search_paths {{$PWD} {$PWD ..}}
if {[file exists [file join $PWD project.rc]]} {
  source [file join $PWD project.rc]
  set ::KIT(platform) $::project(TEA_PLATFORM)
  set ::KIT(ORIG_TCL_SRC_DIR) $::project(TCL_SRC_DIR)
  set ::KIT(ORIG_TK_SRC_DIR) $::project(TK_SRC_DIR)
  set ::KIT(TCL_BUILD_OPTS) {}
  set ::KIT(TK_BUILD_OPTS) {}
  set ::KIT(HOST) $::project(TEA_PLATFORM)
  set ::KIT(TARGET) $::project(TEA_PLATFORM)
  set ::KIT(TCL_VERSION) $::project(TCL_VERSION)
  set ::KIT(TK_VERSION) $::project(TK_VERSION)  
  set ::KIT(TCL_PATCH_LEVEL) $::project(TCL_PATCH_LEVEL)
  set ::KIT(TK_PATCH_LEVEL) $::project(TCL_PATCH_LEVEL)
  set ::KIT(sandbox) [file dirname $::project(srcdir)]
  lappend _search_paths {$::KIT(sandbox)}
} else {
  source [file join $::HERE odieConfig.tcl]
  set ::KIT(platform) ::odie(platform)
  set ::KIT(ORIG_TCL_SRC_DIR) $::odie_tcl(src_dir)
  set ::KIT(ORIG_TK_SRC_DIR) $::odie_tk(src_dir)
  set ::KIT(TCL_BUILD_OPTS) $::odie(tcl_config_flags)
  set ::KIT(TK_BUILD_OPTS) $::odie(tk_config_flags)
  set ::KIT(HOST) $::odie(host)
  set ::KIT(TARGET) $::odie(target)
  set ::KIT(TCL_VERSION) $::odie_tcl(version)
  set ::KIT(TK_VERSION) $::odie_tk(version)
  set ::KIT(TCL_PATCH_LEVEL) $::odie_tcl(patch_level)
  set ::KIT(TK_PATCH_LEVEL) $::odie_tk(patch_level)
  lappend _search_paths $::odie(sandbox)
}
if { $::KIT(platform) eq "windows" } {
  set ::KIT(EXEEXT) .exe
  set ::KIT(platform_src_dir) win
} else {
  set ::KIT(EXEEXT) {}
  set ::KIT(platform_src_dir) win
}
set PKGPREFIX /tcl

foreach dpath $_search_paths {




  set path [file normalize [file join {*}[subst $dpath] toadkit$::KIT(TCL_VERSION)$::KIT(TCL_PATCH_LEVEL)]]
  set KIT(TCLSRCDIR)  [file join $path tcl]
  set KIT(TKSRCDIR)   [file join $path tk]
  set KIT(PKGROOT)    [file join $path pkg]
  set KIT(BASEVFS)    [file join $path vfs]
  if {[file exists $KIT(TCLSRCDIR)]} {
    break
  }
}

###
# Sort out our various build products
###
set _TclSrcDir [file join $KIT(TCLSRCDIR) $::KIT(platform_src_dir)]
set _TkSrcDir  [file join $KIT(TKSRCDIR) $::KIT(platform_src_dir)]

set ::TARGET(tclConfig.sh) [file join $_TclSrcDir tclConfig.sh]
set ::TARGET(tkConfig.sh)  [file join $_TkSrcDir tkConfig.sh]
set ::TARGET(libtoadkit.a) [file join $PWD libtoadkit.a]
set ::TARGET(tclkit_bare)  [file join $PWD tclkit_bare$::KIT(EXEEXT)]
set ::TARGET(toadkit.rc)   [file join $PWD toadkit.rc]

array set build {
  tcl 0
  tk  0
  packages 0
  basekitvfs 0
  toadkit.rc 0
  toadkit 0
  tclkit_bare 0
  libtoadkit.a 0
}
file mkdir build
if {"force" in $argv || "toadkit" in $argv} {
  set build(toadkit) 1
}
if {![file exists $::TARGET(toadkit.rc)]} {
  set build(toadkit.rc) 1
}
if {![file exists $::TARGET(tclkit_bare)]} {
  set build(tclkit_bare) 1
}
if {![file exists $::TARGET(tclConfig.sh)]} {
  set build(tcl) 1
  set build(tk) 1
}
if {![file exists $::TARGET(tkConfig.sh)]} {
  set build(tk) 1
}
if {![file exists $::TARGET(libtoadkit.a)]} {
  set build(libtoadkit.a) 1
}
if {![file exists $KIT(PKGROOT)]} {
  set build(packages) 1
}
if {![file exists $KIT(BASEVFS)]} {
  set build(basekitvfs) 1
}
if {$build(tcl) || $build(tk) || $build(toadkit)} {
  set build(packages) 1
  set build(basekitvfs) 1
  set build(toadkit.rc) 1
  set build(tclkit_bare) 1
  set build(libtoadkit.a) 1
}
if {$build(libtoadkit.a)} {
  set build(tclkit_bare) 1
}
if {$build(packages)} {
  set build(basekitvfs) 1
}

puts "***
KIT(TCLSRCDIR):  [file exists $KIT(TCLSRCDIR)] $KIT(TCLSRCDIR)
KIT(TKSRCDIR):   [file exists $KIT(TKSRCDIR)] $KIT(TKSRCDIR)
KIT(PKGROOT):    [file exists $KIT(PKGROOT)] $KIT(PKGROOT)
KIT(BASEVFS):    [file exists $KIT(BASEVFS)] $KIT(BASEVFS)
toadkit.rc:      [file exists $::TARGET(toadkit.rc)] $::TARGET(toadkit.rc)
***"
parray build


if {$build(tcl)} {
  file mkdir build
  file mkdir [file join $KIT(BASEVFS) boot]
  ###
  # Build a starter VFS for both Tcl and wish
  ###
  set USEMSVC [info exists env(VisualStudioVersion)]



  if {![file exists $KIT(TCLSRCDIR)]} {
    copyDir $::KIT(ORIG_TCL_SRC_DIR) $KIT(TCLSRCDIR)
    cd $_TclSrcDir
    catch {domake distclean}
  }

  if {$USEMSVC} {
    puts "BUILDING Static Tcl"
    cd $_TclSrcDir
    doexec nmake -f makefile.vc INSTALLDIR=$KIT(PKGROOT) release
    doexec nmake -f makefile.vc INSTALLDIR=$KIT(PKGROOT) install
    cd $PWD
  } else {
    if {![file exists $::TARGET(tclConfig.sh)]} {
      puts "BUILDING Static Tcl"
      cd $_TclSrcDir
      set opts {}
      if {$::KIT(HOST) != $::KIT(TARGET)} {
        lappend opts --host=$::KIT(TARGET)
      }
      lappend opts {*}$::KIT(TCL_BUILD_OPTS) --prefix=$PKGPREFIX --exec_prefix=$PKGPREFIX --with-tzdata --enable-shared=no
      doexec sh configure {*}$opts
      domake binaries
      domake packages
      cd $PWD
    }
  }
}
if {$build(tk)} {
  if {![file exists $KIT(TKSRCDIR)]} {
    copyDir $::KIT(ORIG_TK_SRC_DIR) $KIT(TKSRCDIR)
    cd [file join $_TkSrcDir]
    catch {domake distclean}
  }


  if {$USEMSVC} {
    cd $_TkSrcDir
    puts "BUILD TK"
    doexec nmake -f makefile.vc TCLDIR=[file nativename $KIT(TCLSRCDIR)] INSTALLDIR=$KIT(PKGROOT) release
    doexec nmake -f makefile.vc TCLDIR=[file nativename $KIT(TCLSRCDIR)] INSTALLDIR=$KIT(PKGROOT) install
    cd $PWD
  } else {
    if {![file exists $::TARGET(tkConfig.sh)]} {
      puts "BUILD TK"
      set opts {}
      cd $_TkSrcDir
      if {$::KIT(HOST) != $::KIT(TARGET)} {
        lappend opts --host=$::KIT(TARGET)
      }
      lappend opts {*}$::KIT(TK_BUILD_OPTS) --with-tcl=$_TclSrcDir --enable-shared=yes
      doexec sh configure {*}$opts
      domake binaries
      cd $PWD
    }
  }
}

if {$build(toadkit.rc)} {
  set ::KIT(OBJS) {}
  set ::KIT(INCLUDES) {}
  ###
  # Read tclConfig.sh and tkConfig.sh
  ###
  foreach {array pre file} [list ::TCL tcl $::TARGET(tclConfig.sh) ::TK tk $::TARGET(tkConfig.sh)] {
    set l [expr {[string length $pre]+1}]
    foreach {field dat} [read_Config.sh $file] {
      set field [string tolower $field]
      if {[string match ${pre}_* $field]} {
        set field [string range $field $l end]
      }
      set ${array}($field) $dat
      if {[info exists ::KIT($field)]} {
        if {$::KIT($field) ne $dat} {
          unset ::KIT($field)
        }
      } else {
        set ::KIT($field) $dat
      }
    }
  }

  ###
  # Add/synthesize bits
  ###
  lappend ::KIT(INCLUDES) [file join $KIT(TKSRCDIR) generic]
  lappend ::KIT(INCLUDES) [file join $KIT(TKSRCDIR) $::KIT(platform_src_dir)]
  lappend ::KIT(INCLUDES) [file join $KIT(TKSRCDIR) bitmaps]
  lappend ::KIT(INCLUDES) [file join $KIT(TKSRCDIR) xlib]
  
  lappend ::KIT(INCLUDES) [file join $KIT(TCLSRCDIR) generic]
  lappend ::KIT(INCLUDES) [file join $KIT(TCLSRCDIR) $::KIT(platform_src_dir)]
  #lappend ::KIT(INCLUDES) [file join $$KIT(TCLSRCDIR) compat]
  lappend ::KIT(INCLUDES) [file join $KIT(TCLSRCDIR) compat zlib]
  
  lappend ::KIT(INCLUDES) [file join $::HERE generic]
  lappend ::KIT(INCLUDES) [file join $::HERE $::KIT(platform_src_dir)]
  
  if { $::KIT(platform) eq "windows" } {
    set ::KIT(EXEEXT) .exe
    set ::KIT(LDFLAGS_CONSOLE) {-mconsole -pipe -static-libgcc}
    set ::KIT(LDFLAGS_WINDOW) {-mwindows -pipe -static-libgcc}
    set ::KIT(EXTRA_CFLAGS) {-DTCL_TOMMATH -DMP_PREC=4 -DUNICODE -D_UNICODE -DBUILD_tcl -DBUILD_tk -DBUILD_ttk -DSTATIC_BUILD}

    if {[file exists [file join $PWD tclkit.rc]]} {
      set RCSRC [file join $PWD tclkit.rc]
    } else {
      set RCSRC [file join $_TkSrcDir rc wish.rc]
    }
    doexec windres -o [file join $PWD tclkit.res.o] -DSTATIC_BUILD \
      --include [file join $KIT(TCLSRCDIR) generic] --include [file join $KIT(TKSRCDIR) generic] \
      --include $_TkSrcDir \
      --include [file join $_TkSrcDir rc] $RCSRC

    lappend ::KIT(TCLSHELL_OBJS) [file join $PWD tclkit.res.o] 
    lappend ::KIT(WISHSHELL_OBJS) [file join $PWD tclkit.res.o]
    lappend ::KIT(INCLUDES) [file join $_TkSrcDir rc]
  } else {
    set ::KIT(EXEEXT) {}
    set ::KIT(LDFLAGS_CONSOLE) {}
    set ::KIT(LDFLAGS_WINDOW) {}
    set ::KIT(EXTRA_CFLAGS) {-DTCL_TOMMATH -DMP_PREC=4 -DBUILD_tk -DBUILD_ttk}
  }

  set ::KIT(LIBS) {}
  set ::KIT(defs) $::TK(defs)
  
  set fout [open $::TARGET(toadkit.rc) w]
  puts $fout "array set ::TCL \{"
  foreach {field value} [lsort -stride 2 [array get ::TCL]] {
    puts $fout "  [list $field $value]"
  }
  puts $fout "\}"
  puts $fout "array set ::TK \{"
  foreach {field value} [lsort -stride 2 [array get ::TK]] {
    puts $fout "  [list $field $value]"
  }
  puts $fout "\}"
  puts $fout "array set ::TARGET \{"
  foreach {field value} [lsort -stride 2 [array get ::TARGET]] {
    puts $fout "  [list $field $value]"
  }
  puts $fout "\}"
  puts $fout "array set ::KIT \{"
  foreach {field value} [lsort -stride 2 [array get ::KIT]] {
    puts $fout "  [list $field $value]"
  }
  puts $fout "\}"
  close $fout
} else {
  source $::TARGET(toadkit.rc)
}


if {$build(libtoadkit.a)} {
  ###
  # Compile our resident static C library
  ###
  cd $PWD
  if {[file exists $::TARGET(libtoadkit.a)]} {
    file delete $::TARGET(libtoadkit.a)
  }
  ###
  # Rig ourselves to statically build the bits of
  # zlib we need
  ###
  set cdir [file join $KIT(TCLSRCDIR) compat zlib]
  foreach file {
    adler32.c compress.c crc32.c
    deflate.c infback.c inffast.c
    inflate.c inftrees.c trees.c
    uncompr.c zutil.c
  } {
    COMPILE LIBTOADKIT [file join $cdir $file]
  }
  
  set cdir [file join $::HERE generic]
  foreach file {
    password.c rc4.c tclkit_init.c zvfs.c zvfsboot.c
  } {
    COMPILE LIBTOADKIT [file join $cdir $file]
  }
  
  set cdir [file join $::HERE $::KIT(platform_src_dir)]
  if { $::KIT(platform) eq "windows" } {
    # tkwinico.c tlink32.c
    foreach file {
      tclsh_packages.c
    } {
      COMPILE LIBTOADKIT [file join $cdir $file]
    }
    COMPILE TCLSHELL [file join $_TclSrcDir tclAppInit.c] [list -DTCL_LOCAL_MAIN_HOOK=Toadkit_MainHook -DTCL_LOCAL_APPINIT=Toadkit_AppInit]
    COMPILE WISHSHELL [file join $_TkSrcDir winMain.c] [list -DTK_LOCAL_MAIN_HOOK=Toadkit_MainHook -DTK_LOCAL_APPINIT=Toadkit_AppInit]
  } else {
    foreach file {
      tclsh_packages.c
    } {
      COMPILE LIBTOADKIT [file join $cdir $file]
    }
    COMPILE TCLSHELL [file join $$_TclSrcDir tclAppInit.c] [list -DTCL_LOCAL_MAIN_HOOK=Toadkit_MainHook -DTCL_LOCAL_APPINIT=Toadkit_AppInit]
    COMPILE WISHSHELL [file join $_TkSrcDir tclAppInit.c] [list -DTK_LOCAL_MAIN_HOOK=Toadkit_MainHook -DTK_LOCAL_APPINIT=Toadkit_AppInit]
  }


  ###
  # Link together our executable
  ###
  doexec ar cr $::TARGET(libtoadkit.a) {*}$::KIT(LIBTOADKIT_OBJS) [file join $_TclSrcDir libtclstub86.a]
  doexec ranlib $::TARGET(libtoadkit.a)
}








if {$build(packages)} {
  cd $PWD
  if {[file exists $KIT(PKGROOT)]} {
    file delete -force $KIT(PKGROOT)
  }
  set pkg_paths [glob [file join $KIT(TCLSRCDIR) pkgs *]]
  foreach pkgpath $pkg_paths {
    if {[string range [file tail $pkgpath] 0 3] eq "itcl"} continue
    if {![file isdirectory $pkgpath]} continue
    cd $pkgpath
    if {![file exists [file join $pkgpath Makefile]]} {
      if {[file exists [file join $pkgpath Makefile.in]]} {
        doexec sh configure --with-tcl=$_TclSrcDir --with-tclinclude=[file join $KIT(TCLSRCDIR) generic] --with-tzdata --enable-shared --enable-threads
      } else {
        continue
      }
    }
    puts "INSTALLING to VFS [file tail $pkgpath]"
    domake install DESTDIR=$KIT(PKGROOT)
  }
}

if {$build(tclkit_bare)} {
  cd $PWD
  # Build a Tcl-only shell
  set cmd [list $::KIT(cc)  {*}$::KIT(cflags_optimize) {*}$::KIT(shlib_cflags)]
  lappend cmd {*}$::KIT(TCLSHELL_OBJS)
  foreach item [glob ${_TclSrcDir}/*.a] {
    lappend cmd $item
  }
  lappend cmd $::TARGET(libtoadkit.a) {*}$::TCL(libs)
  lappend cmd -o $::TARGET(tclkit_bare) {*}$::KIT(LDFLAGS_CONSOLE)
  doexec {*}$cmd
}
if {$build(basekitvfs)} {
  cd $PWD
  if {[file exists $KIT(BASEVFS)]} {
    file delete -force $KIT(BASEVFS)
  }
  puts "***
*** BASE KIT VFS PACKAGES
***"
  puts [list COPY [file join $KIT(PKGROOT) [string trimleft $PKGPREFIX /] lib]]
  copyDir [file join $KIT(PKGROOT) [string trimleft $PKGPREFIX /] lib] [file join $KIT(BASEVFS) pkgs]
  
  copyDir [file join $KIT(TCLSRCDIR) library] [file join $KIT(BASEVFS) boot tcl]
  if { $::KIT(platform) eq "windows" } {
    set ddedll [glob -nocomplain [file join $_TclSrcDir tcldde*.dll]]
    if {$ddedll != {}} {
      file copy $ddedll [file join $KIT(BASEVFS) boot tcl dde]
    }
    set regdll [glob -nocomplain [file join $_TclSrcDir tclreg*.dll]]
    if {$regdll != {}} {
      file copy $regdll [file join $KIT(BASEVFS) boot tcl reg]
    }
  } else {
    file delete -force [file join $KIT(BASEVFS) boot tcl dde]
    file delete -force [file join $KIT(BASEVFS) boot tcl reg]
  }
  
  copyDir [file join $KIT(TKSRCDIR) library] $KIT(BASEVFS)/boot/tk
  set dllsrc [file join $_TkSrcDir [string trim $::TK(dll_file) \"]]
  file copy -force $dllsrc [file join $KIT(BASEVFS) boot tk]
  
  
  # For the following packages, cat their pkgIndex files to tclIndex
  if {$::tcl_platform(platform) eq {unix}} {
      file attributes [file join $KIT(BASEVFS) boot tcl tclIndex] -permissions 0744
  } else {
      file attributes [file join $KIT(BASEVFS) boot tcl tclIndex] -readonly 0
  }

  
  set fout [open [file join $KIT(BASEVFS) boot tcl tclIndex] a]
  puts $fout {#
# MANIFEST OF INCLUDED PACKAGES
#
}
  puts $fout [string map [list @TKVERSION@ $::TK(version)$::TK(patch_level) @TKDLL@ [string trim $::TK(dll_file) \"]] {
package ifneeded Tk @TKVERSION@ [list load $::tk_library/@TKDLL@ Tk]
  }]
  puts $fout {
if {[file exists /zvfs/pkgIndex.tcl]} {
  set dir /zvfs
  source /zvfs/pkgIndex.tcl
}
  }
  #close $fout
  close $fout
}
cd $PWD


if {[lindex $argv 0] eq "toadkit"} {
  package ifneeded zipfile::mkzip 1.2 [list source [file join $::HERE scripts mkzip.tcl]]
  package require zipfile::mkzip
  set fout [open [file join $KIT(BASEVFS) pkgIndex.tcl] w]
  set buffer [::practcl::pkgindex_path $KIT(BASEVFS)]
  puts $fout $buffer
  close $fout
  ::zipfile::mkzip::mkzip toadkit$::KIT(EXEEXT) -runtime tclkit_bare$::KIT(EXEEXT) -directory $KIT(BASEVFS) 
}
cd $PWD

if {[lindex $argv 0] eq "wrap"} {
  set name [lindex $argv 1]
  set vfspath [lindex $argv 2]
  package ifneeded zipfile::mkzip 1.2 [list source [file join $::HERE scripts mkzip.tcl]]
  package require zipfile::mkzip
  copyDir $KIT(BASEVFS) $vfspath
  set fout [open [file join $vfspath pkgIndex.tcl] w]
  set buffer [::practcl::pkgindex_path $vfspath]
  puts $fout $buffer
  close $fout
  ::zipfile::mkzip::mkzip ${name}$::KIT(EXEEXT) -runtime tclkit_bare$::KIT(EXEEXT) -directory $vfspath
}
Fossil version [935cd45f03] 2025-02-06 15:57:56