faqcatea63.html

this is a mirrored site c-faq. thought might need offline

<p>
<font face=Helvetica size=8 color=blue><b>A:</b></font>
There is no portable way.
Under some versions of Unix
you can call <TT>statfs</TT>.
Under MS-DOS,
use interrupt 0x21 subfunction 0x36,
or perhaps a routine such as
<TT>diskfree</TT>.
Another possibility is to use
<TT>popen</TT>
(see question <a href="faqcatea63.html?sec=osdep#popen">19.30</a>)
to invoke and read the output of a ``disk free'' command
(<TT>df</TT> on Unix).
</p><p>(Note that the amount of free space apparently available on a disk
may not match the
size of the largest file
you can store,
for all sorts of reasons.)
<hr><hr><hr>
<a name="readdir">
<h1>
comp.lang.c FAQ list
<font color=blue>&middot;</font>
<a href="../../osdep/readdir.html"><!-- qtag -->Question 19.20</a>
</h1>
<p>
<font face=Helvetica size=8 color=blue><b>Q:</b></font>
How can I read a directory in a C program?
</p><p><hr>
<p>
<font face=Helvetica size=8 color=blue><b>A:</b></font>
See if you can use
the
<TT>opendir</TT> and <TT>readdir</TT>
functions,
which are
part of the POSIX standard
and are
available on most
Unix
variants.
Implementations also exist for
MS-DOS,
VMS,
and other systems.
(MS-DOS also has
FINDFIRST and FINDNEXT

routines
which do
essentially the same thing,
and




MS Windows has
<TT>FindFirstFile</TT> and <TT>FindNextFile</TT>.)
<TT>readdir</TT>
returns just the
file names;
if you need more information about the file,
try calling <TT>stat</TT>.
To match filenames to some wildcard pattern,
see question <a href="faqcat1067.html?sec=lib#regex">13.7</a>.
</p><p>Here is a tiny example which lists the files in the current directory:
<pre>
#include &lt;stdio.h&gt;
#include &lt;sys/types.h&gt;
#include &lt;dirent.h&gt;

main()
{
	struct dirent *dp;
	DIR *dfd = opendir(".");
	if(dfd != NULL) {
		while((dp = readdir(dfd)) != NULL)
			printf("%s\n", dp-&gt;d_name);
		closedir(dfd);
	}
	return 0;
}
</pre>
(On older systems, the header file to <TT>#include</TT> may be 
<TT>&lt;direct.h&gt;</TT> or <TT>&lt;dir.h&gt;</TT>,
and the pointer returned by <TT>readdir</TT> may be a 
<TT>struct&nbsp;direct&nbsp;*</TT>.
This example assumes that <TT>"."</TT> is a synonym for the 
current directory.)
</p><p>In a pinch, you could use
<TT>popen</TT>
(see question <a href="faqcatea63.html?sec=osdep#popen">19.30</a>)
to call an operating system list-directory program,
and read its output.
(If you only need the filenames displayed to the user,
you could conceivably use <TT>system</TT>;
see question <a href="faqcatea63.html?sec=osdep#system">19.27</a>.)
</p>




<p>References:

K&amp;R2 Sec. 8.6 pp. 179-184
<br>
PCS Sec. 13 pp. 230-1
<br>
POSIX Sec. 5.1
<br>
Schumacher, ed., <I>Software Solutions in C</I> Sec. 8
<hr><hr><hr>
<a name="mkdir">
<h1>
comp.lang.c FAQ list
<font color=blue>&middot;</font>
<a href="../../osdep/mkdir.html"><!-- qtag -->Question 19.21</a>
</h1>
<p>
<font face=Helvetica size=8 color=blue><b>Q:</b></font>
How do I create a directory?
<br>How do I remove a directory
(and its contents)?
</p><p><hr>
<p>
<font face=Helvetica size=8 color=blue><b>A:</b></font>
If your operating system supports
these services,
they are
likely to be
provided
in C
via
functions
named
<TT>mkdir</TT> and
<TT>rmdir</TT>.
Removing a directory's contents as well will require listing 
them
(see question <a href="faqcatea63.html?sec=osdep#readdir">19.20</a>)
and calling <TT>remove</TT>
(see also question <a href="faqcatea63.html?sec=osdep#delete">19.16</a>).
If you don't have these C functions
available,
try <TT>system</TT>
(see question <a href="faqcatea63.html?sec=osdep#system">19.27</a>)
along
with


