DODATEK A

STANDARDNA C KNJIŽNICA

Standardna C knjižnica za sistem Partner temelji na implementaciji libcpm3-z80 in pokriva večino standardnih glav ANSI C. Vključite posamezno glavo z #include <ime.h>. V tem dodatku so opisane vse javno deklarirane funkcije, tipi in makri.

A.1. STDIO.H

Standardni vhod/izhod. Datotečni tip FILE je nepregleden — dostopajte prek funkcij. Globalni tokovi: stdin, stdout, stderr. Konstante: EOF = 0x1A, SEEK_SET = 0, SEEK_CUR = 1, SEEK_END = 2.

fopen()

FILE *fopen(const char *path, const char *mode);

• path – pot do datoteke
• mode – način: "r" branje, "w" pisanje, "a" dodajanje, "r+" branje+pisanje, "w+" ustvari+r/w, "a+" dodaj+r/w

Vrne FILE * ob uspehu ali NULL ob napaki. Odpre datoteko in vrne kazalec na datotečni tok.

Sorodne: fclose(), fread(), fwrite()

FILE *fp = fopen("data.txt", "r");
if (fp) { /* ... */ fclose(fp); }

fclose()

int fclose(FILE *fp);

Vrne 0 ob uspehu ali EOF ob napaki. Zapre datotečni tok in sprosti vire. Vsak fopen() mora imeti ustrezen fclose().

Sorodne: fopen(), fflush()

fclose(fp);

fflush()

int fflush(FILE *fp);

Vrne 0 ob uspehu ali EOF ob napaki. Izprazni medpomnilnik toka in zapiše morebitne čakajoče podatke na disketo.

Sorodne: fclose()

fflush(stdout);

fread()

size_t fread(void *ptr, size_t size, size_t nmemb, FILE *fp);

• ptr – ciljni pomnilnik; size – velikost zapisa; nmemb – število zapisov

Vrne število prebranih zapisov (manj od nmemb pri EOF ali napaki). Prebere binarne podatke iz toka.

Sorodne: fwrite(), fopen(), feof()

char buf[128];
size_t n = fread(buf, 1, sizeof(buf), fp);

fwrite()

size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *fp);

• ptr – izvorni pomnilnik; size – velikost zapisa; nmemb – število zapisov

Vrne število zapisanih zapisov. Zapiše binarne podatke v tok.

Sorodne: fread(), fflush()

fwrite(buf, 1, n, fp);

fseek()

int fseek(FILE *fp, long offset, int whence);

• offset – odmik; whence – SEEK_SET, SEEK_CUR ali SEEK_END

Vrne 0 ob uspehu. Premakne kazalec toka na novo pozicijo.

Sorodne: ftell(), rewind()

fseek(fp, 0, SEEK_SET);  /* na začetek */

ftell()

long ftell(FILE *fp);

Vrne trenutno pozicijo v toku ali -1 ob napaki.

Sorodne: fseek(), rewind()

long pos = ftell(fp);

rewind()

void rewind(FILE *fp);

Vrne brez vrednosti. Premakne kazalec toka na začetek in ponastavi indikatorje napake.

Sorodne: fseek()

rewind(fp);

feof()

int feof(FILE *fp);

Vrne neničelno vrednost, če je bil dosežen konec datoteke. Preverite po fread() ali fgetc().

Sorodne: ferror(), clearerr()

while (!feof(fp)) { fread(...); }

ferror()

int ferror(FILE *fp);

Vrne neničelno vrednost, če je prišlo do napake na toku.

Sorodne: feof(), clearerr(), perror()

if (ferror(fp)) perror("napaka");

clearerr()

void clearerr(FILE *fp);

Vrne brez vrednosti. Ponastavi indikatorja EOF in napake na toku.

Sorodne: feof(), ferror()

clearerr(fp);

fgetc()

int fgetc(FILE *fp);

Vrne naslednji znak iz toka kot unsigned char ali EOF. Prebere en znak iz datotečnega toka.

