| ");
1055 | out_html(" "); break; 1101 | case '_': out_html(" "); break; 1102 | default: 1103 | if (curfield->contents) out_html(curfield->contents); 1104 | break; 1105 | } 1106 | if (curfield->space) 1107 | for (i=0; i "); 1112 | out_html(""); 1113 | } 1114 | curfield=curfield->next; 1115 | } 1116 | out_html(" |
");
1125 | fillout=oldfillout;
1126 | out_html(change_to_size(oldsize));
1127 | out_html(change_to_font(oldfont));
1128 | return c;
1129 | }
1130 |
1131 | char *scan_expression(char *c, int *result) {
1132 | int value=0,value2,sign=1,opex=0;
1133 | char oper='c';
1134 |
1135 | if (*c=='!') {
1136 | c=scan_expression(c+1, &value);
1137 | value= (!value);
1138 | } else if (*c=='n') {
1139 | c++;
1140 | value=nroff;
1141 | } else if (*c=='t') {
1142 | c++;
1143 | value=1-nroff;
1144 | } else if (*c=='\'' || *c=='"' || *c<' ' || (*c=='\\' && c[1]=='(')) {
1145 | /* ?string1?string2?
1146 | ** test if string1 equals string2.
1147 | */
1148 | char *st1=NULL, *st2=NULL, *h;
1149 | char *tcmp=NULL;
1150 | char sep;
1151 | sep=*c;
1152 | if (sep=='\\') {
1153 | tcmp=c;
1154 | c=c+3;
1155 | }
1156 | c++;
1157 | h=c;
1158 | while (*c!= sep && (!tcmp || strncmp(c,tcmp,4))) c++;
1159 | *c='\n';
1160 | scan_troff(h, 1, &st1);
1161 | *c=sep;
1162 | if (tcmp) c=c+3;
1163 | c++;
1164 | h=c;
1165 | while (*c!=sep && (!tcmp || strncmp(c,tcmp,4))) c++;
1166 | *c='\n';
1167 | scan_troff(h,1,&st2);
1168 | *c=sep;
1169 | if (!st1 && !st2) value=1;
1170 | else if (!st1 || !st2) value=0;
1171 | else value=(!strcmp(st1, st2));
1172 | if (st1) free(st1);
1173 | if (st2) free(st2);
1174 | if (tcmp) c=c+3;
1175 | c++;
1176 | } else {
1177 | while (*c && !isspace(*c) && *c!=')') {
1178 | opex=0;
1179 | switch (*c) {
1180 | case '(':
1181 | c=scan_expression(c+1, &value2);
1182 | value2=sign*value2;
1183 | opex=1;
1184 | break;
1185 | case '.':
1186 | case '0': case '1':
1187 | case '2': case '3':
1188 | case '4': case '5':
1189 | case '6': case '7':
1190 | case '8': case '9': {
1191 | int num=0,denum=1;
1192 | value2=0;
1193 | while (isdigit(*c)) value2=value2*10+((*c++)-'0');
1194 | if (*c=='.') {
1195 | c++;
1196 | while (isdigit(*c)) {
1197 | num=num*10+((*c++)-'0');
1198 | denum=denum*10;
1199 | }
1200 | }
1201 | if (isalpha(*c)) {
1202 | /* scale indicator */
1203 | switch (*c) {
1204 | case 'i': /* inch -> 10pt */
1205 | value2=value2*10+(num*10+denum/2)/denum;
1206 | num=0;
1207 | break;
1208 | default:
1209 | break;
1210 | }
1211 | c++;
1212 | }
1213 | value2=value2+(num+denum/2)/denum;
1214 | value2=sign*value2;
1215 | opex=1;
1216 | break;
1217 | }
1218 | case '\\':
1219 | c=scan_escape(c+1);
1220 | value2=intresult*sign;
1221 | if (isalpha(*c)) c++; /* scale indicator */
1222 | opex=1;
1223 | break;
1224 | case '-':
1225 | if (oper) { sign=-1; c++; break; }
1226 | case '>':
1227 | case '<':
1228 | case '+':
1229 | case '/':
1230 | case '*':
1231 | case '%':
1232 | case '&':
1233 | case '=':
1234 | case ':':
1235 | if (c[1]=='=') oper=(*c++) +16; else oper=*c;
1236 | c++;
1237 | break;
1238 | default: c++; break;
1239 | }
1240 | if (opex) {
1241 | sign=1;
1242 | switch (oper) {
1243 | case 'c': value=value2; break;
1244 | case '-': value=value-value2; break;
1245 | case '+': value=value+value2; break;
1246 | case '*': value=value*value2; break;
1247 | case '/': if (value2) value=value/value2; break;
1248 | case '%': if (value2) value=value%value2; break;
1249 | case '<': value=(value': value=(value>value2); break;
1251 | case '>'+16: value=(value>=value2); break;
1252 | case '<'+16: value=(value<=value2); break;
1253 | case '=': case '='+16: value=(value==value2); break;
1254 | case '&': value = (value && value2); break;
1255 | case ':': value = (value || value2); break;
1256 | default: fprintf(stderr,
1257 | "man2html: Unknown operator %c.\n", oper);
1258 | }
1259 | oper=0;
1260 | }
1261 | }
1262 | if (*c==')') c++;
1263 | }
1264 | *result=value;
1265 | return c;
1266 | }
1267 |
1268 | static void
1269 | trans_char(char *c, char s, char t) {
1270 | char *sl = c;
1271 | int slash = 0;
1272 |
1273 | while (*sl && (*sl != '\n' || slash)) {
1274 | if (!slash) {
1275 | if (*sl == escapesym)
1276 | slash = 1;
1277 | else if (*sl == s)
1278 | *sl = t;
1279 | } else
1280 | slash = 0;
1281 | sl++;
1282 | }
1283 | }
1284 |
1285 | /*
1286 | * Read STR until end-of-line (not preceded by \).
1287 | * Find whitespace separated words, and store starts in WORDS of lth MAXN.
1288 | * Return number of words in N.
1289 | * Replace each end-of-word by the character EOW (usually \n or 0).
1290 | * Return pointer to last char seen (either \n or 0).
1291 | *
1292 | * A part \"... is skipped.
1293 | * Quotes not preceded by \ are replaced by \a.
1294 | */
1295 | static char *
1296 | fill_words(char *str, char *words[], int maxn, int *n, char eow) {
1297 | char *s = str;
1298 | int backslash = 0;
1299 | int skipspace = 0; /* 1 if space is not end-of-word */
1300 |
1301 | *n = 0;
1302 | words[*n] = s;
1303 | while (*s && (*s != '\n' || backslash)) {
1304 | if (!backslash) {
1305 | if (*s == '"') {
1306 | *s = '\a';
1307 | skipspace = !skipspace;
1308 | } else if (*s == escapesym) {
1309 | backslash = 1;
1310 | } else if ((*s == ' ' || *s == '\t') && !skipspace) {
1311 | *s = eow;
1312 | if (words[*n] != s && *n < maxn-1)
1313 | (*n)++;
1314 | words[*n] = s+1;
1315 | }
1316 | } else {
1317 | if (*s == '"') {
1318 | s--;
1319 | *s = eow;
1320 | if (words[*n] != s && *n < maxn-1)
1321 | (*n)++;
1322 | s++;
1323 | while (*s && *s != '\n') s++;
1324 | words[*n] = s;
1325 | s--;
1326 | }
1327 | backslash = 0;
1328 | }
1329 | s++;
1330 | }
1331 | if (s != words[*n])
1332 | (*n)++;
1333 | return s;
1334 | }
1335 |
1336 |
1337 | char *section_list[] = {
1338 | "1", "User Commands ",
1339 | "1C", "User Commands",
1340 | "1G", "User Commands",
1341 | "1S", "User Commands",
1342 | "1V", "User Commands ",
1343 | "2", "System Calls",
1344 | "2V", "System Calls",
1345 | "3", "C Library Functions",
1346 | "3C", "Compatibility Functions",
1347 | "3F", "Fortran Library Routines",
1348 | "3K", "Kernel VM Library Functions",
1349 | "3L", "Lightweight Processes Library",
1350 | "3M", "Mathematical Library",
1351 | "3N", "Network Functions",
1352 | "3R", "RPC Services Library",
1353 | "3S", "Standard I/O Functions",
1354 | "3V", "C Library Functions",
1355 | "3X", "Miscellaneous Library Functions",
1356 | "4", "Devices and Network Interfaces",
1357 | "4F", "Protocol Families",
1358 | "4I", "Devices and Network Interfaces",
1359 | "4M", "Devices and Network Interfaces",
1360 | "4N", "Devices and Network Interfaces",
1361 | "4P", "Protocols",
1362 | "4S", "Devices and Network Interfaces",
1363 | "4V", "Devices and Network Interfaces",
1364 | "5", "File Formats",
1365 | "5V", "File Formats",
1366 | "6", "Games and Demos",
1367 | "7", "Environments, Tables, and Troff Macros",
1368 | "7V", "Environments, Tables, and Troff Macros",
1369 | "8", "Maintenance Commands",
1370 | "8C", "Maintenance Commands",
1371 | "8S", "Maintenance Commands",
1372 | "8V", "Maintenance Commands",
1373 | "L", "Local Commands",
1374 | /* for Solaris:
1375 | "1", "User Commands",
1376 | "1B", "SunOS/BSD Compatibility Package Commands",
1377 | "1b", "SunOS/BSD Compatibility Package Commands",
1378 | "1C", "Communication Commands ",
1379 | "1c", "Communication Commands",
1380 | "1F", "FMLI Commands ",
1381 | "1f", "FMLI Commands",
1382 | "1G", "Graphics and CAD Commands ",
1383 | "1g", "Graphics and CAD Commands ",
1384 | "1M", "Maintenance Commands",
1385 | "1m", "Maintenance Commands",
1386 | "1S", "SunOS Specific Commands",
1387 | "1s", "SunOS Specific Commands",
1388 | "2", "System Calls",
1389 | "3", "C Library Functions",
1390 | "3B", "SunOS/BSD Compatibility Library Functions",
1391 | "3b", "SunOS/BSD Compatibility Library Functions",
1392 | "3C", "C Library Functions",
1393 | "3c", "C Library Functions",
1394 | "3E", "C Library Functions",
1395 | "3e", "C Library Functions",
1396 | "3F", "Fortran Library Routines",
1397 | "3f", "Fortran Library Routines",
1398 | "3G", "C Library Functions",
1399 | "3g", "C Library Functions",
1400 | "3I", "Wide Character Functions",
1401 | "3i", "Wide Character Functions",
1402 | "3K", "Kernel VM Library Functions",
1403 | "3k", "Kernel VM Library Functions",
1404 | "3L", "Lightweight Processes Library",
1405 | "3l", "Lightweight Processes Library",
1406 | "3M", "Mathematical Library",
1407 | "3m", "Mathematical Library",
1408 | "3N", "Network Functions",
1409 | "3n", "Network Functions",
1410 | "3R", "Realtime Library",
1411 | "3r", "Realtime Library",
1412 | "3S", "Standard I/O Functions",
1413 | "3s", "Standard I/O Functions",
1414 | "3T", "Threads Library",
1415 | "3t", "Threads Library",
1416 | "3W", "C Library Functions",
1417 | "3w", "C Library Functions",
1418 | "3X", "Miscellaneous Library Functions",
1419 | "3x", "Miscellaneous Library Functions",
1420 | "4", "File Formats",
1421 | "4B", "SunOS/BSD Compatibility Package File Formats",
1422 | "4b", "SunOS/BSD Compatibility Package File Formats",
1423 | "5", "Headers, Tables, and Macros",
1424 | "6", "Games and Demos",
1425 | "7", "Special Files",
1426 | "7B", "SunOS/BSD Compatibility Special Files",
1427 | "7b", "SunOS/BSD Compatibility Special Files",
1428 | "8", "Maintenance Procedures",
1429 | "8C", "Maintenance Procedures",
1430 | "8c", "Maintenance Procedures",
1431 | "8S", "Maintenance Procedures",
1432 | "8s", "Maintenance Procedures",
1433 | "9", "DDI and DKI",
1434 | "9E", "DDI and DKI Driver Entry Points",
1435 | "9e", "DDI and DKI Driver Entry Points",
1436 | "9F", "DDI and DKI Kernel Functions",
1437 | "9f", "DDI and DKI Kernel Functions",
1438 | "9S", "DDI and DKI Data Structures",
1439 | "9s", "DDI and DKI Data Structures",
1440 | "L", "Local Commands",
1441 | */
1442 | NULL, "Misc. Reference Manual Pages",
1443 | NULL, NULL
1444 | };
1445 |
1446 | static char *
1447 | section_name(char *c)
1448 | {
1449 | int i=0;
1450 |
1451 | if (!c) return "";
1452 | while (section_list[i] && strcmp(c,section_list[i])) i=i+2;
1453 | if (section_list[i+1]) return section_list[i+1];
1454 | else return c;
1455 | }
1456 |
1457 | int manidxlen = 0;
1458 | char *manidx = NULL;
1459 | int subs = 0;
1460 | int mip = 0; /* current offset in manidx[] */
1461 | char label[5]="lbAA";
1462 |
1463 | static void
1464 | manidx_need(int m) {
1465 | if (mip + m >= manidxlen) {
1466 | manidxlen += 10000;
1467 | manidx = xrealloc(manidx, manidxlen);
1468 | }
1469 | }
1470 |
1471 | static void
1472 | add_to_index(int level, char *item)
1473 | {
1474 | char *c = NULL;
1475 |
1476 | label[3]++;
1477 | if (label[3]>'Z') {
1478 | label[3]='A';
1479 | label[2]++;
1480 | }
1481 |
1482 | if (level != subs) {
1483 | manidx_need(6);
1484 | if (subs) {
1485 | strcpy(manidx+mip, "\n");
1486 | mip += 6;
1487 | } else {
1488 | strcpy(manidx+mip, "\n");
1489 | mip += 5;
1490 | }
1491 | }
1492 | subs = level;
1493 |
1494 | scan_troff(item, 1, &c);
1495 | manidx_need(100 + strlen(c));
1496 | sprintf(manidx+mip, "- %s
- \n", label, c);
1497 | if (c) free(c);
1498 | while (manidx[mip]) mip++;
1499 | }
1500 |
1501 | static char *
1502 | skip_till_newline(char *c)
1503 | {
1504 | int lvl=0;
1505 |
1506 | while (*c && (*c!='\n' || lvl>0)) {
1507 | if (*c=='\\') {
1508 | c++;
1509 | if (*c=='}') lvl--; else if (*c=='{') lvl++;
1510 | }
1511 | c++;
1512 | }
1513 | c++;
1514 | if (lvl<0 && newline_for_fun) {
1515 | newline_for_fun = newline_for_fun+lvl;
1516 | if (newline_for_fun<0) newline_for_fun=0;
1517 | }
1518 | return c;
1519 | }
1520 |
1521 | int ifelseval=0;
1522 |
1523 | static char *
1524 | scan_request(char *c) {
1525 | /* BSD Mandoc stuff - by Michael Hamilton */
1526 | static int mandoc_synopsis=0; /* True if we are in the synopsis section */
1527 | static int mandoc_command=0; /* True if this is mandoc page */
1528 | static int mandoc_bd_options; /* Only copes with non-nested Bd's */
1529 | static int inXo=0;
1530 |
1531 | int i,j,mode = 0;
1532 | char *h;
1533 | char *wordlist[20];
1534 | int words;
1535 | char *sl;
1536 | STRDEF *owndef;
1537 |
1538 | while (*c == ' ' || *c == '\t')
1539 | c++;
1540 | if (c[0] == '\n')
1541 | return c+1;
1542 | if (c[1] == '\n')
1543 | j = 1;
1544 | else
1545 | j = 2;
1546 | while (c[j] == ' ' || c[j] == '\t')
1547 | j++;
1548 | if (c[0] == escapesym) {
1549 | /* some pages use .\" .\$1 .\} */
1550 | /* .\$1 is too difficult/stupid */
1551 | if (c[1] == '$')
1552 | c = skip_till_newline(c);
1553 | else
1554 | c = scan_escape(c+1);
1555 | } else {
1556 | i=V(c[0],c[1]);
1557 | switch (i) {
1558 | case V('a','b'):
1559 | h=c+j;
1560 | while (*h && *h !='\n') h++;
1561 | *h=0;
1562 | if (scaninbuff && buffpos) {
1563 | buffer[buffpos]=0;
1564 | printf("%s\n", buffer);
1565 | }
1566 | fprintf(stderr, "%s\n", c+2); /* XXX */
1567 | exit(0);
1568 | break;
1569 | case V('d','i'):
1570 | {
1571 | STRDEF *de;
1572 | c=c+j;
1573 | i=V(c[0],c[1]);
1574 | if (*c == '\n') { c++;break; }
1575 | while (*c && *c!='\n') c++;
1576 | c++;
1577 | h=c;
1578 | while (*c && strncmp(c,".di",3)) while (*c && *c++!='\n');
1579 | *c=0;
1580 | de=strdef;
1581 | while (de && de->nr !=i) de=de->next;
1582 | if (!de) {
1583 | de=(STRDEF*) xmalloc(sizeof(STRDEF));
1584 | de->nr=i;
1585 | de->slen=0;
1586 | de->next=strdef;
1587 | de->st=NULL;
1588 | strdef=de;
1589 | } else {
1590 | if (de->st) free(de->st);
1591 | de->slen=0;
1592 | de->st=NULL;
1593 | }
1594 | scan_troff(h,0,&de->st);
1595 | *c='.';
1596 | while (*c && *c++!='\n');
1597 | break;
1598 | }
1599 | case V('d','s'):
1600 | mode=1;
1601 | case V('a','s'):
1602 | {
1603 | STRDEF *de;
1604 | int oldcurpos=curpos;
1605 | c=c+j;
1606 | while (*c == ' ') c++;
1607 | i=V(c[0],c[1]);
1608 | j=0;
1609 | while (c[j] && c[j]!='\n') j++;
1610 | if (j<3) { c=c+j; break; }
1611 | if (c[1] == ' ') c=c+1; else c=c+2;
1612 | while (isspace(*c)) c++;
1613 | if (*c == '"') c++;
1614 | de=strdef;
1615 | while (de && de->nr != i) de=de->next;
1616 | single_escape=1;
1617 | curpos=0;
1618 | if (!de) {
1619 | char *h;
1620 | de=(STRDEF*) xmalloc(sizeof(STRDEF));
1621 | de->nr=i;
1622 | de->slen=0;
1623 | de->next=strdef;
1624 | de->st=NULL;
1625 | strdef=de;
1626 | h=NULL;
1627 | c=scan_troff(c, 1, &h);
1628 | de->st=h;
1629 | de->slen=curpos;
1630 | } else {
1631 | if (mode) { /* .ds */
1632 | char *h=NULL;
1633 | c=scan_troff(c, 1, &h);
1634 | free(de->st); /* segfault XXX */
1635 | de->slen=curpos;
1636 | de->st=h;
1637 | } else { /* .as */
1638 | c=scan_troff(c,1,&de->st); /* XXX */
1639 | de->slen+=curpos;
1640 | }
1641 | }
1642 | single_escape=0;
1643 | curpos=oldcurpos;
1644 | }
1645 | break;
1646 | case V('b','r'):
1647 | if (still_dd) out_html("
- ");
1648 | else out_html("
\n");
1649 | curpos=0;
1650 | c=c+j;
1651 | if (c[0] == escapesym) { c=scan_escape(c+1); }
1652 | c=skip_till_newline(c);break;
1653 | case V('c','2'):
1654 | c=c+j;
1655 | if (*c!='\n') { nobreaksym=*c; }
1656 | else nobreaksym='\'';
1657 | c=skip_till_newline(c);
1658 | break;
1659 | case V('c','c'):
1660 | c=c+j;
1661 | if (*c!='\n') { controlsym=*c; }
1662 | else controlsym='.';
1663 | c=skip_till_newline(c);
1664 | break;
1665 | case V('c','e'):
1666 | c=c+j;
1667 | if (*c == '\n') { i=1; }
1668 | else {
1669 | i=0;
1670 | while ('0'<=*c && *c<='9') {
1671 | i=i*10+*c-'0';
1672 | c++;
1673 | }
1674 | }
1675 | c=skip_till_newline(c);
1676 | /* center next i lines */
1677 | if (i>0) {
1678 | out_html("\n");
1679 | while (i && *c) {
1680 | char *line=NULL;
1681 | c=scan_troff(c,1, &line);
1682 | if (line && strncmp(line, "
", 4)) {
1683 | out_html(line);
1684 | out_html("
\n");
1685 | i--;
1686 | }
1687 | }
1688 | out_html(" \n");
1689 | curpos=0;
1690 | }
1691 | break;
1692 | case V('e','c'):
1693 | c=c+j;
1694 | if (*c!='\n') { escapesym=*c; }
1695 | else escapesym='\\';
1696 | break;
1697 | c=skip_till_newline(c);
1698 | case V('e','o'):
1699 | escapesym=0;
1700 | c=skip_till_newline(c);
1701 | break;
1702 | case V('e','x'):
1703 | exit(0);
1704 | break;
1705 | case V('f','c'):
1706 | c=c+j;
1707 | if (*c == '\n') {
1708 | fieldsym=padsym=0;
1709 | } else {
1710 | fieldsym=c[0];
1711 | padsym=c[1];
1712 | }
1713 | c=skip_till_newline(c);
1714 | break;
1715 | case V('f','i'):
1716 | if (!fillout) {
1717 | out_html(change_to_font(0));
1718 | out_html(change_to_size('0'));
1719 | out_html("
\n");
1720 | }
1721 | curpos=0;
1722 | fillout=1;
1723 | c=skip_till_newline(c);
1724 | break;
1725 | case V('f','t'):
1726 | c=c+j;
1727 | if (*c == '\n') {
1728 | out_html(change_to_font(0));
1729 | } else {
1730 | if (*c == escapesym) {
1731 | int fn;
1732 | c=scan_expression(c, &fn);
1733 | c--;
1734 | out_html(change_to_font(fn));
1735 | } else {
1736 | out_html(change_to_font(*c));
1737 | c++;
1738 | }
1739 | }
1740 | c=skip_till_newline(c);
1741 | break;
1742 | case V('e','l'):
1743 | /* .el anything : else part of if else */
1744 | if (ifelseval) {
1745 | c=c+j;
1746 | c[-1]='\n';
1747 | c=scan_troff(c,1,NULL);
1748 | } else
1749 | c=skip_till_newline(c+j);
1750 | break;
1751 | case V('i','e'):
1752 | /* .ie c anything : then part of if else */
1753 | case V('i','f'):
1754 | /* .if c anything
1755 | * .if !c anything
1756 | * .if N anything
1757 | * .if !N anything
1758 | * .if 'string1'string2' anything
1759 | * .if !'string1'string2' anything
1760 | */
1761 | c=c+j;
1762 | c=scan_expression(c, &i);
1763 | ifelseval=!i;
1764 | if (i) {
1765 | *c='\n';
1766 | c++;
1767 | c=scan_troff(c,1,NULL);
1768 | } else
1769 | c=skip_till_newline(c);
1770 | break;
1771 | case V('i','g'): /* .ig: ignore until .. */
1772 | {
1773 | char *endwith="..\n";
1774 | i=3;
1775 | c=c+j;
1776 | while (*c == ' ') c++;
1777 | if (*c == escapesym && c[1] == '"')
1778 | while (*c != '\n') c++;
1779 | if (*c!='\n') { /* .ig yy: ignore until .yy, then call .yy */
1780 | endwith=c-1;i=1;
1781 | c[-1]='.';
1782 | while (*c && *c!='\n') c++,i++;
1783 | }
1784 | c++;
1785 | while (*c && strncmp(c,endwith,i))
1786 | while (*c && *c++!='\n');
1787 | while (*c && *c++!='\n');
1788 | break;
1789 | }
1790 | case V('n','f'):
1791 | if (fillout) {
1792 | out_html(change_to_font(0));
1793 | out_html(change_to_size('0'));
1794 | out_html("\n");
1795 | }
1796 | curpos=0;
1797 | fillout=0;
1798 | c=skip_till_newline(c);
1799 | break;
1800 | case V('p','s'):
1801 | c=c+j;
1802 | if (*c == '\n') {
1803 | out_html(change_to_size('0'));
1804 | } else {
1805 | j=0;i=0;
1806 | if (*c == '-') { j= -1;c++; } else if (*c == '+') { j=1;c++;}
1807 | c=scan_expression(c, &i);
1808 | if (!j) { j=1; if (i>5) i=i-10; }
1809 | out_html(change_to_size(i*j));
1810 | }
1811 | c=skip_till_newline(c);
1812 | break;
1813 | case V('s','p'):
1814 | c=c+j;
1815 | if (fillout) out_html(""); else {
1816 | out_html(NEWLINE);
1817 | NEWLINE[0]='\n';
1818 | }
1819 | curpos=0;
1820 | c=skip_till_newline(c);
1821 | break;
1822 | case V('s','o'):
1823 | {
1824 | FILE *f;
1825 | struct stat stbuf;
1826 | int l; char *buf;
1827 | char *name = NULL;
1828 |
1829 | curpos=0;
1830 | c += j; /* skip .so part and whitespace */
1831 | if (*c == '/') {
1832 | h = c;
1833 | } else { /* .so man3/cpow.3 -> ../man3/cpow.3 */
1834 | h = c-3;
1835 | h[0] = '.';
1836 | h[1] = '.';
1837 | h[2] = '/';
1838 | }
1839 | while (*c != '\n') c++;
1840 | while (c[-1] == ' ') c--;
1841 | while (*c != '\n') *c++ = 0;
1842 | *c = 0;
1843 | scan_troff(h,1, &name);
1844 | if (name[3] == '/') h=name+3; else h=name;
1845 | l = 0;
1846 | if (stat(h, &stbuf)!=-1) l=stbuf.st_size;
1847 | buf = (char*) xmalloc((l+4)*sizeof(char));
1848 | #if NOCGI
1849 | if (!out_length) {
1850 | char *t,*s;
1851 | t=strrchr(fname, '/');
1852 | if (!t) t=fname;
1853 | fprintf(stderr, "ln -s %s.html %s.html\n", h, t);
1854 | s=strrchr(t, '.');if (!s) s=t;
1855 | printf("
Manpage of %s \n"
1856 | "\n"
1857 | "See the manpage for %s.\n"
1858 | "\n",
1859 | s, h, h);
1860 | } else
1861 | #endif
1862 | {
1863 | /* this works alright, except for section 3 */
1864 | if (!l || !(f = fopen(h,"r"))) {
1865 | fprintf(stderr,
1866 | "man2html: unable to open or read file %s\n", h);
1867 | out_html(""
1868 | "man2html: unable to open or read file\n");
1869 | out_html(h);
1870 | out_html("
\n");
1871 | } else {
1872 | i=fread(buf+1,1,l,f);
1873 | fclose(f);
1874 | buf[0]=buf[l]='\n';
1875 | buf[l+1]=buf[l+2]=0;
1876 | scan_troff(buf+1,0,NULL);
1877 | }
1878 | if (buf) free(buf);
1879 | }
1880 | *c++='\n';
1881 | break;
1882 | }
1883 | case V('t','a'):
1884 | c=c+j;
1885 | j=0;
1886 | while (*c!='\n') {
1887 | sl=scan_expression(c, &tabstops[j]);
1888 | if (*c == '-' || *c == '+') tabstops[j]+=tabstops[j-1];
1889 | c=sl;
1890 | while (*c == ' ' || *c == '\t') c++;
1891 | if (j+1 < SIZE(tabstops))
1892 | j++;
1893 | }
1894 | maxtstop=j;
1895 | curpos=0;
1896 | break;
1897 | case V('t','i'):
1898 | #if 0
1899 | dl_down();
1900 | #endif
1901 | out_html("
\n");
1902 | c=c+j;
1903 | c=scan_expression(c, &j);
1904 | for (i=0; ia b ] */
1932 | mode=1;
1933 | c[0]='B'; c[1]='I';
1934 | out_html(change_to_font('R'));
1935 | out_html("[");
1936 | curpos++;
1937 | case V('B','R'):
1938 | case V('B','I'):
1939 | case V('I','B'):
1940 | case V('I','R'):
1941 | case V('R','B'):
1942 | case V('R','I'):
1943 | {
1944 | char font[2];
1945 | font[0] = c[0]; font[1] = c[1];
1946 | c = c+j;
1947 | if (*c == '\n') c++;
1948 | sl = fill_words(c, wordlist, SIZE(wordlist), &words, '\n');
1949 | c = sl+1;
1950 | /* .BR name (section)
1951 | ** indicates a link. It will be added in the output routine.
1952 | */
1953 | for (i=0; i");
1977 | curpos = 0;
1978 | break;
1979 | case V('T','P'):
1980 | dl_begin();
1981 | c=skip_till_newline(c);
1982 | /* somewhere a definition ends with '.TP' */
1983 | if (!*c) still_dd=1; else {
1984 | c=scan_troff(c,1,NULL);
1985 | out_html("");
1986 | }
1987 | curpos=0;
1988 | break;
1989 | case V('I','X'):
1990 | /* general index */
1991 | sl = fill_words(c+j, wordlist, SIZE(wordlist), &words, '\n');
1992 | c = sl+1;
1993 | j = 4;
1994 | while (idxlabel[j] == 'Z') idxlabel[j--]='A';
1995 | idxlabel[j]++;
1996 | #ifdef MAKEINDEX
1997 | if (idxfile) {
1998 | fprintf(idxfile, "%s@%s@", fname, idxlabel);
1999 | for (j=0; j' and '<' solves it, but creates
2012 | ** some space. A normal space does not work.
2013 | */
2014 | out_html("\"> \n"); else { 2020 | out_html(NEWLINE); 2021 | NEWLINE[0]='\n'; 2022 | } 2023 | curpos=0; 2024 | c=skip_till_newline(c); 2025 | break; 2026 | case V('H','P'): 2027 | dl_begin(); 2028 | still_dd=1; 2029 | c=skip_till_newline(c); 2030 | curpos=0; 2031 | break; 2032 | case V('P','D'): 2033 | c=skip_till_newline(c); 2034 | break; 2035 | case V('R','s'): /* BSD mandoc */ 2036 | case V('R','S'): 2037 | sl = fill_words(c+j, wordlist, SIZE(wordlist), &words, '\n'); 2038 | j = 1; 2039 | if (words>0) scan_expression(wordlist[0], &j); 2040 | if (j>=0) { 2041 | dl_newlevel(); 2042 | c=skip_till_newline(c); 2043 | curpos=0; 2044 | break; 2045 | } 2046 | case V('R','e'): /* BSD mandoc */ 2047 | case V('R','E'): 2048 | dl_endlevel(); 2049 | c=skip_till_newline(c); 2050 | curpos=0; 2051 | break; 2052 | case V('S','B'): 2053 | out_html(change_to_size(-1)); 2054 | out_html(change_to_font('B')); 2055 | c=scan_troff(c+j, 1, NULL); 2056 | out_html(change_to_font('R')); 2057 | out_html(change_to_size('0')); 2058 | break; 2059 | case V('S','M'): 2060 | c=c+j; 2061 | if (*c == '\n') c++; 2062 | out_html(change_to_size(-1)); 2063 | trans_char(c,'"','\a'); 2064 | c=scan_troff(c,1,NULL); 2065 | out_html(change_to_size('0')); 2066 | break; 2067 | case V('S','s'): /* BSD mandoc */ 2068 | mandoc_command = 1; 2069 | case V('S','S'): 2070 | mode=1; 2071 | goto sh_below; 2072 | case V('S','h'): /* BSD mandoc */ 2073 | mandoc_command = 1; 2074 | case V('S','H'): 2075 | sh_below: 2076 | c=c+j; 2077 | if (*c == '\n') c++; 2078 | dl_down(); 2079 | out_html(change_to_font(0)); 2080 | out_html(change_to_size(0)); 2081 | if (!fillout) { 2082 | fillout=1; 2083 | out_html(""); 2084 | } 2085 | trans_char(c,'"', '\a'); 2086 | add_to_index(mode, c); 2087 | out_html(" \n
\n"); else { 2291 | out_html(NEWLINE); 2292 | NEWLINE[0]='\n'; 2293 | } 2294 | curpos=0; 2295 | c=skip_till_newline(c); 2296 | break; 2297 | } 2298 | case V('E','l'): /* BSD mandoc */ 2299 | c=c+j; 2300 | dl_endlevel_type(); 2301 | if (fillout) out_html("
\n"); else { 2302 | out_html(NEWLINE); 2303 | NEWLINE[0]='\n'; 2304 | } 2305 | curpos=0; 2306 | c=skip_till_newline(c); 2307 | break; 2308 | case V('I','t'): /* BSD mandoc */ 2309 | c=c+j; 2310 | if (dl_type(DL)) { 2311 | out_html("
"); 2378 | out_html(change_to_font('L')); 2379 | if (*c == '\n') c++; 2380 | c=scan_troff_mandoc(c, 1, NULL); 2381 | out_html(change_to_font('R')); 2382 | out_html(""); 2383 | if (fillout) curpos++; else curpos=0; 2384 | break; 2385 | case V('B','d'): /* BSD mandoc */ 2386 | { /* Seems like a kind of example/literal mode */ 2387 | char *nl, t=0 /* just for gcc */; 2388 | c=c+j; 2389 | nl = strchr(c,'\n'); 2390 | if (nl) { 2391 | t = *nl; 2392 | *nl = 0; 2393 | } 2394 | out_html(NEWLINE); 2395 | mandoc_bd_options = 0; /* Remember options for terminating Bl */ 2396 | if (strstr(c, "-offset indent")) { 2397 | mandoc_bd_options |= BD_INDENT; 2398 | out_html("
\n");
2399 | }
2400 | if (strstr(c, "-literal") || strstr(c, "-unfilled")) {
2401 | if (fillout) {
2402 | mandoc_bd_options |= BD_LITERAL;
2403 | out_html(change_to_font(0));
2404 | out_html(change_to_size('0'));
2405 | out_html("\n");
2406 | }
2407 | curpos=0;
2408 | fillout=0;
2409 | }
2410 | if (nl)
2411 | *nl = t;
2412 | c=skip_till_newline(c);
2413 | break;
2414 | }
2415 | case V('E','d'): /* BSD mandoc */
2416 | if (mandoc_bd_options & BD_LITERAL) {
2417 | if (!fillout) {
2418 | out_html(change_to_font(0));
2419 | out_html(change_to_size('0'));
2420 | out_html("\n");
2421 | }
2422 | }
2423 | if (mandoc_bd_options & BD_INDENT)
2424 | out_html("\n");
2425 | curpos=0;
2426 | fillout=1;
2427 | c=skip_till_newline(c);
2428 | break;
2429 | case V('B','e'): /* BSD mandoc */
2430 | c=c+j;
2431 | if (fillout) out_html(""); else { 2432 | out_html(NEWLINE); 2433 | NEWLINE[0]='\n'; 2434 | } 2435 | curpos=0; 2436 | c=skip_till_newline(c); 2437 | break; 2438 | case V('X','r'): /* BSD mandoc */ 2439 | { 2440 | /* Translate xyz 1 to xyz(1) 2441 | * Allow for multiple spaces. Allow the section to be missing. 2442 | */ 2443 | char buff[100]; 2444 | char *bufptr; 2445 | trans_char(c,'"','\a'); 2446 | bufptr = buff; 2447 | c = c+j; 2448 | if (*c == '\n') c++; /* Skip spaces */ 2449 | while (isspace(*c) && *c != '\n') c++; 2450 | while (isalnum(*c) && bufptr < buff + SIZE(buff)-4) { 2451 | /* Copy the xyz part */ 2452 | *bufptr++ = *c++; 2453 | } 2454 | while (isspace(*c) && *c != '\n') c++; /* Skip spaces */ 2455 | if (isdigit(*c)) { /* Convert the number if there is one */ 2456 | *bufptr++ = '('; 2457 | while (isalnum(*c) && bufptr < buff + SIZE(buff)-3) { 2458 | *bufptr++ = *c++; 2459 | } 2460 | *bufptr++ = ')'; 2461 | } 2462 | while (*c != '\n' && bufptr < buff + SIZE(buff)-2) { 2463 | /* Copy the remainder */ 2464 | if (!isspace(*c)) { 2465 | *bufptr++ = *c; 2466 | } 2467 | c++; 2468 | } 2469 | *bufptr++ = '\n'; 2470 | *bufptr = 0; 2471 | scan_troff_mandoc(buff, 1, NULL); 2472 | out_html(NEWLINE); 2473 | if (fillout) curpos++; else curpos=0; 2474 | } 2475 | break; 2476 | case V('F','l'): /* BSD mandoc */ 2477 | trans_char(c,'"','\a'); 2478 | c=c+j; 2479 | out_html("-"); 2480 | if (*c!='\n') { 2481 | out_html(change_to_font('B')); 2482 | c=scan_troff_mandoc(c, 1, NULL); 2483 | out_html(change_to_font('R')); 2484 | } 2485 | out_html(NEWLINE); 2486 | if (fillout) curpos++; else curpos=0; 2487 | break; 2488 | case V('P','a'): /* BSD mandoc */ 2489 | case V('P','f'): /* BSD mandoc */ 2490 | trans_char(c,'"','\a'); 2491 | c=c+j; 2492 | if (*c == '\n') c++; 2493 | c=scan_troff_mandoc(c, 1, NULL); 2494 | out_html(NEWLINE); 2495 | if (fillout) curpos++; else curpos=0; 2496 | break; 2497 | case V('P','p'): /* BSD mandoc */ 2498 | if (fillout) out_html("
\n"); else {
2499 | out_html(NEWLINE);
2500 | NEWLINE[0]='\n';
2501 | }
2502 | curpos=0;
2503 | c=skip_till_newline(c);
2504 | break;
2505 | case V('D','q'): /* BSD mandoc */
2506 | trans_char(c,'"','\a');
2507 | c=c+j;
2508 | if (*c == '\n') c++;
2509 | out_html("``");
2510 | c=scan_troff_mandoc(c, 1, NULL);
2511 | out_html("''");
2512 | out_html(NEWLINE);
2513 | if (fillout) curpos++; else curpos=0;
2514 | break;
2515 | case V('O','p'): /* BSD mandoc */
2516 | trans_char(c,'"','\a');
2517 | c=c+j;
2518 | if (*c == '\n') c++;
2519 | out_html(change_to_font('R'));
2520 | out_html("[");
2521 | c=scan_troff_mandoc(c, 1, NULL);
2522 | out_html(change_to_font('R'));
2523 | out_html("]");
2524 | out_html(NEWLINE);
2525 | if (fillout) curpos++; else curpos=0;
2526 | break;
2527 | case V('O','o'): /* BSD mandoc */
2528 | trans_char(c,'"','\a');
2529 | c=c+j;
2530 | if (*c == '\n') c++;
2531 | out_html(change_to_font('R'));
2532 | out_html("[");
2533 | c=scan_troff_mandoc(c, 1, NULL);
2534 | if (fillout) curpos++; else curpos=0;
2535 | break;
2536 | case V('O','c'): /* BSD mandoc */
2537 | trans_char(c,'"','\a');
2538 | c=c+j;
2539 | c=scan_troff_mandoc(c, 1, NULL);
2540 | out_html(change_to_font('R'));
2541 | out_html("]");
2542 | if (fillout) curpos++; else curpos=0;
2543 | break;
2544 | case V('P','q'): /* BSD mandoc */
2545 | trans_char(c,'"','\a');
2546 | c=c+j;
2547 | if (*c == '\n') c++;
2548 | out_html("(");
2549 | c=scan_troff_mandoc(c, 1, NULL);
2550 | out_html(")");
2551 | out_html(NEWLINE);
2552 | if (fillout) curpos++; else curpos=0;
2553 | break;
2554 | case V('Q','l'): /* BSD mandoc */
2555 | { /* Single quote first word in the line */
2556 | char *sp;
2557 | trans_char(c,'"','\a');
2558 | c=c+j;
2559 | if (*c == '\n') c++;
2560 | sp = c;
2561 | do { /* Find first whitespace after the
2562 | * first word that isn't a mandoc macro
2563 | */
2564 | while (*sp && isspace(*sp)) sp++;
2565 | while (*sp && !isspace(*sp)) sp++;
2566 | } while (*sp && isupper(*(sp-2)) && islower(*(sp-1)));
2567 |
2568 | /* Use a newline to mark the end of text to
2569 | * be quoted
2570 | */
2571 | if (*sp) *sp = '\n';
2572 | out_html("`"); /* Quote the text */
2573 | c=scan_troff_mandoc(c, 1, NULL);
2574 | out_html("'");
2575 | out_html(NEWLINE);
2576 | if (fillout) curpos++; else curpos=0;
2577 | break;
2578 | }
2579 | case V('S','q'): /* BSD mandoc */
2580 | trans_char(c,'"','\a');
2581 | c=c+j;
2582 | if (*c == '\n') c++;
2583 | out_html("`");
2584 | c=scan_troff_mandoc(c, 1, NULL);
2585 | out_html("'");
2586 | out_html(NEWLINE);
2587 | if (fillout) curpos++; else curpos=0;
2588 | break;
2589 | case V('A','r'): /* BSD mandoc */
2590 | /* parse one line in italics */
2591 | out_html(change_to_font('I'));
2592 | trans_char(c,'"','\a');
2593 | c=c+j;
2594 | if (*c == '\n') { /* An empty Ar means "file ..." */
2595 | out_html("file ...");
2596 | } else {
2597 | c=scan_troff_mandoc(c, 1, NULL);
2598 | }
2599 | out_html(change_to_font('R'));
2600 | out_html(NEWLINE);
2601 | if (fillout) curpos++; else curpos=0;
2602 | break;
2603 | case V('A','d'): /* BSD mandoc */
2604 | case V('E','m'): /* BSD mandoc */
2605 | case V('V','a'): /* BSD mandoc */
2606 | /* parse one line in italics */
2607 | out_html(change_to_font('I'));
2608 | trans_char(c,'"','\a');
2609 | c=c+j;
2610 | if (*c == '\n') c++;
2611 | c=scan_troff_mandoc(c, 1, NULL);
2612 | out_html(change_to_font('R'));
2613 | out_html(NEWLINE);
2614 | if (fillout) curpos++; else curpos=0;
2615 | break;
2616 | case V('N','d'): /* BSD mandoc */
2617 | trans_char(c,'"','\a');
2618 | c=c+j;
2619 | if (*c == '\n') c++;
2620 | out_html(" - ");
2621 | c=scan_troff_mandoc(c, 1, NULL);
2622 | out_html(NEWLINE);
2623 | if (fillout) curpos++; else curpos=0;
2624 | break;
2625 | case V('N','m'): /* BSD mandoc */
2626 | {
2627 | static char *mandoc_name = 0;
2628 | trans_char(c,'"','\a');
2629 | c=c+j;
2630 | if (mandoc_synopsis) {
2631 | /*
2632 | * Break lines only in the Synopsis.
2633 | * The Synopsis section seems to be treated
2634 | * as a special case - Bummer!
2635 | */
2636 | static int count = 0; /* Don't break on the first Nm */
2637 | if (count) {
2638 | out_html("
42 |
56 |
65 |
14 |
30 | The index uses the Glimpse
31 | (glimpse(1))
32 | text indexing system. Many of the glimpse
33 | options, regular expressions, and wildcards are valid:
34 | see the help page for a summary.
35 |
36 |
39 | Glimpse
40 | was developed by Udi Manber and Burra Gopal of the University of
41 | Arizona, and Sun Wu of the National Chung-Cheng University, Taiwan.
42 | You may contact the authors at
43 | glimpse@cs.arizona.edu
44 |
45 | The Manual Page text search interface was created for Linux by
46 |
47 | Michael Hamilton.
48 |
49 |
50 |
--------------------------------------------------------------------------------
/scripts/cgi-aux/man/mansearchhelp.aux:
--------------------------------------------------------------------------------
1 | Content-type: text/html
2 |
3 |
4 |
16 |
18 | The full text index uses the Glimpse text indexing system.
19 | The
20 | glimpse(1)
21 | manual page documents glimpse in full. This summary documents those
22 | features of glimpse that are valid when searching through the manual pages.
23 |
24 |
104 |
241 |
242 | As was mentioned in the section on PATTERNS above, some characters
243 | serve as meta characters for glimpse and need to be
244 | preceded by '\' to search for them. The most common
245 | examples are the characters '.' (which stands for a wild card),
246 | and '*' (the Kleene closure).
247 | So, "glimpse ab.de" will match abcde, but "glimpse ab\.de"
248 | will not, and "glimpse ab*de" will not match ab*de, but
249 | "glimpse ab\*de" will.
250 | The meta character - is translated automatically to a hyphen
251 | unless it appears between [] (in which case it denotes a range of
252 | characters).
253 |
254 |
255 | The index of glimpse stores all patterns in lower case.
256 | When glimpse searches the index it first converts
257 | all patterns to lower case, finds the appropriate files,
258 | and then searches the actual files using the original
259 | patterns.
260 | So, for example, glimpse ABCXYZ will first find all
261 | files containing abcxyz in any combination of lower and upper
262 | cases, and then searches these files directly, so only the
263 | right cases will be found.
264 | One problem with this approach is discovering misspellings
265 | that are caused by wrong cases.
266 | For example, glimpse -B abcXYZ will first search the
267 | index for the best match to abcxyz (because the pattern is
268 | converted to lower case); it will find that there are matches
269 | with no errors, and will go to those files to search them
270 | directly, this time with the original upper cases.
271 | If the closest match is, say AbcXYZ, glimpse may miss it,
272 | because it doesn't expect an error.
273 | Another problem is speed. If you search for "ATT", it will look
274 | at the index for "att". Unless you use -w to match the whole word,
275 | glimpse may have to search all files containing, for example, "Seattle"
276 | which has "att" in it.
277 |
278 |
279 | There is no size limit for simple patterns and simple patterns
280 | within Boolean expressions.
281 | More complicated patterns, such as regular expressions,
282 | are currently limited to approximately 30 characters.
283 | Lines are limited to 1024 characters.
284 | Records are limited to 48K, and may be truncated if they are larger
285 | than that.
286 | The limit of record length can be
287 | changed by modifying the parameter Max_record in agrep.h.
288 |
289 |
290 | Glimpseindex does not index words of size > 64.
291 |
292 |
293 | 1 match found."
184 | }
185 | else {
186 | print " " mcount " matches found."
187 | }
188 | print "";
189 | print "";
190 | exit;
191 | }' "$@"
192 |
193 |
--------------------------------------------------------------------------------
/scripts/cgi-bin/man/mansearchhelp:
--------------------------------------------------------------------------------
1 | #!/bin/sh
2 | MAN2HTML=/usr/bin/man2html
3 | MANSH=/home/httpd/cgi-aux/man/mansearchhelp.aux
4 |
5 | # Do we need lynxcgi URLs? For the moment our criterion is
6 | # 1) HTTP_USER_AGENT=Lynx* and 2) HTTP_HOST is unset.
7 | AGENT="${HTTP_USER_AGENT-unknown}"
8 | case "$AGENT" in
9 | Lynx*|lynx*)
10 | HH="${HTTP_HOST-nohh}"
11 | ;;
12 | *)
13 | HH=nolynx
14 | ;;
15 | esac
16 |
17 | SERVER="${SERVER_NAME-localhost}"
18 | case "$HH" in
19 | nohh)
20 | CG="lynxcgi:/home/httpd/cgi-bin/man"
21 | ;;
22 | *)
23 | CG="http://$SERVER/cgi-bin/man"
24 | ;;
25 | esac
26 |
27 | if [ -r $MANSH ]; then
28 | sed s#%cg#$CG#g $MANSH
29 | else
30 | $MAN2HTML -E "man2html: cannot open $MANSH"
31 | fi
32 | exit 0
33 |
--------------------------------------------------------------------------------
/scripts/cgi-bin/man/mansec:
--------------------------------------------------------------------------------
1 | #!/usr/bin/awk -f
2 | #
3 | # Generate an index into a manual section by using find.
4 | # Michael Hamilton Manual pages found under " man_path "." > cache_tmp;
118 |
119 | # Find any man[1-8]/filenames
120 | while ((("find " man_path " -follow -type f -printf '%f\n' | sort -f ") | getline manpage) > 0) {
121 | # Check for new letter of alphabet
122 | letter = tolower(substr(manpage,1,1));
123 | if (letter != last_letter) {
124 | last_letter = letter;
125 | letter_index[++num_letters] = letter;
126 | # Start a new alphabetic heading
127 | print " " > cache_tmp;
146 |
147 | # Print out alphabetic quick index and other links
148 | for (i = 1; i <= num_letters; i++) {
149 | print "" toupper(letter_index[i]) "" > cache_tmp;
150 | }
151 |
152 | print " Other sections:" > cache_tmp;
156 | for (i=1; i<=num_sections; i++) {
157 | if (i != section) { # Dont print an entry for the section we are in
158 | print "" i ". " sec_name[i] " " > cache_tmp;
159 | }
160 | }
161 | print " " > cache_tmp;
162 | # Print out the accumulated index entries
163 | while ((getline < buffer_tmp) > 0) print > cache_tmp;
164 | print " " > cache_tmp;
165 | # Print out alphabetic quick index and other links
166 | for (i = 1; i <= num_letters; i++) {
167 | print "" toupper(letter_index[i]) "" > cache_tmp;
168 | }
169 | print " Return to Main Contents" > cache_tmp;
171 | print " Other sections:" > cache_tmp;
172 | for (i=1; i<=num_sections; i++) {
173 | if (i != section) { # Dont print an entry for the section we are in
174 | print "" i ". " sec_name[i] " " > cache_tmp;
175 | }
176 | }
177 | print "\n" > cache_tmp;
178 | system("/bin/mv " cache_tmp " " cache);
179 | system("/bin/rm -f " buffer_tmp);
180 | }
181 | system("/bin/cat " cache);
182 | exit;
183 | }
184 |
--------------------------------------------------------------------------------
/scripts/cgi-bin/man/manwhatis:
--------------------------------------------------------------------------------
1 | #!/usr/bin/awk -f
2 | #
3 | # Generate a whatis index into the manual pages by using find to
4 | # locate all the whatis files.
5 | # Michael Hamilton " > cache_tmp;
121 |
122 | # Note that sort sometimes lives in /bin and sometimes in /usr/bin
123 | sort_cmd = "sort -f >> " sort_tmp;
124 |
125 | while ( (extract_cmd | getline) > 0 ) {
126 | if (bracket_pos = index($0, "(")) {
127 | sec_full_num = substr($0, bracket_pos + 1, index($0, ")") - bracket_pos - 1);
128 | names = substr($0, 1, bracket_pos - 2);
129 | # Get rid of blanks and commas.
130 | n = split(names, name_list, " *, *");
131 | description = substr($0, bracket_pos + length(sec_full_num) + 2);
132 | # Get rid of AT&T
133 | gsub("&", "\&", description);
134 | # Generate a entry for each name
135 | for (i = 1; i <= n; i++) {
136 | print name_list[i] " " sec_full_num " " name_list[1] " / " description | sort_cmd;
137 | }
138 | }
139 | }
140 | close(extract_cmd);
141 | close(sort_cmd);
142 |
143 | while ((getline < sort_tmp) > 0) {
144 |
145 | letter = tolower(substr($1,1,1));
146 | if (letter != last_letter) {
147 | if (last_letter) {
148 | print " " > buffer_tmp;
149 | }
150 | last_letter = letter;
151 | letter_index[++num_letters] = letter;
152 | # Terminate list, start a new one
153 |
154 | print " " > buffer_tmp;
167 | close(buffer_tmp);
168 |
169 | system("/bin/rm " sort_tmp);
170 |
171 | # Print out alphabetic quick index and other links
172 | for (i = 1; i <= num_letters; i++) {
173 | print "" toupper(letter_index[i]) "" > cache_tmp;
174 | }
175 | print " Other sections:" > cache_tmp;
179 | for (i=1; i<=num_sections; i++) {
180 | if (i != section) { # Dont print an entry for the section we are in
181 | print "" i ". " sec_name[i] " " > cache_tmp;
182 | }
183 | }
184 | print " " > cache_tmp;
185 | # Print out the accumulated contents entries
186 | while ((getline < buffer_tmp) > 0) print > cache_tmp;
187 | print " " > cache_tmp;
188 |
189 | for (i = 1; i <= num_letters; i++) {
190 | print "" toupper(letter_index[i]) "" > cache_tmp;
191 | }
192 | print " Return to Main Contents" > cache_tmp;
194 |
195 | print " Other sections:" > cache_tmp;
196 | for (i=1; i<=num_sections; i++) {
197 | if (i != section) { # Dont print an entry for the section we are in
198 | print "" i ". " sec_name[i] " " > cache_tmp;
199 | }
200 | }
201 | print "" > cache_tmp;
202 | print "" > cache_tmp;
203 | system("/bin/mv " cache_tmp " " cache);
204 | system("/bin/rm " buffer_tmp);
205 | }
206 | system("/bin/cat " cache);
207 | exit;
208 | }
209 |
--------------------------------------------------------------------------------
/strdefs.c:
--------------------------------------------------------------------------------
1 | #include "defs.h"
2 |
3 | #ifndef NULL
4 | #define NULL ((void *) 0)
5 | #endif
6 |
7 | int nroff = 1;
8 |
9 | #define NROFF (-666)
10 | #define TROFF (-667)
11 |
12 | STRDEF *chardef, *strdef, *defdef;
13 | INTDEF *intdef;
14 |
15 | static INTDEF standardint[] = {
16 | { V('n',' '), NROFF, 0, NULL },
17 | { V('t',' '), TROFF, 0, NULL },
18 | { V('o',' '), 1, 0, NULL },
19 | { V('e',' '), 0, 0, NULL },
20 | { V('.','l'), 70, 0, NULL },
21 | { V('.','$'), 0, 0, NULL },
22 | { V('.','A'), NROFF, 0, NULL },
23 | { V('.','T'), TROFF, 0, NULL },
24 | { V('.','V'), 1, 0, NULL }, /* the me package tests for this */
25 | { 0, 0, 0, NULL } };
26 |
27 | static STRDEF standardstring[] = {
28 | { V('R',' '), 1, "®", NULL },
29 | { V('l','q'), 2, "``", NULL },
30 | { V('r','q'), 2, "''", NULL },
31 | { 0, 0, NULL, NULL}
32 | };
33 |
34 |
35 | static STRDEF standardchar[] = {
36 | { V('*','*'), 1, "*", NULL }, /* math star */
37 | { V('*','A'), 1, "A", NULL },
38 | { V('*','B'), 1, "B", NULL },
39 | { V('*','C'), 2, "Xi", NULL },
40 | { V('*','D'), 5, "Delta", NULL },
41 | { V('*','E'), 1, "E", NULL },
42 | { V('*','F'), 3, "Phi", NULL },
43 | { V('*','G'), 5, "Gamma", NULL },
44 | { V('*','H'), 5, "Theta", NULL },
45 | { V('*','I'), 1, "I", NULL },
46 | { V('*','K'), 1, "K", NULL },
47 | { V('*','L'), 6, "Lambda", NULL },
48 | { V('*','M'), 1, "M", NULL },
49 | { V('*','N'), 1, "N", NULL },
50 | { V('*','O'), 1, "O", NULL },
51 | { V('*','P'), 2, "Pi", NULL },
52 | { V('*','Q'), 3, "Psi", NULL },
53 | { V('*','R'), 1, "P", NULL },
54 | { V('*','S'), 5, "Sigma", NULL },
55 | { V('*','T'), 1, "T", NULL },
56 | { V('*','U'), 1, "Y", NULL },
57 | { V('*','W'), 5, "Omega", NULL },
58 | { V('*','X'), 1, "X", NULL },
59 | { V('*','Y'), 1, "H", NULL },
60 | { V('*','Z'), 1, "Z", NULL },
61 | { V('*','a'), 5, "alpha", NULL },
62 | { V('*','b'), 4, "beta", NULL },
63 | { V('*','c'), 2, "xi", NULL },
64 | { V('*','d'), 5, "delta", NULL },
65 | { V('*','e'), 7, "epsilon", NULL },
66 | { V('*','f'), 3, "phi", NULL },
67 | { V('*','g'), 5, "gamma", NULL },
68 | { V('*','h'), 5, "theta", NULL },
69 | { V('*','i'), 4, "iota", NULL },
70 | { V('*','k'), 5, "kappa", NULL },
71 | { V('*','l'), 6, "lambda", NULL },
72 | { V('*','m'), 1, "µ", NULL },
73 | { V('*','n'), 2, "nu", NULL },
74 | { V('*','o'), 1, "o", NULL },
75 | { V('*','p'), 2, "pi", NULL },
76 | { V('*','q'), 3, "psi", NULL },
77 | { V('*','r'), 3, "rho", NULL },
78 | { V('*','s'), 5, "sigma", NULL },
79 | { V('*','t'), 3, "tau", NULL },
80 | { V('*','u'), 7, "upsilon", NULL },
81 | { V('*','w'), 5, "omega", NULL },
82 | { V('*','x'), 3, "chi", NULL },
83 | { V('*','y'), 3, "eta", NULL },
84 | { V('*','z'), 4, "zeta", NULL },
85 | { V('+','-'), 1, "±", NULL },
86 | { V('1','2'), 1, "½", NULL },
87 | { V('1','4'), 1, "¼", NULL },
88 | { V('3','4'), 1, "¾", NULL },
89 | { V('F','i'), 3, "ffi", NULL },
90 | { V('F','l'), 3, "ffl", NULL },
91 | { V('a','a'), 1, "´", NULL },
92 | { V('a','p'), 1, "~", NULL },
93 | { V('b','r'), 1, "|", NULL },
94 | { V('b','u'), 1, "*", NULL }, /* bullet */
95 | { V('b','v'), 1, "|", NULL },
96 | { V('c','i'), 1, "o", NULL }, /* circle */
97 | { V('c','o'), 1, "©", NULL },
98 | { V('c','t'), 1, "¢", NULL },
99 | { V('d','e'), 1, "°", NULL },
100 | { V('d','g'), 1, "+", NULL }, /* dagger */
101 | { V('d','i'), 1, "÷", NULL },
102 | { V('e','m'), 3, "---", NULL }, /* em dash */
103 | { V('e','n'), 1, "-", NULL }, /* en dash */
104 | { V('e','q'), 1, "=", NULL },
105 | { V('e','s'), 1, "Ø", NULL },
106 | { V('f','f'), 2, "ff", NULL },
107 | { V('f','i'), 2, "fi", NULL },
108 | { V('f','l'), 2, "fl", NULL },
109 | { V('f','m'), 1, "´", NULL },
110 | { V('g','a'), 1, "`", NULL },
111 | { V('h','y'), 1, "-", NULL },
112 | { V('l','c'), 2, "|¯", NULL },
113 | { V('i','f'), 8, "Infinity", NULL }, /* infinity sign */
114 | { V('i','s'), 8, "Integral", NULL }, /* integral sign */
115 | { V('l','f'), 2, "|_", NULL },
116 | { V('l','k'), 1, "{", NULL },
117 | { V('m','i'), 1, "-", NULL },
118 | { V('m','u'), 1, "×", NULL },
119 | { V('n','o'), 1, "¬", NULL },
120 | { V('o','r'), 1, "|", NULL },
121 | { V('p','d'), 1, "d", NULL }, /* partial derivative */
122 | { V('p','l'), 1, "+", NULL },
123 | { V('r','c'), 2, "¯|", NULL },
124 | { V('r','f'), 2, "_|", NULL },
125 | { V('r','g'), 1, "®", NULL },
126 | { V('r','k'), 1, "}", NULL },
127 | { V('r','n'), 1, "¯", NULL },
128 | { V('r','u'), 1, "_", NULL },
129 | { V('s','c'), 1, "§", NULL },
130 | { V('s','l'), 1, "/", NULL },
131 | { V('s','q'), 2, "[]", NULL },
132 | { V('t','s'), 1, "s", NULL }, /* should be terminal sigma */
133 | { V('u','l'), 1, "_", NULL },
134 | { V('>','='), 1, ">", NULL },
135 | { V('<','='), 1, "<", NULL },
136 | { 0, 0, NULL, NULL }
137 | };
138 |
139 | void stdinit(void) {
140 | STRDEF *stdf;
141 | int i;
142 |
143 | stdf = &standardchar[0];
144 | i = 0;
145 | while (stdf->nr) {
146 | if (stdf->st) stdf->st = xstrdup(stdf->st);
147 | stdf->next = &standardchar[i];
148 | stdf = stdf->next;
149 | i++;
150 | }
151 | chardef=&standardchar[0];
152 |
153 | stdf=&standardstring[0];
154 | i=0;
155 | while (stdf->nr) {
156 | /* waste a little memory, and make a copy, to avoid
157 | the segfault when we free non-malloced memory */
158 | if (stdf->st) stdf->st = xstrdup(stdf->st);
159 | stdf->next = &standardstring[i];
160 | stdf = stdf->next;
161 | i++;
162 | }
163 | strdef=&standardstring[0];
164 |
165 | intdef=&standardint[0];
166 | i=0;
167 | while (intdef->nr) {
168 | if (intdef->nr == NROFF) intdef->nr = nroff; else
169 | if (intdef->nr == TROFF) intdef->nr = !nroff;
170 | intdef->next = &standardint[i];
171 | intdef = intdef->next;
172 | i++;
173 | }
174 | intdef = &standardint[0];
175 | defdef = NULL;
176 | }
177 |
--------------------------------------------------------------------------------
");
2639 | } else {
2640 | char *end, t=0 /* just for gcc */;
2641 | end = strchr(c, '\n');
2642 | if (end) {
2643 | t = *end;
2644 | *end = 0;
2645 | }
2646 | if (mandoc_name)
2647 | free(mandoc_name);
2648 | mandoc_name = xstrdup(c);
2649 | if (end)
2650 | *end = t;
2651 | }
2652 | count++;
2653 | }
2654 | out_html(change_to_font('B'));
2655 | while (*c == ' ' || *c == '\t') c++;
2656 | if (*c == '\n') {
2657 | /*
2658 | * If Nm has no argument, use one from an earlier
2659 | * Nm command that did have one. Hope there aren't
2660 | * too many commands that do this.
2661 | */
2662 | if (mandoc_name)
2663 | out_html(mandoc_name);
2664 | } else {
2665 | c=scan_troff_mandoc(c, 1, NULL);
2666 | }
2667 | out_html(change_to_font('R'));
2668 | out_html(NEWLINE);
2669 | if (fillout) curpos++; else curpos=0;
2670 | break;
2671 | }
2672 | case V('C','d'): /* BSD mandoc */
2673 | case V('C','m'): /* BSD mandoc */
2674 | case V('I','c'): /* BSD mandoc */
2675 | case V('M','s'): /* BSD mandoc */
2676 | case V('O','r'): /* BSD mandoc */
2677 | case V('S','y'): /* BSD mandoc */
2678 | /* parse one line in bold */
2679 | out_html(change_to_font('B'));
2680 | trans_char(c,'"','\a');
2681 | c=c+j;
2682 | if (*c == '\n') c++;
2683 | c=scan_troff_mandoc(c, 1, NULL);
2684 | out_html(change_to_font('R'));
2685 | out_html(NEWLINE);
2686 | if (fillout) curpos++; else curpos=0;
2687 | break;
2688 | case V('D','v'): /* BSD mandoc */
2689 | case V('E','v'): /* BSD mandoc */
2690 | case V('F','r'): /* BSD mandoc */
2691 | case V('L','i'): /* BSD mandoc */
2692 | case V('N','o'): /* BSD mandoc */
2693 | case V('N','s'): /* BSD mandoc */
2694 | case V('T','n'): /* BSD mandoc */
2695 | case V('n','N'): /* BSD mandoc */
2696 | trans_char(c,'"','\a');
2697 | c=c+j;
2698 | if (*c == '\n') c++;
2699 | out_html(change_to_font('B'));
2700 | c=scan_troff_mandoc(c, 1, NULL);
2701 | out_html(change_to_font('R'));
2702 | out_html(NEWLINE);
2703 | if (fillout) curpos++; else curpos=0;
2704 | break;
2705 | case V('%','A'): /* BSD mandoc biblio stuff */
2706 | case V('%','D'):
2707 | case V('%','N'):
2708 | case V('%','O'):
2709 | case V('%','P'):
2710 | case V('%','Q'):
2711 | case V('%','V'):
2712 | c=c+j;
2713 | if (*c == '\n') c++;
2714 | c=scan_troff(c, 1, NULL); /* Don't allow embedded mandoc coms */
2715 | if (fillout) curpos++; else curpos=0;
2716 | break;
2717 | case V('%','B'):
2718 | case V('%','J'):
2719 | case V('%','R'):
2720 | case V('%','T'):
2721 | c=c+j;
2722 | out_html(change_to_font('I'));
2723 | if (*c == '\n') c++;
2724 | c=scan_troff(c, 1, NULL); /* Don't allow embedded mandoc coms */
2725 | out_html(change_to_font('R'));
2726 | if (fillout) curpos++; else curpos=0;
2727 | break;
2728 | /* ----- end of BSD mandoc stuff ----- */
2729 |
2730 | default:
2731 | /* search macro database of self-defined macros */
2732 | owndef = defdef;
2733 | while (owndef && owndef->nr!=i) owndef=owndef->next;
2734 | if (owndef) {
2735 | char **oldargument;
2736 | int deflen;
2737 | int onff;
2738 | sl=fill_words(c+j, wordlist, SIZE(wordlist), &words, '\n');
2739 | c=sl+1;
2740 | *sl=0;
2741 | for (i=1; i
");
2942 | curpos=0;
2943 | }
2944 | usenbsp=fillout;
2945 | if (usenbsp) out_html(" "); else intbuff[ibp++]=' ';
2946 | } else if (*h > 31 && *h < 127) {
2947 | intbuff[ibp++]=*h;
2948 | } else if (((unsigned char)(*h)) > 127) {
2949 | #ifdef NO_8BIT
2950 | intbuff[ibp++]='&';
2951 | intbuff[ibp++]='#';
2952 | intbuff[ibp++]='0'+((unsigned char)(*h))/100;
2953 | intbuff[ibp++]='0'+(((unsigned char)(*h))%100)/10;
2954 | intbuff[ibp++]='0'+((unsigned char)(*h))%10;
2955 | intbuff[ibp++]=';';
2956 | #else
2957 | intbuff[ibp++]=*h;
2958 | #endif
2959 | }
2960 | curpos++;
2961 | break;
2962 | }
2963 | if (ibp>480) FLUSHIBP;
2964 | h++;
2965 | }
2966 | }
2967 | FLUSHIBP;
2968 | if (buffer) buffer[buffpos]=0;
2969 | if (san && *h) h++;
2970 | newline_for_fun=exnewline_for_fun;
2971 | if (result) {
2972 | *result = buffer;
2973 | buffer=exbuffer;
2974 | buffpos=exbuffpos;
2975 | buffmax=exbuffmax;
2976 | scaninbuff=exscaninbuff;
2977 | }
2978 | return h;
2979 | }
2980 |
2981 | static char *scan_troff_mandoc(char *c, int san, char **result) {
2982 | char *ret, *end = c;
2983 | int oldval = mandoc_line;
2984 | mandoc_line = 1;
2985 | while (*end && *end != '\n') {
2986 | end++;
2987 | }
2988 |
2989 | if (end > c + 2
2990 | && ispunct(*(end - 1))
2991 | && isspace(*(end - 2)) && *(end - 2) != '\n') {
2992 | /*
2993 | * Don't format lonely punctuation. E.g. in "xyz ," format
2994 | * the xyz and then append the comma removing the space.
2995 | */
2996 | *(end - 2) = '\n';
2997 | ret = scan_troff(c, san, result);
2998 | *(end - 2) = *(end - 1);
2999 | *(end - 1) = ' ';
3000 | } else {
3001 | ret = scan_troff(c, san, result);
3002 | }
3003 | mandoc_line = oldval;
3004 | return ret;
3005 | }
3006 |
3007 | STRDEF *foundpages=NULL;
3008 |
3009 | static void
3010 | error_page(char *s, char *t, ...) {
3011 | va_list p;
3012 |
3013 | printf("%s
\n", s, s);
3015 | va_start(p, t);
3016 | vfprintf(stdout, t, p);
3017 | va_end(p);
3018 | printf("\n");
3019 | exit(0);
3020 | }
3021 |
3022 | char *
3023 | xstrdup(const char *s) {
3024 | char *p = strdup(s);
3025 | if (p == NULL)
3026 | error_page("Out of memory",
3027 | "Sorry, out of memory, aborting...\n");
3028 | return p;
3029 | }
3030 |
3031 | void *
3032 | xmalloc(size_t size) {
3033 | void *p = malloc(size);
3034 | if (p == NULL)
3035 | error_page("Out of memory",
3036 | "Sorry, out of memory, aborting...\n");
3037 | return p;
3038 | }
3039 |
3040 | void *
3041 | xrealloc(void *ptr, size_t size) {
3042 | void *p = realloc(ptr,size);
3043 | if (p == NULL)
3044 | error_page("Out of memory",
3045 | "Sorry, out of memory, aborting...\n");
3046 | return p;
3047 | }
3048 |
3049 | static void
3050 | usage(void) {
3051 | error_page("man2html: bad invocation",
3052 | "Call: man2html [-l|-h host.domain:port] [-p|-q] [filename]\n"
3053 | "or: man2html -r [filename]\n"
3054 | "or: man2html -c [filename]\n");
3055 | }
3056 |
3057 | static void
3058 | goto_dir(char *path, char **dir, char **name) {
3059 | char *s, *t, *u;
3060 |
3061 | s = xstrdup(path);
3062 | t = strrchr(s, '/');
3063 | if (t) {
3064 | *t = 0;
3065 | u = strrchr(s, '/');
3066 | *t = '/';
3067 | if (u) {
3068 | *u = 0;
3069 | if (chdir(s) == 0) {
3070 | if (dir)
3071 | *dir = s;
3072 | if (name)
3073 | *name = u+1;
3074 | }
3075 | #if 0
3076 | else /* complain or not - this need not be fatal */
3077 | error_page("Error", "man2html: could not chdir to %s", s);
3078 | #endif
3079 | }
3080 | }
3081 | }
3082 |
3083 | /*
3084 | * Call: man2html [-l] [filename]
3085 | *
3086 | * The contents of FILENAME (or STDIN, in case FILENAME is "-" or absent)
3087 | * are converted from man-style nroff to html, and printed on STDOUT.
3088 | *
3089 | * Possible errors are reflected in the output. The return status is 0.
3090 | */
3091 | int
3092 | main(int argc, char **argv) {
3093 | FILE *f;
3094 | struct stat stbuf;
3095 | int l, c;
3096 | char *buf, *filename, *fnam = NULL;
3097 |
3098 | #ifdef __CYGWIN__
3099 | int opterr;
3100 |
3101 | extern int optind;
3102 | extern char *optarg;
3103 | #endif
3104 |
3105 | // printf("Content-type: text/html\n\n");
3106 |
3107 | opterr = 0; /* no stderr error messages */
3108 | while ((c = getopt (argc, argv, "D:E:hH:lL:M:pqrc?vVf")) != -1) {
3109 | switch(c) {
3110 | case 'D':
3111 | goto_dir(optarg, 0, 0); break;
3112 | case 'E':
3113 | error_page("Error", "%s", optarg); break;
3114 | case 'h':
3115 | set_cgibase("localhost"); break;
3116 | case 'H':
3117 | set_cgibase(optarg); break;
3118 | case 'l':
3119 | set_lynxcgibase("/home/httpd"); break;
3120 | case 'L':
3121 | set_lynxcgibase(optarg); break;
3122 | case 'M':
3123 | set_man2htmlpath(optarg); break;
3124 | case 'p':
3125 | set_separator('/'); break;
3126 | case 'q':
3127 | set_separator('?'); break;
3128 | case 'r':
3129 | set_relative_html_links(); break;
3130 | case 'c':
3131 | set_current_html_links(); break;
3132 | case 'v':
3133 | case 'V':
3134 | error_page("Version", "%s from man-%s", argv[0], version);
3135 | exit(0);
3136 | case '?':
3137 | default:
3138 | usage();
3139 | case 'f': /* It is rumoured that some other
3140 | incarnation of man2html uses this flag;
3141 | ignore when given for compatibility. */
3142 | /* case 'F': this will assign a format for man_page_html() */
3143 | break;
3144 | }
3145 | }
3146 |
3147 | /* Find filename */
3148 | if (argc == optind+1)
3149 | fnam = argv[optind];
3150 | else if (argc != optind)
3151 | usage();
3152 |
3153 | filename = fnam;
3154 | directory = 0;
3155 |
3156 | /* Open input file */
3157 | if (!fnam || !strcmp(fnam, "-")) {
3158 | f = stdin;
3159 | fname = "(stdin)";
3160 | } else {
3161 | /* do a chdir() first, to get .so expansion right */
3162 | goto_dir(fnam, &directory, &fnam);
3163 |
3164 | f = fopen(fnam, "r");
3165 | if (f == NULL)
3166 | error_page("File not found", "Could not open %s\n", filename);
3167 | fname = fnam;
3168 | }
3169 |
3170 | /* Read entire file into buf[1..l] */
3171 | #define XTRA 5
3172 | /* buf has 1 extra byte at the start, and XTRA extra bytes at the end */
3173 | if (f == stdin) {
3174 | int sz = 1024;
3175 | int ct = 1, tot = 0;
3176 | char *p = NULL;
3177 |
3178 | clearerr(stdin);
3179 | while (ct > 0) {
3180 | tot += ct;
3181 | if (feof(stdin))
3182 | break;
3183 | sz = 2*sz+tot;
3184 | p = xrealloc(p, sz);
3185 | ct = fread(p+tot,1,sz-tot-XTRA,stdin);
3186 | }
3187 |
3188 | buf = p;
3189 | l = tot-1;
3190 | } else {
3191 | int ct;
3192 |
3193 | l = 0;
3194 | if (fstat(fileno(f), &stbuf) != -1)
3195 | l = stbuf.st_size;
3196 | buf = (char *) xmalloc((l+1+XTRA)*sizeof(char));
3197 | ct = fread(buf+1,1,l,f);
3198 | if (ct < l)
3199 | l = ct;
3200 | fclose(f);
3201 | }
3202 |
3203 | buf[0] = '\n';
3204 | buf[l+1] = '\n';
3205 | buf[l+2] = buf[l+3] = 0;
3206 |
3207 | #ifdef MAKEINDEX
3208 | idxfile = fopen(INDEXFILE, "a");
3209 | #endif
3210 | stdinit();
3211 |
3212 | scan_troff(buf+1,0,NULL);
3213 | dl_down();
3214 | out_html(change_to_font(0));
3215 | out_html(change_to_size(0));
3216 | if (!fillout) {
3217 | fillout=1;
3218 | out_html("");
3219 | }
3220 | out_html(NEWLINE);
3221 | if (output_possible) {
3222 | /* for mosaic users */
3223 | printf("
\n Index
\n\n");
3224 | manidx[mip]=0;
3225 | printf("%s", manidx);
3226 | if (subs) printf("
\n");
3227 | printf("\n");
3228 | print_sig();
3229 | printf("\n\n");
3230 | } else {
3231 | if (!filename)
3232 | filename = fname;
3233 | if (*filename == '/')
3234 | error_page("Invalid Manpage",
3235 | "The requested file %s is not a valid (unformatted) "
3236 | "man page.\nIf the file is a formatted manpage, "
3237 | "you could try to load the\n"
3238 | "plain file.\n",
3239 | filename, filename);
3240 | else
3241 | error_page("Invalid Manpage",
3242 | "The requested file %s is not a valid (unformatted) "
3243 | "man page.", filename);
3244 | }
3245 | if (idxfile)
3246 | fclose(idxfile);
3247 | if (buf)
3248 | free(buf);
3249 | return 0;
3250 | }
3251 |
--------------------------------------------------------------------------------
/scripts/cgi-aux/man/man.aux:
--------------------------------------------------------------------------------
1 | Content-type: text/html
2 |
3 |
4 |
5 | Manual Pages - Main Contents
11 |
12 |
13 | Name and Section lookup
14 |
21 |
26 |
27 |
28 |
29 | Index of pages by name and description
30 | Sections:
31 | 1. User Commands;
32 | 2. System Calls;
33 | 3. Library Functions;
34 | 4. Special Files;
35 | 5. File Formats;
36 | 6. Games;
37 | 7. Miscellany;
38 | 8. Administration and Privileged Commands;
39 | l. Postgresql Commands;
40 | n. Tcl Commands.
41 |
43 | Index of pages by name only
44 | 1. User Commands;
45 | 2. System Calls;
46 | 3. Library Functions;
47 | 4. Special Files;
48 | 5. File Formats;
49 | 6. Games;
50 | 7. Miscellany;
51 | 8. Administration and Privileged Commands;
52 | l. Postgresql Commands;
53 | n. Tcl Commands;
54 | All Sections.
55 |
57 |
58 | Manual Pages full text search
59 |
60 |
61 | Search the full text of the Manual Pages.
62 |
63 |
64 |
66 |
67 | The original man2html program and scripts are due to
68 |
69 | Richard Verhoeven and
70 |
71 | Michael Hamilton.
72 | This version is from man-1.6f maintained by
73 | Federico Lucifredi.
74 |
75 |
76 |
--------------------------------------------------------------------------------
/scripts/cgi-aux/man/mansearch.aux:
--------------------------------------------------------------------------------
1 | Content-type: text/html
2 |
3 |
4 |
5 | Manual Pages - Text Search
11 |
12 | Return to Main Contents
13 |
20 |
27 |
28 |
29 |
37 |
38 | Manual Pages - Search Help
11 |
12 | Perform another search
13 |
14 | Return to Main Contents
15 |
17 |
25 |
26 | Search Options
27 |
28 | The following search options must be at the start of the search string.
29 |
30 |
31 |
32 |
102 |
103 |
105 |
106 | Patterns
107 |
108 | Glimpse
109 | supports a large variety of patterns, including simple
110 | strings, strings with classes of characters, sets of strings,
111 | wild cards, and regular expressions (see LIMITATIONS).
112 |
113 |
114 |
226 |
227 |
228 |
229 | Limitations
230 |
231 | The index of glimpse is word based. A pattern that contains more than
232 | one word cannot be found in the index. The way glimpse overcomes this
233 | weakness is by splitting any multi-word pattern into its set of words
234 | and looking for all of them in the index.
235 | For example, glimpse 'linear programming' will first consult the index
236 | to find all files containing both linear and programming,
237 | and then apply agrep to find the combined pattern.
238 | This is usually an effective solution, but it can be slow for
239 | cases where both words are very common, but their combination is not.
240 |
294 |
295 |
296 |
--------------------------------------------------------------------------------
/scripts/cgi-bin/man/man2html:
--------------------------------------------------------------------------------
1 | #!/bin/sh
2 | # man2html cgi script - uses /usr/bin/man2html to format man pages
3 | # auxiliary text files in /home/httpd/cgi-aux/man
4 | # aeb@cwi.nl - 980109
5 |
6 | MAN2HTML="/usr/bin/man2html"
7 | MANX="/home/httpd/cgi-aux/man/man.aux"
8 |
9 | # Do we need lynxcgi URLs? For the moment our criterion is
10 | # 1) HTTP_USER_AGENT=Lynx* and 2) HTTP_HOST is unset.
11 | AGENT="${HTTP_USER_AGENT-unknown}"
12 |
13 | case "$AGENT" in
14 | Lynx*|lynx*)
15 | HH="${HTTP_HOST-nohh}"
16 | SED="s/%lynx //"
17 | ;;
18 | *)
19 | HH=nolynx
20 | SED="/%lynx/d"
21 | ;;
22 | esac
23 |
24 | SERVER="${SERVER_NAME-localhost}"
25 | case "$HH" in
26 | nohh)
27 | LL="-l"
28 | CG="lynxcgi:/home/httpd/cgi-bin/man"
29 | ;;
30 | *)
31 | LL="-H$SERVER"
32 | CG="http://$SERVER/cgi-bin/man"
33 | ;;
34 | esac
35 |
36 | # Find the required page - expect to be called with "man2html [sec] page".
37 | # There may a prefixed "-M manpath" option.
38 | if [ $# -ge 2 -a x"$1" = x-M ]; then
39 | MANPATH="$2"
40 | export MANPATH
41 | shift; shift
42 | MP=" using the given MANPATH"
43 | else
44 | MP=""
45 | fi
46 |
47 | # If no arguments given, show a start page.
48 | if [ $# = 0 ]; then
49 | if [ -r $MANX ]; then
50 | cat $MANX | sed "s#%cg#$CG#g; $SED"
51 | else
52 | "$MAN2HTML" -E "man2html: cannot open $MANX"
53 | fi
54 | exit 0
55 | fi
56 |
57 | if [ $# -gt 2 ]; then
58 | "$MAN2HTML" -E "man2html: bad invocation: too many arguments"
59 | exit 0
60 | fi
61 |
62 | # A single argument may be an explicitly give path name
63 | # Otherwise, ask man where to find it
64 | if [ $# = 1 ]; then
65 | case "$1" in
66 | /*)
67 | PAGE="$1"
68 | ;;
69 | *)
70 | PAGE=`man -w -c "$@" 2>/dev/null`
71 | ;;
72 | esac
73 | else
74 | PAGE=`man -w -c "$@" 2>/dev/null`
75 | fi
76 |
77 | if [ x"$PAGE" = x ]; then
78 | complaint="man2html: cannot find a page"
79 | if [ $# = 1 ]; then
80 | "$MAN2HTML" -E "$complaint for $1$MP"
81 | else
82 | "$MAN2HTML" -E "$complaint for $2 in section $1$MP"
83 | fi
84 | exit 0
85 | fi
86 |
87 | if [ -r "$PAGE" ]
88 | then
89 | case "$PAGE" in
90 | *.gz)
91 | zcat "$PAGE" | "$MAN2HTML" "$LL" -D "$PAGE"
92 | ;;
93 | *.bz2)
94 | bzcat "$PAGE" | "$MAN2HTML" "$LL" -D "$PAGE"
95 | ;;
96 | *)
97 | "$MAN2HTML" "$LL" "$PAGE"
98 | ;;
99 | esac
100 | elif [ -r "$PAGE".gz ]
101 | then
102 | zcat "$PAGE".gz | "$MAN2HTML" "$LL" -D "$PAGE"
103 | elif [ -r "$PAGE".bz2 ]
104 | then
105 | bzcat "$PAGE".bz2 | "$MAN2HTML" "$LL" -D "$PAGE"
106 | else
107 | "$MAN2HTML" -E "Strange... Cannot find (or read) $PAGE."
108 | fi
109 | exit 0
110 |
--------------------------------------------------------------------------------
/scripts/cgi-bin/man/mansearch:
--------------------------------------------------------------------------------
1 | #!/bin/sh
2 | #
3 | # Interface to a glimpse search of the man pages.
4 | # Michael Hamilton Manual Pages - Search Results
";
101 | print "Target text: " options " " string "
";
102 |
103 | print "";
104 | print "Perform another search";
105 | print "
";
106 | print "";
107 | print "Return to Main Contents";
108 | print "";
109 |
110 | print "
";
111 |
112 | print "";
113 | # Unless you like being hacked, the single
114 | # forward quotes are most important.
115 | cmd = glimpse_cmd " " options " " quote string quote " 2>/dev/null" ;
116 |
117 | while ((cmd | getline matchline) > 0) {
118 | if (split(matchline, part, ": ") == 1) {
119 | continue;
120 | }
121 | else {
122 | fullname = part[1];
123 | }
124 |
125 | if (fullname == "glimpse") {
126 | print "
";
140 | print "Location: " dirname "
";
141 | print "";
142 | }
143 | }
144 | else {
145 | filename = fullname;
146 | }
147 |
148 | if (match(filename, /\.[^.]+$/)) {
149 | ref = substr(filename, 1, RSTART - 1) "+" substr(filename, RSTART + 1);
150 | }
151 | else {
152 | ref = filename;
153 | }
154 | print "
";
179 | if (mcount == 0) {
180 | print "No matches found.";
181 | }
182 | else if (mcount == 1) {
183 | print "
\n
\nManual Pages - Page Names
" > cache_tmp;
103 | print "Section " section ": " sec_name[section] "
" > cache_tmp;
104 |
105 | "hostname" | getline hostname;
106 | "date" | getline date;
107 | print hostname " (" date ")" > cache_tmp;
108 |
109 | if (section != "all") {
110 | sec_sub_dir = "/man" section;
111 | }
112 | else {
113 | sec_sub_dir = "/man*";
114 | }
115 | gsub(" ", sec_sub_dir " ", man_path);
116 |
117 | print " ", toupper(letter), "
" > buffer_tmp;
128 | # Print out alphabetic quick index and other links
129 | }
130 | # Split page.n into "page" and "n" and generate an entry
131 | sub(/[.]([zZ]|(gz))$/, "", manpage);
132 | match(manpage, /[.][^.]+$/);
133 | title = substr(manpage, 1, RSTART - 1);
134 | if (section != "all") {
135 | print "", title, "(", substr(manpage, RSTART + 1), ")" > buffer_tmp;
136 | }
137 | else {
138 | sec = substr(manpage, RSTART + 1)
139 | print "", title, "(", sec, ")" > buffer_tmp;
140 | }
141 | }
142 |
143 | close(buffer_tmp);
144 |
145 | print "
" > cache_tmp;
153 | print "Return to Main Contents" > cache_tmp;
154 |
155 | print "
" > cache_tmp;
170 | print "Manual Pages - Names and Descriptions
" > cache_tmp;
94 | print "Section " section ": " sec_name[section] "
" > cache_tmp;
95 | "hostname" | getline hostname;
96 | "date" | getline date;
97 | print hostname " (" date ")" > cache_tmp;
98 | # Find out the man path
99 | "man -w" | getline;
100 | $1 = $1 ":";
101 | gsub(":", " ", $1);
102 |
103 | find_cmd = "find " man_path " -maxdepth 1 -name whatis -printf '%p '";
104 | find_cmd | getline whatis_files;
105 | close(find_cmd);
106 |
107 | if (whatis_files == "") {
108 | print "Content-type: text/html\n\n";
109 | print "";
110 | print "
Manual pages referenced in " whatis_files " ", toupper(letter), "
\n" > buffer_tmp ;
155 | }
156 | # Generate a
" > cache_tmp;
176 | print "Return to Main Contents" > cache_tmp;
177 |
178 | print "
" > cache_tmp;
193 | print "