+++
title = 'Xbasic'
date = '2000-04-01T00:00:00Z'
description = ''
author = 'Κώστας Τσακάλογλου(mailto:tsakf@hellug.gr)'
issue = ['Magaz 23']
issue_weight = 2
+++
----------------------------------------------------------------------------------------------------------------------------------------------------------------

*Μία γλώσσα προγραμματισμού Basic που έχει αρκετά στοιχεία C.*

----------------------------------------------------------------------------------------------------------------------------------------------------------------

Κατά την τακτική επίσκεψη μου στους δικτυακούς χώρους πέρασα και από το site της [Sourceforge](http://Sourceforge.net). Στην προσπάθεια αναζήτησης εργαλείων
προγραμματισμού για το LINUX ζήτησα να δώ τι υπάρχει από Developement tools. Προσπαθώντας να δω τελικά με τι θα δουλέψω τώρα που έστησα και εγω επιτέλους το
Linuxάκι μου (SUSE 6.3) έπεσα επάνω σε ένα link που έγραφε Xbasic. Τι ωραία! Λές να υπάρχει κάτι ενδιαφέρον, αναρωτιέμαι.. Μια και γράφω σε Basic από την εποχή
του TRS-80 καλό θα ήταν να βρω κάτι που δεν θα μου αλλάξει και πολύ το στύλ μου. Ακολουθώντας τα διάφορα links πηγαίνω στην κατάλληλη σελίδα για να δω
τελοσπάντων τι πράγμα είναι αυτή η Xbasic. Επιλέγοντας να δω κάποια οθόνη από το πρόγραμμα βρέθηκα μπροστά στην παρακάτω εικόνα:

![](/23/img/xbasic.gif)

Αρκετά όμορφο περιβάλλον για να γράφει κανείς πρόγραμμα, για να δούμε όμως από ουσία τι λέει:

Ετσι αποφάσισα να κατεβάσω το πρόγραμμα και να το εγκαταστήσω στο μηχάνημά μου. Σύμφωνα με τις οδηγίες εγκατάστασης, έπρεπε να κατεβάσω το αρχείο
*xblinux.tar.gz* στο μηχάνημά μου και μετά να πληκτρολογήσω τις παρακάτω εντολές:

----------------------------------------------------------------------------------------------------------------------------------------------------------------

    cd /
     tar xfz xblinux.tar.gz

----------------------------------------------------------------------------------------------------------------------------------------------------------------

Αφού λοιπόν το κατέβασμα έγινε μια χαρά και το tar έκανε την δουλειά του, ξεκινάω τα X (KDE). Ανοίγω το Bash Terminal και γράφω:

     cd /usr/xb
     xb

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

----------------------------------------------------------------------------------------------------------------------------------------------------------------

    '
    '
    ' ######################
    ' #####  Entry ()  #####
    ' ######################
    '
    ' Programs contain:
    '   1. A PROLOG with type/function/constant declarations.
    '   2. This Entry() function where execution begins.
    '   3. Zero or more additional functions.
    '
    FUNCTION  Entry ()

    END FUNCTION

----------------------------------------------------------------------------------------------------------------------------------------------------------------

Αυτό δεν θυμίζει λίγο στο ξεκίνημα για την C;

----------------------------------------------------------------------------------------------------------------------------------------------------------------

    main()
    {

    }

----------------------------------------------------------------------------------------------------------------------------------------------------------------

Προσπαθώντας έτσι να ρίξω μια ματιά στην γλώσσα για να δω περίπου τι κάνει, πέφτω επάνω στους τύπους των μεταβλητών. Αρχίζω και βλέπω τύπους που δεν υπάρχουν
στην MS-BASIC ούτε καν στην VISUAL BASIC. Είδα διάφορα ωραία πράγματα και τα παραθέτω. Πρώτα από όλα να ξεκινήσω με τον κατάλογο των επιθεμάτων.

  ----------------------------------------------------- ----------------------------------------------------- -----------------------------------------------------
  \                                                     SBYTE                                                 8-bit signed integer
  `@`                                                                                                         

  `@@`                                                  UBYTE                                                 8 bit unsigned integer

  \%                                                    SSHORT                                                16 bit signed integer

  %%                                                    USHORT                                                16 bit unsigned integer

  &                                                     SLONG                                                 32 bit signed long integer

  &&                                                    ULONG                                                 32 bit unsigned long integer

  \~                                                    XLONG                                                 32/64 bit signed machine integer

  \$\$                                                  GIANT                                                 64 bit signed giant (financial) integer

  !                                                     SINGLE                                                IEEE single precision floating point

  \#                                                    DOUBLE                                                IEEE double precision floating point

  \$                                                    STRING                                                STRING of unsigned bytes

                                                                                                              
  ----------------------------------------------------- ----------------------------------------------------- -----------------------------------------------------

Από τον παραπάνω πίνακα, οι τύποι SBYTE ,UBYTE,USHORT,ULONG,XLONG και GIANT δεν υπάρχουν στην MS-BASIC και VISUAL BASIC. Οι Unsigned τύποι καθαρά είναι τύποι
που υποστηρίζει η C. Για τον τύπο XLONG νομίζω ότι είναι μια χαρά για εφαρμογές προγραμματισμού συστήματος (systems programming).

Οι μεταβλητες όμως στην XBASIC μπορούν να έχουν και προθέματα που δείχνουν την χρήση των μεταβλητών στις διάφορες ρουτίνες και προγράμματα. Τα προθέματα που
μπορούν να χρησιμοποιηθούν στην XBASIC είναι:

  ----------------------------------------------------- ----------------------------------------------------- -----------------------------------------------------
  \                                                     SHARED                                                Η μεταβλητή είναι διαθέσιμη σε όλες τις ρουτίνες
  \#                                                                                                          

  \#\#                                                  EXTERNAL                                              Η μεταβλητή είναι διαθέσιμη και σε άλλα προγράμματα

  \$                                                    LOCAL CONSTANT                                        Η μεταβλητή έχει σταθερή τιμή για την τρέχουσα
                                                                                                              ρουτίνα

  \$\$                                                  SHARED CONSTANT                                       Η μεταβλητή έχει σταθερή τιμή και είναι διαθέσιμη σε
                                                                                                              όλες τις ρουτίνες

                                                                                                              
  ----------------------------------------------------- ----------------------------------------------------- -----------------------------------------------------

Θέλει προσοχή όταν ορίζουμε και χρησιμοποιούμε μεταβλητές στην XBASIC. Όπως και στο Linuxάκι μας τα κεφαλαία / πεζά είναι σημαντικά για την ονοματολογία των
αρχείων, έτσι και στην XBasic τα κεφαλαία / πεζά δίνουν διαφορετικά ονόματα μεταβλητών άρα και διαφορετικές τιμές. Για αυτή την γλώσσα τα ονόματα COUNT, Count
και count είναι διαφορετικές μεταβλητές.

Σύμφωνα με προηγούμενα καταλαβαίνουμε ότι οι εντολές πρέπει να γράφονται αποκλειστικά με κεφαλαία γράμματα γιατί διαφορετικά η γλώσσα τις βλέπει σαν μεταβλητές.
Έτσι το:

    FOR I%=1 to 100   

είναι σωστό, ενώ το:

    For  I%=1 to 100  

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

Παρακάτω συνέχισα την ανάγνωση και έπεσα στους τελεστές συγκρίσεων. Εκεί πάλι είδα στοιχεία από την C να ξεφυτρώνουν όπως οι τελεστές:

    = ,<>,<  ,<=,>=,>

μπορούν να εκφραστούν και αντίστοιχα με

    ==,!=,!>=,!>,!<,!<=

Επίσης αν ρίξουμε μια ματιά στον παρακάτω πίνακα θα δούμε τελεστές διευθύνσεων μνήμης (pointers) που τόσο αρέσουν στους προγραμματιστές της C και διάφορα άλλα
καλούδια όπως μετακινίσεις bit κλπ.

  ------------------- ------------------- ------------------- ------------------- ------------------- ------------------- ------------------- -------------------
  \                   ALT                 ΚIND                CLASS               OPERANDS            RETURNS             PREC                COMMENTS
  OP                                                                                                                                          

  &                                       unary               10                  AnyType             Address             12                  Address of Object
                                                                                                                                              Data

  &&                                      unary               10                  AnyType             Address             12                  Address of Object
                                                                                                                                              Handle

  !                                       unary               9                   Numeric             T/F                 12                  Logical Not (TRUE
                                                                                                                                              if 0, else FALSE)

  !!                                      unary               9                   Numeric             T/F                 12                  Logical Test (FALSE
                                                                                                                                              if 0, else TRUE)

  NOT                 \~                  unary               9                   Integer             SameType            12                  Bitwise NOT

  \+                                      unary               8                   Numeric             SameType            12                  Plus

  \-                                      unary               8                   Numeric             SameType            12                  Minus

  \>\>\>                                  binary              7                   Integer             LeftType            11                  Arithmetic Up Shift

  \<\<\<                                  binary              7                   Integer             LeftType            11                  Arithmetic Down
                                                                                                                                              Shift

  \<\<                                    binary              7                   Integer             LeftType            11                  Bitwise Left Shift

  \>\>                                    binary              7                   Integer             LeftType            11                  Bitwise Right Shift

  \*\*                                    binary              4                   Numeric             HighType            10                  Power

  /                                       binary              4                   Numeric             HighType            9                   Divide

  \*                                      binary              4                   Numeric             HighType            9                   Multiply

  \\                                      binary              6                   Numeric             Integer             9                   Integer Divide

  MOD                                     binary              6                   Numeric             Integer             9                   Modul. (Int.Remain)

  \+                                      binary              5                   Numeric             HighType            8                   Add

  \+                                      binary              5                   String              String              8                   Concatenate

  \-                                      binary              4                   Numeric             HighType            8                   Subtract

  AND                 &                   binary              3                   Integer             HighType            7                   Bitwise AND

  XOR                 \^                  binary              3                   Integer             HighType            6                   Bitwise XOR

  OR                  \|                  binary              3                   Integer             HighType            6                   Bitwise OR

  \>                  !\<=                binary              2                   NumStr              T/F                 5                   Greater-Than

  \>=                 !\<                 binary              2                   NumStr              T/F                 5                   Greater-Or-Equal

  \<=                 !\>                 binary              2                   NumStr              T/F                 5                   Less-Or-Equal

  \<                  !\>=                binary              2                   NumStr              T/F                 5                   Less-Than

  \<\>                !=                  binary              2                   NumStr              T/F                 4                   Not-Equal

  =                   ==                  binary              2                   NumStr              T/F                 4                   Equal(also
                                                                                                                                              \"!\<\>\")

  &&                                      binary              1                   Integer             T/F                 3                   Logical AND

  \^\^                                    binary              1                   Integer             T/F                 2                   Logical XOR

  \|\|                                    binary              1                   Integer             T/F                 2                   Logical OR

  =                                       binary                                  NumStr              RightType           1                   Assignment

                                                                                                      T/F                                     T/F always returned
                                                                                                                                              as XLONG

                                                                                                                                              
  ------------------- ------------------- ------------------- ------------------- ------------------- ------------------- ------------------- -------------------

Κάτι Address και bitwise shift έχουν κάποιο ενδιαφέρον για κάποιους που θέλουν να χρησιμοποιήσουν αυτές τις εντολές αλλά η μέχρι τώρα γνωστές Basic δεν τους
έδιναν αυτή την δυνατότητα.

Από μια πρώτη ματιά νομίζω ότι κάποιος που ξέρει BASIC και έχει αποφασίσει να αρχίσει να γράφει προγράμματα για το LINUX καλό είναι να ρίξει μια ματιά σε αυτή
την γλώσσα που εκ πρώτης όψεως υπόσχεται πολλά. Εκτός από τις εντολές που δίνουν την δύναμη της C στον προγραμματιστή υπάρχει και παράθυρο εργαλείων για την
κατασκευή μιας φόρμας. Κουμπιά και όλα τα Widgets των X μάλλον υποστηρίζονται. Λέω μάλλον γιατί δεν έχω προλάβει να αρχίσω να κάνω κάτι με αυτή την γλώσσα. Απλά
όταν την είδα με μια πρώτη ματιά μου άρεσε τόσο που αποφάσισα να μοιραστώ τις εντυπώσεις που με άλλους προγραμματιστές γράφοντας αυτό το κείμενο και
παρουσιάζοντάς το στο Magaz. Τον άλλο μήνα που θα έχω κάνει κάτι θα γράψω και νεότερα. Εχω σκοπό να κρατάω σημειώσεις για κάθε τι που κάνω και να παρουσιάζω
κάθε τόσο από τη στήλη του Magaz κάθε τι καινούργιο όπως θα το μαθαίνω. Αυτά τα λίγα για τώρα και τα ξαναλέμε στο επόμενο Magaz.
