user/wc.c

C · 55 lines · annotated 100% · user program / library · upstream

About this file

wc (“word count”) counts the lines, words and bytes of each file named on its command line, or of standard input if there are none, and prints them in that order followed by the name: wc README prints 48 336 2441 README in a freshly built xv6, and echo hi there | wc prints 1 2 9 (the name is empty for standard input).

It reads input with the same loop as user/cat.c, but instead of writing each chunk out it scans it byte by byte. Lines are counted by newlines. Words are counted with a two-state machine: “inside a word” or “between words”; a word starts each time the state changes from “between” to “inside”.

Read before: user/cat.c. Read next: user/grep.c, which also processes its input line by line.

Show notes inline

1#include "kernel/types.h"
2#include "kernel/stat.h"
3#include "kernel/fcntl.h"
4#include "user/user.h"
5
6char buf[512];
7
8void
9wc(int fd, char *name)
10{
11  int i, n;
12  int l, w, c, inword;
13
14  l = w = c = 0;
15  inword = 0;
16  while ((n = read(fd, buf, sizeof(buf))) > 0) {
17    for (i = 0; i < n; i++) {
18      c++;
19      if (buf[i] == '\n')
20        l++;
21      if (strchr(" \r\t\n\v", buf[i]))
22        inword = 0;
23      else if (!inword) {
24        w++;
25        inword = 1;
26      }
27    }
28  }
29  if (n < 0) {
30    printf("wc: read error\n");
31    exit(1);
32  }
33  printf("%d %d %d %s\n", l, w, c, name);
34}
35
36int
37main(int argc, char *argv[])
38{
39  int fd, i;
40
41  if (argc <= 1) {
42    wc(0, "");
43    exit(0);
44  }
45
46  for (i = 1; i < argc; i++) {
47    if ((fd = open(argv[i], O_RDONLY)) < 0) {
48      printf("wc: cannot open %s\n", argv[i]);
49      exit(1);
50    }
51    wc(fd, argv[i]);
52    close(fd);
53  }
54  exit(0);
55}

Lines 1–6

Headers and the input buffer

The same headers as the other utilities (kernel/fcntl.h for O_RDONLY). buf is a 512-byte global chunk buffer, as in user/cat.c: its size only affects how many read system calls are made, never the counts.

Lines 8–15

wc(): the counters

l, w and c count lines, words and characters (bytes, really: xv6 has no notion of multi-byte characters). inword is the state of the word machine: 1 while the previous byte was part of a word, 0 otherwise. It starts at 0, so the first non-space byte of the input begins a word.

All four are set once per file, outside the read loop. That matters for inword: read can split the input at any byte, including in the middle of a word. Because the state carries over from one chunk to the next, a word cut in two by the chunk boundary is still counted once.

Line 14

Counts start at zero for each file.

Line 15

Start “between words”.

Lines 16–28

Scan every byte with the word state machine

Every byte counts as a character. Every \n ends a line, so a last line without a newline is not counted as a line (the same rule as Unix wc).

The word machine has two states and two kinds of input:

state	next byte	action	new state
between words	space	none	between words
between words	other	count a word	inside a word
inside a word	space	none	between words
inside a word	other	none	inside a word

“Space” here means one of the five characters in " \r\t\n\v": space, carriage return, tab, newline, vertical tab. (Form feed, \f, is missing from the list, so wc treats it as part of a word.) The test uses strchr, which returns a pointer to the byte if it is in the string and 0 otherwise. xv6’s strchr stops at the string’s terminating NUL without comparing it, so a NUL byte in the input counts as a word character; the standard C strchr would find the terminator and treat NUL as a space.

Example: in hi there\n the bytes h and t each move the machine from “between” to “inside”, giving 2 words; the line count is 1 and the byte count 9.

Line 16

Read the next chunk (sys_read) until end of input or error.

Line 17

Visit each of the n bytes actually read (not sizeof(buf)).

Line 18

Every byte is a character.

Line 19

A newline ends a line.

Line 21

A whitespace byte: the machine moves to (or stays in) “between words”.

Line 23

A non-whitespace byte while between words: a new word starts here.

Line 24

Count it.

Line 25

Now inside a word; further non-space bytes do not count again.

Lines 29–34

Report a read error, or print the counts

As in user/cat.c, the read loop ends on 0 (end of input) or -1 (error). An error prints a message and exits with status 1 (exit status), but with printf, so the message goes to standard output rather than standard error.

Otherwise one line of results goes to standard output: lines, words, bytes, name. Unlike Unix wc, there is no total line when several files are given.

Line 29

The loop ended because read failed.

Line 30

Error message, on standard output.

Line 33

Lines, words, bytes, name.

Lines 36–55

main(): standard input, or each named file

The same shape as main in user/cat.c: no arguments means count descriptor 0 (with an empty name, so the output line ends in a space); otherwise open each file read-only (sys_open), count it, close it. A file that cannot be opened ends the program with status 1, and that message also goes to standard output.

Line 41

No file names.

Line 42

Count standard input; the empty name leaves a trailing space in the output.

Line 47

Open each file read-only.

Line 48

Error on standard output, then stop with status 1.

Line 51

Count this file and print its line.

Line 52

Free the descriptor for the next file (sys_close).