your operating system's delete command(s).
</p>

<p>References:

PCS Sec. 12 pp. 203-4
<br>
POSIX Secs. 5.4.1,5.5.2
<hr><hr><hr>
<a name="memavail">
<h1>
comp.lang.c FAQ list
<font color=blue>&middot;</font>
<a href="../../osdep/memavail.html"><!-- qtag -->Question 19.22</a>
</h1>
<p>
<font face=Helvetica size=8 color=blue><b>Q:</b></font>
How can I find out how much memory is available?
</p><p><hr>
<p>
<font face=Helvetica size=8 color=blue><b>A:</b></font>
Your operating system may provide a routine which returns this 
information,
but it's quite system-dependent.
(Also, the number may vary over time.)
If you're trying to predict whether
you'll be able to
allocate
a certain amount of memory,
just try it--call
<TT>malloc</TT>
(requesting that amount)
and check
the
return value.

<hr><hr><hr>
<a name="bigdatastr">
<h1>
comp.lang.c FAQ list
<font color=blue>&middot;</font>
<a href="../../osdep/bigdatastr.html"><!-- qtag -->Question 19.23</a>
</h1>
<p>
<font face=Helvetica size=8 color=blue><b>Q:</b></font>
How can I allocate arrays or structures bigger than 64K?
</p><p><hr>
<p>
<font face=Helvetica size=8 color=blue><b>A:</b></font>
A reasonable
computer
ought to
give you transparent access
to all available memory.
If you're
not so lucky,
you'll either have to rethink your program's use of memory,
or use various system-specific techniques.
</p><p>64K is
(still)
a pretty
big chunk of memory.
No matter how much memory your computer
has available,
it's asking a lot to be able to allocate huge amounts of
it
contiguously.
(The C Standard does not guarantee that
single objects can be 32K or larger,

or 64K for C99.)
Often it's a good idea to use data
structures which don't 
require that all memory be contiguous.
For dynamically-allocated multidimensional arrays,
you can
use pointers to pointers,
as illustrated in
questions <a href="faqcatca65.html?sec=aryptr#dynmuldimary">6.16</a> and <a href="faqcat38c2.html?sec=misc#ragged">20.2</a>.
Instead of a large array of structures,
you can use a linked list,
or an array of pointers to structures.
</p><p>If you're using a
PC-compatible
(8086-based)
system,
and running up against a

64K or
640K limit,
consider using
``huge'' memory model,
or expanded or extended

memory,
or malloc variants such as <TT>halloc</TT>
or <TT>farmalloc</TT>,
or a 32-bit
``flat'' compiler
(e.g. djgpp,
see question <a href="faqcatccbd.html?sec=resources#compilers">18.3</a>),
or some kind of a DOS extender,
or another operating system.
</p>

<p>References:

ISO Sec. 5.2.4.1
<br>
C9X Sec. 5.2.4.1
<hr><hr><hr>
<a name="dgroup">
<h1>
comp.lang.c FAQ list
<font color=blue>&middot;</font>
<a href="../../osdep/dgroup.html"><!-- qtag -->Question 19.24</a>
</h1>
<p>
<font face=Helvetica size=8 color=blue><b>Q:</b></font>
What does the error message
``DGROUP
data allocation
exceeds 64K''
mean,
and what can I do about it?
I thought that using large model meant that I could use
more than 64K of data!
</p><p><hr>
<p>
<font face=Helvetica size=8 color=blue><b>A:</b></font>
Even in large memory models,
MS-DOS compilers apparently toss certain data
(strings, some initialized global or <TT>static</TT> variables)
into a default data segment,
and it's this segment that is overflowing.
Either use less global data,
or,
if you're already limiting yourself to reasonable amounts
(and if the problem is due to something like the number of strings),