Sorodne: fputc(), ungetc(), getc()

int c;
while ((c = fgetc(fp)) != EOF) putchar(c);

fgets()

char *fgets(char *str, int n, FILE *fp);

• str – ciljna vrsta; n – največ n-1 znakov + '\0'

Vrne str ali NULL pri EOF/napaki. Prebere vrstico do '\n' ali n-1 znakov.

Sorodne: fputs(), gets()

char line[80];
while (fgets(line, sizeof(line), fp)) { /* ... */ }

fputc()

int fputc(int c, FILE *fp);

Vrne zapisani znak ali EOF. Zapiše en znak v tok.

Sorodne: fgetc(), putc()

fputc('A', fp);

fputs()

int fputs(const char *s, FILE *fp);

Vrne nenegativno vrednost ob uspehu ali EOF. Zapiše niz v tok brez zaključnega '\n'.

Sorodne: fgets(), puts()

fputs("besedilo", fp);

puts()

int puts(const char *s);

Vrne nenegativno vrednost ob uspehu. Izpiše niz na stdout in doda '\n'.

Sorodne: fputs(), printf()

puts("ŽIVJO, SVET!");

gets()

char *gets(char *str);

Vrne str ali NULL. Prebere vrstico s stdin do '\n' (ne preverja dolžine — pazite na prekoračitev medpomnilnika).

Sorodne: fgets()

char buf[80];
gets(buf);

getchar()

int getchar(void);

Vrne naslednji znak s stdin ali EOF. Enakovredno getc(stdin).

Sorodne: putchar(), fgetc()

int c = getchar();

putchar()

int putchar(int c);

Vrne zapisani znak ali EOF. Izpiše znak na stdout. Enakovredno putc(c, stdout).

Sorodne: getchar(), fputc()

putchar('A');

getc() / getc_unlocked()

int getc(FILE *fp);
int getc_unlocked(FILE *fp);

Vrne naslednji znak ali EOF. Enakovredno fgetc(). Različica _unlocked deluje brez zaklepanja.

Sorodne: putc(), fgetc()

int c = getc(fp);

putc()

int putc(int c, FILE *fp);

Vrne zapisani znak ali EOF. Enakovredno fputc().

Sorodne: getc(), fputc()

putc('X', fp);

getw()

int getw(FILE *fp);

Vrne prebrani 16-bitni podatek ali EOF. Prebere eno 16-bitno besedo iz binarnega toka.

Sorodne: fread()

int w = getw(fp);

ungetc()

int ungetc(int c, FILE *fp);

Vrne c ob uspehu ali EOF. Vrne znak nazaj v vhodni tok — naslednji fgetc() bo prebral ta znak.

Sorodne: fgetc(), getc()

int c = fgetc(fp);
if (c != ':') ungetc(c, fp);

printf() / fprintf() / sprintf()

int printf(char *fmt, ...);
int fprintf(FILE *fp, char *fmt, ...);
int sprintf(char *buf, char *fmt, ...);

• fmt – oblikovni niz; podprte oznake: %d, %i, %u, %o, %x, %X, %c, %s, %f, %%

Vrne število izpisanih znakov. printf() piše na stdout, fprintf() v tok, sprintf() v niz.

Sorodne: vprintf(), puts()

printf("Vrednost: %d\n", 42);
sprintf(buf, "x=%d y=%d", x, y);

vprintf() / vfprintf() / vsprintf()

int vprintf(const char *fmt, va_list ap);
int vfprintf(FILE *fp, const char *fmt, va_list ap);
int vsprintf(char *buf, const char *fmt, va_list ap);

Vrne število izpisanih znakov. Različice printf z eksplicitnim va_list za pisanje lastnih variadičnih funkcij.

Sorodne: printf(), va_start(), va_end()

void moj_log(const char *fmt, ...) {
    va_list ap; va_start(ap, fmt);
    vprintf(fmt, ap); va_end(ap);
}

perror()

