you@shellscripts$ enter() { echo "Shell scripting ftw!, deel 1

dinsdag 24 juni 2008 @ 20:31:53 #26

whoops

Home is where the heart is...

quote:
Op dinsdag 24 juni 2008 19:24 schreef slacker_nl het volgende:
i=$((i + 1))

quote:
$HOME gebruiken

Dit waren degene die ik zocht, thanks slack...

In the beginning, the universe was created. This made a lot of people very angry and has been widely regarded as a bad move.

dinsdag 24 juni 2008 @ 20:47:57 #27

Iblis

aequat omnis cinis

quote:
Op dinsdag 24 juni 2008 19:47 schreef slacker_nl het volgende:
Maar hoe zou je dit, voor de lol, in sh compatibel code willen doen dan?

Je moet dan ‘eval’ gebruiken. eval is een built-in commando dat de argumenten evalueert als waren ze een string in een shell-script.

B.v.

1
2
3

foo=bar
bar=baz
eval echo \$$foo

De eerste twee regels zijn duidelijk, de derde werkt als volgt: eerst worden de argumenten van het commando ‘eval’ geëvalueerd, dus dat wordt in feite:

1	eval echo $bar

En dan wordt ‘echo $bar’ geëvalueerd, wat ‘baz’ levert. Zo gaat het ook met je arrays:

1
2
3
4
5
6
7

foo0="foo zero"
foo1="foo one"
foo2="foo two"
foo3="foo three"
for i in 0 1 2 3; do
eval echo \$foo$i;
done;

Dit kan heel traag worden als je b.v. meerdere indices gebruikt, het eval-commando is namelijk vrij traag.

Daher iſt die Aufgabe nicht ſowohl, zu ſehn was noch Keiner geſehn hat, als, bei Dem, was Jeder ſieht, zu denken was noch Keiner gedacht hat.

dinsdag 24 juni 2008 @ 22:46:41 #28

whoops

Home is where the heart is...

quote:
Op dinsdag 24 juni 2008 20:47 schreef Iblis het volgende:

[..]

Je moet dan ‘eval’ gebruiken. eval is een built-in commando dat de argumenten evalueert als waren ze een string in een shell-script.

B.v.
[ code verwijderd ]

De eerste twee regels zijn duidelijk, de derde werkt als volgt: eerst worden de argumenten van het commando ‘eval’ geëvalueerd, dus dat wordt in feite:
[ code verwijderd ]

En dan wordt ‘echo $bar’ geëvalueerd, wat ‘baz’ levert. Zo gaat het ook met je arrays:
[ code verwijderd ]

Dit kan heel traag worden als je b.v. meerdere indices gebruikt, het eval-commando is namelijk vrij traag.

Het gebruiken van eval doet slacker ook al in zijn antwoord op mijn vraag hierboven...

Vanuit php heb ik trouwens altijd geleerd eval==evil en op zich denk ik dat ook wel... Toch gebruik ik het om mijn array mooi in dialog te krijgen. Als jij daar nog een manier zonder eval voor weet hou ik me aanbevolen...

De scripts die ik schrijf mogen inderdaad wel puur bash zijn, over het algemeen bouw ik ze voor een eigen gebruik, hoewel het het mooiste is om standaard te zijn...

In the beginning, the universe was created. This made a lot of people very angry and has been widely regarded as a bad move.

woensdag 25 juni 2008 @ 01:24:04 #29

slakkie

quote:
Op dinsdag 24 juni 2008 20:47 schreef Iblis het volgende:
Dit kan heel traag worden als je b.v. meerdere indices gebruikt, het eval-commando is namelijk vrij traag.

Ik had al het vermoeden dat je deze methode zou gaan gebruiken. Heb hem ook overwogen in eerste instantie, maar vond de array feature veel handiger

Je kan makkelijker opties toevoegen, tenminste, je hoeft niet ook nog eens je for loop te definieren.

Maar we zijn stom bezig.... Terwijl ik bezig was om te kijken welke manier nou sneller was kwam ik op de uiteindelijke oplossing. Een soort van array push simuleren in bash. sh is twijfelachtig, $((i + i)) wordt volgens mij niet ondersteund.

1
2
3
4
5
6
7
8
9
10

function add_choice() {
    if [ -n "$1" ] ; then
        CHOICES="$CHOICES $1"
        LIMIT=$((LIMIT + 1))
        #LIMIT=`expr $LIMIT + 1`
    else
        CHOICES=""
        LIMIT=0
    fi
}

test_bash
real 0m0.005s
user 0m0.004s
sys 0m0.000s

test_sh
real 0m0.048s (schommelt tussen .024 - .050 bij herhaaldelijk aanroepen)
user 0m0.008s
sys 0m0.020s

test_choice
real 0m0.006s
user 0m0.008s
sys 0m0.000s

test_choice - met expr (schommelt tussen .045 - .070)
real 0m0.044s
user 0m0.036s
sys 0m0.008s

test_choice - sh compat
real 0m0.028s (schommelt tussen .014 - .030)
user 0m0.012s
sys 0m0.004s

De code

donderdag 28 augustus 2008 @ 11:37:51 #30

Jo0Lz

Lick the box!

Centraal.

 Yes we can! | I didn't fail, it's just postponed success.

donderdag 28 augustus 2008 @ 13:22:56 #31

RemcoDelft

4 8 15 16 23 42

quote:
Op donderdag 28 augustus 2008 11:37 schreef Jo0Lz het volgende:
Centraal.

Goeie zaak, want ik had dit topic nog niet eerder opgemerkt!

quote:
Op maandag 14 januari 2008 11:22 schreef slacker_nl het volgende:
Big fucking warning
Ga nooit "leuk" zijn en mensen vertellen dat ze rm -rf /, moeten uitvoeren, dit wordt ZWAAR bestraft door de mods @hier en terecht. Voor de mensen die niet precies weten wat dit doet: rm -rf is een recursive, geforcede delete (rm == remove) actie op de root van je systeem. Mocht je als root zijn ingelogd dan verwijder je alle bestanden van je systeem en zal je snel merken dat je PC niet meer boot en je al je data kwijt bent. Mocht je een gewone user zijn en dit uitvoeren, dan heb je grote kans dat je homedir pleitte is, en andere bestanden buiten je $HOME, waar jij de eigenaar voor bent en/of group schrijfrechten voor hebt. Voer dit daarom dan ook NOOIT uit (tenzij je pijn leuk vind of als je in een virtuele omgeving zit waar dataverlies niet uitmaakt). Als we een post vinden waarin we dit zien, kijk er dan niet raar vanop dat je niet meer kan posten in DIG, of op heel Fok for that matter. U bent gewaarschuwd!

Het kan ook erger (spreek ik uit ervaring... 8)7 8)7 ):

