Next Previous Contents

## 10. A Bit of Programming

## 10.1 Shell Scripts: .BAT Files on Steroids

If you used .BAT files to create shortcuts of long command lines (I did a lot), this goal can be attained by inserting appropriate alias lines (see example above) in `profile` or `.bash_profile`. But if your .BATs were more complicated, then you'll love the scripting language made available by the shell: it's as powerful as good ol' QBasic, if not more. It has variables, structures like while, for, case, if... then... else, and lots of other features: it can be a good alternative to a ``real'' programming language.

To write a script---the equivalent of a .BAT file under DOS---all you have to do is write a standard ASCII file containing the instructions, save it, then make it executable with the command `chmod +x <scriptfile>`. To execute it, type its name.

A word of warning. The system editor is called `vi`, and in my experience most new users find it very difficult to use. I'm not going to explain how to use it; please consult Matt Welsh's book or search for a tutorial on the net. Suffice it here to say that:

- to insert some text, type `i` then your text;
- to delete characters, type <ESC> then `x`;
- to quit `vi` whithout saving, type <ESC> then `:q!`
- to save and quit, type <ESC> then `:wq`.

A good beginner editor is `joe`: invoking it by typing `jstar` you'll get the same key bindings as the DOS/Win editor. `jed` in WordStar or IDE mode is even better. Please consult Section Where to Find Applications to see where to get these editors.

Writing scripts under `bash` is such a vast subject it would require a book by itself, and I will not delve into the topic any further. I'll just give you an example of shell script, from which you can extract some basic rules:

    #!/bin/sh
    # sample.sh
    # I am a comment
    # don't change the first line, it must be there
    echo "This system is: `uname -a`" # use the output of the command
    echo "My name is $0" # built-in variables
    echo "You gave me the following $# parameters: "$*
    echo "The first parameter is: "$1
    echo -n "What's your name? " ; read your_name
    echo notice the difference: "hi $your_name" # quoting with "
    echo notice the difference: 'hi $your_name' # quoting with '
    DIRS=0 ; FILES=0
    for file in `ls .` ; do
      if [ -d ${file} ] ; then # if file is a directory
        DIRS=`expr $DIRS + 1`  # DIRS = DIRS + 1
      elif [ -f ${file} ] ; then
        FILES=`expr $FILES + 1`
      fi
      case ${file} in
        *.gif|*jpg) echo "${file}: graphic file" ;;
        *.txt|*.tex) echo "${file}: text file" ;;
        *.c|*.f|*.for) echo "${file}: source file" ;;
        *) echo "${file}: generic file" ;;
      esac
    done
    echo "there are ${DIRS} directories and ${FILES} files"
    ls | grep "ZxY--%%WKW"
    if [ $? != 0 ] ; then # exit code of last command
      echo "ZxY--%%WKW not found"
    fi
    echo "enough... type 'man bash' if you want more info."

## 10.2 C for Yourself

Under UNIX, the system language is C, love it or hate it. Scores of other languages (Java, FORTRAN, Pascal, Lisp, Basic, Perl, awk...) are also available.

Taken for granted that you know C, here are a couple of guidelines for those of you who have been spoilt by Turbo C++ or one of its DOS kin. Linux's C compiler is called `gcc` and lacks all the bells and whistles that usually accompany its DOS counterparts: no IDE, on-line help, integrated debugger, etc. It's just a rough command-line compiler, very powerful and efficient. To compile your standard `hello.c` you'll do:

> `

>     $ gcc hello.c

> `

which will create an executable file called `a.out`. To give the executable a different name, do

> `

>     $ gcc -o hola hello.c

> `

To link a library against a program, add the switch -l<libname>. For example, to link in the math library:

> `

>     $ gcc -o mathprog mathprog.c -lm

> `

(The `-l<libname>` switch forces `gcc` to link the library `/usr/lib/lib<libname>.so`; so `-lm` links `/usr/lib/libm.so`).

So far, so good. But when your prog is made of several source files, you'll need to use the utility `make`. Let's suppose you have written an expression parser: its source file is called `parser.c` and #includes two header files, `parser.h` and `xy.h`. Then you want to use the routines in `parser.c` in a program, say, `calc.c`, which in turn #includes `parser.h`. What a mess! What do you have to do to compile `calc.c`?

You'll have to write a so-called `Makefile`, which teaches the compiler the dependencies between sources and objects files. In our example:

    # This is Makefile, used to compile calc.c
    # Press the <TAB> key where indicated!

    calc: calc.o parser.o
    <TAB>gcc -o calc calc.o parser.o -lm
    # calc depends on two object files: calc.o and parser.o

    calc.o: calc.c parser.h
    <TAB>gcc -c calc.c
    # calc.o depends on two source files

    parser.o:  parser.c parser.h xy.h
    <TAB>gcc -c parser.c
    # parser.o depends on three source files

    # end of Makefile.

Save this file as `Makefile` and type `make` to compile your program; alternatively, save it as `calc.mak` and type `make -f calc.mak`, and of course RMP. You can invoke some help about the C functions, that are covered by man pages, section 3; for example,

> `

>     $ man 3 printf

> `

To debug your programs, use `gdb`. `info gdb` to learn how to use it.

There are lots of libraries available; among the first you may want to use are `ncurses` (textmode effects), and `svgalib` (console graphics). Many editors can act as an IDE; `emacs` and `jed`, for instance, also feature syntax highlighting, automatic indent, and so on. Alternatively, get the package `rhide` from ftp://metalab.unc.edu:/pub/Linux/devel/debuggers/. It's a Borland IDE clone, and chances are that you'll like it.

## 10.3 X11 Programming

If you feel brave enough to tackle X11 programming (it's not that difficult), there are several libraries that make writing X11 programs a breeze. The main sites to visit are those of GTK+, http://www.gtk.org, and Qt, http://www.troll.no. Gtk+ is a C-based widget set originally written for the graphic package The GIMP ( http://www.gimp.org), and is used by the Gnome environment. Kdeveloper is based on C++-based Qt, used by KDE. Most likely, you'll use one of these.

Some of the best tools for visual programming are Kdevelop for Qt, http://www.kdevelop.org, and Glade for GTK+, http://glade.pn.org. This page has more information: http://www.free-soft.org/guitool/.

### Multi-Platform Programming

Wouldn't it be nice if you could write code that compiled seamlessly under Linux and Windows using `gcc`? As of this writing, there are some widget sets that allow for more-or-less stable multi-platform programming. As far as stability and completeness are concerned though, I would say that the choice is narrowed down to only one: FLTK, the Fast Light Tool Kit http://www.fltk.org. It's amazingly small, quick, and stable. It also has a semi-visual builder called Fluid.

Next Previous Contents