#!/usr/local/bin/tclsh
#
# Copyright (c): Uwe Schmidt, FH Wedel
#
# You may study, modify and distribute this source code
# FOR NON-COMMERCIAL PURPOSES ONLY.
# This copyright message has to remain unchanged.
#
# Note that this document is provided 'as is',
# WITHOUT WARRANTY of any kind either expressed or implied.

# die wichtigsten Tcl Kommandos

#--------------------------
# puts: Ausgabe auf eine Datei

# o.k.
puts hello

# Fehler: bad file identifier
puts hello world

# o.k.
puts stdout hello
puts stderr hello

puts "hello world"

#--------------------------
#
# expr: Artithmetik

expr 1 * 1


#--------------------------
#
# set: Zuweisungen an Variablen

# Zuweisung
set a 5

#--------------------------
#
# Variablen Substitution

# Auslesen
puts $a

# Ersetzen in Texten

puts $abc
puts ${a}bc
puts $a$a$a

# Abfragen: gibt es eine Variable
info exists a
info exists unbekannt

# Anhaengen
append a 6 7 8

#--------------------------
#
# Kommando Substitution

set a [expr 1 * 1]

#--------------------------
#
# \ Substitution

puts [expr $a * $a]

puts \[expr\ \$a\ *\ \$a\]

puts abc\ndef

#--------------------------
#
# "..." Quoting

puts "hello world
good bye
"

set a 5
set b 7

puts "$a * $b = [expr $a * $b]"

#--------------------------
#
# {...} Quoting

puts {$a * $b = [expr $a * $b]}

puts {hello world
good bye
}

#--------------------------
#
# expr: Syntax wie in C

expr 1 < 5
expr ! ( 1 < 5 )

# string Vergleich
expr {"Hellmut" < "Oskar"}

#--------------------------
#
# if {cond} then {cmd} else {cmd}

set a 5
set b 7

if {$a < $b} {
    set res "a ist kleiner als b"
} else {
    set res " a ist groesser als b"
}

puts $res

set a emil
set b egon

if {"$a" == "$b"} {
    set res "a ist gleich b"
} else {
    set res "a ist ungleich b"
}

puts $res

#--------------------------
#
# for {init-cmd} {test-expr} {incr-cmd} {body-cmd}

for {set i 1} {$i < 4} {incr i} {
    puts "Das sage ich Dir zum $i. Mal!"
}

# foreach variable {value-list} {body-cmd}

set res ""
foreach i {Vanille Erdbeer Schoko} {
    append res "Eine Kugel $i bitte!\n"
}
puts $res


# while {cond-expr} {body-cmd}

set i 1
while {$i < 5} {
    puts "Das $i. Mal\n"
    incr i
}

#--------------------------
#
# proc name {arg-list} {body} : Funktionen

# ein Parameter
proc square {x} {
    return [expr $x * $x]
}

# zwei Parameter
proc times {x y} {
    return [expr $x * $y]
}

# eine Liste von Parametern: fester Name args
proc echoargs args {
    set cnt 1
    set res ""
    foreach i $args {
	append res "Der $cnt. Parameter hat den Wert: \"$i\"\n"
	incr cnt
    }
    puts $res
}

# 0 Parameter
proc p0 {} {
    return "dies ist eine Prozedur ohne Parameter"
}

set gv "this is a global variable"
proc p {} {
    global gv

    puts $gv
}

#--------------------------
#
# exec: BS Kommandos ausfuehren

exec date
exec date +%H:%M
exec ps -l

set time [exec date "+%H:%M"]
set status [exec ps -l]
set this_file [exec cat Kommandos.tcl]

#--------------------------
#
# catch {cmd-body} res-var : Fehler abfangen

if {[catch {exec fortune} res]} {
    puts stderr "Fehler: kein fortune Programm"
    set res ""
} else {
    puts stderr "fortune erfolgreich aufgerufen"
}

puts $res

#--------------------------
#
# eval arg1 ...  argn
# nimmt seine Argumente, setzt diese zu einem Tcl Kommando zusammen
# und fuehrt es aus, wird z.B. bei der Verarbeitung von Listen gebraucht

set a "set x"
set b "5"
eval $a $b

puts "$x"

echoargs $a
eval echoargs $a