void perror(const char *s);

Vrne brez vrednosti. Izpiše niz s in besedilno sporočilo zadnje napake (errno) na stderr.

Sorodne: strerror(), errno

FILE *fp = fopen("x.txt","r");
if (!fp) perror("fopen");

tmpfile()

FILE *tmpfile(void);

Vrne FILE * ali NULL. Ustvari začasno datoteko, ki se ob zaprtju samodejno izbriše.

Sorodne: tmpnam(), fclose()

FILE *tmp = tmpfile();

tmpnam()

char *tmpnam(char *s);

Vrne kazalec na edinstveno ime datoteke. Ustvari edinstveno ime za začasno datoteko; če je s != NULL, shrani ime tja.

Sorodne: tmpfile()

char name[16]; tmpnam(name);

setbuf() / setvbuf()

void setbuf(FILE *fp, char *buf);
int setvbuf(FILE *fp, char *buf, int mode, size_t size);

• buf – medpomnilnik (NULL = brez medpomnjenja); mode – _IOFBF polno, _IOLBF vrstično, _IONBF brez

Vrne setvbuf() 0 ob uspehu. Nastavi medpomnjenje toka. Klicati pred prvim branjem/pisanjem.

Sorodne: fflush()

setvbuf(fp, NULL, _IONBF, 0);  /* brez medpomnjenja */

remove()

int remove(const char *path);

Vrne 0 ob uspehu ali -1 ob napaki. Izbriše datoteko s podano potjo.

Sorodne: unlink()

remove("stara.tmp");

A.2. STDLIB.H

Splošne pomožne funkcije: zaključek programa, pretvorbe, naključna števila, dinamični pomnilnik, iskanje in urejanje.

exit() / abort()

void exit(int status);
void abort(void);

Vrne brez vrednosti (ne vrne). exit() pravilno zaključi program s kodo status (0 = uspeh). abort() takoj prekine program.

Sorodne: atexit()

if (napaka) exit(1);
exit(0);

atexit()

int atexit(void (*func)(void));

Vrne 0 ob uspehu. Registrira funkcijo, ki se pokliče ob normalnem izhodu iz programa.

Sorodne: exit()

void cleanup(void) { /* sprostitev ... */ }
atexit(cleanup);

abs() / labs()

int abs(int i);
long labs(long i);

Vrne absolutno vrednost argumenta. abs() za int, labs() za long.

Sorodne: fabs()

int a = abs(-5);   /* a = 5 */

atoi() / atol() / atof()

int   atoi(const char *str);
long  atol(const char *str);
float atof(const char *str);

Vrne pretvorjeno vrednost (0 ob napaki). Pretvori niz v celo ali decimalno število.

Sorodne: strtol(), strtoul(), itoa()

int n = atoi("42");
float f = atof("3.14");

itoa()

char *itoa(int num, char *str, int base);

• num – vrednost; str – ciljni niz; base – osnova (2–16)

Vrne str. Nestandarden razširek: pretvori celo število v niz z dano osnovo.

Sorodne: atoi(), sprintf()

char buf[10]; itoa(255, buf, 16); /* "ff" */

strtol() / strtoul()

long          strtol (char *nptr, char **endptr, int base);
unsigned long strtoul(const char *nptr, char **endptr, int base);

• nptr – vhodni niz; endptr – kazalec za prvim neprebranim znakom; base – osnova 2–36 ali 0

Vrne pretvorjeno vrednost. Naprednejša pretvorba niza v celo število s podajanjem osnove in zaznavanjem konca.

Sorodne: atoi(), atol()

char *end;
long v = strtol("0xFF", &end, 16); /* v = 255 */

rand() / srand()

int  rand(void);
void srand(unsigned int seed);

Vrne rand() naključno celo število. srand() nastavi seme generatorja naključnih števil.

Sorodne: –

srand(42);
int r = rand() % 10;  /* 0..9 */

malloc() / calloc() / free()

