static VALUE *eval5(void)
{
VALUE *l, *r, *v;
l = eval6();
while (nextarg(":")) {
G.args++;
r = eval6();
v = docolon(l, r);
freev(l);
freev(r);
l = v;
}
return l;
}
static VALUE *eval(void)
{
VALUE *l, *r;
l = eval1();
while (nextarg("|")) {
G.args++;
r = eval1();
if (null(l)) {
freev(l);
l = r;
} else
freev(r);
}
return l;
}
static VALUE *eval1(void)
{
VALUE *l, *r;
l = eval2();
while (nextarg("&")) {
G.args++;
r = eval2();
if (null(l) || null(r)) {
freev(l);
freev(r);
l = int_value(0);
} else
freev(r);
}
return l;
}
static VALUE *eval3(void)
{
VALUE *l, *r;
int op;
arith_t val;
l = eval4();
while (1) {
op = nextarg("+");
if (!op) {
op = nextarg("-");
if (!op) return l;
}
G.args++;
r = eval4();
val = arithmetic_common(l, r, op);
freev(l);
freev(r);
l = int_value(val);
}
}
static void
search_whatis(char *whatpath, char *word)
{
FILE *fp;
char *line = NULL;
size_t linecap = 0;
char *pkwd;
regex_t preg;
char **ss = NULL;
char s[MAXNAMELEN];
int i;
if ((fp = fopen(whatpath, "r")) == NULL) {
perror(whatpath);
return;
}
DPRINTF("-- Found %s: %s\n", WHATIS, whatpath);
/* Build keyword regex */
if (asprintf(&pkwd, "%s%s%s", (whatis) ? "\\<" : "",
word, (whatis) ? "\\>" : "") == -1)
err(1, "asprintf");
if (regcomp(&preg, pkwd, REG_BASIC | REG_ICASE | REG_NOSUB) != 0)
err(1, "regcomp");
if (sargs)
ss = split(mansec, ',');
while (getline(&line, &linecap, fp) > 0) {
if (regexec(&preg, line, 0, NULL, 0) == 0) {
if (sargs) {
/* Section-restricted search */
for (i = 0; ss[i] != NULL; i++) {
(void) snprintf(s, sizeof (s), "(%s)",
ss[i]);
if (strstr(line, s) != NULL) {
(void) printf("%s", line);
break;
}
}
} else {
(void) printf("%s", line);
}
}
}
if (ss != NULL)
freev(ss);
free(pkwd);
(void) fclose(fp);
}
vector data_get_intensive_derivative(SimpleGraphData * data)
{
if (data->b_derivative_intensive_norm == 0)
{
vector intensive = data_get_intensive_norm(data);
vector derivative_intensive = derivativev(intensive);
data->d_derivative_intensive_norm = normalizev(derivative_intensive, MASK_MIN, MASK_MAX);
freev(derivative_intensive);
data->b_derivative_intensive_norm == 1;
}
return data->d_derivative_intensive_norm;
}
vector data_get_intensive_cutted(SimpleGraphData * data)
{
if (data->b_intensive_cutted == 0)
{
vector intensive = data_get_intensive(data);
vector pitch_log = data_get_pitch_log(data);
vector resized_pitch_log = vector_resize(pitch_log, intensive.x);
data->d_intensive_cutted = vector_cut_by_mask(intensive, resized_pitch_log);
freev(resized_pitch_log);
data->b_intensive_cutted = 1;
}
return data->d_intensive_cutted;
}
static VALUE *eval6(void)
{
static const char keywords[] ALIGN1 =
"quote\0""length\0""match\0""index\0""substr\0";
VALUE *r, *i1, *i2;
static VALUE *l = NULL;
static VALUE *v = NULL;
int key = *G.args ? index_in_strings(keywords, *G.args) + 1 : 0;
if (key == 0) /* not a keyword */
return eval7();
G.args++; /* We have a valid token, so get the next argument. */
if (key == 1) { /* quote */
if (!*G.args)
bb_error_msg_and_die("syntax error");
return str_value(*G.args++);
}
if (key == 2) { /* length */
r = eval6();
tostring(r);
v = int_value(strlen(r->u.s));
freev(r);
} else
l = eval6();
if (key == 3) { /* match */
r = eval6();
v = docolon(l, r);
freev(l);
freev(r);
}
if (key == 4) { /* index */
r = eval6();
tostring(l);
tostring(r);
v = int_value(strcspn(l->u.s, r->u.s) + 1);
if (v->u.i == (arith_t) strlen(l->u.s) + 1)
v->u.i = 0;
freev(l);
freev(r);
}
if (key == 5) { /* substr */
i1 = eval6();
i2 = eval6();
tostring(l);
if (!toarith(i1) || !toarith(i2)
|| i1->u.i > (arith_t) strlen(l->u.s)
|| i1->u.i <= 0 || i2->u.i <= 0)
v = str_value("");
else {
v = xmalloc(sizeof(VALUE));
v->type = STRING;
v->u.s = xstrndup(l->u.s + i1->u.i - 1, i2->u.i);
}
freev(l);
freev(i1);
freev(i2);
}
return v;
}
void freeSimpleGraphData(SimpleGraphData * data)
{
freev(data->d_full_wave);
freev(data->d_pitch_original);
if (data->b_pitch == 1) freev(data->d_pitch);
if (data->b_pitch_norm == 1) freev(data->d_pitch_norm);
if (data->b_pitch_log == 1) freev(data->d_pitch_log);
if (data->b_pitch_derivative == 1) freev(data->d_pitch_derivative);
freev(data->d_intensive_original);
if (data->b_intensive == 1) freev(data->d_intensive);
if (data->b_intensive_cutted == 1) freev(data->d_intensive_cutted);
if (data->b_intensive_norm == 1) freev(data->d_intensive_norm);
if (data->b_intensive_smooth == 1) freev(data->d_intensive_smooth);
if (data->b_derivative_intensive_norm == 1) freev(data->d_derivative_intensive_norm);
freev(data->d_spec_proc);
if (data->b_spec == 1) freev(data->d_spec);
if (data->b_spec_norm == 1) freev(data->d_spec_norm);
if (data->b_cepstrum == 1) freev(data->d_cepstrum);
if (data->b_cepstrum_norm == 1) freev(data->d_cepstrum_norm);
freev(data->d_mask);
freeiv(data->md_p.pointsFrom);
freeiv(data->md_p.pointsLength);
freeiv(data->md_t.pointsFrom);
freeiv(data->md_t.pointsLength);
freeiv(data->md_n.pointsFrom);
freeiv(data->md_n.pointsLength);
if (data->file_data)
{
waveCloseFile(data->file_data);
}
}
void freeGraphData(GraphData * data)
{
freev(data->d_intensive_original);
freev(data->d_intensive);
freev(data->d_pitch_original);
freev(data->d_pitch);
freev(data->d_pitch_log);
freev(data->d_spec);
freev(data->d_spec_proc);
freev(data->d_wave);
freev(data->d_full_wave);
freev(data->d_mask);
freev(data->d_p_wave);
freev(data->d_t_wave);
freev(data->d_n_wave);
freev(data->p_mask);
freev(data->n_mask);
freev(data->t_mask);
freev(data->pnt_mask);
}
SimpleGraphData * SimpleProcWave2Data(QString fname, bool keepWaveData)
{
qDebug() << "::SimpleProcWave2Data" << LOG_DATA;
SPTK_SETTINGS * sptk_settings = SettingsDialog::getSPTKsettings();
SimpleGraphData * data = new SimpleGraphData();
data->b_pitch = 0;
data->b_pitch_log = 0;
data->b_pitch_derivative = 0;
data->b_intensive = 0;
data->b_intensive_cutted = 0;
data->b_intensive_norm = 0;
data->b_intensive_smooth = 0;
data->b_derivative_intensive_norm = 0;
data->b_spec = 0;
data->b_cepstrum = 0;
data->b_pitch_norm = 0;
QFile file(fname);
qDebug() << "::SimpleProcWave2Data QFile" << fname << LOG_DATA;
file.open(QIODevice::ReadOnly);
qDebug() << "::SimpleProcWave2Data file.open " << file.isOpen() << LOG_DATA;
WaveFile * waveFile = waveOpenHFile(file.handle());
qDebug() << "::SimpleProcWave2Data waveOpenFile" << LOG_DATA;
data->file_data = waveFile;
int size = littleEndianBytesToUInt32(waveFile->dataChunk->chunkDataSize);
qDebug() << "::SimpleProcWave2Data chunkDataSize " << size << LOG_DATA;
short int bits = littleEndianBytesToUInt16(waveFile->formatChunk->significantBitsPerSample);
qDebug() << "::SimpleProcWave2Data significantBitsPerSample " << bits << LOG_DATA;
double seconds = 1.0 * size / RECORD_FREQ / bits * CHAR_BIT;
qDebug() << "::SimpleProcWave2Data seconds=" << seconds << LOG_DATA;
data->seconds = seconds;
vector wave = sptk_v2v(waveFile->dataChunk->waveformData, size, bits);
qDebug() << "::SimpleProcWave2Data wave" << LOG_DATA;
vector norm_wave = normalizev(wave, 0.0, 1.0);
qDebug() << "::SimpleProcWave2Data norm_wave" << LOG_DATA;
data->d_full_wave = norm_wave;
vector frame = sptk_frame(wave, sptk_settings->frame);
qDebug() << "::SimpleProcWave2Data frame" << LOG_DATA;
vector intensive = vector_intensive(wave, sptk_settings->frame->leng, sptk_settings->frame->shift);
qDebug() << "::SimpleProcWave2Data intensive" << LOG_DATA;
data->d_intensive_original = intensive;
vector window = sptk_window(frame, sptk_settings->window);
qDebug() << "::SimpleProcWave2Data window" << LOG_DATA;
vector lpc = sptk_lpc(frame, sptk_settings->lpc);
qDebug() << "::SimpleProcWave2Data lpc " << lpc.x << LOG_DATA;
vector lpc2c = sptk_lpc2c(lpc, sptk_settings->lpc);
qDebug() << "::SimpleProcWave2Data lpc2c " << lpc2c.x;
data->d_cepstrum = lpc2c;
data->b_cepstrum = 1;
vector spec = sptk_spec(lpc, sptk_settings->spec);
qDebug() << "::SimpleProcWave2Data spec " << maxv(spec) << LOG_DATA;
data->d_spec = spec;
data->b_spec = 1;
vector spec_proc;
if (sptk_settings->spec->proc == 0){
spec_proc = vector_pow_log(spec, sptk_settings->spec->factor, sptk_settings->spec->min);
qDebug() << "::SimpleProcWave2Data spec_log" << LOG_DATA;
} else if (sptk_settings->spec->proc == 1){
spec_proc = vector_pow_exp(spec, sptk_settings->spec->factor, sptk_settings->spec->min);
qDebug() << "::SimpleProcWave2Data spec_exp" << LOG_DATA;
}
qDebug() << "::SimpleProcWave2Data spec_proc " << maxv(spec_proc) << LOG_DATA;
data->d_spec_proc = spec_proc;
vector smooth_wave = vector_smooth_lin(wave, sptk_settings->dp->smooth_frame);
vector pitch = processZeros(sptk_pitch_spec(smooth_wave, sptk_settings->pitch, intensive.x));
qDebug() << "::SimpleProcWave2Data pitch" << LOG_DATA;
data->d_pitch_original = pitch;
int otype = sptk_settings->pitch->OTYPE;
sptk_settings->pitch->OTYPE = 2;
vector pitch_log = sptk_pitch_spec(smooth_wave, sptk_settings->pitch, intensive.x);
sptk_settings->pitch->OTYPE = otype;
vector pitch_log_norm = normalizev(pitch_log, MASK_MIN, MASK_MAX);
qDebug() << "::SimpleProcWave2Data pitch_log" << LOG_DATA;
data->d_pitch_log = pitch_log_norm;
data->b_pitch_log = 1;
data->d_intensive = data_get_intensive(data);
data->d_intensive_norm = data_get_intensive_norm(data);
vector file_mask;
WaveFile * procFile = waveFile;
if (sptk_settings->dp->auto_marking)
{
procFile = selectMarkoutAlgorithm(data);
}
file_mask = getFileMask(procFile, wave, pitch.x);
data->md_p = getLabelsFromFile(procFile, MARK_PRE_NUCLEUS);
data->md_n = getLabelsFromFile(procFile, MARK_NUCLEUS);
data->md_t = getLabelsFromFile(procFile, MARK_POST_NUCLEUS);
if (sptk_settings->dp->auto_marking)
{
waveCloseFile(procFile);
}
qDebug() << "::SimpleProcWave2Data file_mask" << LOG_DATA;
vector mask_and = vector_mask_and(pitch_log_norm, file_mask);
vector mask = vector_smooth_mid(mask_and, 10);
qDebug() << "::SimpleProcWave2Data mask" << LOG_DATA;
data->d_mask = mask;
vector inverted_mask = vector_invert_mask(mask);
qDebug() << "::SimpleProcWave2Data inverted_mask" << LOG_DATA;
vector pitch_interpolate = vector_interpolate_by_mask(
pitch,
inverted_mask,
0,
sptk_settings->plotF0->interpolation_type
);
qDebug() << "::SimpleProcWave2Data pitch_interpolate" << LOG_DATA;
vector pitch_mid = vector_smooth_mid(pitch_interpolate, sptk_settings->plotF0->frame);
qDebug() << "::SimpleProcWave2Data pitch_mid" << LOG_DATA;
data->d_pitch = pitch_mid;
data->b_pitch = 1;
data->d_derivative_intensive_norm = data_get_intensive_derivative(data);
freev(frame);
freev(window);
freev(lpc);
freev(wave);
freev(pitch_interpolate);
freev(inverted_mask);
freev(smooth_wave);
freev(pitch_log);
freev(file_mask);
freev(mask_and);
qDebug() << "::SimpleProcWave2Data freev" << LOG_DATA;
file.close();
qDebug() << "::SimpleProcWave2Data file.close" << LOG_DATA;
if (keepWaveData)
{
waveFile->file = NULL;
} else {
data->file_data = NULL;
waveCloseFile(waveFile);
qDebug() << "::SimpleProcWave2Data waveCloseFile" << LOG_DATA;
}
return data;
}
GraphData * ProcWave2Data(QString fname)
{
SPTK_SETTINGS * sptk_settings = SettingsDialog::getSPTKsettings();
QFile file(fname);
file.open(QIODevice::ReadOnly);
WaveFile * waveFile = waveOpenHFile(file.handle());
qDebug() << "waveOpenFile" << LOG_DATA;
int size = littleEndianBytesToUInt32(waveFile->dataChunk->chunkDataSize);
qDebug() << "chunkDataSize" << LOG_DATA;
short int bits = littleEndianBytesToUInt16(waveFile->formatChunk->significantBitsPerSample);
qDebug() << "significantBitsPerSample" << LOG_DATA;
vector wave = sptk_v2v(waveFile->dataChunk->waveformData, size, bits);
qDebug() << "wave" << LOG_DATA;
vector frame = sptk_frame(wave, sptk_settings->frame);
qDebug() << "frame" << LOG_DATA;
vector intensive = vector_intensive(frame, sptk_settings->frame->leng, sptk_settings->frame->shift);
qDebug() << "intensive" << LOG_DATA;
vector window = sptk_window(frame, sptk_settings->window);
qDebug() << "window" << LOG_DATA;
vector lpc = sptk_lpc(frame, sptk_settings->lpc);
qDebug() << "lpc" << LOG_DATA;
vector spec = sptk_spec(lpc, sptk_settings->spec);
qDebug() << "spec " << maxv(spec) << LOG_DATA;
vector spec_proc;
if (sptk_settings->spec->proc == 0){
spec_proc = vector_pow_log(spec, sptk_settings->spec->factor, sptk_settings->spec->min);
qDebug() << "spec_log" << LOG_DATA;
} else if (sptk_settings->spec->proc == 1){
spec_proc = vector_pow_exp(spec, sptk_settings->spec->factor, sptk_settings->spec->min);
qDebug() << "spec_exp" << LOG_DATA;
}
qDebug() << "spec_proc " << maxv(spec_proc) << LOG_DATA;
vector pitch = processZeros(sptk_pitch_spec(wave, sptk_settings->pitch, intensive.x));
qDebug() << "pitch" << LOG_DATA;
vector mask = getFileMask(waveFile, wave, pitch.x);
qDebug() << "mask" << LOG_DATA;
vector pitch_cutted = processZeros(vector_cut_by_mask(pitch, mask));
qDebug() << "pitch_cutted" << LOG_DATA;
double pitch_min = getv(pitch_cutted, minv(pitch_cutted));
double pitch_max = getv(pitch_cutted, maxv(pitch_cutted));
vector intensive_cutted = vector_cut_by_mask(intensive, mask);
qDebug() << "intensive_cutted" << LOG_DATA;
vector inverted_mask = vector_invert_mask(mask);
qDebug() << "inverted_mask" << LOG_DATA;
vector pitch_interpolate = vector_interpolate_by_mask(
pitch_cutted,
inverted_mask,
0,
sptk_settings->plotF0->interpolation_type
);
qDebug() << "pitch_interpolate" << LOG_DATA;
vector intensive_interpolate = vector_interpolate_by_mask(
intensive_cutted,
inverted_mask,
0,
sptk_settings->plotEnergy->interpolation_type
);
qDebug() << "intensive_interpolate" << LOG_DATA;
vector pitch_mid = vector_smooth_mid(pitch_interpolate, sptk_settings->plotF0->frame);
qDebug() << "pitch_mid" << LOG_DATA;
vector intensive_mid = vector_smooth_lin(intensive_interpolate, sptk_settings->plotEnergy->frame);
qDebug() << "intensive_mid" << LOG_DATA;
vector norm_wave = normalizev(wave, 0.0, 1.0);
MaskData md_p = getLabelsFromFile(waveFile, MARK_PRE_NUCLEUS);
MaskData md_n = getLabelsFromFile(waveFile, MARK_NUCLEUS);
MaskData md_t = getLabelsFromFile(waveFile, MARK_POST_NUCLEUS);
vector p_mask = readMaskFromFile(waveFile, wave.x, MARK_PRE_NUCLEUS);
qDebug() << "p_mask" << LOG_DATA;
vector n_mask = readMaskFromFile(waveFile, wave.x, MARK_NUCLEUS);
qDebug() << "n_mask" << LOG_DATA;
vector t_mask = readMaskFromFile(waveFile, wave.x, MARK_POST_NUCLEUS);
qDebug() << "t_mask" << LOG_DATA;
vector p_wave = zero_to_nan(vector_cut_by_mask(norm_wave, p_mask));
qDebug() << "p_mask" << LOG_DATA;
vector n_wave = zero_to_nan(vector_cut_by_mask(norm_wave, n_mask));
qDebug() << "n_mask" << LOG_DATA;
vector t_wave = zero_to_nan(vector_cut_by_mask(norm_wave, t_mask));
qDebug() << "t_mask" << LOG_DATA;
vector pnt_mask = onesv(norm_wave.x);
for (int i=0; i<p_mask.x && i<n_mask.x && i<t_mask.x && i<norm_wave.x; i++) {
if (getv(p_mask, i) == 1 || getv(n_mask, i) == 1 || getv(t_mask, i) == 1)
{
setv(pnt_mask, i, 0);
} else {
setv(pnt_mask, i, 1);
}
}
vector display_wave = zero_to_nan(vector_cut_by_mask(norm_wave, pnt_mask));
freev(frame);
freev(window);
freev(lpc);
freev(pitch_cutted);
freev(intensive_cutted);
freev(inverted_mask);
freev(pitch_interpolate);
freev(intensive_interpolate);
freev(wave);
qDebug() << "freev" << LOG_DATA;
file.close();
waveCloseFile(waveFile);
qDebug() << "waveCloseFile" << LOG_DATA;
GraphData * data = new GraphData();
data->d_full_wave = norm_wave;
data->d_wave = display_wave;
data->d_p_wave = p_wave;
data->d_n_wave = n_wave;
data->d_t_wave = t_wave;
data->d_pitch_original = pitch;
data->d_pitch = pitch_mid;
data->pitch_max = pitch_max;
data->pitch_min = pitch_min;
data->d_intensive_original = intensive;
data->d_intensive = intensive_mid;
data->d_spec_proc = spec_proc;
data->d_spec = spec;
data->d_mask = mask;
data->p_mask = p_mask;
data->n_mask = n_mask;
data->t_mask = t_mask;
data->pnt_mask = pnt_mask;
data->md_p = md_p;
data->md_t = md_t;
data->md_n = md_n;
return data;
}
/*
* This routine builds the manpage structure from MANPATH or PATH,
* depending on flags. See BMP_* definitions above for valid
* flags.
*/
static struct man_node *
build_manpath(char **pathv, int flags)
{
struct man_node *manpage = NULL;
struct man_node *currp = NULL;
struct man_node *lastp = NULL;
char **p;
char **q;
char *mand = NULL;
char *mandir = DEFMANDIR;
int s;
struct dupnode *didup = NULL;
struct stat sb;
s = sizeof (struct man_node);
for (p = pathv; *p != NULL; ) {
if (flags & BMP_ISPATH) {
if ((mand = path_to_manpath(*p)) == NULL)
goto next;
free(*p);
*p = mand;
}
q = split(*p, ',');
if (stat(q[0], &sb) != 0 || (sb.st_mode & S_IFDIR) == 0) {
freev(q);
goto next;
}
if (access(q[0], R_OK | X_OK) == 0) {
/*
* Some element exists. Do not append DEFMANDIR as a
* fallback.
*/
flags &= ~BMP_FALLBACK_DEFMANDIR;
if ((currp = (struct man_node *)calloc(1, s)) == NULL)
err(1, "calloc");
currp->frompath = (flags & BMP_ISPATH);
if (manpage == NULL)
lastp = manpage = currp;
getpath(currp, p);
getsect(currp, p);
/*
* If there are no new elements in this path,
* do not add it to the manpage list.
*/
if (dupcheck(currp, &didup) != 0) {
freev(currp->secv);
free(currp);
} else {
currp->next = NULL;
if (currp != manpage)
lastp->next = currp;
lastp = currp;
}
}
freev(q);
next:
/*
* Special handling of appending DEFMANDIR. After all pathv
* elements have been processed, append DEFMANDIR if needed.
*/
if (p == &mandir)
break;
p++;
if (*p != NULL)
continue;
if (flags & (BMP_APPEND_DEFMANDIR | BMP_FALLBACK_DEFMANDIR)) {
p = &mandir;
flags &= ~BMP_ISPATH;
}
}
free_dupnode(didup);
return (manpage);
}
int
main(int argc, char **argv)
{
int c, i;
char **pathv;
char *manpath = NULL;
static struct man_node *mandirs = NULL;
int bmp_flags = 0;
int ret = 0;
char *opts;
char *mwstr;
int catman = 0;
(void) setlocale(LC_ALL, "");
(void) strcpy(language, setlocale(LC_MESSAGES, (char *)NULL));
if (strcmp("C", language) != 0)
(void) strlcpy(localedir, language, MAXPATHLEN);
#if !defined(TEXT_DOMAIN)
#define TEXT_DOMAIN "SYS_TEST"
#endif
(void) textdomain(TEXT_DOMAIN);
if (strcmp(__progname, "apropos") == 0) {
apropos++;
opts = "M:ds:";
} else if (strcmp(__progname, "whatis") == 0) {
apropos++;
whatis++;
opts = "M:ds:";
} else if (strcmp(__progname, "catman") == 0) {
catman++;
makewhatis++;
opts = "P:M:w";
} else if (strcmp(__progname, "makewhatis") == 0) {
makewhatis++;
makewhatishere++;
manpath = ".";
opts = "";
} else {
opts = "FM:P:T:adfklprs:tw";
if (argc > 1 && strcmp(argv[1], "-") == 0) {
pager = "cat";
optind++;
}
}
opterr = 0;
while ((c = getopt(argc, argv, opts)) != -1) {
switch (c) {
case 'M': /* Respecify path for man pages */
manpath = optarg;
break;
case 'a':
all++;
break;
case 'd':
debug++;
break;
case 'f':
whatis++;
/*FALLTHROUGH*/
case 'k':
apropos++;
break;
case 'l':
list++;
all++;
break;
case 'p':
printmp++;
break;
case 's':
mansec = optarg;
sargs++;
break;
case 'r':
lintout++;
break;
case 't':
psoutput++;
break;
case 'T':
case 'P':
case 'F':
/* legacy options, compatibility only and ignored */
break;
case 'w':
makewhatis++;
break;
case '?':
default:
if (apropos)
usage_whatapro();
else if (catman)
usage_catman();
else if (makewhatishere)
usage_makewhatis();
else
usage_man();
}
}
argc -= optind;
argv += optind;
if (argc == 0) {
if (apropos) {
(void) fprintf(stderr, gettext("%s what?\n"),
__progname);
exit(1);
} else if (!printmp && !makewhatis) {
(void) fprintf(stderr,
gettext("What manual page do you want?\n"));
exit(1);
}
}
init_bintoman();
if (manpath == NULL && (manpath = getenv("MANPATH")) == NULL) {
if ((manpath = getenv("PATH")) != NULL)
bmp_flags = BMP_ISPATH | BMP_APPEND_DEFMANDIR;
else
manpath = DEFMANDIR;
}
pathv = split(manpath, ':');
mandirs = build_manpath(pathv, bmp_flags);
freev(pathv);
fullpaths(&mandirs);
if (makewhatis) {
do_makewhatis(mandirs);
exit(0);
}
if (printmp) {
print_manpath(mandirs);
exit(0);
}
/* Collect environment information */
if (isatty(STDOUT_FILENO) && (mwstr = getenv("MANWIDTH")) != NULL &&
*mwstr != '\0') {
if (strcasecmp(mwstr, "tty") == 0) {
struct winsize ws;
if (ioctl(0, TIOCGWINSZ, &ws) != 0)
warn("TIOCGWINSZ");
else
manwidth = ws.ws_col;
} else {
manwidth = (int)strtol(mwstr, (char **)NULL, 10);
if (manwidth < 0)
manwidth = 0;
}
}
if (manwidth != 0) {
DPRINTF("-- Using non-standard page width: %d\n", manwidth);
}
if (pager == NULL) {
if ((pager = getenv("PAGER")) == NULL || *pager == '\0')
pager = PAGER;
}
DPRINTF("-- Using pager: %s\n", pager);
for (i = 0; i < argc; i++) {
char *cmd;
static struct man_node *mp;
char *pv[2];
/*
* If full path to command specified, customize
* the manpath accordingly.
*/
if ((cmd = strrchr(argv[i], '/')) != NULL) {
*cmd = '\0';
if ((pv[0] = strdup(argv[i])) == NULL)
err(1, "strdup");
pv[1] = NULL;
*cmd = '/';
mp = build_manpath(pv,
BMP_ISPATH | BMP_FALLBACK_DEFMANDIR);
} else {
mp = mandirs;
}
if (apropos)
whatapro(mp, argv[i]);
else
ret += manual(mp, argv[i]);
if (mp != NULL && mp != mandirs) {
free(pv[0]);
free_manp(mp);
}
}
return (ret == 0 ? 0 : 1);
}
