File: node25.html

package info (click to toggle)
rutebook 1.0-1
links: PTS
area: non-free
in suites: sarge
size: 9,476 kB
ctags: 1,112
sloc: makefile: 47
file content (3069 lines) | stat: -rw-r--r-- 133,098 bytes
parent folder | download | duplicates (2)
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">

<!--Converted with LaTeX2HTML 99.2beta8 (1.46)
original version by:  Nikos Drakos, CBLU, University of Leeds
* revised and updated by:  Marcus Hennecke, Ross Moore, Herb Swan
* with significant contributions from:
  Jens Lippmann, Marek Rouchal, Martin Wilck and others -->
<HTML>
<HEAD>
<TITLE>22. Trivial Introduction to C</TITLE>
<META NAME="description" CONTENT="22. Trivial Introduction to C">
<META NAME="keywords" CONTENT="rute">
<META NAME="resource-type" CONTENT="document">
<META NAME="distribution" CONTENT="global">

<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso-8859-1">
<META NAME="Generator" CONTENT="LaTeX2HTML v99.2beta8">
<META HTTP-EQUIV="Content-Style-Type" CONTENT="text/css">

<LINK REL="STYLESHEET" HREF="rute.css">

<LINK REL="next" HREF="node26.html">
<LINK REL="previous" HREF="node24.html">
<LINK REL="up" HREF="rute.html">
<LINK REL="next" HREF="node26.html">
</HEAD>

<BODY BGCOLOR=#FFFFFF >
<TABLE width="100%" border="0" cellspacing="0" cellpadding="0">
<TR><TD align=left bgcolor="#000000">
<FONT COLOR=white>
&nbsp;<A HREF="http://www.icon.co.za/~psheer/rute-purchase.html"><FONT COLOR=white>Purchase</FONT></A>&nbsp;
</FONT>
</TD><TD align=center bgcolor="#000000">
<FONT COLOR=white>
Copyright&nbsp;&#169;&nbsp;2002&nbsp;Paul Sheer. <A HREF="copying.html"><FONT COLOR=white>Click here for copying permissions.</FONT></A>
</FONT>
</TD><TD align=right bgcolor="#000000">
<FONT COLOR=white>
&nbsp;<A HREF="http://www.icon.co.za/~psheer/rute-home.html"><FONT COLOR=white>Home</FONT></A>&nbsp;
</FONT>
</TD></TR>
<TR><TD colspan=2 align=left bgcolor="#ECEBF4">
<IMG SRC="va-btn-small-light-60.png">
</TD><TD align=right bgcolor="#ECEBF4">
<IMG SRC="sflogo2-steel-60.png">
</TD></TR>
</TABLE><BR>

<!--Navigation Panel-->
<A NAME="tex2html2197"
  HREF="node26.html">
<IMG WIDTH="37" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="next" SRC="next.png"></A> 
<A NAME="tex2html2193"
  HREF="rute.html">
<IMG WIDTH="26" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="up" SRC="up.png"></A> 
<A NAME="tex2html2187"
  HREF="node24.html">
<IMG WIDTH="63" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="previous" SRC="prev.png"></A> 
<A NAME="tex2html2195"
  HREF="node1.html">
<IMG WIDTH="65" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="contents" SRC="contents.png"></A>  
<BR>
<B> Next:</B> <A NAME="tex2html2198"
  HREF="node26.html">23. Shared Libraries</A>
<B> Up:</B> <A NAME="tex2html2194"
  HREF="rute.html">rute</A>
<B> Previous:</B> <A NAME="tex2html2188"
  HREF="node24.html">21. System Services and</A>
 &nbsp <B>  <A NAME="tex2html2196"
  HREF="node1.html">Contents</A></B> 
<BR>
<BR>
<!--End of Navigation Panel-->
<!--Table of Child-Links-->
<A NAME="CHILD_LINKS"><STRONG>Subsections</STRONG></A>

<UL>
<LI><A NAME="tex2html2199"
  HREF="#SECTION002510000000000000000">22.1 <B>C</B> Fundamentals</A>
<UL>
<LI><A NAME="tex2html2200"
  HREF="#SECTION002511000000000000000">22.1.1 The simplest <B>C</B> program</A>
<LI><A NAME="tex2html2201"
  HREF="#SECTION002512000000000000000">22.1.2 Variables and types</A>
<LI><A NAME="tex2html2202"
  HREF="#SECTION002513000000000000000">22.1.3 Functions</A>
<LI><A NAME="tex2html2203"
  HREF="#SECTION002514000000000000000">22.1.4 <TT>
<FONT COLOR="#0000ff">for</FONT></TT>, <TT>
<FONT COLOR="#0000ff">while</FONT></TT>, <TT>
<FONT COLOR="#0000ff">if</FONT></TT>, and <TT>
<FONT COLOR="#0000ff">switch</FONT></TT> statements</A>
<LI><A NAME="tex2html2204"
  HREF="#SECTION002515000000000000000">22.1.5 Strings, arrays, and memory allocation</A>
<LI><A NAME="tex2html2205"
  HREF="#SECTION002516000000000000000">22.1.6 String operations</A>
<LI><A NAME="tex2html2206"
  HREF="#SECTION002517000000000000000">22.1.7 File operations</A>
<LI><A NAME="tex2html2207"
  HREF="#SECTION002518000000000000000">22.1.8 Reading command-line arguments inside <B>C</B> programs</A>
<LI><A NAME="tex2html2208"
  HREF="#SECTION002519000000000000000">22.1.9 A more complicated example</A>
<LI><A NAME="tex2html2209"
  HREF="#SECTION0025110000000000000000">22.1.10 <TT>
<FONT COLOR="#0000ff">#include</FONT></TT> statements and prototypes</A>
<LI><A NAME="tex2html2210"
  HREF="#SECTION0025111000000000000000">22.1.11 <B>C</B> comments</A>
<LI><A NAME="tex2html2211"
  HREF="#SECTION0025112000000000000000">22.1.12 <TT>
<FONT COLOR="#0000ff">#define</FONT></TT> and <TT>
<FONT COLOR="#0000ff">#if</FONT></TT> -- <B>C</B> macros</A>
</UL>
<LI><A NAME="tex2html2212"
  HREF="#SECTION002520000000000000000">22.2 Debugging with <TT>
<FONT COLOR="#0000ff">gdb</FONT></TT> and <TT>
<FONT COLOR="#0000ff">strace</FONT></TT></A>
<UL>
<LI><A NAME="tex2html2213"
  HREF="#SECTION002521000000000000000">22.2.1 <TT>
<FONT COLOR="#0000ff">gdb</FONT></TT></A>
<LI><A NAME="tex2html2214"
  HREF="#SECTION002522000000000000000">22.2.2 Examining <TT>
<FONT COLOR="#0000ff">core</FONT></TT> files</A>
<LI><A NAME="tex2html2215"
  HREF="#SECTION002523000000000000000">22.2.3 <TT>
<FONT COLOR="#0000ff">strace</FONT></TT></A>
</UL>
<LI><A NAME="tex2html2216"
  HREF="#SECTION002530000000000000000">22.3 <B>C</B> Libraries</A>
<LI><A NAME="tex2html2217"
  HREF="#SECTION002540000000000000000">22.4 <B>C</B> Projects -- <TT>
<FONT COLOR="#0000ff">Makefile</FONT></TT>s</A>
<UL>
<LI><A NAME="tex2html2218"
  HREF="#SECTION002541000000000000000">22.4.1 Completing our example <TT>
<FONT COLOR="#0000ff">Makefile</FONT></TT></A>
<LI><A NAME="tex2html2219"
  HREF="#SECTION002542000000000000000">22.4.2 Putting it all together</A>
</UL></UL>
<!--End of Table of Child-Links-->
<HR>

<H1><A NAME="SECTION002500000000000000000">
22. Trivial Introduction to <B>C</B></A>
</H1>

<P>
<A NAME="chap:trivintroc"></A>
<P>
&nbsp;<B>C</B> was invented for the purpose
of writing an operating system that
could be recompiled (ported)
to different hardware platforms (different CPUs). 
Because the operating system is written in <B>C</B>, this
language is
the first choice for writing any kind of application that has to
communicate efficiently with the operating system.

<P>
Many people who don't program very well in <B>C</B> think of <B>C</B> as
an arbitrary language out of many. This point should be made at
once: <B>C</B> is the fundamental basis of all computing in the world
today. U<SMALL>NIX</SMALL>, Microsoft Windows, office suites, web browsers
and device drivers are all written in <B>C</B>. Ninety-nine percent of your time spent
at a computer is probably spent using an application written
in <B>C</B>. About 70% of all ``open source'' software is written in <B>C</B>,
and the remaining 30% written in languages whose
compilers or interpreters
are written in <B>C</B>. <FONT COLOR="#ffa500">[C++ is also quite popular. It is, however, not
as fundamental to computing, although it is more suitable in
many situations.]</FONT>
<P>
Further, there is no replacement for <B>C</B>. Since it fulfills its purpose
almost flawlessly, there will never be a need to replace it.
<I>Other languages may fulfill other purposes, but <B>C</B> fulfills
its purpose most adequately.</I> For instance, all future operating
systems will probably be written in <B>C</B> for a long time to come.

<P>
It is for these reasons that your knowledge of U<SMALL>NIX</SMALL> will never be
complete until you can program in <B>C</B>. On the other hand, just because
you can program in <B>C</B> does not mean that you <I>should</I>. Good <B>C</B>
programming is a fine art which many veteran <B>C</B> programmers
never manage to master, even after many years. <I>It is essential
to join a Free software project to properly master an effective style
of <B>C</B> development.</I>

<P>

<H1><A NAME="SECTION002510000000000000000">
22.1 <B>C</B> Fundamentals</A>
</H1>

<P>
We start with a simple <B>C</B> program
and then add fundamental elements to it.
Before going too far, you may wish to review <TT>
<FONT COLOR="#0000ff">bash</FONT></TT>
functions in Section <A HREF="node10.html#sec:functions">7.7</A>.

<P>

<H2><A NAME="SECTION002511000000000000000">
22.1.1 The simplest <B>C</B> program</A>
</H2>

<P>
A simple <B>C</B> program is:

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>5</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>#include&nbsp;&#060;stdlib.h&#062;</code><br>
<code>#include&nbsp;&#060;stdio.h&#062;</code><br>
<code>&nbsp;</code><br>
<code>int&nbsp;main&nbsp;(int&nbsp;argc,&nbsp;char&nbsp;*argv[])</code><br>
<code>{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;printf&nbsp;("Hello&nbsp;World!\n")&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;return&nbsp;3&#059;</code><br>
<code>}</code><br>
</FONT></TD></TR></TABLE><P>

<P>
Save this program in a file <TT>
<FONT COLOR="#0000ff">hello.c</FONT></TT>. We will now
compile the program. <FONT COLOR="#ffa500">[<I>Compiling</I> is the process of turning <B>C</B>
code into <I>assembler instructions</I>. Assembler instructions are
the program code that your 80<I>?</I>86/SPARC/RS6000 CPU
understands directly. The resulting binary executable is fast because
it is executed natively by
your processor--it is the very chip that
you see on your motherboard that does fetch <TT>
<FONT COLOR="#0000ff">Hello</FONT></TT> byte for byte
from memory and executes each instruction. This is what is meant by
<I>million instructions per second</I> (MIPS). The
<I>megahertz</I> of the machine quoted by hardware vendors is
<I>very</I> roughly the number of MIPS. Interpreted languages (like
shell scripts) are much slower because the code itself is written in
something not understandable to the CPU. The <TT>
<FONT COLOR="#0000ff">/bin/bash</FONT></TT>
program has to <I>interpret</I> the shell program. <TT>
<FONT COLOR="#0000ff">/bin/bash</FONT></TT>
itself is written in <B>C</B>, but the overhead of interpretation makes
scripting languages many orders of magnitude slower than compiled
languages. Shell scripts do not need to be compiled.]</FONT>Run the command

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>gcc&nbsp;-Wall&nbsp;-o&nbsp;hello&nbsp;hello.c</code><br>
</FONT></TD></TR></TABLE><P>
The <TT>
<FONT COLOR="#0000ff">-o hello</FONT></TT> option tells
<TT>
<FONT COLOR="#0000ff">gcc</FONT></TT> <FONT COLOR="#ffa500">[GNU <B>C</B> Compiler.
<TT>
<FONT COLOR="#0000ff">cc</FONT></TT> on other U<SMALL>NIX</SMALL>
systems.]</FONT> to produce the binary file <TT>
<FONT COLOR="#0000ff">hello</FONT></TT> instead of the
default binary file named
<TT>
<FONT COLOR="#0000ff">a.out</FONT></TT>. <FONT COLOR="#ffa500">[Called <TT>
<FONT COLOR="#0000ff">a.out</FONT></TT> for historical reasons.]</FONT>The <TT>
<FONT COLOR="#0000ff">-Wall</FONT></TT> option means to report <TT>
<FONT COLOR="#0000ff">all</FONT></TT>
<TT>
<FONT COLOR="#0000ff">W</FONT></TT>arnings during the compilation. This is not
strictly necessary but is most helpful
for correcting possible errors in your programs. More compiler options
are discussed on page <A HREF="node27.html#page:compileroptions"><IMG  ALIGN="BOTTOM" BORDER="1" ALT="[*]" SRC="crossref.png"></A>.

<P>
Then, run the program with

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>./hello</code><br>
</FONT></TD></TR></TABLE><P>

<P>
Previously you should have familiarized yourself with
<TT>
<FONT COLOR="#0000ff">bash</FONT></TT> functions. In
<B>C</B> <I>all</I> code is inside a function.
The first function to be called (by the operating system) is the
<TT>
<FONT COLOR="#0000ff">main</FONT></TT> function.

<P>
Type <TT>
<FONT COLOR="#0000ff">echo $?</FONT></TT> to see the return
code of the program. You will
see it is <TT>
<FONT COLOR="#0000ff">3</FONT></TT>, the return value of the <TT>
<FONT COLOR="#0000ff">main</FONT></TT>
function.