void *malloc(size_t size);
void *calloc(size_t num, size_t size);
void  free(void *ptr);

Vrne malloc()/calloc() kazalec na blok ali NULL. malloc() rezervira pomnilnik, calloc() rezervira in inicializira z ničlami. free() sprosti blok.

Sorodne: –

int *p = (int *)malloc(10 * sizeof(int));
if (p) { /* ... */ free(p); }

qsort()

void qsort(void *base, size_t nitems, size_t size,
           int (*compar)(const void *, const void *));

• base – kazalec na polje; nitems – število elementov; size – velikost elementa; compar – primerjalna funkcija

Vrne brez vrednosti. Uredi polje s hitrim urejanjem (quicksort).

Sorodne: bsearch()

int cmp(const void *a, const void *b) {
    return *(int*)a - *(int*)b; }
qsort(polje, n, sizeof(int), cmp);

bsearch()

void *bsearch(const void *key, const void *base,
              size_t nitems, size_t size,
              int (*compar)(const void *, const void *));

Vrne kazalec na najdeni element ali NULL. Binarna iskanje v urejenem polju.

Sorodne: qsort()

int k = 5;
int *r = (int *)bsearch(&k, polje, n, sizeof(int), cmp);

div() / ldiv()

div_t  div (int numer, int denom);
ldiv_t ldiv(long numer, long denom);

Vrne strukturo z .quot (količnik) in .rem (ostanek). Deli in vrne oba rezultata hkrati.

Sorodne: abs()

div_t r = div(17, 5); /* r.quot=3, r.rem=2 */

_splitpath()

int _splitpath(const char *path, char *drive,
               int *user, char *fname, char *ext);

• path – celotna pot; drive – pogon (1 znak); user – CP/M področje; fname – ime (8 znakov); ext – pripona (3 znaki)

Vrne 0 ob uspehu. Nestandarden razširek: razčleni CP/M pot v sestavne dele.

Sorodne: fopen()

char drv[2], fn[9], ext[4]; int usr;
_splitpath("A:PROG.COM", drv, &usr, fn, ext);

A.3. STRING.H

Funkcije za delo z znaki in nizi v pomnilniku.

memset()

void *memset(void *s, int c, size_t n);

Vrne s. Nastavi n bajtov na vrednost c.

Sorodne: memcpy(), memcmp()

memset(buf, 0, sizeof(buf));

memcpy()

void *memcpy(void *dest, const void *src, size_t n);

Vrne dest. Kopira n bajtov iz src v dest. Področji se ne smeta prekrivati.

Sorodne: memset(), memmove()

memcpy(dst, src, 64);

memchr()

void *memchr(const void *s, int c, size_t n);

Vrne kazalec na prvo pojavitev c v prvih n bajtih ali NULL.

Sorodne: strchr()

char *p = (char *)memchr(buf, '\n', n);

memcmp()

int memcmp(const void *s1, const void *s2, size_t n);

Vrne 0 če enaka, negativno/pozitivno če s1 < s2 oz. s1 > s2. Primerja n bajtov.

Sorodne: strcmp()

if (memcmp(a, b, 4) == 0) { /* enako */ }

strlen()

size_t strlen(const char *s);

Vrne dolžino niza brez zaključnega '\0'.

Sorodne: strcpy()

size_t n = strlen("hello"); /* n = 5 */

strcpy() / strncpy()

char *strcpy (char *dest, const char *src);
char *strncpy(char *dst,  const char *src, size_t num);

Vrne dest. Kopira niz. strncpy() omeji kopiranje na največ num znakov.

Sorodne: strlen(), strcat()

char buf[10];
strncpy(buf, vhod, sizeof(buf) - 1);

strcmp() / strncmp()

int strcmp (const char *s1, const char *s2);
int strncmp(const char *s1, const char *s2, size_t n);

Vrne 0 za enaka niza. Primerja niza leksikografsko. strncmp() primerja največ n znakov.

Sorodne: memcmp()

if (strcmp(ukaz, "DIR") == 0) { /* ... */ }

