diff options
Diffstat (limited to 'Demo')
-rw-r--r-- | Demo/ibrowse/README | 34 | ||||
-rwxr-xr-x | Demo/ibrowse/ib | 2 | ||||
-rwxr-xr-x | Demo/ibrowse/ib.py | 21 | ||||
-rwxr-xr-x | Demo/ibrowse/ibrowse | 719 | ||||
-rwxr-xr-x | Demo/ibrowse/ibrowse.py | 617 | ||||
-rwxr-xr-x | Demo/ibrowse/icache.py | 74 | ||||
-rwxr-xr-x | Demo/ibrowse/ifile.py | 328 | ||||
-rwxr-xr-x | Demo/ibrowse/itags.py | 127 |
8 files changed, 1922 insertions, 0 deletions
diff --git a/Demo/ibrowse/README b/Demo/ibrowse/README new file mode 100644 index 0000000..22e4039 --- /dev/null +++ b/Demo/ibrowse/README @@ -0,0 +1,34 @@ +This directory contains a browser written in Python for "Info files" +as used by the Emacs documentation system. The browser requires that +Python is built with the "stdwin" option and runs under X11 or the +Mac window system. + +Now you can read Info files even if you can't spare the memory, time or +disk space to run Emacs. (I have used this extensively on a Macintosh +with 1 Megabyte main memory and a 20 Meg harddisk.) + +You can give this to someone with great fear of complex computer +systems, as long as they can use a mouse. + +Another reason to use this is to encourage the use of Info for on-line +documentation of software that is not related to Emacs or GNU. +(In particular, I plan to redo the Python and STDWIN documentation +in texinfo.) + +The main program is in file "ib.py"; this accepts a file name and a +node name as optional command line arguments, i.e., its usage is + + python ib.py [file [node]] + + +Configuration: + +- The pathname of the directory (or directories) containing +the standard Info files should be set by editing the +value assigned to INFOPATH in module ifile.py. + +- The default font should be set by editing the value of FONT +in this module (ibrowse.py). + +- For fastest I/O, you may look at BLOCKSIZE and a few other +constants in ifile.py. diff --git a/Demo/ibrowse/ib b/Demo/ibrowse/ib new file mode 100755 index 0000000..04cb790 --- /dev/null +++ b/Demo/ibrowse/ib @@ -0,0 +1,2 @@ +: ${ARCH}=`arch` +exec /ufs/guido/bin/$ARCH/python ib.py ${1+"$@"} diff --git a/Demo/ibrowse/ib.py b/Demo/ibrowse/ib.py new file mode 100755 index 0000000..588270e --- /dev/null +++ b/Demo/ibrowse/ib.py @@ -0,0 +1,21 @@ +#! /usr/local/bin/python + +# Call ibrowse (the info file browser) under UNIX. + +import sys +import ibrowse + +if len(sys.argv) > 1: + file = sys.argv[1] + if len(sys.argv) > 2: + if len(sys.argv) > 3: + sys.stdout = sys.stderr + print 'usage:', sys.argv[0], '[file [node]]' + sys.exit(2) + else: + node = sys.argv[2] + else: + node = '' + ibrowse.start('(' + file + ')' + node) +else: + ibrowse.main() diff --git a/Demo/ibrowse/ibrowse b/Demo/ibrowse/ibrowse new file mode 100755 index 0000000..8b0dcde --- /dev/null +++ b/Demo/ibrowse/ibrowse @@ -0,0 +1,719 @@ +This file documents the ibrowse program. -*-Text-*- +The H command of ibrowse goes to the node Help in this file. + +File: ibrowse Node: Top Up: (DIR) Next: Expert + +Ibrowse is a program for reading documentation, which you are using now. +** Ibrowse uses the file format of the Emacs Info program, and its +** commands are similar, but not identical. + +To learn how to use Ibrowse, type the command "h". It will bring you +to a programmed instruction sequence. + +* Menu: + +* Expert:: Advanced Ibrowse commands: c, k, g, s, 1 - 9, arrows. +* Add:: Describes how to add new nodes to the hierarchy. + Also tells what nodes look like. +* Menus:: How to add to or create menus in Info nodes. +* Cross-refs:: How to add cross-references to Info nodes. +* Tags:: How to make tag tables for Info files. +* Checking:: How to check the consistency of an Info file. +* Texinfo: (texinfo). + How to generate an Info file and a printed manual + from the same source file. + +File: ibrowse Node: Summary Next: Help + +Ibrowse is a Python program for browsing through the Emacs Info +documentation tree. Documentation in Info is divided into "nodes", +each of which discusses one topic and contains references to other +nodes which discuss related topics. Ibrowse has commands to follow the +references and show you other nodes. + +h Invoke the Ibrowse tutorial. +? Display this Summary node. +q Quit Ibrowse. +w Close current window. + +Selecting other nodes: +n Move to the "next" node of this node. +p Move to the "previous" node of this node. +m Pick menu item specified by name (or abbreviation). +1-9 Pick first..ninth in node's menu. + Menu items select nodes that are "subsections" of this node. +u Move "up" from this node (i.e., from a subsection to a section). +f Follow a cross reference by name (or abbrev). Type `l' to get back. +l Move back to the last node you were in. + +Moving within a node: +Space Scroll forward a full screen. DEL, BS Scroll backward. +b Go to beginning of node. + +Advanced commands: +k Clone current window (create an independent duplicate). +c Copy text selection to clipboard (for paste in another application). +g Move to node specified by name. + You may include a filename as well, as (FILENAME)NODENAME. +d Go to the main directory of Info files. +t Go to Top node of this file. +s Search through this Info file for node with specified regexp. + +File: ibrowse Node: Help-Small-Screen Next: Help + +Since your terminal has an unusually small number of lines on its +screen, it is necessary to give you special advice at the beginning. + +If you see the text "--All----" at near the bottom right corner of +the screen, it means the entire text you are looking at fits on the +screen. If you see "--Top----" instead, it means that there is more +text below that does not fit. To move forward through the text and +see another screen full, press the Space bar. To move back up, press +the key labeled Rubout or Delete or DEL. + +Here are 40 lines of junk, so you can try Spaces and Rubout and +see what they do. At the end are instructions of what you should do +next. + +This is line 17 +This is line 18 +This is line 19 +This is line 20 +This is line 21 +This is line 22 +This is line 23 +This is line 24 +This is line 25 +This is line 26 +This is line 27 +This is line 28 +This is line 29 +This is line 30 +This is line 31 +This is line 32 +This is line 33 +This is line 34 +This is line 35 +This is line 36 +This is line 37 +This is line 38 +This is line 39 +This is line 40 +This is line 41 +This is line 42 +This is line 43 +This is line 44 +This is line 45 +This is line 46 +This is line 47 +This is line 48 +This is line 49 +This is line 50 +This is line 51 +This is line 52 +This is line 53 +This is line 54 +This is line 55 +This is line 56 + +If you have managed to get here, go back to the beginning with +Rubout, and come back here again, then you understand Space and +Rubout. So now type an "n"--just one character; don't type the +quotes and don't type a Return afterward-- to get to the normal start +of the course. + +File: ibrowse Node: Help Next: Help-P Previous: Help-Small-Screen + +You are talking to the program Ibrowse, for reading documentation. + + Right now you are looking at one "Node" of Information. +A node contains text describing a specific topic at a specific +level of detail. This node's topic is "how to use Ibrowse". + + The top line of a node is its "header". This node's header (look at +it now) says that it is the node named "Help" in the file "ibrowse". +It says that the Next node after this one is the node called "Help-P". +An advanced Ibrowse command lets you go to any node whose name you know. + + Besides a "Next", a node can have a "Previous" or an "Up". +This node has a "Previous" but no "Up", as you can see. + + Now it's time to move on to the Next node, named "Help-P". + +>> Type "n" to move there. Type just one character; + don't type the quotes and don't type a Return afterward. + +">>" in the margin means it is really time to try a command. + +File: ibrowse Node: Help-P Next: Help-Page Previous: Help + +This node is called "Help-P". The "Previous" node, as you see, is +"Help", which is the one you just came from using the "N" command. +Another "N" command now would take you to the Next node, "Help-Page". + +>> But don't do that yet. First, try the "p" command, which takes +you to the Previous node. When you get there, you can do an "n" +again to return here. + + This all probably seems insultingly simple so far, but DON'T be +led into skimming. Things will get more complicated soon. Also, +don't try a new command until you are told it's time to. Otherwise, +you may make Ibrowse skip past an important warning that was coming up. + +>> Now do an "n" to get to the node "Help-Page" and learn more. + +File: ibrowse Node: Help-Page Next: Help-M Previous: Help-P + +Space, Backspace, and B commands. + + This node's header tells you that you are now at node "Help-Page", and +that "P" would get you back to "Help-P". The line starting "Space," +is a "Title", saying what the node is about (most nodes have titles). + + This is a big node and it doesn't all fit on your display screen. +You can tell that there is more that isn't visible because you +the scroll bar on the side of the window has become active (gray). + + The Space, Backspace and B commands exist to allow you to "move +around" in a node that doesn't all fit on the screen at once. +Space moves forward, to show what was below the bottom of the screen. +Backspace moves backward, to show what was above the top of the screen +(there isn't anything above the top until you have typed some spaces). + +>> Now try typing a Space (afterward, type a Backspace to return here). + + When you type the space, the two lines that were at the bottom of the +screen appear at the top, followed by more lines. Backspace takes the +two lines from the top and moves them to the bottom, USUALLY, but if +there are not a full screen's worth of lines above them they may not +make it all the way to the bottom. + + If you type a Space when there is no more to see, it will ring the +bell and otherwise do nothing. The same goes for a Backspace when +the header of the node is visible. + + Of course you can use the mouse and directly move the scroll bar +as well, but Ibrowse has keyboard commands for almost everything, +including scrolling. These keyboard commands are called "shortcuts", +because it generally takes less effort to press a key on the +keyboard than to move the mouse. On the other hand, if you are +an infrequent user of Ibrowse, you can do everything with the +mouse that you can do with the keyboard. Just look in the menus +(I'm sure you must know how to use the menus on this system, or +else you couldn't have gotten this far...). In fact you'll see that +the commands and shortcuts listed in the menus are the same as those +described in this course. You can use the shortcuts either with or +without the "Command" or "Meta" key. + + Two menus are always available: the "Ibrowse" menu contains commands +pertaining to the Ibrowse program at large, while the "Navigation" menu +contains commands that move around between nodes. There may be other +menus; these will be explained later. + + To move back to the beginning of the node you are on, you can type +a lot of Backspaces. You can also type simply "b" for beginning. +>> Try that now. (I have put in enough verbiage to make sure you are + not on the first screenful now). Then come back, with Spaces. + + You have just learned a considerable number of commands. If you +want to use one but have trouble remembering which, just pull down +the menus to get a summary of commands and shortcuts. Some additional +shortcuts (not listed in the menus) are listed by the "Short help" +command. This brings up a dialog box which you can acknowledge +by clicking the OK button or pressing the Return key. + + From now on, you will encounter large nodes without warning, and +will be expected to know how to use Space and Backspace to move +around in them without being told. Since you could change the +size of the window used, it would be impossible to warn you anyway. + +>> Now type "n" to see the description of the "m" command. + +File: ibrowse Node: Help-M Next: Help-Adv Previous: Help-Page + +Menus and the "m" command + + With only the "n" and "p" commands for moving between nodes, nodes +are restricted to a linear sequence. Menus allow a branching +structure. A menu is a list of other nodes you can move to. It is +actually just part of the text of the node formatted specially so that +Ibrowse can interpret it. The beginning of a menu is always identified +by a line which starts with "* Menu:". A node contains a menu if and +only if it has a line in it which starts that way. The only menu you +can use at any moment is the one in the node you are in. To use a +menu in any other node, you must move to that node first. + + (There is an unfortunate confusion of terms here. "Menu" may refer +to one of the Ibrowse menus at the top, such as as the "Ibrowse" and +"Navigation" menus explained in the previous node, or to the menu in +a node. Where confusion is possible, these will be disambiguated by +calling them "Ibrowse menus" or "node menu".) + + After the start of the menu, each line that starts with a "*" +identifies one subtopic. The line will usually contain a brief name +for the subtopic (followed by a ":"), the name of the node that talks +about that subtopic, and optionally some further description of the +subtopic. Lines in the menu that don't start with a "*" have no +special meaning - they are only for the human reader's benefit and do +not define additional subtopics. Here is an example: +* Foo: FOO's Node This tells about FOO +The subtopic name is Foo, and the node describing it is "FOO's Node". +The rest of the line is just for the reader's Information. +[[ But this line is not a real menu item, simply because there is +no line above it which starts with "* Menu:".]] + + When you use a menu to go to another node (in a way that will be +described soon), what you specify is the subtopic name, the first +thing in the menu line. Ibrowse uses it to find the menu line, extracts +the node name from it, and goes to that node. The reason that there +is both a subtopic name and a node name is that the node name must be +meaningful to the computer and may therefore have to be ugly looking. +The subtopic name can be chosen just to be convenient for the user to +specify. Often the node name is convenient for the user to specify +and so both it and the subtopic name are the same. There is an +abbreviation for this: +* Foo:: This tells about FOO +This means that the subtopic name and node name are the same; they are +both "Foo". + +>> Now use Spaces to find the menu in this node, then come back to +the front with a "b". As you see, a menu is actually visible +in its node. If you can't find a menu in a node by looking at it, +then the node doesn't have a menu and the "m" command is not available. + + (Actually, a quicker way to see if there is a node menu, is to look +for an Ibrowse menu at the top named "Menu".) + + The command to go to one of the subnodes is "m" - but DON'T DO IT +YET! Before you use "m", you must understand the difference between +commands and arguments. So far, you have learned several commands +that do not need arguments. When you type one, Ibrowse processes it and +is instantly ready for another command. The "m" command is different: +it is incomplete without the NAME OF THE SUBTOPIC. Once you have +typed "m", Ibrowse wants to read the subtopic name. + + Thanks to modern user interface technology, this will be obvious: +you are prompted for the subtopic name in a dialog box. When you are +finished typing the name, press Return or click the OK button. You can +cancel the dialog box by clicking the Cancel button. The first subtopic +is provided as a default choice, so if you want to go there, you can +just press Return. + + You can abbreviate the subtopic name. If the abbreviation is not +unique, the first matching subtopic is chosen. Some menus will put +the shortest possible abbreviation for each subtopic name in capital +letters, so you can see how much you need to type. It does not +matter whether you use upper case or lower case when you type the +subtopic. You should not put any spaces at the end, or inside of the +item name, except for one space where a space appears in the item in +the menu. + + Here is a menu to give you a chance to practice. + +* Menu: The menu starts here. + +This menu gives you three ways of going to one place, Help-FOO. + +* Foo: Help-FOO A node you can visit for fun +* Bar: Help-FOO Strange! two ways to get to the same place. +* Help-FOO:: And yet another! + +>> Now type just an "m" and see what happens. (Read ahead before +>> trying this out, as the dialog box will probably cover these +>> instructions!) + + Now you are "inside" an "m" command. Commands can't be used now; +the next thing you will type must be the name of a subtopic. + + You can change your mind about doing the "m" by clicking the Cancel +button. +>> Try that now; notice the dialog box disappear. +>> Then type another "m". + +>> Now type "BAR", the item name. Don't type Return yet. + + While you are typing the item name, you can use the Backspace +key to cancel one character at a time if you make a mistake. +>> Type one to cancel the "R". You could type another "R" to +replace it. You don't have to, since "BA" is a valid abbreviation. +>> Now you are ready to go. Type a Return. + + After visiting Help-FOO, you should return here (it will tell how). + +>> Type "n" to see more commands. + +File: ibrowse Node: Help-FOO Up: Help-M + +The "u" command + + Congratulations! This is the node Help-FOO. Unlike the other +nodes you have seen, this one has an "Up": "Help-M", the node you +just came from via the "m" command. This is the usual convention-- +the nodes you reach from a menu have Ups that lead back to the menu. +Menus move Down in the tree, and Up moves Up. Previous, on the other +hand, is usually used to "stay on the same level but go backwards". + + You can go back to the node Help-M by typing the command +"u" for "Up". That will put you at the FRONT of the node - to get +back to where you were reading you will have to type some Spaces. + +>> Now type "u" to move back up to Help-M. + +File: ibrowse Node: Help-Adv Next: Help-Q Previous: Help-M + +Some advanced Ibrowse commands + + The course is almost over, so please stick with it to the end. + + If you have been moving around to different nodes and wish to +retrace your steps, the "l" command ("l" for "last") will do that, one +node at a time. If you have been following directions, an "l" command +now will get you back to Help-M. Another "l" command would undo the "u" +and get you back to Help-FOO. Another "l" would undo the M and get you +back to Help-M. + +>> Try typing three "l"'s, pausing in between to see what each "l" does. +Then follow directions again and you will end up back here. + + Note the difference between "l" and "p": "l" moves to where YOU +last were, whereas "p" always moves to the node which the header says +is the "Previous" node (from this node, to Help-M). + + The "d" command gets you instantly to the Directory node. +This node, which is the first one you saw when you entered Ibrowse, +has a menu which leads (directly, or indirectly through other menus), +to all the nodes that exist. + +>> Try doing a "d", then do an "l" to return here (yes, DO return). + + Sometimes, in Ibrowse documentation, you will see a cross reference. +Cross references look like this: *Note Cross: Help-Cross. That is a +real, live cross reference which is named "Cross" and points at the +node named "Help-Cross". + + If you wish to follow a cross reference, you must use the "f" +command. The "f" prompts for the cross reference name (in this case, +"Cross") with a dialog box. + +>> Type "f", followed by "Cross", and a Return. + + The "f" command allows abbreviations just like "m". + + To get a list of all the cross references in the current node, +look in the Ibrowse menu at the top labeled "Footnotes". This menu is +only present if there are cross references in the current node, and +can be used to directly follow a cross reference, just like the "Menu" +menu is another way to choose an item of the node's menu. + +>> Now type "n" to see the last node of the course. + +File: ibrowse Node: Help-Cross + + This is the node reached by the cross reference named "Cross". + + While this node is specifically intended to be reached by a cross +reference, most cross references lead to nodes that "belong" someplace +else far away in the structure of Ibrowse. So you can't expect the +footnote to have a Next, Previous or Up pointing back to where you +came from. In general, the "l" (el) command is the only way to get +back there. + +>> Type "l" to return to the node where the cross reference was. + +File: ibrowse Node: Help-Q Previous: Help-Adv Up: Top + + To get out of Ibrowse, type "q" for "Quit". All Ibrowse windows +will be closed (on UNIX, only those managed by the same process). +To close just one window, use the standard method of closing windows +on your system; you can also use "w". + + This is the end of the course on using Ibrowse. There are some other +commands that are not essential or meant for experienced users; they +are useful, and you can find them by looking in the directory for +documentation on Ibrowse. Finding them will be a good exercise in using +Ibrowse in the usual manner. + +>> Close this window and find back the window where you typed "h" + to enter this tutorial. + Then type "d" to go to the Ibrowse directory node if necessary, + and choose the "Ibrowse" menu item, to get to the node about + Ibrowse and see what other help is available. + +File: ibrowse, Node: Expert, Up: Top, Previous: Top, Next: Add + +Some Advanced Ibrowse Commands ("c", "k", "g", "s", "1" - "9", arrows). + +The "c" command lets you copy text from the window to the clipboard. +You must first select the text to be copied with the mouse. + +The "k" command means "klone" (we are running out of letters now...). +It creates a new Ibrowse window, showing the same node as the current. +You can then make an excursion in the new window to different nodes or +files, while the old window keeps showing the original node. Each +window has its own history for use by the "l" command. + +If you know a node's name, you can go there with the "g" command. +This prompts for a node name with a dialog box. Entering, "Top" +would go to the node called Top in this file (its directory node). +Pressing "g" again and entering "Expert" would come back here. + +Unlike "m", "g" does not allow the use of abbreviations. + +To go to a node in another file, you can include the filename in the +node name by putting it at the front, in parentheses. Thus, +"(dir)Top" would go to the Ibrowse Directory node, which is +node Top in the file dir. + +The node name "*" specifies the whole file. So you can look at all +of the current file by typing "*" or all of any other file +with "(FILENAME)*". + +File names are converted to lower case before they are tried; this +is necessary to be compatible with Emacs Info. (File names are +generally relative to the Info directory, but needn't be.) + +The "s" command allows you to search a whole file for a regular +expression. Unlike the corresponding Emacs Info command, it will +not search beyond the end of the current node. + +Regular expressions are like in UNIX egrep; if you don't know what +regular expressions are, limit your search strings to letters, digits +and spaces. Searches in Ibrowse are case-sensitive; searching for +"foo" will not find "Foo" or "FOO"! + +A description of regular expressions as they occur in Emacs is +available. (*Note Emacs Regular Expressions: (regex)syntax.) +Ibrowse regular expressions are slightly different: the meaning +of \( \| \) is swapped with that of ( | ), and there are no +escapes to handle "words" specially. + +Searching starts after the current focus position. The "B" command +resets the focus to the beginning of the file, but space and backspace +leave it unchanged (so they may render the focus invisible). + +If you grudge the system each character of type-in it requires, +you might like to use the commands "1", "2", "3", through "9". +They are short for the first nine entries of the node menu. + +The left, right and up arrow keys are duplicates of "p", "n" and "u". + +The down arrow key, as well as the Return key, goes to the first item +of the node's menu if there is one, else it executes "n". This is a +quick way to visit all nodes in a tree in pre-order: use Return to go +down and right as far as possible, then use "u" and "n" to go right +at the next higher level. + +File: ibrowse, Node: Add, Up: Top, Previous: Expert, Next: Menus + +To add a new topic to the list in the directory, you must + 1) enter the Emacs text editor. *Note Emacs: (emacs). + 2) create a node, in some file, to document that topic. + 3) put that topic in the menu in the directory. *Note Menu: Menus. + + The new node can live in an existing documentation file, or in a new +one. It must have a ^_ character before it (invisible to the user; +this node has one but you can't see it), and it ends with either a ^_, +or the end of file. A nice way to make a node boundary be a +page boundary as well is to put a ^L RIGHT AFTER the ^_. + + The ^_ starting a node must be followed by a newline or a ^L newline, +after which comes the node's header line. The header line must give +the node's name (by which Ibrowse will find it), and state the names of +the Next, Previous, and Up nodes (if there are any). As you can see, +this node's Up node is the node Top, which points at all the +documentation for Ibrowse. The Next node is "Menus". + + The keywords "Node", "Previous", "Up" and "Next", may appear in +any order, anywhere in the header line, but the recommended order is +the one in this sentence. Each keyword must be followed by a colon, +spaces and tabs, and then the appropriate name. The name may be +terminated with a tab, a comma, or a newline. A space does not end +it; node names may contain spaces. The case of letters in the names +is insignificant. "Previous" can be abbreviated to "Prev". + + A node name has two forms. A node in the current file is named by +what appears after the "Node: " in that node's first line. For +example, this node's name is "Add". A node in another file is named +by "(FILENAME)NODE-WITHIN-FILE", as in "(ibrowse)Add" for this node. +If the file name is relative, it is taken starting from the standard +Info file directory of your site. The name "(FILENAME)Top" can be +abbreviated to just "(FILENAME)". By convention, the name "Top" is +used for the "highest" node in any single file - the node whose "Up" +points out of the file. The Directory node is "(dir)". The Top node +of a document file listed in the Directory should have an "Up: (dir)" +in it. + + The node name "*" is special: it refers to the entire file. Thus, +g* will show you the whole current file. The use of the node * is to +make it possible to make old-fashioned, unstructured files into nodes +of the tree. Footnotes and node menus appearing in a file are disabled +when it is viewed in this way. + + The "Node:" name, in which a node states its own name, must not +contain a filename, since Ibrowse when searching for a node does not +expect one to be there. The Next, Previous and Up names may contain +them. In this node, since the Up node is in the same file, it was not +necessary to use one. + + Note that the nodes in this file have a File name in the header +line. The File names are ignored by Ibrowse, but they serve as +comments to help identify the node for the user. + +File: ibrowse, Node: Menus, Previous: Add, Up: Top, Next: Cross-refs + +How to Create Menus: + + Any node in the Ibrowse hierarchy may have a MENU--a list of subnodes. +The "m" command searches the current node's menu for the topic which it +reads from the terminal. + + A menu begins with a line starting with "* Menu:". The rest of the +line is a comment. After the starting line, every line that begins +with a "* " lists a single topic. The name of the topic--the arg +that the user must give to the "m" command to select this topic-- +comes right after the star and space, and is followed by +a colon, spaces and tabs, and the name of the node which discusses +that topic. The node name, like node names following Next, +Previous and Up, may be terminated with a tab, comma, or newline; +it may also be terminated with a period. + + If the node name and topic name are the same, than rather than +giving the name twice, the abbreviation "* NAME::" may be used +(and should be used, whenever possible, as it reduces the visual +clutter in the menu). + + It is considerate to choose the topic names so that they differ +from each other very near the beginning--this allows the user to type +short abbreviations. In a long menu, it is a good idea to capitalize +the beginning of each item name which is the minimum acceptable +abbreviation for it (a long menu is more than 5 or so entries). + + The node's listed in a node's menu are called its "subnodes", and +it is their "superior". They should each have an "Up:" pointing at +the superior. It is often useful to arrange all or most of the +subnodes in a sequence of Next's/Previous's so that someone who +wants to see them all need not keep revisiting the Menu. + + The Info Directory is simply the menu of the node "(dir)Top"--that +is, node Top in file .../info/dir. You can put new entries in that +menu just like any other menu. The Info Directory is NOT the same as +the file directory called "info". It happens that many of Ibrowse's +files live on that file directory, but they don't have to; and files +on that directory are not automatically listed in the Info Directory +node. + + The Ibrowse program uses a second directory called .../ibrowse, +which contains versions of the "dir" and "info" files adapted to +Ibrowse (the latter renamed to "ibrowse", obviously). It searches +any file first in the "ibrowse", then in the "info" directory. +(Actually, the search path is configurable.) + + Also, although the Info node graph is claimed to be a "hierarchy", +in fact it can be ANY directed graph. Shared structures and pointer +cycles are perfectly possible, and can be used if they are +appropriate to the meaning to be expressed. There is no need for all +the nodes in a file to form a connected structure. In fact, this +file has two connected components. You are in one of them, which is +under the node Top; the other contains the node Help which the "h" +command goes to. In fact, since there is no garbage collector, +nothing terrible happens if a substructure is not pointed to, but +such a substructure will be rather useless since nobody will ever +find out that it exists. + +File: ibrowse, Node: Cross-refs, Previous: Menus, Up: Top, Next: Tags + +Creating Cross References: + + A cross reference can be placed anywhere in the text, unlike a menu +item which must go at the front of a line. A cross reference looks +like a menu item except that it has "*note" instead of "*". It CANNOT +be terminated by a ")", because ")"'s are so often part of node names. +If you wish to enclose a cross reference in parentheses, terminate it +with a period first. Here are two examples of cross references pointers: + + *Note details: commands. (See *note 3: Full Proof.) + +They are just examples. The places they "lead to" don't really exist! + +File: ibrowse, Node: Tags, Previous: Cross-refs, Up: Top, Next: Checking + +Tag Tables for Info Files: + + You can speed up the access to nodes of a large Info file by giving +it a tag table. Unlike the tag table for a program, the tag table for +an Info file lives inside the file itself and will automatically be +used whenever Ibrowse reads in the file. + + To make a tag table, go to a node in the file using Emacs Info and type +M-x Info-tagify. Then you must use C-x C-s to save the file. + + Once the Info file has a tag table, you must make certain it is up +to date. If, as a result of deletion of text, any node moves back +more than a thousand characters in the file from the position +recorded in the tag table, Ibrowse will no longer be able to find that +node. To update the tag table, use the Info-tagify command again. + + An Info file tag table appears at the end of the file and looks like +this: + +^_^L +Tag Table: +File: ibrowse, Node: Cross-refs21419 +File: ibrowse, Node: Tags22145 +^_ +End Tag Table + +Note that it contains one line per node, and this line contains +the beginning of the node's header (ending just after the node name), +a rubout (DEL) character, and the character position in the file of the +beginning of the node. The words "Tag Table" may occur in lower case +as well. + +It is also possible for an extra level of indirection to be present. +In this case, the first line of the Tag table contains the string +"(Indirect)", and preceding the tag table is another "pseudo node" +whose header reads "Indirect:". Each following line has the form +"filename: offset", meaning that nodes at that offset or larger (but +less than the offset in the next line) really occur in the file named +here, and that the file's offset should be subtracted from the node's +offset. (Indirect tables are created by texinfo for large files. +*Note Texinfo: (texinfo). *Note Splitting files: (texinfo)Splitting.) + +File: ibrowse, Node: Checking, Previous: Tags, Up: Top + +Checking an Info File: + + When creating an Info file, it is easy to forget the name of a node +when you are making a pointer to it from another node. If you put in +the wrong name for a node, this will not be detected until someone +tries to go through the pointer using Ibrowse. Verification of the Info +file is an automatic process which checks all pointers to nodes and +reports any pointers which are invalid. Every Next, Previous, and Up +is checked, as is every menu item and every cross reference. In addition, +any Next which doesn't have a Previous pointing back is reported. +Only pointers within the file are checked, because checking pointers +to other files would be terribly slow. But those are usually few. + + To check an Info file, do M-x Info-validate while looking at any +node of the file with Emacs Info. + +Tag table: +Node: Top117 +Node: Summary952 +Node: Help-Small-Screen997 +Node: Help2628 +Node: Help-P3588 +Node: Help-Page4348 +Node: Help-M7763 +Node: Help-FOO13183 +Node: Help-Adv13887 +Node: Help-Cross15923 +Node: Help-Q16443 +Node: Expert17326 +Node: Add20280 +Node: Menus23273 +Node: Cross-refs26394 +Node: Tags27050 +Node: Checking28966 + +End tag table diff --git a/Demo/ibrowse/ibrowse.py b/Demo/ibrowse/ibrowse.py new file mode 100755 index 0000000..41574ad --- /dev/null +++ b/Demo/ibrowse/ibrowse.py @@ -0,0 +1,617 @@ +# Browser for "Info files" as used by the Emacs documentation system. +# +# Now you can read Info files even if you can't spare the memory, time or +# disk space to run Emacs. (I have used this extensively on a Macintosh +# with 1 Megabyte main memory and a 20 Meg harddisk.) +# +# You can give this to someone with great fear of complex computer +# systems, as long as they can use a mouse. +# +# Another reason to use this is to encourage the use of Info for on-line +# documentation of software that is not related to Emacs or GNU. +# (In particular, I plan to redo the Python and STDWIN documentation +# in texinfo.) + + +# NB: this is not a self-executing script. You must startup Python, +# import ibrowse, and call ibrowse.main(). On UNIX, the script 'ib' +# runs the browser. + + +# Configuration: +# +# - The pathname of the directory (or directories) containing +# the standard Info files should be set by editing the +# value assigned to INFOPATH in module ifile.py. +# +# - The default font should be set by editing the value of FONT +# in this module (ibrowse.py). +# +# - For fastest I/O, you may look at BLOCKSIZE and a few other +# constants in ifile.py. + + +# This is a fairly large Python program, split in the following modules: +# +# ibrowse.py Main program and user interface. +# This is the only module that imports stdwin. +# +# ifile.py This module knows about the format of Info files. +# It is imported by all of the others. +# +# itags.py This module knows how to read prebuilt tag tables, +# including indirect ones used by large texinfo files. +# +# icache.py Caches tag tables and visited nodes. + + +# XXX There should really be a different tutorial, as the user interface +# XXX differs considerably from Emacs... + + +import sys +import regexp +import stdwin +from stdwinevents import * +import string +from ifile import NoSuchFile, NoSuchNode +import icache + + +# Default font. +# This should be an acceptable argument for stdwin.setfont(); +# on the Mac, this can be a pair (fontname, pointsize), while +# under X11 it should be a standard X11 font name. +# For best results, use a constant width font like Courier; +# many Info files contain tabs that don't align with other text +# unless all characters have the same width. +# +#FONT = ('Monaco', 9) # Mac +FONT = '-schumacher-clean-medium-r-normal--14-140-75-75-c-70-iso8859-1' # X11 + + +# Try not to destroy the list of windows when reload() is used. +# This is useful during debugging, and harmless in production... +# +try: + dummy = windows + del dummy +except NameError: + windows = [] + + +# Default main function -- start at the '(dir)' node. +# +def main(): + start('(dir)') + + +# Start at an arbitrary node. +# The default file is 'ibrowse'. +# +def start(ref): + stdwin.setdefscrollbars(0, 1) + stdwin.setfont(FONT) + stdwin.setdefwinsize(76*stdwin.textwidth('x'), 22*stdwin.lineheight()) + makewindow('ibrowse', ref) + mainloop() + + +# Open a new browser window. +# Arguments specify the default file and a node reference +# (if the node reference specifies a file, the default file is ignored). +# +def makewindow(file, ref): + win = stdwin.open('Info file Browser, by Guido van Rossum') + win.mainmenu = makemainmenu(win) + win.navimenu = makenavimenu(win) + win.textobj = win.textcreate((0, 0), win.getwinsize()) + win.file = file + win.node = '' + win.last = [] + win.pat = '' + win.dispatch = idispatch + win.nodemenu = None + win.footmenu = None + windows.append(win) + imove(win, ref) + +# Create the 'Ibrowse' menu for a new browser window. +# +def makemainmenu(win): + mp = win.menucreate('Ibrowse') + mp.callback = [] + additem(mp, 'New window (clone)', 'K', iclone) + additem(mp, 'Help (tutorial)', 'H', itutor) + additem(mp, 'Command summary', '?', isummary) + additem(mp, 'Close this window', 'W', iclose) + additem(mp, '', '', None) + additem(mp, 'Copy to clipboard', 'C', icopy) + additem(mp, '', '', None) + additem(mp, 'Search regexp...', 'S', isearch) + additem(mp, '', '', None) + additem(mp, 'Reset node cache', '', iresetnodecache) + additem(mp, 'Reset entire cache', '', iresetcache) + additem(mp, '', '', None) + additem(mp, 'Quit', 'Q', iquit) + return mp + +# Create the 'Navigation' menu for a new browser window. +# +def makenavimenu(win): + mp = win.menucreate('Navigation') + mp.callback = [] + additem(mp, 'Menu item...', 'M', imenu) + additem(mp, 'Follow reference...', 'F', ifollow) + additem(mp, 'Go to node...', 'G', igoto) + additem(mp, '', '', None) + additem(mp, 'Next node in tree', 'N', inext) + additem(mp, 'Previous node in tree', 'P', iprev) + additem(mp, 'Up in tree', 'U', iup) + additem(mp, 'Last visited node', 'L', ilast) + additem(mp, 'Top of tree', 'T', itop) + additem(mp, 'Directory node', 'D', idir) + return mp + +# Add an item to a menu, and a function to its list of callbacks. +# (Specifying all in one call is the only way to keep the menu +# and the list of callbacks in synchrony.) +# +def additem(mp, text, shortcut, function): + if shortcut: + mp.additem(text, shortcut) + else: + mp.additem(text) + mp.callback.append(function) + + +# Stdwin event processing main loop. +# Return when there are no windows left. +# Note that windows not in the windows list don't get their events. +# +def mainloop(): + while windows: + event = stdwin.getevent() + if event[1] in windows: + try: + event[1].dispatch(event) + except KeyboardInterrupt: + # The user can type Control-C (or whatever) + # to leave the browser without closing + # the window. Mainly useful for + # debugging. + break + except: + # During debugging, it was annoying if + # every mistake in a callback caused the + # whole browser to crash, hence this + # handler. In a production version + # it may be better to disable this. + # + msg = sys.exc_type + if sys.exc_value: + val = sys.exc_value + if type(val) <> type(''): + val = `val` + msg = msg + ': ' + val + msg = 'Oops, an exception occurred: ' + msg + event = None + stdwin.message(msg) + event = None + + +# Handle one event. The window is taken from the event's window item. +# This function is placed as a method (named 'dispatch') on the window, +# so the main loop will be able to handle windows of a different kind +# as well, as long as they are all placed in the list of windows. +# +def idispatch(event): + type, win, detail = event + if type == WE_CHAR: + if not keybindings.has_key(detail): + detail = string.lower(detail) + if keybindings.has_key(detail): + keybindings[detail](win) + return + if detail in '0123456789': + i = eval(detail) - 1 + if i < 0: i = len(win.menu) + i + if 0 <= i < len(win.menu): + topic, ref = win.menu[i] + imove(win, ref) + return + stdwin.fleep() + return + if type == WE_COMMAND: + if detail == WC_LEFT: + iprev(win) + elif detail == WC_RIGHT: + inext(win) + elif detail == WC_UP: + iup(win) + elif detail == WC_DOWN: + idown(win) + elif detail == WC_BACKSPACE: + ibackward(win) + elif detail == WC_RETURN: + idown(win) + else: + stdwin.fleep() + return + if type == WE_MENU: + mp, item = detail + if mp == None: + pass # A THINK C console menu was selected + elif mp in (win.mainmenu, win.navimenu): + mp.callback[item](win) + elif mp == win.nodemenu: + topic, ref = win.menu[item] + imove(win, ref) + elif mp == win.footmenu: + topic, ref = win.footnotes[item] + imove(win, ref) + return + if type == WE_SIZE: + win.textobj.move((0, 0), win.getwinsize()) + (left, top), (right, bottom) = win.textobj.getrect() + win.setdocsize(0, bottom) + return + if type == WE_CLOSE: + iclose(win) + return + if not win.textobj.event(event): + pass + + +# Paging callbacks + +def ibeginning(win): + win.setorigin(0, 0) + win.textobj.setfocus(0, 0) # To restart searches + +def iforward(win): + lh = stdwin.lineheight() # XXX Should really use the window's... + h, v = win.getorigin() + docwidth, docheight = win.getdocsize() + width, height = win.getwinsize() + if v + height >= docheight: + stdwin.fleep() + return + increment = max(lh, ((height - 2*lh) / lh) * lh) + v = v + increment + win.setorigin(h, v) + +def ibackward(win): + lh = stdwin.lineheight() # XXX Should really use the window's... + h, v = win.getorigin() + if v <= 0: + stdwin.fleep() + return + width, height = win.getwinsize() + increment = max(lh, ((height - 2*lh) / lh) * lh) + v = max(0, v - increment) + win.setorigin(h, v) + + +# Ibrowse menu callbacks + +def iclone(win): + stdwin.setdefwinsize(win.getwinsize()) + makewindow(win.file, win.node) + +def itutor(win): + # The course looks best at 76x22... + stdwin.setdefwinsize(76*stdwin.textwidth('x'), 22*stdwin.lineheight()) + makewindow('ibrowse', 'Help') + +def isummary(win): + stdwin.setdefwinsize(76*stdwin.textwidth('x'), 22*stdwin.lineheight()) + makewindow('ibrowse', 'Summary') + +def iclose(win): + # + # Remove the window from the windows list so the mainloop + # will notice if all windows are gone. + # Delete the textobj since it constitutes a circular reference + # to the window which would prevent it from being closed. + # (Deletion is done by assigning None to avoid crashes + # when closing a half-initialized window.) + # + if win in windows: + windows.remove(win) + win.textobj = None + +def icopy(win): + focustext = win.textobj.getfocustext() + if not focustext: + stdwin.fleep() + else: + stdwin.rotatecutbuffers(1) + stdwin.setcutbuffer(0, focustext) + # XXX Should also set the primary selection... + +def isearch(win): + try: + pat = stdwin.askstr('Search pattern:', win.pat) + except KeyboardInterrupt: + return + if not pat: + pat = win.pat + if not pat: + stdwin.message('No previous pattern') + return + try: + cpat = regexp.compile(pat) + except regexp.error, msg: + stdwin.message('Bad pattern: ' + msg) + return + win.pat = pat + f1, f2 = win.textobj.getfocus() + text = win.text + match = cpat.match(text, f2) + if not match: + stdwin.fleep() + return + a, b = match[0] + win.textobj.setfocus(a, b) + + +def iresetnodecache(win): + icache.resetnodecache() + +def iresetcache(win): + icache.resetcache() + +def iquit(win): + for win in windows[:]: + iclose(win) + + +# Navigation menu callbacks + +def imenu(win): + ichoice(win, 'Menu item (abbreviated):', win.menu, whichmenuitem(win)) + +def ifollow(win): + ichoice(win, 'Follow reference named (abbreviated):', \ + win.footnotes, whichfootnote(win)) + +def igoto(win): + try: + choice = stdwin.askstr('Go to node (full name):', '') + except KeyboardInterrupt: + return + if not choice: + stdwin.message('Sorry, Go to has no default') + return + imove(win, choice) + +def inext(win): + prev, next, up = win.header + if next: + imove(win, next) + else: + stdwin.fleep() + +def iprev(win): + prev, next, up = win.header + if prev: + imove(win, prev) + else: + stdwin.fleep() + +def iup(win): + prev, next, up = win.header + if up: + imove(win, up) + else: + stdwin.fleep() + +def ilast(win): + if not win.last: + stdwin.fleep() + else: + i = len(win.last)-1 + lastnode, lastfocus = win.last[i] + imove(win, lastnode) + if len(win.last) > i+1: + # The move succeeded -- restore the focus + win.textobj.setfocus(lastfocus) + # Delete the stack top even if the move failed, + # else the whole stack would remain unreachable + del win.last[i:] # Delete the entry pushed by imove as well! + +def itop(win): + imove(win, '') + +def idir(win): + imove(win, '(dir)') + + +# Special and generic callbacks + +def idown(win): + if win.menu: + default = whichmenuitem(win) + for topic, ref in win.menu: + if default == topic: + break + else: + topic, ref = win.menu[0] + imove(win, ref) + else: + inext(win) + +def ichoice(win, prompt, list, default): + if not list: + stdwin.fleep() + return + if not default: + topic, ref = list[0] + default = topic + try: + choice = stdwin.askstr(prompt, default) + except KeyboardInterrupt: + return + if not choice: + return + choice = string.lower(choice) + n = len(choice) + for topic, ref in list: + topic = string.lower(topic) + if topic[:n] == choice: + imove(win, ref) + return + stdwin.message('Sorry, no topic matches ' + `choice`) + + +# Follow a reference, in the same window. +# +def imove(win, ref): + savetitle = win.gettitle() + win.settitle('Looking for ' + ref + '...') + # + try: + file, node, header, menu, footnotes, text = \ + icache.get_node(win.file, ref) + except NoSuchFile, file: + win.settitle(savetitle) + stdwin.message(\ + 'Sorry, I can\'t find a file named ' + `file` + '.') + return + except NoSuchNode, node: + win.settitle(savetitle) + stdwin.message(\ + 'Sorry, I can\'t find a node named ' + `node` + '.') + return + # + win.settitle('Found (' + file + ')' + node + '...') + # + if win.file and win.node: + lastnode = '(' + win.file + ')' + win.node + win.last.append(lastnode, win.textobj.getfocus()) + win.file = file + win.node = node + win.header = header + win.menu = menu + win.footnotes = footnotes + win.text = text + # + win.setorigin(0, 0) # Scroll to the beginnning + win.textobj.settext(text) + win.textobj.setfocus(0, 0) + (left, top), (right, bottom) = win.textobj.getrect() + win.setdocsize(0, bottom) + # + if win.footmenu: win.footmenu.close() + if win.nodemenu: win.nodemenu.close() + win.footmenu = None + win.nodemenu = None + # + win.menu = menu + if menu: + win.nodemenu = win.menucreate('Menu') + digit = 1 + for topic, ref in menu: + if digit < 10: + win.nodemenu.additem(topic, `digit`) + else: + win.nodemenu.additem(topic) + digit = digit + 1 + # + win.footnotes = footnotes + if footnotes: + win.footmenu = win.menucreate('Footnotes') + for topic, ref in footnotes: + win.footmenu.additem(topic) + # + win.settitle('(' + win.file + ')' + win.node) + + +# Find menu item at focus +# +findmenu = regexp.compile('^\* [mM]enu:').match +findmenuitem = regexp.compile( \ + '^\* ([^:]+):[ \t]*(:|\([^\t]*\)[^\t,\n.]*|[^:(][^\t,\n.]*)').match +# +def whichmenuitem(win): + if not win.menu: + return '' + match = findmenu(win.text) + if not match: + return '' + a, b = match[0] + i = b + f1, f2 = win.textobj.getfocus() + lastmatch = '' + while i < len(win.text): + match = findmenuitem(win.text, i) + if not match: + break + (a, b), (a1, b1), (a2, b2) = match + if a > f1: + break + lastmatch = win.text[a1:b1] + i = b + return lastmatch + + +# Find footnote at focus +# +findfootnote = \ + regexp.compile('\*[nN]ote ([^:]+):[ \t]*(:|[^:][^\t,\n.]*)').match +# +def whichfootnote(win): + if not win.footnotes: + return '' + i = 0 + f1, f2 = win.textobj.getfocus() + lastmatch = '' + while i < len(win.text): + match = findfootnote(win.text, i) + if not match: + break + (a, b), (a1, b1), (a2, b2) = match + if a > f1: + break + lastmatch = win.text[a1:b1] + i = b + return lastmatch + + +# Now all the "methods" are defined, we can initialize the table +# of key bindings. +# +keybindings = {} + +# Window commands + +keybindings['k'] = iclone +keybindings['h'] = itutor +keybindings['?'] = isummary +keybindings['w'] = iclose + +keybindings['c'] = icopy + +keybindings['s'] = isearch + +keybindings['q'] = iquit + +# Navigation commands + +keybindings['m'] = imenu +keybindings['f'] = ifollow +keybindings['g'] = igoto + +keybindings['n'] = inext +keybindings['p'] = iprev +keybindings['u'] = iup +keybindings['l'] = ilast +keybindings['d'] = idir +keybindings['t'] = itop + +# Paging commands + +keybindings['b'] = ibeginning +keybindings['.'] = ibeginning +keybindings[' '] = iforward diff --git a/Demo/ibrowse/icache.py b/Demo/ibrowse/icache.py new file mode 100755 index 0000000..0629bf9 --- /dev/null +++ b/Demo/ibrowse/icache.py @@ -0,0 +1,74 @@ +# Cache management for info file processing. +# The function get_node() is the standard interface; +# its signature is the same as ifile.get_node() but it uses +# the cache and supports indirect tag tables. + + +import string +import ifile +from ifile import NoSuchNode, NoSuchFile +import itags + + +# Special hack to save the cache when using reload(). +# This can just be "cache = {}" in a production version. +# +try: + dummy = cache + del dummy +except NameError: + cache = {} + + +# Clear the entire cache. +# +def resetcache(): + for key in cache.keys(): + del cache[key] + + +# Clear the node info from the cache (the most voluminous data). +# +def resetnodecache(): + for key in cache.keys(): + tags, nodes = cache[key] + cache[key] = tags, {} + + +# Get a node. +# +def get_node(curfile, ref): + file, node = ifile.parse_ref(curfile, ref) + file = string.lower(file) + node = string.lower(node) + if node == '*': + # Don't cache whole file references; + # reading the data is faster than displaying it anyway. + return ifile.get_whole_file(file) # May raise NoSuchFile + if not cache.has_key(file): + cache[file] = get_tags(file), {} # May raise NoSuchFile + tags, nodes = cache[file] + if not nodes.has_key(node): + if not tags.has_key(node): + raise NoSuchNode, ref + file1, offset, line = tags[node] + if not file1: + file1 = file + file1, node1, header, menu, footnotes, text = \ + ifile.get_file_node(file1, offset, node) + nodes[node] = file, node1, header, menu, footnotes, text + return nodes[node] + + +# Get the tag table for a file. +# Either construct one or get the one found in the file. +# Raise NoSuchFile if the file isn't found. +# +def get_tags(file): + f = ifile.try_open(file) # May raise NoSuchFile + tags = itags.get_tags(f) + if not tags: + ###print 'Scanning file...' + f.seek(0) + tags = ifile.make_tags(f) + return tags diff --git a/Demo/ibrowse/ifile.py b/Demo/ibrowse/ifile.py new file mode 100755 index 0000000..b8d59ee --- /dev/null +++ b/Demo/ibrowse/ifile.py @@ -0,0 +1,328 @@ +# Tools for info file processing. + +# XXX Need to be more careful with reading ahead searching for nodes. + + +import regexp +import string + + +# Exported exceptions. +# +NoSuchFile = 'no such file' +NoSuchNode = 'no such node' + + +# The search path for info files; this is site-specific. +# Directory names should end in a partname delimiter, +# so they can simply be concatenated to a relative pathname. +# +#INFOPATH = ['', ':Info.Ibrowse:', ':Info:'] # Mac +INFOPATH = ['', '/usr/local/emacs/info/'] # X11 on UNIX + + +# Tunable constants. +# +BLOCKSIZE = 512 # Qty to align reads to, if possible +FUZZ = 2*BLOCKSIZE # Qty to back-up before searching for a node +CHUNKSIZE = 4*BLOCKSIZE # Qty to read at once when reading lots of data + + +# Regular expressions used. +# Note that it is essential that Python leaves unrecognized backslash +# escapes in a string so they can be seen by regexp.compile! +# +findheader = regexp.compile('\037\014?\n(.*\n)').match +findescape = regexp.compile('\037').match +parseheader = regexp.compile('[nN]ode:[ \t]*([^\t,\n]*)').match +findfirstline = regexp.compile('^.*\n').match +findnode = regexp.compile('[nN]ode:[ \t]*([^\t,\n]*)').match +findprev = regexp.compile('[pP]rev[ious]*:[ \t]*([^\t,\n]*)').match +findnext = regexp.compile('[nN]ext:[ \t]*([^\t,\n]*)').match +findup = regexp.compile('[uU]p:[ \t]*([^\t,\n]*)').match +findmenu = regexp.compile('^\* [mM]enu:').match +findmenuitem = regexp.compile( \ + '^\* ([^:]+):[ \t]*(:|\([^\t]*\)[^\t,\n.]*|[^:(][^\t,\n.]*)').match +findfootnote = regexp.compile( \ + '\*[nN]ote ([^:]+):[ \t]*(:|[^:][^\t,\n.]*)').match +parsenoderef = regexp.compile('^\((.*)\)(.*)$').match + + +# Get a node and all information pertaining to it. +# This doesn't work if there is an indirect tag table, +# and in general you are better off using icache.get_node() instead. +# Functions get_whole_file() and get_file_node() provide part +# functionality used by icache. +# Raise NoSuchFile or NoSuchNode as appropriate. +# +def get_node(curfile, ref): + file, node = parse_ref(curfile, ref) + if node == '*': + return get_whole_file(file) + else: + return get_file_node(file, 0, node) +# +def get_whole_file(file): + f = try_open(file) # May raise NoSuchFile + text = f.read() + header, menu, footnotes = ('', '', ''), [], [] + return file, '*', header, menu, footnotes, text +# +def get_file_node(file, offset, node): + f = try_open(file) # May raise NoSuchFile + text = find_node(f, offset, node) # May raise NoSuchNode + node, header, menu, footnotes = analyze_node(text) + return file, node, header, menu, footnotes, text + + +# Parse a node reference into a file (possibly default) and node name. +# Possible reference formats are: "NODE", "(FILE)", "(FILE)NODE". +# Default file is the curfile argument; default node is Top. +# A node value of '*' is a special case: the whole file should +# be interpreted (by the caller!) as a single node. +# +def parse_ref(curfile, ref): + match = parsenoderef(ref) + if not match: + file, node = curfile, ref + else: + (a, b), (a1, b1), (a2, b2) = match + file, node = ref[a1:b1], ref[a2:b2] + if not file: + file = curfile # (Is this necessary?) + if not node: + node = 'Top' + return file, node + + +# Extract node name, links, menu and footnotes from the node text. +# +def analyze_node(text): + # + # Get node name and links from the header line + # + match = findfirstline(text) + if match: + (a, b) = match[0] + line = text[a:b] + else: + line = '' + node = get_it(text, findnode) + prev = get_it(text, findprev) + next = get_it(text, findnext) + up = get_it(text, findup) + # + # Get the menu items, if there is a menu + # + menu = [] + match = findmenu(text) + if match: + (a, b) = match[0] + while 1: + match = findmenuitem(text, b) + if not match: + break + (a, b), (a1, b1), (a2, b2) = match + topic, ref = text[a1:b1], text[a2:b2] + if ref == ':': + ref = topic + menu.append(topic, ref) + # + # Get the footnotes + # + footnotes = [] + b = 0 + while 1: + match = findfootnote(text, b) + if not match: + break + (a, b), (a1, b1), (a2, b2) = match + topic, ref = text[a1:b1], text[a2:b2] + if ref == ':': + ref = topic + footnotes.append(topic, ref) + # + return node, (prev, next, up), menu, footnotes +# +def get_it(line, matcher): + match = matcher(line) + if not match: + return '' + else: + (a, b), (a1, b1) = match + return line[a1:b1] + + +# Find a node in an open file. +# The offset (from the tags table) is a hint about the node's position. +# Pass zero if there is no tags table. +# Raise NoSuchNode if the node isn't found. +# NB: This seeks around in the file. +# +def find_node(f, offset, node): + node = string.lower(node) # Just to be sure + # + # Position a little before the given offset, + # so we may find the node even if it has moved around + # in the file a little. + # + offset = max(0, ((offset-FUZZ) / BLOCKSIZE) * BLOCKSIZE) + f.seek(offset) + # + # Loop, hunting for a matching node header. + # + while 1: + buf = f.read(CHUNKSIZE) + if not buf: + break + i = 0 + while 1: + match = findheader(buf, i) + if match: + (a,b), (a1,b1) = match + start = a1 + line = buf[a1:b1] + i = b + match = parseheader(line) + if match: + (a,b), (a1,b1) = match + key = string.lower(line[a1:b1]) + if key == node: + # Got it! Now read the rest. + return read_node(f, buf[start:]) + elif findescape(buf, i): + next = f.read(CHUNKSIZE) + if not next: + break + buf = buf + next + else: + break + # + # If we get here, we didn't find it. Too bad. + # + raise NoSuchNode, node + + +# Finish off getting a node (subroutine for find_node()). +# The node begins at the start of buf and may end in buf; +# if it doesn't end there, read additional data from f. +# +def read_node(f, buf): + i = 0 + match = findescape(buf, i) + while not match: + next = f.read(CHUNKSIZE) + if not next: + end = len(buf) + break + i = len(buf) + buf = buf + next + match = findescape(buf, i) + else: + # Got a match + (a, b) = match[0] + end = a + # Strip trailing newlines + while end > 0 and buf[end-1] == '\n': + end = end-1 + buf = buf[:end] + return buf + + +# Read reverse starting at offset until the beginning of a node is found. +# Then return a buffer containing the beginning of the node, +# with f positioned just after the buffer. +# The buffer will contain at least the full header line of the node; +# the caller should finish off with read_node() if it is the right node. +# (It is also possible that the buffer extends beyond the node!) +# Return an empty string if there is no node before the given offset. +# +def backup_node(f, offset): + start = max(0, ((offset-CHUNKSIZE) / BLOCKSIZE) * BLOCKSIZE) + end = offset + while start < end: + f.seek(start) + buf = f.read(end-start) + i = 0 + hit = -1 + while 1: + match = findheader(buf, i) + if match: + (a,b), (a1,b1) = match + hit = a1 + i = b + elif end < offset and findescape(buf, i): + next = f.read(min(offset-end, BLOCKSIZE)) + if not next: + break + buf = buf + next + end = end + len(next) + else: + break + if hit >= 0: + return buf[hit:] + end = start + start = max(0, end - CHUNKSIZE) + return '' + + +# Make a tag table for the given file by scanning the file. +# The file must be open for reading, and positioned at the beginning +# (or wherever the hunt for tags must begin; it is read till the end). +# +def make_tags(f): + tags = {} + while 1: + offset = f.tell() + buf = f.read(CHUNKSIZE) + if not buf: + break + i = 0 + while 1: + match = findheader(buf, i) + if match: + (a,b), (a1,b1) = match + start = offset+a1 + line = buf[a1:b1] + i = b + match = parseheader(line) + if match: + (a,b), (a1,b1) = match + key = string.lower(line[a1:b1]) + if tags.has_key(key): + print 'Duplicate node:', + print key + tags[key] = '', start, line + elif findescape(buf, i): + next = f.read(CHUNKSIZE) + if not next: + break + buf = buf + next + else: + break + return tags + + +# Try to open a file, return a file object if succeeds. +# Raise NoSuchFile if the file can't be opened. +# Should treat absolute pathnames special. +# +def try_open(file): + for dir in INFOPATH: + try: + return open(dir + file, 'r') + except IOError: + pass + raise NoSuchFile, file + + +# A little test for the speed of make_tags(). +# +TESTFILE = 'texinfo-1' +def test_make_tags(): + import time + f = try_open(TESTFILE) + t1 = time.time() + tags = make_tags(f) + t2 = time.time() + print 'Making tag table for', `TESTFILE`, 'took', t2-t1, 'sec.' diff --git a/Demo/ibrowse/itags.py b/Demo/ibrowse/itags.py new file mode 100755 index 0000000..f30f3fd --- /dev/null +++ b/Demo/ibrowse/itags.py @@ -0,0 +1,127 @@ +# Utility module for 'icache.py': interpret tag tables and indirect nodes. + +# (This module is a bit chatty when confronted with the unexpected.) + + +import regexp +import string +import ifile + + +# Get the tag table of an open file, as a dictionary. +# Seeks around in the file; after reading, the position is undefined. +# Return an empty tag table if none is found. +# +def get_tags(f): + # + # First see if the last "node" is the end of tag table marker. + # + f.seek(0, 2) # Seek to EOF + end = f.tell() + buf = ifile.backup_node(f, end) + if not labelmatch(buf, 0, 'end tag table\n'): + return {} # No succes + # + # Next backup to the previous "node" -- the tag table itself. + # + ###print 'Getting prebuilt tag table...' + end = f.tell() - len(buf) + buf = ifile.backup_node(f, end) + label = 'tag table:\n' + if not labelmatch(buf, 0, label): + print 'Weird: end tag table marker but no tag table?' + print 'Node begins:', `buf[:50]` + return {} + # + # Now read the whole tag table. + # + end = f.tell() - len(buf) # Do this first! + buf = ifile.read_node(f, buf) + # + # First check for an indirection table. + # + indirlist = [] + if labelmatch(buf, len(label), '(indirect)\n'): + indirbuf = ifile.backup_node(f, end) + if not labelmatch(indirbuf, 0, 'indirect:\n'): + print 'Weird: promised indirection table not found' + print 'Node begins:', `indirbuf[:50]` + # Carry on. Things probably won't work though. + else: + indirbuf = ifile.read_node(f, indirbuf) + indirlist = parse_indirlist(indirbuf) + # + # Now parse the tag table. + # + findtag = regexp.compile('^(.*[nN]ode:[ \t]*(.*))\177([0-9]+)$').match + i = 0 + tags = {} + while 1: + match = findtag(buf, i) + if not match: + break + (a,b), (a1,b1), (a2,b2), (a3,b3) = match + i = b + line = buf[a1:b1] + node = string.lower(buf[a2:b2]) + offset = eval(buf[a3:b3]) # XXX What if it overflows? + if tags.has_key(node): + print 'Duplicate key in tag table:', `node` + file, offset = map_offset(offset, indirlist) + tags[node] = file, offset, line + # + return tags + + +# Return true if buf[i:] begins with a label, after lower case conversion. +# The label argument must be in lower case. +# +def labelmatch(buf, i, label): + return string.lower(buf[i:i+len(label)]) == label + + +# Parse the indirection list. +# Return a list of (filename, offset) pairs ready for use. +# +def parse_indirlist(buf): + list = [] + findindir = regexp.compile('^(.+):[ \t]*([0-9]+)$').match + i = 0 + while 1: + match = findindir(buf, i) + if not match: + break + (a,b), (a1,b1), (a2,b2) = match + file = buf[a1:b1] + offset = eval(buf[a2:b2]) # XXX What if this gets overflow? + list.append(file, offset) + i = b + return list + + +# Map an offset through the indirection list. +# Return (filename, new_offset). +# If the list is empty, return the given offset and an empty file name. +# +def map_offset(offset, indirlist): + if not indirlist: + return '', offset + # + # XXX This could be done more elegant. + # + filex, offx = indirlist[0] + for i in range(len(indirlist)): + file1, off1 = indirlist[i] + if i+1 >= len(indirlist): + file2, off2 = '', 0x7fffffff + else: + file2, off2 = indirlist[i+1] + if off1 <= offset < off2: + # Add offx+2 to compensate for extra header. + # No idea whether this is always correct. + return file1, offset-off1 + offx+2 + # + # XXX Shouldn't get here. + # + print 'Oops, map_offset fell through' + return '', offset # Not likely to get good results |