1	cd /tmp; rm -rf .*

Ooit wou ik alle files en directories die met een PUNT beginnen in /tmp opruimen (dit zijn de directories die o.a. X achterlaat). Echter, hierbij zag ik over het hoofd dat ".." op deze manier ook wordt meegenomen, en vanaf /tmp is ".." gelijk aan / ... Na enkele seconden viel het kwartje, omdat de delete-actie wel erg lang duurde, en heb ik CTRL-C gedaan. M'n userdata was nog veilig, maar m'n OS kon ik opnieuw installeren (en nee, m'n OS backup ik niet).
Ondertussen is "rm .*" zo slim om te zeggen dat-ie . en .. negeert :)
Moraal van het verhaal: Unix/Linux doet precies wat je zegt, maar pas altijd op wat je zegt :D

censuur :O

donderdag 28 augustus 2008 @ 13:39:48 #32

Iblis

aequat omnis cinis

quote:
Op donderdag 28 augustus 2008 13:22 schreef RemcoDelft het volgende:
Ondertussen is "rm .*" zo slim om te zeggen dat-ie . en .. negeert
Moraal van het verhaal: Unix/Linux doet precies wat je zegt, maar pas altijd op wat je zegt

rm zelf doet niets met ‘.*’, het is de shell die zo’n pattern matcht en vervang door een lijst van bestanden die eraan voldoen. De Kornshell laat . en .. niet matchen op .*, bash echter soms wel, afhankelijk van de waarde van $GLOBIGNORE. Als je rm -rf .. intypt zal het nog steeds misgaan.

Bij zulke zaken is het dus goed om uit te zoeken wat de precieze semantiek van je shell is!

Daher iſt die Aufgabe nicht ſowohl, zu ſehn was noch Keiner geſehn hat, als, bei Dem, was Jeder ſieht, zu denken was noch Keiner gedacht hat.

