diff --git a/usr.sbin/makemandb/Makefile b/usr.sbin/makemandb/Makefile index a5645c0f2b41..3257e122e004 100644 --- a/usr.sbin/makemandb/Makefile +++ b/usr.sbin/makemandb/Makefile @@ -1,4 +1,4 @@ -# $NetBSD: Makefile,v 1.8 2017/05/21 15:28:43 riastradh Exp $ +# $NetBSD: Makefile,v 1.9 2017/06/18 16:24:10 abhinav Exp $ .include @@ -6,9 +6,9 @@ MDOCDIR=${NETBSDSRCDIR}/external/bsd/mdocml MANCONFDIR=${NETBSDSRCDIR}/usr.bin/man PROGS= makemandb apropos whatis -SRCS.makemandb= makemandb.c apropos-utils.c manconf.c -SRCS.apropos= apropos.c apropos-utils.c manconf.c -SRCS.whatis= whatis.c apropos-utils.c manconf.c +SRCS.makemandb= makemandb.c apropos-utils.c manconf.c custom_apropos_tokenizer.c +SRCS.apropos= apropos.c apropos-utils.c manconf.c custom_apropos_tokenizer.c +SRCS.whatis= whatis.c apropos-utils.c manconf.c custom_apropos_tokenizer.c MAN.makemandb= makemandb.8 MAN.apropos= apropos.1 MAN.whatis= whatis.1 @@ -39,7 +39,14 @@ stopwords.c: stopwords.txt echo '};' \ ) > ${.TARGET} -DPSRCS+= stopwords.c -CLEANFILES+= stopwords.c +nostem.c: nostem.txt + ( set -e; ${TOOL_NBPERF} -n nostem_hash -s -p ${.ALLSRC}; \ + echo 'static const char *nostem[] = {'; \ + ${TOOL_SED} -e 's|^\(.*\)$$| "\1",|' ${.ALLSRC}; \ + echo '};' \ + ) > ${.TARGET} + +DPSRCS+= stopwords.c nostem.c +CLEANFILES+= stopwords.c nostem.c .include diff --git a/usr.sbin/makemandb/apropos-utils.c b/usr.sbin/makemandb/apropos-utils.c index 9c8e7e1c9cfb..3af721cfcd4e 100644 --- a/usr.sbin/makemandb/apropos-utils.c +++ b/usr.sbin/makemandb/apropos-utils.c @@ -1,4 +1,4 @@ -/* $NetBSD: apropos-utils.c,v 1.37 2017/05/01 05:28:00 abhinav Exp $ */ +/* $NetBSD: apropos-utils.c,v 1.38 2017/06/18 16:24:10 abhinav Exp $ */ /*- * Copyright (c) 2011 Abhinav Upadhyay * All rights reserved. @@ -31,7 +31,7 @@ */ #include -__RCSID("$NetBSD: apropos-utils.c,v 1.37 2017/05/01 05:28:00 abhinav Exp $"); +__RCSID("$NetBSD: apropos-utils.c,v 1.38 2017/06/18 16:24:10 abhinav Exp $"); #include #include @@ -50,7 +50,9 @@ __RCSID("$NetBSD: apropos-utils.c,v 1.37 2017/05/01 05:28:00 abhinav Exp $"); #undef tab // XXX: manconf.h #include "apropos-utils.h" +#include "custom_apropos_tokenizer.h" #include "manconf.h" +#include "fts3_tokenizer.h" typedef struct orig_callback_data { void *data; @@ -79,6 +81,28 @@ static const double col_weights[] = { 1.00 //machine }; +static int +register_tokenizer(sqlite3 *db) +{ + int rc; + sqlite3_stmt *stmt; + const sqlite3_tokenizer_module *p; + const char *name = "custom_apropos_tokenizer"; + get_custom_apropos_tokenizer(&p); + const char *sql = "SELECT fts3_tokenizer(?, ?)"; + + sqlite3_db_config(db, SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER, 1, 0); + rc = sqlite3_prepare_v2(db, sql, -1, &stmt, 0); + if (rc != SQLITE_OK) + return rc; + + sqlite3_bind_text(stmt, 1, name, -1, SQLITE_STATIC); + sqlite3_bind_blob(stmt, 2, &p, sizeof(p), SQLITE_STATIC); + sqlite3_step(stmt); + + return sqlite3_finalize(stmt); +} + /* * lower -- * Converts the string str to lower case @@ -180,7 +204,7 @@ create_db(sqlite3 *db) #ifndef DEBUG "compress=zip, uncompress=unzip, " #endif - "tokenize=porter, notindexed=section, notindexed=md5_hash); " + "tokenize=custom_apropos_tokenizer, notindexed=section, notindexed=md5_hash); " //mandb_meta "CREATE TABLE IF NOT EXISTS mandb_meta(device, inode, mtime, " "file UNIQUE, md5_hash UNIQUE, id INTEGER PRIMARY KEY); " @@ -365,6 +389,14 @@ init_db(mandb_access_mode db_flag, const char *manconf) goto error; } + sqlite3_extended_result_codes(db, 1); + + rc = register_tokenizer(db); + if (rc != SQLITE_OK) { + warnx("Unable to register custom tokenizer: %s", sqlite3_errmsg(db)); + goto error; + } + if (create_db_flag && create_db(db) < 0) { warnx("%s", "Unable to create database schema"); goto error; @@ -390,7 +422,6 @@ init_db(mandb_access_mode db_flag, const char *manconf) } sqlite3_finalize(stmt); - sqlite3_extended_result_codes(db, 1); /* Register the zip and unzip functions for FTS compression */ rc = sqlite3_create_function(db, "zip", 1, SQLITE_ANY, NULL, zip, diff --git a/usr.sbin/makemandb/apropos-utils.h b/usr.sbin/makemandb/apropos-utils.h index 2589f2c110eb..39441c161f52 100644 --- a/usr.sbin/makemandb/apropos-utils.h +++ b/usr.sbin/makemandb/apropos-utils.h @@ -1,4 +1,4 @@ -/* $NetBSD: apropos-utils.h,v 1.12 2017/05/01 05:28:00 abhinav Exp $ */ +/* $NetBSD: apropos-utils.h,v 1.13 2017/06/18 16:24:10 abhinav Exp $ */ /*- * Copyright (c) 2011 Abhinav Upadhyay * All rights reserved. @@ -45,7 +45,7 @@ typedef enum mandb_access_mode { } mandb_access_mode; -#define APROPOS_SCHEMA_VERSION 20120507 +#define APROPOS_SCHEMA_VERSION 20170618 /* * Used to identify the section of a man(7) page. diff --git a/usr.sbin/makemandb/custom_apropos_tokenizer.c b/usr.sbin/makemandb/custom_apropos_tokenizer.c new file mode 100644 index 000000000000..340c5c5abd4b --- /dev/null +++ b/usr.sbin/makemandb/custom_apropos_tokenizer.c @@ -0,0 +1,754 @@ +/* $NetBSD: custom_apropos_tokenizer.c,v 1.1 2017/06/18 16:24:10 abhinav Exp $ */ +/* +** 2006 September 30 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** Implementation of the full-text-search tokenizer that implements +** a Porter stemmer. +*/ + +/* +** The code in this file is only compiled if: +** +** * The FTS3 module is being built as an extension +** (in which case SQLITE_CORE is not defined), or +** +** * The FTS3 module is being built into the core of +** SQLite (in which case SQLITE_ENABLE_FTS3 is defined). +*/ + +#include +#include +#include +#include +#include + +#include "custom_apropos_tokenizer.h" +#include "fts3_tokenizer.h" +#include "nostem.c" + +/* + * Class derived from sqlite3_tokenizer + */ +typedef struct custom_apropos_tokenizer { + sqlite3_tokenizer base; /* Base class */ +} custom_apropos_tokenizer; + +/* + * Class derived from sqlite3_tokenizer_cursor + */ +typedef struct custom_apropos_tokenizer_cursor { + sqlite3_tokenizer_cursor base; + const char *zInput; /* input we are tokenizing */ + size_t nInput; /* size of the input */ + size_t iOffset; /* current position in zInput */ + size_t iToken; /* index of next token to be returned */ + char *zToken; /* storage for current token */ + size_t nAllocated; /* space allocated to zToken buffer */ +} custom_apropos_tokenizer_cursor; + +/* + * Create a new tokenizer instance. + */ +static int +aproposPorterCreate(int argc, const char *const * argv, + sqlite3_tokenizer ** ppTokenizer) +{ + custom_apropos_tokenizer *t; + t = calloc(1, sizeof(*t)); + if (t == NULL) + return SQLITE_NOMEM; + *ppTokenizer = &t->base; + return SQLITE_OK; +} + +/* + * Destroy a tokenizer + */ +static int +aproposPorterDestroy(sqlite3_tokenizer * pTokenizer) +{ + free(pTokenizer); + return SQLITE_OK; +} + +/* + * Prepare to begin tokenizing a particular string. The input + * string to be tokenized is zInput[0..nInput-1]. A cursor + * used to incrementally tokenize this string is returned in + * *ppCursor. + */ +static int +aproposPorterOpen( + sqlite3_tokenizer * pTokenizer, /* The tokenizer */ + const char *zInput, int nInput, /* String to be tokenized */ + sqlite3_tokenizer_cursor ** ppCursor /* OUT: Tokenization cursor */ +) +{ + custom_apropos_tokenizer_cursor *c; + + c = calloc(1, sizeof(*c)); + if (c == NULL) + return SQLITE_NOMEM; + + c->zInput = zInput; + if (zInput != 0) { + if (nInput < 0) + c->nInput = strlen(zInput); + else + c->nInput = nInput; + } + + *ppCursor = &c->base; + return SQLITE_OK; +} + +/* + * Close a tokenization cursor previously opened by a call to + * aproposPorterOpen() above. + */ +static int +aproposPorterClose(sqlite3_tokenizer_cursor *pCursor) +{ + custom_apropos_tokenizer_cursor *c = (custom_apropos_tokenizer_cursor *) pCursor; + free(c->zToken); + free(c); + return SQLITE_OK; +} + +/* + * Vowel or consonant + */ +static const char cType[] = { + 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, + 1, 1, 1, 2, 1 +}; + +/* + * isConsonant() and isVowel() determine if their first character in + * the string they point to is a consonant or a vowel, according + * to Porter ruls. + * + * A consonate is any letter other than 'a', 'e', 'i', 'o', or 'u'. + * 'Y' is a consonant unless it follows another consonant, + * in which case it is a vowel. + * + * In these routine, the letters are in reverse order. So the 'y' rule + * is that 'y' is a consonant unless it is followed by another + * consonent. + */ +static int isVowel(const char*); + +static int +isConsonant(const char *z) +{ + int j; + char x = *z; + if (x == 0) + return 0; + assert(x >= 'a' && x <= 'z'); + j = cType[x - 'a']; + if (j < 2) + return j; + return z[1] == 0 || isVowel(z + 1); +} + +static int +isVowel(const char *z) +{ + int j; + char x = *z; + if (x == 0) + return 0; + assert(x >= 'a' && x <= 'z'); + j = cType[x - 'a']; + if (j < 2) + return 1 - j; + return isConsonant(z + 1); +} + +/* + * Let any sequence of one or more vowels be represented by V and let + * C be sequence of one or more consonants. Then every word can be + * represented as: + * + * [C] (VC){m} [V] + * + * In prose: A word is an optional consonant followed by zero or + * vowel-consonant pairs followed by an optional vowel. "m" is the + * number of vowel consonant pairs. This routine computes the value + * of m for the first i bytes of a word. + * + * Return true if the m-value for z is 1 or more. In other words, + * return true if z contains at least one vowel that is followed + * by a consonant. + * + * In this routine z[] is in reverse order. So we are really looking + * for an instance of a consonant followed by a vowel. + */ +static int +m_gt_0(const char *z) +{ + while (isVowel(z)) { + z++; + } + if (*z == 0) + return 0; + while (isConsonant(z)) { + z++; + } + return *z != 0; +} + +/* Like mgt0 above except we are looking for a value of m which is + * exactly 1 + */ +static int +m_eq_1(const char *z) +{ + while (isVowel(z)) { + z++; + } + if (*z == 0) + return 0; + while (isConsonant(z)) { + z++; + } + if (*z == 0) + return 0; + while (isVowel(z)) { + z++; + } + if (*z == 0) + return 1; + while (isConsonant(z)) { + z++; + } + return *z == 0; +} + +/* Like mgt0 above except we are looking for a value of m>1 instead + * or m>0 + */ +static int +m_gt_1(const char *z) +{ + while (isVowel(z)) { + z++; + } + if (*z == 0) + return 0; + while (isConsonant(z)) { + z++; + } + if (*z == 0) + return 0; + while (isVowel(z)) { + z++; + } + if (*z == 0) + return 0; + while (isConsonant(z)) { + z++; + } + return *z != 0; +} + +/* + * Return TRUE if there is a vowel anywhere within z[0..n-1] + */ +static int +hasVowel(const char *z) +{ + while (isConsonant(z)) { + z++; + } + return *z != 0; +} + +/* + * Return TRUE if the word ends in a double consonant. + * + * The text is reversed here. So we are really looking at + * the first two characters of z[]. + */ +static int +doubleConsonant(const char *z) +{ + return isConsonant(z) && z[0] == z[1]; +} + +/* + * Return TRUE if the word ends with three letters which + * are consonant-vowel-consonent and where the final consonant + * is not 'w', 'x', or 'y'. + * + * The word is reversed here. So we are really checking the + * first three letters and the first one cannot be in [wxy]. + */ +static int +star_oh(const char *z) +{ + return isConsonant(z) && + z[0] != 'w' && z[0] != 'x' && z[0] != 'y' && + isVowel(z + 1) && + isConsonant(z + 2); +} + +/* + * If the word ends with zFrom and xCond() is true for the stem + * of the word that preceeds the zFrom ending, then change the + * ending to zTo. + * + * The input word *pz and zFrom are both in reverse order. zTo + * is in normal order. + * + * Return TRUE if zFrom matches. Return FALSE if zFrom does not + * match. Not that TRUE is returned even if xCond() fails and + * no substitution occurs. + */ +static int +stem( + char **pz, /* The word being stemmed (Reversed) */ + const char *zFrom, /* If the ending matches this... (Reversed) */ + const char *zTo, /* ... change the ending to this (not reversed) */ + int (*xCond) (const char *) /* Condition that must be true */ +) +{ + char *z = *pz; + while (*zFrom && *zFrom == *z) { + z++; + zFrom++; + } + if (*zFrom != 0) + return 0; + if (xCond && !xCond(z)) + return 1; + while (*zTo) { + *(--z) = *(zTo++); + } + *pz = z; + return 1; +} + +/* + * This is the fallback stemmer used when the porter stemmer is + * inappropriate. The input word is copied into the output with + * US-ASCII case folding. If the input word is too long (more + * than 20 bytes if it contains no digits or more than 6 bytes if + * it contains digits) then word is truncated to 20 or 6 bytes + * by taking 10 or 3 bytes from the beginning and end. + */ +static void +copy_stemmer(const char *zIn, size_t nIn, char *zOut, size_t *pnOut) +{ + size_t i, mx, j; + int hasDigit = 0; + for (i = 0; i < nIn; i++) { + char c = zIn[i]; + if (c >= 'A' && c <= 'Z') { + zOut[i] = c - 'A' + 'a'; + } else { + if (c >= '0' && c <= '9') + hasDigit = 1; + zOut[i] = c; + } + } + mx = hasDigit ? 3 : 10; + if (nIn > mx * 2) { + for (j = mx, i = nIn - mx; i < nIn; i++, j++) { + zOut[j] = zOut[i]; + } + i = j; + } + zOut[i] = 0; + *pnOut = i; +} + + +/* + * Stem the input word zIn[0..nIn-1]. Store the output in zOut. + * zOut is at least big enough to hold nIn bytes. Write the actual + * size of the output word (exclusive of the '\0' terminator) into *pnOut. + * + * Any upper-case characters in the US-ASCII character set ([A-Z]) + * are converted to lower case. Upper-case UTF characters are + * unchanged. + * + * Words that are longer than about 20 bytes are stemmed by retaining + * a few bytes from the beginning and the end of the word. If the + * word contains digits, 3 bytes are taken from the beginning and + * 3 bytes from the end. For long words without digits, 10 bytes + * are taken from each end. US-ASCII case folding still applies. + * + * If the input word contains not digits but does characters not + * in [a-zA-Z] then no stemming is attempted and this routine just + * copies the input into the input into the output with US-ASCII + * case folding. + * + * Stemming never increases the length of the word. So there is + * no chance of overflowing the zOut buffer. + */ +static void +porter_stemmer(const char *zIn, size_t nIn, char *zOut, size_t *pnOut) +{ + size_t i, j; + char zReverse[28]; + char *z, *z2; + if (nIn < 3 || nIn >= sizeof(zReverse) - 7) { + /* The word is too big or too small for the porter stemmer. + * Fallback to the copy stemmer + */ + copy_stemmer(zIn, nIn, zOut, pnOut); + return; + } + + for (i = 0, j = sizeof(zReverse) - 6; i < nIn; i++, j--) { + char c = zIn[i]; + if (c >= 'A' && c <= 'Z') { + zReverse[j] = c + 'a' - 'A'; + } else if (c >= 'a' && c <= 'z') { + zReverse[j] = c; + } else { + /* The use of a character not in [a-zA-Z] means that + * we fallback * to the copy stemmer + */ + copy_stemmer(zIn, nIn, zOut, pnOut); + return; + } + } + memset(&zReverse[sizeof(zReverse) - 5], 0, 5); + z = &zReverse[j + 1]; + + + /* Step 1a */ + if (z[0] == 's') { + if ( + !stem(&z, "sess", "ss", 0) && + !stem(&z, "sei", "i", 0) && + !stem(&z, "ss", "ss", 0) + ) { + z++; + } + } + /* Step 1b */ + z2 = z; + if (stem(&z, "dee", "ee", m_gt_0)) { + /* Do nothing. The work was all in the test */ + } else if ( + (stem(&z, "gni", "", hasVowel) || stem(&z, "de", "", hasVowel)) + && z != z2 + ) { + if (stem(&z, "ta", "ate", 0) || + stem(&z, "lb", "ble", 0) || + stem(&z, "zi", "ize", 0)) { + /* Do nothing. The work was all in the test */ + } else if (doubleConsonant(z) && (*z != 'l' && *z != 's' && *z != 'z')) { + z++; + } else if (m_eq_1(z) && star_oh(z)) { + *(--z) = 'e'; + } + } + /* Step 1c */ + if (z[0] == 'y' && hasVowel(z + 1)) { + z[0] = 'i'; + } + /* Step 2 */ + switch (z[1]) { + case 'a': + if (!stem(&z, "lanoita", "ate", m_gt_0)) { + stem(&z, "lanoit", "tion", m_gt_0); + } + break; + case 'c': + if (!stem(&z, "icne", "ence", m_gt_0)) { + stem(&z, "icna", "ance", m_gt_0); + } + break; + case 'e': + stem(&z, "rezi", "ize", m_gt_0); + break; + case 'g': + stem(&z, "igol", "log", m_gt_0); + break; + case 'l': + if (!stem(&z, "ilb", "ble", m_gt_0) + && !stem(&z, "illa", "al", m_gt_0) + && !stem(&z, "iltne", "ent", m_gt_0) + && !stem(&z, "ile", "e", m_gt_0) + ) { + stem(&z, "ilsuo", "ous", m_gt_0); + } + break; + case 'o': + if (!stem(&z, "noitazi", "ize", m_gt_0) + && !stem(&z, "noita", "ate", m_gt_0) + ) { + stem(&z, "rota", "ate", m_gt_0); + } + break; + case 's': + if (!stem(&z, "msila", "al", m_gt_0) + && !stem(&z, "ssenevi", "ive", m_gt_0) + && !stem(&z, "ssenluf", "ful", m_gt_0) + ) { + stem(&z, "ssensuo", "ous", m_gt_0); + } + break; + case 't': + if (!stem(&z, "itila", "al", m_gt_0) + && !stem(&z, "itivi", "ive", m_gt_0) + ) { + stem(&z, "itilib", "ble", m_gt_0); + } + break; + } + + /* Step 3 */ + switch (z[0]) { + case 'e': + if (!stem(&z, "etaci", "ic", m_gt_0) + && !stem(&z, "evita", "", m_gt_0) + ) { + stem(&z, "ezila", "al", m_gt_0); + } + break; + case 'i': + stem(&z, "itici", "ic", m_gt_0); + break; + case 'l': + if (!stem(&z, "laci", "ic", m_gt_0)) { + stem(&z, "luf", "", m_gt_0); + } + break; + case 's': + stem(&z, "ssen", "", m_gt_0); + break; + } + + /* Step 4 */ + switch (z[1]) { + case 'a': + if (z[0] == 'l' && m_gt_1(z + 2)) { + z += 2; + } + break; + case 'c': + if (z[0] == 'e' && z[2] == 'n' && (z[3] == 'a' || z[3] == 'e') && m_gt_1(z + 4)) { + z += 4; + } + break; + case 'e': + if (z[0] == 'r' && m_gt_1(z + 2)) { + z += 2; + } + break; + case 'i': + if (z[0] == 'c' && m_gt_1(z + 2)) { + z += 2; + } + break; + case 'l': + if (z[0] == 'e' && z[2] == 'b' && (z[3] == 'a' || z[3] == 'i') && m_gt_1(z + 4)) { + z += 4; + } + break; + case 'n': + if (z[0] == 't') { + if (z[2] == 'a') { + if (m_gt_1(z + 3)) { + z += 3; + } + } else if (z[2] == 'e') { + if (!stem(&z, "tneme", "", m_gt_1) + && !stem(&z, "tnem", "", m_gt_1) + ) { + stem(&z, "tne", "", m_gt_1); + } + } + } + break; + case 'o': + if (z[0] == 'u') { + if (m_gt_1(z + 2)) { + z += 2; + } + } else if (z[3] == 's' || z[3] == 't') { + stem(&z, "noi", "", m_gt_1); + } + break; + case 's': + if (z[0] == 'm' && z[2] == 'i' && m_gt_1(z + 3)) { + z += 3; + } + break; + case 't': + if (!stem(&z, "eta", "", m_gt_1)) { + stem(&z, "iti", "", m_gt_1); + } + break; + case 'u': + if (z[0] == 's' && z[2] == 'o' && m_gt_1(z + 3)) { + z += 3; + } + break; + case 'v': + case 'z': + if (z[0] == 'e' && z[2] == 'i' && m_gt_1(z + 3)) { + z += 3; + } + break; + } + + /* Step 5a */ + if (z[0] == 'e') { + if (m_gt_1(z + 1)) { + z++; + } else if (m_eq_1(z + 1) && !star_oh(z + 1)) { + z++; + } + } + /* Step 5b */ + if (m_gt_1(z) && z[0] == 'l' && z[1] == 'l') { + z++; + } + /* z[] is now the stemmed word in reverse order. Flip it back + * around into forward order and return. + */ + *pnOut = i = strlen(z); + zOut[i] = 0; + while (*z) { + zOut[--i] = *(z++); + } +} + +/* + * Based on whether the input word is in the nostem list or not + * call porter stemmer to stem it, or call copy_stemmer to keep it + * as it is (copy_stemmer converts simply converts it to lower case) + * Returns SQLITE_OK if stemming is successful, an error code for + * any errors + */ +static int +do_stem(const char *zIn, size_t nIn, char *zOut, size_t *pnOut) +{ + /* Before looking up the word in the hash table, convert it to lower-case */ + char *dupword = malloc(nIn); + if (dupword == NULL) + return SQLITE_NOMEM; + + for (size_t i = 0; i < nIn; i++) + dupword[i] = tolower((unsigned char) zIn[i]); + + size_t idx = nostem_hash(dupword, nIn); + if (strncmp(nostem[idx], dupword, nIn) == 0 && nostem[idx][nIn] == 0) + copy_stemmer(zIn, nIn, zOut, pnOut); + else + porter_stemmer(zIn, nIn, zOut, pnOut); + + free(dupword); + return SQLITE_OK; +} + + +/* + * Characters that can be part of a token. We assume any character + * whose value is greater than 0x80 (any UTF character) can be + * part of a token. In other words, delimiters all must have + * values of 0x7f or lower. + */ +static const char porterIdChar[] = { +/* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF */ + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, /* 3x */ + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 4x */ + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, /* 5x */ + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 6x */ + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, /* 7x */ +}; + +#define isDelim(C) (((ch=C)&0x80)==0 && (ch<0x30 || !porterIdChar[ch-0x30])) + +/* + * Extract the next token from a tokenization cursor. The cursor must + * have been opened by a prior call to aproposPorterOpen(). + */ +static int +aproposPorterNext( + sqlite3_tokenizer_cursor *pCursor, /* Cursor returned by aproposPorterOpen */ + const char **pzToken, /* OUT: *pzToken is the token text */ + int *pnBytes, /* OUT: Number of bytes in token */ + int *piStartOffset, /* OUT: Starting offset of token */ + int *piEndOffset, /* OUT: Ending offset of token */ + int *piPosition /* OUT: Position integer of token */ +) +{ + custom_apropos_tokenizer_cursor *c = (custom_apropos_tokenizer_cursor *) pCursor; + const char *z = c->zInput; + + while (c->iOffset < c->nInput) { + size_t iStartOffset, ch; + + /* Scan past delimiter characters */ + while (c->iOffset < c->nInput && isDelim(z[c->iOffset])) { + c->iOffset++; + } + + /* Count non-delimiter characters. */ + iStartOffset = c->iOffset; + while (c->iOffset < c->nInput && !isDelim(z[c->iOffset])) { + c->iOffset++; + } + + if (c->iOffset > iStartOffset) { + size_t n = c->iOffset - iStartOffset; + if (n > c->nAllocated) { + char *pNew; + c->nAllocated = n + 20; + pNew = realloc(c->zToken, c->nAllocated); + if (!pNew) + return SQLITE_NOMEM; + c->zToken = pNew; + } + int stemStatus = do_stem(&z[iStartOffset], n, c->zToken, (size_t *) pnBytes); + if (stemStatus != SQLITE_OK) + return stemStatus; + + *pzToken = c->zToken; + *piStartOffset = iStartOffset; + *piEndOffset = c->iOffset; + *piPosition = c->iToken++; + return SQLITE_OK; + } + } + return SQLITE_DONE; +} + +/* + * The set of routines that implement the porter-stemmer tokenizer + */ +static const sqlite3_tokenizer_module aproposPorterTokenizerModule = { + 0, + aproposPorterCreate, + aproposPorterDestroy, + aproposPorterOpen, + aproposPorterClose, + aproposPorterNext, + 0 +}; + +/* + * Allocate a new porter tokenizer. Return a pointer to the new + * tokenizer in *ppModule + */ +void +get_custom_apropos_tokenizer(sqlite3_tokenizer_module const ** ppModule) +{ + *ppModule = &aproposPorterTokenizerModule; +} diff --git a/usr.sbin/makemandb/custom_apropos_tokenizer.h b/usr.sbin/makemandb/custom_apropos_tokenizer.h new file mode 100644 index 000000000000..5c85c4bc498e --- /dev/null +++ b/usr.sbin/makemandb/custom_apropos_tokenizer.h @@ -0,0 +1,38 @@ +/* $NetBSD: custom_apropos_tokenizer.h,v 1.1 2017/06/18 16:24:10 abhinav Exp $ */ +/*- + * Copyright (c) 2017 Abhinav Upadhyay + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef CUSTOM_APROPOS_TOKENIZER_H +#define CUSTOM_APROPOS_TOKENIZER_H + +#include "fts3_tokenizer.h" + +void get_custom_apropos_tokenizer(sqlite3_tokenizer_module const **); + +#endif diff --git a/usr.sbin/makemandb/fts3_tokenizer.h b/usr.sbin/makemandb/fts3_tokenizer.h new file mode 100644 index 000000000000..4a40b2b38503 --- /dev/null +++ b/usr.sbin/makemandb/fts3_tokenizer.h @@ -0,0 +1,161 @@ +/* +** 2006 July 10 +** +** The author disclaims copyright to this source code. +** +************************************************************************* +** Defines the interface to tokenizers used by fulltext-search. There +** are three basic components: +** +** sqlite3_tokenizer_module is a singleton defining the tokenizer +** interface functions. This is essentially the class structure for +** tokenizers. +** +** sqlite3_tokenizer is used to define a particular tokenizer, perhaps +** including customization information defined at creation time. +** +** sqlite3_tokenizer_cursor is generated by a tokenizer to generate +** tokens from a particular input. +*/ +#ifndef _FTS3_TOKENIZER_H_ +#define _FTS3_TOKENIZER_H_ + +/* TODO(shess) Only used for SQLITE_OK and SQLITE_DONE at this time. +** If tokenizers are to be allowed to call sqlite3_*() functions, then +** we will need a way to register the API consistently. +*/ +#include "sqlite3.h" + +/* +** Structures used by the tokenizer interface. When a new tokenizer +** implementation is registered, the caller provides a pointer to +** an sqlite3_tokenizer_module containing pointers to the callback +** functions that make up an implementation. +** +** When an fts3 table is created, it passes any arguments passed to +** the tokenizer clause of the CREATE VIRTUAL TABLE statement to the +** sqlite3_tokenizer_module.xCreate() function of the requested tokenizer +** implementation. The xCreate() function in turn returns an +** sqlite3_tokenizer structure representing the specific tokenizer to +** be used for the fts3 table (customized by the tokenizer clause arguments). +** +** To tokenize an input buffer, the sqlite3_tokenizer_module.xOpen() +** method is called. It returns an sqlite3_tokenizer_cursor object +** that may be used to tokenize a specific input buffer based on +** the tokenization rules supplied by a specific sqlite3_tokenizer +** object. +*/ +typedef struct sqlite3_tokenizer_module sqlite3_tokenizer_module; +typedef struct sqlite3_tokenizer sqlite3_tokenizer; +typedef struct sqlite3_tokenizer_cursor sqlite3_tokenizer_cursor; + +struct sqlite3_tokenizer_module { + + /* + ** Structure version. Should always be set to 0 or 1. + */ + int iVersion; + + /* + ** Create a new tokenizer. The values in the argv[] array are the + ** arguments passed to the "tokenizer" clause of the CREATE VIRTUAL + ** TABLE statement that created the fts3 table. For example, if + ** the following SQL is executed: + ** + ** CREATE .. USING fts3( ... , tokenizer arg1 arg2) + ** + ** then argc is set to 2, and the argv[] array contains pointers + ** to the strings "arg1" and "arg2". + ** + ** This method should return either SQLITE_OK (0), or an SQLite error + ** code. If SQLITE_OK is returned, then *ppTokenizer should be set + ** to point at the newly created tokenizer structure. The generic + ** sqlite3_tokenizer.pModule variable should not be initialized by + ** this callback. The caller will do so. + */ + int (*xCreate)( + int argc, /* Size of argv array */ + const char *const*argv, /* Tokenizer argument strings */ + sqlite3_tokenizer **ppTokenizer /* OUT: Created tokenizer */ + ); + + /* + ** Destroy an existing tokenizer. The fts3 module calls this method + ** exactly once for each successful call to xCreate(). + */ + int (*xDestroy)(sqlite3_tokenizer *pTokenizer); + + /* + ** Create a tokenizer cursor to tokenize an input buffer. The caller + ** is responsible for ensuring that the input buffer remains valid + ** until the cursor is closed (using the xClose() method). + */ + int (*xOpen)( + sqlite3_tokenizer *pTokenizer, /* Tokenizer object */ + const char *pInput, int nBytes, /* Input buffer */ + sqlite3_tokenizer_cursor **ppCursor /* OUT: Created tokenizer cursor */ + ); + + /* + ** Destroy an existing tokenizer cursor. The fts3 module calls this + ** method exactly once for each successful call to xOpen(). + */ + int (*xClose)(sqlite3_tokenizer_cursor *pCursor); + + /* + ** Retrieve the next token from the tokenizer cursor pCursor. This + ** method should either return SQLITE_OK and set the values of the + ** "OUT" variables identified below, or SQLITE_DONE to indicate that + ** the end of the buffer has been reached, or an SQLite error code. + ** + ** *ppToken should be set to point at a buffer containing the + ** normalized version of the token (i.e. after any case-folding and/or + ** stemming has been performed). *pnBytes should be set to the length + ** of this buffer in bytes. The input text that generated the token is + ** identified by the byte offsets returned in *piStartOffset and + ** *piEndOffset. *piStartOffset should be set to the index of the first + ** byte of the token in the input buffer. *piEndOffset should be set + ** to the index of the first byte just past the end of the token in + ** the input buffer. + ** + ** The buffer *ppToken is set to point at is managed by the tokenizer + ** implementation. It is only required to be valid until the next call + ** to xNext() or xClose(). + */ + /* TODO(shess) current implementation requires pInput to be + ** nul-terminated. This should either be fixed, or pInput/nBytes + ** should be converted to zInput. + */ + int (*xNext)( + sqlite3_tokenizer_cursor *pCursor, /* Tokenizer cursor */ + const char **ppToken, int *pnBytes, /* OUT: Normalized text for token */ + int *piStartOffset, /* OUT: Byte offset of token in input buffer */ + int *piEndOffset, /* OUT: Byte offset of end of token in input buffer */ + int *piPosition /* OUT: Number of tokens returned before this one */ + ); + + /*********************************************************************** + ** Methods below this point are only available if iVersion>=1. + */ + + /* + ** Configure the language id of a tokenizer cursor. + */ + int (*xLanguageid)(sqlite3_tokenizer_cursor *pCsr, int iLangid); +}; + +struct sqlite3_tokenizer { + const sqlite3_tokenizer_module *pModule; /* The module for this tokenizer */ + /* Tokenizer implementations will typically add additional fields */ +}; + +struct sqlite3_tokenizer_cursor { + sqlite3_tokenizer *pTokenizer; /* Tokenizer for this cursor. */ + /* Tokenizer implementations will typically add additional fields */ +}; + +int fts3_global_term_cnt(int iTerm, int iCol); +int fts3_term_cnt(int iTerm, int iCol); + + +#endif /* _FTS3_TOKENIZER_H_ */ diff --git a/usr.sbin/makemandb/nostem.txt b/usr.sbin/makemandb/nostem.txt new file mode 100644 index 000000000000..29d79d09dfff --- /dev/null +++ b/usr.sbin/makemandb/nostem.txt @@ -0,0 +1,4840 @@ +af +afsc +afslog +afterboot +age +agp +agr +agrep +aha +ahb +ahc +ahci +ahcisata +ahd +ahdilabel +ahsc +ai +aiboost +aibs +aic +aica +aio +akbd +alc +ale +algor +alignof +alipm +alloc +alloca +allocaddrinfo +allocbuf +allserver +alphasort +altboot +altmem +altq +altq.conf +altqd +altqstat +amd +amd.conf +amdpcib +amdpm +amdpmi +amdtemp +amhphy +amidisplaycc +amldb +amq +amr +amrctl +ams +aname +anvil +ap +apecs +api +apic +apm +apmd +apmlabel +appdefault +applink +aprint +aps +ar +arange +aranges +arckbd +arcmsr +arcofi +arg +aria +arm +arp +arpaname +arpintr +arpresolve +arraycount +arrayorder +artsata +as +asa +asc +ascii +asctime +asin +asinf +asinh +asinhf +asp +asprintf +assert +ast +astro +asus +async +at +ata +atabus +atactl +atalk +atan +atanf +atanh +atanhf +atapi +atapibus +ataraid +atc +ate +atend +atexit +atf +atf-c++-api +atf-c-api +atf-check +atf-config +atf-formats +atf-report +atf-run +atf-sh +atf-sh-api +atf-test-case +atf-test-program +atf-version +atfork +ath +athn +atime +atof +atoi +atol +atoll +aton +atphy +atppc +atq +atrm +atrun +attimer +attr +attributetype +attrlist +attroff +attron +attrset +attrval +atu +atw +atzsc +auacer +aubtfwl +audioamd +audiocfg +audiocs +audioctl +audioplay +audiorecord +aue +auich +auixp +aupci +auth +authid +authnone +authpf +authsys +authtok +authunix +authz +autocheckpoint +autocommit +autoconf +autovect +autri +auvia +auvitek +auxdata +auxreg +awacs +awi +awk +axe +axen +az +azalia +backgammon +badaddr +bah +banner +barrierattr +battlestar +bawrite +bba +bc +bcd +bcdtobin +bce +bcmgpio +bcmp +bcopy +bcsp +bdes +bdevsw +bdevvp +bdwrite +be +begindetach +bellctrl +ber +bg +bge +bha +bicc +biff +bindresvport +bindtextdomain +binpatch +binstall +bintime +bintobcd +binuptime +bio +bioctl +biodone +bioscall +biowait +birthtime +bitoffset +bitops +bitstr +bkgd +bkgdset +bktr +blacklistctl +blacklistd +blacklistd.conf +blocksize +blowfish +bluetooth +bm +bmap +bmapv +bmd +bmtphy +bn +bnx +boca +boot.cfg +boothowto +bootparamd +bootparams +bootpd +bootpef +bootpgw +bootpref +bootptab +bootptest +bootselect +boottime +bozohttpd +bp +bpf +bpfjit +bpp +bppcsc +brconfig +bread +breada +breadn +breakloop +brelse +brgphy +bridge +brk +bsd +bsdlabel +bsearch +bstring +bswap +bt +btattach +btbc +btconfig +btdevctl +bthcid +bthidev +bthset +bthub +btkbd +btkey +btmagic +btms +btoc +btodb +btowc +btpand +btpin +btree +btsco +btuart +buf +bufcreate +buffercache +bufferevent +bufferevent.h +bufferio +bufq +builtin +bus +bvarray +bvdup +bvecadd +bvecfree +bvfree +bvstr +bvstrdup +bwi +bwrite +bwtwo +by +byteorder +bytestokey +bzcat +bzero +c++ +c++filt +ca +ca.pl +cabsf +cabsl +cac +cacheflush +cacheline +cacos +cacosf +cacosh +cacoshf +cacoshl +cacosl +caesar +cal +callhdr +callmsg +calloc +callout +callrpc +can +canconfig +canfield +canloop +cap +capfile +cardbus +cardslot +carg +cargf +cargl +carp +cas +casin +casinf +casinh +casinhf +casinhl +casinl +catan +catanf +catanh +catanhf +catanhl +catanl +catclose +catgets +catman +catopen +cb +cbb +cbc +cbcm +cbreak +cbrt +cbrtf +cbrtl +cc +ccache +cccp +ccd +ccd.conf +ccdconfig +ccos +ccosf +ccosh +ccoshf +ccoshl +ccosl +cd +cdb +cdbr +cdbw +cdce +cdefs +cdevsw +cdevvp +cdplay +cec +ceil +ceilf +ceill +cert +cexp +cexpf +cexpl +cfa +cfb +cfgetispeed +cfgetospeed +cfmakeraw +cfsetispeed +cfsetospeed +cfsetspeed +cgd +cgdconfig +cgeight +cgetcap +cgetclose +cgetent +cgetfirst +cgetmatch +cgetnext +cgetnum +cgetset +cgetstr +cgetustr +cgfour +cgfourteen +cgram +cgsix +cgthree +cgtwo +ch +changegroup +changepw +changeset +chauthtok +chdir +checkexp +checknr +checkprot +checksumsize +chflags +chfn +chfs +chgat +chgkprot +chgrp +ching +chio +chipsfb +chmod +chown +chpass +chroot +chsh +ci +cia +cidr +cie +cimag +cimagf +cimagl +ciphy +cir +cis +ciss +cksum +cksumtype +clcs +clct +cleanerd +cleantags +clearerr +clearok +cli +clmpcc +clnt +clntraw +clnttcp +clntudp +clockctl +clockport +clogf +clogl +closedir +closef +closefile +closefrom +closelog +clr +clrbit +clri +clrtobot +clrtoeol +cltom +cmd +cmdide +cmos +cmp +cmpci +cms +cmsg +cn +cnattach +cnbell +cndetach +cngetc +cngetsn +cnmagic +cnpollc +cnputc +cntl +cnw +cnwctl +co +codeset +col +colcrt +coll +colrm +com +comm +comp +compileoption +comsat +con +concat +cond +condattr +condvar +conf +config.samples +confstr +congctl +conj +conjf +conjl +cons +const +constfunc +consttime +cont +contentinfo +conv +copyback +copydata +copydel +copyin +copyinstr +copym +copyout +copyoutstr +copypacket +copyset +copysign +copysignf +copysignl +copystr +copyup +copywin +copyx +coram +coredump +coretemp +cos +cosc +cosf +cosh +coshf +countmail +countset +cp +cpc +cpi +cpio +cpow +cpowf +cpowl +cpp +cprng +cproj +cprojf +cprojl +cpsw +cpu +cpuctl +cpufreq +cpuset +cpxattr +creal +crealf +creall +creat +createerr +createv +cred +cribbage +crl +cron +crontab +crunchgen +crunchide +cs +csc +csf +csh +csin +csinf +csinh +csinhf +csinhl +csinl +csplit +csqrt +csqrtf +csqrtl +css +cstring +ct +ctags +ctan +ctanf +ctanh +ctanhf +ctanhl +ctanl +ctassert +ctermid +ctf +ctfconvert +ctfdump +ctfmerge +ctime +ctl +ctob +ctod +ctrl +ctx +ctype +cu +cuda +cue +curcpu +curlwp +curproc +curs +curses +cursor +curterm +cuserid +cut +cv +cvs +cvsbug +cvslatest +cxdtv +cy +cypide +cz +dab +daic +daicctl +daily +daily.conf +dataref +db +dbconfig +dbcool +dbm +dbopen +dbri +dbstatus +dbsym +dbtob +dc +dcgettext +dcm +dcngettext +dd +ddb +ddc +ddn +ddns-confgen +de +debugused +dec +decl +decltype +decr +def +del +delch +deleteln +deletestr +delmulti +delscreen +deltat +delv +delwin +depca +deroff +derwin +des +desc +dest +destroyv +dev +devaddr +devenum +devfilter +devget +devinfo +devinquiry +deviter +devmajor +devmatch +devminor +devname +devopen +devpubd +devrecv +devreq +devs +devsend +devsw +df +dg +dge +dgettext +dgst +dh +dhclient +dhclient-script +dhclient.conf +dhclient.leases +dhcp-eval +dhcp-options +dhcpcd +dhcpcd-run-hooks +dhcpcd.conf +dhcpd +dhcpd.conf +dhcpd.leases +dhcrelay +dhparam +dhparams +dhu +diagassert +diagused +diename +dieoffset +diff +difftime +digestinit +digestsigninit +digestverifyinit +dino +dio +dir +dirent +dirfd +dirfno +dirname +dirs +diskpart +disktab +ditroff +div +dk +dkcksum +dkctl +dkscan +dksubr +dl +dladdr +dlclose +dlctl +dlerror +dlfcn +dlopen +dlsym +dlvsym +dm +dm.conf +dma +dmaabort +dmacascade +dmacount +dmadone +dmamap +dmamaxsize +dmamem +dmastart +dmatag +dmc +dmctl +dmesg +dmf +dmover +dmoverio +dmphy +dmsetup +dmv +dmz +dn +dngettext +dnkbd +dns +dns-sd +dnsblog +dnssec-dsfromkey +dnssec-importkey +dnssec-keyfromlabel +dnssec-keygen +dnssec-revoke +dnssec-settime +dnssec-signzone +dnssec-verify +do +dofileread +dofilereadv +dofilewrite +dofilewritev +domainname +dopowerhooks +dosboot +doshutdownhooks +doupdate +dpclock +dprintf +dpt +dpti +driverid +drm +drq +drtest +drvctl +ds +dsa +dsaparam +dsapublickey +dsc +dsclock +dtide +dtmfdecode +dtoc +dtrace +dttoif +dtv +dtviic +dty +du +dumpbus +dumpconf +dumpfs +dumplfs +dumpsize +dumpsys +dup +dupbv +dupfdopen +dupwin +dvbox +dwarf +dwctwo +dwlpx +dyn +dz +ea +eai +eap +easprintf +eb +ebus +ec +eca +ecalloc +ecb +ecdsa +echochar +eclock +ecparam +ecprivatekey +ed +edahdi +edata +edc +edid +editline +editrc +edquota +eeprom +ef +efa +efopen +efs +efun +eg +egd +egrep +eh +ehci +ehdr +ei +eisa +ekermit +el +elanpar +elanpex +elansc +elf +elfedit +elftosb +elmc +elroy +emalloc +emdtv +empb +emuxki +en +enablecache +enc +encodeinit +encrypteddata +encryptinit +enctype +endfsent +endgrent +endhostent +endnetconfig +endnetent +endnetgrent +endnetpath +endofrecord +endprotoent +endpwent +endrpcent +endservent +endttyent +endusershell +endutxent +endwin +enic +enodev +enoioctl +enosys +enqueue +env +envctrl +environ +envlist +envstat +envsys +envsys.conf +enxio +eof +eopnotsupp +ep +epgpio +epic +eq +eqn +erasechar +erealloc +ereallocarr +erf +erfc +erfcf +erfcl +erff +erfl +err +errc +errcode +errlist +errmsg +errstr +errx +es +esa +escdelay +esetfunc +esh +eshconfig +esiop +esm +eso +esp +ess +est +estrdup +estrlcat +estrlcpy +estrndup +estrtoi +estrtou +et +etcupdate +etext +etfs +etherip +ethers +ethersubr +etphy +ets +etype +ev +evasprintf +evbuffer +evbuffer.h +evcnt +evdeprecated +evdns +evhttp +evp +evrpc +evt +evtag +evthread +evutil +ex +execl +execle +execlp +execlpe +execsigs +exect +execv +execve +execvp +execvpe +exp +expf +exphy +expr +ext +extattr +extattrctl +fabs +fabsf +fabsl +faccessat +fadvise +faithd +falloc +fallocate +fastboot +fasthalt +fcache +fchdir +fchflags +fchmod +fchmodat +fchown +fchownat +fchroot +fclose +fcntl +fcpxattr +fcrypt +fd +fdalloc +fdatasync +fdc +fdcheckstd +fdclear +fdclone +fdcloseexec +fdcopy +fddi +fde +fdesc +fdexpand +fdformat +fdfree +fdim +fdimf +fdiml +fdinit +fdiscard +fdisk +fdopen +fdopendir +fdrelease +fdremove +fds +fdset +fdshare +fdunshare +fea +feclearexcept +fedisableexcept +feenableexcept +fegetenv +fegetexcept +fegetexceptflag +fegetround +feholdexcept +fenv +feof +feraiseexcept +ferror +fesetenv +fesetexceptflag +fesetround +fetestexcept +feupdateenv +ffb +ffc +fflags +fflush +ffree +ffs +fg +fgen +fgetc +fgetln +fgetown +fgetpos +fgets +fgetwc +fgetwln +fgetws +fgrep +fhopen +fhpib +fhstat +fhstatvfs +fhtovp +fileassoc +fileio +filemon +filt +fincore +fingerd +fini +finitef +finsio +firmload +firsthdr +firstkey +fixmount +fk +fktrace +fl +flagarhdr +flagdata +flagehdr +flagelf +flagphdr +flagscn +flagshdr +flashctl +flex +flock +flockfile +floorf +floorl +floppy +floppytab +flushinp +flushok +fma +fmaf +fmal +fmax +fmaxf +fmaxl +fmemopen +fmin +fminf +fminl +fmod +fmodf +fmodl +fms +fmt +fmtcheck +fmtmsg +fmv +fnmatch +foreach +forkpty +formaddr +formblock +formexprloc +formflag +formref +formsdata +formstring +formudata +fownsignal +fp +fpa +fparseln +fpathconf +fpclassify +fpgetmask +fpgetprec +fpgetround +fpgetsticky +fpr +fprintf +fpsetmask +fpsetprec +fpsetround +fpsetsticky +fpurge +fputc +fputs +fputwc +fputws +framebuf +fread +freeaddrinfo +freeargs +freebsd +freecheck +freecode +freeifaddrs +freem +freemntopts +freenameindex +freereq +freeres +freesession +freopen +frexp +frodo +fropen +fs +fscanf +fsck +fscow +fsdb +fseek +fseeko +fsetown +fsetpos +fsinfo +fsirand +fsize +fsplit +fss +fssconfig +fstab +fstat +fstatat +fstatvfs +fstrans +fsync +fta +ftell +ftello +ftime +ftok +ftp +ftp-proxy +ftpchroot +ftpd +ftpd.conf +ftpusers +ftruncate +ftrylockfile +fts +ftw +fubyte +fuibyte +fuiword +fujbp +fujhk +func +funcname +funcs +funlockfile +funopen +fusermount +fuswintr +fusword +futimens +futimes +fuword +fwctl +fwd +fwhrng +fwide +fwip +fwohci +fwopen +fwprintf +fwrite +fwscanf +fxp +g++ +gai +gammaf +gapspci +gbox +gbus +gcc +gcore +gcov +gcpp +gcq +gcscaudio +gcscide +gcscpcib +gdb +gdiffmk +gdrom +gelf +gem +gen +genaddrs +genassym +genassym.cf +gencat +gendsa +generatelocalsubkey +generic +genfb +genfs +genpkey +genrsa +gentbi +geodecntr +geodeide +geodewdog +geq +getaddr +getaddrinfo +getaddrs +getaffinity +getargs +getargv +getarhdr +getarsym +getauthenticator +getbase +getbegx +getbegy +getbintime +getbinuptime +getbkgd +getblk +getblocksize +getbootfile +getbsize +getbyteorder +getc +getcaller +getcallercreds +getcap +getcapbool +getcapnum +getcapsize +getcapstr +getcaptime +getch +getchar +getcksumtype +getclass +getclock +getclr +getconf +getconfoundersize +getcontext +getcpuclockid +getcurx +getcury +getcwd +getdata +getdate +getdelim +getdents +getdetachstate +getdevmajor +getdirentries +getdiskbyname +getdiskcookedname +getdiskrawname +getdomainname +getdtablesize +getdyn +geteblk +getegid +getehdr +getencstat +getenctype +getent +getenv +getenvlist +getenvv +geterr +geteuid +getextattr +getfh +getfile +getfiles +getflag +getflags +getflg +getfsent +getfsfile +getfsspec +getfsspecname +getfstypename +getgid +getgrent +getgrgid +getgrnam +getgrouplist +getgroupmembership +getgroups +getguardsize +gethdr +gethostbyaddr +gethostbyname +gethostent +gethostid +gethostname +getident +getifa +getifaddrs +getimplname +getinheritsched +getint +getiobuf +getitimer +getkernelname +getkey +getkeytype +getlabeloffset +getlabelsector +getlabelusesmbr +getlastlogx +getline +getloadavg +getlocalseqnumber +getlocalsubkey +getlogin +getlwps +getmaps +getmaxpartitions +getmaxx +getmaxy +getmaxyx +getmech +getmicrotime +getmicrouptime +getmntinfo +getmntoptnum +getmntopts +getmntoptstr +getmode +getmountdevice +getmountpoint +getmove +getn +getname +getnameinfo +getnanotime +getnanouptime +getnetbyaddr +getnetbyname +getnetconfig +getnetconfigent +getnetent +getnetgrent +getnetpath +getnewfsid +getnstr +getnum +getnumidtypes +getnumobjtypes +getopsbyname +getopt +getoverrun +getpadsize +getpages +getpagesize +getparam +getparx +getpary +getparyx +getpass +getpassfd +getpeereid +getpeername +getpgid +getpgroup +getpgrp +getphdr +getphdrnum +getphnum +getpid +getport +getportbyname +getpos +getppid +getprefix +getprioceiling +getpriority +getprivate +getprocs +getprogname +getprop +getprotobyname +getprotobynumber +getprotocol +getprotoent +getpshared +getpwclass +getpwconf +getpwent +getpwnam +getpwuid +getrawpartition +getrcache +getref +getrel +getrela +getremoteseqnumber +getremotesubkey +getreq +getreqset +getres +getrestrictions +getrlimit +getrpcbyname +getrpcbynumber +getrpccaller +getrpcent +getrpcport +getrusage +gets +getschedparam +getschedpolicy +getscheduler +getscn +getscope +getscopeid +getservbyname +getservbyport +getservent +getservers +getshdr +getshdrnum +getshdrstrndx +getshnum +getshstrndx +getsid +getsigdefault +getsigmask +getskeyprompt +getsockname +getsockopt +getspecific +getstack +getstackaddr +getstacksize +getstate +getstr +getstrategyname +getsubopt +getsym +getsyminfo +getsymshndx +getsyx +gettext +gettime +gettimeofday +gettmode +getttyent +getttynam +getty +gettype +gettytab +getuid +getuserkey +getusershell +getutmp +getutmpx +getutxent +getutxid +getutxline +getvalue +getvfs +getvfsstat +getvmmap +getw +getwc +getwchar +getwd +getwin +getyx +gid +gif +gio +giopci +globfree +globname +glxsb +glxtphy +gm +gmtime +gname +gnutar +gomoku +gphyter +gpib +gpio +gpio.conf +gpioctl +gpioiic +gpiolock +gpioow +gpiopwm +gpiosim +gprof +gpt +grantpt +gre +grep +grf +grfcl +grfconfig +grfcv +grfet +grfrh +grfrt +grful +grn +grodvi +groff +grog +grohtml +grolbp +grops +grotty +groupadd +groupdb +groupdel +groupinfo +groupmod +growkernel +grtwo +grzip +gsc +gsckbc +gscpcib +gsip +gspa +gss +gssapi +gt +gtp +gtsc +gtty +gunzip +gus +guspnp +gxio +gzcat +gzexe +gzip +halfdelay +hals +haltwo +hardclock +hasattr +hasform +hashdone +hashinit +haskey +hcide +hcreate +hdafg +hdaudio +hdaudiobus +hdaudioctl +hdestroy +hdh +heapsort +heim +herror +hesinfo +hesiod +hesiod.conf +hexdump +hfs +hid +hier +hifn +highpc +hil +hilid +hilkbd +hilms +hk +hlfsd +hline +hmac +hme +holdrele +hostalias +hostapd +hostapd.conf +hosts.allow +hosts.deny +hosts.equiv +hostton +hotplug +howmany +hp +hpacel +hpc +hpcboot +hpet +hpftodit +hpib +hpibbus +hpqlb +hprop +hpropd +hptide +hq +hsearch +hst +hstrerror +ht +htonl +htons +http +httpd +huntd +hy +hypot +hypotf +hythygtemp +hz +hztoms +ia +iasl +iavc +ibmcd +ibmhawk +ibus +ic +icache +ichlpcib +ichsmb +icmp +iconv +icp +icpsp +icsphy +id +idcok +ident +identd +idlok +idtype +idx +ie +iee +ieee +if +ifaliases +ifattach +ifconfig +ifconfig.if +ifdetach +ifinit +ifmcstat +ifmedia +ifnet +ifpci +iftodt +ifwatchd +igmafb +igphy +igsfb +iha +ihphy +iic +ik +ikphy +il +ilogb +ilogbf +ilogbl +imax +imaxabs +imaxdiv +imc +imin +immedok +inc +inchnstr +inchstr +incore +incr +indextoname +indxbib +inet +inetd +inetd.conf +infocmp +infokey +init +initclocks +initgroups +initivector +initlog +initscr +initstate +inittodr +inl +innetgr +innstr +ino +inphy +inputhandler +insch +insdelln +insertch +insertln +insertstr +insn +insque +inst +install-info +install.conf +installboot +instr +int +intio +into +intr +intrctl +intrflush +intro +inttypes +intx +inval +io +ioapic +ioasic +ioat +iobus +iocap +ioctl +ioerr +iomdkbc +iop +iopaau +iopctl +iophy +iopl +iopsp +iopwdog +iostat +iovec +ip +ipcrm +ipcs +ipf +ipf.conf +ipfilter +ipfs +ipfstat +ipftest +ipi +ipkdb +ipkdbcmds +ipkdbfbyte +ipkdbif +ipkdbinit +ipkdbsbyte +ipl +ipmi +ipmon +ipnat +ipnat.conf +ippool +ippool.conf +ippp +ipppctl +ipresend +iprop +iprop-log +ipropd-master +ipropd-slave +ipsec +ipsec.conf +ipsend +iptest +ipw +ipwctl +irda +irdaattach +irframe +irframetty +irip +irmce +irongate +iruserok +is +isa +isabeep +isalnum +isalpha +isapnp +isascii +isatty +isblank +isbytes +isclr +iscntrl +isconfigured +isconsole +iscsi-initiator +iscsi-target +iscsictl +iscsid +isdigit +isdn +isdnbchan +isdncapi +isdnctl +isdnd +isdnd.acct +isdnd.rates +isdnd.rc +isdnmonitor +isdntel +isdntelctl +isdntrace +isdntrc +isempty +isendwin +isfinite +isfree +isgraph +isgreater +isibootd +isic +isinf +isinff +islocked +islower +ismt +isnan +isnanf +isnormal +isns +isotherset +isourserver +isp +isprint +ispunct +isr +isrunning +isset +issetugid +issignal +isspace +isunder +isupper +isv +iswalnum +iswalpha +iswblank +iswcntrl +iswctype +iswdigit +iswgraph +iswlower +iswprint +iswpunct +iswspace +iswupper +iswxdigit +isxdigit +iszero +ite +iteconfig +iteide +iter +itesio +itimerfix +itimerspec +itimerval +ivec +iwi +iwic +iwictl +iwm +iwn +ix +ixg +ixpide +iy +jemalloc +jensenio +jlock +jme +jmide +jn +jnf +jot +joy +junlock +kadmin +kadmind +kafs +kassert +kassertmsg +kauth +kbd +kcm +kcopy +kcpuset +kdassert +kdassertmsg +kdc +kdestroy +kdigest +kdispatch +kdone +kdump +kenter +kerberos +kernacc +kernel +kernfs +kernhist +kevent +keyblock +keygen +keyinfo +keypad +keysym +keytab +kfilter +kft +kg +kgetcred +kgmon +killchar +killpg +killproc +kimpersonate +kinfo +kinit +klist +kloader +klua +km +kmem +knote +kpasswd +kpasswdd +kpause +kpgsignal +kpreempt +kprintf +kpsignal +kqueue +krb +krbhst +kregister +kremove +kse +ksem +ksh +kstash +ksu +ksyms +kthread +ktrace +ktruss +kttcp +ktutil +kue +kvm +kvno +lam +langinfo +lapic +larn +lasi +lastcomm +lasthop +lastlog +lastlogin +lastlogx +lber-decode +lber-encode +lber-memory +lber-sockbuf +lber-types +lc +lca +lcd +lchflags +lchmod +lchown +lcpxattr +ld +ld.aout +ld.elf +ld.so +ld.so.conf +ldap +ldap.conf +ldapadd +ldapcompare +ldapdelete +ldapexop +ldapmodify +ldapmodrdn +ldappasswd +ldapsearch +ldapurl +ldapwhoami +ldconfig +ldd +ldexp +ldexpf +ldexpl +ldif +ldiv +ldpd +ldpd.conf +ldt +le +leadingspace +leaveok +leds +len +leq +less +lessecho +lessfile +lesskey +lex +lfind +lfs +lgamma +lgammaf +lh +lha +lhash +lib +libarchive +libarchive-formats +libblacklist +libiscsi +libmagic +libmj +libnetpgp +libnetpgpverify +libnpf +libperfuse +libquota +libradius +librtld +libsaslc +libunbound +libusbhid +libutil +lii +lineaddr +linebeginstatement +lineblock +linedisc +lineendsequence +lineno +lineoff +linesrc +linetouched +linkaddr +linkat +linkify +linkntoa +linkresolver +lint +linux +lio +list +listen +listextattr +listio +lkbib +llabs +lldiv +llrint +llrintf +lm +lmc +lmcconfig +lmenv +lms +lmtemp +lmtp +ln +lnaof +lne +lns +lo +loadbsd +loadbsd.x +loadfont +loadkmap +loadvnode +loc +local +localcount +locale +locale.alias +localeconv +localname +localtime +locate.conf +locate.updatedb +lockd +lockf +lockinit +lockmgr +lockstat +lockstate +lockstatus +loclist +logb +logbf +logbl +logf +logger +logical +login +login.access +login.conf +loginx +logname +logoutx +logwtmp +logwtmpx +lom +longjmp +longjmperror +longname +lookbib +lookupdev +lookupnet +lorder +lower +lowpc +lp +lpa +lpc +lpd +lpq +lpr +lprm +lpt +lptest +lrealm +lrint +lrintf +lrzip +ls +lsearch +lseek +lsextattr +lstat +ltsleep +lua +luac +luactl +lutimens +lutimes +lvchange +lvconvert +lvcreate +lvdisplay +lvextend +lvm +lvm.conf +lvmchange +lvmdiskscan +lvmdump +lvreduce +lvremove +lvrename +lvresize +lvs +lvscan +lwp +lwproc +lwresd +lxtphy +lzcat +lzf +lzfcat +lzip +lzma +lzmainfo +lzop +macinfo +madvise +mail.local +mailaddr +mailer.conf +mailq +mailwrapper +mailx +mainbus +maindbname +make +makeaddr +makecontext +makedbm +makedev +makedev.local +makefs +makeinfo +makeiplcookie +makekey +makemandb +makewritable +makphy +malloc +malloc.conf +malo +man.conf +mandoc +map-mbone +maple +mappage +mapreg +markexec +marktext +markv +master.passwd +matchingrule +mavb +max +maxitems +mb +mbe +mblen +mbr +mbrlabel +mbrlen +mbrtowc +mbsinit +mbsrtowcs +mbstowcs +mbtowc +mbuf +mc +mca +mcbus +mcclock +mcd +mchtype +mclget +mcmem +mcpcia +md +mdconfig +mdnsd +mdoc +mdoc.samples +mdsetimage +me +mec +mech +mechs +mem +memalign +membar +memc +memcache +memccpy +memchr +memcmp +memcpy +memequal +memmem +memmove +memoryallocators +memrchr +memset +memstream +memswitch +menuc +mergesort +mesg +mesh +meta +mextadd +mextmalloc +mfb +mfcs +mfi +mfp +mfree +mfs +mgadrm +mget +mgethdr +mgmt +mgnsc +mh +mhzc +mi +mic +micphy +microseq +microtime +microuptime +midi +midiplay +midirecord +mii +mille +min +mincore +minherit +minidlna.conf +minor +mixerctl +mixerctl.conf +mk +mk-amd-map +mk.conf +mkalias +mkbd +mkboot +mkbootimage +mkdb +mkdep +mkdir +mkdirat +mkdtemp +mkfifo +mkfifoat +mkfilters +mkheader +mklocale +mknetid +mknod +mknodat +mkostemp +mkostemps +mkquery +mkstemp +mkstemps +mkstr +mktemp +mktime +mkubootimage +mlcd +mlock +mlockall +mlx +mlxctl +mly +mm +mmap +mmcformat +mmem +mms +mmse +mntva +modctl +modf +modff +modfl +modload +modrdn +modstat +modules.conf +moduli +modunload +mom +moncontrol +mongoose +monop +monstartup +montgomery +monthly +monthly.conf +mopchk +mopcopy +mopd +mopprobe +moptrace +morse +motd +mountalloc +mountd +mountedon +mountroot +moused +mpii +mpls +mpool +mppb +mprintf +mprotect +mpt +mpu +mq +mqueue +mremap +mrinfo +mrouted +ms +mscdlabel +msconfig +msdos +msg +msgattrib +msgc +msgcat +msgcmp +msgcomm +msgconv +msgctl +msgen +msgexec +msgfmt +msgfree +msgget +msgid +msginit +msgmerge +msgrcv +msgs +msgsnd +msgtype +msgunfmt +msguniq +msi +msix +msk +mskc +msr +mstohz +msync +mt +mtc +mtd +mtime +mtio +mtocl +mtod +mtrace +mtree +mtrr +mtsleep +mul +multiboot +multicast +munlock +munlockall +munmap +mutex +mutexattr +mv +mvaddch +mvaddchnstr +mvaddchstr +mvaddnstr +mvaddstr +mvchgat +mvcur +mvderwin +mvgetch +mvgetnstr +mvgetstr +mvhline +mvinchnstr +mvinchstr +mvinnstr +mvinstr +mvprintw +mvsata +mvvline +mvwaddch +mvwaddchnstr +mvwaddchstr +mvwaddnstr +mvwaddstr +mvwchgat +mvwgetch +mvwgetnstr +mvwgetstr +mvwhline +mvwin +mvwinchnstr +mvwinchstr +mvwinnstr +mvwinstr +mvwprintw +mvwvline +myaddress +nadb +namecache +named +named-checkconf +named-checkzone +named-compilezone +named-journalprint +named.conf +namei +nameindex +nametoindex +nan +nanf +nanl +nanosleep +nanotime +nanouptime +napms +nbfs +nbperf +nbsvtool +nc +nca +ncbc +ncdcs +nclear +nclose +nconf +ncrsc +ndbm +ndbootd +ndestroy +ndinit +ndis +ndiscvt +ndp +ndxscn +ne +nearbyint +nearbyintf +nearbyintl +needfunc +nele +nell +neqn +nerr +nestiobuf +netconfig +netdock +netgroup +netid +netintro +netof +netpgp +netpgpkeys +netpgpverify +netsmb +netstat +newaliases +newbtconf +newc +newdata +newdisk +newehdr +newfs +newgrp +newpad +newphdr +newport +newscn +newsession +newsyslog +newsyslog.conf +newterm +newvnode +newwin +nextafter +nextafterf +nextafterl +nextkey +nextscn +nexttoward +nexttowardf +nfe +nfs +nfsd +nfsmb +nfsmbc +nfsstat +nfssvc +nftw +ngettext +nhpib +nhpow +ni +nid +nil +nilfs +ninit +nis +nisplus +njata +njs +nl +nlink +nlist +nlock +nloop +nls +nm +nmi +nmkquery +nmkupdate +nocbreak +nocopy +nodelay +noecho +nofail +nohup +noinline +nolog +nologin +noncecount +nonl +noproc +noprog +noqiflush +noraw +notavail +notimeout +noutrefresh +nowait +np +npf +npf.conf +npfctl +npfd +nquery +nquerydomain +nroff +nsclpcsio +nsdispatch +nsearch +nsec +nsend +nsendsigned +nseq +nset +nside +nslookup +nsmb +nsp +nsphy +nsphyter +nsswitch.conf +nsupdate +ntalkd +ntfs +ntoa +ntohl +ntohost +ntohs +ntop +ntp +ntp-keygen +ntp.conf +ntp.keys +ntpd +ntpdate +ntpdc +ntpq +ntptime +ntptrace +ntwo +ntwoc +nullconv +nullop +num +nupdate +nv +nvar +nvis +nvme +nvmectl +nvram +nxthdr +oak +obio +obj +objcopy +objdump +objectclass +objtype +oboe +ocsp +od +odcm +of +ofb +ofctl +offdie +offsetof +ofisa +ofwboot +ofwboot.elf +ofwboot.xcf +ohci +oid +ok +omshell +onewire +oosiop +op +openat +opencrypto +opencursor +opendir +opendisk +openfiles +openinit +openlog +openmemory +openpam +openprom +openpt +openpty +openssl +openssl.cnf +opl +ops +optiide +optstr +oqmgr +orcmd +ord +osiop +ossaudio +ostring +otus +ourserver +owtemp +pa +pac +paccept +padata +paddr +pageable +pagealloc +pagefree +pageout +pagerealloc +pagesize +palette +pam +pam.conf +paq +parms +parsedate +pas +passcheck +passphrase +passwd +passwd.conf +pathchk +pathconf +pawd +pax +paxctl +pbms +pbsdboot +pc +pcache +pcap +pcap-config +pcap-filter +pcap-linktype +pcap-savefile +pcap-tstamp +pcbc +pcc +pcctwo +pcdisplay +pchb +pci +pciback +pcibios +pcibus +pcic +pcictl +pcidev +pciide +pckbc +pckbd +pckbport +pckbportintr +pcl +pclose +pcmcia +pcmcom +pcn +pcnfsd +pcppi +pcq +pcreateerror +pcscp +pcu +pcweasel +pdc +pdcide +pdcsata +pdisk +pechochar +pem +percpu +perfused +perrno +perror +pf +pf.boot.conf +pf.conf +pf.os +pfbtops +pfctl +pfil +pflog +pflogd +pfs +pfsync +pglistalloc +pglistfree +pgrep +pgrp +pgsignal +phantasia +phantomas +phdr +phy +phys +physio +physload +pic +pidfile +pidlock +pigz +piixide +piixpcib +piixpm +pim +pk +pkey +pkeyparam +pkeyutl +pkg +pkgsrc +pkill +pkt +pkthdr +platinumfb +plip +pm +pmap +pmaplist +pmatch +pmc +pmf +pmi +pmppc +pms +pmsi +pmu +pnaphy +pnoutrefresh +pnozz +pnpbios +podulebus +policylen +pollset +pollts +pom +poolpage +popcountl +popcountll +popd +popen +popenve +pos +posix +postcat +postconf +postdrop +postfix +postfix-wrapper +postinstall +postkick +postlock +postlog +postmap +postmulti +postqueue +postscreen +postsig +postsuper +posttls-finger +pow +powerd +powerhook +powernow +poweroff +powerstate +powf +powsw +ppath +ppb +ppbus +ppi +ppp +pppd +pppdump +pppoe +pppoectl +pppstats +ppsratecheck +ppt +pquery +pr +pread +preadv +preauth +pref +prefresh +preinit +prenice +preupdate +prev +princ +printcap +printenv +printf +printinfo +printw +priv +proc +procfs +profhz +progvers +promisc +prop +proplib +proxiable +proxymap +ps +pselect +pserialize +pset +pseye +psiginfo +psignal +psk +pslist +psref +psrset +psshfs +pstat +pswitch +ptcd +pthread +ptm +ptoa +pton +ptr +ptrace +ptsc +ptsname +ptyfs +pubname +pubtype +pubtypename +pubtypes +puc +pud +puffs +purgeall +purgevfs +pushd +putc +putchar +putenv +putiobuf +putp +putpages +putref +puts +putscopeid +pututxline +putw +putwc +putwchar +putwin +pvchange +pvck +pvcreate +pvcsif +pvctxctl +pvdisplay +pvmove +pvr +pvremove +pvresize +pvs +pvscan +pw +pwait +pwcache +pwcheck +pwd +pwdog +pwhash +pwrite +pwritev +px +pxaip +pxeboot +pxg +qabs +qdiv +qe +qec +qiflush +qmgr +qms +qn +qop +qsafe +qsieve +qsort +qsphy +qsubst +qt +querydomain +quot +quotacheck +quotactl +quotacursor +quotadump +quotaoff +quotaon +quotarestore +quotaval +racoon +racoon.conf +racoonctl +radeondrm +radioctl +radiotap +radius.conf +radixsort +raidctl +ral +rand +randomid +ranlib +rar +rarpd +ras +rasctl +rasops +rasterconsole +ratecheck +rawdata +rawfile +rawinput +rb +rbio +rbootd +rbox +rbtree +rc +rc.conf +rc.d +rc.local +rc.shutdown +rc.subr +rcache +rcmd +rcons +rcorder +rcp +rcs +rcsclean +rcsdiff +rcsfile +rcsfreeze +rcsid +rcsintro +rcslog +rcsmerge +rd +rdate +rdcide +rdcpcib +rdcphy +rdev +rdevmajor +rdevminor +rdisc +rdist +rdlock +rdmsr +rdn +rdtsc +rdump +rdwr +re +readdir +readdisklabel +readelf +readline +readlinev +readlink +readlinkat +readonly +readv +readword +realloc +reallocarr +reallocarray +realpath +receiptrequest +recipientinfos +recno +recv +recvfrom +recvmmsg +recvmsg +ref +reg +regasub +regcomp +regerror +regex +regexec +regexp +regfree +registerrpc +regnsub +reinit +rekey +rel +rela +rele +reloc +remainderf +removeflags +remque +remquo +remquof +renameat +renice +rep +replymsg +repquota +req +res +resched +resettodr +resetty +resizeterm +resolv.conf +resolvconf +resolvconf.conf +responsedata +resstat +rev +revlookup +revnetgroup +rewinddir +rexec +rexecd +rf +rfcomm +rfmon +rgephy +rhosts +rindex +rint +rintf +rintl +ripemd +ripoffline +rl +rlog +rlogin +rlogind +rlphy +rm +rmdir +rmextattr +rmidi +rmp +rmt +rmtcall +rmtops +rnd +rndc +rndc-confgen +rndc.conf +rndctl +rndsink +ro +roff +rootconf +rootmountalloc +rootok +rounddown +roundf +roundl +roundrobin +roundup +route.conf +routed +rowid +rpc +rpc.bootparamd +rpc.lockd +rpc.pcnfsd +rpc.rquotad +rpc.rstatd +rpc.rusersd +rpc.rwalld +rpc.sprayd +rpc.statd +rpc.yppasswdd +rpcb +rpcbind +rpcgen +rpcinfo +rpm +rquotad +rr +rrestore +rresvport +rs +rsa +rsapublickey +rsautl +rsh +rshd +rsp +rssadapt +rstatd +rstate +rt +rtadvd +rtadvd.conf +rtc +rtfps +rth +rthdr +rtii +rtk +rtld +rtquery +rtsol +rtsold +rtsx +rtw +rtwn +rump +rump.dhcpclient +rump.halt +rumpclient +rumpfs +rumphijack +rumpkernel +rumpuser +rup +ruptime +ruserok +rusers +rusersd +rw +rwall +rwalld +rwho +rwhod +rwlock +rwlockattr +rz +sa +sab +sableio +sabtty +sasl +saslc +saslc.d +satalink +satmgr +savagedrm +savecore +savetty +sb +sbkeygen +sbp +sbrk +sbt +sbtool +sbus +sc +scache +scalb +scalbf +scalbn +scalbnf +scalbnl +scanc +scandir +scanf +scanstat +scanstatus +scanw +scc +sched +schedctl +schedparam +schide +sco +scp +screenblank +scrl +scrollok +scsi +scsibus +scsictl +scsipi +sd +sdhc +sdiff +sdmmc +sdp +sdpd +sdpquery +sdtemp +se +sea +sealinit +secmodel +securelevel +securetty +security.conf +sed +seek +seekdir +seeprom +segclean +segwait +seldestroy +selectable +selinit +selnotify +selrecord +sem +semctl +semget +semop +send-pr +sendmail +sendmmsg +sendmsg +sendrecv +sendreply +sendsig +sendto +sensor +seq +ser +ses +sess +setaddrs +setaffinity +setattr +setbindtries +setbit +setbuf +setbuffer +setcancelstate +setcanceltype +setcksumtype +setclasscontext +setclock +setcontext +setcreatesuspend +setcred +setdetachstate +setdirection +setdisklabel +setdisktab +setdomainname +setegid +setencstat +setenv +seterrarg +seterrhand +seteuid +setextattr +setfilter +setflags +setfsent +setfunc +setgid +setgrent +setgroupent +setgroups +setguardsize +sethardlimit +sethiwat +sethostent +sethostid +sethostname +setinheritsched +setint +setitimer +setivector +setjmp +setkey +setkeytype +setlinebuf +setlocale +setlocalseqnumber +setlocalsubkey +setlogin +setlogmask +setlowat +setmode +setname +setnetbootinfo +setnetconfig +setnetent +setnetgrent +setnetpath +setnonblock +setobjstat +setpagesize +setparam +setpassent +setpgid +setpgroup +setpgrp +setpos +setprefix +setprioceiling +setpriority +setprivate +setproctitle +setprogname +setprop +setprotocol +setprotoent +setpshared +setpublicfs +setpwent +setrcache +setregid +setremoteseqnumber +setremotesubkey +setresgid +setresuid +setreuid +setrgid +setrlimit +setroot +setrpcent +setruid +setschedparam +setschedpolicy +setscheduler +setscope +setscrreg +setservent +setservers +setshstrndx +setsid +setsigdefault +setsigmask +setsize +setsockopt +setspecific +setstack +setstackaddr +setstacksize +setstate +setsyx +setterm +settime +settimeofday +setttyent +setttyentpath +settype +setuid +setupterm +setusercontext +setuserkey +setusershell +setutxent +setvbuf +sf +sfb +sftp +sftp-server +sgivol +sgsmix +sh +sha +shar +shb +shdr +shiftin +shiftout +shlock +shm +shmat +shmctl +shmdt +shmget +shmif +showexport +showmount +showq +shpcic +shquote +shquotev +shutdownhook +si +siblingof +sig +sigaction +sigactsfree +sigactsinit +sigactsunshare +sigaddset +sigaltstack +sigblock +sigcode +sigdelset +sigemptyset +sigevent +sigexit +sigfillset +sighold +sigignore +siginfo +siginit +siginterrupt +sigismember +siglist +siglongjmp +sigmask +signalname +signalnext +signalnumber +signame +signbit +signedint +signerinfos +significand +significandf +signinit +sigpause +sigpending +sigprocmask +sigqueue +sigqueueinfo +sigrelse +sigset +sigsetjmp +sigsetmask +sigsetops +sigstack +sigsuspend +sigtimedwait +sigtramp +sigvec +sigwait +sigwaitinfo +sii +siisata +simpleq +sin +sinf +singlethread +sinh +sinhf +siop +sip +sisdrm +siside +sizeof +sk +skc +skey +skeyaudit +skeychallenge +skeygetnext +skeyinfo +skeyinit +skeylookup +skeyverify +skeyzero +skipidtype +skiprecord +skpc +sl +slattach +slhci +sliplogin +slist +slk +slogin +slstats +sm +smbfs +smbus +smbutil +smime +smsc +smscmon +smsh +smtp +smtpd +sn +sname +snaplen +snapper +snprintb +snprintf +sntp +snvis +so +soc +sock +sockaddr +sockatmark +socketpair +sockopt +sockstat +soekrisgpio +soelim +softint +softintr +solaris +sony +sort +sortinfo +sourcepath +sp +spawnattr +spawnp +spc +spcreateerror +spdmem +speaker +sperrno +sperror +spi +spic +spif +spinlockinit +spinlockmgr +spkac +spkr +spl +splbio +splclock +splhigh +splimp +split +spllower +spllowersoftclock +splnet +splraise +splraiseipl +splsched +splserial +splsoftbio +splsoftclock +splsoftnet +splsoftserial +splstatclock +spltty +splvm +splx +sppd +sprayd +sprintf +sq +sql +sqlite +sqphy +sqrt +sqrtf +sqrtl +sradixsort +srand +srandom +src +srcfileno +srcfiles +srclang +srclines +srtconfig +ss +sscanf +ssh +ssh-add +ssh-agent +ssh-keygen +ssh-keyscan +ssh-keysign +sshd +ssio +ssl +ssp +st +stailq +standend +startstop +stat +statd +statfile +stathz +statustostr +statvfs +stdarg +stdbool +stddef +stderr +stdethers +stdhosts +stdin +stdint +stdio +stdlib +stdout +ste +stf +stge +sti +stmt +stmtstatus +stpcide +stpcpy +stpncpy +str +straddch +stravis +strcasecmp +strcasestr +strcat +strchr +strchrnul +strcmp +strcoll +strcpy +strcspn +strdup +strerror +stresep +strfile +strfmon +strftime +strglob +stricmp +stringa +stringb +stringlist +strlcat +strlcpy +strlen +strlike +strm +strmode +strn +strncasecmp +strncat +strncmp +strncpy +strndup +strnlen +strnstr +strnunvis +strnunvisx +strnvis +strnvisx +strpbrk +strpct +strptime +strptr +strrchr +strsep +strsignal +strsnvis +strsnvisx +strspct +strspn +strstr +strsuftoll +strsuftollx +strsvis +strsvisx +strtod +strtof +strtoi +strtoimax +strtok +strtol +strtold +strtoll +strtonum +strtoq +strtou +strtoul +strtoull +strtoumax +strtouq +strunvis +strunvisx +strvis +strvisx +strxfrm +stty +stuirda +su +suballoc +submatch +subpad +subpath +subst +subwin +subyte +suibyte +suiword +sunlabel +sunos +sup +supfilesrv +supplicant +supplicant.conf +supscan +supservers +suser +suspendctl +suspendsched +suswintr +susword +suword +sv +svc +svcerr +svcfd +svcraw +svctcp +svcudp +svhlabel +svis +svwsata +sw +swab +swapcontext +swapctl +swapon +swcrypto +switchto +switchtoconsole +swprintf +swscanf +swsensor +swwdog +sym +syminfo +symlink +symlinkat +symshndx +sync +syncbus +syncok +sys +sysarch +sysbeep +syscall +sysconf +sysctl +sysctl.conf +sysctlbyname +sysctlfs +sysctlgetmibinfo +sysctlnametomib +sysexits +sysinst +syslog +syslog.conf +syslogd +syslogp +sysmon +syspuffs +sysstat +systat +systemerr +sysvbfs +tabsize +tadpolectl +tailq +talkd +tanf +tanh +tanhf +tar +targ +taskq +tbl +tbrconfig +tc +tcasic +tcdrain +tcds +tcflow +tcflush +tcgetattr +tcgetpgrp +tcgetsid +tcic +tco +tcom +tcopy +tcp +tcpdchk +tcpdmatch +tcpdrop +tcpdump +tcsendbreak +tcsetattr +tcsetpgrp +tctrl +tcu +tcx +tda +tdelete +tdfxdrm +tdvfb +tee +teliosio +telldir +telnet +telnetd +temp +tempnam +termcap +terminfo +termios +termname +testcancel +testctrl +tetris +texindex +texinfo +textdomain +tfb +tfind +tfmtodit +tftp +tftp-proxy +tftpd +tgamma +tgammaf +tgetent +tgetflag +tgetnum +tgetstr +tgmath +tgoto +tgt +thinkpad +threadsafe +ti +tic +tick +tickadj +tigetflag +tigetnum +tigetstr +timecounter +timed +timedc +timedlock +timedrdlock +timedreceive +timedsend +timedwait +timedwrlock +timegm +timelocal +timeofday +timeoff +timeradd +timerclear +timercmp +timerisset +timersub +timespec +timespecadd +timespecclear +timespeccmp +timespecisset +timespecsub +timeval +timezone +tiparm +tkt +tl +tli +tlp +tlphy +tlsb +tlsbmem +tlsext +tlsmgr +tlsproxy +tm +tmac +tmp +tmpfile +tmpfs +tmpnam +tmux +to +toascii +todr +tok +tolower +topcat +touchoverlap +touchwin +toupper +towctrans +towlower +towupper +tp +tparm +tpctl +tpfmt +tpm +tprintf +tprof +tput +tputs +tqphy +tr +tra +traceroute +trailingspace +transferlockers +trapsignal +trivial-rewrite +trm +troff +trpt +trunc +truncate +truncf +truncl +tryenter +trylock +tryrdlock +tryupgrade +trywait +trywrlock +ts +tsc +tsciic +tsearch +tset +tsget +tsleep +tslot +tsort +tsp +tst +tstamp +ttwoga +ttwopci +tty +ttyaction +ttyconv +ttyflags +ttyldisc +ttylock +ttymsg +ttyname +ttyprintf +ttys +ttyslot +ttyunlock +tu +tun +tunefs +tvctrl +tvpll +tvtohz +twa +twalk +twe +txp +txt +typeahead +typename +typeof +tzalloc +tzfile +tzfree +tzgetgmtoff +tzgetname +tzset +tzsetwall +ualarm +ualea +uao +uark +uatp +uaudio +ubc +uberry +ubsa +ubsec +ubt +ucas +uchcom +ucom +ucontext +ucycom +uda +udav +udf +udp +udsbr +uep +ufs +uftdi +ug +ugen +ugensa +uha +uhci +uhid +uhidev +uhmodem +uhso +uhub +ui +uid +uint +uio +uiomove +uipaq +uirda +uk +ukbd +ukfs +ukphy +ukyopon +ul +ulimit +ulong +ulpt +ultrix +umap +umask +umass +umcs +umct +umidi +umodem +umount +ums +uname +unbound +unbound-anchor +unbound-checkconf +unbound-control +unbound-host +unbound.conf +uncompress +unconfig +unconst +unctrl +undef +undefined +undelete +underend +underscore +unexpand +ungetc +ungetch +ungetwc +unicast +unichar +unifdef +unifdefall +union +uniq +unistd +units +unix +unixbp +unlinkat +unlockpt +unlzf +unlzma +unmountall +unparse +unpost +unreg +unsetenv +unstr +untouchwin +unvis +unxz +updatestats +updlastlogx +updwtmpx +upgt +upl +uplcom +uprintf +uptime +urandom +uri +urio +url +urldesc +urlphy +urndis +urtw +urtwn +us +usb +usbd +usbdevs +usbdi +usbhid +usbhidaction +usbhidctl +usbtask +uscanner +useradd +userconf +userdb +userdel +userinfo +usermgmt.conf +usermod +username +userptr +userret +usleep +uslsa +usmsc +usscanner +ustar +ustir +ut +uthum +util +utime +utimens +utimensat +utimes +utmp +utmpx +utmpxname +utoppy +utoppya +utrace +uts +uturn +uu +uudecode +uuencode +uuid +uuidgen +uvideo +uvisor +uvm +uvmspace +uvn +uvscom +uyap +uyurex +va +vaccess +vaddr +val +vald +valloc +valz +var +varname +vasprintf +vattr +vbi +vc +vcache +vcons +vdead +vdevgone +vdprintf +veriexec +veriexecctl +veriexecgen +verifyinit +verr +verrc +verror +verrx +vers +vfinddev +vflush +vflushbuf +vfork +vfprintf +vfs +vfscanf +vfsops +vfssubr +vfwprintf +vfwscanf +vga +vgcfgbackup +vgcfgrestore +vgchange +vgck +vgconvert +vgcreate +vgdisplay +vge +vget +vgexport +vgextend +vgimport +vgmerge +vgmknodes +vgone +vgonel +vgreduce +vgremove +vgrename +vgrind +vgrindefs +vgs +vgscan +vgsplit +vhold +vi +viadrm +viaenv +viaide +vidcaudio +vidcvideo +videoctl +vinfo +vinvalbuf +vioif +viomb +viornd +vioscsi +vipw +virecover +virt +virtio +vis +vlan +vline +vlog +vme +vmem +vmmon +vmnet +vmstat +vmt +vmx +vn +vnconfig +vnd +vndcompress +vndconfig +vnduncompress +vnfileops +vnode +vnodeops +vnp +vnsubr +voidop +voodoofb +vop +vp +vpanic +vpd +vprint +vprintf +vprompt +vptofh +vput +vr +vrecycle +vref +vrele +vs +vscanf +vslock +vsnprintf +vsprintf +vsscanf +vsunlock +vswprintf +vswscanf +vsyslog +vsyslogp +vtab +vte +vtruncbuf +vv +vwakeup +vwarn +vwarnc +vwarnx +vwprintf +vwscanf +waddch +waddchnstr +waddchstr +waddnstr +waddstr +waitid +waitpid +wakeonlan +wakeup +wal +wapbl +warc +wargames +warnc +warnx +watchdog +wattr +wattroff +wattron +wattrset +wax +wb +wbkgd +wbkgdset +wborder +wbsio +wc +wchgat +wclear +wclrtobot +wclrtoeol +wcolor +wcrtomb +wcscasecmp +wcscat +wcschr +wcscmp +wcscoll +wcscpy +wcscspn +wcsdup +wcsftime +wcslcat +wcslcpy +wcslen +wcsncasecmp +wcsncat +wcsncmp +wcsncpy +wcsnlen +wcspbrk +wcsrchr +wcsrtombs +wcsspn +wcsstr +wcstod +wcstof +wcstoimax +wcstok +wcstol +wcstold +wcstoll +wcstombs +wcstoul +wcstoull +wcstoumax +wcswcs +wcswidth +wcsxfrm +wctob +wctomb +wctrans +wctype +wcursyncup +wcwidth +wd +wdc +wdelch +wdeleteln +wdeletestr +wdogctl +wds +wdsc +weakauth +weakname +wechochar +wedge +weekly +weekly.conf +wend +werase +wesc +wget +wgetc +wgetch +wgetnstr +wgets +wgetstr +whatattr +whatform +whatis +whereis +whiteout +whline +whoami +whois +wi +wiconfig +win +winch +winchnstr +winchstr +winit +winnstr +winsch +winsdelln +winsertln +winsertstr +winstr +wintouched +wire-test +wizd +wlanctl +wline +wm +wmb +wmd +wmemchr +wmemcmp +wmemcpy +wmemmove +wmemset +wmemstream +wmidell +wmieeepc +wmihp +wmimsi +wmove +wnoutrefresh +wordexp +workqueue +wpa +wparse +wpi +wprintf +wprintw +wpush +wrapstring +wrefresh +wreset +wresize +writebuf +writechk +writedisklabel +writer +writev +wrlock +wrmsr +wrtheader +wscanf +wscanw +wscons +wscons.conf +wsconscfg +wsconsctl +wscrl +wsdisplay +wsdisplaydevprint +wsemuldisplaydevprint +wset +wsetscrreg +wsfont +wsfontload +wskbd +wskbddevprint +wsmouse +wsmoused +wsmoused.conf +wsmousedevprint +wsmux +wsmuxctl +wss +wstandend +wstandout +wstr +wsyncup +wt +wtf +wtimeout +wtmp +wtmpx +wtouchln +wump +wunderend +wunderscore +wvline +www +xalloc +xar +xargs +xbd +xbdback +xbox +xc +xcall +xcbc +xcfb +xd +xdr +xdrmem +xdrrec +xdrstdio +xenbus +xenix +xennet +xfree +xge +xgettext +xhci +xi +xirc +xlatetof +xlatetom +xmlwf +xname +xpci +xprt +xsh +xstr +xsurf +xt +xvif +xy +xz +xzcat +yacc +yds +ym +ymdhms +yn +ynf +yp +ypbind +ypcat +ypclnt +yperr +ypinit +ypmatch +yppasswd +yppasswdd +yppoll +ypprot +yppush +ypserv +ypset +yptest +ypwhich +ypxfr +zalloc +zcat +zcmp +zdb +zdiff +zdump +zegrep +zerorange +zfgrep +zforce +zfs +zgrep +zic +zip +zless +zlib +zmore +znew +zpool +zs +zsc +zssc +zstty +zx +zyd +zzz