Τετάρτη, 30 Σεπτεμβρίου 2015

Προγραμματισμός 0004

Νέα αναθεώρηση 57
Μία βελτίωση, μια επαναφορά, μια διόρθωση (ένας προγραμματιστής...)
Οι αναθεωρήσεις λέγονται και "συντήρηση"..τεχνηέντως...Μεγάλες επιχειρήσεις τις λένε Service Release, ή Patch αν είναι κάτι σύντομο και απαραίτητο, ή επίκαιρο (update) αν είναι κάτι που πρέπει να συμβαδίζει με κάτι νέο (δηλαδή μια βελτίωση ουσιαστικά). Συντήρηση γενικά λέμε την διατήρηση ενός προγράμματος και των απαραίτητων δεδομένων του σε καλή λειτουργία. Για εμπορικά προγράμματα που στηρίζονται σε βάσεις δεδομένων, όταν λέμε συντήρηση σημαίνει ότι κάνουμε καθάρισμα της βάσης (και ότι άλλο μπορεί να την κάνει περισσότερο γρήγορη άρα και λειτουργική)

1. Τώρα η συνάρτηση Ταύτιση() παίρνει και ελληνικούς χαρακτήρες, το ίδιο ισχύει και για την εντολή Σωρός.

αδειασε           \\ αδειάζει το σωρό
\\ μετά φτιάχνουμε μια λίστα και την περνάμε σε ένα αλφαριθμητικό
α$=παραθεση$(1,2,"αλφα", 45*56)
Τύπωσε α$   \\ εδώ τυπώνουμε τη λίστα ως έχει
σωρος α$,"αα"   \\ εδώ ζητάμε από τη λίστα δυο αριθμούς (και το "νν" δουλεύει)
\\ προσοχή όμως εδώ τους αναστρέφει, δηλαδή βάζει το τελευταίο ως πρώτο (στη κορυφή)
σωρος    \\ χωρίς παράμετρο βλέπουμε το σωρό στην οθόνη
\\ εδώ κοιτάμε αν ο σωρός έχει δυο αριθμούς, αλλά δεν τους τραβάμε
Τύπωσε Ταύτιση("αα")
\\ εδώ διαβάζουμε τους δυο αριθμούς
διαβασε Α, Β
σωρος α$,"γ"               \\ γ από το γράμμα ή γράμματα
διάβασε Β$
Τύπωσε Α, Β,Β$, α$
         1        2αλφα             2520

πριν την αναθεώρηση ήθελε N αγγλικό για αριθμό και S για αλφαριθμητικό
Παρόλα αυτά η Φάκελος$() γυρίζει πάντα N ή S (αγγλικά).
α$=παραθεση$(1,2,"αλφα", 45*56)
τύπωσε φάκελος$(α$)  \\ θα δώσει τα αγγλικά
NNSN 
Επειδή για κάθε στοιχείο επιστρέφει η φάκελος$() ένα γράμμα, μπορούμε να ξέρουμε πόσα στοιχεία έχει μέσα το αλφαριθμητικό:
τύπωσε μήκος(φάκελος$(α$))
αν θέλουμε να ξέρουμε τι έχει το πρώτο στοιχείο
Τύπωσε φάκελος$(α$,"α")<>""      \\ τυπώνει -1 (αληθές)
Τύπωσε φάκελος$(α$,"γ")<>""       \\ τυπώνει 0 (ψευδές)

Οι λίστες στα αλφαριθμητικά δεν μπορούν να έχουν ομάδες ή πίνακες, όπως μπορεί να έχει ο σωρός, για στοιχεία.
β$=α$+","+α$  ενώνουμε δυο λίστες
β$=α$+","+α$ 
α$="1 1 2;σκουπίδια"   \\ το κόμμα δεν είναι απαραίτητο, μπορούμε να βάλουμε "σκουπίδια".

Τύπωσε φακελος$(α$)
σωρος α$,"ααα"

Τύπωσε α$     \\ τυπώνει το ";σκουπίδια".

α$="1 1 2;5 6 7"
σωρος α$     \\ αν δεν δώσουμε επακριβώς τι θέλουμε..τα σκουπίδια θα χαθούν...

Τύπωσε α$
Μέχρι εδώ είδαμε την απλή μορφή λίστας
Η συνάρτηση σωρός$() φτιάχνει σωρούς με αλφαριθμητικά που δεν βρίσκονται εντός εισαγωγικών αλλά με αριθμό στοιχείων πρώτα. Έτσι η εντολή σωρός και η φάκελος() λειτουργούν τώρα με δυνατότητα να έχουμε λίστες σε λίστες.
α$=σωρος$(1,2,3,4,"άλφα")
τυπωσε α$
β$=σωρος$(α$,10, σωρος$(1,2,3))
Τύπωσε φακελος$(β$)   \\ SNS
Σωρος Νεος { Σωρος β$,"γν" }  \\ πετάω τα πρώτα δύο στοιχεία
Σωρος β$ : Διαβασε β$
Σωρος β$
Διαβασε Α,Β,Γ
Τύπωσε Α,Β,Γ   \\ τυπώνει το 1 2 3


Ο λόγος που χρησιμοποιούμε τα αλφαριθμητικά ως λίστες είναι για να τα περάσουμε σε αρχεία, ή σε πίνακες ή να τα στείλουμε μέσω αυλών (pipes) σε άλλο πρόγραμμα που τρέχει στο δίκτυο. Οι αυλοί στην Μ2000 (είναι στοιχεία των Windows) χρησιμοποιούνται μόνο για να "ακούνε" για στοιχεία. Έτσι μια εφαρμογή μπορεί να στήσει έναν αυλό και να περιμένει να πάρει "εντολές". Αυτές τις εντολές έρχονται σε λίστα και εκεί μπορεί ένα άλλο πρόγραμμα να γνωστοποιήσει τον δικό του αυλό "επικοινωνίας". Με αυτό το τρόπο φτιάχνουμε συστήματα (δηλαδή τουλάχιστον δυο εφαρμογές σε M2000 να τρέχουν) ως "πελάτη-εξυπηρετητή". Δείτε εντολές USE και PIPE (Χρήση και Αυλός).


2. Επιπλέον επανήλθε η Βοήθεια με κανονική χρήση των τόνων. π.χ. (είχε "σπάσει" μετά την 44).
Βοήθεια Φάκελος δίνει το Φάκελος$()

3. Επιπλέον διορθώθηκε αυτό (το περιγράφω για να δει κανείς πόσο εύκολα γίνονται λάθη. Εδώ δεν το είχα προσέξει μέχρι που το χρησιμοποίησα...):
class aa {name$, module aa { read .name$ }} 
dim a(1)=aa("OK")
' είχαμε λάθος στις επόμενες γραμμές γιατί δεν δέχονταν τα \ και ; όταν
' χρησιμοποιούσαμε τη μορφή ανάγνωσης ιδιότητας από αντικείμενο στην εκτύπωσε!
'  ενώ δέχονταν αυτό for a(0) { print .name$; }
' το πρόβλημα ήταν ότι μια συνάρτηση που "κοίταζε μπροστά"...όταν έφθανε στην ). 
' μετά έπαιρνε όχι μόνο το .name$ αλλά και το ; μαζί και αναζητούσε την "name$;"
' το ίδιο έκανε για την ' και την \ (που χρησιμοποιούμε για σημειώσεις στο κώδικα).
' το ? είναι η Τύπωσε (Print)
? a(0).name$  \\ hello
? a(0).name$;"..."

Τρίτη, 29 Σεπτεμβρίου 2015

Συναρτησιακός Προγραμματισμός (Μ2000-Προχωρημένο Επίπεδο)

(το παρακάτω πρόγραμμα γράφτηκε πριν φτιαχτούν οι συναρτήσεις λάμδα που είναι τιμές πρώτης τάξεως, δηλαδή μπορούν να επιστραφούν ως τιμές, μπορούν να περαστούν ως ορίσματα και μπορούν να έχουν κλείσιμο μεταβλητών. Δείτε το παράδειγμα με χρήση αντικειμένου Σωρού και συναρτήσεων Λάμδα
Συναρτησιακός Προγραμματισμός ΙΙ
)

