Newsgroup: it.comp.lang.c
Titolo: from BASIC to C (spero non OT)

Ciao a tutti,
sto lavorando ad un progetto che prevede la conversione di un codice
QBASIC in C. Apparentemente non dovrebbero esserci grosse difficoltà
ma, forse a causa della mia "rospaggine", sono finito in un buco nero.
Ho questo frammento di codice:
7000 FOR h = 1 TO pop
7005     IF a(h, c + at + 1) = 0 THEN GOTO 7090
7006     IF a(h, c + at + 1) < d THEN GOTO 7090
7010     FOR k = 1 TO pop
7015         IF a(k, c + at + 1) = 0 THEN GOTO 7080
7020            FOR j = 1 TO c
7030                IF b(j) = 0 THEN GOTO 7050
7040                IF a(h, j) > a(k, j) THEN GOTO 7080
7050            NEXT j
7051            FOR j = c + 1 TO c + at
7052                IF b(j) = 0 THEN GOTO 7056
7055                IF a(h, j) <> a(k, j) THEN GOTO 7080
7056            NEXT j
7061                 IF a(k, c + at + 1) < d THEN contr = contr + 1
7062                 IF a(k, c + at + 1) >= d THEN corr = corr + 1
7080     NEXT k
7085     lower(h) = corr / (contr + corr): contr = 0: corr = 0
7090 NEXT h
Ho impostato una serie di cicli for annidiati con qualche if nel mezzo
(con seri problemi di leggibilità... ma vedremo) ma quando mi trovo a
"tradurre" le linee 7052 e 7055 ho difficoltà a gestire due controlli
con rimandi a punti differenti. Vorrei evitare i GOTO.
Grazie
Geonomos

 7080
for (j=c+1;j<=c+at && !(b(j) && a(h,j)!=a(k,j));j++);
if (j>c+at && b(j)) {
    if (a(k,c+at+1) < d) contr++;
    else corr++;
}
E.

> for (j=c+1;j<=c+at && !(b(j) && a(h,j)!=a(k,j));j++);
Grazie per la risposta, ma ho ancora qualche dubbio;
1. non mi è chiaro il significato del punto esclamativo nelle
condizioni di for, immediatamente dopo il primo &&;
2. commetterei un errore se scrivessi il for così:
 for (j=c+1;j<=c+at && (b(j)!=0 && a(h,j)!=a(k,j));j++);
Grazie ancora per l'aiuto.
geo

  for (j=c+1;j<=c+at && (b(j)!=0 && a(h,j)!=a(k,j));j++);
� diverso da quello che ho scritto io. Se il mio era giusto, questo � 
sbagliato.
E.

ok,
grazie

