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 .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 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
chgmod +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, because I don't like it and don't
use it, so there. See Matt Welsh's ``Linux installation...'', pag.
109. (You had better get hold of another editor like joe
or
emacs
for X.) Suffice it here to say that:
vi
whithout saving, type <ESC> then :q!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 "First parameter is: "$1 echo -n "What's your name? " ; read your_name echo look the difference: "hi $your_name" # quoting with " echo look 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."
Under Unix, the system language is C, love it or hate it. Scores of other languages (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 brothers. 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 the math library:
$ gcc -o mathprog mathprog.c -lm
(The -l<libname>
switch forces gcc
to link the library
/usr/lib/lib<libname>.a
; so -lm
links
/usr/lib/libm.a
).
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 at appropriate positions! 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
There are lots of libraries available out there; among the first
you'll want to use are ncurses
, to handle textmode effects,
and svgalib
, to do graphics. If you feel brave enough to tackle
X programming, get XForms
(
bloch.phys.uwm.edu/pub/xforms
) and/or MGUI
(
www.volftp.vol.it/IT/IT/ITALIANI/MORELLO/index.htm
), two
terrific libraries that make X programming easy. Moreover, if you can't live
without an IDE a la Borland, get the package xwpe
from
sunsite.unc.edu:/pub/Linux/apps/editors/
. Chances are you'll
like it.