<P>
Other things to note are the <TT>
<FONT COLOR="#0000ff">"</FONT></TT> on either side of the string
to be printed. Quotes are required around string literals. Inside
a string literal, the <TT>
<FONT COLOR="#0000ff">&#92;n</FONT></TT> <I>escape sequence</I>
indicates a newline character. <TT>
<FONT COLOR="#0000ff">ascii</FONT></TT>(7) shows some
other escape sequences. You can also see a proliferation of
<TT>
<FONT COLOR="#0000ff">;</FONT></TT> everywhere in a <B>C</B> program. Every statement in <B>C</B> is
terminated by a <TT>
<FONT COLOR="#0000ff">;</FONT></TT> unlike statements in shell scripts where
a <TT>
<FONT COLOR="#0000ff">;</FONT></TT> is optional.

<P>
Now try:

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>5</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>#include&nbsp;&#060;stdlib.h&#062;</code><br>
<code>#include&nbsp;&#060;stdio.h&#062;</code><br>
<code>&nbsp;</code><br>
<code>int&nbsp;main&nbsp;(int&nbsp;argc,&nbsp;char&nbsp;*argv[])</code><br>
<code>{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;printf&nbsp;("number&nbsp;%d,&nbsp;number&nbsp;%d\n",&nbsp;1&nbsp;+&nbsp;2,&nbsp;10)&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;exit&nbsp;(3)&#059;</code><br>
<code>}</code><br>
</FONT></TD></TR></TABLE><P>
<TT>
<FONT COLOR="#0000ff">printf</FONT></TT> can be thought of as the command to send output
to the terminal. It is also what is known as a <I>standard <B>C</B>
library function</I>. In other words, it is specified that a <B>C</B>
implementation should always have the <TT>
<FONT COLOR="#0000ff">printf</FONT></TT> function
and that it should behave in a certain way.

<P>
The <TT>
<FONT COLOR="#0000ff">%d</FONT></TT> specifies that a <TT>
<FONT COLOR="#0000ff">d</FONT></TT><I>ecimal</I> should
go in at that point in the text. The number to be substituted
will be the first <I>argument</I> to the <TT>
<FONT COLOR="#0000ff">printf</FONT></TT> function
after the string literal--that is, the <TT>
<FONT COLOR="#0000ff">1 + 2</FONT></TT>. The
next <TT>
<FONT COLOR="#0000ff">%d</FONT></TT> is substituted with the second argument--that is,
the <TT>
<FONT COLOR="#0000ff">10</FONT></TT>. The <TT>
<FONT COLOR="#0000ff">%d</FONT></TT> is known as a <I>format
specifier</I>. It essentially <I>converts</I> an integer number into
a decimal representation. See <TT>
<FONT COLOR="#0000ff">printf</FONT></TT>(3) for more details.

<P>

<H2><A NAME="SECTION002512000000000000000">
22.1.2 Variables and types</A>
</H2>

<P>
With <TT>
<FONT COLOR="#0000ff">bash</FONT></TT>, you could use a variable anywhere, anytime, and the
variable would just be blank if it had never been assigned a value. In <B>C</B>,
however, you have to explicitly tell the compiler what variables you are
going to need before each block of code. You do this with a variable declaration:

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>5</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>10</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>#include&nbsp;&#060;stdlib.h&#062;</code><br>
<code>#include&nbsp;&#060;stdio.h&#062;</code><br>
<code>&nbsp;</code><br>
<code>int&nbsp;main&nbsp;(int&nbsp;argc,&nbsp;char&nbsp;*argv[])</code><br>
<code>{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;int&nbsp;x&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;int&nbsp;y&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;x&nbsp;=&nbsp;10&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;y&nbsp;=&nbsp;2:</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;printf&nbsp;("number&nbsp;%d,&nbsp;number&nbsp;%d\n",&nbsp;1&nbsp;+&nbsp;y,&nbsp;x)&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;exit&nbsp;(3)&#059;</code><br>
<code>}</code><br>
</FONT></TD></TR></TABLE><P>
The <TT>
<FONT COLOR="#0000ff">int x</FONT></TT> is a variable declaration. It tells the
program to reserve space for one <TT>
<FONT COLOR="#0000ff">int</FONT></TT><I>eger</I>
variable
that it will later refer to as <TT>
<FONT COLOR="#0000ff">x</FONT></TT>. <TT>
<FONT COLOR="#0000ff">int</FONT></TT> is the
<I>type</I> of the variable. <TT>
<FONT COLOR="#0000ff">x = 10</FONT></TT> assigned a value of 10
to the variable. There are types for each kind of number
you would like to work with, and format specifiers to convert them
for printing:

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>5</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>10</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>15</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>20</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>#include&nbsp;&#060;stdlib.h&#062;</code><br>
<code>#include&nbsp;&#060;stdio.h&#062;</code><br>
<code>&nbsp;</code><br>
<code>int&nbsp;main&nbsp;(int&nbsp;argc,&nbsp;char&nbsp;*argv[])</code><br>
<code>{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;char&nbsp;a&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;short&nbsp;b&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;int&nbsp;c&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;long&nbsp;d&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;float&nbsp;e&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;double&nbsp;f&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;long&nbsp;double&nbsp;g&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;a&nbsp;=&nbsp;'A'&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;b&nbsp;=&nbsp;10&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;c&nbsp;=&nbsp;10000000&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;d&nbsp;=&nbsp;10000000&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;e&nbsp;=&nbsp;3.14159&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;f&nbsp;=&nbsp;10e300&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;g&nbsp;=&nbsp;10e300&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;printf&nbsp;("%c,&nbsp;%hd,&nbsp;%d,&nbsp;%ld,&nbsp;%f,&nbsp;%f,&nbsp;%Lf\n",&nbsp;a,&nbsp;b,&nbsp;c,&nbsp;d,&nbsp;e,&nbsp;f,&nbsp;g)&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;exit&nbsp;(3)&#059;</code><br>
<code>}</code><br>
</FONT></TD></TR></TABLE><P>

<P>
You will notice that <TT>
<FONT COLOR="#0000ff">%f</FONT></TT> is used for both
<TT>
<FONT COLOR="#0000ff">float</FONT></TT><I>s</I> <I>and</I>
<TT>
<FONT COLOR="#0000ff">double</FONT></TT><I>s</I>. The reason is that a <TT>
<FONT COLOR="#0000ff">float</FONT></TT> is always converted
to a <TT>
<FONT COLOR="#0000ff">double</FONT></TT> before an operation like this. Also try replacing
<TT>
<FONT COLOR="#0000ff">%f</FONT></TT> with <TT>
<FONT COLOR="#0000ff">%e</FONT></TT> to print in
exponential notation--that is,
less significant digits.

<P>

<H2><A NAME="SECTION002513000000000000000">
22.1.3 Functions</A>
</H2>

<P>
Functions are implemented as follows:

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>5</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>10</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>#include&nbsp;&#060;stdlib.h&#062;</code><br>
<code>#include&nbsp;&#060;stdio.h&#062;</code><br>
<code>&nbsp;</code><br>
<code>void&nbsp;mutiply_and_print&nbsp;(int&nbsp;x,&nbsp;int&nbsp;y)</code><br>
<code>{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;printf&nbsp;("%d&nbsp;*&nbsp;%d&nbsp;=&nbsp;%d\n",&nbsp;x,&nbsp;y,&nbsp;x&nbsp;*&nbsp;y)&#059;</code><br>
<code>}</code><br>
<code>&nbsp;</code><br>
<code>int&nbsp;main&nbsp;(int&nbsp;argc,&nbsp;char&nbsp;*argv[])</code><br>
<code>{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;mutiply_and_print&nbsp;(30,&nbsp;5)&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;mutiply_and_print&nbsp;(12,&nbsp;3)&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;exit&nbsp;(3)&#059;</code><br>
<code>}</code><br>
</FONT></TD></TR></TABLE><P>

<P>
Here we have a non-main function <I>called</I> by the
<TT>
<FONT COLOR="#0000ff">main</FONT></TT> function. The function is first <I>declared</I>
with

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>void&nbsp;mutiply_and_print&nbsp;(int&nbsp;x,&nbsp;int&nbsp;y)</code><br>
</FONT></TD></TR></TABLE><P>

<P>
This declaration states the return value of the function
(<TT>
<FONT COLOR="#0000ff">void</FONT></TT> for no return value), the function name
(<TT>
<FONT COLOR="#0000ff">mutiply_and_print</FONT></TT>), and then the
<I>arguments</I> that
are going to be passed to the function. The numbers passed to
the function are given their own names, <TT>
<FONT COLOR="#0000ff">x</FONT></TT> and <TT>
<FONT COLOR="#0000ff">y</FONT></TT>,
and are converted to the type of <TT>
<FONT COLOR="#0000ff">x</FONT></TT> and <TT>
<FONT COLOR="#0000ff">y</FONT></TT> before
being passed to the function--in this case, <TT>
<FONT COLOR="#0000ff">int</FONT></TT> and
<TT>
<FONT COLOR="#0000ff">int</FONT></TT>. The actual <B>C</B> code that comprises the function
goes between curly braces <TT>
<FONT COLOR="#0000ff">&#123;</FONT></TT> and
<TT>
<FONT COLOR="#0000ff">&#125;</FONT></TT>.

<P>
In other words, the above function is equivalent to:

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>5</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>void&nbsp;mutiply_and_print&nbsp;()</code><br>
<code>{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;int&nbsp;x&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;int&nbsp;y&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;x&nbsp;=&nbsp;&#060;first-number-passed&#062;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;y&nbsp;=&nbsp;&#060;second-number-passed&#062;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;printf&nbsp;("%d&nbsp;*&nbsp;%d&nbsp;=&nbsp;%d\n",&nbsp;x,&nbsp;y,&nbsp;x&nbsp;*&nbsp;y)&#059;</code><br>
<code>}</code><br>
</FONT></TD></TR></TABLE><P>

<P>

<H2><A NAME="SECTION002514000000000000000">
22.1.4 <TT>
<FONT COLOR="#0000ff">for</FONT></TT>, <TT>
<FONT COLOR="#0000ff">while</FONT></TT>, <TT>
<FONT COLOR="#0000ff">if</FONT></TT>, and <TT>
<FONT COLOR="#0000ff">switch</FONT></TT> statements</A>
</H2>

<P>
As with shell scripting, we have
the <TT>
<FONT COLOR="#0000ff">for</FONT></TT>, <TT>
<FONT COLOR="#0000ff">while</FONT></TT>, and
<TT>
<FONT COLOR="#0000ff">if</FONT></TT> statements:

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>5</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>10</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>15</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>20</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>25</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>30</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>35</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>40</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>45</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>#include&nbsp;&#060;stdlib.h&#062;</code><br>
<code>#include&nbsp;&#060;stdio.h&#062;</code><br>
<code>&nbsp;</code><br>
<code>int&nbsp;main&nbsp;(int&nbsp;argc,&nbsp;char&nbsp;*argv[])</code><br>
<code>{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;int&nbsp;x&#059;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;x&nbsp;=&nbsp;10&#059;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;if&nbsp;(x&nbsp;==&nbsp;10)&nbsp;{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;printf&nbsp;("x&nbsp;is&nbsp;exactly&nbsp;10\n")&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;x++&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;}&nbsp;else&nbsp;if&nbsp;(x&nbsp;==&nbsp;20)&nbsp;{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;printf&nbsp;("x&nbsp;is&nbsp;equal&nbsp;to&nbsp;20\n")&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;}&nbsp;else&nbsp;{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;printf&nbsp;("No,&nbsp;x&nbsp;is&nbsp;not&nbsp;equal&nbsp;to&nbsp;10&nbsp;or&nbsp;20\n")&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;}</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;if&nbsp;(x&nbsp;&#062;&nbsp;10)&nbsp;{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;printf&nbsp;("Yes,&nbsp;x&nbsp;is&nbsp;more&nbsp;than&nbsp;10\n")&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;}</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;while&nbsp;(x&nbsp;&#062;&nbsp;0)&nbsp;{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;printf&nbsp;("x&nbsp;is&nbsp;%d\n",&nbsp;x)&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;x&nbsp;=&nbsp;x&nbsp;-&nbsp;1&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;}</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;for&nbsp;(x&nbsp;=&nbsp;0&#059;&nbsp;x&nbsp;&#060;&nbsp;10&#059;&nbsp;x++)&nbsp;{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;printf&nbsp;("x&nbsp;is&nbsp;%d\n",&nbsp;x)&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;}</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;switch&nbsp;(x)&nbsp;{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;case&nbsp;9:</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;printf&nbsp;("x&nbsp;is&nbsp;nine\n")&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;break&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;case&nbsp;10:</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;printf&nbsp;("x&nbsp;is&nbsp;ten\n")&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;break&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;case&nbsp;11:</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;printf&nbsp;("x&nbsp;is&nbsp;eleven\n")&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;break&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;default:</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;printf&nbsp;("x&nbsp;is&nbsp;huh?\n")&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;break&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;}</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;return&nbsp;0&#059;</code><br>
<code>}</code><br>
</FONT></TD></TR></TABLE><P>
It is easy to see the format that these statements take, although they
are vastly different from shell scripts. <B>C</B> code works in
<I>statement blocks</I> between
curly braces, in the same way that shell scripts have
<TT>
<FONT COLOR="#0000ff">do</FONT></TT>'s and <TT>
<FONT COLOR="#0000ff">done</FONT></TT>'s.

<P>
Note that with most programming languages when we want to
add <TT>
<FONT COLOR="#0000ff">1</FONT></TT> to a variable we have to write, say, <TT>
<FONT COLOR="#0000ff">x = x + 1</FONT></TT>.
In <B>C</B>, the abbreviation <TT>
<FONT COLOR="#0000ff">x++</FONT></TT> is used, meaning to
<I>increment</I> a variable by <TT>
<FONT COLOR="#0000ff">1</FONT></TT>.