Grazie ai suggerimenti di ?manu* (e un po di studio in più) ho
tradotto gran parte del codice del mio progetto da QB a C ma c'è una
parte da cui non riesco a "cavarne i piedi". Ho provato con strumenti
del tipo qb2c e BCX ma anzichè i cicli mi genera un gran numro di
label-goto. Qualcuno può aiutarmi indicandomi qualche tools o qualche
documento o qualsiasi altra cosa che possa aiutarmi nella conversione?
La difficoltà è nel districarmi con il gran numero di ciclo e di GOTO.
grazie comunque
La parte di codice è questa che per mia esclusiva esigenza ho cercto
di indentare raggruppando il codice per cicli:
8000 FOR h = 1 TO pop
8010     IF lower(h) < csoglia THEN GOTO 12380
8020     FOR t = 1 TO rule
8030         FOR j = 1 TO c
8040             IF b(j) = 0 AND rulea(t, j) = 1000 THEN GOTO 8070
8050             IF b(j) = 0 THEN GOTO 8090
8055             IF rulea(t, j) = 1000 THEN GOTO 8070
8060             IF rulea(t, j) > a(h, j) THEN GOTO 8090
8070         NEXT j
8071         FOR j = c + 1 TO c + at
8072             IF b(j) = 0 AND rulea(t, j) = 1000 THEN GOTO 8076
8073             IF b(j) = 0 THEN GOTO 8090
8074             IF rulea(t, j) = 1000 THEN GOTO 8076
8075             IF rulea(t, j) <> a(h, j) THEN GOTO 8090
8076         NEXT j
8080         IF credrul(t) >= lower(h) THEN GOTO 12380
8090     NEXT t
9020     FOR k = 1 TO pop
9040         IF k = h THEN GOTO 9140
9050         IF lower(k) < lower(h) THEN GOTO 9140
9060         FOR j = 1 TO c
9070             IF b(j) = 0 THEN GOTO 9090
9080             IF a(h, j) < a(k, j) THEN GOTO 9140
9090         NEXT j
9091         FOR j = c + 1 TO c + at
9092             IF b(j) = 0 THEN GOTO 9094
9093             IF a(h, j) <> a(k, j) THEN GOTO 9140
9094         NEXT j
9100         FOR j = 1 TO c
9110             IF b(j) = 0 THEN GOTO 9130
9120             IF a(h, j) <> a(k, j) THEN GOTO 12380
9130         NEXT j
9140     NEXT k
9150     rule = rule + 1: credrul(rule) = lower(h)
10100    FOR j = 1 TO c + at
10120        IF b(j) = 0 THEN GOTO 10140
10130        rulea(rule, j) = a(h, j)
10140    NEXT j
11080    FOR l = 1 TO pop
11085        IF a(l, c + at + 1) = 0 THEN GOTO 11140
11090        FOR j = 1 TO c
11100            IF rulea(rule, j) = 1000 THEN GOTO 11120
11101            IF a(l, j) = 1000 THEN GOTO 11140
11110            IF rulea(rule, j) > a(l, j) THEN GOTO 11140
11120        NEXT j
11121        FOR j = c + 1 TO c + at
11122            IF rulea(rule, j) = 1000 THEN GOTO 11125
11123            IF a(l, j) = 1000 THEN GOTO 11140
11124            IF rulea(rule, j) <> a(l, j) THEN GOTO 11140
11125        NEXT j
11135        tot = tot + 1
11140    NEXT l
11155    sup = tot / pop
11156    tot = 0
12140    IF sup < tSUP THEN GOTO 12380
12150    rp = rp + 1: PRINT rp;
         FOR j = 1 TO c
             ruleb(rp, j) = rulea(rule, j)
         NEXT j
         credrulb(rp) = credrul(rule)
         WRITE #1, "regola n."
         WRITE #1, "valore rp", rp
12160    PRINT credrul(rule);
         WRITE #1, "conf."
         WRITE #1, credrul(rule)
12170    PRINT "    ;";
         WRITE #1, "    ;"
12180    FOR j = 1 TO c + at
12190        IF rulea(rule, j) < 1000 THEN PRINT rulea(rule, j);
             IF rulea(rule, j) < 1000 THEN WRITE #1, "domanda": impa
(j) = impa(j) + 1
             IF rulea(rule, j) < 1000 THEN WRITE #1, j
             IF rulea(rule, j) < 1000 THEN WRITE #1, rulea(rule, j)
12200        IF rulea(rule, j) = 1000 THEN PRINT "*";
12210    NEXT j
12220    PRINT "  "
         WRITE #1, "    "
12230    FOR l = 1 TO pop
12240        IF a(l, c + at + 1) = 0 THEN GOTO 12350
12250        FOR j = 1 TO c
12255            IF rulea(rule, j) = 1000 THEN GOTO 12280
12260            IF a(l, j) = 1000 AND a(l, c + at + 1) < d THEN nn =
nn + 1: GOTO 12350
                 IF a(l, j) = 1000 AND a(l, c + at + 1) >= d THEN np =
np + 1: GOTO 12350
12270            IF rulea(rule, j) > a(l, j) AND a(l, c + at + 1) < d
THEN nn = nn + 1: GOTO 12350
                 IF rulea(rule, j) > a(l, j) AND a(l, c + at + 1) >= d