strchr() / strrchr()

char *strchr (const char *s, int c);
char *strrchr(const char *s, int c);

Vrne kazalec na znak ali NULL. strchr() poišče prvo, strrchr() zadnjo pojavitev znaka c.

Sorodne: strstr(), memchr()

char *p = strchr(niz, '.');

strtok() / strsep()

char *strtok(char *s, const char *delim);
char *strsep(char **stringp, const char *delim);

Vrne kazalec na naslednji žeton ali NULL. Razcepi niz na žetone po ločilih. strtok() hrani stanje interno; strsep() (Unix razširek) posodobi kazalec.

Sorodne: strchr()

char *tok = strtok(niz, ",");
while (tok) { /* ... */ tok = strtok(NULL, ","); }

strcspn()

size_t strcspn(const char *s1, const char *s2);

Vrne dolžino začetnega dela s1, ki ne vsebuje nobenih znakov iz s2.

Sorodne: strchr()

size_t n = strcspn("hello,world", ",");

strerror()

char *strerror(int errnum);

Vrne besedilno sporočilo za napako errnum.

Sorodne: perror(), errno

printf("Napaka: %s\n", strerror(errno));

strrev()

void strrev(char *s, size_t n);

• n – dolžina niza

Vrne brez vrednosti. Nestandarden razširek: obrne niz na mestu.

Sorodne: strlen()

char s[] = "PARTNER";
strrev(s, strlen(s)); /* "RENTRAP" */

stoupper() / stolower()

void stoupper(char *s);
void stolower(char *s);

Vrne brez vrednosti. Nestandarden razširek: pretvori vse znake niza v velike oz. male črke na mestu.

Sorodne: toupper(), tolower()

char s[] = "Partner";
stoupper(s); /* "PARTNER" */

A.4. CTYPE.H

Funkcije za razvrščanje in pretvorbo znakov. Vse sprejemajo int in vračajo bool (razen toupper()/tolower()).

isalpha() / isalnum() / isdigit() / isxdigit()

bool isalpha (int c);   /* je črka (a-z, A-Z) */
bool isalnum (int c);   /* je črka ali cifra */
bool isdigit (int c);   /* je decimalna cifra 0-9 */
bool isxdigit(int c);   /* je šestnajstiška cifra 0-9, a-f, A-F */

Vrne true/false. Preverijo razred znaka.

Sorodne: isprint(), iscntrl()

if (isdigit(c)) n = c - '0';

islower() / isupper() / tolower() / toupper()

bool islower(int c);   /* je mala črka */
bool isupper(int c);   /* je velika črka */
int  tolower(int c);   /* pretvori v malo */
int  toupper(int c);   /* pretvori v veliko */

Vrne logično vrednost ali pretvorjeni znak.

Sorodne: stoupper(), stolower()

char up = (char)toupper('a'); /* 'A' */

isprint() / isgraph() / isspace() / ispunct() / iscntrl()

bool isprint(int c);   /* je izpisljiv (vključno s presledkom) */
bool isgraph(int c);   /* je grafični (brez presledka) */
bool isspace(int c);   /* je belo ime (\t, \n, \r, ' ', ...) */
bool ispunct(int c);   /* je ločilo */
bool iscntrl(int c);   /* je kontrolni znak */

Vrne true/false. Preverjanje razredov znakov.

Sorodne: isalpha()

if (!isprint(c)) c = '?';

A.5. MATH.H

Matematične funkcije s plavajočo vejico. Vse sprejemajo in vračajo float. Konstanta HUGE_VAL = 3.402823466e+38 označuje prekoračitev obsega.

fabs() / ceil() / floor()

float fabs (float x);   /* absolutna vrednost */
float ceil (float x);   /* zaokrožitev navzgor */
float floor(float x);   /* zaokrožitev navzdol */

Vrne ustrezno pretvorjeno vrednost.

Sorodne: abs(), modf()