you may be able to coax the compiler
into not using the default data segment for so much.
Some compilers place only ``small'' data objects
in the default data segment,
and give you a way
(e.g. the <TT>/Gt</TT> option under Microsoft compilers)
to configure the threshold for ``small.''
<hr><hr><hr>
<a name="rawmemadr">
<h1>
comp.lang.c FAQ list
<font color=blue>&middot;</font>
<a href="../../osdep/rawmemadr.html"><!-- qtag -->Question 19.25</a>
</h1>
<p>
<font face=Helvetica size=8 color=blue><b>Q:</b></font>
How can I access memory
(a memory-mapped device,
or graphics memory)
located at a certain address?
<br>How can I do PEEK and POKE in C?
</p><p><hr>
<p>
<font face=Helvetica size=8 color=blue><b>A:</b></font>
Set a pointer,
of the appropriate type,
to the right number
(using an explicit cast
to assure the compiler
that you really do intend this nonportable conversion):
<pre>
	unsigned int *magicloc = (unsigned int *)0x12345678;
</pre>
Then, <TT>*magicloc</TT> refers to the location you want.
<a href="../../osdep/fn92.html" rel=subdocument>[footnote]</a>




If the location is a memory-mapped I/O register,
you will probably also want to use
the <TT>volatile</TT> qualifier:
``<TT>volatile&nbsp;unsigned&nbsp;int&nbsp;*magicloc</TT>''.

(If you want to refer to a byte at a certain address
rather than a word,
use <TT>unsigned&nbsp;char&nbsp;*</TT>.)
</p><p>Under
MS-DOS,
you may find a macro like <TT>MK_FP()</TT>
handy
for working with segments and
offsets.
As suggested by Gary Blaine,
you can also declare tricky array pointers which allow you to 
access screen memory using array
notation.
For example,
on an MS-DOS machine
in an 80x25 text mode,
given the declaration
<pre>
unsigned short (far * videomem)[80] =
		(unsigned short (far *)[80])0xb8000000;
</pre>
you can access the character and attribute byte
at row <TT>i</TT>, column <TT>j</TT>
with <TT>videomem[i][j]</TT>.
</p><p>


Many

operating systems execute user-mode programs
in a protected mode
where direct access to I/O devices
(or to <em>any</em> address outside the running process)
is simply not possible.
In such cases you
will
have to ask the operating system
to carry out I/O operations for you.
</p><p>See also questions
<a href="faqcatabdc.html?sec=ptrs#int2ptr">4.14</a>
and
<a href="faqcat1f1a.html?sec=null#accessloc0">5.19</a>.
</p>




<p>References:

K&amp;R1 Sec. A14.4 p. 210
<br>
K&amp;R2 Sec. A6.6 p. 199
<br>
ISO Sec. 6.3.4
<br>
Rationale Sec. 3.3.4
<br>
H&amp;S Sec. 6.2.7 pp. 171-2
<hr><hr><hr>
<a name="endiantest">
<h1>
comp.lang.c FAQ list
<font color=blue>&middot;</font>
<a href="../../osdep/endiantest.html"><!-- qtag -->Question 19.25b</a>
</h1>
<p>
<font face=Helvetica size=8 color=blue><b>Q:</b></font>
How can I determine whether a machine's
byte order
is big-endian or little-endian?
</p>
<p><hr>
<p>
<font face=Helvetica size=8 color=blue><b>A:</b></font>
See question <a href="faqcat38c2.html?sec=misc#endiantest">20.9</a>.
<hr><hr><hr>
<a name="accessloc0">
<h1>
comp.lang.c FAQ list
<font color=blue>&middot;</font>
<a href="../../osdep/accessloc0.html"><!-- qtag -->Question 19.26</a>
</h1>
<p>
<font face=Helvetica size=8 color=blue><b>Q:</b></font>
How can I access
an interrupt vector
located at
the machine's location 0?
If I set a pointer to <TT>0</TT>,
the compiler might translate it to some nonzero internal null
pointer value.
</p>
<p><hr>
<p>
<font face=Helvetica size=8 color=blue><b>A:</b></font>
See question <a href="faqcat1f1a.html?sec=null#accessloc0">5.19</a>.
<hr><hr><hr>
<a name="system">
<h1>
comp.lang.c FAQ list
<font color=blue>&middot;</font>
<a href="../../osdep/system.html"><!-- qtag -->Question 19.27</a>
</h1>
<p>
<font face=Helvetica size=8 color=blue><b>Q:</b></font>
How can I invoke
another program
(a standalone executable,
or an operating system command)
from within a C program?
</p><p><hr>
<p>
<font face=Helvetica size=8 color=blue><b>A:</b></font>
Use
the library function
<TT>system</TT>,
which does exactly that.
</p><p>Some systems also provide a family of <TT>spawn</TT>
routines which accomplish
approximately the same thing.
<TT>system</TT> is more ``portable''
in that it is required under the ANSI C Standard,
although the interpretation of the command
string--its
syntax and the set of commands
accepted--will
obviously vary tremendously.
</p><p>The
<TT>system</TT>
function

``calls''
a command in the manner of 
a subroutine,
and control
eventually
returns to the calling program.
If you want to overlay the calling program with another program
(that is,
a ``chain'' operation)
you'll need a
system-specific routine,
such as the <TT>exec</TT> family on Unix.
</p><p>Note
that <TT>system</TT>'s return value
is
at best
the command's exit status
(although even that is not guaranteed),
and usually has nothing to do with the output of the command.
</p><p>See also
questions
<a href="faqcatea63.html?sec=osdep#system2">19.28</a>
and
<a href="faqcatea63.html?sec=osdep#popen">19.30</a>.
</p>







<p>References:

K&amp;R1 Sec. 7.9 p. 157
<br>
K&amp;R2 Sec. 7.8.4 p. 167, Sec. B6 p. 253
<br>
ISO Sec. 7.10.4.5
<br>
H&amp;S Sec. 19.2 p. 407
<br>
PCS Sec. 11 p. 179
<hr><hr><hr>
<a name="system2">
<h1>
comp.lang.c FAQ list
<font color=blue>&middot;</font>
<a href="../../osdep/system2.html"><!-- qtag -->Question 19.28</a>
</h1>
<p>
<font face=Helvetica size=8 color=blue><b>Q:</b></font>
How can I call <TT>system</TT> when parameters
(filenames, etc.)
of the executed command
aren't known until run time?
</p><p><hr>
<p>
<font face=Helvetica size=8 color=blue><b>A:</b></font>
Just use <TT>sprintf</TT>
(or perhaps <TT>strcpy</TT> and <TT>strcat</TT>)
to build the command string in a
buffer,
then call <TT>system</TT> with that 
buffer.
(Make sure the buffer is allocated with enough space;
see also questions <a href="faqcatbafd.html?sec=malloc#malloc2">7.2</a> and <a href="faqcat1d60.html?sec=stdio#sprintfsize">12.21</a>.)
</p><p>Here is
a contrived example
suggesting how you might
build a data file,
then sort it
(assuming the existence of a sort utility,
and Unix-
or MS-DOS-style
input/output redirection):
<pre>
	char *datafile = "file.dat";
	char *sortedfile = "file.sort";
	char cmdbuf[50];
	FILE *fp = fopen(datafile, "w");

	/* ...write to fp to build data file... */

	fclose(fp);

	sprintf(cmdbuf, "sort &lt; %s &gt; %s", datafile, sortedfile);
	system(cmdbuf);

	fp = fopen(sortedfile, "r");
	/* ...now read sorted data from fp... */
</pre>