dinsdag 23 september 2008 @ 00:29:47 #33

GBCHEATER

Wat nou?

Ik ben inmiddels weer vrolijk aan het bashen geslagen, ik zoek een manier om te kijken of ik in een string evenveel { en }; heb. Nu dacht ik, als ik nou de regex gebruik die ingebouwd zit in bash.

1
2
3
4
5
6
7

string="zone "asdf.asdf" {type master;file "/etc/bind/zones/asdf.asdf.db";allow-transfer{none;};};"
regex="};"
if [[ "$string" =~ $regex ]]; then
echo "Jay, ik heb ${#BASH_REMATCH[*]} keer een }; gevonden";
else
echo "He verdorie, niets..";
fi

echter komt hier altijd 1 uit.

Toen ben ik verder gaan zoeken, en toen had ik zoiets als dit

1
2
3

#get number of { and substract one.
nr=`echo "$string" | tr "{" "\n" | wc -l`
let nr=nr-1;

Dit werkt voor het { gedeelte van de twee. Voor de }; echter niet, ik denk dat dit komt omdat tr een match heeft per character in plaats van een tekenreeks.

Enig idee hoe ik of het }; gedeelte kan uitvissen, of hoe ik dit anders aan zou moeten pakken?

dinsdag 23 september 2008 @ 10:07:12 #34

whoops

Home is where the heart is...

Volgens mij werkt je methode met tr en wc wel hoor.

1
2
3
4
5

$ string="en { dat { is { een { en { dat { is { twee en } dat } is } drie } en } dat } is } vier "
$ echo "$string" | tr "}" "\n" | wc -l
8
$ echo "$string" | tr "{" "\n" | wc -l
8

Ik zou overigens niet weten of het efficienter kan.

In the beginning, the universe was created. This made a lot of people very angry and has been widely regarded as a bad move.

dinsdag 23 september 2008 @ 13:13:24 #35

GBCHEATER

Wat nou?

quote:
Op dinsdag 23 september 2008 10:07 schreef whoops het volgende:
Volgens mij werkt je methode met tr en wc wel hoor.
[ code verwijderd ]

Ik zou overigens niet weten of het efficienter kan.

Klopt, echter is de sluit "tag" }; dus inclusief de ;

Als de ; op een volgende regel staat, moet deze meegenomen worden. Dus moet eerst de volgende regel ingelezen worden, waarna hij pas compleet is. Dus hij moet echt gematcht worden op "};"

donderdag 25 september 2008 @ 08:23:23 #36

Iblis

aequat omnis cinis

In principe kun je met regexpen niet wat je hiermee wilt. Een regexp kan niet echt ‘tellen’ en niet kijken of haakjes gebalanceerd zijn. Je kunt het proberen, maar als je de string '{a{b}c{d}e}' hebt dan zal een regexp voor '{.*}' matchen op de gehele string als deze greedy is, of op '{a{b}' als deze lazy is. In het eerste geval zou je weer kunnen substring matchen, maar dan heb je eenzelfde probleem, omdat dan de match {b}c{d} wordt. (En een substring match op b}c{d niet gaat werken.)