float a = fabs(-3.7f);  /* 3.7 */
float b = ceil(3.2f);   /* 4.0 */
float c = floor(3.9f);  /* 3.0 */

sqrt() / pow()

float sqrt(float x);
float pow (float x, float y);

Vrne kvadratni koren oz. potenco x^y.

Sorodne: exp(), log()

float h = sqrt(a*a + b*b);
float p = pow(2.0f, 8.0f); /* 256.0 */

sin() / cos() / tan() / cot()

float sin(float f);   /* sinus (radiani) */
float cos(float x);   /* kosinus (radiani) */
float tan(float x);   /* tangens (radiani) */
float cot(float x);   /* kotangens (radiani) */

Vrne trigonometrično vrednost. Argumenti so v radianih.

Sorodne: atan()

float y = sin(3.14159f / 2.0f); /* ~1.0 */

exp() / log() / log10()

float exp  (float x);   /* e^x */
float log  (float x);   /* naravni logaritem */
float log10(float x);   /* desetiški logaritem */

Vrne rezultat. Za x <= 0 sta log() in log10() nedefinirana.

Sorodne: pow()

float e = exp(1.0f);       /* ~2.718 */
float l = log10(100.0f);   /* 2.0 */

frexp() / ldexp() / modf()

float frexp(float x, int *pw2);
float ldexp(float x, int pw2);
float modf (float x, float *y);

• frexp() – razdeli x na mantiso [0.5, 1) in eksponent; shrani eksponent v *pw2
• ldexp() – vrne x × 2^pw2
• modf() – loči celotni del (shranjen v *y) od ulomka; vrne ulomek

Sorodne: ceil(), floor()

float frac, integ;
frac = modf(3.75f, &integ); /* frac=0.75, integ=3.0 */

A.6. ASSERT.H

assert()

#include <assert.h>
assert(izraz);

Makro. Če je izraz false, izpiše sporočilo z imenom datoteke in vrstico ter pokliče exit(1). Ko je definiran NDEBUG, se makro ne prevede.

Sorodne: exit()

assert(p != NULL);
assert(n > 0 && n < 256);

A.7. ERRNO.H

Globalna spremenljivka errno vsebuje kodo zadnje napake. Postavljata jo funkcije, ki zaznajo napako. Kode napak:

ENOENT = 2	Datoteka ali imenik ne obstaja
EIO = 5	V/I napaka
EBADF = 9	Neveljaven deskriptor datoteke
EAGAIN = 11	Poskusite znova
ENOMEM = 12	Ni dovolj pomnilnika
EINVAL = 22	Neveljaven argument
ENFILE = 23	Preveč odprtih datotek
EDOM = 33	Argument izven domene
ERANGE = 34	Rezultat izven obsega

#include <errno.h>
extern int errno;
if (errno == ENOENT) puts("Datoteka ne obstaja.");

A.8. SETJMP.H

Nelokalny skoki — mehanizem za izhod iz gnezdenih klicev brez razvijanja sklada s return.

setjmp() / longjmp()

typedef uint16_t jmp_buf[3];
int  setjmp (jmp_buf env);
void longjmp(jmp_buf env, int val);

• setjmp() – shrani kontekst izvajanja; vrne 0 ob neposrednem klicu ali vrednost val ob vrnitvi prek longjmp()
• longjmp() – obnovi kontekst in se vrne na mesto setjmp() z vrednostjo val

Vrne setjmp() 0 ali val.

jmp_buf env;
if (setjmp(env) == 0) {
    /* normalno izvajanje */
    if (napaka) longjmp(env, 1);
} else {
    /* sem pridemo ob napaki */
}

A.9. UNISTD.H

POSIX-podobne nizkoravenske datotečne funkcije z deskriptorji. Vključite s #include <unistd.h>.

open() / creat() / close()

int open (const char *pathname, int flags, ...);
int creat(const char *pathname);
int close(int fd);

• flags – kombinacija: O_RDONLY, O_WRONLY, O_RDWR, O_CREAT, O_TRUNC