THEN np = np + 1: GOTO 12350
12280        NEXT j
12290        FOR j = c + 1 TO c + at
12295            IF rulea(rule, j) = 1000 THEN GOTO 12320
12300            IF a(l, j) = 1000 AND a(l, c + at + 1) < d THEN nn =
nn + 1: GOTO 12350
                 IF a(l, j) = 1000 AND a(l, c + at + 1) >= d THEN np =
np + 1: GOTO 12350
12310            IF rulea(rule, j) <> a(l, j) AND a(l, c + at + 1) < d
THEN nn = nn + 1: GOTO 12350
                 IF rulea(rule, j) <> a(l, j) AND a(l, c + at + 1) >=
d THEN np = np + 1: GOTO 12350
12320        NEXT j
12330        PRINT l;
             WRITE #1, l
12340        IF a(l, c + at + 1) < d THEN pn = pn + 1: PRINT "(*)";
             IF a(l, c + at + 1) < d THEN WRITE #1, "(*)"
             IF a(l, c + at + 1) >= d THEN pp = pp + 1
12350    NEXT l
12360    PRINT "  "
         WRITE #1, "  "
12370    PRINT sup
         WRITE #1, "sup."
         WRITE #1, sup
         PRINT "nn", nn;
         PRINT "np", np;
         PRINT "pn", pn;
         PRINT "pp", pp;
         WRITE #1, "nn", nn, "np", np, "pn", pn, "pp", pp
         dc = pp / (pp + pn) - (pp + np) / pop
         PRINT dc
         WRITE #1, "dc", dc
          nn = 0: pp = 0: np = 0: pn = 0
12380 NEXT h

 label-goto. 
E perch� non ti va bene?
E.

 E.
Perchè devono essere cicli. Dai testi che sto studiando mi sembra di
avere capito che quando una cosa si può fare con un for invece che con
un goto - label è sempre preferibile la prima ipotesi. Spero di non
avere "sposato" un dogma sbagliato.
ciao

 Spero di non avere "sposato" un dogma sbagliato.
Prima di tutto dovresti capire il significato delle keyword 'break' e 
'continue', ma noon credo che il tuo programma basic, data la sua 
struttura, si possa riscrivere senza usare i goto.
In fin dei conti i goto sono deprecati solo perché rendono il codice 
meno leggibile e mantenibile, ma se devi portare un programma già 
scritto con i goto perché preoccuparsi.
Ciao
Giovanni
-- 
   A computer is like an air conditioner,
   it stops working when you open Windows.
   < 
http://giovanni.homelinux.net/
 >

 
Ciao,
penso che se l'algoritmo non è "spiegabile" a parole, perché non
conosciuto da nessuno, sia conveniente trascrivere il listato basic
in 'c' senza nessuna ottimizzazione/modifica, per quanto possibile.
Nel caso esista un'analisi del problema penso che si possa pensare ad
una "traduzione" di quelle istruzioni in modo che siano più
"gestibili" in futuro.
Luca

 in 'c'
In realtà sto lavorando su due fronti: uno è quello della traduzione
del codice e l'altro è quello della costruzione dell'algoritmo in
qualcosa di simile ad uno "pseudocodice". Fino al punto a cui sono
arrivato le due attività sono state complementari, nel senso che la
traduzione del codice mi è servita per comprendere meglio l'algoritmo
e viceversa. Ora mi trovo ad un punto morto. Non capisco l'algoritmo e
non riesco a convertire il codice con cicli for che, a prescindere da
questioni di stile del codice, mi sembra che siano le strutture per
l'algoritmo (in realtà si tratta di una serie di vettori e di matrici)
grazie a tutti dell'aiuto e dei suggerimenti
geo

 grazie comunque
disegnalo. Un bel flowchart dovrebbe aiutarti a capirci qualcosa.
Ciao Jack