<P>
The <TT>
<FONT COLOR="#0000ff">for</FONT></TT> loop takes three statements between <TT>
<FONT COLOR="#0000ff">(</FONT></TT>
... <TT>
<FONT COLOR="#0000ff">)</FONT></TT>: a statement to start things off, a comparison, and
a statement to be executed on each completion of the statement block.
The statement block after the <TT>
<FONT COLOR="#0000ff">for</FONT></TT> is repeatedly executed until
the comparison is untrue.

<P>
The <TT>
<FONT COLOR="#0000ff">switch</FONT></TT> statement is like
<TT>
<FONT COLOR="#0000ff">case</FONT></TT> in shell scripts.
<TT>
<FONT COLOR="#0000ff">switch</FONT></TT> considers the argument inside its <TT>
<FONT COLOR="#0000ff">(</FONT></TT> ...
<TT>
<FONT COLOR="#0000ff">)</FONT></TT> and decides which <TT>
<FONT COLOR="#0000ff">case</FONT></TT> line to jump to. In this
example it will obviously be <TT>
<FONT COLOR="#0000ff">printf ("x is ten&#92;n");</FONT></TT> because
<TT>
<FONT COLOR="#0000ff">x</FONT></TT> was 10 when the previous <TT>
<FONT COLOR="#0000ff">for</FONT></TT> loop exited.
The <TT>
<FONT COLOR="#0000ff">break</FONT></TT> tokens mean that we are through with the <TT>
<FONT COLOR="#0000ff">switch</FONT></TT>
statement and that execution should continue from Line 46.

<P>
Note that in <B>C</B> the comparison <TT>
<FONT COLOR="#0000ff">==</FONT></TT> is used instead of <TT>
<FONT COLOR="#0000ff">=</FONT></TT>.
The symbol <TT>
<FONT COLOR="#0000ff">=</FONT></TT> means to assign a value to a variable, whereas <TT>
<FONT COLOR="#0000ff">==</FONT></TT>
is an <I>equality operator</I>.

<P>

<H2><A NAME="SECTION002515000000000000000">
22.1.5 Strings, arrays, and memory allocation</A>
</H2>