Met veel kunst en vliegwerk is hier wel omheen te werken. De oplossing met ‘tr’ heeft een beetje een probleem dat het foute input als '}}{{' er niet uit kan halen. Ik weet niet of je dat wilt, maar anders is dit een probleem. Het makkelijkste is, als je het echt foutloos wilt doen, een klein perl of awk scriptje te schrijven dat de input simpelweg karakter voor karakter langsgaat en bij elke { de teller ophoogt, en bij elke } verlaagt. Als je teller < 0 komt, heb je te veel }, is deze > 0 bij het eind van de input heb je te veel { en is deze 0, dan zijn ze in balans. Verder kun je dus, als deze 0 is, de input afscannen naar ';'.

Weet je zeker dat de haakjes wel in balans zijn, dan zou je het volgende kunnen proberen:

1
2
3
4
5
6
7
8
9

string="en { dat { is { een {; en { dat { is { twee en } dat } is } drie } en } dat } is \n}\n; vier "
nstring=$(echo $string | tr -d -C '{};')
leftcount=$(echo $nstring | grep -o '{' | wc -l)
rightcount=$(echo $nstring | grep -o '}' | wc -l)
if echo "$nstring" | grep -q '};$' &&  test $leftcount -eq $rightcount; then
        echo 'bingo';
else
        echo 'jammer'
fi;

Eerst haal ik dus alle zooi uit de string behalve {, } en ; – ook de '\n's zijn dan weg. Dan tel ik linker en rechter haakjes (aannemende dat ze al in balans zijn). En dan moet de string met '};' eindigen.

Daher iſt die Aufgabe nicht ſowohl, zu ſehn was noch Keiner geſehn hat, als, bei Dem, was Jeder ſieht, zu denken was noch Keiner gedacht hat.

donderdag 25 september 2008 @ 13:57:52 #37

GBCHEATER

Wat nou?

Hier ga ik morgen even mee aan de slag, even rondspelen met verschillende input combinaties, misschien werkt het, maar waarschijnlijk zit er nog een mogelijkheid in dat een blok (dus wat tussen de { en de }; zit) niet afgesloten kan zijn geweest.

Maar opzich maakt dat niet heel erg veel uit, aangezien BIND zelf dan gaat lopen mekkeren dat de syntax niet goed is.

Bedankt voor de mogelijke oplossing. Ik ben benieuwd

p.s. PERL is geen optie, omdat dit niet aanwezig is op het systeem (en niet geinstalleerd mag/kan worden)

donderdag 25 september 2008 @ 16:40:59 #38

Iblis

aequat omnis cinis

Met AWK kun je nagenoeg hetzelfde als met Perl, zij het vaak iets minder beknopt. Zie onderstaande code. BEGIN wordt uitgevoerd voordat de input wordt gelezen, END altijd nadat alle input is gelezen, en het blok ertussen voor elke regel. Hij scant dus elke regel karakter voor karakter op '}', als de haakjes uit balans zijn komt er een error. Na de laatste } moet een ';' komen. Er is één catch, de input die alleen uit ';' bestaat wordt óók goedgekeurd. Daar kun je misschien expliciet op checken.

Je runt het met awk -f 'bestand' en kunt er dan gewoon via stdin input instoppen.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

BEGIN {
        counter = 0;
        done = 0;
}
{
        for (i = 1; i <= length($0); i++) {
                c = substr($0, i, 1);
                if (c== "{") {
                        counter++
                        done = 0;
                } else if (c == "}") {
                        if (counter == 0) {
                                print "Meer } dan { gevonden!";
                                exit 1;
                        }
                        counter--;
                } else if (c == ";" && counter == 0) {
                        done = 1;
                }
        }
}
END {
        if (counter > 0) {
                print "Enkele { zijn niet afgesloten!";
                exit 1;
        }
        if (!done) {
                print "Geen afsluitende ';' gevonden!"
                exit 1;
        }
        print "Alles in orde."
}

Daher iſt die Aufgabe nicht ſowohl, zu ſehn was noch Keiner geſehn hat, als, bei Dem, was Jeder ſieht, zu denken was noch Keiner gedacht hat.

zondag 28 september 2008 @ 21:52:34 #39

GBCHEATER

Wat nou?

quote:
Op donderdag 25 september 2008 16:40 schreef Iblis het volgende:
Met AWK kun je nagenoeg hetzelfde als met Perl, zij het vaak iets minder beknopt. Zie onderstaande code. BEGIN wordt uitgevoerd voordat de input wordt gelezen, END altijd nadat alle input is gelezen, en het blok ertussen voor elke regel. Hij scant dus elke regel karakter voor karakter op '}', als de haakjes uit balans zijn komt er een error. Na de laatste } moet een ';' komen. Er is één catch, de input die alleen uit ';' bestaat wordt óók goedgekeurd. Daar kun je misschien expliciet op checken.

Je runt het met awk -f 'bestand' en kunt er dan gewoon via stdin input instoppen.
[ code verwijderd ]

Bedankt voor de reactie, Ik probeer de Named.Conf.Local te parsen van BIND. Hierbij is het nodig dat ik fouten probeer te voorkomen waar dit mogelijk is. Voorbeeld van invoer:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

zone "asdf.asdf" {type master;file "/etc/bind/zones/asdf.asdf.db";allow-transfer{none;};};

Maar ook:

