--- /dev/null
+;;; tinytag.el --- Grep tags: show C++/Java/etc. syntax call while coding
+
+;; This file is not part of Emacs.
+
+;;{{{ Id
+
+;; Copyright (C) 1996-2007 Jari Aalto
+;; Keywords: tools
+;; Author: Jari Aalto
+;; Maintainer: Jari Aalto
+;;
+;; To get information on this program, call M-x tinytag-version.
+;; Look at the code with folding.el.
+
+;; This program is free software; you can redistribute it and/or modify it
+;; under the terms of the GNU General Public License as published by the Free
+;; Software Foundation; either version 2 of the License, or (at your option)
+;; any later version.
+;;
+;; This program is distributed in the hope that it will be useful, but
+;; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+;; or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+;; for more details.
+;;
+;; You should have received a copy of the GNU General Public License
+;; along with program; see the file COPYING. If not, write to the
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
+;;
+;; Visit <http://www.gnu.org/copyleft/gpl.html> for more information
+
+;;}}}
+;;{{{ Install
+
+;; ....................................................... &t-install ...
+;; Put this file on your Emacs-Lisp load path, add following into your
+;; ~/.emacs startup file. Rip code with with tinylib.el/ti::package-rip-magic
+;;
+;; (setq tinytag-:database-dir "~/elisp/config")
+;; (require 'tinytag)
+;;
+;; You can also use the autoload feature, which speeds up loading
+;; the ~/.emacs
+;;
+;; (autoload 'tinytag-install "tinytag" "" t)
+;; (autoload 'tinytag-main "tinytag" "" t)
+;; (autoload 'tinytag-main-mouse "tinytag" "" t)
+;;
+;; You do not have to install `tinytag-install' function to every known
+;; programming language, because the mode will be global once it
+;; is called. Here, if you program mostly with Java and C,
+;; then either one will activate tinytag for all buffers.
+;;
+;; (add-hook 'c++-mode-hook 'tinytag-install)
+;; (add-hook 'c-mode-hook 'tinytag-install)
+;; (add-hook 'java-mode-hook 'tinytag-install)
+;;
+;; ********************************************************************
+;;
+;; YOU MAY NEED TO CHANGE VARIABLE tinytag-:database-setup-table
+;; BEFORE YOU USE THIS PACKAGE.
+;;
+;; It gives the instructions where are the databases located
+;; that offer the code help in echo are. Without that variable
+;; this package does nothing.
+;;
+;; Read section "Installing support for your programming languages"
+;;
+;; ********************************************************************
+;;
+;; When you use this package for the first time, an example C/C++
+;; database is extracted fromt he end of this file. See the attached
+;; perl script if you want to generate the database from your
+;; system's manual pages by hand.
+;;
+;; M-x load-library RET tinytag RET
+;; M-x tinytag-install-sample-databases
+;;
+;; Keybinding suggestion (HP-UX)
+;;
+;; (global-set-key [(alt control mouse-2)] 'tinytag-main-mouse)
+;; (global-set-key "\C-c\C-z" 'tinytag-main)
+;;
+;; If you have any questions, use these function
+;;
+;; M-x tinytag-submit-bug-report
+;;
+;; Pleace, send any other programming language database that you may use,
+;; even an different C prototypes in different platform. Let's share the
+;; information with others!
+;;
+;; C/C++ database help
+;;
+;; Peter Simons <simons@petium.rhein.de> to get
+;; NetBSD/Linux C database
+;;
+;; Java database help
+;;
+;; Jari Aalto
+;; SUN Java databases (1.2.2 - 1.4)
+
+;;}}}
+;;{{{ Documentation
+
+;; ..................................................... &t-commentary ...
+;;; Commentary:
+
+;; Preface, overview of features
+;;
+;; o Simple database searching, some analogue to emacs TAGS package.
+;; Databaseses are simple text files that are searched for matches.
+;; o Flips databases easily to show the right data.
+;; o The Language's function call syntax is shown in the echo area
+;; when cursor is over an identifiable item.
+;; o Limitations: The function help info can only be 80 characters
+;; or as long as your minibuffer is wide. But you can keep the
+;; *tinytag-output* buffer visible in another buffer to show all
+;; the information.
+;; o Unlimited extendability to any programming or other "lookup"
+;; languages.
+;;
+;; Ready-to-use databases currently available:
+;;
+;; o HP-UX/Netbsd C/C++ function database is included in this file
+;; and perl script to rip the function definitions from Unix manual
+;; pages.
+;; o Perl script to generate databases from any
+;; Javadoc compliant pages (E.g full database from all
+;; JDK 1.2.2 pages) The Java database is not distributed
+;; because it takes over a Meg and generating one straight
+;; from SUN Java /docs tree is trivial.
+;;
+;; Story behind this package
+;;
+;; The word "tag" refers to famous tags package in emacs that allows
+;; you to browse your C/C++ code easily.
+;;
+;; Someone may be in the middle of c++ project at work and notice
+;; that he frequently consults the manual pages to find correct
+;; syntax for calling stdio.h functions. It's hard to remember
+;; them right every time. Time spent for reading manual pages may
+;; be considerable just to figure out what #include statements
+;; each function might require, and what type of parameters they
+;; need.
+;;
+;; No more. There must be a way out of this...
+;;
+;; If you have programmed in lisp, you propably know package called
+;; eldoc.el (get it fast if you haven't) by Noah Friedman
+;; <friedman@prep.ai.mit.edu>. It shows you the lisp function call
+;; arguments when your cursor is right over some function.
+;;
+;; What a cool tool! You never have to go to elisp info pages
+;; just to check what the function takes, and you don't have to
+;; pop up extra buffer with c-h f <func>. It's a real time saver.
+;; Similar keyword lookup feature culd be built for any
+;; programing. Since eldoc looked the lisp args from memory
+;; (emacs obarray, symbol storage), the other programming
+;; languages must use external reference files: databases.
+;;
+;; First, all C/C++ function syntaxes were extracted out of the
+;; man pages with small perl program. The final output after
+;; ripping all the 3C man pages loooked like this. The output
+;; is put under database 'c++-functions'
+;;
+;; <dirent.h> dir *opendir(const char *dirname);
+;; <dirent.h> int closedir(dir *dirp);
+;; <dirent.h> int readdir_r(dir *dirp, struct dirent *result);
+;; <dirent.h> long int telldir(dir *dirp);
+;; <dirent.h> struct dirent *readdir(dir *dirp);
+;; ...
+;; <string.h><strings.h> char *index(const char *s, int c);
+;; <string.h><strings.h> char *rindex(const char *s, int c);
+;;
+;; Notice how perl stuck the '#define' statements at the
+;; beginning of each function. After this 'function' database was
+;; ready, the only thing needed was lisp code to handle database
+;; lookups for the keyword under the cursor. Similar approach can
+;; be user for any programming language. Just set up the
+;; database, entries to search; one per line. that's it.
+;;
+;; Word about installation -- performance problems [19.29 or lower]
+;;
+;; Skip this part if you have 19.30+
+;;
+;; When you load this package, it immediately installs an _example_
+;; post-command function. It assumes that you're using the "Having a
+;; test drive" C++ database and stored it as explained. You propably
+;; want to remove that default post-command function and use your own
+;; definition. Here is how you remove it.
+;;
+;; Doing this is also recommended if you don't want post command
+;; actions, but want to use the tinytag-main[-mouse] functions
+;; directly. Call them only when you need them.
+;;
+;; o before any load command say: (setq tinytag-:load-hook nil)
+;; o If package is already loaded, say: C-u M-x tinytag-install.
+;;
+;; If your databases are big, or if you're afraid of the overall emacs
+;; performance I STRONGLY ADVICE THAT YOU REMOVE THAT post-command
+;; with methods (2) or (1) You can always call the database with the
+;; supplied keyboard or mouse commands when you need the information.
+;;
+;; Having a test run
+;;
+;; There is sample C++ database from HP-UX 10 man 3C pages, which
+;; is unfortunately incomplete. You may consider using the BSD
+;; C-database instaed. The BSD is installed by default when you
+;; call `M-x' `tinytag-install-sample-database-c'. Rememeber that
+;; you really should replace those definitions with your own
+;; systems equivalents, because not all functions are found in
+;; all systems. Vendors are different.
+;;
+;; This is how you test this package.
+;;
+;; o Go to empty buffer
+;; o Add statement "strcat(a,b)" to the buffer
+;; o Turn on C++ mode
+;; o Be sure to have tinytag on (M-x load-library tinytag.el)
+;; o Move your cursor over the word "strcat" and wait few seconds.
+;; <For very old Emacs, below 19.30: wave your cursor
+;; back and forth about 5 times.>
+;;
+;; You should see the "strcat"'s function's definition displayed in
+;; the echo area. Next, you can start writing your own databases to
+;; languages you use.
+;;
+;; Installing support for your programming languages
+;;
+;; While you may have installed the default database for C/C++, you
+;; have to configure the variable `tinytag-:database-setup-table' to
+;; include all languages where you have databases available. It is
+;; recommended that you keep all emacs related configuration,
+;; including databases, in one place, e.g.
+;;
+;; ~/elisp/config/
+;;
+;; First you need databases which you must write yourself.
+;; e.g. emacs-tinytag-python-function.el where you describe the
+;; function, packages and call syntax. The only thing after creating the
+;; database is to tell where it can be found. E.g for php you would
+;; add couple of you own variables:
+;;
+;; (defconst my-tinytag-:db-map-php
+;; '((func "emacs-config-tinytag-php.txt"))
+;; "Java database.")
+;;
+;; (defconst my-tinytag-:db-re-php
+;; '(("." (func))) ;; See name FUNC in prev. variable
+;; "PHP database.")
+;;
+;; And tell tinytag.el that the Java is now known:
+;;
+;; (defconst tinytag-:database-setup-table
+;; (list
+;; (list
+;; "code-php\\|php"
+;; '(my-tinytag-:db-map-php
+;; my-tinytag-:db-re-php))
+;; (list
+;; "c-mode....."
+;; '(..
+;; ))))
+;;
+;; C/C++ database
+;;
+;; Run c-function-list.pl that comes with Tiny Tools Distribution to
+;; generate function database.
+;;
+;; Alternatively copy the database from the end of this file or
+;; use M-x tinytag-install-sample-databases
+;;
+;; Java database
+;;
+;; Run script `java-function-list.pl' that comes with Tiny Tools
+;; distribution to generate function database from the Sun JDK's javadoc
+;; html pages. See the manual page of the script how to run it (--help
+;; option)
+;;
+;; NOTE: In SUN documentation, there is no System.out.print() or
+;; System.out.println() functions that could be extracted. Please add
+;; Those functions by hand to the database.
+;;
+;; This script is also run with call tinytag-install-sample-databases,
+;; provided that you have `perl' and `java' and `java-function-list.pl'
+;; installed and located along PATH.
+;;
+;; Perl database
+;;
+;; <coming>
+;;
+;; Run perl-function-list.pl that comes with Tiny Tools Distribution to
+;; generate function database. See the manual page of the script how to
+;; run it (--help option)
+;;
+;; Database format and display
+;;
+;; There is nothing special in the database format, each entry must me
+;; in one line nad that's all. Try to find most suitable display format
+;; for your language, like the general method that is used for C/C++, Java
+;; and Perl
+;;
+;; <LIBRARY> return-value function-name(function-parameters) REST-INFO
+;;
+;; _Important_: When function `tinytag-search-db' searches the whole
+;; database, it gathers the lines that likely match and FIRST one that
+;; is found is displayed in the echo-area. So that you're aware of other
+;; matches, the count of matches is displayed
+;;
+;; 10: java.lang.System.out void println()
+;; |
+;; Count of matches
+;;
+;; If you have time, it would be sensible to move the most informational
+;; description of the function first in the list of lines, so that it
+;; get displayed. For example, you could move method this method first in
+;; the line and add [] inside function parameters to signal that the
+;; parameter is optional
+;;
+;; java.lang.System.out void print([Object obj])
+;;
+;; Alternatively, you can keep the buffer `tinytag-:output-buffer'
+;; visible e.g in separate frame, so that all the matched items are
+;; visible to you in case the one displayed in echo-are is not correct.
+;;
+;; Differencies between 19.30+ and lower
+;;
+;; The 19.30 Emacs has idle hook, which runs after you move cursor. It
+;; doesn't run if you move mouse. 19.28 on the other hand has post
+;; command hook, that runs every time you either move cursor _OR_
+;; move mouse.
+;;
+;; Now, to get display fast in 19.28, you propably want to wave
+;; your mouse fast couple of times. In 19.30 you can have immediate
+;; display with just one cursor move over the word.
+;;
+;; What to do if you don't see the definition displayed?
+;;
+;; hem most informative is the internal debug which you turn on with:
+;;
+;; M-x tinytag-debug
+;;
+;; Then call this function directly over the word whose definition
+;; you want to display (e.g. strcat in C++)
+;;
+;; ESC ESC : (tinytag-post-command-1)
+;; ========
+;; Press this key combination and enter text to the right.
+;;
+;; After that call there is buffer *tinytag-debug* that has some
+;; information about called functions and parameters. Please
+;; investigate the call chain for possible problem. Is the database
+;; selected right? if the regexp used for search right? If you don't
+;; know how to read the debug buffer's output, just send the buffer's
+;; content to me and describe what you did and what was your current
+;; major mode.
+;;
+;; Thank you
+;;
+;; Peter Simons <simons@petium.rhein.de> sent me
+;; NetBSD and Linux C databases and his perl script can help you
+;; to create your own database from the man pages.
+
+;;}}}
+
+;;; Change Log:
+
+;;; Code:
+
+;;{{{ setup: require
+
+;; Under no circumstances remove the following comment line below!
+;; $PackageInstallRe: '^;;+[*]' $
+
+(require 'tinylibm)
+
+(eval-and-compile
+ (autoload 'man "man" "" t))
+
+(eval-when-compile (ti::package-use-dynamic-compilation))
+
+(ti::package-defgroup-tiny TinyTag tinytag-: programming
+ "Grep database: example show C++ synatx call while coding.
+Overview of features
+ o simple database searching, some analogue to emacs TAGS package.
+ o you can flip databases very easily to show the right data.
+ o example: showing c++ funcall syntax in echo area while you program.
+ o installs hp-ux or netbsd c function databases automatically.")
+
+;;}}}
+;;{{{ setup: -- variables
+
+(defcustom tinytag-:load-hook nil
+ "*Hook run when file has been loaded."
+ :type 'hook
+ :group 'TinyTag)
+
+(defcustom tinytag-:post-command-try-hook
+ '(tinytag-try-function-show-cached-word
+ tinytag-try-function-search-db)
+ "*Try displaying the information.
+Run these functions, until one of them return non-nil.
+Put here only functions that does not need any user interaction."
+ :type 'hook
+ :group 'TinyTag)
+
+(defcustom tinytag-:try-hook
+ '(tinytag-try-function-show-cached-word
+ tinytag-try-function-search-db
+ tinytag-try-function-man)
+ "*Try displaying the information.
+Run these functions, until one of them return non-nil.
+This hook is primarily run upon request: M - x, keyboard command, or mouse
+command."
+ :type 'hook
+ :group 'TinyTag)
+
+(defcustom tinytag-:set-database-hook
+ '(tinytag-set-database)
+ "*Function to set the correct database for buffer.
+Run these functions, until someone return non-nil."
+ :type 'hook
+ :group 'TinyTag)
+
+(defcustom tinytag-:word-filter-hook
+ '(tinytag-filter-default-function)
+ "*Run hook until some function return non-nil.
+Every function in this hook is called with
+
+arg1: string, word picked at current point to initiate database search
+
+The function should return nil if the word should not be searched.
+many times short words are not valid 'keys' in database: e.g. in
+C/C++ code common words like 'char' 'double' 'int' can be ignored."
+ :type 'hook
+ :group 'TinyTag)
+
+(defcustom tinytag-:word-modify-hook 'tinytag-word-default-adjust
+ "*This function formats the searched word to correct search regexp.
+Regexp should match only desired hits.
+
+Call arguments:
+ string
+
+Function must return always:
+ string"
+ :type 'hook
+ :group 'TinyTag)
+
+(defcustom tinytag-:database-ok-hook nil
+ "*Run hook database was set according to current buffer.
+Called from `tinytag-set-database'.
+
+The variables `tinytag-:database-map' and `tinytag-:regexp-to-databases'
+have valid values when the hook is called."
+ :type 'hook
+ :group 'TinyTag)
+
+;;; ....................................................... &v-private ...
+
+(defvar tinytag-:last-word-lookup nil
+ "Last lookup, '(WORD . (DB-STRING DB-STRING)).")
+(make-variable-buffer-local 'tinytag-:last-word-lookup)
+
+(defvar tinytag-:noerror nil
+ "If non-nil, no error command is called.")
+
+(defvar tinytag-:post-command-hook-counter nil
+ "Counter.")
+
+(defvar tinytag-:post-command-hook-wakeup
+ ;; There is no delay in 19.30+, but for <19.30 the must be
+ ;;
+ (if (boundp 'post-command-idle-hook)
+ 0 3)
+ "Wakeup threshold.
+The more lower value, the more often post command hook is called
+and your Emacs probably slows down. The values must be 0 in 19.30+,
+because `post-command-hook' is not used there.")
+
+(defvar tinytag-:database-map nil
+ "Databases available, format '((NAME-SYMBOL FILENAME) .. )
+Do not put directory name here, use `tinytag-:database-dir' instead.")
+
+(defvar tinytag-:regexp-to-databases nil
+ "Which REGEXP on word should initiate database search?.
+Format: '((REGEXP '(database1 database2 ..)) (RE (d1 d1 ..)) ..)")
+
+(defvar tinytag-:idle-timer-elt nil
+ "If idle timer is used, this variable has the timer elt.")
+
+;;; .................................................. &private-sample ...
+;;; - These are offered as samples, see tinytag-set-database,
+;;; which uses these variable. They are not part of the tinytag.el
+;;; package (user variables). You should program your own
+;;; tinytag-set-database function to deal with different buffers.
+
+(defconst tinytag-:example-db-map-c++
+ '((func "emacs-config-tinytag-c++-functions.txt")
+ (struct "emacs-config-tinytag-c++-structs.txt")
+ (types "emacs-config-tinytag-c++-types.txt"))
+ "Sample. C++ databases.")
+
+(defconst tinytag-:example-db-re-c++
+ '(("_t" (types structs))
+ ("_s" (struct types))
+ ("." (func)))
+ "Sample. C++ word-to-database mappings.")
+
+(defconst tinytag-:example-db-map-java
+ '((func "emacs-config-tinytag-java-functions.txt"))
+ "Sample. Java databases.")
+
+(defconst tinytag-:example-db-re-java
+ '(("." (func))) ;; All words are looked from `func' database
+ "Sample. Map found word to correct Java database.")
+
+;;; You propably should program your own filter function for variaous
+;;; modes. This variable belongs to default filter only.
+;;;
+(defcustom tinytag-:filter-default-c++-words
+ (concat
+ "^char\\|^double\\|^int$\\|^float\\|^void\\|static"
+ "\\|endif\\|define\\|ifndef\\|ifdef\\|include"
+ "\\|break")
+ "*Filter out unwanted words from current point.
+This variable is used in `tinytag-filter-default-function'."
+ :type '(string "Regexp")
+ :group 'TinyTag)
+
+;;; ........................................................ &v-public ...
+;;; user configurable
+
+(defcustom tinytag-:output-buffer "*tinytag-output*"
+ "*Buffer where to display all database matches for word at point.
+Many times the word picked at point matches several functions and you
+can keep this buffer in separate frame in Window environment to see what
+is the correct match.
+If this variable is nil, no buffer is created.")
+
+(defcustom tinytag-:database-dir
+ (or
+ (file-name-as-directory
+ (file-name-directory (ti::package-config-file-prefix "tinytag.el")))
+ (error "TinyTag: Can't set default value for `tinytag-:database-dir'.
+Please define the directory of database directory to `tinytag-:database-dir'."))
+ "*Directory of database files."
+ :type 'directory
+ :group 'TinyTag)
+
+(defcustom tinytag-:filter-word-table
+ (list
+ (list
+ (concat
+ "c-mode\\|cc-mode\\|c[+]+-mode"
+ ;;See tinylibid.el
+ "\\|code-c\\|code-c[+]+")
+ '(or (< (length string) 4) ;too short word ?
+ (string-match tinytag-:filter-default-c++-words string))))
+ "*Format is:
+
+'((BUFFER-TYPE-REGEXP EVAL-STATEMENT-TO-REJECT) (B E) ..)
+
+If buffer type/mode matches REGEXP then the eval statement is evaluated
+for current word that is stored into 'string'. The statement should return
+t if word should be rejected. During the eval, any matches done are
+case sensitive."
+ :type '(repeat
+ (string :tag "buffer type regexp")
+ (sexp :tag "Form"))
+ :group 'TinyTag)
+
+(defcustom tinytag-:database-setup-table
+ (list
+ (list
+ (concat
+ ;; See tinylibid.el to detect buffer type
+ "c-mode\\|cc-mode\\|c[+]+-mode"
+ "\\|code-c\\|code-c[+]+")
+ '(tinytag-:example-db-map-c++
+ tinytag-:example-db-re-c++))
+ (list
+ "java"
+ '(tinytag-:example-db-map-java
+ tinytag-:example-db-re-java)))
+ "*If buffer type/mode match REGEXP then set database variables.
+Cariables `tinytag-:database-map' and
+`tinytag-:regexp-to-databases' are used.
+
+The BUFFER-TYPE-REGEXP corresponds the value returned by ti::id-info
+for current buffer. The function detects various progrmaming.
+
+Format:
+
+'((BUFFER-TYPE-REGEXP (DATABASE-MAP-SYM DATABASE-REGEXP-SYM))
+ ..)"
+ :type '(repeat
+ (list
+ (string :tag "mode regexp")
+ (list
+ (symbol :tag "db map sym")
+ (symbol :tag "db regexp sym"))))
+ :group 'TinyTag)
+
+(defcustom tinytag-:display-function 'tinytag-display-function
+ "*Function to display search results.
+Should accept one ARG, which is list of matched lines from databases."
+ :type 'function
+ :group 'TinyTag)
+
+;;}}}
+;;{{{ version
+
+;;;### (autoload 'tinytab-debug-toggle "tinytag" t t)
+
+(eval-and-compile (ti::macrof-debug-standard "tinytag" "-:"))
+
+(eval-and-compile
+ (ti::macrof-version-bug-report
+ "tinytag.el"
+ "tinytag"
+ tinytag-:version-id
+ "$Id: tinytag.el,v 2.53 2007/05/01 17:21:00 jaalto Exp $"
+ '(tinytag-:version-id
+ tinytag-:debug
+ tinytag-:load-hook
+ tinytag-:try-hook
+ tinytag-:set-database-hook
+ tinytag-:last-word-lookup
+ tinytag-:noerror
+ tinytag-:post-command-hook-counter
+ tinytag-:post-command-hook-wakeup
+ tinytag-:example-db-map-c++
+ tinytag-:example-db-re-c++
+ tinytag-:database-dir
+ tinytag-:database-map
+ tinytag-:regexp-to-databases
+ tinytag-:display-function
+ post-command-idle-hook
+ post-command-hook)
+ '(tinytag-:debug-buffer)))
+
+;;}}}
+;;{{{ code: install
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinytag-initialize ()
+ "Start package and verify that some variables exist."
+ (interactive)
+ (let* ()
+ (if (or (not (stringp tinytag-:database-dir))
+ (not (file-exists-p tinytag-:database-dir)))
+ (error "\
+TinyTag: `tinytag-:database-dir' is not a directory. Please configure"))))
+
+;;; ----------------------------------------------------------------------
+;;;
+;;;###autoload
+(defun tinytag-install (&optional uninstall)
+ "Install package. Optionally UNINSTALL."
+ (interactive "P")
+ (let* ((hook (if (boundp 'post-command-idle-hook)
+ ;; post-command-idle-hook became obsolete in 19.34
+ 'post-command-idle-hook
+ 'post-command-hook))
+ (cmd (if uninstall
+ 'remove-hook
+ 'add-hook)))
+ (cond
+ ((ti::idle-timer-supported-p)
+ (ti::compat-timer-cancel-function 'tinytag-post-command)
+ (unless uninstall
+ (setq
+ tinytag-:idle-timer-elt
+ (ti::funcall
+ 'run-with-idle-timer
+ 2
+ 'repeat
+ 'tinytag-post-command))))
+ (t
+ ;; We use post-command-idle-hook if defined,
+ ;; otherwise put it on post-command-hook.
+ ;; The idle hook appeared in Emacs 19.30.
+ (funcall cmd hook 'tinytag-post-command)))
+ (when (interactive-p)
+ (message "TinyTag: Package %s" (if uninstall
+ "deactivated"
+ "activated")))))
+
+;;; ----------------------------------------------------------------------
+;;;
+;;;###autoload
+(defun tinytag-uninstall ()
+ "Uninstall package."
+ (tinytag-install 'uninstall))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinytag-install-sample-database-java-external-process (doc-dir file)
+ "Call external process to examine DOC-DIR to build Java function calls.
+The output is written to FILE."
+ (let* ((info (ti::process-perl-version "perl"))
+ (perl (nth 2 info))
+ ;; (type (nth 1 info))
+ (bin "java-function-list.pl")
+ (prg (ti::file-get-load-path bin exec-path)))
+ (cond
+ ((null perl)
+ (message
+ (concat
+ "Tinytag: [install] Cannot find `perl' along path. "
+ "Please check your PATH or install perl. "
+ (if (ti::win32-p)
+ "http://www.activestate.com"
+ "http://www.perl.com/"))))
+ ((null prg)
+ (message
+ (concat
+ "Tinytag: [install] Cannot find " bin
+ " please check your PATH")))
+ (t
+ (unless (file-directory-p
+ (file-name-directory file))
+ (error "Tinytag: Can't find directory %s" file))
+ (with-temp-buffer
+ ;; Java 1.3-1.4 documentation size, when processes, is 1.5 Meg
+ ;; It will fit into memory.
+ (message
+ (concat
+ "Tinytag: [install] Java database... "
+ "Please wait for external process to traverse %s") doc-dir)
+ (call-process perl
+ nil
+ (current-buffer)
+ nil
+ prg
+ "--recurse"
+ doc-dir)
+ (message "Tinytag: [install] Java database...done. Size %d"
+ (buffer-size))
+ ;; perl syntax error in line NNNN
+ (when (ti::re-search-check " line [0-9]")
+ (error "Tinytag: Failed to call %s\n\ [Perl error] %s"
+ prg (buffer-string)))
+ (when (ti::buffer-empty-p)
+ (error "Tinytag: %s with %s didn't return anything."
+ prg doc-dir))
+ (write-region (point-min) (point-max) file)
+ (message "Tinytag: [install] Java database...done %s"
+ file))))))
+
+;;; ----------------------------------------------------------------------
+;;;
+;;;###autoload
+(defun tinytag-install-sample-database-java ()
+ "Install Java database from Sub JDK documentation."
+ (interactive)
+ (tinytag-initialize)
+ (let* ((java-info (progn
+ (message "TinyTag: Wait, checking java...")
+ (prog1 (ti::process-java-version)
+ (message "TinyTag: Wait, checking java...done."))))
+ (case-fold-search t))
+ (cond
+ ((not java-info)
+ (message
+ (concat
+ "Tinytag: [install] Skipped. No `java' binary found along PATH."
+ " Java sample database will not be installed.")))
+ (t
+ ;; path to `java' binary could be something like
+ ;; i:/java/sun/jdk1.3_02/bin/java
+ ;;
+ ;; The Java documentation si assumed to be under
+ ;; i:/java/sun/jdk1.3_02/docs/
+ ;;
+ (let* ((java (nth 2 java-info)) ;; path
+ (dir (file-name-directory java))
+ (root (and dir (ti::directory-up dir)))
+ (doc-dir (and root (concat (file-name-as-directory root)
+ "docs")))
+ (out-dir (file-name-as-directory tinytag-:database-dir))
+ (db (concat
+ out-dir
+ (nth 1 (assq 'func tinytag-:example-db-map-java)))))
+ (cond
+ ((and (stringp doc-dir)
+ (file-directory-p doc-dir))
+ (if (file-exists-p db)
+ (message
+ "Tinytag: [install] Skipped. Database already exists %s"
+ db)
+ (tinytag-install-sample-database-java-external-process
+ doc-dir db)))
+ (t
+ (message "Tinytag: [install] Can't find java docs/ dir [%s]"
+ doc-dir))))))))
+
+;;; ----------------------------------------------------------------------
+;;;
+;;;###autoload
+(defun tinytag-install-sample-database-c ()
+ "Install c/C++ database from file tintytag.el."
+ (interactive)
+ (tinytag-initialize)
+ (let* ((case-fold-search t)
+ (file (locate-library "tinytag.el"))
+ (dir (file-name-as-directory tinytag-:database-dir))
+ (db (concat
+ dir
+ (nth 1 (assq 'func tinytag-:example-db-map-c++))))
+ buffer)
+ (unless (stringp file)
+ (error "Tinytag: [install] cannot find tinytag.el along load-path."))
+ (setq buffer (ti::package-install-example "tinytag.el"))
+ (with-current-buffer buffer
+ (if (not (re-search-forward "Sample.*function database" nil t))
+ (error "Tinytag: [install] Cannot find start of example section.")
+ ;; Remove all before the database.
+ (beginning-of-line)
+ (delete-region (point-min) (point))
+ (cond
+ ((string-match "hpux" (emacs-version))
+ ;; GNU Emacs 19.28.1 (hppa1.1-hp-hpux9, X toolkit)
+ ;;
+ (re-search-forward "END HP-UX")
+ (forward-line 1)
+ (delete-region (point) (point-max)))
+ (t
+ ;; GNU Emacs 19.33.1 (i386-unknown-netbsd1.1, X toolkit)
+ ;;
+ (re-search-forward "# NetBSD Sample")
+ (beginning-of-line) (delete-region (point-min) (point))
+ (re-search-forward "# END NetBSD")
+ (forward-line 1)
+ (delete-region (point) (point-max))))
+
+ (if (file-exists-p db)
+ (message
+ "Tinytag: [install] Skipped. Database already exists %s" db)
+ (message "Tinytag: [install] C/C++ database...")
+ (write-region (point-min) (point-max) db)
+ (message
+ "Tinytag: [install] C/C++ database...installed %s" db))))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinytag-install-sample-databases ()
+ "Install Sample databases: C/C++ and Java.
+This function sets ´tinytag-install-sample-databases'
+property 'done to non-nil value, when called."
+ (tinytag-install-sample-database-c)
+ (tinytag-install-sample-database-java)
+ ;; This is signal for other setups, that can check if functon
+ ;; has already been called (not to install databases multiple times)
+ (put 'tinytag-install-sample-databases 'done t)
+ (ti::kill-buffer-safe "*ti::pkg*"))
+
+;;}}}
+
+;;{{{ code: misc
+
+;;; ----------------------------------------------------------------------
+;;;
+(defsubst tinytag-word-at-point ()
+ "Read word on current point."
+ (if (looking-at "[.a-z0-9_]+[ \t\n\r]*(") ;is here word ?
+ (ti::buffer-read-word "-_.A-Za-z0-9" )))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defsubst tinytag-display (list)
+ "Call display function with LIST."
+ (funcall tinytag-:display-function list))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinytag-display-function (list)
+ "Display car of LIST and count of LIST.
+Output matched to tinytag-:output-buffer too."
+ (when (stringp tinytag-:output-buffer)
+ (with-current-buffer (get-buffer-create tinytag-:output-buffer)
+ (erase-buffer)
+ (dolist (line list)
+ (insert line "\n"))))
+ (message
+ (format
+ "%s: %s" (length list) (car list))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinytag-filter-default-function (string)
+ "Default filter function. Reject STRING."
+ (let* ((fid "tinytag-filter-default-function: ")
+ (id (or (ti::id-info nil 'variable-lookup)
+ (symbol-name major-mode)))
+ (table tinytag-:filter-word-table)
+ (accept t)
+ (case-fold-search nil) ;Case is important here
+ elt)
+ (when (and (setq elt (ti::list-find table id))
+ (eval (nth 1 elt)))
+ (setq accept nil))
+ (tinytag-debug fid " ret accept" accept "elt" elt "\n")
+ accept))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinytag-word-default-adjust (string)
+ "Convert STRING to suitable regexp.
+Currently supports only C/C++ and Java."
+ (let ((fid "tinytag-word-default-adjust: ")
+ (id (or (ti::id-info nil 'variable-lookup)
+ (symbol-name major-mode)))
+ (ret string))
+ (cond
+ ((string-match "c[+]+\\|code-c\\|c-mode\\|cc-mode" id)
+ ;;
+ ;; We suppose database format
+ ;; "<include.h> function(definition...)"
+ ;;
+ ;; Notice the '*' which matches functions returning a pointer
+ ;; ring.h><strings.h> char *strcat(
+ ;;
+ (setq ret (format "[ \t*]%s[ \t]*(" string)))
+ ((string-match "java" id)
+ ;;
+ ;; We suppose database format
+ ;;
+ ;; java.lang.System.out void print(boolean b)
+ ;; java.lang.System.out void print(Object obj)
+ ;;
+ ;; --> System.out.*print\\>
+ ;;
+ ;; But there is a problem with variables
+ ;;
+ ;; Runtime rt = Runtime.getRuntime();
+ ;; long free = rt.freeMemory();
+ ;; *cursor here --> grabbed "rt.freeMemory"
+ ;;
+ ;; --> Search last word after dot too.
+ ;;
+ (let (class
+ function)
+ (tinytag-debug fid "java" (string-match "^(.*\\.)(.*)$" string)
+ ret "\n")
+ (cond
+ ((string-match "\\(.+\\)\\.\\(.*\\)$" string)
+ (setq class (match-string 1 string)
+ function (match-string 2 string)
+ ret (format "%s.*%s\\>"
+ (regexp-quote class)
+ (regexp-quote function)))
+ ;; If the name is "System.something", the assume that the first word
+ ;; is pure java Class.
+ ;;
+ ;; If the name is in lowercase, assume that it is variable and
+ ;; search for plain function name as well.
+ (unless (ti::string-match-case "^[A-Z]" class)
+ (setq ret (format "%s\\| %s(" ret function))))
+ ((not (string-match "\\." string))
+ (setq ret (format "\\<%s[ \t]*("
+ (regexp-quote string))))))))
+ (tinytag-debug fid "ret" ret "\n")
+ ret))
+
+;;}}}
+;;{{{ code: search engine
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinytag-search-db (re single-or-list)
+ "Search RE from databases in SINGLE-OR-LIST.
+
+References:
+
+ `tinytag-:database-map'
+ `tinytag-:database-dir'
+ `tinytag-:noerror'
+ `tinytag-:word-modify-hook'
+
+Return:
+
+ list '(line line ..) matched lines or nil."
+ (tinytag-initialize)
+ (let* ((fid "tinytag-search-db: ")
+ (table tinytag-:database-map)
+ (noerr tinytag-:noerror)
+ (dir (file-name-as-directory tinytag-:database-dir))
+ (list (ti::list-make single-or-list))
+ buffer
+ file
+ ret)
+ (tinytag-debug fid " input" re single-or-list "\n")
+ (dolist (elt list)
+ (when (setq elt (assq elt table))
+ (setq file (concat
+ (file-name-as-directory dir)
+ (nth 1 elt)))
+ (setq buffer (or (get-file-buffer file)
+ (and (file-exists-p file)
+ (find-file-noselect file))))
+ (tinytag-debug fid " buffer" buffer "file" file "\n")
+ ;; ......................................... search or no file ...
+ (cond
+ ((and
+ buffer
+ (setq re (run-hook-with-args-until-success
+ 'tinytag-:word-modify-hook re)))
+ (tinytag-debug fid " regexp" re "\n")
+ (with-current-buffer buffer
+ (ti::pmin)
+ (setq ret (ti::buffer-grep-lines re))))
+ ((null noerr)
+ (error "No database to search %s" file))))) ;; when-dolist
+ (tinytag-debug fid "RET" ret "\n")
+ ret))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinytag-do-search (string)
+ "Search those databases which match predefined regexp against STRING.
+
+References:
+ `tinytag-:regexp-to-databases'
+
+Return:
+ list '(db-matched-line ..) or nil"
+ (let* ((fid "tinytag-do-search: ")
+ (table tinytag-:regexp-to-databases)
+ e
+ db
+ re
+ ret)
+ (tinytag-debug fid "string" string "\n")
+ (when (run-hook-with-args-until-success
+ 'tinytag-:word-filter-hook string)
+ (dolist (elt table)
+ (setq re (car elt)
+ db (nth 1 elt))
+ (when (string-match re string)
+ (setq ret (tinytag-search-db string db))
+ (tinytag-debug fid " MATCH" "re" re "str" string "ret" ret"\n")
+ (return))))
+ ret))
+
+;;}}}
+;;{{{ code: try funcs
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinytag-try-function-show-cached-word (&optional noerr)
+ "Pick word at point and show info if word was same as previously looked.
+NOERR ignores errors."
+ (interactive)
+ (let* ((word (tinytag-word-at-point))
+ (prev-word (car-safe tinytag-:last-word-lookup))
+ (prev-info (cdr-safe tinytag-:last-word-lookup))
+ (err (or noerr tinytag-:noerror))
+ (fid "tinytag-try-function-show-cached-word: "))
+ (catch 'quit
+ (tinytag-debug fid
+ "word" word
+ "previous word" prev-word
+ "previous info" prev-info
+ "error flag" err
+ "\n")
+ (when (not (stringp word))
+ (if (null err)
+ (message "tinytag: No word at point."))
+ (throw 'quit t))
+
+ (when (and (not (null prev-word))
+ (not (null prev-info))
+ (string= word prev-word))
+ (tinytag-display prev-info)
+ (throw 'quit t)))))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinytag-try-function-search-db ()
+ "Do lookup, pick word at point and search databases.
+Show the matched word from database."
+ (interactive)
+ (let* ((fid "tinytag-try-function-search-db: ")
+ (word (tinytag-word-at-point))
+ info)
+ (tinytag-debug fid "word" word "\n")
+ (when (and (stringp word)
+ (run-hook-with-args-until-success 'tinytag-:set-database-hook)
+ (setq info (tinytag-do-search word)))
+ (setq tinytag-:last-word-lookup (cons word info))
+ (tinytag-display info)
+ t)))
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinytag-try-function-man ()
+ "Suggest man page search for current word."
+ (interactive)
+ (let* ((word (ti::buffer-read-word))
+ ;; only in 19.30
+;;; (syntax-elt (fexec 'c-guess-basic-syntax))
+;;; (syntax (car-safe syntax-elt))
+ ans)
+ (when
+ (and word ;; (memq syntax '(statement nil))
+ (y-or-n-p (concat "Run man on " word))
+ (not
+ (ti::nil-p
+ (setq ans (read-from-minibuffer "Man cmd: " word)))))
+ (man ans)
+ t)))
+
+;;}}}
+;;{{{ main
+
+;;; ----------------------------------------------------------------------
+;;;
+;;;###autoload
+(defun tinytag-main ()
+ "Run `tinytag-:try-hook' until some of the functions return non-nil."
+ (interactive)
+ (run-hook-with-args-until-success 'tinytag-:try-hook))
+
+;;; ----------------------------------------------------------------------
+;;;
+;;;###autoload
+(defun tinytag-main-mouse (&optional event)
+ "See `tinytag-main'. Function is called with mouse EVENT."
+ (interactive "e")
+ (tinytag-main))
+
+;;}}}
+;;{{{ code: example
+
+;;; ----------------------------------------------------------------------
+;;;
+(defun tinytag-post-command-1 ()
+ "Do lookup."
+ ;; ... ... ... ... ... ... ... ... ... ... ... ... ... do action . .
+ ;;
+ (when (and
+ (run-hook-with-args-until-success 'tinytag-:set-database-hook)
+ (run-hook-with-args-until-success 'tinytag-:post-command-try-hook))
+ ;; This is needed in 19.30<, so that the
+ ;; message doesn't get wiped away.
+ ;;
+ ;; (unless (fboundp 'post-command-idle-hook)
+ ;; (sleep-for 1))
+ ;;(discard-input)
+ nil))
+
+;;; ----------------------------------------------------------------------
+;;; - The functionality is copied from Noah's <friedman@prep.ai.mit.edu>
+;;; eldoc.el: eldoc-mode-print-current-symbol-info
+;;;
+;;;###autoload
+(defun tinytag-post-command ()
+ "Activates only if `tinytag-:set-database-hook' wakes up.
+Show the database definition for the current word under point.
+
+References:
+
+ `tinytag-:noerror'
+ `tinytag-:post-command-hook-wakeup'
+ `tinytag-:set-database-hook'"
+ (let* ((tinytag-:noerror t)
+ it-is-time)
+ (when (and (not (ti::compat-executing-macro))
+ ;; Having this mode operate in the minibuffer
+ ;; makes it impossible to
+ ;; see what you're doing.
+ (not (eq (selected-window) (minibuffer-window)))
+ (symbolp this-command)
+ (sit-for 0.50)
+ ;; Is this programming language supported?
+ (run-hook-with-args-until-success
+ 'tinytag-:set-database-hook))
+ ;; ... ... ... ... ... ... ... ... ... ... ... ... wakeup time? . .
+ ;; This is not used if we're in 19.34
+ ;;
+ (cond
+ ((fboundp 'run-with-idle-timer)
+ (setq it-is-time t))
+ (t
+ (if (null tinytag-:post-command-hook-counter)
+ (setq tinytag-:post-command-hook-counter 0))
+ ;; Don't wake up all the time.. saves Emacs processing time.
+ ;;
+ (setq
+ it-is-time
+ (or (eq 0 tinytag-:post-command-hook-wakeup)
+ (and (not (eq 0 tinytag-:post-command-hook-counter))
+ (eq 0 (% tinytag-:post-command-hook-counter
+ tinytag-:post-command-hook-wakeup)))))
+ (incf tinytag-:post-command-hook-counter)
+ (if it-is-time ;do reset
+ (setq tinytag-:post-command-hook-counter 0))))
+ ;; ... ... ... ... ... ... ... ... ... ... ... ... ... do action . .
+ ;;
+ (if it-is-time
+ (tinytag-post-command-1)))))
+
+;;; ----------------------------------------------------------------------
+;;; This is default function. Copy this and you _have_to_ write your own.
+;;;
+(defun tinytag-set-database ()
+ "Set correct database values according to buffer content.
+Return:
+ non-nil or nil was the database set according to buffer?"
+ (let* ((id (or (ti::id-info nil 'variable-lookup)
+ (symbol-name major-mode)))
+ ;; read last word, delete rest
+ ;;
+ (table tinytag-:database-setup-table)
+ elt
+ did-it)
+ (cond
+ ((and (setq elt (ti::list-find table id))
+ (setq elt (nth 1 elt))) ;Get second list
+ (setq tinytag-:database-map (eval (nth 0 elt))
+ tinytag-:regexp-to-databases (eval (nth 1 elt))
+ did-it (nth 0 elt)))
+ (t
+ ;; Disable search. We don't know database for this buffer
+ ;;
+ (setq tinytag-:database-map nil
+ tinytag-:regexp-to-databases nil)))
+
+ (if did-it
+ (run-hooks 'tinytag-:database-ok-hook))
+ did-it))
+
+;;}}}
+;;{{{ example: perl script for creating your own database
+
+;;; ..................................................... &example-c++ ...
+
+;;; Here sript which you can use to generate database lines from
+;;; manual page files. I would have included mine, but it uses my private
+;;; perl libs and it's much bigger than Peter's handy script.
+
+;;* #! /usr/local/perl5/bin/perl
+;;* #
+;;* # Peter Simons <simons@petium.rhein.de>
+;;* # (#) Script to make C++ function database for Emacs tinytag.el
+;;* _
+;;* foreach $filename (@ARGV) {
+;;* open(INFILE, $filename) || die("Can't open file $filename.");
+;;* @lines = <INFILE>;
+;;* chop(@lines);
+;;* $lines_num = @lines;
+;;* for ($isSynopsis = 0, $includes = "", $curr_line = "", $i = 0;
+;;* $i < $lines_num; $i++) {
+;;* $lines[$i] =~ s/.\b//g;
+;;* if ($lines[$i] =~ /^SYNOPSIS$/) {
+;;* $isSynopsis = 1;
+;;* next;
+;;* }
+;;* if ($lines[$i] =~ /^DESCRIPTION$/) {
+;;* $isSynopsis = 0;
+;;* $includes = "";
+;;* $curr_line = "";
+;;* last;
+;;* }
+;;* if ($isSynopsis == 1) {
+;;* if ($lines[$i] =~ /^ *#include/) {
+;;* $lines[$i] =~ s/^.*<(.*)>$/<$1>/;
+;;* $includes = $includes . $lines[$i];
+;;* }
+;;* elsif ($lines[$i] =~ /^$/) {
+;;* if ($curr_line ne "") {
+;;* $curr_line =~ s/ +/ /g;
+;;* if ($includes eq "") {
+;;* printf("<none>$curr_line\n");
+;;* }
+;;* else {
+;;* printf("$includes$curr_line\n");
+;;* }
+;;* $curr_line = "";
+;;* }
+;;* }
+;;* else {
+;;* $curr_line = $curr_line . $lines[$i];
+;;* }
+;;* }
+;;* }
+;;* }
+
+;; }}}
+;; {{{ example: HP-UX simple database
+
+;;; Rip code with with tinylib.el/ti::package-rip-magic
+;;; These databases are automatically intalled when call
+;;; M-x tinytag-install-sample-database-c
+
+;;* # HP-UX Sample C++ function database
+;;* #
+;;* # HP 10, The C/C++ function call definitions from man 3C and 2.
+;;* # Not guarrantees, that are calls are here.
+;;* #
+;;* _
+;;* <dirent.h> DIR *opendir(const char *dirname);
+;;* <dirent.h> int closedir(DIR *dirp);
+;;* <dirent.h> int readdir_r(DIR *dirp, struct dirent *result);
+;;* <dirent.h> long int telldir(DIR *dirp);
+;;* <dirent.h> struct dirent *readdir(DIR *dirp);
+;;* <dirent.h> void rewinddir(DIR *dirp);
+;;* <dirent.h> void seekdir(DIR *dirp, long int loc);
+;;* <regexp.h> extern char *loc1, *loc2, *locs;
+;;* <regexp.h> extern int circf, sed, nbra;
+;;* <regexp.h> int advance(const char *string, const char *expbuf);
+;;* <regexp.h> int step(const char *string, const char *expbuf);
+;;* <stdio.h> FILE *fdopen(int fildes, const char *type);
+;;* <stdio.h> FILE *fopen(const char *pathname, const char *type);
+;;* <stdio.h> FILE *freopen(const char *pathname, const char *type, FILE *stream);
+;;* <stdio.h> FILE *stream);
+;;* <stdio.h> int fclose(FILE *stream);
+;;* <stdio.h> int fclose_unlocked(FILE *stream);
+;;* <stdio.h> int feof(FILE *stream);
+;;* <stdio.h> int feof_unlocked(FILE *stream);
+;;* <stdio.h> int ferror(FILE *stream);
+;;* <stdio.h> int ferror_unlocked(FILE *stream);
+;;* <stdio.h> int fflush(FILE *stream);
+;;* <stdio.h> int fflush_unlocked(FILE *stream);
+;;* <stdio.h> int fscanf(FILE *stream, const char *format, /* [pointer,] */ ...);
+;;* <stdio.h> int fseek(FILE *stream, long int offset, int whence);
+;;* <stdio.h> int fseek_unlocked(FILE *stream, long int offset, int whence);
+;;* <stdio.h> int scanf(const char *format, /* [pointer,] */ ...);
+;;* <stdio.h> int sscanf(const char *s, const char *format, /* [pointer,] */ ...);
+;;* <stdio.h> long int ftell(FILE *stream);
+;;* <stdio.h> long int ftell_unlocked(FILE *stream);
+;;* <stdio.h> size_t fread(void *ptr, size_t size, size_t nitems, FILE *stream);
+;;* <stdio.h> size_t fwrite(const void *ptr, size_t size, size_t nitems, FILE *stream);
+;;* <stdio.h> void clearerr(FILE *stream);
+;;* <stdio.h> void clearerr_unlocked(FILE *stream);
+;;* <stdio.h> void rewind(FILE *stream);
+;;* <stdio.h> void rewind_unlocked(FILE *stream);
+;;* <stdlib.h> int system(const char *command);
+;;* <stdlib.h> void abort(void);
+;;* <string.h><strings.h> char *index(const char *s, int c);
+;;* <string.h><strings.h> char *rindex(const char *s, int c);
+;;* <string.h><strings.h> char *strcat(char *s1, const char *s2);
+;;* <string.h><strings.h> char *strchr(const char *s, int c);
+;;* <string.h><strings.h> char *strcpy(char *s1, const char *s2);
+;;* <string.h><strings.h> char *strdup(const char *s);
+;;* <string.h><strings.h> char *strncat(char *s1, const char *s2, size_t n);
+;;* <string.h><strings.h> char *strncpy(char *s1, const char *s2, size_t n);
+;;* <string.h><strings.h> char *strpbrk(const char *s1, const char *s2);
+;;* <string.h><strings.h> char *strrchr(const char *s, int c);
+;;* <string.h><strings.h> char *strrstr(const char *s1, const char *s2);
+;;* <string.h><strings.h> char *strstr(const char *s1, const char *s2);
+;;* <string.h><strings.h> char *strtok(char *s1, const char *s2);
+;;* <string.h><strings.h> char *strtok_r(char *s1, const char *s2, char **last);
+;;* <string.h><strings.h> int strcasecmp(const char *s1, const char *s2);
+;;* <string.h><strings.h> int strcmp(const char *s1, const char *s2);
+;;* <string.h><strings.h> int strcoll(const char *s1, const char *s2);
+;;* <string.h><strings.h> int strncasecmp(const char *s1, const char *s2, size_t n);
+;;* <string.h><strings.h> int strncmp(const char *s1, const char *s2, size_t n);
+;;* <string.h><strings.h> size_t strcspn(const char *s1, const char *s2);
+;;* <string.h><strings.h> size_t strlen(const char *s);
+;;* <string.h><strings.h> size_t strspn(const char *s1, const char *s2);
+;;* <string.h><strings.h> size_t strxfrm(char *s1, const char *s2, size_t n);
+;;* <time.h> char *asctime(const struct tm *timeptr);
+;;* <time.h> char *ctime(const time_t *timer);
+;;* <time.h> double difftime(time_t time1, time_t time0);
+;;* <time.h> extern char *tzname[2];
+;;* <time.h> extern int daylight;
+;;* <time.h> extern long timezone;
+;;* <time.h> int asctime_r(const struct tm *timeptr, char *buffer, int buflen);
+;;* <time.h> int ctime_r(const time_t *timer, char *buffer, int buflen);
+;;* <time.h> int gmtime_r(const time_t *timer, struct tm *result);
+;;* <time.h> int localtime_r(const time_t *timer, struct tm *result);
+;;* <time.h> struct tm *gmtime(const time_t *timer);
+;;* <time.h> struct tm *localtime(const time_t *timer);
+;;* <time.h> time_t mktime(struct tm *timeptr);
+;;* <time.h> void tzset(void);
+;;* <unistd.h> char *getcwd(char *buf, size_t size);
+;;* _
+;;* #
+;;* # HP 10 man 2 pages
+;;* #
+;;* <sys/stat.h> int stat(const char *path, struct stat *buf);
+;;* <sys/stat.h> int lstat(const char *path, struct stat *buf);
+;;* <sys/stat.h> int fstat(int fildes, struct stat *buf);
+;;* <stdlib.h><unistd.h> void exit(int status);
+;;* <stdlib.h><unistd.h> void _exit(int status);
+;;* <unistd.h> pid_t getpid(void);
+;;* <unistd.h> pid_t getpgrp(void);
+;;* <unistd.h> pid_t getppid(void);
+;;* <unistd.h> pid_t getpgrp2(pid_t pid);
+;;* <unistd.h> int link(const char *path1, const char *path2);
+;;* <time.h> time_t time(time_t *tloc);
+;;* <sys/socket.h> int send(int s, const void *msg, int len, int flags);
+;;* <sys/socket.h> int tolen);
+;;* <sys/socket.h> int sendmsg(int s, const struct msghdr msg[], int flags);
+;;* <unistd.h> extern char **environ;
+;;* <unistd.h> int execv(const char *path, char * const argv[]);
+;;* <unistd.h> int execve(const char *file, char * const argv[], char * const envp[]);
+;;* <unistd.h> int execvp(const char *file, char * const argv[]);
+;;* <unistd.h> unsigned int alarm(unsigned int sec);
+;;* <sys/times.h> clock_t times(struct tms *buffer);
+;;* <errno.h> extern int errno;
+;;* <sys/uio.h><unistd.h> ssize_t write(int fildes, const void *buf, size_t nbyte);
+;;* <sys/uio.h><unistd.h> );
+;;* <unistd.h> pid_t fork(void);
+;;* <unistd.h> int close(int fildes);
+;;* <unistd.h> int unlink(const char *path);
+;;* <unistd.h> extern char **environ;
+;;* <unistd.h> int execv(const char *path, char * const argv[]);
+;;* <unistd.h> int execve(const char *file, char * const argv[], char * const envp[]);
+;;* <unistd.h> int execvp(const char *file, char * const argv[]);
+;;* <time.h> int stime(const time_t *tp);
+;;* <ulimit.h> long ulimit(int cmd, ...);
+;;* <sys/wait.h> pid_t wait(int *stat_loc);
+;;* <sys/wait.h> pid_t waitpid(pid_t pid, int *stat_loc, int options);
+;;* <sys/wait.h> pid_t wait3(int *stat_loc, int options, int *reserved);
+;;* <time.h> int getitimer(int which, struct itimerval *value);
+;;* <unistd.h> int setuid(uid_t uid);
+;;* <unistd.h> int setgid(gid_t gid);
+;;* <unistd.h> int setresuid(uid_t ruid, uid_t euid, uid_t suid);
+;;* <unistd.h> int setresgid(gid_t rgid, gid_t egid, gid_t sgid);
+;;* <signal.h> int kill(pid_t pid, int sig);
+;;* <signal.h> int raise(int sig);
+;;* <signal.h> void (*signal(int sig, void (*action)(int)))(int);
+;;* int rmdir(const char *path);
+;;* <sys/wait.h> pid_t wait(int *stat_loc);
+;;* <sys/wait.h> pid_t waitpid(pid_t pid, int *stat_loc, int options);
+;;* <sys/wait.h> pid_t wait3(int *stat_loc, int options, int *reserved);
+;;* <unistd.h> int pause(void);
+;;* <symlink.h> int symlink(const char *name1, const char *name2);
+;;* <signal.h> int sigsuspend(const sigset_t *sigmask);
+;;* <sys/uio.h><unistd.h> size_t read(int fildes, void *buf, size_t nbyte);
+;;* <sys/uio.h><unistd.h> );
+;;* <unistd.h> extern char **environ;
+;;* <unistd.h> int execv(const char *path, char * const argv[]);
+;;* <unistd.h> int execve(const char *file, char * const argv[], char * const envp[]);
+;;* <unistd.h> int execvp(const char *file, char * const argv[]);
+;;* <unistd.h> int access(char *path, int amode);
+;;* <sys/stat.h> int mknod(const char *path, mode_t mode, dev_t dev);
+;;* <fcntl.h> int creat(const char *path, mode_t mode);
+;;* <sys/stat.h> int mkdir(const char *path, mode_t mode);
+;;* <sys/uio.h><unistd.h> size_t read(int fildes, void *buf, size_t nbyte);
+;;* <ustat.h> int ustat(dev_t dev, struct ustat *buf);
+;;* <sys/stat.h> int chmod(const char *path, mode_t mode);
+;;* <sys/stat.h> int fchmod(int fildes, mode_t mode)
+;;* _
+;;* # END HP-UX Sample C++ function database
+
+;; }}}
+;; {{{ example: NetBSD 1.2 database
+
+;;* # NetBSD Sample 1.2
+;;* # collected by Peter Simons <simons@rhein.de>
+;;* # Thu Oct 17 16:31:10 MET DST 1996
+;;* #
+;;* <assert.h> assert(expression)
+;;* <bitstring.h> bit_clear(bit_str name, int bit)
+;;* <bitstring.h> bit_decl(bit_str name, int nbits)
+;;* <bitstring.h> bit_ffc(bit_str name, int nbits, int *value)
+;;* <bitstring.h> bit_ffs(bit_str name, int nbits, int *value)
+;;* <bitstring.h> bit_nclear(bit_str name, int start, int stop)
+;;* <bitstring.h> bit_nset(bit_str name, int start, int stop)
+;;* <bitstring.h> bit_set(bit_str name, int bit)
+;;* <bitstring.h> bit_test(bit_str name, int bit)
+;;* <bitstring.h> bitstr_size(int nbits)
+;;* <bitstring.h> bitstr_t * bit_alloc(int nbits)
+;;* <ctype.h> int isalnum(int c)
+;;* <ctype.h> int isalpha(int c)
+;;* <ctype.h> int isascii(int c)
+;;* <ctype.h> int isblank(int c)
+;;* <ctype.h> int iscntrl(int c)
+;;* <ctype.h> int isdigit(int c)
+;;* <ctype.h> int isgraph(int c)
+;;* <ctype.h> int islower(int c)
+;;* <ctype.h> int isprint(int c)
+;;* <ctype.h> int ispunct(int c)
+;;* <ctype.h> int isspace(int c)
+;;* <ctype.h> int isupper(int c)
+;;* <ctype.h> int isxdigit(int c)
+;;* <ctype.h> int tolower(int c)
+;;* <ctype.h> int toupper(int c)
+;;* <dirent.h> int getdirentries(int fd, char *buf, int nbytes, long *basep)
+;;* <dlfcn.h> char * dlerror(void)
+;;* <dlfcn.h> int dlclose(void *handle)
+;;* <dlfcn.h> int dlctl(void *handle, int cmd, void *data)
+;;* <dlfcn.h> void * dlopen(char *path, int mode)
+;;* <dlfcn.h> void * dlsym(void *handle, char *symbol)
+;;* <err.h> void err(int eval, const char *fmt, ...)
+;;* <err.h> void errx(int eval, const char *fmt, ...)
+;;* <err.h> void verr(int eval, const char *fmt, va_list args)
+;;* <err.h> void verrx(int eval, const char *fmt, va_list args)
+;;* <err.h> void vwarn(const char *fmt, va_list args)
+;;* <err.h> void vwarnx(const char *fmt, va_list args)
+;;* <err.h> void warn(const char *fmt, ...)
+;;* <err.h> void warnx(const char *fmt, ...)
+;;* <fcntl.h> int fcntl(int fd, int cmd, int arg)
+;;* <fcntl.h> int open(const char *path, int flags, mode_t mode)
+;;* <fcntl.h><kvm.h> int kvm_close(kvm_t *kd)
+;;* <fcntl.h><kvm.h> kvm_t * kvm_open(const char *execfile, const char *corefile, char *swapfile, int flags, const char *errstr)
+;;* <fcntl.h><kvm.h> kvm_t * kvm_openfiles(const char *execfile, const char *corefile, char *swapfile, int flags, char *errbuf)
+;;* <fnmatch.h> int fnmatch(const char *pattern, const char *string, int flags)
+;;* <fstab.h> int setfsent(void)
+;;* <fstab.h> struct fstab * getfsent(void)
+;;* <fstab.h> struct fstab * getfsfile(const char *file)
+;;* <fstab.h> struct fstab * getfsspec(const char *spec)
+;;* <fstab.h> void endfsent(void)
+;;* <glob.h> int glob(const char *pattern, int flags, const int (*errfunc)(const char *, int), glob_t *pglob)
+;;* <glob.h> void globfree(glob_t *pglob)
+;;* <kvm.h> char * kvm_geterr(kvm_t *kd)
+;;* <kvm.h> ssize_t kvm_read(kvm_t *kd, u_long addr, void *buf, size_t nbytes)
+;;* <kvm.h> ssize_t kvm_write(kvm_t *kd, u_long addr, const void *buf, size_t nbytes)
+;;* <kvm.h><nlist.h> int kvm_nlist(kvm_t *kd, struct nlist *nl)
+;;* <kvm.h><sys/kinfo.h><sys/file.h> char * kvm_getfiles(kvm_t *kd, int op, int arg, int *cnt)
+;;* <kvm.h><sys/sysctl.h> char ** kvm_getargv(kvm_t *kd, const struct kinfo_proc *p, int nchr)
+;;* <kvm.h><sys/sysctl.h> char ** kvm_getenvv(kvm_t *kd, const struct kinfo_proc *p, int nchr)
+;;* <kvm.h><sys/sysctl.h> struct kinfo_proc * kvm_getprocs(kvm_t *kd, int op, int arg, int *cnt)
+;;* <limits.h><stdlib.h> int radixsort(u_char **base, int nmemb, u_char *table, u_int endbyte)
+;;* <limits.h><stdlib.h> int sradixsort(u_char **base, int nmemb, u_char *table, u_int endbyte)
+;;* <machine/sysarch.h> int sysarch(int number, char *args)
+;;* <math.h> double acos(double x)
+;;* <math.h> double acosh(double x)
+;;* <math.h> double asin(double x)
+;;* <math.h> double asinh(double x)
+;;* <math.h> double atan(double x)
+;;* <math.h> double atan2(double y, double x)
+;;* <math.h> double atanh(double x)
+;;* <math.h> double cabs(z)
+;;* <math.h> double cbrt(double x)
+;;* <math.h> double ceil(double x)
+;;* <math.h> double copysign(double x, double y)
+;;* <math.h> double cos(double x)
+;;* <math.h> double cosh(double x)
+;;* <math.h> double erf(double x)
+;;* <math.h> double erfc(double x)
+;;* <math.h> double exp(double x)
+;;* <math.h> double expm1(double x)
+;;* <math.h> double fabs(double x)
+;;* <math.h> double floor(double x)
+;;* <math.h> double fmod(double x, double y)
+;;* <math.h> double frexp(double value, int *exp)
+;;* <math.h> double hypot(double x, double y)
+;;* <math.h> double j0(double x)
+;;* <math.h> double j1(double x)
+;;* <math.h> double jn(int n, double x)
+;;* <math.h> double ldexp(double x, int exp)
+;;* <math.h> double lgamma(double x)
+;;* <math.h> double log(double x)
+;;* <math.h> double log10(double x)
+;;* <math.h> double log1p(double x)
+;;* <math.h> double logb(double x)
+;;* <math.h> double modf(double value, double *iptr)
+;;* <math.h> double nextafter(double x, double y)
+;;* <math.h> double pow(double x, double y)
+;;* <math.h> double remainder(double x, double y)
+;;* <math.h> double rint(double x)
+;;* <math.h> double scalb(double x, double n)
+;;* <math.h> double scalbn(double x, int n)
+;;* <math.h> double significand(double x)
+;;* <math.h> double sin(double x)
+;;* <math.h> double sinh(double x)
+;;* <math.h> double sqrt(double x)
+;;* <math.h> double tan(double x)
+;;* <math.h> double tanh(double x)
+;;* <math.h> double y0(double x)
+;;* <math.h> double y1(double x)
+;;* <math.h> double yn(int n, double x)
+;;* <math.h> erff(float x)
+;;* <math.h> extern int signgam;
+;;* <math.h> float acosf(float x)
+;;* <math.h> float acoshf(float x)
+;;* <math.h> float asinf(float x)
+;;* <math.h> float asinhf(float x)
+;;* <math.h> float atan2f(float y, float x)
+;;* <math.h> float atanf(float x)
+;;* <math.h> float atanhf(float x)
+;;* <math.h> float cbrtf(float x)
+;;* <math.h> float ceilf(float x)
+;;* <math.h> float copysignf(float x, float y)
+;;* <math.h> float cosf(float x)
+;;* <math.h> float coshf(float x)
+;;* <math.h> float erfcf(float x)
+;;* <math.h> float expf(float x)
+;;* <math.h> float expm1f(float x)
+;;* <math.h> float fabsf(float x)
+;;* <math.h> float floorf(float x)
+;;* <math.h> float fmodf(float x, float y)
+;;* <math.h> float hypotf(float x, float y)
+;;* <math.h> float j0f(float x)
+;;* <math.h> float j1f(float x)
+;;* <math.h> float jnf(int n, float x)
+;;* <math.h> float lgammaf(float x)
+;;* <math.h> float log10f(float x)
+;;* <math.h> float log1pf(float x)
+;;* <math.h> float logbf(float x)
+;;* <math.h> float logf(float x)
+;;* <math.h> float nextafterf(float x, float y)
+;;* <math.h> float powf(float x, float, y")
+;;* <math.h> float remainderf(float x, float y)
+;;* <math.h> float rintf(float x)
+;;* <math.h> float scalbf(float x, float n)
+;;* <math.h> float scalbnf(float x, int n)
+;;* <math.h> float significand(float x)
+;;* <math.h> float sinf(float x)
+;;* <math.h> float sinhf(float x)
+;;* <math.h> float sqrtf(float x)
+;;* <math.h> float tanf(float x)
+;;* <math.h> float tanhf(float x)
+;;* <math.h> float y0f(float x)
+;;* <math.h> float y1f(float x)
+;;* <math.h> float ynf(int n, float x)
+;;* <math.h> int finite(double x)
+;;* <math.h> int finitef(float x)
+;;* <math.h> int ilogb(double x)
+;;* <math.h> int ilogbf(float x)
+;;* <netdb.h> char * hstrerror(int err)
+;;* <netdb.h> endnetent()
+;;* <netdb.h> endprotoent()
+;;* <netdb.h> setnetent(int stayopen)
+;;* <netdb.h> setprotoent(int stayopen)
+;;* <netdb.h> struct hostent * gethostbyaddr(const char *addr, int len, int type)
+;;* <netdb.h> struct hostent * gethostbyname(const char *name)
+;;* <netdb.h> struct hostent * gethostent(void)
+;;* <netdb.h> struct netent * getnetbyaddr(long net, int type)
+;;* <netdb.h> struct netent * getnetbyname(char *name)
+;;* <netdb.h> struct netent * getnetent()
+;;* <netdb.h> struct protoent * getprotobyname(char *name)
+;;* <netdb.h> struct protoent * getprotobynumber(int proto)
+;;* <netdb.h> struct protoent * getprotoent()
+;;* <netdb.h> struct rpcent * getrpcbyname(char *name)
+;;* <netdb.h> struct rpcent * getrpcbynumber(int number)
+;;* <netdb.h> struct rpcent * getrpcent(void)
+;;* <netdb.h> struct servent * getservbyname(char *name, char *proto)
+;;* <netdb.h> struct servent * getservbyport(int port, proto)
+;;* <netdb.h> struct servent * getservent()
+;;* <netdb.h> void endhostent(void)
+;;* <netdb.h> void endrpcent(void)
+;;* <netdb.h> void endservent(void)
+;;* <netdb.h> void herror(char *string)
+;;* <netdb.h> void sethostent(int stayopen)
+;;* <netdb.h> void setrpcent(int stayopen)
+;;* <netdb.h> void setservent(int stayopen)
+;;* <netinet/if_ether.h> char * ether_ntoa(struct ether_addr *e)
+;;* <netinet/if_ether.h> ether_hostton(char *hostname, struct ether_addr *e)
+;;* <netinet/if_ether.h> ether_line(char *l, struct ether_addr *e, char *hostname)
+;;* <netinet/if_ether.h> ether_ntohost(char *hostname, struct ether_addr *e)
+;;* <netinet/if_ether.h> struct ether_addr * ether_aton(char *s)
+;;* <nl_types.h> char * catgets(nl_catd catd, int set_id, int msg_id, char *s)
+;;* <nl_types.h> int catclose(nl_catd catd)
+;;* <nl_types.h> nl_catd catopen(const char *name, int oflag)
+;;* <nl_types.h><langinfo.h> char * nl_langinfo(nl_item item)
+;;* <nlist.h> int nlist(const char *filename, struct nlist *nl)
+;;* <none> char * getusershell(void)
+;;* <none> char * lfind(const void *key, const void *base, size_t *nelp, size_t width, int (*compar)(void *, void *))
+;;* <none> char * lsearch(const void *key, const void *base, size_t *nelp, size_t width, int (*compar)(void *, void *))
+;;* <none> char * tgetstr(char *id, char **area)
+;;* <none> char * tgoto(char *cm, destcol, destline)
+;;* <none> char * timezone(int zone, int dst)
+;;* <none> char *crypt(const char *key, const char *setting)
+;;* <none> getloadavg(double loadavg[], int nelem)
+;;* <none> getpw(uid, char *buf)
+;;* <none> group_from_gid(gid_t gid, int nogroup)
+;;* <none> int des_cipher(const char *in, char *out, long salt, int count)
+;;* <none> int des_setkey(const char *key)
+;;* <none> int encrypt(char *block, int flag)
+;;* <none> int getnetgrent(char **host, char **user, char **domain)
+;;* <none> int getrpcport(char *host, int prognum, int versnum, int proto)
+;;* <none> int innetgr(const char *netgroup, const char *host, const char *user, )
+;;* <none> int isinf(double)
+;;* <none> int isnan(double)
+;;* <none> int profil(char *samples, size_t size, u_long offset, u_int scale)
+;;* <none> int rexec(ahost, int inport, char *user, char *passwd, char *cmd, int *fd2p)
+;;* <none> int setkey(const char *key)
+;;* <none> mode_t getmode(const void *set, mode_t mode)
+;;* <none> moncontrol(int mode)
+;;* <none> monstartup(u_long *lowpc, u_long *highpc)
+;;* <none> nice(int incr)
+;;* <none> tgetent(char *bp, char *name)
+;;* <none> tgetflag(char *id)
+;;* <none> tgetnum(char *id)
+;;* <none> user_from_uid(uid_t uid, int nouser)
+;;* <none> void * setmode(const char *mode_str)
+;;* <none> void * shutdownhook_establish(void (*fn)(void *), void *arg)
+;;* <none> void doshutdownhooks(void)
+;;* <none> void endnetgrent(void)
+;;* <none> void endusershell(void)
+;;* <none> void inittodr(time_t base)
+;;* <none> void resettodr(void)
+;;* <none> void setnetgrent(const char *netgroup)
+;;* <none> void setusershell(void)
+;;* <none> void shutdownhook_disestablish(void *cookie)
+;;* <none> void tputs(register char *cp, int affcnt, int (*outc)())
+;;* <none> void tzset()
+;;* <pwd.h><unistd.h> char * getpass(const char *prompt)
+;;* <regexp.h> int regexec(const regexp *prog, const char *string)
+;;* <regexp.h> regexp * regcomp(const char *exp)
+;;* <regexp.h> void regsub(const regexp *prog, const char *source, char *dest)
+;;* <search.h> struct qelem { struct qelem *q_forw; struct qelem *q_back; char q_data[]; }; void insque(struct qelem *elem, struct qelem *pred)
+;;* <search.h> void remque(struct qelem *elem)
+;;* <setjmp.h> int _setjmp(jmp_buf env)
+;;* <setjmp.h> int setjmp(jmp_buf env)
+;;* <setjmp.h> int sigsetjmp(sigjmp_buf env, int savemask)
+;;* <setjmp.h> void _longjmp(jmp_buf env, int val)
+;;* <setjmp.h> void longjmp(jmp_buf env, int val)
+;;* <setjmp.h> void longjmperror(void)
+;;* <setjmp.h> void siglongjmp(sigjmp_buf env, int val)
+;;* <sgtty.h> gtty(int fd, struct sgttyb *buf)
+;;* <sgtty.h> stty(int fd, struct sgttyb *buf)
+;;* <signal.h> int kill(pid_t pid, int sig)
+;;* <signal.h> int killpg(pid_t pgrp, int sig)
+;;* <signal.h> int raise(int sig)
+;;* <signal.h> int sigaction(int sig, const struct sigaction *act, struct sigaction *oact)
+;;* <signal.h> int sigaddset(sigset_t *set, int signo)
+;;* <signal.h> int sigblock(int mask)
+;;* <signal.h> int sigdelset(sigset_t *set, int signo)
+;;* <signal.h> int sigemptyset(sigset_t *set)
+;;* <signal.h> int sigfillset(sigset_t *set)
+;;* <signal.h> int siginterrupt(int sig, int flag)
+;;* <signal.h> int sigismember(sigset_t *set, int signo)
+;;* <signal.h> int sigmask(signum)
+;;* <signal.h> int sigpause(int sigmask)
+;;* <signal.h> int sigpending(sigset_t *set)
+;;* <signal.h> int sigprocmask(int how, const sigset_t *set, sigset_t *oset)
+;;* <signal.h> int sigreturn(struct sigcontext *scp)
+;;* <signal.h> int sigsetmask(int mask)
+;;* <signal.h> int sigsuspend(const sigset_t *sigmask)
+;;* <signal.h> sigmask(signum)
+;;* <signal.h> sigvec(int sig, struct sigvec *vec, struct sigvec *ovec)
+;;* <signal.h> struct sigaction { void (*sa_handler)(); sigset_t sa_mask; int sa_flags; };
+;;* <signal.h> struct sigcontext { int sc_onstack; int sc_mask; int sc_sp; int sc_fp; int sc_ap; int sc_pc; int sc_ps; };
+;;* <signal.h> struct sigvec { void (*sv_handler)(); sigset_t sv_mask; int sv_flags; };
+;;* <signal.h> void (*signal(int sig, void (*func)()))()
+;;* <stdarg.h> type va_arg(va_list ap, type)
+;;* <stdarg.h> void va_end(va_list ap)
+;;* <stdarg.h> void va_start(va_list ap, last)
+;;* <stdio.h> FILE * fdopen(int fildes, char *mode)
+;;* <stdio.h> FILE * fopen(char *path, char *mode)
+;;* <stdio.h> FILE * freopen(char *path, char *mode, FILE *stream)
+;;* <stdio.h> FILE * fropen(void *cookie, int (*readfn)(void *, char *, int))
+;;* <stdio.h> FILE * funopen(void *cookie, int (*readfn)(void *, char *, int), int (*writefn)(void *, const char *, int), fpos_t (*seekfn)(void *, fpos_t, int), int (*closefn)(void *))
+;;* <stdio.h> FILE * fwopen(void *cookie, int (*writefn)(void *, char *, int))
+;;* <stdio.h> FILE * popen(const char *command, const char *type)
+;;* <stdio.h> FILE * tmpfile(void)
+;;* <stdio.h> FILE *stdin; FILE *stdout; FILE *stderr;
+;;* <stdio.h> char * ctermid(char *buf)
+;;* <stdio.h> char * cuserid(char *buf)
+;;* <stdio.h> char * fgetln(FILE *stream, size_t *len)
+;;* <stdio.h> char * fgets(char *str, size_t size, FILE *stream)
+;;* <stdio.h> char * gets(char *str)
+;;* <stdio.h> char * tempnam(const char *tmpdir, const char *prefix)
+;;* <stdio.h> char * tmpnam(char *str)
+;;* <stdio.h> int fclose(FILE *stream)
+;;* <stdio.h> int feof(FILE *stream)
+;;* <stdio.h> int ferror(FILE *stream)
+;;* <stdio.h> int fflush(FILE *stream)
+;;* <stdio.h> int fgetc(FILE *stream)
+;;* <stdio.h> int fgetpos(FILE *stream, fpos_t *pos)
+;;* <stdio.h> int fileno(FILE *stream)
+;;* <stdio.h> int fprintf(FILE *stream, const char *format, ...)
+;;* <stdio.h> int fpurge(FILE *stream)
+;;* <stdio.h> int fputc(int c, FILE *stream)
+;;* <stdio.h> int fputs(const char *str, FILE *stream)
+;;* <stdio.h> int fscanf(FILE *stream, const char *format, ...)
+;;* <stdio.h> int fseek(FILE *stream, long offset, int whence)
+;;* <stdio.h> int fsetpos(FILE *stream, fpos_t *pos)
+;;* <stdio.h> int getc(FILE *stream)
+;;* <stdio.h> int getchar()
+;;* <stdio.h> int getsubopt(char **optionp, char * const *tokens, char **valuep)
+;;* <stdio.h> int getw(FILE *stream)
+;;* <stdio.h> int pclose(FILE *stream)
+;;* <stdio.h> int printf(const char *format, ...)
+;;* <stdio.h> int putc(int c, FILE *stream)
+;;* <stdio.h> int putchar(int c)
+;;* <stdio.h> int puts(const char *str)
+;;* <stdio.h> int putw(int w, FILE *stream)
+;;* <stdio.h> int remove(const char *path)
+;;* <stdio.h> int rename(const char *from, const char *to)
+;;* <stdio.h> int scanf(const char *format, ...)
+;;* <stdio.h> int setlinebuf(FILE *stream)
+;;* <stdio.h> int setvbuf(FILE *stream, char *buf, int mode, size_t size)
+;;* <stdio.h> int snprintf(char *str, size_t size, const char *format, ...)
+;;* <stdio.h> int sprintf(char *str, const char *format, ...)
+;;* <stdio.h> int sscanf(const char *str, const char *format, ...)
+;;* <stdio.h> int ungetc(int c, FILE *stream)
+;;* <stdio.h> long ftell(FILE *stream)
+;;* <stdio.h> size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream)
+;;* <stdio.h> size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream)
+;;* <stdio.h> void clearerr(FILE *stream)
+;;* <stdio.h> void perror(const char *string)
+;;* <stdio.h> void rewind(FILE *stream)
+;;* <stdio.h> void setbuf(FILE *stream, char *buf)
+;;* <stdio.h> void setbuffer(FILE *stream, char *buf, size_t size)
+;;* <stdio.h><stdarg.h> int vfprintf(FILE *stream, const char *format, va_list ap)
+;;* <stdio.h><stdarg.h> int vfscanf(FILE *stream, const char *format, va_list ap)
+;;* <stdio.h><stdarg.h> int vprintf(const char *format, va_list ap)
+;;* <stdio.h><stdarg.h> int vscanf(const char *format, va_list ap)
+;;* <stdio.h><stdarg.h> int vsnprintf(char *str, size_t size, const char *format, va_list ap)
+;;* <stdio.h><stdarg.h> int vsprintf(char *str, char *format, va_list ap)
+;;* <stdio.h><stdarg.h> int vsscanf(const char *str, const char *format, va_list ap)
+;;* <stdlib.h> char * cgetcap(char *buf, char *cap, char type)
+;;* <stdlib.h> char * devname(dev_t dev, mode_t type)
+;;* <stdlib.h> char * getbsize(int *headerlenp, long *blocksizep)
+;;* <stdlib.h> char * getenv(const char *name)
+;;* <stdlib.h> char * initstate(unsigned seed, char *state, int n)
+;;* <stdlib.h> char * setstate(char *state)
+;;* <stdlib.h> daemon(int nochdir, int noclose)
+;;* <stdlib.h> div_t div(int num, int denom)
+;;* <stdlib.h> double atof(const char *nptr)
+;;* <stdlib.h> double drand48(void)
+;;* <stdlib.h> double erand48(unsigned short xseed[3])
+;;* <stdlib.h> double strtod(const char *nptr, char **endptr)
+;;* <stdlib.h> int abs(int j)
+;;* <stdlib.h> int atexit(void (*function)(void))
+;;* <stdlib.h> int atoi(const char *nptr)
+;;* <stdlib.h> int cgetclose(void)
+;;* <stdlib.h> int cgetent(char **buf, char **db_array, char *name)
+;;* <stdlib.h> int cgetfirst(char **buf, char **db_array)
+;;* <stdlib.h> int cgetmatch(char *buf, char *name)
+;;* <stdlib.h> int cgetnext(char **buf, char **db_array)
+;;* <stdlib.h> int cgetnum(char *buf, char *cap, long *num)
+;;* <stdlib.h> int cgetset(char *ent)
+;;* <stdlib.h> int cgetstr(char *buf, char *cap, char **str)
+;;* <stdlib.h> int cgetustr(char *buf, char *cap, char **str)
+;;* <stdlib.h> int heapsort(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *))
+;;* <stdlib.h> int mergesort(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *))
+;;* <stdlib.h> int putenv(const char *string)
+;;* <stdlib.h> int rand(void)
+;;* <stdlib.h> int setenv(const char *name, const char *value, int overwrite)
+;;* <stdlib.h> int system(const char *string)
+;;* <stdlib.h> ldiv_t ldiv(long num, long denom)
+;;* <stdlib.h> long atol(const char *nptr)
+;;* <stdlib.h> long jrand48(unsigned short xseed[3])
+;;* <stdlib.h> long labs(long j)
+;;* <stdlib.h> long lrand48(void)
+;;* <stdlib.h> long mrand48(void)
+;;* <stdlib.h> long nrand48(unsigned short xseed[3])
+;;* <stdlib.h> long random(void)
+;;* <stdlib.h> qdiv_t qdiv(quad_t num, quad_t denom)
+;;* <stdlib.h> quad_t qabs(quad_t j)
+;;* <stdlib.h> unsigned short * seed48(unsigned short xseed[3])
+;;* <stdlib.h> void * alloca(size_t size)
+;;* <stdlib.h> void * bsearch(const void *key, const void *base, size_t nmemb, size_t size, int (*compar) (const void *, const void *))
+;;* <stdlib.h> void * calloc(size_t nelem, size_t elsize)
+;;* <stdlib.h> void * calloc(size_t nmemb, size_t size)
+;;* <stdlib.h> void * malloc(size_t size)
+;;* <stdlib.h> void * realloc(void *ptr, size_t size)
+;;* <stdlib.h> void abort(void)
+;;* <stdlib.h> void exit(int status)
+;;* <stdlib.h> void free(void *ptr)
+;;* <stdlib.h> void lcong48(unsigned short p[7])
+;;* <stdlib.h> void qsort(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *))
+;;* <stdlib.h> void setproctitle(const char *fmt, ...)
+;;* <stdlib.h> void srand(unsigned seed)
+;;* <stdlib.h> void srand48(long seed)
+;;* <stdlib.h> void srandom(unsigned seed)
+;;* <stdlib.h> void unsetenv(const char *name)
+;;* <stdlib.h><limits.h> long strtol(const char *nptr, char **endptr, int base)
+;;* <stdlib.h><limits.h> unsigned long strtoul(const char *nptr, char **endptr, int base)
+;;* <stdlib.h><limits.h><sys/types.h><stdlib.h><limits.h> quad_t strtoq(const char *nptr, char **endptr, int base)
+;;* <stdlib.h><limits.h><sys/types.h><stdlib.h><limits.h> u_quad_t strtouq(const char *nptr, char **endptr, int base)
+;;* <string.h> char * index(const char *s, int c)
+;;* <string.h> char * rindex(const char *s, int c)
+;;* <string.h> char * strcat(char *s, const char * append)
+;;* <string.h> char * strcat(char *s, const char *append)
+;;* <string.h> char * strchr(const char *s, int c)
+;;* <string.h> char * strcpy(char *dst, const char *src)
+;;* <string.h> char * strdup(const char *str)
+;;* <string.h> char * strerror(int errno)
+;;* <string.h> char * strerror(int errnum)
+;;* <string.h> char * strncat(char *s, const char *append, size_t count)
+;;* <string.h> char * strncpy(char *dst, const char *src, size_t count)
+;;* <string.h> char * strncpy(char *dst, const char *src, size_t len)
+;;* <string.h> char * strpbrk(const char *s, const char *charset)
+;;* <string.h> char * strrchr(const char *s, int c)
+;;* <string.h> char * strsep(char **stringp, char *delim)
+;;* <string.h> char * strsep(char **stringp, const char *delim)
+;;* <string.h> char * strsignal(int sig)
+;;* <string.h> char * strstr(const char *big, const char *little)
+;;* <string.h> char * strtok(char *s, const char *delim)
+;;* <string.h> char * strtok(char *str, const char *sep)
+;;* <string.h> int bcmp(const void *b1, const void *b2, size_t len)
+;;* <string.h> int ffs(int value)
+;;* <string.h> int memcmp(const void *b1, const void *b2, size_t len)
+;;* <string.h> int strcasecmp(const char *s1, const char *s2)
+;;* <string.h> int strcmp(const char *s1, const char *s2)
+;;* <string.h> int strcoll(const char *s1, const char *s2)
+;;* <string.h> int strncasecmp(const char *s1, const char *s2, size_t count)
+;;* <string.h> int strncasecmp(const char *s1, const char *s2, size_t len)
+;;* <string.h> int strncmp(const char *s1, const char *s2, size_t count)
+;;* <string.h> int strncmp(const char *s1, const char *s2, size_t len)
+;;* <string.h> size_t strcspn(const char *s, const char *charset)
+;;* <string.h> size_t strlen(const char *s)
+;;* <string.h> size_t strspn(const char *s, const char *charset)
+;;* <string.h> size_t strxfrm(char *dst, const char *src, size_t n)
+;;* <string.h> void * memccpy(void *dst, const void *src, int c, size_t len)
+;;* <string.h> void * memchr(const void *b, int c, size_t len)
+;;* <string.h> void * memcpy(void *dst, const void *src, size_t len)
+;;* <string.h> void * memmove(void *dst, const void *src, size_t len)
+;;* <string.h> void * memset(void *b, int c, size_t len)
+;;* <string.h> void bcopy(const void *src, void *dst, size_t len)
+;;* <string.h> void bzero(void *b, size_t len)
+;;* <string.h> void strmode(mode_t mode, char *bp)
+;;* <string.h> void swab(const void *src, void *dst, size_t len)
+;;* <sys/disklabel.h> struct disklabel * getdiskbyname(const char *name)
+;;* <sys/file.h> int flock(int fd, int operation)
+;;* <sys/ioctl.h> int ioctl(int d, unsigned long request, char *argp)
+;;* <sys/param.h> u_long htonl(u_long hostlong)
+;;* <sys/param.h> u_long ntohl(u_long netlong)
+;;* <sys/param.h> u_short htons(u_short hostshort)
+;;* <sys/param.h> u_short ntohs(u_short netshort)
+;;* <sys/param.h><stdlib.h> char * realpath(const char *pathname, char resolvedname[MAXPATHLEN])
+;;* <sys/param.h><sys/mount.h> int fstatfs(int fd, struct statfs *buf)
+;;* <sys/param.h><sys/mount.h> int mount(const char *type, const char *dir, int flags, void *data)
+;;* <sys/param.h><sys/mount.h> int statfs(const char *path, struct statfs *buf)
+;;* <sys/param.h><sys/mount.h> int unmount(const char *dir, int flags)
+;;* <sys/param.h><sys/sysctl.h> int sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp, size_t newlen)
+;;* <sys/param.h><sys/types.h><unistd.h> int getgroups(int gidsetlen, gid_t *gidset)
+;;* <sys/param.h><sys/ucred.h><sys/mount.h> int getfsstat(struct statfs *buf, long bufsize, int flags)
+;;* <sys/param.h><sys/ucred.h><sys/mount.h> int getmntinfo(struct statfs **mntbufp, int flags)
+;;* <sys/param.h><unistd.h> int setgroups(int ngroups, const gid_t *gidset)
+;;* <sys/queue.h> CIRCLEQ_ENTRY(TYPE)
+;;* <sys/queue.h> CIRCLEQ_HEAD(HEADNAME, TYPE)
+;;* <sys/queue.h> CIRCLEQ_INIT(CIRCLEQ_HEAD *head)
+;;* <sys/queue.h> CIRCLEQ_INSERT_AFTER(CIRCLEQ_HEAD *head, TYPE *listelm, TYPE *elm, CIRCLEQ_ENTRY NAME)
+;;* <sys/queue.h> CIRCLEQ_INSERT_BEFORE(CIRCLEQ_HEAD *head, TYPE *listelm, TYPE *elm, CIRCLEQ_ENTRY NAME)
+;;* <sys/queue.h> CIRCLEQ_INSERT_HEAD(CIRCLEQ_HEAD *head, TYPE *elm, CIRCLEQ_ENTRY NAME)
+;;* <sys/queue.h> CIRCLEQ_INSERT_TAIL(CIRCLEQ_HEAD *head, TYPE *elm, CIRCLEQ_ENTRY NAME)
+;;* <sys/queue.h> CIRCLEQ_REMOVE(CIRCLEQ_HEAD *head, TYPE *elm, CIRCLEQ_ENTRY NAME)
+;;* <sys/queue.h> LIST_ENTRY(TYPE)
+;;* <sys/queue.h> LIST_HEAD(HEADNAME, TYPE)
+;;* <sys/queue.h> LIST_INIT(LIST_HEAD *head)
+;;* <sys/queue.h> LIST_INSERT_AFTER(TYPE *listelm, TYPE *elm, LIST_ENTRY NAME)
+;;* <sys/queue.h> LIST_INSERT_BEFORE(TYPE *listelm, TYPE *elm, LIST_ENTRY NAME)
+;;* <sys/queue.h> LIST_INSERT_HEAD(LIST_HEAD *head, TYPE *elm, LIST_ENTRY NAME)
+;;* <sys/queue.h> LIST_REMOVE(TYPE *elm, LIST_ENTRY NAME)
+;;* <sys/queue.h> TAILQ_ENTRY(TYPE)
+;;* <sys/queue.h> TAILQ_HEAD(HEADNAME, TYPE)
+;;* <sys/queue.h> TAILQ_INIT(TAILQ_HEAD *head)
+;;* <sys/queue.h> TAILQ_INSERT_AFTER(TAILQ_HEAD *head, TYPE *listelm, TYPE *elm, TAILQ_ENTRY NAME)
+;;* <sys/queue.h> TAILQ_INSERT_BEFORE(TYPE *listelm, TYPE *elm, TAILQ_ENTRY NAME)
+;;* <sys/queue.h> TAILQ_INSERT_HEAD(TAILQ_HEAD *head, TYPE *elm, TAILQ_ENTRY NAME)
+;;* <sys/queue.h> TAILQ_INSERT_TAIL(TAILQ_HEAD *head, TYPE *elm, TAILQ_ENTRY NAME)
+;;* <sys/queue.h> TAILQ_REMOVE(TAILQ_HEAD *head, TYPE *elm, TAILQ_ENTRY NAME)
+;;* <sys/reboot.h> void boot(int howto)
+;;* <sys/resource.h><kvm.h> int kvm_getloadavg(kvm_t *kd, double loadavg[], int nelem)
+;;* <sys/signal.h> extern char *sys_siglist[]; extern char *sys_signame[];
+;;* <sys/signal.h> void psignal(unsigned sig, const char *s)
+;;* <sys/socket.h> int getpeername(int s, struct sockaddr *name, int *namelen)
+;;* <sys/socket.h> int getsockname(int s, struct sockaddr *name, int *namelen)
+;;* <sys/socket.h> int listen(int s, int backlog)
+;;* <sys/socket.h> int shutdown(int s, int how)
+;;* <sys/socket.h><netinet/in.h><arpa/inet.h> char * inet_ntoa(struct in_addr in)
+;;* <sys/socket.h><netinet/in.h><arpa/inet.h> int inet_aton(const char *cp, struct in_addr *pin)
+;;* <sys/socket.h><netinet/in.h><arpa/inet.h> struct in_addr inet_makeaddr(int net, int lna)
+;;* <sys/socket.h><netinet/in.h><arpa/inet.h> unsigned long inet_addr(const char *cp)
+;;* <sys/socket.h><netinet/in.h><arpa/inet.h> unsigned long inet_lnaof(struct in_addr in)
+;;* <sys/socket.h><netinet/in.h><arpa/inet.h> unsigned long inet_netof(struct in_addr in)
+;;* <sys/socket.h><netinet/in.h><arpa/inet.h> unsigned long inet_network(const char *cp)
+;;* <sys/stat.h><unistd.h> int chflags(const char *path, u_long flags)
+;;* <sys/stat.h><unistd.h> int fchflags(int fd, u_long flags)
+;;* <sys/syscall.h><unistd.h> int __syscall(quad_t number, ...)
+;;* <sys/syscall.h><unistd.h> int syscall(int number, ...)
+;;* <sys/time.h> int adjtime(const struct timeval *delta, struct timeval *olddelta)
+;;* <sys/time.h> int futimes(int fd, const struct timeval *times)
+;;* <sys/time.h> int getitimer(int which, struct itimerval *value)
+;;* <sys/time.h> int gettimeofday(struct timeval *tp, struct timezone *tzp)
+;;* <sys/time.h> int setitimer(int which, const struct itimerval *value, struct itimerval *ovalue)
+;;* <sys/time.h> int settimeofday(const struct timeval *tp, const struct timezone *tzp)
+;;* <sys/time.h> int utimes(const char *file, const struct timeval *times)
+;;* <sys/time.h><sys/resource.h> int getpriority(int which, int who)
+;;* <sys/time.h><sys/resource.h> int getrusage(int who, struct rusage *rusage)
+;;* <sys/time.h><sys/resource.h> int setpriority(int which, int who, int prio)
+;;* <sys/times.h> clock_t times(struct tms *tp)
+;;* <sys/types.h> char * sbrk(int incr)
+;;* <sys/types.h> char *ctime(clock) const time_t *clock;
+;;* <sys/types.h> double difftime(time1, time0) time_t time1; time_t time0;
+;;* <sys/types.h> int bindresvport(int sd, struct sockaddr_in **sin)
+;;* <sys/types.h> int brk(const char *addr)
+;;* <sys/types.h> int setrgid(gid_t gid)
+;;* <sys/types.h> int setruid(uid_t uid)
+;;* <sys/types.h><bm.h> bm_pat * bm_comp(u_char *pattern, size_t patlen, u_char freq[256]);
+;;* <sys/types.h><bm.h> u_char * bm_exec(bm_pat *pdesc, u_char *text, size_t len);
+;;* <sys/types.h><bm.h> void bm_free(bm_pat *pdesc);
+;;* <sys/types.h><dirent.h> DIR * opendir(const char *filename)
+;;* <sys/types.h><dirent.h> int alphasort(const void *d1, const void *d2)
+;;* <sys/types.h><dirent.h> int closedir(DIR *dirp)
+;;* <sys/types.h><dirent.h> int dirfd(DIR *dirp)
+;;* <sys/types.h><dirent.h> int scandir(const char *dirname, struct dirent ***namelist, int (*select)(struct dirent *), int (*compar)(const void *, const void *))
+;;* <sys/types.h><dirent.h> long telldir(const DIR *dirp)
+;;* <sys/types.h><dirent.h> struct dirent * readdir(DIR *dirp)
+;;* <sys/types.h><dirent.h> void rewinddir(DIR *dirp)
+;;* <sys/types.h><dirent.h> void seekdir(DIR *dirp, long loc)
+;;* <sys/types.h><grp.h> int setgroupent(int stayopen)
+;;* <sys/types.h><grp.h> struct group * getgrent(void)
+;;* <sys/types.h><grp.h> struct group * getgrgid(gid_t gid)
+;;* <sys/types.h><grp.h> struct group * getgrnam(const char *name)
+;;* <sys/types.h><grp.h> void endgrent(void)
+;;* <sys/types.h><grp.h> void setgrent(void)
+;;* <sys/types.h><limits.h><db.h> DB * dbopen(const char *file, int flags, int mode, DBTYPE type, const void *openinfo);
+;;* <sys/types.h><machine/segments.h><machine/sysarch.h> int i386_get_ldt(int start_sel, union descriptor *descs, int num_sels)
+;;* <sys/types.h><machine/segments.h><machine/sysarch.h> int i386_set_ldt(int start_sel, union descriptor *descs, int num_sels)
+;;* <sys/types.h><machine/sysarch.h> int i386_get_ioperm(u_long *iomap)
+;;* <sys/types.h><machine/sysarch.h> int i386_iopl(int iopl)
+;;* <sys/types.h><machine/sysarch.h> int i386_set_ioperm(u_long *iomap)
+;;* <sys/types.h><netinet/in.h><arpa/nameser.h><resolv.h> dn_comp(char *exp_dn, char *comp_dn, int length, char **dnptrs, char **lastdnptr)
+;;* <sys/types.h><netinet/in.h><arpa/nameser.h><resolv.h> dn_expand(u_char *msg, u_char *eomorig, u_char *comp_dn, u_char *exp_dn, int length)
+;;* <sys/types.h><netinet/in.h><arpa/nameser.h><resolv.h> res_init()
+;;* <sys/types.h><netinet/in.h><arpa/nameser.h><resolv.h> res_mkquery(int op, char *dname, int class, int type, char *data, int datalen, struct rrec *newrr, char *buf, int buflen)
+;;* <sys/types.h><netinet/in.h><arpa/nameser.h><resolv.h> res_query(char *dname, int class, int type, u_char *answer, int anslen)
+;;* <sys/types.h><netinet/in.h><arpa/nameser.h><resolv.h> res_search(char *dname, int class, int type, u_char *answer, int anslen)
+;;* <sys/types.h><netinet/in.h><arpa/nameser.h><resolv.h> res_send(char *msg, int msglen, char *answer, int anslen)
+;;* <sys/types.h><netns/ns.h> char * ns_ntoa(struct ns_addr ns)
+;;* <sys/types.h><netns/ns.h> struct ns_addr ns_addr(char *cp)
+;;* <sys/types.h><pwd.h> int setpassent(int stayopen)
+;;* <sys/types.h><pwd.h> struct passwd * getpwent(void)
+;;* <sys/types.h><pwd.h> struct passwd * getpwnam(const char *login)
+;;* <sys/types.h><pwd.h> struct passwd * getpwuid(uid_t uid)
+;;* <sys/types.h><pwd.h> void endpwent(void)
+;;* <sys/types.h><pwd.h> void setpwent(void)
+;;* <sys/types.h><regex.h> int regcomp(regex_t *preg, const char *pattern, int cflags);
+;;* <sys/types.h><regex.h> int regexec(const regex_t *preg, const char *string, size_t nmatch, regmatch_t pmatch[], int eflags);
+;;* <sys/types.h><regex.h> size_t regerror(int errcode, const regex_t *preg, char *errbuf, size_t errbuf_size);
+;;* <sys/types.h><regex.h> void regfree(regex_t *preg);
+;;* <sys/types.h><rpcsvc/ypclnt.h><rpcsvc/yp_prot.h> char * yperr_string(int incode)
+;;* <sys/types.h><rpcsvc/ypclnt.h><rpcsvc/yp_prot.h> int yp_all(char *indomain, char *inmap, struct ypall_callback *incallback)
+;;* <sys/types.h><rpcsvc/ypclnt.h><rpcsvc/yp_prot.h> int yp_bind(char *dom)
+;;* <sys/types.h><rpcsvc/ypclnt.h><rpcsvc/yp_prot.h> int yp_first(char *indomain, char *inmap, char **outkey, int *outkeylen, char **outval, int *outvallen)
+;;* <sys/types.h><rpcsvc/ypclnt.h><rpcsvc/yp_prot.h> int yp_get_default_domain(char **domp)
+;;* <sys/types.h><rpcsvc/ypclnt.h><rpcsvc/yp_prot.h> int yp_master(char *indomain, char *inmap, char **outname)
+;;* <sys/types.h><rpcsvc/ypclnt.h><rpcsvc/yp_prot.h> int yp_match(char *indomain, char *inmap, const char *inkey, int inkeylen, char **outval, int *outvallen)
+;;* <sys/types.h><rpcsvc/ypclnt.h><rpcsvc/yp_prot.h> int yp_next(char *indomain, char *inmap, char *inkey, int inkeylen, char **outkey, int *outkeylen, char **outval, int *outvallen)
+;;* <sys/types.h><rpcsvc/ypclnt.h><rpcsvc/yp_prot.h> int yp_order(char *indomain, char *inmap, char *outorder)
+;;* <sys/types.h><rpcsvc/ypclnt.h><rpcsvc/yp_prot.h> int ypprot_err(unsigned int incode)
+;;* <sys/types.h><rpcsvc/ypclnt.h><rpcsvc/yp_prot.h> void yp_unbind(char *dom)
+;;* <sys/types.h><signal.h> int sigaltstack(const struct sigaltstack *ss, struct sigaltstack *oss)
+;;* <sys/types.h><signal.h><machine/segments.h><machine/sysarch.h><machine/vm86.h> int i386_vm86(struct vm86_struct *vmcp)
+;;* <sys/types.h><sys/disklabel.h><sys/disk.h> struct disk * disk_find(char *)
+;;* <sys/types.h><sys/disklabel.h><sys/disk.h> void disk_attach(struct disk *)
+;;* <sys/types.h><sys/disklabel.h><sys/disk.h> void disk_busy(struct disk *)
+;;* <sys/types.h><sys/disklabel.h><sys/disk.h> void disk_detatch(struct disk *)
+;;* <sys/types.h><sys/disklabel.h><sys/disk.h> void disk_init(void)
+;;* <sys/types.h><sys/disklabel.h><sys/disk.h> void disk_resetstat(struct disk *)
+;;* <sys/types.h><sys/disklabel.h><sys/disk.h> void disk_unbusy(struct disk *)
+;;* <sys/types.h><sys/ipc.h> key_t ftok(const char *path, char id);
+;;* <sys/types.h><sys/ipc.h><sys/msg.h> int msgctl(int msqid, int cmd, struct msqid_ds *buf)
+;;* <sys/types.h><sys/ipc.h><sys/msg.h> int msgget(key_t key, int msgflg)
+;;* <sys/types.h><sys/ipc.h><sys/msg.h> int msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg)
+;;* <sys/types.h><sys/ipc.h><sys/msg.h> int msgsnd(int msqid, void *msgp, size_t msgsz, int msgflg)
+;;* <sys/types.h><sys/ipc.h><sys/msg.h> int shmctl(int shmid, int cmd, struct shmid_ds *buf)
+;;* <sys/types.h><sys/ipc.h><sys/sem.h> int semctl(int semid, int semnum, int cmd, union semun arg)
+;;* <sys/types.h><sys/ipc.h><sys/sem.h> int semget(key_t key, int nsems, int semflg)
+;;* <sys/types.h><sys/ipc.h><sys/sem.h> int semop(int semid, struct sembuf *sops, int nsops)
+;;* <sys/types.h><sys/ipc.h><sys/shm.h> int shmdt(void *shmaddr)
+;;* <sys/types.h><sys/ipc.h><sys/shm.h> int shmget(key_t key, int size, int shmflg)
+;;* <sys/types.h><sys/ipc.h><sys/shm.h> void * shmat(int shmid, void *shmaddr, int shmflg)
+;;* <sys/types.h><sys/mman.h> caddr_t mmap(caddr_t addr, size_t len, int prot, int flags, int fd, off_t offset)
+;;* <sys/types.h><sys/mman.h> int madvise(caddr_t addr, size_t len, int behav)
+;;* <sys/types.h><sys/mman.h> int mincore(caddr_t addr, size_t len, char *vec)
+;;* <sys/types.h><sys/mman.h> int mlock(caddr_t addr, size_t len)
+;;* <sys/types.h><sys/mman.h> int mprotect(caddr_t addr, size_t len, int prot)
+;;* <sys/types.h><sys/mman.h> int msync(caddr_t addr, size_t len)
+;;* <sys/types.h><sys/mman.h> int munlock(caddr_t addr, size_t len)
+;;* <sys/types.h><sys/mman.h> int munmap(caddr_t addr, size_t len)
+;;* <sys/types.h><sys/mount.h> int getfh(const char *path, fhandle_t *fhp)
+;;* <sys/types.h><sys/ptrace.h> int ptrace(int request, pid_t pid, caddr_t addr, int data)
+;;* <sys/types.h><sys/socket.h> int accept(int s, struct sockaddr *addr, int *addrlen)
+;;* <sys/types.h><sys/socket.h> int bind(int s, const struct sockaddr *name, int namelen)
+;;* <sys/types.h><sys/socket.h> int connect(int s, const struct sockaddr *name, int namelen)
+;;* <sys/types.h><sys/socket.h> int getsockopt(int s, int level, int optname, void *optval, int *optlen)
+;;* <sys/types.h><sys/socket.h> int setsockopt(int s, int level, int optname, const void *optval, int optlen)
+;;* <sys/types.h><sys/socket.h> int socket(int domain, int type, int protocol)
+;;* <sys/types.h><sys/socket.h> int socketpair(int d, int type, int protocol, int *sv)
+;;* <sys/types.h><sys/socket.h> ssize_t recv(int s, void *buf, size_t len, int flags)
+;;* <sys/types.h><sys/socket.h> ssize_t recvfrom(int s, void *buf, size_t len, int flags, struct sockaddr *from, int *fromlen)
+;;* <sys/types.h><sys/socket.h> ssize_t recvmsg(int s, struct msghdr *msg, int flags)
+;;* <sys/types.h><sys/socket.h> ssize_t send(int s, const void *msg, size_t len, int flags)
+;;* <sys/types.h><sys/socket.h> ssize_t sendmsg(int s, const struct msghdr *msg, int flags)
+;;* <sys/types.h><sys/socket.h> ssize_t sendto(int s, const void *msg, size_t len, int flags, const struct sockaddr *to, int tolen)
+;;* <sys/types.h><sys/socket.h><net/if_dl.h> char * link_ntoa(const struct sockaddr_dl *sdl)
+;;* <sys/types.h><sys/socket.h><net/if_dl.h> void link_addr(const char *addr, struct sockaddr_dl *sdl)
+;;* <sys/types.h><sys/stat.h> int chmod(const char *path, mode_t mode)
+;;* <sys/types.h><sys/stat.h> int fchmod(int fd, mode_t mode)
+;;* <sys/types.h><sys/stat.h> int fstat(int fd, struct stat *sb)
+;;* <sys/types.h><sys/stat.h> int lstat(const char *path, struct stat *sb)
+;;* <sys/types.h><sys/stat.h> int mkdir(const char *path, mode_t mode)
+;;* <sys/types.h><sys/stat.h> int mkfifo(const char *path, mode_t mode)
+;;* <sys/types.h><sys/stat.h> int stat(const char *path, struct stat *sb)
+;;* <sys/types.h><sys/stat.h> mode_t umask(mode_t numask)
+;;* <sys/types.h><sys/stat.h><fcntl.h> int creat(const char *path, mode_t mode)
+;;* <sys/types.h><sys/stat.h><fts.h> FTS * fts_open(char * const *path_argv, int options, int *compar(const FTSENT **, const FTSENT **))
+;;* <sys/types.h><sys/stat.h><fts.h> FTSENT * fts_children(FTS *ftsp, int options)
+;;* <sys/types.h><sys/stat.h><fts.h> FTSENT * fts_read(FTS *ftsp)
+;;* <sys/types.h><sys/stat.h><fts.h> int fts_close(FTS *ftsp)
+;;* <sys/types.h><sys/stat.h><fts.h> int fts_set(FTS ftsp, FTSENT *f, int options)
+;;* <sys/types.h><sys/systm.h> int copyin(void *uaddr, void *kaddr, size_t len)
+;;* <sys/types.h><sys/systm.h> int copyinstr(void *uaddr, void *kaddr, size_t len, size_t *done)
+;;* <sys/types.h><sys/systm.h> int copyout(void *kaddr, void *uaddr, size_t len)
+;;* <sys/types.h><sys/systm.h> int copyoutstr(void *kaddr, void *uaddr, size_t len, size_t *done)
+;;* <sys/types.h><sys/systm.h> int copystr(void *kfaddr, void *kdaddr, size_t len, size_t *done)
+;;* <sys/types.h><sys/systm.h> int fubyte(void *base)
+;;* <sys/types.h><sys/systm.h> int fuswintr(void *base)
+;;* <sys/types.h><sys/systm.h> int fusword(void *base)
+;;* <sys/types.h><sys/systm.h> int fuword(void *base)
+;;* <sys/types.h><sys/systm.h> int subyte(void *base)
+;;* <sys/types.h><sys/systm.h> int suswintr(void *base)
+;;* <sys/types.h><sys/systm.h> int susword(void *base)
+;;* <sys/types.h><sys/systm.h> int suword(void *base)
+;;* <sys/types.h><sys/time.h><sys/resource.h> int getrlimit(int resource, struct rlimit *rlp)
+;;* <sys/types.h><sys/time.h><sys/resource.h> int setrlimit(int resource, const struct rlimit *rlp)
+;;* <sys/types.h><sys/time.h><unistd.h> FD_CLR(fd, &fdset)
+;;* <sys/types.h><sys/time.h><unistd.h> FD_ISSET(fd, &fdset)
+;;* <sys/types.h><sys/time.h><unistd.h> FD_SET(fd, &fdset)
+;;* <sys/types.h><sys/time.h><unistd.h> FD_ZERO(&fdset)
+;;* <sys/types.h><sys/time.h><unistd.h> int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout)
+;;* <sys/types.h><sys/timeb.h> int ftime(struct timeb *tp)
+;;* <sys/types.h><sys/uio.h><unistd.h> ssize_t read(int d, void *buf, size_t nbytes)
+;;* <sys/types.h><sys/uio.h><unistd.h> ssize_t readv(int d, const struct iovec *iov, int iovcnt)
+;;* <sys/types.h><sys/uio.h><unistd.h> ssize_t write(int d, const void *buf, size_t nbytes)
+;;* <sys/types.h><sys/uio.h><unistd.h> ssize_t writev(int d, const struct iovec *iov, int iovcnt)
+;;* <sys/types.h><sys/wait.h> pid_t wait(int *status)
+;;* <sys/types.h><sys/wait.h> pid_t waitpid(pid_t wpid, int *status, int options)
+;;* <sys/types.h><sys/wait.h><sys/time.h><sys/resource.h> pid_t wait3(int *status, int options, struct rusage *rusage)
+;;* <sys/types.h><sys/wait.h><sys/time.h><sys/resource.h> pid_t wait4(pid_t wpid, int *status, int options, struct rusage *rusage)
+;;* <sys/types.h><time.h> char *asctime(tm) const struct tm *tm;
+;;* <sys/types.h><time.h> struct tm *gmtime(clock) const time_t *clock;
+;;* <sys/types.h><time.h> struct tm *localtime(clock) const time_t *clock;
+;;* <sys/types.h><time.h> time_t mktime(tm) struct tm *tm;
+;;* <sys/types.h><time.h> time_t posix2time(t) time_t t
+;;* <sys/types.h><time.h> time_t time2posix(t) time_t t
+;;* <sys/types.h><unistd.h> gid_t getegid(void)
+;;* <sys/types.h><unistd.h> gid_t getgid(void)
+;;* <sys/types.h><unistd.h> int chown(const char *path, uid_t owner, gid_t group)
+;;* <sys/types.h><unistd.h> int fchown(int fd, uid_t owner, gid_t group)
+;;* <sys/types.h><unistd.h> int setegid(gid_t egid)
+;;* <sys/types.h><unistd.h> int seteuid(uid_t euid)
+;;* <sys/types.h><unistd.h> int setgid(gid_t gid)
+;;* <sys/types.h><unistd.h> int setuid(uid_t uid)
+;;* <sys/types.h><unistd.h> int tcsetpgrp(int fd, pid_t pgrp_id)
+;;* <sys/types.h><unistd.h> pid_t fork(void)
+;;* <sys/types.h><unistd.h> pid_t getpid(void)
+;;* <sys/types.h><unistd.h> pid_t getppid(void)
+;;* <sys/types.h><unistd.h> pid_t setsid(void)
+;;* <sys/types.h><unistd.h> pid_t tcgetpgrp(int fd)
+;;* <sys/types.h><unistd.h> uid_t geteuid(void)
+;;* <sys/types.h><unistd.h> uid_t getuid(void)
+;;* <sys/types.h><utime.h> int utime(const char *file, const struct utimbuf *timep)
+;;* <sys/utsname.h> int uname(struct utsname *name)
+;;* <sys/vlimit.h> vlimit(resource, value)
+;;* <sys/vtimes.h> vtimes(struct vtimes *par_vm, struct vtimes *ch_vm)
+;;* <syslog.h><varargs.h> int setlogmask(int maskpri)
+;;* <syslog.h><varargs.h> void closelog(void)
+;;* <syslog.h><varargs.h> void openlog(const char *ident, int logopt, int facility)
+;;* <syslog.h><varargs.h> void syslog(int priority, const char *message, ...)
+;;* <syslog.h><varargs.h> void vsyslog(int priority, const char *message, va_list args)
+;;* <termios.h> int cfsetispeed(struct termios *t, speed_t speed)
+;;* <termios.h> int cfsetospeed(struct termios *t, speed_t speed)
+;;* <termios.h> int tcdrain(int fd)
+;;* <termios.h> int tcflow(int fd, int action)
+;;* <termios.h> int tcflush(int fd, int action)
+;;* <termios.h> int tcgetattr(int fd, struct termios *t)
+;;* <termios.h> int tcsendbreak(int fd, int len)
+;;* <termios.h> int tcsetattr(int fd, int action, const struct termios *t)
+;;* <termios.h> speed_t cfgetispeed(const struct termios *t)
+;;* <termios.h> speed_t cfgetospeed(const struct termios *t)
+;;* <termios.h> void cfmakeraw(struct termios *t)
+;;* <termios.h> void cfsetspeed(struct termios *t, speed_t speed)
+;;* <time.h> clock_t clock(void)
+;;* <time.h> size_t strftime(char *buf, size_t maxsize, const char *format, const struct tm *timeptr)
+;;* <time.h> time_t time(time_t *tloc)
+;;* <ttyent.h> int endttyent(void)
+;;* <ttyent.h> int setttyent(void)
+;;* <ttyent.h> struct ttyent * getttyent()
+;;* <ttyent.h> struct ttyent * getttynam(char *name)
+;;* <unistd.h> char * getcwd(char *buf, size_t size)
+;;* <unistd.h> char * getlogin(void)
+;;* <unistd.h> char * getwd(char *buf)
+;;* <unistd.h> char * mktemp(char *template)
+;;* <unistd.h> char * re_comp(const char *s)
+;;* <unistd.h> char * ttyname(int fd)
+;;* <unistd.h> char * valloc(unsigned size)
+;;* <unistd.h> extern char **environ;
+;;* <unistd.h> extern char *optarg; extern int optind; extern int optopt; extern int opterr; extern int optreset;
+;;* <unistd.h> int access(const char *path, int mode)
+;;* <unistd.h> int acct(const char *file)
+;;* <unistd.h> int chdir(const char *path)
+;;* <unistd.h> int chroot(const char *dirname)
+;;* <unistd.h> int close(int d)
+;;* <unistd.h> int dup(int oldd)
+;;* <unistd.h> int dup2(int oldd, int newd)
+;;* <unistd.h> int execl(const char *path, const char *arg, ...)
+;;* <unistd.h> int execle(const char *path, const char *arg, ..., char *const envp[])
+;;* <unistd.h> int execlp(const char *file, const char *arg, ...)
+;;* <unistd.h> int exect(const char *path, char *const argv[], char *const envp[])
+;;* <unistd.h> int execv(const char *path, char *const argv[])
+;;* <unistd.h> int execve(const char *path, char *const argv[], char *const envp[])
+;;* <unistd.h> int execvp(const char *file, char *const argv[])
+;;* <unistd.h> int fchdir(int fd)
+;;* <unistd.h> int fsync(int fd)
+;;* <unistd.h> int ftruncate(int fd, off_t length)
+;;* <unistd.h> int getdomainname(char *name, int namelen)
+;;* <unistd.h> int getdtablesize(void)
+;;* <unistd.h> int getgrouplist(const char *name, gid_t basegid, gid_t *groups, int *ngroups)
+;;* <unistd.h> int gethostname(char *name, int namelen)
+;;* <unistd.h> int getopt(int argc, char * const *argv, const char *optstring)
+;;* <unistd.h> int getpagesize(void)
+;;* <unistd.h> int initgroups(const char *name, gid_t basegid)
+;;* <unistd.h> int iruserok(u_int32_t raddr, int superuser, const char *ruser, const char *luser)
+;;* <unistd.h> int isatty(int fd)
+;;* <unistd.h> int link(const char *name1, const char *name2)
+;;* <unistd.h> int mknod(const char *path, mode_t mode, dev_t dev)
+;;* <unistd.h> int mkstemp(char *template)
+;;* <unistd.h> int pause(void)
+;;* <unistd.h> int pipe(int *fildes)
+;;* <unistd.h> int rcmd(char **ahost, int inport, const char *locuser, const char *remuser, const char *cmd, int *fd2p)
+;;* <unistd.h> int re_exec(const char *s)
+;;* <unistd.h> int readlink(const char *path, char *buf, int bufsiz)
+;;* <unistd.h> int revoke(const char *path)
+;;* <unistd.h> int rmdir(const char *path)
+;;* <unistd.h> int rresvport(int *port)
+;;* <unistd.h> int ruserok(const char *rhost, int superuser, const char *ruser, const char *luser)
+;;* <unistd.h> int setdomainname(const char *name, int namelen)
+;;* <unistd.h> int sethostid(long hostid)
+;;* <unistd.h> int sethostname(const char *name, int namelen)
+;;* <unistd.h> int setlogin(const char *name)
+;;* <unistd.h> int setpgid(pid_t pid, pid_t pgrp)
+;;* <unistd.h> int setpgrp(pid_t pid, pid_t pgrp)
+;;* <unistd.h> int setregid(int rgid, int egid)
+;;* <unistd.h> int setreuid(int ruid, int euid)
+;;* <unistd.h> int swapon(const char *special)
+;;* <unistd.h> int symlink(const char *name1, const char *name2)
+;;* <unistd.h> int truncate(const char *path, off_t length)
+;;* <unistd.h> int ttyslot()
+;;* <unistd.h> int unlink(const char *path)
+;;* <unistd.h> long fpathconf(int fd, int name)
+;;* <unistd.h> long gethostid(void)
+;;* <unistd.h> long pathconf(const char *path, int name)
+;;* <unistd.h> long sysconf(int name)
+;;* <unistd.h> off_t lseek(int fildes, off_t offset, int whence)
+;;* <unistd.h> pid_t getpgrp(void)
+;;* <unistd.h> pid_t vfork(void)
+;;* <unistd.h> size_t confstr(int name, char *buf, size_t len)
+;;* <unistd.h> u_int ualarm(u_int microseconds, u_int interval)
+;;* <unistd.h> unsigned int alarm(unsigned int seconds)
+;;* <unistd.h> unsigned int sleep(unsigned int seconds)
+;;* <unistd.h> void _exit(int status)
+;;* <unistd.h> void sync(void)
+;;* <unistd.h> void usleep(u_int microseconds)
+;;* <unistd.h><nfs/nfs.h> int nfssvc(int flags, void *argstructp)
+;;* <unistd.h><sys/reboot.h> int reboot(int howto)
+;;* <util.h> #indlude <pwd.h>
+;;* <util.h> int getmaxpartitions(void)
+;;* <util.h> int getrawpartition(void)
+;;* <util.h> int login_tty(int fd)
+;;* <util.h> int logout(const char *line)
+;;* <util.h> int pw_lock(int retries)
+;;* <util.h> int pw_mkdb()
+;;* <util.h> int pw_scan(char *bp, struct passwd *pw, int *flags)
+;;* <util.h> pid_t forkpty(int *amaster, char *name, struct termios *termp, struct winsize *winp)
+;;* <util.h> void login(struct utmp *ut)
+;;* <util.h> void logwtmp(const char *line, const char *name, const char *host)
+;;* <util.h> void openpty(int *amaster, int *aslave, char *name, struct termios *termp, struct winsize *winp)
+;;* <util.h> void pw_abort()
+;;* <util.h> void pw_copy(int ffd, int tfd, struct passwd *pw)
+;;* <util.h> void pw_edit(int notsetuid, const char *filename)
+;;* <util.h> void pw;;* _
+;;* # END NetBSD Sample C++ function database
+
+;;}}}
+
+(tinytag-install)
+
+(provide 'tinytag)
+(run-hooks 'tinytag-:load-hook)
+
+;;; tinytag.el ends here
projects / lib.git / blobdiff