Εδώ υπάρχει ένα πρόγραμμα που αρχικά γράφτηκε στην αγγλική (η Μ2000 έχει όλες τις εντολές και στα αγγλικά), όμως έκανα αλλαγές και ό,τι έχει μείνει στα αγγλικά...δεν είναι εντολές! Άφησα δηλαδή επίτηδες τα ονόματα στα αγγλικά για να καταλάβει κανείς ποιες είναι εντολές και ποια ονόματα (αναγνωριστικά μπορούμε να τα λέμε) που ορίζουμε εμείς.
Σε  μια γραμμή Συναρτησιακός Προγραμματισμός:
Γενικό ThisString$ : Goal "{Κάλεσε integer(25)}"  , "{qubic_of &ThisString$}" : Τύπωσε ThisString$
Παίρνουμε  τους κύβους (χ^3) των αριθμών 1...25.
Goal &ThisString
Παίρνουμε τη λίστα το ένα στοιχείο κάτω από το άλλο (αν υπήρχαν πράξεις θα εκτελούνταν πριν την εξαγωγή (Οκνηρή αποτίμηση - Lazy evaluation)

Στον Συναρτησιακό Προγραμματισμό δεν υπάρχουν αντικαταστάσεις π.χ. Χ=10.
Εδώ φτιάξαμε μια κενή ThisSring$ την βάλαμε στη Goal και τη πήραμε γεμάτη.

Η Μ2000 δεν είναι Συναρτησιακή Γλώσσα. Αυτό που κάνουμε εδώ είναι να φτιάξουμε εργαλεία που να κάνουν αυτό που δεν μπορεί η Μ2000 με τις έτοιμες εντολές. Ομοίως και η Μ2000 είναι γραμμένη με Visual Basic 6 (ο κώδικας συνοδεύεται μαζί με το εκτελέσιμο), και κάνει πράγματα που χωρίς κώδικα δεν μπορεί άμεσα να τα κάνει η Vb6.

Προσθήκη:
Εκτός από τις συναρτήσεις που ορίζουμε με την εντολή Συνάρτηση, καθώς και τις μεταβλητές που ορίζονται ως συναρτήσεις (όταν φτιάχτηκε το παρακάτω πρόγραμμα δεν υποστήριζε η Μ2000 τέτοιες μεταβλητές), υπάρχουν οι συναρτήσεις εντός αλφαριθμητικού ως ανώνυμες συναρτήσεις. 
Πχ το "{=3+5}"  αν το βάλουμε στο σωρό τιμών με την ΒΑΛΕ τότε μπορούμε να την διαβάσουμε ως αλφαριθμητικό πχ Διάβασε Α$ αλλά και εδώ αυτό μας ενδιαφέρει να την διαβάσουμε ως ορισμό συνάρτησης: Διάβασε &Α().
Ομοίως αν έχουμε μια συνάρτηση Α(), που είχαμε ορίσει πιο πριν τότε με Βάλε &Α() μπαίνει ο ορισμός της ως αλφαριθμητικό στο σωρό. Ειδικά στις συναρτήσεις ενός αντικειμένου (ομάδα) το πέρασμα στο σωρό βάζει επιπλέον στοιχεία μετά τη τελευταία αγκύλη έτσι ώστε όταν τρέξει να έχει η συνάρτηση πρόσβαση στα μέλη της ομάδας, άλλες συναρτήσεις και μεταβλητές. Με αυτό τον τρόπο περνάμε συνάρτηση ομάδας  με αναφορά στην ομάδα (αντικείμενο) κατά την κλήση άλλης συνάρτησης ή τμήματος, ακόμα και αν αυτό είναι σε άλλο αντικείμενο, χωρίς να περάσουμε όλο το αντικείμενο, δηλαδή εκθέτουμε με αναφορά σε μια λειτουργία που θα παραλάβει κάποια δεδομένα, από εκεί που εκθέτουμε, θα τα επεξεργαστεί και θα δώσει αποτέλεσμα, όσες φορές θέλουμε πριν επιστρέψει η ροή στην επόμενη εντολή. Πχ αντικ2.τμημα1 &αντικ1.συναρτ1() όπου στο 2 και στο τμήμα του 1 εκθέτουμε το αντικείμενο 1 μέσω της συνάρτησης του 1. Στην Μ2000 όλα τα αντικείμενα έχουν τον τύπο Ομάδα, ανεξάρτητα από το τι μέλη έχουν (η Μ2000 έχει και ειδικά αντικείμενα που σχετίζονται με το σύστημα COM, για τις φόρμες και για επικοινωνία με προγράμματα όπως το Word)


Η πρώτη έκδοση του προγράμματος έγινε εδώ  στο Vbforums

\\ Συναρτησιακός προγραμματισμός
\\ γραμμένος στη γλώσσα Μ2000
\\ Με F1 ο διορθωτής αλλάζει την αναδίπλωση λέξεων (τη βάζει ή τη βγάζει)
\\ Αν θέλουμε Ελληνικά στα μενού τότε γράφουμε Ελληνικά στην γραμμή εντολών
\\ ή με το Ρυθμισεις (ctrl U) βάζουμε ελληνικά εξ αρχής


\\ Γιώργος Καρράς



\****************** Τμήμα Γενικό Pack ******************************************
\* Η Pack δέχεται με αναφορά μια μεταβλητή αλφαριθμητική και βάζει ένα στοιχείο
\* που διαβάζει από το σωρό κατάλληλα διαμορφωμένο.
\* Δεν επιστρέφει τιμή στο σωρό
\**************************************************************************
Τμημα Γενικό Pack {
            Διάβασε &a$
            Αν Ειναρ Τότε Βάλε trim$(str$(αριθμός)) \\ η Ειναρ γυρίζει αληθές η κορυφή του σωρού είναι αριθμός  (για αλφαριθμητικό είναι το Εινγρ.
            Αν a$="" Τότε { a$="{"+γράμμα$+"}"
             } Αλλιώς a$=a$+", {"+γράμμα$+"}"
      }
\********************Τμήμα Γενικό Unpack********************************
\* Αυτά που είχε βάλει το Pack τα διαμορφώνει το Unpack
\*  ώστε σίγουρα να αποτελούν συναρτήσεις!
\* ο χειριστής ~ είναι ίδιος με την Like της VB6
\* το b$ ~ "*=*"  δίνει αληθές (-1) αν υπάρχει το
\* ίσον κάπου μέσα στο κείμενό του B$, αλλά όχι σε άκρες
\* το ? "=12" ~ "*=*" τυπώνει 0 (ψευδές) γιατί δεν έχει γράμματα
\* αριστερά του ίσον
\**************************************************************************
Τμήμα Γενικό Unpack {
      Διάβασε b$
      Αν b$ ~ "*=*" Τότε {
       b$="{"+b$+"}"
      } Αλλιώς b$="{= "+b$+"}"
      Βάλε b$
}     
\**********************Συνάρτηση Γενικό List$******************************
\* Δημιουργεί μια λίστα συναρτήσεων (χωρίς όνομα)
\* γενική b=10
\* a$=list$(b+12,{b**2})
\* όταν χρησιμοποιήσουμε τη λίστα το b**2  (ίδιο με το b^2)
\* θα υπολογιστεί τότε, ενώ το b+12 υπολογίζεται στη δημιουργία
\* Έτσι υλοποιούμε τις eager και lazy επεξεργασίες (evaluations).
\*************************************************************************************
Συνάρτηση Γενική List$ {
      s$=""
                        \\ ο σωρός της συνάρτησης κληρονομείται στην Pack
                        \\ έτσι οι παρέμετροι ένας προς έναν πάνε στην Pack
                        \\ με πρώτο όμως μια αναφορά την s$ για να μαζέψουμε τη λίστα.
      Αν Μέγεθος.Σωρού =0 Τότε Βάλε ""
      Για i=1 Έως Μέγεθος.Σωρού { Pack &s$ }
      =s$
}
\**************************** Συνάρτηση List.count************************************
\* Διαβάζουμε τον αριθμό στοιχείων στην λίστα
\* Η εντολή ένθεση εκτελεί ένα αλφαριθμητικό ως κώδικα
\* Με την Pack κάναμε όλη τη λίστα να έχει αλφαριθμητικά
\* (οι αγκύλες { } ορίζουν και αλφαριθμητικά εκτός από μπλοκ εντολών)
\* Η συνάρτηση έχει δικό της σωρό και στο πέρας θα διαγραφεί
\* Έτσι παίρνουμε μόνο το μέγεθος σωρού που μας ενδιαφέρει.
\**************************************************************************************
Συνάρτηση List.count {
      Διάβασε a$
      Ένθεση "Βάλε "+a$
      =Μέγεθος.Σωρού
}
\*******************************Τμήμα  Goal******************************************
\* Με παράμετρο μια αναφορά σε λίστα μας δίνει τα στοιχεία της ένα προς ένα
\* στην τρέχουσα έξοδο που είναι μέσω της Τύπωσε
\* (εξ ορισμού η τύπωσε εξάγει στην οθόνη αλλά μπορεί να αλλάξει αυτό)
\* Μπορούμε να δώσουμε μια δεύτερη παράμετρο και να αλλάξουμε το τι θα κάνουμε
\* σε κάθε στοιχείο της λίστας. Ουσιαστικά αυτό το τμήμα τρέχει τις λίστες.

\* Η εντολή Πάνω χωρίς παραμέτρους διπλασιάζει τη κορυφή
\* του σωρού τιμών (ειδική στοίβα της Μ2000)
\**************************************************************************************
Τμήμα Γενικό Goal {
      Πάνω : Διάβασε test$
      Αν Θέση(test$,"{")=1 Τότε {
            Διάβασε &a() \\ Συνάρτηση
            Σωρός νέος {
            a$=""
            Κάλεσε a()
            Αν Μέγεθος.Σωρού=0 Τότε Διέκοψε \\ η Διέκοψε (break) **σπάει** πολλά μπλοκ μαζί
            Για i=1 Έως Μέγεθος.Σωρού {pack &a$}
            }
      } Αλλιώς Διάβασε &a$
      Αν a$="" Τότε Έξοδος \\ η έξοδος **σπάει** μόνο το τρέχον μπλοκ
      Αν ταύτιση("S") Τότε { Διάβασε &redirect() } Αλλιώς Συνάρτηση redirect {Διάβασε a: Τύπωσε a}
      Σωρός νέος {
            Ένθεση "Σειρά "+a$ \\ Η εντολή σειρά βάζει στο σωρό ως FiFo  \\ Η Βάλε ως  LiFo
            Ενώ Όχι Κενό {
                  Για Αυτό { \\  δημιουργούμε ένα μπλοκ για προσωρινά ονόματα.
                        Unpack
                        Διάβασε &pp() \\ μόνο σε ονόματα που δεν υπάρχουν βάζουμε αναφορές
                        \\ εδώ έχουμε τους δυο τρόπους κλήσης συνάρτησης
                        \\ ο πρώτος δίνει νέο σωρό και περιμένει τιμή.
                    
                          Βάλε pp() \\ βάζουμε το αποτέλεσμα στο σωρό
                      
                        \\ ο δεύτερος καλεί τη συνάρτηση ως τμήμα, παρέχοντας το σωρό
                    
                          Κάλεσε redirect() \\  μη μηδενική τιμή αν επιστραφεί (π.χ. με =10) θα δώσει Λάθος
                    
                        \\\  κάποιος θα έβαζε π.χ. kk=redirect(pp()) και θα δούλευε...στο παράδειγμα
                        \\ kk=redirect(pp())     \\ σκίασε τα παραπάνω Βάλε και Κάλεσε και αποκάλυψε αυτό εδώ!
                    
                        \\ πράγματι δουλεύει για αυτά τα παραδείγματα. Αλλά με τον παραπάνω τρόπο
                        \\\ εκθέτουμε το σωρό στην redirect() που σημαίνει ότι παρέχουμε δυνατότητα να
                        \\ "διαβάσει μπροστά"...ή look ahead, να δουλεύει ανά δυο στοιχεία.
                        \\ να γιατί παραπάνω έχουμ εμια Ενώ όχι κενό { } και όχι μια Για ι=1 Έως Μέγεθος.Σωρού {}
                    
                        \\ τώρα η pp() θα διαγραφεί. Και έτσι την επόμενη φορά θα της δώσουμε αναφορά!
                  }
            }
      }


}
\********************************Τμήμα Γενικό Process*******************************
\* Δέχεται μια λίστα ή μια συνάρτηση και μια πράξη.
\* Επιπλέον διαβάζει έναν αριθμό (αυτός δίνεται στην Goal ως αποτέλεσμα
\* από κάθε συναρτηση (η λίστα της Goal είναι μια λίστα συναρτήσεων)
\* Αν με την Process περάσουμε λίστα έχουμε για κάθε αποτέλεσμα πράξη..
\* με κάθε στοιχείο στη λίστα
\**************************************************************************************
Τμήμα Γενικό Process {
      Διάβασε mylist$, op$
      Διάβασε a
      Σωρός νέος {
            Ένθεση "Σειρά "+ mylist$
            Διάβασε where$
            Ενώ Όχι Κενό {
                  Για Αυτό {
                        Unpack
                        Διάβασε &bb()
                        Ένθεση " Pack "+where$+", a"+op$+"(bb())"                       
                  }
            }
      }
}
\**************************************************************************************
\* Σε μια γραμμή Συναρτησιακός Προγραμματισμός:
\* Γενικό ThisString$ : Goal "{Κάλεσε integer(25)}"  , "{qubic_of &ThisString$}" : Τύπωσε ThisString$
\**************************************************************************************


Φόρμα 60,28 \\ οθόνη με φόρμα 60 χαρακτήρες πλάτος επί 28 γραμμές
Άδειασε   \\ ο σωρός τώρα αδειάζει από οτιδήποτε
Τύπωσε list.count("") \\ 0
Γενικό ab=10, bb=30
      a$=List$({bb+=ab : =sqrt(ab)},40,{ab**2+bb-20}, 50,60)
            Goal &a$
Γενικό sss$
      Goal &a$,  "{Pack &sss$}"  \\ δίνουμε συνάρτηση για να πάρουμε μια λίστα
            Τύπωσε sss$ \\ τυπώνουμε τη λίστα


Τύπωσε ab, bb



Γενικό add$, mul$
a$=List$(1,2,3)
Γενικό b=10, a=25


\\ Θα προσθέσουμε κάθε στοιχείο της λίστας a$ με άλλη λίστα
\\ η εξαγωγή θα πάει στο add$
\\ ουσιαστικά εδώ με το b++ σπάμε το κανόνα που θέλει να μην γίνονται αντικαταστάσεις


Goal &a$ ,  "{Process List$({&add$},{b++: =b},5,{a/2+b},20, a),{+} }"
Τύπωσε add$


\\ Θα πολλαπλασιάσουμε κάθε στοιχείο της λίστας a$ με άλλη λίστα
\\ η εξαγωγή θα πάει στη λίστα mul$
Goal &a$ ,  "{Process List$({&mul$},{b++: =b},5,{a/2+b},20),{*} }"
Τύπωσε mul$


Γενικό Result$, Result1$, Result3$
      zero$=list$(25)
      Goal &zero$, "{Διάβασε kl : Για i=1 Έως kl {Σειρά i*i : Pack &Result$}}"
      Τύπωσε Result$
  
      Goal "{Για i=1 Έως 25 {Σειρά i*i}}", "{Pack &Result1$}"
      Τύπωσε Result1$


Συνάρτηση Γενική integer { Διάβασε x : Ενώ x>0 { Βάλε x : x--}}
Τμήμα Γενικό square_of { Διάβασε &S$, x: Pack &S$, x*x}
Τμήμα Γενικό qubic_of { Διάβασε &S$, x: Pack &S$, x*x*x}


      Goal "{Κάλεσε integer(25)}"  , "{square_of &Result3$}"
      Τύπωσε Result3$


Καθαρό Result3$ 


      Goal "{Κάλεσε integer(25)}"  , "{qubic_of &Result3$}"
      Τύπωσε Result3$
      Τύπωσε "ok"


Βασικές γνώσεις (Τμήματα) στη Μ2000

Σημ 1. Μπορούμε να γράφουμε σημειώσεις με την Σημ (REM)
\\ και χωρίς αυτήν με το \ ή και το '
' και αυτή είναι σημείωση


Σημ 1.1 για να εκτελέσουμε αυτό το παράδειγμα:
\\ τρέχουμε το m2000.exe
\\ γράφουμε   σ α   (ανοίγει ο διορθωτής για το τμήμα α)
\\ κάνουμε επικόλληση και πατάμε Esc
\\ γράφουμε το όνομα του τμήματος:  α (και πατάμε Enter)
\\ τόσο απλά.
\\Με βελάκια πάνω-κάτω βλέπουμε τις παλαιότερες εντολες.
\\ Σώνουμε με Σώσε ενα_ονομα
\\ Φορτώνουμε με Φόρτωσε ενα_ονομα
\\ Βλέπουμε τι τμήματα έχουμε με Τμήματα  και Τμήματα ?
\\ Για συναρτήσεις γενικές γράφουμε Σ α( ή Σ α$( ή Σα%(
\\ (πρέπει να δηλώνουμε τι επιστρέφει αριθμό ή γράμματα
\\ Μπορούν να επιστρέφουν πίνακες και αντικείμενα, αλλά αυτό
\\ δεν φαίνεται από το όνομα αλλά από το πρόγραμμα!
\\ Γράψε: Βοήθεια Όλα και κάνε κλικ σε κάτι απ' όλα!

Σημ 2. Εδώ θα δούμε την έννοια του σκοπού μιας μεταβλητής
\\ εδώ σε πίνακα και σε τμήμα.
\\ Τα τμήματα μοιάζουν με τις διαδικασίες σε άλλες γλώσσες
\\ Μπορούμε να δουλεύουμε μόνο με τοπικά τμήματα
\\ και τμήματα σε τμήματα, καθώς και σε ζήτηση να φορτώνουμε
\\ με αυτήν την έννοια μπορούμε κάθε τμήμα να το βλέπουμε ως
\\ ένα πρόγραμμα. Η είσοδος και έξοδος μπορεί να είναι κοινή
\\ και αυτό γιατί η Μ2000 έχει ένα σωρό Τιμών που μέσω αυτού
\\ περνάει ενώνει τα τμήματα που καλεί με δεδομένα, και σε αυτό
\\ μπορούν να επιστρέψουν τιμές.
\\ Τα τμήματα δεν έχουν αναδρομή με την απευθείας κλήση
\\ Έχουν αν τα καλέσουμε με την Κάλεσε. Η διαφορά υπάρχει στο
\\ τρόπο που ονομάζεται εσωτερικά ένα τμήμα, και έχει επίπτωση
\\ σε αυτό που λέμε χώρο ονομάτων Δες παρακάτω.


Σημ 3. Μπορούμε να φτιάχνουμε γενικούς πίνακες με μια τιμή
θεσε πίνακας α(10,5)=100


Σημ 3.1. Ή χωρίς τιμή
Γενικό β(10,10), δ(20,20), κ()
Πίνακας β(5,5) =20 \\ εδώ σκιάσαμε τον γενικό με ένα τοπικό
κ()=β() \\ αλλά εδώ βγάλαμε ένα αντίγραφο και τον δώσαμε στον γενικό
Τύπωσε β(3,3) \\ τοπικό


Σημ 4. Τεκμηρίωση: καλούμε το τμήμα άλφα και βλέπουμε αποτελέσματα
τμήμα γενικό άλφα { \\ στον ορισμό συνάρτησης βάζουμε συνάρτηση γενική
      τυπωσε 123, α(1,1), β(3,3), κ(3,3)
}


άλφα    \\ καλούμε την άλφα


Σημ 5. Τώρα θα καλέσουμε την άλφα από ένα τοπικό τμήμα βήτα


Τμήμα βήτα {
      διάβασε οδηγία$
      αν οδηγία$="οκ" τότε {
            άλφα
      } αλλιώς.αν οδηγία$="" τότε κάλεσε άλφα \\ άλλος τρόπος κλήσης
}


βήτα "οκ"
βήτα ""


Σημ 6. Τα τμήματα διαβάζουν τον σωρό τιμών


βάλε "οκ"
βήτα   \\ τώρα το "οκ" το βρήσκει στον σωρό
βάλε ""
κάλεσε βήτα


Σημ 7. Μπορούμε να περνάμε τιμές με αναφορά


Τμήμα δέλτα {
      Διάβασε &κάτι
      κάτι+=100
}
γενικό Άλφα
τοπική βήτα \\ εξ ορισμού είναι όλα τοπικά στο τμήμα   - δεν υπάρχει εντολή τοπικό!
Άλφα<=40 \\ τα γενικά θέλουν <= στην αντικατάσταση τιμής, αλλιώς θα φτιαχτεί τοπική
                  \\ Οι πίνακες δεν χρειάζονται το <= για αντικατάσταση σε γενικό
Στη Άλφα=50
                  \\ η Στη (LET) δουλεύει αλλιώς οπότε δεν φτιάχνει τοπική αν υπάρχει γενική
Άλφα+=20
Άλφα++ \\ =71
δέλτα &Άλφα
Τύπωσε Άλφα \\  171
δέλτα &βήτα
Τύπωσε βήτα



\\ Περί Τμημάτων (βασικά θέματα):
\\  Τα τμήματα διαφέρουν από τις Διαδικασίες άλλων γλωσσών γιατί:
\\  1. Μπορούν να επιστρέφουν τιμές εκτός με αναφορά και σε σωρό
\\  2. Βλέπουν μόνο τις δικές τους μεταβλητές και εκείνες του γενικού σκοπού.
\\  3. Μπορούν να δημιουργούν άλλα τμήματα ή να τα φορτώνουν
\\  4. Μπορούν να δημιουργούν σκιάζοντας γενικές μεταβλητές
\\ 5. Δεν έχουν αναδρομή εκτός και αν κληθούν ως συναρτήσεις (προχωρημένο θέμα).
\\ 6. Τα τμήματα μοιράζονται τον ίδιο σωρό αν είναι στην ίδια σειρά κλήσης
\\ 7. Τα τμήματα που ορίζουμε με τη συγγραφή (π.χ. σ Α) είναι γενικού σκοπού.


\\Περί σειράς κλήσης
\\ Αν το Α καλέσει το Β και το Β το Γ τότε λέμε ότι το Γ είναι σε σειρά κλήσης με το Α
\\ Επειδή η Μ2000 έχει νήματα...ενδέχεται ένα νήμα στη Γ να καλέσει την Α
\\ Αυτό το νήμα ξεκινάει νέα σειρά κλήσης. Η Α που κάλεσε έχει απλά το ίδιο πρόγραμμα.
\\ Αυτό που τρέχει ως Α στο νήμα του Γ και οι μεταβλητές του....
\\ .......(τα ονόματά του) είναι σε άλλο "χώρο ονομάτων", και επιπλέον έχουν άλλο σωρό.
\\ Εκτός από τα νήματα αυτό συμβαίνει και με τις συναρτήσεις που φτιάχνουμε.
\\ Κάθε δική μας συναρτηση όταν τρέχει ξεκινάει την δική της σειρά κλήσης με δικό της σωρό.
\\ Ακόμα και αν καλέσει τον εαυτό της, κάθε κλήση θα είναι μια νέα σειρά κλήσης, νέος σωρός.
            Συνάρτηση Άλφα {
                  διάβασε Α
                  =Α+1
            }
            Τύπωσε Άλφα(Άλφα(Άλφα(1))) \\ κάθε διάβασε στην Άλφα γίνεται σε νέο σωρό.
\\                                  4
\\ μπορούμε να φτιάχνουμε και συναρτήσεις σε μια γραμμή, αλλά θα δώσουμε τις παραμέτρους
\\ αυτή είναι μακροεντολή γιατί φτιάχνει ουσιαστικά μια Συνάρτηση βήτα {Διάβασε Χ : =Χ+1}
\\ επιπλέον αυτός ο τρόπος της μια γραμμής (από το DEF FN της παλιάς Basic) δεν παίρνει σήμα Γενική
\\ def beta(x)=x+1   \\ από την παλιά Basic (χωρίς το FN, η παλιά Basic το είχε απλά πρόσθετο στο όνομα)
κάνε βήτα(Χ)=Χ+1
Τύπωσε βήτα(2)


\\ Οι συναρτήσεις μπορούν να περαστούν με αναφορά (όμως θα είναι απλά πέρασμα ο κώδικας, όχι οι μεταβλητές)


Τμήμα έψιλον {
       \\ η διάβασε ξεχωρίζει αν έχουμε αναφορά πίνακα ή συνάρτησης
      Διάβασε &Οποιοδήποτε_Όνομα(), &ΚάτιΑλλο()
      ? Οποιοδήποτε_Όνομα(ΚάτιΑλλο(1)) \\ το ? είναι Τύπωσε
}
πίνακας κλ(10)=20
\\ Το &κλ(1) είναι --ΛΑΘΟΣ--- δεν μπορούμε να το περάσουμε, αναφορές σε στοιχεία πίνακα δεν γίνονται
\\ ούτε αναφορές συνάρτησης με πέρασμα μεταβλητών έτσι &βήτα(1,2,4) ---ΛΑΘΟΣ---
έψιλον &βήτα(), &κλ()
\\              21


\\ Περί Σκοπού:
\\  Αν  τα παρακάτω έχουν οριστεί γενικού σκοπού φαίνονται παντού
\\  Μεταβλητές, Πίνακες, Τμήματα, Συναρτήσεις, Κλάσεις
\\ (οι κλάσεις στην Μ2000 είναι συναρτήσεις που κατασκευάζουν αντικείμενα)
\\ Βασικοί Κανόνες:


\\*** Οτιδήποτε τοπικό με ίδιο όνομα κρύβει το αντίστοιχο γενικό****
\\ Αν ορίζουμε γενικές μεταβλητές ή πίνακες με την θέσε τότε κάνουμε αντικατάσταση
\\ Αν ορίζουμε με την γενικό (ή γενική) τότε δημιουργούμε νέα μεταβλητή/πίνακα
\\  που σκιάζει το προηγούμενο. Η σκίαση φεύγει αν η τοπική βγει εκτός σκοπού, σβηστεί.


\\ ***Οτιδήποτε ορίζεται εντός τμήματος, ακόμα και γενικό, θα σβηστεί στο πέρας**
\\ Ο σωρός τιμών δεν έχει όνομα! Έτσι δεν εμπίπτει στο κανόνα.
\\ μπορούμε να φτιάξουμε ένα πίνακα σε ένα τμήμα και να αφήσουμε ένα αντίγραφο στο σωρό.
\\ όμως ο αρχικός θα χαθεί! Θα μείνει το αντίγραφο. Λογικά λοιπόν μπορούμε να φτιάξουμε
\\ κάτι και να εξάγουμε. Άλλο σημαίνει φτιάχνω και άλλο ορίζω!



Κυριακή, 27 Σεπτεμβρίου 2015

Δοκιμή σε Windows 8 (M2000)

Η αναθεώρηση της γλώσσας, στην τελική έκδοση 8.7. Δείτε την αρχική σελίδα

Στις εικόνες στο παλιό κείμενο δεν φαίνεται ο χρωματισμός εντολών στον διορθωτή! Οπότε να μια με χρωματισμό, ο οποίος γίνεται αυτόματα (το τμήμα σώνεται χωρίς χρώμα, ο υπολογισμός είναι πολύ γρήγορος). Φαίνεται και η κίτρινη μπάρα ολίσθησης- που εξαφανίζεται κανονικά αλλά εδώ είχα το δείκτη πάνω της. Η εντολή Οθόνη, -19 δίνει 19 γραμμές από το κάτω μέρος για τη χωριστή οθόνη,στην οποία από πάνω καλύπτει  η φόρμα του διορθωτή, χωρίς να σβήσει κάτι στην οθόνη, με esc βγαίνουμε από τον διορθωτή, με αριστερό κλικ στην γραμμή αναφοράς ανοίγει το μενού επιλογών, όπως και με δεξί κλικ οπουδήποτε στο διορθωτή. Μπορούμε να επιλέξουμε πολλές γραμμές και με Tab τις μεταφέρουμε δεξιά ή με Shift Tab αριστερά! Με F1 αλλάζουμε την αναδίπλωση λέξεων (με ή χωρίς). Με F12 βλέπουμε λίστα με άλλα τμήματα και επιλέγουμε κάποιο για να το συγκρίνουμε ή να πάρουμε κάποιο τμήματα του. Με F6 έως F8 βάζουμε σελιδοδείκτες (το σύστημα τους κρατάει μόνο για το τμήμα που διορθώνουμε)
Ο διορθωτής μπορεί να δείξει οποιαδήποτε γλώσσα (δουλεύει με Unicode) και μπορούμε να βάζουμε επιπρόσθετους τόνους, π.χ. Γιω̃ργος  μετά το ω πατάμε Alt 771 με δεκαδικό νούμερο ή με δεκαεξαδικό: Alt + 303  (το "+" το πατάμε).
Τον διορθωτή τον έχω γράψει και είναι μέσα στο κώδικα της Μ2000 σε Visual Basic 6/




Δοκίμασα την τελευταία αναθεώρηση (56) σε Windows 8. Τρέχει πιο γρήγορα από τις παλαιότερες εκδόσεις (μετά την αλλαγή στη ρουτίνα που κάνει τα ελληνικά κεφαλαία).


1.Αποτύπωση της οθόνης, με το πρόγραμμα της προηγούμενης ανάρτησης. Εδώ τρέχει το m2000.exe



2. Η Μ2000 μέσα στο IDE της Visual Basic 6. Φαίνεται το βασικό τμήμα με 28271 γραμμές.

Όλες οι φόρμες έχουν ένα μόνο User Control που κάνει τα πάντα σε συνδυασμό με κλάσεις όπως η TextViewer.cls που το κάνει επεξεργαστή κειμένου. 


Λειτουργεί και το TAB και SHIFT TAB, επιλέγοντας στοιχείο.  Με βελάκι ανοίγουμε τη λίστα και επιλέγουμε. Έχει αυτόματη συμπλήρωση.  Εκεί που έχει μια μπάρα ολίσθησης αλλάζουν οι τιμές με το ροδελάκι του ποντικιού ή και τα βελάκια.


Εδώ μίκρυνα την φόρμα από τη κάτω δεξιά γωνία!


Στη γραμματοσειρά έχουμε αυτόματη συμπλήρωση, αλλά και πριν επιλέξουμε καθώς βλέπουμε τις επιλογές έχουμε δίπλα την προεπισκόπηση.


Πάντα εμφανίζονται τα αρχεία πάνω και οι φάκελοι από κάτω. Εδώ υπάρχει και πεδίο με προεπισκόπηση.


Όλες οι φόρμες για αρχεία, φακέλους, εικόνες έχουν ρύθμιση (οι δυο λευκές παύλες ανοίγουν την ρύθμιση). Μπορούμε να βλέπουμε δένδρο με βάθος τριών υποφακέλων ή το συνολικό. Η ενέργεια γίνεται στο περιθώριο (βλέπουμε το τρέχον μέχρι να ετοιμαστεί το ζητούμενο).



Οι επιλογές μπορούν να γίνουν με κλικ ή με σύρσιμο δεξιά  Δεν μπορούμε να μετακινήσουμε ή να σβήσουμε αρχεία από αυτούς τους διαλόγους (και για το λόγο αυτό φτιάχτηκαν). Επίσης όλοι οι διάλογοι δείχνουν Unicode χαρακτήρες. (και είναι φτιαγμένοι με ένα μόνο στοιχείο ελέγχου, εδώ έχει τρία, τίτλος, μέση, και κάτω επιλογή)



Το μενού βγαίνει ή με δεξί κλικ στο κείμενο ή με αριστερό στην γραμμή πληροφοριών. Τα F6 F7 F8 είναι σημάδια στο κείμενο για να πηγαίνουμε γρήγορα. Με ένα πάτημα μπαίνει το σημάδι, με δεύτερο αν είναι στο προορισμό σβήνει, αν δεν είναι πηγαίνει (τόσο απλά). Αν το κείμενο δεν είναι αναδιπλωμένο (αλλάζει με F1) τότε το σημάδι θα μετακινήσει κατάλληλα το κείμενο. Τα σημάδια σχετίζονται με συγκεκριμένες παραγράφους και όχι με τον αριθμό σειράς εμφάνισης. Αν δηλαδή διαγράψουμε παραγράφους πιο πριν δεν θα χαθεί το σημάδι. Το ίδιο αν βάλουμε άλλες πριν.



Επειδή εδώ έχω χωριστή κάτω οθόνη  ο διορθωτής ανοίγει στο κατάλληλο ύψος για να μην κρύψει ότι θέλω να είναι σταθερό στην οθόνη. Επίσης και το αναδυόμενο μενού μεγαλώνει με τράβηγμα από την κάτω δεξιά γωνία (και μικραίνει). Η μπάρα ολίσθησης κρύβεται, όπως και στον επεξεργαστή κειμένου και στη βοήθεια (δες παρακάτω), αυτόματα και ανοίγει αυτόματα, αν πάμε το δείκτη στο πλάι.

Αλλαγή μεγέθους γραμμάτων με την εντολή Φόντο. Εδώ έδωσα 40,20 που σημαίνει 40 χαρακτήρες επί είκοσι γραμμές χαρακτήρων. Διορθώνω απ΄ευθείας στο αρχείο. Το βλέπω στο όνομα κιόλας. δώ έχω επιλέξει το πενα με ένα κλικ και πάτησα ctrl+F1 και βλέπω τη βοήθεια. Η εντολή φόντο αφαιρεί τη χωριστή οθόνη, και έτσι ο διορθωτής πιάνει όλη την οθόνη.
Φόντο 40,20 
Σ  "ιταλικα.gsb"

Πρόγραμμα απόδοσης προφοράς Ιταλικών (Μ2000)

Σε αυτή την ανάρτηση θα δούμε τη Μηχανή Απόδοσης Προφοράς Ιταλικών Λέξεων. Είναι ένα παράδειγμα και όχι ό,τι καλύτερο. Έχω κάνει μερικές αλλαγές από την αρχική έκδοση που γράφτηκε πριν έντεκα χρόνια και έτρεχε σε έκδοση 5.6. Τρέχει στην έκδοση 8 αναθεώρηση 56 και πάνω.
Η αναθεώρηση 56 είναι σημερινή, και περιλαμβάνει δυο εντολές την ΣΕΝΑΡΙΟ και την ΕΝΘΕΣΗ ΚΩΔΙΚΑ (η ΕΝΘΕΣΗ υπάρχει αλλά προστέθηκε μια παραλλαγή). Η πρώτη τρέχει στο διερμηνευτή εντολών γραμμής ενώ η δεύτερη στον Εκτελεστή (δες παρακάτω). Και οι δυο κάνουν το ίδιο πράγμα, δηλαδή ζητούν ένα όνομα τμήματος και παίρνουν τον κώδικα και τον τρέχουν απευθείας, σαν να ήταν ο κώδικας γραμμένος στη θέση της εντολής. Το γιατί το ήθελα αυτό θα το δούμε στο παράδειγμα των Ιταλικών!

Επί ευκαιρία να ξεκαθαρίσω ότι η γλώσσα έχει πέντε εσωτερικούς διερμηνευτές:
1. Ο διερμηνευτής γραμμής εντολών (CLI ή command line interpreter)  και εκεί δεν υπάρχουν εντολές όπως ΓΙΑ, ΕΝΩ, ΕΠΑΝΕΛΑΒΕ, ΕΠΙΛΕΞΕ και άλλες που θέλουν πολλές γραμμές και εκτελούν άλματα μπρος ή πίσω. Ο διερμηνευτής αν δεν αναγνωρίζει μια εντολή καλεί τον εκτελεστή. Αν και λέγεται "γραμμής" μπορεί να εκτελέσει πολλές εντολές αν χωρίζονται με : ή με αλλαγή γραμμής.

2.Ο εκτελεστής ο οποίος φτιάχνει μεταβλητές, έχει όλες τις εντολές που αλλάζει ροή στο πρόγραμμα, και ότι δεν αναγνωρίζει καλεί τον διερμηνευτή εντολών. 

3.Ο διερμηνευτής εντολών, εκτελεί ότι δεν γνωρίζουν τα παραπάνω. Όμως, εδώ είναι το ωραίο, εκτελεί εντολές οι οποίες καλούν πάλι τον εκτελεστή ή και τον διερμηνευτή γραμμής εντολών, αλλά όχι ως μια επικοινωνία του Β προς το Α, το οποίο το είχε καλέσει, αλλά με νέα εκκίνηση. 

και οι τρεις παραπάνω διερμηνευτές καλούν τους άλλους δύο (4ος, 5ος):
4. Ο επεξεργαστής Εκφράσεων με αριθμητικό αποτέλεσμα, που περιλαμβάνει και τις συγκρίσεις με σύμβολα και με χειριστές όπως ΚΑΙ, Η, ΑΠΟ (το ΑΠΟ είναι το XOR). Αυτός λοιπόν αναγνωρίζει τις εκφράσεις και ενδεχομένως μέχρι να βγει το αποτέλεσμα να έχουν κληθεί όλοι οι άλλοι μεταφραστές και ο ίδιος ξανά, αλλά όπως έγραψα παραπάνω όχι  κλήση του προηγούμενου αλλά κλήση κάθε φορά ενός νέου διερμηνευτή ή επεξεργαστή. Αυτός ο επεξεργαστής αναγνωρίζει τις μεταβλητές που έχουμε ορίσει, τις συναρτήσεις που υπάρχουν στη γλώσσα και αυτές που έχουμε ορίσει καθώς και μια σειρά μεταβλητών μόνο ανάγνωσης (αλλάζουν τιμές από το σύστημα, και μόνο διαβάζονται)

 5. Ο επεξεργαστής Εκφράσεων Αλφαριθμητικών. Εδώ η επιστροφή του είναι αλφαριθμητικό (γράμματα με οτιδήποτε σύμβολα ακόμα και αριθμούς ή ακόμα και το κενό αλφαριθμητικό). Και αυτός έχει δικό του διερμηνευτή που γνωρίζει μεταβλητές αλφαριθμητικές, συναρτήσεις γλώσσας και εκείνες του χρήστη.

Το ότι κάθε μεταφραστής δύναται να κληθεί πολλές φορές, είναι με την έννοια ότι το Α καλεί το Β μετά το Β το Γ μετά το Γ το Α μετά το Α το Δ μετά το Δ το Γ μετά το Γ το Α και κάποια στιγμή όλα επιστρέφουν στην αρχική κλήση. Η δυνατότητα αυτή λέγεται Reentrancy γιατί αν το δούμε αλλιώς, όταν το  Α καλεί το Β δεν έχει τερματίσει, και κάπου στο βάθος των κλήσεων μια άλλη ρουτίνα ή συνάρτηση καλεί την Α κάνει την δουλειά του και  με τις επιστροφές φτάνουμε στην Α και αυτή συνεχίζει. Αυτά συμβαίνουν στο κώδικα της Μ2000 που είναι γραμμένος σε Visual Basic 6

Τα τμήματα στην Μ2000 δεν μπορούν ως έχουν να καλέσουν τον εαυτό τους (οι συναρτήσεις μπορούν). Η κλήση στον εαυτό λέγεται αναδρομή. Για να πετύχουμε το Reentrancy εκεί που δεν υπάρχει αναδρομή, πρέπει να καλέσουμε ένα τμήμα ξανά μέσω ενός άλλου τμήματος. Δείτε όμως το θέμα στο παρακάτω πρόγραμμα. Αν βγάλουμε το προσδιοριστικό "γενικό" σε κάθε τμήμα τότε έχουμε λάθος! Δηλαδή στην μπες_ξανά κάνουμε να καλέσουμε την μπες_από_εδώ  αλλά αυτή δεν υπάρχει για την μπες_ξανά  υπάρχει για την α. Αν ορίσουμε ότι αυτά τα δυο εσωτερικά τμήματα είναι γενικά τότε θα τρέξει το πρόγραμμα μέχρι το κ να γίνει μικρότερο του 0. Έτσι καταλαβαίνουμε ότι στην Visual Basic 6 οι συναρτήσεις και οι διαδικασίες (subroutines) βρίσκονται σε μια γενική οριοθέτηση, δηλαδή μεταξύ τους είναι "γνωστά", ή όπως λέμε είναι γενικού σκοπού. Όπως βλέπουμε στη Μ2000 ο σκοπός περιορίζεται σε ότι υπάρχει στο τρέχον τμήμα ή έχει ονομαστεί πρωτύτερα ως γενικό. 

Τμήμα α {
      τμήμα γενικο μπες_ξανά {
            διαβασε κ
            τύπωσε τμήμα$, κ \\τυπώνει το αναγνωριστικό του τμήματος
            αν κ>0 τότε μπες_από_εδώ κ-1
      }
      Τμήμα γενικο μπες_από_εδώ {
            διαβασε κ
            τύπωσε τμήμα$, κ
            μπες_ξανά κ-1
      }      
      μπες_ξανά 10
}
α   

Παρακάτω είναι ένα πρόγραμμα με μια ιδιαιτερότητα ως προς τον σχεδιασμό. Η Μ2000 έχει έναν πίνακα που βάζει σε κάθε θέση ένα τμήμα ή μια συνάρτηση. Για να τρέξει ένα τμήμα ή μια συνάρτηση πρέπει να βρίσκεται στον πίνακα αυτό. Όταν σε ένα τμήμα έχουμε ορισμούς άλλων τμημάτων, όταν το τρέξουμε αυτά τα τμήματα θα μετεγγραφούν στον πίνακα, θα εκτελεστούν αν τα καλέσουμε (η εκτέλεση γίνεται με αντιγραφή από τον πίνακα του κώδικα σε μια παράμετρο του εκτελεστή (δες το 2)), και στο πέρας της εκτέλεσης ότι ορίστηκε θα σβηστεί και θα μείνει η λίστα τμημάτων΄/συναρτήσεων ως είχε πριν εκτελέσουμε το τμήμα.
Όταν εκτελούμε την σ α, δηλαδή συγγραφή α, τότε αν υπάρχει το τμήμα στη λίστα μας το δίνει για διόρθωση/συμπλήρωση, αν δεν υπάρχει τότε δημιουργεί μια θέση επιπλέον και βάζει ένα κενό τμήμα με το όνομα που δίνουμε και μας ανοίγει το διορθωτή για να γράψουμε το τμήμα μας!
Θα μπορούσαμε λοιπόν να δούμε ένα πρόγραμμα ως μια συλλογή τμημάτων που καλούμε από την γραμμή εντολών. Δηλαδή εδώ αλλάζουμε την εντύπωση που ίσως είχαμε ότι ένα πρόγραμμα είναι κάτι "δεμένο" σε ένα σύνολο, αλλά μπορεί να απαρτίζεται από τμήματα χωριστά. Και εδώ στο παράδειγμα είναι σε τμήματα στην κυριολεξία. Και αντί να έχουμε ένα μενού επιλογών, γράφουμε απευθείας το τμήμα που θέλουμε με τις παραμέτρους του και παίρνουμε την απάντηση. Την ώρα που τρέχει ένα τμήμα, τα άλλα τμήματα βρίσκονται στο λεγόμενο επίπεδο μηδέν, όπου όλα είναι γενικά (να γιατί η ανάλυση της VB6 πριν). Το πρόγραμμα που θα βάλω εδώ δεν θα είναι γραμμένο σε ένα τμήμα αλλά σε ένα αρχείο με κατάληξη gsb και θα το φορτώσω στον μεταφραστή γραμμής ο οποίος θα τρέξει εντολές, θα φτιάξει τίτλους, θα χωρίσει την οθόνη, όπου το κάτω τμήμα της θα μπορεί να ολισθαίνει και θα περιμένει να δώσουμε εντολές ενώ δεν θα έχουμε βγει από την γραμμή εντολών!
Μάλιστα καθορίζει και το ctrl+F1 για να έχουμε βοήθεια, η οποία μας λέει ποιες εντολές έχουμε επιπλέον, σαν να προστέθηκαν στην γλώσσα, και ποια πλήκτρα λειτουργίας (κλειδιά) μπορούμε να χρησιμοποιήσουμε (F1 F2 F3).

Για να γράψουμε το αρχείο κάνουμε αυτό (ανοίγουμε τον διορθωτή για κείμενο στο δίσκο και όχι στη λίστα τμημάτων/συναρτήσεων)

σ "ιταλικα.gsb"
τώρα αντιγράφουμε το παρακάτω (ενημερώθηκε, γράφει έκδοση 2.1)


τμημα ΠΡΟΦΟΡΑ {
      διάβασε ΛΕΞΗ$
      αν ΛΕΞΗ$="" τότε έξοδος
      πενα 7
      τυπωσε "η λέξη: ";
      πενα χρώμα(255,128,40) {
            πλαγια
            τυπωσε ΛΕΞΗ$;
            πλάγια
      }
      τυπωσε " έχει προφορά: ";
      Ν = 1 : Μ = 1
      ΛΕΞΗ$=ΛΕΞΗ$+" "
      βαλε 0 ' σκοπός  - αν το βρούμε σημαίνει τέλος
      Ι=0
      {
            Ι++
            αν Ι> ΜΗΚΟΣ(ΛΕΞΗ$) τότε ΕΞΟΔΟΣ
            Σ=0
            ΑΣΦΑΛΕΙΑ=0
            Ν = 1
            {
                  Μ=Ν
                  επιλεξε με κεφ$(μεσ$(ΛΕΞΗ$, Ι, Ν))
                  με "A"
                        {Ν=2 :Ι++: βαλε "α"}
                  με "B"
                        βαλε "μπ"
                  με "C"
                        Ν = 2
                  με "CI","CE"
                  {
                        αν Σ=1 τότε {
                              διάβασε ΚΚΚ$
                              βαλε "σσ"
                        }αλλιώς βαλε "τσ"
                  }
                  με "CO","CA","CU", "CQ"
                        βαλε "κ"
                  με "C "
                        βαλε "τσι"
                  με "G "
                        βαλε "τζ"
                  με "SS"
                        {Ι++
                        βαλε "σ"}
                  με "GL"
                        Ν=3
                  με "GLI"
                        {βαλε "λι"
                         ι+=2
                        }
                  με "GH"
                        Ν=3
                  με "GHI", "GHE"
                        {Ι++
                         βαλε "γκχ"
                        }
                  με "CH"
                        Ν=3
                  με "CHI", "CHE"
                        {Ι++
                        βαλε "κχ"
                        }
                  με "D"
                        βαλε "ντ"
                  με "E"
                        {Ν=2:Ι++:βαλε "ε"}
                  με "F"
                        βαλε "φ"
                  με "G"
                        Ν=2
                  με "GN"
                        {Ι++
                        βαλε "νι"}
                  με "GI","GE"
                        βαλε "τζ"
                  με "GO","GA","GU"
                         βαλε "γκ"
                  με "H"
                         βαλε "" 'αηχο
                  με "I"
                         {Ν=2 :Ι++: βαλε "ι"}
                  με "L"
                         βαλε "λ"
                  με "M"
                         βαλε "μ"
                  με "N"
                         βαλε "ν"
                  με "O"
                         {Ν=2 :Ι++: βαλε "ο"}
                  με "P"
                         βαλε "π"
                  με "Q"
                         βαλε "κ"
                  με "R"
                         βαλε "ρ"
                  με "S"
                        {
                              Ι++
                              Μ=0
                              Σ=1
                              βαλε "σ"
                        }
                  με "SA","SO","SI","SU","SE"
                        βαλε "ζ"
                  με "T"
                         βαλε "τ"
                  με "U"
                        {Ν=2 :Ι++: βαλε "ου"}
                  με "V"
                        βαλε "β"
                  με "Z"
                        {
                              αν Ι=1 τότε {
                              βαλε "τζζ"
                              } αλλιώς βαλε "τσσ"
                        }
                  με "GG"
                        {Ι++
                        Ν=1}
                  με "CC"
                        {Ι++
                        Ν=1}
                  με "GB" ΕΩΣ "GZ"
                        {Ι++
                        βαλε "γκ"
                        Ν=1}
                  με "CB" ΕΩΣ "CZ"
                        {Ι++
                        βαλε "κ"
                        Ν=1}
                  με " "
                        Ν=Μ
                  αλλιώς
                  {
                        Ν=1 : Σ=0
                        ΑΣΦΑΛΕΙΑ++
                        αν ΑΣΦΑΛΕΙΑ>2 τότε Ν=Μ
                  }
                  τελος επιλογης
                  αν Ν<>Μ τότε ΚΥΚΛΙΚΑ
            }
            κυκλικα
      }
      'τωρα μαζεύουμε την λέξη
      Κ$=""
      Λ$=""
      αν εινγρ τότε { \\ η εινγρ λέει αληθλης αν είναι γράμματα (αλφαριθμητικό) στη κορυφή του σωρού
            ενω οχι ειναρ { \\ η ειναρ λέει αληθής αν είναι αριθμός στη κορυφή του σωρού
                  διάβασε Γ$ \\ διαβάζει από το σωρό
                  αν (Λ$ <> Γ$) Η ΜΗΚΟΣ(Γ$)=1 τότε {Κ$=Γ$+Κ$}
                  Λ$=Γ$
            }
            διάβασε ΣΚΟΠΟΣ
            πενα ΧΡΩΜΑ(100,200,100)
            φαρδια
            τυπωσε ΠΕΖ$(κεφ$(Κ$))
            φαρδια
      } αλλιώς {
            πενα 4
            τυπωσε "ΛΕΞΗ ?"
      }
      πενα 15
}
τμημα P { \\ p "λέξη"
      διαβασε α$
      ΠΡΟΦΟΡΑ α$
}
τμημα ΛΕΞΕΙΣ {
      για Ι=1 εως 4 {
            αλλαξε Α$(τυχαιος(0,14)), Α$(15)
            ΠΡΟΦΟΡΑ Α$(Ι)
      }
}
τμημα PA { ΠΡΟΤΑΣΗ γραμμα$ \\ pa "λέξη"
}
τμημα ΠΡΟΤΑΣΗ {
      διαβασε Π$
      Π$=αποκ$(Π$)+" "
      ενω Π$<>" " {
            Ι=θεση(Π$," ")
            Λ$=αρισ$(Π$,Ι-1)
            Π$=αποκ$(μεσ$(Π$,Ι))+" "
            αν Λ$<>"" τότε ΠΡΟΦΟΡΑ Λ$
      }
}
τμημα ΟΔΗΓΙΕΣ {
            περι ! "ΧΡΗΣΗ ΠΡΟΓΡΑΜΜΑΤΟΣ", 8000, 5000 , { p "giorgio"
                        Τυπώνει την προφορά της λέξης
                        pa "gli zii"
                        Τυπώνει την προφορά των λέξεων!
                        F1 - ΛΕΞΕΙΣ, F2 - ΚΑΘΑΡΗ οθονη, F3 - τελος
                        }
\\ βάζουμε εδώ τις σημειώσεις γιατί στα σενάρια δεν μπορούμε να τις βάλουμε
\\ θα το καλέσουμε σαν σενάριο εντολών.
\\ ένα σενάριο εντολών έχει εντολές που καταλαβαίνει η γραμμή εντολών
\\ δεν υπάρχει αλλαγή ροής προς προηγούμενη ή μεθεπόμενη γραμμή
\\ πάντα θα τρέχει η επόμενη
}
τμημα ΜΑΠΙΛ {
      οθονη 5,0
      πινακας Α$(16)
      Α$(0)="famiglia","chiamo", "casa", "gelato", "ghiaccio", "canzone", "ciao","pizza", "zio", "pesce", "rosso", "luce", "bagno", "pachetto","gonna", "anno"
      κλειδι 1,"ΛΕΞΕΙΣ"
      κλειδι 2,"ΟΘΟΝΗ"
      κλειδι 3,"τελος"
      ΟΔΗΓΙΕΣ
      πενα 13
      φαρδια
      τυπωσε "Μ.Α.Π.Ι.Λ εκδ 2.1"
      τυπωσε "ΜΗΧΑΝΗ ΑΠΟΔΟΣΗΣ ΠΡΟΦΟΡΑΣ ΙΤΑΛΙΚΩΝ ΛΕΞΕΩΝ"
      φαρδια
      τυπωσε
      οθονη ,γραμμη
      πενα 11
      τυπωσε "Παράδειγμα:"
      πενα 15
      τυπωσε "p "+Παραθεση$("giorgio")
      P "giorgio"
      τυπωσε "Ctrl+F1 για Βοήθεια"
      πενα 15
      αναψε
}
Σεναριο ΜΑΠΙΛ

Η εντολή Σεναριο τρέχει τις εντολές στο τμήμα σαν να τις γράφαμε μια προς μια. 
Ακολουθήστε τις οδηγίες
Με Ctrl+N βλέπουμε τα τμήματα/συναρτήσεις που είναι φορτωμένα.

Προσθήκη: Δεν έγραψα το "γιατί". Γιατί χρησιμοποίησα τη Σενάριο;
Ο λόγος είναι ότι ήθελα ο πίνακας που βρίσκεται μέσα στο τμήμα ΜΑΠΙΛ να μείνει μετά τη κλήση και να είναι γενικός, αφού σκοπό είχα να καλέσω το ΜΑΠΙΛ και να γυρίσω στην γραμμή εντολών. Αν δώσουμε την εντολη ΛΙΣΤΑ θα δούμε ότι υπάρχει ο πίνακας Α(). Αν ήθελα να φορτώσω το πίνακα από ένα αρχείο τότε θα καλούσα μια συνάρτηση που θα έκανε όλη τη δουλειά και θα γύρναγε το πίνακα
>_
>Σ π$(
γράφω
Πίνακας Α$(10)="οκ"
=Α$()
βγαίνω με esc και γράφω
>Πίνακας Β$()
>Β$()=π$()
>Τύπωσε Β$(1)
οκ