zone "asdf.net"
{

type master;
file "/etc/bind/zones/asdf.net.db";};

   zone "asdf.com" { //some comment here
        type master;
        file "/etc/bind/zones/asdf.com.db";
        allow-transfer

        {
                none;
}

;
};

Ik zoek het eerste gedeelte op met een regular expression, waardoor ik weet waar ik moet beginnen.
Daarna (is de bedoeling) dat ik bekijk dat ik na een { ook een bijbehorende }; heb. Wanneer dit zo is, weet ik dat ik de volledige zone heb. Wanneer dit niet zo is, lees ik de volgende regel in (verwijder ik whitespaces en comments), en bekijk ik verder of ik alles heb.

Hierdoor is het dus ook zo dat de ; 2 regels later kan komen.

Op dit moment heb ik (ongeveer) hetzelfde gedaan wat jij doet in die paar regels met awk, alleen dan ook met (basic) syntax checking.

Ik moet alleen nog bekijken hoe ik een newline kan matchen met een regular expression, aangezien na een } wel een spatie en een newline kan komen, maar geen ander teken moet ik hier rekening mee houden.

Wanneer de zone file naar de bagger is, moet het script stoppen en het niet erger maken :)

Ik zie dat je met awk redelijk veel kan doen, wist niet dat er zo een uitgebreide scripttaal achter zat..

zondag 28 september 2008 @ 21:58:12 #40

Iblis

aequat omnis cinis

Newlines in reguliere expressies matchen is meestal gewoon ‘\n’, maar veel tools scheiden impliciet op ‘\n’, zodat er dus nooit een ‘\n’ in je string komt. Als je dit weet echter kun je toch simpelweg (in termen van AWK) records inlezen, wat in de praktijk op regels neerkomt, en kijken of die records alleen spaties bevatten. Die records c.q. regels zelf moeten dan wel door ‘\n’ gescheiden zijn.

Daher iſt die Aufgabe nicht ſowohl, zu ſehn was noch Keiner geſehn hat, als, bei Dem, was Jeder ſieht, zu denken was noch Keiner gedacht hat.

maandag 29 september 2008 @ 04:53:36 #41

GBCHEATER

Wat nou?

quote:
Op zondag 28 september 2008 21:58 schreef Iblis het volgende:
Newlines in reguliere expressies matchen is meestal gewoon ‘\n’, maar veel tools scheiden impliciet op ‘\n’, zodat er dus nooit een ‘\n’ in je string komt. Als je dit weet echter kun je toch simpelweg (in termen van AWK) records inlezen, wat in de praktijk op regels neerkomt, en kijken of die records alleen spaties bevatten. Die records c.q. regels zelf moeten dan wel door ‘\n’ gescheiden zijn.

Op dit moment ben ik niet zeker of het de newline character is wat zo loopt te klieren. Wanneer ik het wil echoen op het scherm, krijg ik gewoon een spatie, maar hij word niet gematcht door de \s teken. Ik zal wat meer debuggen en dan kom ik hier op terug.

Bedankt voor het meedenken iedereen

dinsdag 23 december 2008 @ 14:22:10 #42

slacker_nl

Sicko pur sang

Weet iemand hoe het komt dat bash hetvolgende doet;

1
2
3

bla=$(find . -print)
echo $bla
. ./CS01.WANA-EAS.FI.2008.048.v02.csv ./CS01.BBDD-DSL.FI.2008.018.v02.csv ./rrd.ppt

Zsh doet dit, en dit is wat ik wil:

1
2
3
4
5
6

bla=$(find . -print)
echo $bla
.
./CS01.WANA-EAS.FI.2008.048.v02.csv
./CS01.BBDD-DSL.FI.2008.018.v02.csv
./rrd.ppt

-edit-
echo "$bla" is de oplossing...

Zie http://wooledge.org:8000/WordSplitting

[ Bericht 5% gewijzigd door slacker_nl op 23-12-2008 14:33:24 ]

In theory there is no difference between theory and practice. In practice there is.

dinsdag 23 december 2008 @ 14:38:00 #43

RemcoDelft

4 8 15 16 23 42

Waarom find . -print? Doet dat niet hetzelfde als gewoon "find"?

Ik gebruik altijd zoiets, veel inzichtelijker:
for i in `find`; do echo $i; done

censuur :O

dinsdag 23 december 2008 @ 14:41:04 #44