Vrne deskriptor datoteke (≥0) ali -1 ob napaki. Odpre oz. ustvari datoteko in vrne deskriptor.

Sorodne: fopen(), read(), write()

int fd = open("data.bin", O_RDONLY);
if (fd >= 0) { /* ... */ close(fd); }

read() / write()

ssize_t read (int fd, void *buf, size_t count);
ssize_t write(int fd, const void *buf, size_t count);

Vrne število prenesenih bajtov ali -1. Prebere oz. zapiše do count bajtov.

Sorodne: fread(), fwrite()

char buf[128];
ssize_t n = read(fd, buf, sizeof(buf));

lseek() / fsync()

off_t lseek(int fd, off_t offset, int whence);
int   fsync(int fd);

Vrne lseek() novo pozicijo ali -1. Premakne kazalec deskriptorja (lseek()) oz. sinhronizira z diskom (fsync()).

Sorodne: fseek()

lseek(fd, 0, SEEK_SET);  /* na začetek */

unlink()

int unlink(const char *path);

Vrne 0 ob uspehu. Izbriše datoteko. Enakovredno remove().

Sorodne: remove()

unlink("tmp.dat");

_msleep()

void _msleep(int millisec);

Vrne brez vrednosti. Nestandarden razširek: čaka podano število milisekund. Privzeta implementacija je prazna; za dejansko delovanje implementirajte platformno specifično različico.

Sorodne: timer_ms() v partner/clock.h

_msleep(100);  /* počakaj 100ms */

A.10. DIRENT.H

POSIX-podobno prelistavanje imenika.

opendir() / readdir() / closedir()

DIR            *opendir (const char *path);
struct dirent  *readdir (DIR *dir);
int             closedir(DIR *dir);

struct dirent ima polje d_name[256] z imenom datoteke.

Vrne opendir() kazalec ali NULL; readdir() naslednji vnos ali NULL na koncu; closedir() 0 ob uspehu.

DIR *d = opendir("A:");
struct dirent *e;
while ((e = readdir(d))) puts(e->d_name);
closedir(d);

A.11. FCNTL.H

open() (fcntl.h)

Glej razdelek A.9 (unistd.h). Ista funkcija open() je deklarirana v obeh glavah za združljivost s POSIX.

Zastavice, definirane v fcntl.h:

O_RDONLY	0x0000	Samo branje
O_WRONLY	0x0001	Samo pisanje
O_RDWR	0x0002	Branje in pisanje
O_CREAT	0x0200	Ustvari, če ne obstaja
O_TRUNC	0x0400	Skrajšaj na dolžino 0

creat()

int creat(const char *pathname);

Vrne deskriptor ali -1. Ustvari novo datoteko ali odpre obstoječo za pisanje (skrajšano). Enakovredno open(path, O_WRONLY|O_CREAT|O_TRUNC).

int fd = creat("izh.bin");

A.12. TIPI IN MAKRI

Preostale standardne glave definirajo tipe in makre brez funkcij.

stdint.h – celoštevilski tipi

int8_t	predznačen 8-bitni
uint8_t	nepredznačen 8-bitni
int16_t	predznačen 16-bitni
uint16_t	nepredznačen 16-bitni
int32_t	predznačen 32-bitni
uint32_t	nepredznačen 32-bitni

stddef.h – temeljni tipi

size_t	uint16_t – rezultat operatorja sizeof
ptrdiff_t	uint16_t – razlika dveh kazalcev

stdbool.h – logični tip

#define bool   int
#define true   1
#define false  0

stdarg.h – spremenljivo število argumentov

typedef unsigned char *va_list;
va_start(marker, last);   /* inicializiraj pred prvim arg */
va_arg(marker, type);     /* naslednji argument tipa type */
va_end(marker);           /* zaključi */

void tisk(const char *fmt, ...) {
    va_list ap;
    va_start(ap, fmt);
    vprintf(fmt, ap);
    va_end(ap);
}