#--------------------------
#
# weitere Kommandos: Einzelheiten mit man nachsehen
#
# Navigation durchs Filesystem
#
#   pwd				print working dir
#   cd				change dir
#   file <sub-cmd> <file>	file information
#   glob <option> <pattern>	files ueber Muster auswaehlen
#
# String Verarbeitung:
#
#   string length <str>				Laenge
#   string index  <str> <index>			indizierter Zugriff
#   string range  <str> <index> <index>		Teilstrings
#   string compare <str> <str>			Vergleich
#   string first <str> <str>			Suche
#   string last  <str> <str>			Suche
#   string toupper <str>			alles in Grossbuchstaben
#   string tolower <str>			alles in Kleinbuchstaben
#   string match <muster> <str>			Muster suchen (mit shell Mustern)
#   string trim <str>			        whitespace am Anfang und Ende loeschen
#
# String Formatierung:
#
#   format <format> <str> ...			Druckaufbereitung mit Formatanweisungen aus C

#--------------------------
#
# regulaere Ausdruecke:
# Vorsicht mit Sonderzeichen: z.B [] wird in Tcl interpretiert und in regexp
#
# regexp <muster> <str>	...			suchen
# regsub <muster> <str> <subst> ....		ersetzen

regexp {[0-9]+} abc-123-def
regexp {[0-9]+} abc-123-def a
regexp {[0-9]+} abc-123-456-789-def a
regexp {([0-9]+)[^0-9]+([0-9]+)} abc-123-456-def a a1 a2
puts $a

regexp {[0-9]+} --123-- a
puts $a

regsub {l} "Elli" m res
puts $res

regsub -all -- {l} "Elli" m res
puts $res

regsub -all -- {([0-9]+)} "123-456-789" {.\1.} res
puts $res


#--------------------------
#
# Kommandos fuer Listen

# Erzeugen von listen

# eine Liste von Konstanten
set l {ali berta caesar dolli}

set n1 "Karl Knut"
set n2 "Mueller Luedenscheid"

# eine dynamisch erzeugte Liste
set l [list $n1 $n2 "$n1 $n2"]

# indizierter Zugriff
set v1 [lindex $l 0]
set v2 [lindex $l 1]

# Laenge einer Liste
set len [llength $l]

# Listen verlaengern
lappend l "Theo Lingen"
set l

# in Listen Elemente einfuegen:
# linsert <list> <index> <element> ...
# Elemente werden vor den Index eingefuegt
set l2 [linsert $l 1 "Franz Beckenbauer"]
set l
set l2

# Teilbereiche einer Liste selektieren
# lrange <list> <first> <last>
set l2 [lrange $l 2 end]

# Elemente in einer Liste suchen
# lsearch <list> <element>
set i [lsearch $l abc]
set i [lsearch $l "Karl Knut"]

# Elemente in einer Liste ersetzen oder loeschen
# lreplace <list> <first> <last> <element> ...
set l {a b c d e f g}
set l1 [lreplace $l 3 end]
set l2 [lreplace $l 1 2 B C]

# Liste konkatenieren
# concat <list> ...
set l {a b c d e f g}
set l2 [concat $l $l]

# Listen sortieren
# lsort <list>
set l3 [lsort $l2]

# alle Elemente einer Liste verarbeiten
set result ""
foreach i $l {
    append result "Element $i wird verarbeitet\n"
}

# Texte in Listen zerlegen
# split <list> <charList>
split 123.456.789.111 .

split 123.456.789.111 1

split 123.456.789.111 ""

# Listen zu Texten zusammensetzten
# inverses Kommando zu split
# join <list> <string>

set l [split 123.456.789.111 .]
join $l .

#--------------------------
#
# assoziative Felder

set a(nachname) "Lingen"
set a(vorname)  "Theo"
set a(alter)    "sehr alt"

puts "Name: $a(vorname) $a(nachname)\nAlter: $a(alter)"

# Verarbeitung aller Elemente in einem Feld

foreach i [array names a] {
    puts "a($i) = $a($i)"
}

#--------------------------
#
# Kommandos zum Laden eines Programms
# source <dateiname>

source ./tcl/setopt.tcl
source ./tcl/format-html.tcl

tag_h1 "die &Uuml;berschrift"
tag_em "eine wichtige Aussage"

#--------------------------
#
# persistente Daten:
# Daten in einer Datei speichern
# und spaeter wieder einlesen

set res ""
foreach i [array names a] {
    append res [list set a($i) $a($i)]
    append res "\n"
}
# res enthaelt tcl Code zur Erzeugung des Feldes a

set tmpfile [open "tmp.tcl" w]
puts $tmpfile $res
close $tmpfile

# wieder einlesen
source "tmp.tcl"