slacker_nl

Sicko pur sang

quote:
Op dinsdag 23 december 2008 14:38 schreef RemcoDelft het volgende:
Waarom find . -print? Doet dat niet hetzelfde als gewoon "find"?

Ik gebruik altijd zoiets, veel inzichtelijker:
for i in `find`; do echo $i; done

Kan ook zonder de -print. Gebruik ze beide. Maar ik hoef niet over find te loopen.

Uit de man page van find:

quote:
If no expression is present, -print will be used as the
expression. Otherwise, if the given expression does not con-
tain any of the primaries -exec, -ok or -print, the given
expression will be effectively replaced by:

( given_expression ) -print

En als niet perse sh compatible code hoeft te schrijven $() is veel sneller dan backticks.

for i in $(find . ) ; do echo $i ; done

In theory there is no difference between theory and practice. In practice there is.

dinsdag 23 december 2008 @ 17:38:18 #45

Iblis

aequat omnis cinis

$() is ook gewoon POSIX. Je hebt dus sowieso een niet-POSIX shell te pakken als $() het niet doet. De vraag is in hoeverre je daar tegenwoordig nog rekening mee wilt houden.

Daher iſt die Aufgabe nicht ſowohl, zu ſehn was noch Keiner geſehn hat, als, bei Dem, was Jeder ſieht, zu denken was noch Keiner gedacht hat.

woensdag 24 december 2008 @ 13:31:44 #46

slacker_nl

Sicko pur sang

Op solaris 8:

cat x.sh
#!/bin/sh

echo $(ls)

chmod +x x.sh
./x.sh
./x.sh: syntax error at line 3: `(' unexpected

In theory there is no difference between theory and practice. In practice there is.

donderdag 10 september 2009 @ 14:20:47 #47

slacker_nl

Sicko pur sang

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#!/bin/bash

TOTAL_MEM=0
TOTAL_PROC=0
DIV=$(perl -e 'print "-" x 40')

printf "%-10s %-18s %-10s\n" pid name anon_mem

echo $DIV

pgrep -lf "^ora_j"| sort -k2 | while read pid name junk ; do
    [ -z "$pid" ] && continue
    RES=$(pmap -x $pid 2>/dev/null)
    [ $? -ne 0 ] && continue
    RES=$(echo -e "$RES"  |tail -1 | awk '{NF=NF-1} {print $NF}' )
    printf "%-10d %-18s %-10d\n" $pid $name $RES
    TOTAL_MEM=$(($TOTAL_MEM + $RES))
    TOTAL_PROC=$((TOTAL_PROC +1 ))
    # Just for testing
    [ $TOTAL_PROC -eq 5 ] && break
done

TOTAL_MEM_GB=$(echo "scale = 4; ($TOTAL_MEM/1024)/1024"|bc)
echo $DIV
printf "TOTALS\n%-10s %-18s %-10s" procs "anon_mem kb" "anon_mem Gb"
echo $DIV

printf "%-10s %-18s %-10s\n" "$TOTAL_PROC" "$TOTAL_MEM" "$TOTAL_MEM_GB"

Waarom print ie niet m'n totalen uit??

Als ik

1	pgrep -lf "^ora_j"\| sort -k2 \| while read pid name junk ; do

naar

1
2
3

for i in $(pgrep -lf "^ora_j"| sort -k2|sed -e 's/ /$/') ; do
pid=$(echo $i | cut -d\$ -f1)
name=$(echo $i | cut -d\$ -f2)

Werkt het wel... Why??

In theory there is no difference between theory and practice. In practice there is.

donderdag 10 september 2009 @ 15:40:11 #48

Iblis

aequat omnis cinis

http://mywiki.wooledge.org/BashFAQ/024

Daher iſt die Aufgabe nicht ſowohl, zu ſehn was noch Keiner geſehn hat, als, bei Dem, was Jeder ſieht, zu denken was noch Keiner gedacht hat.

donderdag 10 september 2009 @ 15:45:45 #49

whoops

Home is where the heart is...

quote:
foto Op donderdag 10 september 2009 14:20 schreef slacker_nl het volgende:

[ code verwijderd ]

Waarom print ie niet m'n totalen uit??

Als ik
[ code verwijderd ]

naar
[ code verwijderd ]

Werkt het wel... Why??