<P>
You can define a list of numbers with:

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>int&nbsp;y[10]&#059;</code><br>
</FONT></TD></TR></TABLE><P>
This list is called an <I>array</I>:

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>5</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>10</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>15</code></font><code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>#include&nbsp;&#060;stdlib.h&#062;</code><br>
<code>#include&nbsp;&#060;stdio.h&#062;</code><br>
<code>&nbsp;</code><br>
<code>int&nbsp;main&nbsp;(int&nbsp;argc,&nbsp;char&nbsp;*argv[])</code><br>
<code>{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;int&nbsp;x&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;int&nbsp;y[10]&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;for&nbsp;(x&nbsp;=&nbsp;0&#059;&nbsp;x&nbsp;&#060;&nbsp;10&#059;&nbsp;x++)&nbsp;{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;y[x]&nbsp;=&nbsp;x&nbsp;*&nbsp;2&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;}</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;for&nbsp;(x&nbsp;=&nbsp;0&#059;&nbsp;x&nbsp;&#060;&nbsp;10&#059;&nbsp;x++)&nbsp;{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;printf&nbsp;("item&nbsp;%d&nbsp;is&nbsp;%d\n",&nbsp;x,&nbsp;y[x])&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;}</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;return&nbsp;0&#059;</code><br>
<code>}</code><br>
</FONT></TD></TR></TABLE><P>

<P>
If an array is of type <TT>
<FONT COLOR="#0000ff">char</FONT></TT><I>acter</I>,
then it is called a <I>string</I>:

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>5</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>10</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>15</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>#include&nbsp;&#060;stdlib.h&#062;</code><br>
<code>#include&nbsp;&#060;stdio.h&#062;</code><br>
<code>&nbsp;</code><br>
<code>int&nbsp;main&nbsp;(int&nbsp;argc,&nbsp;char&nbsp;*argv[])</code><br>
<code>{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;int&nbsp;x&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;char&nbsp;y[11]&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;for&nbsp;(x&nbsp;=&nbsp;0&#059;&nbsp;x&nbsp;&#060;&nbsp;10&#059;&nbsp;x++)&nbsp;{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;y[x]&nbsp;=&nbsp;65&nbsp;+&nbsp;x&nbsp;*&nbsp;2&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;}</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;for&nbsp;(x&nbsp;=&nbsp;0&#059;&nbsp;x&nbsp;&#060;&nbsp;10&#059;&nbsp;x++)&nbsp;{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;printf&nbsp;("item&nbsp;%d&nbsp;is&nbsp;%d\n",&nbsp;x,&nbsp;y[x])&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;}</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;y[10]&nbsp;=&nbsp;0&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;printf&nbsp;("string&nbsp;is&nbsp;%s\n",&nbsp;y)&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;return&nbsp;0&#059;</code><br>
<code>}</code><br>
</FONT></TD></TR></TABLE><P>
Note that a string has to be <I>null-terminated</I>. This means
that the last character must be a zero. The code <TT>
<FONT COLOR="#0000ff">y[10] = 0</FONT></TT>
sets the 11th item in the array to zero. This also means that
strings need to be one <TT>
<FONT COLOR="#0000ff">char</FONT></TT> longer than you would think.

<P>
(Note that the first item in the array is <TT>
<FONT COLOR="#0000ff">y[0]</FONT></TT>, not <TT>
<FONT COLOR="#0000ff">y[1]</FONT></TT>,
as with some other programming languages.)

<P>
In the preceding example, the line <TT>
<FONT COLOR="#0000ff">char y[11]</FONT></TT> reserved 11
bytes for the string. But what if you want a string of 100,000
bytes? <B>C</B> allows you to request memory
from the kernel.
This is called <I>allocate memory</I>. Any non-trivial
program will allocate memory for itself and there is no other
way of getting large blocks of memory for your program
to use. Try:

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>5</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>10</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>15</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>#include&nbsp;&#060;stdlib.h&#062;</code><br>
<code>#include&nbsp;&#060;stdio.h&#062;</code><br>
<code>&nbsp;</code><br>
<code>int&nbsp;main&nbsp;(int&nbsp;argc,&nbsp;char&nbsp;*argv[])</code><br>
<code>{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;int&nbsp;x&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;char&nbsp;*y&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;y&nbsp;=&nbsp;malloc&nbsp;(11)&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;printf&nbsp;("%ld\n",&nbsp;y)&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;for&nbsp;(x&nbsp;=&nbsp;0&#059;&nbsp;x&nbsp;&#060;&nbsp;10&#059;&nbsp;x++)&nbsp;{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;y[x]&nbsp;=&nbsp;65&nbsp;+&nbsp;x&nbsp;*&nbsp;2&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;}</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;y[10]&nbsp;=&nbsp;0&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;printf&nbsp;("string&nbsp;is&nbsp;%s\n",&nbsp;y)&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;free&nbsp;(y)&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;return&nbsp;0&#059;</code><br>
<code>}</code><br>
</FONT></TD></TR></TABLE><P>

<P>
The declaration <TT>
<FONT COLOR="#0000ff">char *y</FONT></TT> means to
declare a variable (a number) called <TT>
<FONT COLOR="#0000ff">y</FONT></TT> that <I>points</I>
to a memory location. The <TT>
<FONT COLOR="#0000ff">*</FONT></TT>
(<I>asterisk</I>) in this context
means <I>pointer</I>. For example, if you have a machine with perhaps 256
megabytes of RAM + swap, then <TT>
<FONT COLOR="#0000ff">y</FONT></TT> potentially has a range of
this much. The numerical value of <TT>
<FONT COLOR="#0000ff">y</FONT></TT> is also printed
with <TT>
<FONT COLOR="#0000ff">printf ("%ld&#92;n", y);</FONT></TT>, but is of no
interest to the programmer.

<P>
When you have finished using memory you must give it back to the operating
system by using <TT>
<FONT COLOR="#0000ff">free</FONT></TT>. Programs that don't <TT>
<FONT COLOR="#0000ff">free</FONT></TT>
all the memory they allocate are said to
<I>leak</I> memory.

<P>
Allocating memory often requires you to perform a calculation to
determine the amount of memory required. In the above case we
are allocating the space of 11 <TT>
<FONT COLOR="#0000ff">char</FONT></TT>s. Since each
<TT>
<FONT COLOR="#0000ff">char</FONT></TT> is really a single byte, this presents no problem. But
what if we were allocating 11 <TT>
<FONT COLOR="#0000ff">int</FONT></TT>s? An <TT>
<FONT COLOR="#0000ff">int</FONT></TT> on a
PC is 32 bits--four bytes. To determine the size of a type,
we use the <TT>
<FONT COLOR="#0000ff">sizeof</FONT></TT> keyword:

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>5</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>10</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>15</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>20</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>#include&nbsp;&#060;stdlib.h&#062;</code><br>
<code>#include&nbsp;&#060;stdio.h&#062;</code><br>
<code>&nbsp;</code><br>
<code>int&nbsp;main&nbsp;(int&nbsp;argc,&nbsp;char&nbsp;*argv[])</code><br>
<code>{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;int&nbsp;a&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;int&nbsp;b&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;int&nbsp;c&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;int&nbsp;d&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;int&nbsp;e&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;int&nbsp;f&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;int&nbsp;g&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;a&nbsp;=&nbsp;sizeof&nbsp;(char)&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;b&nbsp;=&nbsp;sizeof&nbsp;(short)&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;c&nbsp;=&nbsp;sizeof&nbsp;(int)&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;d&nbsp;=&nbsp;sizeof&nbsp;(long)&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;e&nbsp;=&nbsp;sizeof&nbsp;(float)&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;f&nbsp;=&nbsp;sizeof&nbsp;(double)&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;g&nbsp;=&nbsp;sizeof&nbsp;(long&nbsp;double)&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;printf&nbsp;("%d,&nbsp;%d,&nbsp;%d,&nbsp;%d,&nbsp;%d,&nbsp;%d,&nbsp;%d\n",&nbsp;a,&nbsp;b,&nbsp;c,&nbsp;d,&nbsp;e,&nbsp;f,&nbsp;g)&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;return&nbsp;0&#059;</code><br>
<code>}</code><br>
</FONT></TD></TR></TABLE><P>
Here you can see the number of bytes required by all of these
types.
Now we can easily allocate arrays of things other than <TT>
<FONT COLOR="#0000ff">char</FONT></TT>.

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>5</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>10</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>15</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>#include&nbsp;&#060;stdlib.h&#062;</code><br>
<code>#include&nbsp;&#060;stdio.h&#062;</code><br>
<code>&nbsp;</code><br>
<code>int&nbsp;main&nbsp;(int&nbsp;argc,&nbsp;char&nbsp;*argv[])</code><br>
<code>{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;int&nbsp;x&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;int&nbsp;*y&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;y&nbsp;=&nbsp;malloc&nbsp;(10&nbsp;*&nbsp;sizeof&nbsp;(int))&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;printf&nbsp;("%ld\n",&nbsp;y)&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;for&nbsp;(x&nbsp;=&nbsp;0&#059;&nbsp;x&nbsp;&#060;&nbsp;10&#059;&nbsp;x++)&nbsp;{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;y[x]&nbsp;=&nbsp;65&nbsp;+&nbsp;x&nbsp;*&nbsp;2&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;}</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;for&nbsp;(x&nbsp;=&nbsp;0&#059;&nbsp;x&nbsp;&#060;&nbsp;10&#059;&nbsp;x++)&nbsp;{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;printf&nbsp;("%d\n",&nbsp;y[x])&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;}</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;free&nbsp;(y)&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;return&nbsp;0&#059;</code><br>
<code>}</code><br>
</FONT></TD></TR></TABLE><P>
On many machines an <TT>
<FONT COLOR="#0000ff">int</FONT></TT> is four bytes (32 bits), but you
should never assume this. <I>Always use the <TT>
<FONT COLOR="#0000ff">sizeof</FONT></TT>
keyword to allocate memory.</I>

<P>

<H2><A NAME="SECTION002516000000000000000">
22.1.6 String operations</A>
</H2>

<P>
&nbsp;<B>C</B> programs probably do more string manipulation than
anything else. Here is a program that divides a sentence
into words:

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>5</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>10</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>15</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>20</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>25</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>30</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>35</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>#include&nbsp;&#060;stdlib.h&#062;</code><br>
<code>#include&nbsp;&#060;stdio.h&#062;</code><br>
<code>#include&nbsp;&#060;string.h&#062;</code><br>
<code>&nbsp;</code><br>
<code>int&nbsp;main&nbsp;(int&nbsp;argc,&nbsp;char&nbsp;*argv[])</code><br>
<code>{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;int&nbsp;length_of_word&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;int&nbsp;i&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;int&nbsp;length_of_sentence&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;char&nbsp;p[256]&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;char&nbsp;*q&#059;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;strcpy&nbsp;(p,&nbsp;"hello&nbsp;there,&nbsp;my&nbsp;name&nbsp;is&nbsp;fred.")&#059;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;length_of_sentence&nbsp;=&nbsp;strlen&nbsp;(p)&#059;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;length_of_word&nbsp;=&nbsp;0&#059;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;for&nbsp;(i&nbsp;=&nbsp;0&#059;&nbsp;i&nbsp;&#060;=&nbsp;length_of_sentence&#059;&nbsp;i++)&nbsp;{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;if&nbsp;(p[i]&nbsp;==&nbsp;'&nbsp;'&nbsp;||&nbsp;i&nbsp;==&nbsp;length_of_sentence)&nbsp;{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;q&nbsp;=&nbsp;malloc&nbsp;(length_of_word&nbsp;+&nbsp;1)&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;if&nbsp;(q&nbsp;==&nbsp;0)&nbsp;{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;perror&nbsp;("malloc&nbsp;failed")&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;abort&nbsp;()&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;strncpy&nbsp;(q,&nbsp;p&nbsp;+&nbsp;i&nbsp;-&nbsp;length_of_word,&nbsp;length_of_word)&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;q[length_of_word]&nbsp;=&nbsp;0&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;printf&nbsp;("word:&nbsp;%s\n",&nbsp;q)&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;free&nbsp;(q)&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;length_of_word&nbsp;=&nbsp;0&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}&nbsp;else&nbsp;{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;length_of_word&nbsp;=&nbsp;length_of_word&nbsp;+&nbsp;1&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;}</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;return&nbsp;0&#059;</code><br>
<code>}</code><br>
</FONT></TD></TR></TABLE><P>
Here we introduce three more
<I>standard <B>C</B> library functions</I>.
<TT>
<FONT COLOR="#0000ff">strcpy</FONT></TT> stands for
<TT>
<FONT COLOR="#0000ff">str</FONT></TT><I>ing</I><TT>
<FONT COLOR="#0000ff">c</FONT></TT><I>o</I><TT>
<FONT COLOR="#0000ff">py</FONT></TT>. It copies
bytes from one place to another sequentially, until it reaches a zero
byte (i.e., the end of string). Line 13 of this program
copies text <I>into</I> the <TT>
<FONT COLOR="#0000ff">char</FONT></TT>acter array <TT>
<FONT COLOR="#0000ff">p</FONT></TT>, which
is called the <I>target</I> of the copy.

<P>
<TT>
<FONT COLOR="#0000ff">strlen</FONT></TT> stands for <TT>
<FONT COLOR="#0000ff">str</FONT></TT><I>ing</I><TT>
<FONT COLOR="#0000ff">len</FONT></TT><I>gth</I>.
It determines the length of a string, which is just a count of
the number of <TT>
<FONT COLOR="#0000ff">char</FONT></TT>acters up to the null character.

<P>
We need to loop over the length of the sentence. The variable
<TT>
<FONT COLOR="#0000ff">i</FONT></TT> indicates the current position in the sentence.

<P>
Line 20 says that if
we find a character 32 (denoted by <TT>
<FONT COLOR="#0000ff">' '</FONT></TT>), we know we have
reached a word boundary. We also know that the end of the
sentence is a word boundary even though there may not be a
space there. The token <TT>
<FONT COLOR="#0000ff">&#124;&#124;</FONT></TT>
means <B>OR</B>. At
this point we can allocate memory for the
current word and copy the word into that memory. The
<TT>
<FONT COLOR="#0000ff">strncpy</FONT></TT> function is useful for this. It copies
a string, but only up to a limit of <TT>
<FONT COLOR="#0000ff">length_of_word</FONT></TT>
characters (the last argument). Like <TT>
<FONT COLOR="#0000ff">strcpy</FONT></TT>, the first
argument is the target, and the second argument is the
place to copy from.

<P>
To calculate the position of the start of the last word, we use
<TT>
<FONT COLOR="#0000ff">p + i - length_of_word</FONT></TT>. This means that we are adding
<TT>
<FONT COLOR="#0000ff">i</FONT></TT> to the memory location <TT>
<FONT COLOR="#0000ff">p</FONT></TT> and then going back
<TT>
<FONT COLOR="#0000ff">length_of_word</FONT></TT> counts thereby pointing
<TT>
<FONT COLOR="#0000ff">strncpy</FONT></TT> to the exact position.

<P>
Finally, we null-terminate the string on Line 27. We can then print
<TT>
<FONT COLOR="#0000ff">q</FONT></TT>, <TT>
<FONT COLOR="#0000ff">free</FONT></TT> the used memory,
and begin with the next word.

<P>
For a complete list of string operations, see <TT>
<FONT COLOR="#0000ff">string</FONT></TT>(3).

<P>

<H2><A NAME="SECTION002517000000000000000">
22.1.7 File operations</A>
</H2>

<P>
Under most programming languages, file operations involve
three steps: <I>opening</I> a file, <I>reading</I> or
<I>writing</I> to the file, and then <I>closing</I> the
file. You use the command <TT>
<FONT COLOR="#0000ff">fopen</FONT></TT> to tell the operating
system that you are ready to begin working with a file:

<P>
The following program opens a file and spits it
out on the terminal:

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>5</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>10</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>15</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>20</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>#include&nbsp;&#060;stdlib.h&#062;</code><br>
<code>#include&nbsp;&#060;stdio.h&#062;</code><br>
<code>#include&nbsp;&#060;string.h&#062;</code><br>
<code>&nbsp;</code><br>
<code>int&nbsp;main&nbsp;(int&nbsp;argc,&nbsp;char&nbsp;*argv[])</code><br>
<code>{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;int&nbsp;c&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;FILE&nbsp;*f&#059;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;f&nbsp;=&nbsp;fopen&nbsp;("mytest.c",&nbsp;"r")&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;if&nbsp;(f&nbsp;==&nbsp;0)&nbsp;{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;perror&nbsp;("fopen")&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;return&nbsp;1&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;}</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;for&nbsp;(&#059;&#059;)&nbsp;{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;c&nbsp;=&nbsp;fgetc&nbsp;(f)&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;if&nbsp;(c&nbsp;==&nbsp;-1)</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;break&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;printf&nbsp;("%c",&nbsp;c)&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;}</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;fclose&nbsp;(f)&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;return&nbsp;0&#059;</code><br>
<code>}</code><br>
</FONT></TD></TR></TABLE><P>

<P>
A new type is presented here: <TT>
<FONT COLOR="#0000ff">FILE *</FONT></TT>. It is a file 
operations variable that must be <I>initialized</I> with
<TT>
<FONT COLOR="#0000ff">fopen</FONT></TT> before it can be used. The <TT>
<FONT COLOR="#0000ff">fopen</FONT></TT>
function takes two arguments: the first is the name of the file, and
the second is a string explaining <I>how</I> we want to open the
file--in this case <TT>
<FONT COLOR="#0000ff">"r"</FONT></TT> means <TT>
<FONT COLOR="#0000ff">r</FONT></TT><I>eading</I>
from the start of the file. Other options are <TT>
<FONT COLOR="#0000ff">"w"</FONT></TT> for
<TT>
<FONT COLOR="#0000ff">w</FONT></TT><I>riting</I> and several more described in <TT>
<FONT COLOR="#0000ff">fopen</FONT></TT>(3).

<P>
If the return value of <TT>
<FONT COLOR="#0000ff">fopen</FONT></TT> is zero, it means that
<TT>
<FONT COLOR="#0000ff">fopen</FONT></TT> has failed. The <TT>
<FONT COLOR="#0000ff">perror</FONT></TT> function then prints a
textual error message (for example, <TT>
<FONT COLOR="#0000ff">No such file or directory</FONT></TT>).
It is essential to check the return value of all
library calls in this way. These checks will
constitute about one third of your <B>C</B> program.

<P>
The command <TT>
<FONT COLOR="#0000ff">fgetc</FONT></TT> <I>gets</I> a character from the file.
It retrieves consecutive bytes from the file until it reaches the
end of the file, when it returns a <TT>
<FONT COLOR="#0000ff">-1</FONT></TT>. The <TT>
<FONT COLOR="#0000ff">break</FONT></TT>
statement says to immediately terminate the <TT>
<FONT COLOR="#0000ff">for</FONT></TT> loop,
whereupon execution will continue from line 21. <TT>
<FONT COLOR="#0000ff">break</FONT></TT>
statements can appear inside <TT>
<FONT COLOR="#0000ff">while</FONT></TT> loops as well.

<P>
You will notice that the <TT>
<FONT COLOR="#0000ff">for</FONT></TT> statement is empty. This is
allowable <B>C</B> code and means to loop forever.

<P>
Some other file functions are <TT>
<FONT COLOR="#0000ff">fread</FONT></TT>, <TT>
<FONT COLOR="#0000ff">fwrite</FONT></TT>,
<TT>
<FONT COLOR="#0000ff">fputc</FONT></TT>, <TT>
<FONT COLOR="#0000ff">fprintf</FONT></TT>, and <TT>
<FONT COLOR="#0000ff">fseek</FONT></TT>. See <TT>
<FONT COLOR="#0000ff">fwrite</FONT></TT>(3),
<TT>
<FONT COLOR="#0000ff">fputc</FONT></TT>(3), <TT>
<FONT COLOR="#0000ff">fprintf</FONT></TT>(3), and <TT>
<FONT COLOR="#0000ff">fseek</FONT></TT>(3).

<P>

<H2><A NAME="SECTION002518000000000000000">
22.1.8 Reading command-line arguments inside <B>C</B> programs</A>
</H2>

<P>
Up until now, you are probably wondering what the
<TT>
<FONT COLOR="#0000ff">(int argc, char *argv[])</FONT></TT> are for. These are
the command-line arguments passed to the program by
the shell. <TT>
<FONT COLOR="#0000ff">argc</FONT></TT> is the total number of command-line
arguments, and <TT>
<FONT COLOR="#0000ff">argv</FONT></TT> is an array of strings of
each argument. Printing them out is easy:

<P>

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>5</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>10</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>#include&nbsp;&#060;stdlib.h&#062;</code><br>
<code>#include&nbsp;&#060;stdio.h&#062;</code><br>
<code>#include&nbsp;&#060;string.h&#062;</code><br>
<code>&nbsp;</code><br>
<code>int&nbsp;main&nbsp;(int&nbsp;argc,&nbsp;char&nbsp;*argv[])</code><br>
<code>{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;int&nbsp;i&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;for&nbsp;(i&nbsp;=&nbsp;0&#059;&nbsp;i&nbsp;&#060;&nbsp;argc&#059;&nbsp;i++)&nbsp;{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;printf&nbsp;("argument&nbsp;%d&nbsp;is&nbsp;%s\n",&nbsp;i,&nbsp;argv[i])&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;}</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;return&nbsp;0&#059;</code><br>
<code>}</code><br>
</FONT></TD></TR></TABLE><P>

<P>

<H2><A NAME="SECTION002519000000000000000">
22.1.9 A more complicated example</A>
</H2>

<P>
Here we put this altogether in a program that reads in lots of files and
dumps them as words. Here are some new notations you will encounter:
<TT>
<FONT COLOR="#0000ff">!=</FONT></TT> is the inverse of <TT>
<FONT COLOR="#0000ff">==</FONT></TT> and tests if
<I>not-equal-to</I>; <TT>
<FONT COLOR="#0000ff">realloc</FONT></TT> <I>reallocates</I>
memory--it resizes an old block of memory so that any
bytes of the old block are preserved; <TT>
<FONT COLOR="#0000ff">&#92;n</FONT></TT>,
<TT>
<FONT COLOR="#0000ff">&#92;t</FONT></TT> mean the newline character, 10, or the
tab character, 9, respectively (see <TT>
<FONT COLOR="#0000ff">ascii</FONT></TT>(7)).

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red size="-1">
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-2"><code>5</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-2"><code>10</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-2"><code>15</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-2"><code>20</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-2"><code>25</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-2"><code>30</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-2"><code>35</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-2"><code>40</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-2"><code>45</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-2"><code>50</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-2"><code>55</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-2"><code>60</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-2"><code>65</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-2"><code>70</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-2"><code>75</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue size="-1">
<code>#include&nbsp;&#060;stdlib.h&#062;</code><br>
<code>#include&nbsp;&#060;stdio.h&#062;</code><br>
<code>#include&nbsp;&#060;string.h&#062;</code><br>
<code>&nbsp;</code><br>
<code>void&nbsp;word_dump&nbsp;(char&nbsp;*filename)</code><br>
<code>{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;int&nbsp;length_of_word&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;int&nbsp;amount_allocated&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;char&nbsp;*q&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;FILE&nbsp;*f&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;int&nbsp;c&#059;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;c&nbsp;=&nbsp;0&#059;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;f&nbsp;=&nbsp;fopen&nbsp;(filename,&nbsp;"r")&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;if&nbsp;(f&nbsp;==&nbsp;0)&nbsp;{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;perror&nbsp;("fopen&nbsp;failed")&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;exit&nbsp;(1)&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;}</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;length_of_word&nbsp;=&nbsp;0&#059;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;amount_allocated&nbsp;=&nbsp;256&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;q&nbsp;=&nbsp;malloc&nbsp;(amount_allocated)&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;if&nbsp;(q&nbsp;==&nbsp;0)&nbsp;{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;perror&nbsp;("malloc&nbsp;failed")&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;abort&nbsp;()&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;}</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;while&nbsp;(c&nbsp;!=&nbsp;-1)&nbsp;{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;if&nbsp;(length_of_word&nbsp;&#062;=&nbsp;amount_allocated)&nbsp;{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;amount_allocated&nbsp;=&nbsp;amount_allocated&nbsp;*&nbsp;2&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;q&nbsp;=&nbsp;realloc&nbsp;(q,&nbsp;amount_allocated)&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;if&nbsp;(q&nbsp;==&nbsp;0)&nbsp;{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;perror&nbsp;("realloc&nbsp;failed")&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;abort&nbsp;()&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;c&nbsp;=&nbsp;fgetc&nbsp;(f)&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;q[length_of_word]&nbsp;=&nbsp;c&#059;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;if&nbsp;(c&nbsp;==&nbsp;-1&nbsp;||&nbsp;c&nbsp;==&nbsp;'&nbsp;'&nbsp;||&nbsp;c&nbsp;==&nbsp;'\n'&nbsp;||&nbsp;c&nbsp;==&nbsp;'\t')&nbsp;{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;if&nbsp;(length_of_word&nbsp;&#062;&nbsp;0)&nbsp;{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;q[length_of_word]&nbsp;=&nbsp;0&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;printf&nbsp;("%s\n",&nbsp;q)&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;amount_allocated&nbsp;=&nbsp;256&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;q&nbsp;=&nbsp;realloc&nbsp;(q,&nbsp;amount_allocated)&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;if&nbsp;(q&nbsp;==&nbsp;0)&nbsp;{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;perror&nbsp;("realloc&nbsp;failed")&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;abort&nbsp;()&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;length_of_word&nbsp;=&nbsp;0&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}&nbsp;else&nbsp;{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;length_of_word&nbsp;=&nbsp;length_of_word&nbsp;+&nbsp;1&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;}</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;fclose&nbsp;(f)&#059;</code><br>
<code>}</code><br>
<code>&nbsp;</code><br>
<code>int&nbsp;main&nbsp;(int&nbsp;argc,&nbsp;char&nbsp;*argv[])</code><br>
<code>{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;int&nbsp;i&#059;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;if&nbsp;(argc&nbsp;&#060;&nbsp;2)&nbsp;{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;printf&nbsp;("Usage:\n\twordsplit&nbsp;&#060;filename&#062;&nbsp;...\n")&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;exit&nbsp;(1)&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;}</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;for&nbsp;(i&nbsp;=&nbsp;1&#059;&nbsp;i&nbsp;&#060;&nbsp;argc&#059;&nbsp;i++)&nbsp;{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;word_dump&nbsp;(argv[i])&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;}</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;return&nbsp;0&#059;</code><br>
<code>}</code><br>
</FONT></TD></TR></TABLE><P>

<P>
This program is more complicated than you might immediately
expect. Reading in a file where we are <I>sure</I> that a word will
never exceed 30 characters is simple. But what if we have a file
that contains some words that are 100,000 characters long? GNU
programs are expected to behave correctly under these
circumstances.

<P>
To cope with normal as well as extreme circumstances, we
start off assuming that a word will never be more than 256
characters. If it appears that the word is growing over 256
characters, we <TT>
<FONT COLOR="#0000ff">realloc</FONT></TT><I>ate</I> the memory space to
double its size (lines 32 amd 33). When we start with a new word, we can free up
memory again, so we <TT>
<FONT COLOR="#0000ff">realloc</FONT></TT> back to 256 again (lines 48 and 49). In this
way we are using the minimum amount of memory at each point in time.

<P>
We have hence created a program that can work efficiently with a
100-gigabyte file just as easily as with a 100-byte file. <I>This
is part of the art of <B>C</B> programming.</I>

<P>
Experienced <B>C</B> programmers may actually scoff at the above
listing because it really isn't as ``minimalistic'' as is absolutely
possible. In fact, it is a truly excellent listing for the following
reasons:

<UL>
<LI>The program is easy to understand.
</LI>
<LI>The program uses an efficient algorithm (albeit not optimal).
</LI>
<LI>The program contains no arbitrary limits that would cause
	unexpected behavior in extreme circumstances.
</LI>
<LI>The program uses no nonstandard <B>C</B> functions or notations
	that would prohibit it compiling successfully on other systems.
	It is therefore <I>portable</I>.
</LI>
</UL>
<I>Readability in <B>C</B> is your first
priority--it is imperative
that what you do is <I>obvious</I> to anyone reading the code.</I>

<P>

<H2><A NAME="SECTION0025110000000000000000">
22.1.10 <TT>
<FONT COLOR="#0000ff">#include</FONT></TT> statements and prototypes</A>
</H2>

<P>
At the start of each program will be one or more <TT>
<FONT COLOR="#0000ff">#include</FONT></TT>
statements. These tell the compiler to read in another <B>C</B> program.
Now, ``raw'' <B>C</B> does not have a whole lot in the way of protecting
against errors: for example, the <TT>
<FONT COLOR="#0000ff">strcpy</FONT></TT> function could
just as well be used with one, three, or four arguments, and the
<B>C</B> program would still compile. It would, however, wreak havoc
with the internal memory and cause the program to crash. These
other <TT>
<FONT COLOR="#0000ff">.h</FONT></TT> <B>C</B> programs are called <I>header</I> files.
They contain templates for how functions are meant to be called.
Every function you might like to use is contained in one or another
template file. The templates are called <I>function
prototypes</I>. <FONT COLOR="#ffa500">[C++ has something called ``templates.'' This is
a special C++ term having nothing to do with the discussion here.]</FONT>
<P>
A function prototype is written the same as the function itself,
but without the code. A function
prototype for <TT>
<FONT COLOR="#0000ff">word_dump</FONT></TT>
would simply be:

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>void&nbsp;word_dump&nbsp;(char&nbsp;*filename)&#059;</code><br>
</FONT></TD></TR></TABLE><P>
The trailing <TT>
<FONT COLOR="#0000ff">;</FONT></TT> is essential and distinguishes a function
prototype from a function.

<P>
After a function prototype is defined, any attempt to use the function in a
way other than intended--say, passing it to few arguments or
arguments of the wrong type--will be met with fierce
opposition from <TT>
<FONT COLOR="#0000ff">gcc</FONT></TT>.

<P>
You will notice that the <TT>
<FONT COLOR="#0000ff">#include &lt;string.h&gt;</FONT></TT> appeared
when we started using <TT>
<FONT COLOR="#0000ff">str</FONT></TT>ing operations. Recompiling
these programs without the <TT>
<FONT COLOR="#0000ff">#include &lt;string.h&gt;</FONT></TT> line
gives the warning message

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>mytest.c:21:&nbsp;warning:&nbsp;implicit&nbsp;declaration&nbsp;of&nbsp;function&nbsp;`strncpy'</code><br>
</FONT></TD></TR></TABLE><P>
which is quite to the point.

<P>
The function prototypes
give a clear definition of how every
function is to be used. Man pages will always first state
the function prototype so that you are clear on what arguments
are to be passed and what types they should have.

<P>

<H2><A NAME="SECTION0025111000000000000000">
22.1.11 <B>C</B> comments</A>
</H2>

<P>
A <B>C</B> comment is denoted with
<TT>
<FONT COLOR="#0000ff">/* &lt;comment lines&gt; */</FONT></TT> and can
span multiple lines.
Anything between the <TT>
<FONT COLOR="#0000ff">/*</FONT></TT> and <TT>
<FONT COLOR="#0000ff">*/</FONT></TT> is ignored. Every function
should be commented, and all nonobvious code should be
commented. It is a good maxim that a program that <I>needs</I>
lots of comments to explain it is <I>badly written</I>. Also, never
comment the obvious, and explain <I>why</I> you do things rather
that <I>what</I> you are doing. It is advisable <I>not</I> to
make pretty graphics between each function, so rather:

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>/*&nbsp;returns&nbsp;-1&nbsp;on&nbsp;error,&nbsp;takes&nbsp;a&nbsp;positive&nbsp;integer&nbsp;*/</code><br>
<code>int&nbsp;sqr&nbsp;(int&nbsp;x)</code><br>
<code>{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&#060;...&#062;</code><br>
</FONT></TD></TR></TABLE><P>
than

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>5</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>/***************************----SQR----******************************</code><br>
<code>&nbsp;*&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;x&nbsp;=&nbsp;argument&nbsp;to&nbsp;make&nbsp;the&nbsp;square&nbsp;of&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;*</code><br>
<code>&nbsp;*&nbsp;&nbsp;&nbsp;&nbsp;return&nbsp;value&nbsp;&nbsp;=&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;*</code><br>
<code>&nbsp;*&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;-1&nbsp;(on&nbsp;error)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;*</code><br>
<code>&nbsp;*&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;square&nbsp;of&nbsp;x&nbsp;(on&nbsp;success)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;*</code><br>
<code>&nbsp;********************************************************************/</code><br>
<code>int&nbsp;sqr&nbsp;(int&nbsp;x)</code><br>
<code>{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&#060;...&#062;</code><br>
</FONT></TD></TR></TABLE><P>
which is liable to cause nausea. In C++, the additional comment
<TT>
<FONT COLOR="#0000ff">//</FONT></TT> is allowed, whereby everything between the
<TT>
<FONT COLOR="#0000ff">//</FONT></TT> and the end of the line is ignored. It is accepted under <TT>
<FONT COLOR="#0000ff">gcc</FONT></TT>,
but should not be used unless you really are programming in C++. In addition,
programmers often ``comment out'' lines by placing a <TT>
<FONT COLOR="#0000ff">#if 0</FONT></TT> ...
<TT>
<FONT COLOR="#0000ff">#endif</FONT></TT> around them, which really does exactly the same
thing as a comment (see Section <A HREF="node25.html#sec:cdefine">22.1.12</A>) but allows
you to have comments within comments. For example

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>5</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>&nbsp;&nbsp;&nbsp;&nbsp;int&nbsp;x&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;x&nbsp;=&nbsp;10&#059;</code><br>
<code>#if&nbsp;0</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;printf&nbsp;("debug:&nbsp;x&nbsp;is&nbsp;%d\n",&nbsp;x)&#059;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;/*&nbsp;print&nbsp;debug&nbsp;information&nbsp;*/</code><br>
<code>#endif</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;y&nbsp;=&nbsp;x&nbsp;+&nbsp;10&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&#060;...&#062;</code><br>
</FONT></TD></TR></TABLE><P>
comments out Line 4.

<P>

<H2><A NAME="SECTION0025112000000000000000">
22.1.12 <TT>
<FONT COLOR="#0000ff">#define</FONT></TT> and <TT>
<FONT COLOR="#0000ff">#if</FONT></TT> -- <B>C</B> macros</A>
</H2>

<P>
<A NAME="sec:cdefine"></A>
<P>
Anything starting with a <TT>
<FONT COLOR="#0000ff">#</FONT></TT> is not actually <B>C</B>, but a
<B>C</B> <I>preprocessor directive</I>. A <B>C</B> program is first
run through a <I>preprocessor</I> that removes all spurious
junk, like comments, <TT>
<FONT COLOR="#0000ff">#include</FONT></TT> statements, and anything
else beginning with a <TT>
<FONT COLOR="#0000ff">#</FONT></TT>. You can make <B>C</B> programs
much more readable by defining <I>macros</I> instead
of literal values. For instance,

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>#define&nbsp;START_BUFFER_SIZE&nbsp;256</code><br>
</FONT></TD></TR></TABLE><P>
in our example program, <TT>
<FONT COLOR="#0000ff">#define</FONT></TT><I>s</I> the text
<TT>
<FONT COLOR="#0000ff">START_BUFFER_SIZE</FONT></TT> to be the text <TT>
<FONT COLOR="#0000ff">256</FONT></TT>.
Thereafter, wherever in the <B>C</B> program we have a
<TT>
<FONT COLOR="#0000ff">START_BUFFER_SIZE</FONT></TT>, the text <TT>
<FONT COLOR="#0000ff">256</FONT></TT> will be seen by
the compiler, and we can use <TT>
<FONT COLOR="#0000ff">START_BUFFER_SIZE</FONT></TT>
instead. This is a much <I>cleaner</I> way of programming
because, if, say, we would like to change the <TT>
<FONT COLOR="#0000ff">256</FONT></TT> to some
other value, we only need to change it in one place.
<TT>
<FONT COLOR="#0000ff">START_BUFFER_SIZE</FONT></TT> is also more meaningful than a
number, making the program more readable.

<P>
Whenever you have a <I>literal constant</I> like <TT>
<FONT COLOR="#0000ff">256</FONT></TT>,
you should replace it with a macro defined near the top of
your program.

<P>
You can also check for the existence of macros with the
<TT>
<FONT COLOR="#0000ff">#ifdef</FONT></TT> and
<TT>
<FONT COLOR="#0000ff">#ifndef</FONT></TT> directive. <TT>
<FONT COLOR="#0000ff">#</FONT></TT> directives are
really a programming language all on their own:

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>5</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>10</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>15</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>20</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>25</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>/*&nbsp;Set&nbsp;START_BUFFER_SIZE&nbsp;to&nbsp;fine-tune&nbsp;performance&nbsp;before&nbsp;compiling:&nbsp;*/</code><br>
<code>#define&nbsp;START_BUFFER_SIZE&nbsp;256</code><br>
<code>/*&nbsp;#define&nbsp;START_BUFFER_SIZE&nbsp;128&nbsp;*/</code><br>
<code>/*&nbsp;#define&nbsp;START_BUFFER_SIZE&nbsp;1024&nbsp;*/</code><br>
<code>/*&nbsp;#define&nbsp;START_BUFFER_SIZE&nbsp;16384&nbsp;*/</code><br>
<code>&nbsp;</code><br>
<code>#ifndef&nbsp;START_BUFFER_SIZE</code><br>
<code>#error&nbsp;This&nbsp;code&nbsp;did&nbsp;not&nbsp;define&nbsp;START_BUFFER_SIZE.&nbsp;Please&nbsp;edit</code><br>
<code>#endif</code><br>
<code>&nbsp;</code><br>
<code>#if&nbsp;START_BUFFER_SIZE&nbsp;&#060;=&nbsp;0</code><br>
<code>#error&nbsp;Wooow!&nbsp;START_BUFFER_SIZE&nbsp;must&nbsp;be&nbsp;greater&nbsp;than&nbsp;zero</code><br>
<code>#endif</code><br>
<code>&nbsp;</code><br>
<code>#if&nbsp;START_BUFFER_SIZE&nbsp;&#060;&nbsp;16</code><br>
<code>#warning&nbsp;START_BUFFER_SIZE&nbsp;to&nbsp;small,&nbsp;program&nbsp;may&nbsp;be&nbsp;inefficient</code><br>
<code>#elif&nbsp;START_BUFFER_SIZE&nbsp;&#062;&nbsp;65536</code><br>
<code>#warning&nbsp;START_BUFFER_SIZE&nbsp;to&nbsp;large,&nbsp;program&nbsp;may&nbsp;be&nbsp;inefficient</code><br>
<code>#else</code><br>
<code>/*&nbsp;START_BUFFER_SIZE&nbsp;is&nbsp;ok,&nbsp;do&nbsp;not&nbsp;report&nbsp;*/</code><br>
<code>#endif</code><br>
<code>&nbsp;</code><br>
<code>void&nbsp;word_dump&nbsp;(char&nbsp;*filename)</code><br>
<code>{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&#060;...&#062;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;amount_allocated&nbsp;=&nbsp;START_BUFFER_SIZE&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;q&nbsp;=&nbsp;malloc&nbsp;(amount_allocated)&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&#060;...&#062;</code><br>
</FONT></TD></TR></TABLE><P>

<P>

<H1><A NAME="SECTION002520000000000000000">
22.2 Debugging with <TT>
<FONT COLOR="#0000ff">gdb</FONT></TT> and <TT>
<FONT COLOR="#0000ff">strace</FONT></TT></A>
</H1>

<P>
Programming errors, or <I>bugs</I>, can be
found by inspecting program execution. Some developers claim
that the need for such inspection implies a sloppy development
process. Nonetheless it is instructive to learn <B>C</B> by
actually watching a program work.

<P>

<H2><A NAME="SECTION002521000000000000000">
22.2.1 <TT>
<FONT COLOR="#0000ff">gdb</FONT></TT></A>
</H2>

<P>
The GNU debugger, <TT>
<FONT COLOR="#0000ff">gdb</FONT></TT>,
is a replacement for the standard
U<SMALL>NIX</SMALL> debugger,
<TT>
<FONT COLOR="#0000ff">db</FONT></TT>. To debug a program means to step through its execution
line-by-line, in order to find programming errors as they happen. Use the
command <TT>
<FONT COLOR="#0000ff">gcc -Wall -g -O0 -o wordsplit wordsplit.c</FONT></TT> to recompile your
program above.
The <TT>
<FONT COLOR="#0000ff">-g</FONT></TT> option enables debugging support in the resulting executable
and the <TT>
<FONT COLOR="#0000ff">-O0</FONT></TT> option disables compiler optimization
(which sometimes causes confusing behavior).
For the following example, create a test file <TT>
<FONT COLOR="#0000ff">readme.txt</FONT></TT> with some plain text
inside it. You can then run <TT>
<FONT COLOR="#0000ff">gdb -q wordsplit</FONT></TT>. The
standard <TT>
<FONT COLOR="#0000ff">gdb</FONT></TT> prompt will appear,
which indicates the start of a <I>debugging session</I>:

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>(gdb)&nbsp;</code><br>
</FONT></TD></TR></TABLE><P>
At the prompt, many one letter commands are available to
control program execution. The first of these is <TT>
<FONT COLOR="#0000ff">r</FONT></TT><I>un</I>
which executes the program as though it had been started
from a regular shell:

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>5</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>(gdb)&nbsp;<font color="navy"><B>r</B></font></code><br>
<code>Starting&nbsp;program:&nbsp;/homes/src/wordsplit/wordsplit&nbsp;</code><br>
<code>Usage:</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;wordsplit&nbsp;&#060;filename&#062;&nbsp;...</code><br>
<code>&nbsp;</code><br>
<code>Program&nbsp;exited&nbsp;with&nbsp;code&nbsp;01.</code><br>
</FONT></TD></TR></TABLE><P>
Obviously, we will want to set some trial command-line arguments.
This is done with the special command, <TT>
<FONT COLOR="#0000ff">set args</FONT></TT>:

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>(gdb)&nbsp;<font color="navy"><B>set&nbsp;args&nbsp;readme.txt&nbsp;readme2.txt</B></font></code><br>
</FONT></TD></TR></TABLE><P>

<P>
The <TT>
<FONT COLOR="#0000ff">b</FONT></TT><I>reak</I> command
is used like <TT>
<FONT COLOR="#0000ff">b&nbsp;[[&lt;file&gt;:]&lt;line&gt;&#124;&lt;function&gt;]</FONT></TT>,
and sets a <I>break point</I> at a function or line number:

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>(gdb)&nbsp;<font color="navy"><B>b&nbsp;main</B></font></code><br>
<code>Breakpoint&nbsp;1&nbsp;at&nbsp;0x8048796:&nbsp;file&nbsp;wordsplit.c,&nbsp;line&nbsp;67.</code><br>
</FONT></TD></TR></TABLE><P>
A break point will interrupt execution of the program. In this case
the program will stop when it enters the
<TT>
<FONT COLOR="#0000ff">main</FONT></TT> function (i.e., right at the start).
Now we can <TT>
<FONT COLOR="#0000ff">r</FONT></TT>un the program again:

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>5</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>(gdb)&nbsp;<font color="navy"><B>r</B></font></code><br>
<code>Starting&nbsp;program:&nbsp;/home/src/wordsplit/wordsplit&nbsp;readme.txt&nbsp;readme2.txt</code><br>
<code>&nbsp;</code><br>
<code>Breakpoint&nbsp;1,&nbsp;main&nbsp;(argc=3,&nbsp;argv=0xbffff804)&nbsp;at&nbsp;wordsplit.c:67</code><br>
<code>67&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;if&nbsp;(argc&nbsp;&#060;&nbsp;2)&nbsp;{</code><br>
<code>(gdb)&nbsp;</code><br>
</FONT></TD></TR></TABLE><P>
As specified, the program stops at the beginning of the <TT>
<FONT COLOR="#0000ff">main</FONT></TT>
function at line 67.

<P>
If you are interested in viewing the contents of
a variable, you can use the <TT>
<FONT COLOR="#0000ff">p</FONT></TT>rint command:

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>(gdb)&nbsp;<font color="navy"><B>p&nbsp;argc</B></font></code><br>
<code>$1&nbsp;=&nbsp;3</code><br>
<code>(gdb)&nbsp;<font color="navy"><B>p&nbsp;argv[1]</B></font></code><br>
<code>$2&nbsp;=&nbsp;0xbffff988&nbsp;"readme.txt"</code><br>
</FONT></TD></TR></TABLE><P>
which tells us the value of <TT>
<FONT COLOR="#0000ff">argc</FONT></TT> and <TT>
<FONT COLOR="#0000ff">argv[1]</FONT></TT>.
The <TT>
<FONT COLOR="#0000ff">l</FONT></TT><I>ist</I> command
displays the lines about the current line:

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>5</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>(gdb)&nbsp;<font color="navy"><B>l</B></font></code><br>
<code>63&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;int&nbsp;main&nbsp;(int&nbsp;argc,&nbsp;char&nbsp;*argv[])</code><br>
<code>64&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;{</code><br>
<code>65&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;int&nbsp;i&#059;</code><br>
<code>66&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><br>
<code>67&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;if&nbsp;(argc&nbsp;&#060;&nbsp;2)&nbsp;{</code><br>
<code>68&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;printf&nbsp;("Usage:\n\twordsplit&nbsp;&#060;filename&#062;&nbsp;...\n")&#059;</code><br>
<code>69&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;exit&nbsp;(1)&#059;</code><br>
<code>70&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}</code><br>
</FONT></TD></TR></TABLE><P>
The <TT>
<FONT COLOR="#0000ff">l</FONT></TT><I>ist</I> command can also take an optional file and line number
(or even a function name):

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>5</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>(gdb)&nbsp;<font color="navy"><B>l&nbsp;wordsplit.c:1</B></font></code><br>
<code>1&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;#include&nbsp;&#060;stdlib.h&#062;</code><br>
<code>2&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;#include&nbsp;&#060;stdio.h&#062;</code><br>
<code>3&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;#include&nbsp;&#060;string.h&#062;</code><br>
<code>4&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</code><br>
<code>5&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;void&nbsp;word_dump&nbsp;(char&nbsp;*filename)</code><br>
<code>6&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;{</code><br>
<code>7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;int&nbsp;length_of_word&#059;</code><br>
<code>8&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;int&nbsp;amount_allocated&#059;</code><br>
</FONT></TD></TR></TABLE><P>

<P>
Next, we can try setting a break point at an arbitrary line and then
using the <TT>
<FONT COLOR="#0000ff">c</FONT></TT><I>ontinue</I>
command to proceed with program execution:

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>5</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>(gdb)&nbsp;<font color="navy"><B>b&nbsp;wordsplit.c:48</B></font></code><br>
<code>Breakpoint&nbsp;2&nbsp;at&nbsp;0x804873e:&nbsp;file&nbsp;wordsplit.c,&nbsp;line&nbsp;48.</code><br>
<code>(gdb)&nbsp;<font color="navy"><B>c</B></font></code><br>
<code>Continuing.</code><br>
<code>Zaphod</code><br>
<code>&nbsp;</code><br>
<code>Breakpoint&nbsp;2,&nbsp;word_dump&nbsp;(filename=0xbffff988&nbsp;"readme.txt")&nbsp;at&nbsp;wordsplit.c:48</code><br>
<code>48&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;amount_allocated&nbsp;=&nbsp;256&#059;</code><br>
</FONT></TD></TR></TABLE><P>
Execution obediently stops at line 48. At this point it is useful to
run a <TT>
<FONT COLOR="#0000ff">b</FONT></TT><I>ack</I><TT>
<FONT COLOR="#0000ff">t</FONT></TT><I>race</I>.
This prints out the current
<I>stack</I> which shows the functions that were called to get to the
current line. This output allows you to <I>trace</I> the history of
execution.

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>5</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>(gdb)&nbsp;<font color="navy"><B>bt</B></font></code><br>
<code>#0&nbsp;&nbsp;word_dump&nbsp;(filename=0xbffff988&nbsp;"readme.txt")&nbsp;at&nbsp;wordsplit.c:48</code><br>
<code>#1&nbsp;&nbsp;0x80487e0&nbsp;in&nbsp;main&nbsp;(argc=3,&nbsp;argv=0xbffff814)&nbsp;at&nbsp;wordsplit.c:73</code><br>
<code>#2&nbsp;&nbsp;0x4003db65&nbsp;in&nbsp;__libc_start_main&nbsp;(main=0x8048790&nbsp;&#060;main&#062;,&nbsp;argc=3,&nbsp;ubp_av=0xbf</code><br>
<code>fff814,&nbsp;init=0x8048420&nbsp;&#060;_init&#062;,&nbsp;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;fini=0x804883c&nbsp;&#060;_fini&#062;,&nbsp;rtld_fini=0x4000df24&nbsp;&#060;_dl_fini&#062;,&nbsp;stack_end=0xbffff8</code><br>
<code>0c)&nbsp;at&nbsp;../sysdeps/generic/libc-start.c:111</code><br>
</FONT></TD></TR></TABLE><P>

<P>
The <TT>
<FONT COLOR="#0000ff">clear</FONT></TT> command then deletes the break point at the
current line:

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>(gdb)&nbsp;<font color="navy"><B>clear</B></font></code><br>
<code>Deleted&nbsp;breakpoint&nbsp;2&nbsp;</code><br>
</FONT></TD></TR></TABLE><P>

<P>
The most important commands for debugging are the <TT>
<FONT COLOR="#0000ff">n</FONT></TT><I>ext</I>
and <TT>
<FONT COLOR="#0000ff">s</FONT></TT><I>tep</I> commands. The <TT>
<FONT COLOR="#0000ff">n</FONT></TT> command simply executes one line of
<B>C</B> code:

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>5</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>(gdb)&nbsp;<font color="navy"><B>n</B></font></code><br>
<code>49&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;q&nbsp;=&nbsp;realloc&nbsp;(q,&nbsp;amount_allocated)&#059;</code><br>
<code>(gdb)&nbsp;<font color="navy"><B>n</B></font></code><br>
<code>50&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;if&nbsp;(q&nbsp;==&nbsp;0)&nbsp;{</code><br>
<code>(gdb)&nbsp;<font color="navy"><B>n</B></font></code><br>
<code>54&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;length_of_word&nbsp;=&nbsp;0&#059;</code><br>
</FONT></TD></TR></TABLE><P>
This activity is called <I>stepping</I> through your program. The <TT>
<FONT COLOR="#0000ff">s</FONT></TT>
command is identical to <TT>
<FONT COLOR="#0000ff">n</FONT></TT> except that it dives into functions instead
of running them as single line. To see the difference, step over line 73
first with <TT>
<FONT COLOR="#0000ff">n</FONT></TT>, and then with <TT>
<FONT COLOR="#0000ff">s</FONT></TT>, as follows:

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>5</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>10</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>15</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>20</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>25</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>(gdb)&nbsp;<font color="navy"><B>set&nbsp;args&nbsp;readme.txt&nbsp;readme2.txt</B></font></code><br>
<code>(gdb)&nbsp;<font color="navy"><B>b&nbsp;main</B></font></code><br>
<code>Breakpoint&nbsp;1&nbsp;at&nbsp;0x8048796:&nbsp;file&nbsp;wordsplit.c,&nbsp;line&nbsp;67.</code><br>
<code>(gdb)&nbsp;<font color="navy"><B>r</B></font></code><br>
<code>Starting&nbsp;program:&nbsp;/home/src/wordsplit/wordsplit&nbsp;readme.txt&nbsp;readme2.txt</code><br>
<code>&nbsp;</code><br>
<code>Breakpoint&nbsp;1,&nbsp;main&nbsp;(argc=3,&nbsp;argv=0xbffff814)&nbsp;at&nbsp;wordsplit.c:67</code><br>
<code>67&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;if&nbsp;(argc&nbsp;&#060;&nbsp;2)&nbsp;{</code><br>
<code>(gdb)&nbsp;<font color="navy"><B>n</B></font></code><br>
<code>72&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;for&nbsp;(i&nbsp;=&nbsp;1&#059;&nbsp;i&nbsp;&#060;&nbsp;argc&#059;&nbsp;i++)&nbsp;{</code><br>
<code>(gdb)&nbsp;<font color="navy"><B>n</B></font></code><br>
<code>73&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;word_dump&nbsp;(argv[i])&#059;</code><br>
<code>(gdb)&nbsp;<font color="navy"><B>n</B></font></code><br>
<code>Zaphod</code><br>
<code>has</code><br>
<code>two</code><br>
<code>heads</code><br>
<code>72&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;for&nbsp;(i&nbsp;=&nbsp;1&#059;&nbsp;i&nbsp;&#060;&nbsp;argc&#059;&nbsp;i++)&nbsp;{</code><br>
<code>(gdb)&nbsp;<font color="navy"><B>s</B></font></code><br>
<code>73&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;word_dump&nbsp;(argv[i])&#059;</code><br>
<code>(gdb)&nbsp;<font color="navy"><B>s</B></font></code><br>
<code>word_dump&nbsp;(filename=0xbffff993&nbsp;"readme2.txt")&nbsp;at&nbsp;wordsplit.c:13</code><br>
<code>13&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;c&nbsp;=&nbsp;0&#059;</code><br>
<code>(gdb)&nbsp;<font color="navy"><B>s</B></font></code><br>
<code>15&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;f&nbsp;=&nbsp;fopen&nbsp;(filename,&nbsp;"r")&#059;</code><br>
<code>(gdb)&nbsp;</code><br>
</FONT></TD></TR></TABLE><P>

<P>
An interesting feature of <TT>
<FONT COLOR="#0000ff">gdb</FONT></TT> is its ability to 
attach onto running programs. Try the following sequence of
commands:

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>5</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>10</code></font><code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>[root@cericon]#&nbsp;<font color="navy"><B>lpd</B></font></code><br>
<code>[root@cericon]#&nbsp;<font color="navy"><B>ps&nbsp;awx&nbsp;|&nbsp;grep&nbsp;lpd</B></font></code><br>
<code>28157&nbsp;?&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;S&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;0:00&nbsp;lpd&nbsp;Waiting</code><br>
<code>28160&nbsp;pts/6&nbsp;&nbsp;&nbsp;&nbsp;S&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;0:00&nbsp;grep&nbsp;lpd</code><br>
<code>[root@cericon]#&nbsp;<font color="navy"><B>gdb&nbsp;-q&nbsp;/usr/sbin/lpd</B></font></code><br>
<code>(no&nbsp;debugging&nbsp;symbols&nbsp;found)...</code><br>
<code>(gdb)&nbsp;<font color="navy"><B>attach&nbsp;28157</B></font></code><br>
<code>Attaching&nbsp;to&nbsp;program:&nbsp;/usr/sbin/lpd,&nbsp;Pid&nbsp;28157</code><br>
<code>0x40178bfe&nbsp;in&nbsp;__select&nbsp;()&nbsp;from&nbsp;/lib/libc.so.6</code><br>
<code>(gdb)&nbsp;</code><br>
</FONT></TD></TR></TABLE><P>
The <TT>
<FONT COLOR="#0000ff">lpd</FONT></TT> daemon was not compiled with debugging support,
but the point is still made: you can halt and debug <I>any</I> running
process on the system. Try running a <TT>
<FONT COLOR="#0000ff">bt</FONT></TT> for fun. Now release
the process with

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>(gdb)&nbsp;<font color="navy"><B>detach</B></font></code><br>
<code>Detaching&nbsp;from&nbsp;program:&nbsp;/usr/sbin/lpd,&nbsp;Pid&nbsp;28157</code><br>
</FONT></TD></TR></TABLE><P>

<P>
The debugger provides copious amounts of online help.
The <TT>
<FONT COLOR="#0000ff">help</FONT></TT> command can
be run to explain further.
The <TT>
<FONT COLOR="#0000ff">gdb</FONT></TT> <TT>
<FONT COLOR="#0000ff">info</FONT></TT> pages also elaborate on an
enormous number of display features and tracing
features not covered here.

<P>

<H2><A NAME="SECTION002522000000000000000">
22.2.2 Examining <TT>
<FONT COLOR="#0000ff">core</FONT></TT> files</A>
</H2>

<P>
If your program has a segmentation violation
(``segfault'') then a <TT>
<FONT COLOR="#0000ff">core</FONT></TT> file will be
written to the current directory. This is known as a <I>core dump</I>.
A core dump is caused by a bug in the program--its response to a
<TT>
<FONT COLOR="#0000ff">SIGSEGV</FONT></TT> signal sent to the program because
it tried to access an area of memory outside of its allowed range.
These files can be examined using <TT>
<FONT COLOR="#0000ff">gdb</FONT></TT> to (usually) reveal where the problem
occurred. Simply run <TT>
<FONT COLOR="#0000ff">gdb &lt;executable&gt; ./core</FONT></TT> and then type <TT>
<FONT COLOR="#0000ff">bt</FONT></TT> (or any <TT>
<FONT COLOR="#0000ff">gdb</FONT></TT> command)
at the <TT>
<FONT COLOR="#0000ff">gdb</FONT></TT> prompt. Typing <TT>
<FONT COLOR="#0000ff">file ./core</FONT></TT> will reveal something like

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red size="-1">
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue size="-1">
<code>/root/core:&nbsp;ELF&nbsp;32-bit&nbsp;LSB&nbsp;core&nbsp;file&nbsp;of&nbsp;'&#060;executable&#062;'&nbsp;(signal&nbsp;11),&nbsp;Intel&nbsp;80386,&nbsp;version&nbsp;1</code><br>
</FONT></TD></TR></TABLE><P>

<P>

<H2><A NAME="SECTION002523000000000000000">
22.2.3 <TT>
<FONT COLOR="#0000ff">strace</FONT></TT></A>
</H2>

<P>
The <TT>
<FONT COLOR="#0000ff">strace</FONT></TT> command prints every
<I>system call</I> performed
by a program. A system call is a function call made <I>by</I> a <B>C</B>
library function to the L<SMALL>INUX</SMALL> kernel. Try

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>strace&nbsp;ls</code><br>
<code>strace&nbsp;./wordsplit</code><br>
</FONT></TD></TR></TABLE><P>

<P>
If a program has not been compiled with debugging support, the
only way to inspect its execution may be with the <TT>
<FONT COLOR="#0000ff">strace</FONT></TT>
command. In any case, the command can provide valuable information
about where a program is failing and is useful for diagnosing errors.

<P>

<H1><A NAME="SECTION002530000000000000000">
22.3 <B>C</B> Libraries</A>
</H1>

<P>
We made reference to the Standard <B>C</B> library. The <B>C</B>
language on its own does almost nothing; everything useful
is an external function. External functions are grouped
into libraries. The Standard <B>C</B> library is the file
<TT>
<FONT COLOR="#0000ff">/lib/libc.so.6</FONT></TT>. To list all the <B>C</B> library functions, run:

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>nm&nbsp;/lib/libc.so.6</code><br>
<code>nm&nbsp;/lib/libc.so.6&nbsp;|&nbsp;grep&nbsp;'&nbsp;T&nbsp;'&nbsp;|&nbsp;cut&nbsp;-f3&nbsp;-d'&nbsp;'&nbsp;|&nbsp;grep&nbsp;-v&nbsp;'^_'&nbsp;|&nbsp;sort&nbsp;-u&nbsp;|&nbsp;less</code><br>
</FONT></TD></TR></TABLE><P>
many of these have <TT>
<FONT COLOR="#0000ff">man</FONT></TT> pages, but some will have
no documentation and require you to read the comments inside
the header files (which are often most explanatory).
It is better not to use functions unless
you are sure that they are
<I>standard</I> functions in the
sense that they are common to other systems.

<P>
To create your own library is simple. Let's say we have two
files that contain several functions that we would like to
compile into a library. The files are <TT>
<FONT COLOR="#0000ff">simple_math_sqrt.c</FONT></TT>

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>5</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>10</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>15</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>20</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>#include&nbsp;&#060;stdlib.h&#062;</code><br>
<code>#include&nbsp;&#060;stdio.h&#062;</code><br>
<code>&nbsp;</code><br>
<code>static&nbsp;int&nbsp;abs_error&nbsp;(int&nbsp;a,&nbsp;int&nbsp;b)</code><br>
<code>{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;if&nbsp;(a&nbsp;&#062;&nbsp;b)</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;return&nbsp;a&nbsp;-&nbsp;b&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;return&nbsp;b&nbsp;-&nbsp;a&#059;</code><br>
<code>}</code><br>
<code>&nbsp;</code><br>
<code>int&nbsp;simple_math_isqrt&nbsp;(int&nbsp;x)</code><br>
<code>{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;int&nbsp;result&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;if&nbsp;(x&nbsp;&#060;&nbsp;0)&nbsp;{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;fprintf&nbsp;(stderr,&nbsp;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;"simple_math_sqrt:&nbsp;taking&nbsp;the&nbsp;sqrt&nbsp;of&nbsp;a&nbsp;negative&nbsp;number\n")&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;abort&nbsp;()&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;}</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;result&nbsp;=&nbsp;2&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;while&nbsp;(abs_error&nbsp;(result&nbsp;*&nbsp;result,&nbsp;x)&nbsp;&#062;&nbsp;1)&nbsp;{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;result&nbsp;=&nbsp;(x&nbsp;/&nbsp;result&nbsp;+&nbsp;result)&nbsp;/&nbsp;2&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;}</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;return&nbsp;result&#059;</code><br>
<code>}</code><br>
</FONT></TD></TR></TABLE><P>
and <TT>
<FONT COLOR="#0000ff">simple_math_pow.c</FONT></TT>

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>5</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>10</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>15</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>20</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>#include&nbsp;&#060;stdlib.h&#062;</code><br>
<code>#include&nbsp;&#060;stdio.h&#062;</code><br>
<code>&nbsp;</code><br>
<code>int&nbsp;simple_math_ipow&nbsp;(int&nbsp;x,&nbsp;int&nbsp;y)</code><br>
<code>{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;int&nbsp;result&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;if&nbsp;(x&nbsp;==&nbsp;1&nbsp;||&nbsp;y&nbsp;==&nbsp;0)</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;return&nbsp;1&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;if&nbsp;(x&nbsp;==&nbsp;0&nbsp;&#038;&#038;&nbsp;y&nbsp;&#060;&nbsp;0)&nbsp;{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;fprintf&nbsp;(stderr,</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;"simple_math_pow:&nbsp;raising&nbsp;zero&nbsp;to&nbsp;a&nbsp;negative&nbsp;power\n")&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;abort&nbsp;()&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;}</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;if&nbsp;(y&nbsp;&#060;&nbsp;0)</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;return&nbsp;0&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;result&nbsp;=&nbsp;1&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;while&nbsp;(y&nbsp;&#062;&nbsp;0)&nbsp;{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;result&nbsp;=&nbsp;result&nbsp;*&nbsp;x&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;y&nbsp;=&nbsp;y&nbsp;-&nbsp;1&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;}</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;return&nbsp;result&#059;</code><br>
<code>}</code><br>
</FONT></TD></TR></TABLE><P>

<P>
We would like to call the library <TT>
<FONT COLOR="#0000ff">simple_math</FONT></TT>.
It is good practice to name all the functions in the library
<TT>
<FONT COLOR="#0000ff">simple_math_</FONT></TT><I>??????</I>. The function <TT>
<FONT COLOR="#0000ff">abs_error</FONT></TT>
is not going to be used outside of the file <TT>
<FONT COLOR="#0000ff">simple_math_sqrt.c</FONT></TT>
and so we put the keyword <TT>
<FONT COLOR="#0000ff">static</FONT></TT> in front of it, meaning
that it is a <I>local</I> function.

<P>
We can compile the code with:

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>gcc&nbsp;-Wall&nbsp;-c&nbsp;simple_math_sqrt.c</code><br>
<code>gcc&nbsp;-Wall&nbsp;-c&nbsp;simple_math_pow.c</code><br>
</FONT></TD></TR></TABLE><P>
The <TT>
<FONT COLOR="#0000ff">-c</FONT></TT> option means <I>compile only</I>. The
code is not turned into an executable. The generated
files are <TT>
<FONT COLOR="#0000ff">simple_math_sqrt.o</FONT></TT> and <TT>
<FONT COLOR="#0000ff">simple_math_pow.o</FONT></TT>.
These are called <TT>
<FONT COLOR="#0000ff">o</FONT></TT><I>bject</I> files.

<P>
We now need to <I>archive</I> these files into
a library. We do this with the <TT>
<FONT COLOR="#0000ff">ar</FONT></TT> command (a predecessor
of <TT>
<FONT COLOR="#0000ff">tar</FONT></TT>):

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>ar&nbsp;libsimple_math.a&nbsp;simple_math_sqrt.o&nbsp;simple_math_pow.o</code><br>
<code>ranlib&nbsp;libsimple_math.a</code><br>
</FONT></TD></TR></TABLE><P>
The <TT>
<FONT COLOR="#0000ff">ranlib</FONT></TT> command indexes the archive.

<P>
The library can now be used. Create a file <TT>
<FONT COLOR="#0000ff">mytest.c</FONT></TT>:

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>5</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>#include&nbsp;&#060;stdlib.h&#062;</code><br>
<code>#include&nbsp;&#060;stdio.h&#062;</code><br>
<code>&nbsp;</code><br>
<code>int&nbsp;main&nbsp;(int&nbsp;argc,&nbsp;char&nbsp;*argv[])</code><br>
<code>{</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;printf&nbsp;("%d\n",&nbsp;simple_math_ipow&nbsp;(4,&nbsp;3))&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;printf&nbsp;("%d\n",&nbsp;simple_math_isqrt&nbsp;(50))&#059;</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;return&nbsp;0&#059;</code><br>
<code>}</code><br>
</FONT></TD></TR></TABLE><P>
and run

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>gcc&nbsp;-Wall&nbsp;-c&nbsp;mytest.c</code><br>
<code>gcc&nbsp;-o&nbsp;mytest&nbsp;mytest.o&nbsp;-L.&nbsp;-lsimple_math</code><br>
</FONT></TD></TR></TABLE><P>
The first command compiles the file <TT>
<FONT COLOR="#0000ff">mytest.c</FONT></TT> into
<TT>
<FONT COLOR="#0000ff">mytest.o</FONT></TT>, and the second function is called
<I>linking</I> the program, which assimilates <TT>
<FONT COLOR="#0000ff">mytest.o</FONT></TT>
and the libraries into a single executable. The option
<TT>
<FONT COLOR="#0000ff">L.</FONT></TT> means to look in the current directory
for any libraries (usually only <TT>
<FONT COLOR="#0000ff">/lib</FONT></TT>
and <TT>
<FONT COLOR="#0000ff">/usr/lib</FONT></TT> are
searched). The option <TT>
<FONT COLOR="#0000ff">-lsimple_math</FONT></TT> means to assimilate the
library <TT>
<FONT COLOR="#0000ff">libsimple_math.a</FONT></TT> (<TT>
<FONT COLOR="#0000ff">lib</FONT></TT> and <TT>
<FONT COLOR="#0000ff">.a</FONT></TT> are added
automatically). This operation is called <I>static</I> <FONT COLOR="#ffa500">[Nothing
to do with the ``<TT>
<FONT COLOR="#0000ff">static</FONT></TT>'' keyword.]</FONT> linking
because it happens before the program is run and includes all object
files into the executable<A NAME="page:staticlinking"></A>.

<P>
As an aside, note that it is often the case that many static
libraries are linked into the same program. Here order is important: the
library with the least dependencies should come last, or you will get
so-called <I>symbol referencing errors</I>.

<P>
We can also create a header file <TT>
<FONT COLOR="#0000ff">simple_math.h</FONT></TT> for using the
library.

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>5</code></font><code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>/*&nbsp;calculates&nbsp;the&nbsp;integer&nbsp;square&nbsp;root,&nbsp;aborts&nbsp;on&nbsp;error&nbsp;*/</code><br>
<code>int&nbsp;simple_math_isqrt&nbsp;(int&nbsp;x)&#059;</code><br>
<code>&nbsp;</code><br>
<code>/*&nbsp;calculates&nbsp;the&nbsp;integer&nbsp;power,&nbsp;aborts&nbsp;on&nbsp;error&nbsp;*/</code><br>
<code>int&nbsp;simple_math_ipow&nbsp;(int&nbsp;x,&nbsp;int&nbsp;y)&#059;</code><br>
</FONT></TD></TR></TABLE><P>
Add the line <TT>
<FONT COLOR="#0000ff">#include "simple_math.h"</FONT></TT> to
the top of <TT>
<FONT COLOR="#0000ff">mytest.c</FONT></TT>:

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>#include&nbsp;&#060;stdlib.h&#062;</code><br>
<code>#include&nbsp;&#060;stdio.h&#062;</code><br>
<code>#include&nbsp;"simple_math.h"</code><br>
</FONT></TD></TR></TABLE><P>
This addition gets rid of
the <TT>
<FONT COLOR="#0000ff">implicit declaration of function</FONT></TT>
warning messages.
Usually <TT>
<FONT COLOR="#0000ff">#include &lt;simple_math.h&gt;</FONT></TT> would be used,
but here, this is a header file in the current directory--our
<I>own</I> header file--and this is where
we use <TT>
<FONT COLOR="#0000ff">"simple_math.h"</FONT></TT> instead of <TT>
<FONT COLOR="#0000ff">&lt;simple_math.h&gt;</FONT></TT>.

<P>

<H1><A NAME="SECTION002540000000000000000">
22.4 <B>C</B> Projects -- <TT>
<FONT COLOR="#0000ff">Makefile</FONT></TT>s</A>
</H1>

<P>
What if you make
a small change to one of the files
(as you are likely to do very often when developing)?
You could script the process of compiling and linking,
but the script would build everything, and not just the
changed file. What we really need is a utility that
only recompiles object files whose sources have changed:
<TT>
<FONT COLOR="#0000ff">make</FONT></TT> is such a utility.

<P>
<TT>
<FONT COLOR="#0000ff">make</FONT></TT> is a program that looks inside a
<TT>
<FONT COLOR="#0000ff">Makefile</FONT></TT>
in the current directory then does a lot of compiling and linking.
<TT>
<FONT COLOR="#0000ff">Makefile</FONT></TT>s contain lists of rules and <I>dependencies</I>
describing how to build a program.

<P>
Inside a <TT>
<FONT COLOR="#0000ff">Makefile</FONT></TT> you need to state a list of 
<I>what-depends-on-what</I> dependencies that <TT>
<FONT COLOR="#0000ff">make</FONT></TT>
can work through, as well as the shell commands needed to
achieve each goal.

<P>

<H2><A NAME="SECTION002541000000000000000">
22.4.1 Completing our example <TT>
<FONT COLOR="#0000ff">Makefile</FONT></TT></A>
</H2>

<P>
Our first (last?) <I>dependency</I> in the process of completing
the compilation is that <TT>
<FONT COLOR="#0000ff">mytest</FONT></TT> <I>depends on</I> 
both the library, <TT>
<FONT COLOR="#0000ff">libsimple_math.a</FONT></TT>, and
the object file, <TT>
<FONT COLOR="#0000ff">mytest.o</FONT></TT>. In <TT>
<FONT COLOR="#0000ff">make</FONT></TT> terms
we create a <TT>
<FONT COLOR="#0000ff">Makefile</FONT></TT> line that looks like:

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>mytest:&nbsp;&nbsp;&nbsp;libsimple_math.a&nbsp;mytest.o</code><br>
</FONT></TD></TR></TABLE><P>
meaning simply that the files <TT>
<FONT COLOR="#0000ff">libsimple_math.a mytest.o</FONT></TT>
must exist and be updated before <TT>
<FONT COLOR="#0000ff">mytest</FONT></TT>.
<TT>
<FONT COLOR="#0000ff">mytest:</FONT></TT> is called a <TT>
<FONT COLOR="#0000ff">make</FONT></TT> <I>target</I>.
Beneath this line, we also need to state
how to build <TT>
<FONT COLOR="#0000ff">mytest</FONT></TT>:

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;gcc&nbsp;-Wall&nbsp;-o&nbsp;$@&nbsp;mytest.o&nbsp;-L.&nbsp;-lsimple_math</code><br>
</FONT></TD></TR></TABLE><P>
The <TT>
<FONT COLOR="#0000ff">$@</FONT></TT> means the name of the target
itself, which is just substituted with <TT>
<FONT COLOR="#0000ff">mytest</FONT></TT>. <I>Note that the
space before the <TT>
<FONT COLOR="#0000ff">gcc</FONT></TT> is a tab
character and not 8 space characters.</I>

<P>
The next dependency is that <TT>
<FONT COLOR="#0000ff">libsimple_math.a</FONT></TT>
depends on <TT>
<FONT COLOR="#0000ff">simple_math_sqrt.o simple_math_pow.o</FONT></TT>.
Once again we have a dependency, along with a shell
script to build the target. The full <TT>
<FONT COLOR="#0000ff">Makefile</FONT></TT>
<I>rule</I> is:

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>libsimple_math.a:&nbsp;simple_math_sqrt.o&nbsp;simple_math_pow.o</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;rm&nbsp;-f&nbsp;$@</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;ar&nbsp;rc&nbsp;$@&nbsp;simple_math_sqrt.o&nbsp;simple_math_pow.o</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;ranlib&nbsp;$@</code><br>
</FONT></TD></TR></TABLE><P>
<I>Note again that the left margin consists of a single tab character and not spaces.</I>

<P>
The final dependency is that the files <TT>
<FONT COLOR="#0000ff">simple_math_sqrt.o</FONT></TT> and <TT>
<FONT COLOR="#0000ff">simple_math_pow.o</FONT></TT> 
depend on the files <TT>
<FONT COLOR="#0000ff">simple_math_sqrt.c</FONT></TT> and <TT>
<FONT COLOR="#0000ff">simple_math_pow.c</FONT></TT>.
This requires two <TT>
<FONT COLOR="#0000ff">make</FONT></TT> target rules, but <TT>
<FONT COLOR="#0000ff">make</FONT></TT> has a short
way of stating such a rule in the case of many <B>C</B> source files,

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>.c.o:</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;gcc&nbsp;-Wall&nbsp;-c&nbsp;-o&nbsp;$*.o&nbsp;$&#060;</code><br>
</FONT></TD></TR></TABLE><P>
which means that any <TT>
<FONT COLOR="#0000ff">.o</FONT></TT> files needed
can be built from a <TT>
<FONT COLOR="#0000ff">.c</FONT></TT> file of a similar name by means
of the command <TT>
<FONT COLOR="#0000ff">gcc -Wall -c -o $*.o $&lt;</FONT></TT>, where <TT>
<FONT COLOR="#0000ff">$*.o</FONT></TT>
means the name of the object file and <TT>
<FONT COLOR="#0000ff">$&lt;</FONT></TT> means
the name of the file that <TT>
<FONT COLOR="#0000ff">$*.o</FONT></TT> depends on, one at
a time.

<P>

<H2><A NAME="SECTION002542000000000000000">
22.4.2 Putting it all together</A>
</H2>

<P>
<TT>
<FONT COLOR="#0000ff">Makefile</FONT></TT>s can, in fact, have their rules
put in any order, so it's best to state the most obvious
rules first for readability.

<P>
There is also a rule you should always state at the
outset:

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>all:&nbsp;&nbsp;&nbsp;&nbsp;libsimple_math.a&nbsp;mytest</code><br>
</FONT></TD></TR></TABLE><P>
The <TT>
<FONT COLOR="#0000ff">all:</FONT></TT> target is the rule that
<TT>
<FONT COLOR="#0000ff">make</FONT></TT> tries to satisfy when <TT>
<FONT COLOR="#0000ff">make</FONT></TT> is
run with no command-line arguments. This just
means that <TT>
<FONT COLOR="#0000ff">libsimple_math.a</FONT></TT> and <TT>
<FONT COLOR="#0000ff">mytest</FONT></TT>
are the last two files to be built, that is, they are
the top-level dependencies.

<P>
<TT>
<FONT COLOR="#0000ff">Makefile</FONT></TT>s also have their own form of environment
variables, like shell scripts. You can see that we have
used the text <TT>
<FONT COLOR="#0000ff">simple_math</FONT></TT> in three of our rules.
It makes sense to define a <I>macro</I> for this so that
we can easily change to a different library name.

<P>
Our final <TT>
<FONT COLOR="#0000ff">Makefile</FONT></TT> is<A NAME="page:libmakefile"></A>:

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>5</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>10</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>15</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<font size="-1"><code>20</code></font><code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>#&nbsp;Comments&nbsp;start&nbsp;with&nbsp;a&nbsp;#&nbsp;(hash)&nbsp;character&nbsp;like&nbsp;shell&nbsp;scripts.</code><br>
<code>#&nbsp;Makefile&nbsp;to&nbsp;build&nbsp;libsimple_math.a&nbsp;and&nbsp;mytest&nbsp;program.</code><br>
<code>#&nbsp;Paul&nbsp;Sheer&nbsp;&#060;psheer@cranzgot.co.za&#062;&nbsp;Sun&nbsp;Mar&nbsp;19&nbsp;15:56:08&nbsp;2000</code><br>
<code>&nbsp;</code><br>
<code>OBJS&nbsp;&nbsp;&nbsp;&nbsp;=&nbsp;simple_math_sqrt.o&nbsp;simple_math_pow.o</code><br>
<code>LIBNAME&nbsp;=&nbsp;simple_math</code><br>
<code>CFLAGS&nbsp;&nbsp;=&nbsp;-Wall</code><br>
<code>&nbsp;</code><br>
<code>all:&nbsp;&nbsp;&nbsp;&nbsp;lib$(LIBNAME).a&nbsp;mytest</code><br>
<code>&nbsp;</code><br>
<code>mytest:&nbsp;&nbsp;&nbsp;lib$(LIBNAME).a&nbsp;mytest.o</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;gcc&nbsp;$(CFLAGS)&nbsp;-o&nbsp;$@&nbsp;mytest.o&nbsp;-L.&nbsp;-l${LIBNAME}</code><br>
<code>&nbsp;</code><br>
<code>lib$(LIBNAME).a:&nbsp;$(OBJS)</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;rm&nbsp;-f&nbsp;$@</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;ar&nbsp;rc&nbsp;$@&nbsp;$(OBJS)</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;ranlib&nbsp;$@</code><br>
<code>&nbsp;</code><br>
<code>.c.o:</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;gcc&nbsp;$(CFLAGS)&nbsp;-c&nbsp;-o&nbsp;$*.o&nbsp;$&#060;</code><br>
<code>&nbsp;</code><br>
<code>clean:</code><br>
<code>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;rm&nbsp;-f&nbsp;*.o&nbsp;*.a&nbsp;mytest</code><br>
</FONT></TD></TR></TABLE><P>

<P>
We can now easily type

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>make</code><br>
</FONT></TD></TR></TABLE><P>
in the current directory to
cause everything to be built.

<P>
You can see we have added an additional disconnected
target <TT>
<FONT COLOR="#0000ff">clean:</FONT></TT>. Targets can be run explictly on the command-line
like this:

<P><TABLE nowrap="1" width="100%" border="0" cellspacing="0" cellpadding="0">
<TR>
<TD valign="top" class="source" width="2%"><FONT color=red>
<code>&nbsp;</code><br>
</FONT></TD><TD valign="top" class="source" bgcolor="#FFE0C0"><FONT color=blue>
<code>make&nbsp;clean</code><br>
</FONT></TD></TR></TABLE><P>
which removes all built files.

<P>
<TT>
<FONT COLOR="#0000ff">Makefile</FONT></TT>s have far more uses than just building <B>C</B>
programs. Anything that needs to be built from
sources can employ a <TT>
<FONT COLOR="#0000ff">Makefile</FONT></TT> to make things
easier.

<P>
<HR>
<!--Navigation Panel-->
<A NAME="tex2html2197"
  HREF="node26.html">
<IMG WIDTH="37" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="next" SRC="next.png"></A> 
<A NAME="tex2html2193"
  HREF="rute.html">
<IMG WIDTH="26" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="up" SRC="up.png"></A> 
<A NAME="tex2html2187"
  HREF="node24.html">
<IMG WIDTH="63" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="previous" SRC="prev.png"></A> 
<A NAME="tex2html2195"
  HREF="node1.html">
<IMG WIDTH="65" HEIGHT="24" ALIGN="BOTTOM" BORDER="0" ALT="contents" SRC="contents.png"></A>  
<BR>
<B> Next:</B> <A NAME="tex2html2198"
  HREF="node26.html">23. Shared Libraries</A>
<B> Up:</B> <A NAME="tex2html2194"
  HREF="rute.html">rute</A>
<B> Previous:</B> <A NAME="tex2html2188"
  HREF="node24.html">21. System Services and</A>
 &nbsp <B>  <A NAME="tex2html2196"
  HREF="node1.html">Contents</A></B> 
<!--End of Navigation Panel-->

</BODY>
</HTML>