diff options
Diffstat (limited to 'src/hyper/hyper.pamphlet')
| -rw-r--r-- | src/hyper/hyper.pamphlet | 1078 |
1 files changed, 1078 insertions, 0 deletions
diff --git a/src/hyper/hyper.pamphlet b/src/hyper/hyper.pamphlet new file mode 100644 index 00000000..3e407d07 --- /dev/null +++ b/src/hyper/hyper.pamphlet @@ -0,0 +1,1078 @@ +\documentclass{article} +\usepackage{axiom} +\begin{document} +\title{\$SPAD/src/hyper} +\author{The Axiom Team} +\maketitle +\begin{abstract} +\end{abstract} +\eject +\tableofcontents +\eject +\section{hyper.h} +The [[hypertex]] function, of which this is the top level, is a browser +for Axiom information. It works off a database of pages. The pages are +stored in the [[$AXIOM/share/hypertex/pages]] subdirectory and there is +a key file called [[ht.db]] in that subdirectory which contains +critical information about each page. If you add or delete pages you +must rerun the [[htadd]] command. +(See the [[htadd]] command in [[src/hyper/htadd.pamphlet]].) + +Generally, if you add or delete pages you can recreate a proper +[[pages/ht.db]] file by doing: +\begin{verbatim} +cd $AXIOM/share/hypertex +htadd -f pages -n pages/* +\end{verbatim} + + +The [[hypertex]] function looks in [[$AXIOM/share/hypertex/pages]] by +default. This can be over-ridden by setting the [[HTPATH]] shell +variable to point to the desired directory containing the pages and +the ht.db file. +<<hyper.h>>= +<<license>> +#ifndef _HYPER_H_ +#define _HYPER_H_ 1 + +#include "axiom-c-macros.h" +#include <stdio.h> +#include <stdlib.h> +#include <unistd.h> +#include <limits.h> + +#include <X11/Xlib.h> +#include <X11/Xutil.h> +#include <X11/Xos.h> + +#include "com.h" +#include "token.h" +#include "hash.h" + +#define boolean unsigned short int + +#ifndef TRUE +#define TRUE ((boolean) 0x1) +#endif +#ifndef FALSE +#define FALSE ((boolean) 0x0) +#endif + +/* Struct forward declarations */ + +struct text_node; +struct input_box; +struct input_window; +struct paste_node; +struct radio_boxes; +struct group_item; + +#define Scrollupbutton 1 +#define Scrolldownbutton 2 +#define Noopbutton 6 + +#define Scrolling 1 +#define Header 2 +#define Footer 3 +#define Title 4 + +#ifndef HTADD +extern int MenuServerOpened; + +/* These are all the colors one can use in HyperDoc. */ + +extern int gActiveColor, + gAxiomColor, + gBackgroundColor, + gBfColor, + gControlBackgroundColor, + gControlForegroundColor, + gEmColor, + gInputBackgroundColor, + gInputForegroundColor, + gItColor, + gRmColor, + gSlColor, + gTtColor; + +/* These are all the different fonts one can use in HyperDoc. */ + +extern XFontStruct *gActiveFont, + *gAxiomFont, + *gBfFont, + *gEmFont, + *gInputFont, + *gItFont, + *gRmFont, + *gSlFont, + *gTitleFont, + *gTtFont; + + +#endif + + +/** I am implementing a state node stack, this is the structure I store **/ + +typedef struct state_node { + int last_ch, last_token, input_type; + long fpos, keyword_fpos; + long page_start_fpos; + Token token; + char *input_string; + FILE *cfile; + int keyword; + struct state_node *next; +} StateNode; + +#ifndef HTADD +/** pointer to the top of the state node graph **/ +extern StateNode *top_state_node; +#endif + + +/* structure for a hyper text link */ +typedef struct hyper_link { + int type; /* Memolink, Spadlink, Downlink etc. */ + Window win; /* X11 window containing active area */ + union { + struct text_node *node; /* ID of link to which link refers */ + struct input_box *box; + struct input_window *string; + struct paste_node *paste; /* the paste node area */ + } reference; + int x,y; /* relative position inside page */ +} HyperLink; + + +typedef struct if_node { + struct text_node *cond; /* the condition nodes*/ + struct text_node *thennode; + struct text_node *elsenode; +} IfNode; + +typedef struct item_stack { + int indent; + int item_indent; + int in_item; + struct item_stack *next; +} ItemStack; + +typedef struct paste_node { + char *name; + int where; /* where should I be parsing from? */ + short int hasbutton; + short int haspaste; + struct group_item *group; + ItemStack *item_stack; + struct text_node *arg_node; + struct text_node *end_node; + struct text_node *begin_node; + struct input_window *paste_item; +} PasteNode; + +/* Structure for formatted hypertext */ + +typedef struct text_node { + short type; /* type of node (text, link, etc.) */ + int x,y, width, height; /* relative location on screen */ + int space; /* was there space in front of me ? */ + union { + char *text; /* piece of text to display */ + struct text_node *node; /* argument text */ + struct if_node *ifnode; + } data; + HyperLink *link; /* link for active text */ + union { + Pixmap pm; /* pixmap for bit images */ + XImage *xi; /* pixmap image */ + } image; + struct text_node *next; /* next node in formatted text */ +} TextNode; + +/** Structure used to store pixmaps and bitmaps **/ + +typedef struct image_struct { + int width,height; /** It's width and height **/ + union { + Pixmap pm; + XImage *xi; + } image; + char *filename; /** The filename used to reference it **/ +} ImageStruct; + +/* Structure for locating HyperDoc pages in a source file */ + +typedef struct { + char *name; /* file name */ + long pos; /* position in file */ + int ln; /* the line number */ +} FilePosition; + +/*** The structure needed for storing a macro **/ + +typedef struct macro_store { + short int loaded; + FilePosition fpos; + char *name; + char *macro_string; + short number_parameters; +} MacroStore; + + +/** Structure needed for storing a patch **/ +typedef struct patch_store { + short int loaded; + FilePosition fpos; + char *name; + char *string; +} PatchStore; + +/* Here are the structures needed for doing input to HyperDoc windows. */ + +typedef struct line_struct { + char *buffer; + int changed; /* Has the line changed */ + int line_number; + int buff_pntr; + int len; + struct line_struct *prev, *next; +} LineStruct; + +typedef struct input_window { + char *name; /* symbol name **/ + int size; /* the length of the window **/ + int cursor_x; /* x-coordinate for the cursor **/ + int entered; /* tells me whether I have typed here + before */ + int num_lines; /* number of lines needed to store + buffer */ + LineStruct *lines; + LineStruct *curr_line; /* the current line on which the cursor */ + Window win; + struct input_window *next; +} InputItem; + + +/* structure for storing input boxes **/ +typedef struct input_box { + char *name; + ImageStruct *selected, *unselected; + short int picked; + struct input_box *next; + struct radio_boxes *rbs; + Window win; +} InputBox; + +typedef struct radio_boxes { + char *name; + InputBox *boxes; + ImageStruct *selected, *unselected; + int width, height; + struct radio_boxes *next; +} RadioBoxes; + +/* Structure for spadcommand dependencies hash table entries */ +typedef struct spadcom_depend { + char *label; /* dependency label */ + TextNode *spadcom; /* spadcommand defining the label */ + short executed; /* true iff spadcommand has benn executed */ +} SpadcomDepend; + +typedef struct button_list { + int x0,y0,x1,y1; + HyperLink *link; + Window win; + struct button_list *next; +} ButtonList; + +/* Stucture for unformatted hyper text page */ + +typedef struct hyperdoc_page { + short type; /* Normal, Quitbutton, Upbutton etc. */ + char *name; /* ID of page */ + char *filename; /* The name of the file in which the page + occurs, Null if not */ + int scroll_off; /* The offset in the scrolling region */ + int bot_scroll_margin; /* bottom of the scrolling region */ + int top_scroll_margin; /* top of the scrolling region */ + TextNode *title; /* the title of the page */ + TextNode *header; /* formatted version of page */ + TextNode *scrolling; /* Top of scrolling region */ + TextNode *footer; /* top of non-scrolling region at bottom */ + Sock *sock; /* socket connection for spad buffer */ + HashTable *fLinkHashTable; /* active link hash table */ + ButtonList *s_button_list; /* active buttons on page */ + ButtonList *button_list; /* active buttons on page */ + HashTable *depend_hash; /* Hash tables of spadcommand dependencies */ + InputItem *input_list; /* List of input structures */ + InputItem *current_item; /* a pntr to the currently active item */ + HashTable *box_hash; /* place where all the boxes are stored */ + RadioBoxes *radio_boxes; /* a linked list of radio boxes */ + short page_flags; /* A list of flags for the page */ + char *helppage; /* the name of the helppage */ +} HyperDocPage; + +/* Structure for an unloaded page */ + +typedef struct unloaded_page { + short type; /* indicator of unloaded page */ + char *name; /* name of page */ + FilePosition fpos; /* where to find the page */ +} UnloadedPage; + +/* Structure for a HyperDoc Window */ + +typedef struct { + Window fMainWindow; /* The main text field window. */ + Window fScrollWindow; /* The scrolling area of the window */ + Window fDisplayedWindow; /* The current window of the above two, */ + /* being filled by display */ + + Window fScrollUpWindow; /* Window for scrolling up a line */ + Window fScrollDownWindow; /* Window for scrolling down a line */ + + Window scrollbar; /* the window for scrolling */ + Window scroller; /* the scroller window */ + + Window fTitleBarButton1; /* 1st titlebar bitmap button */ + Window fTitleBarButton2; /* 2nd titlebar bitmap button */ + Window fTitleBarButton3; /* 3rd titlebar bitmap button */ + Window fTitleBarButton4; /* 4th titlebar bitmap button */ + + int fScrollerTopPos; /* where the top of the scroller is */ + int fScrollerHeight; /* the height of the scroller */ + int fScrollBarHeight; /* the height for the scrollbar */ + + int scrollwidth; /* the width of the scrolling area */ + int scrollheight; /* the height of the scrolling area */ + int scrollupy; /* Current y position of the scroll up */ + /* button */ + int scrolldowny; /* Current y position of the scroll */ + /* downbutton */ + int scrollbary; /* Current y position of teh scrollbar */ + int scrollx; /* X coordinates for all of the above */ + int border_width; /* Width of the border */ + HyperDocPage *page; /* currently displayed page */ + int width, height; /* in pixels */ + int columns; /* Width in characters, only setable */ + /* for form pages */ + HyperDocPage **fMemoStack; /* stack of memo links */ + HyperDocPage **fDownLinkStack;/* stack of down links */ + + int *fDownLinkStackTop; /* stack of down links */ + int fMemoStackIndex; /* memo stack pointer */ + int fDownLinkStackIndex; /* downlink stack pointer */ + + HashTable *fWindowHashTable; /* hash table of active subwindows */ + HashTable *fPageHashTable; /* hash table of HyperDoc pages */ + HashTable *fPasteHashTable; /* hash table for paste in areas */ + HashTable *fMacroHashTable; /* hash table of HyperDoc macros */ + HashTable *fCondHashTable; /* hash table for values */ + HashTable *fPatchHashTable; /* hash table for patch locations */ + + int fAxiomFrame; /* Axiom frame number initializing window */ + GC fStandardGC; /* Graphics context for window */ + GC fInputGC; /* Graphics context for the input windows */ + GC fCursorGC; /* Graphics context for the cursors */ + GC fControlGC; /* Graphics context for the buttons */ + Cursor fDisplayedCursor; /* The currently displayed cursor */ +} HDWindow; + +/* Structure for identifying appropriate link hash tables */ + +typedef struct { + int code; /* code of active area */ + HyperDocPage *page; /* page for which hash table applies */ +} LinkHashID; + +/*** Flags for the page ***/ + +#define NOLINES 0000001 /* Ibid, for the bottom of the page ***/ + + +/* external variables and functions. See the source file for a description + of their purposes */ + +extern HashTable gSessionHashTable; /* hash table of HD windows */ + +extern HDWindow *gParentWindow; /* the parent window. The one that + * appears when you first start HD */ + +extern HyperLink *quitLink; /** a special link to the protected quit page **/ + + +#ifndef HTADD +/* From hyper.c */ +extern int gXScreenNumber; +extern Display *gXDisplay; +extern int gSwitch_to_mono; +extern unsigned long * spadColors; +extern int gIsEndOfOutput; +extern HDWindow *gWindow; +extern Sock *session_server; +extern Sock *spad_socket; +extern HashTable gFileHashTable; +extern HashTable gImageHashTable; /* A global hash table for images */ +extern Cursor gNormalCursor; /* The normal mouse cursor */ +extern Cursor gActiveCursor; /* The cursor in active regions */ +extern Cursor gBusyCursor; /* The clock cursor for when I am busy */ +extern int gIsAxiomServer; /* true iff HyperDoc is acting as an Axiom server */ +extern int gArgc; /* original argc from main */ +extern char **gArgv; /* original argv from main */ +/* from lex.c */ +extern long fpos, keyword_fpos; +extern Token token; +extern int last_token, input_type, last_ch; +extern char *input_string; +extern FILE *cfile; +/* from input.c */ +extern XImage *picked; +extern int picked_height; +extern int picked_width; +extern XImage *unpicked; +extern int unpicked_height; +extern int unpicked_width; +/* from display.c */ +extern int line_height; +extern int need_scroll_up_button; +extern int scrolling; +extern int need_scroll_down_button; +extern int space_width; +#endif + +/* Here are some of the functions and constants declared and needed in + htadd.c ******/ + +#define NoChar -9999 +#define temp_dir "/tmp/" +#define db_file_name "ht.db" +#define def_spad "/usr/local/axiom" + + +/* Types of HyperDoc pages */ + +#define UlUnknownPage 9993 /*I hate this hack, but I have to know whether*/ +#define UnknownPage 9994 /*this page has been loaded or not. */ +#define ErrorPage 9995 +#define Unixfd 9996 +#define SpadGen 9997 +#define Normal 9998 +#define UnloadedPageType 9999 + +/* Commands from Axiom */ + +#define EndOfPage 99 +#define SendLine 98 +#define StartPage 97 /* A normal HyperDoc page */ +#define LinkToPage 96 +#define PopUpPage 95 /* A pop-up page */ +#define PopUpNamedPage 94 +#define KillPage 93 +#define ReplacePage 92 +#define ReplaceNamedPage 91 +#define SpadError 90 + +/* Constants declaring size of page stacks */ + +#define MaxMemoDepth 25 /* max nesting level for memolinks */ +#define MaxDownlinkDepth 50 /* max downlink nesting depth */ + +/* Constants defining the size of various hash tables */ + +#define PageHashSize 1000 +#define FileHashSize 30 +#define SessionHashSize 10 +#define MacroHashSize 100 +#define ImageHashSize 100 +#define CondHashSize 100 +#define BoxHashSize 20 +#define PasteHashSize 100 +#define PatchHashSize 100 + +/* A couple of macros for memo and down links */ + +#define need_up_button \ + (gWindow->fMemoStackIndex ? gWindow->fDownLinkStackIndex >= \ + gWindow->fDownLinkStackTop[gWindow->fMemoStackIndex-1] \ + : gWindow->fDownLinkStackIndex) + +#define need_return_button (gWindow->fMemoStackIndex) + +#define need_help_button (gWindow->page->helppage != NULL) + +#define max(x,y) ((x) > (y) ? (x) : (y)) + + +#define pick_box(box) fill_box(box->win, box->selected) +#define unpick_box(box) fill_box(box->win, box->unselected) + +#define TopLevelHelpPage "ugHyperPage" +#define NoMoreHelpPage "NoMoreHelpPage" +#define KeyDefsHelpPage "ugHyperKeysPage" +#define InputAreaHelpPage "ugHyperInputPage" + +/* definitions for connecting to the Axiom server */ + +#define Connected 0 +#define NotConnected 1 +#define SpadBusy 2 + +/* some GUI-dependent stuff */ + +#define BeepAtTheUser() /* (XBell(gXDisplay, 5)) */ +#define LoudBeepAtTheUser() /* (XBell(gXDisplay, 50)) */ + + +/*** default fonts ***/ + +#if defined(RTplatform) || defined(PS2platform) || defined(RIOSplatform) || defined(AIX370platform) +#define RmFontDefault "Rom14" +#define TtFontDefault "Erg14" +#define ActiveFontDefault "Bld14" +#define AxiomFontDefault "Erg14" +#define EmphasizeFontDefault "Itl14" +#define BoldFontDefault "Bld14" +#endif + +#if defined(SUNplatform) || defined (SUN4OS5platform) || defined(SGIplatform) || defined (HP9platform) || defined(HP10platform) || defined (ALPHAplatform) || defined(LINUXplatform) || defined(MACOSXplatform) || defined(BSDplatform) +#define RmFontDefault "-adobe-courier-medium-r-normal--18-*-*-*-m-*-iso8859-1" +#define TtFontDefault "-adobe-courier-medium-r-normal--18-*-*-*-m-*-iso8859-1" +#define ActiveFontDefault "-adobe-courier-bold-r-normal--18-*-*-*-m-*-iso8859-1" +#define AxiomFontDefault "-adobe-courier-bold-o-normal--18-*-*-*-m-*-iso8859-1" +#define EmphasizeFontDefault "-adobe-courier-medium-o-normal--18-*-*-*-m-*-iso8859-1" +#define BoldFontDefault "-adobe-courier-bold-r-normal--18-*-*-*-m-*-iso8859-1" +#endif + + + + + + +typedef struct group_item { + int cur_color; + XFontStruct *cur_font; + int center; + struct group_item *next; +} GroupItem; + + +extern GroupItem *gTopOfGroupStack; + + +typedef struct cond_node { + char *label; + char *cond; +} CondNode; + +typedef struct parameter_list_type { + char **list; /** The parameters in string form **/ + short number; /** How many parameters are there **/ + struct parameter_list_type *next; +} *ParameterList; + +#endif +@ +\section{hyper.c} +<<hyper.c>>= +/* + * This is the main module of the HyperDoc program. It contains the main + * routine which initializes all the X stuff, and the tables. Then it passes + * control over to the main event loop. + */ + +/* #define DEBUG 1 */ + +/* Include all the needed include files */ +#define _HYPER_C +#include "useproto.h" +#include "debug.h" + + +#include "hyper.h" + +#include <sys/signal.h> +#include <sys/types.h> +#include <sys/wait.h> +#include <setjmp.h> +#include <X11/cursorfont.h> + +#include "keyin.h" +#include "initx.h" +#include "event.h" +#include "parse-aux.h" +#include "bsdsignal.h" + +#include "all_hyper_proto.H1" +#include "sockio-c.H1" +#include "bsdsignal.H1" +/* + * Here is a flag used to tell me whether I made a good connection to the + * menu server. Needed so I don't send spad commands when I should not + */ + +int MenuServerOpened = 1; + +/* include icon bitmap data */ + +#define BITMAPDEPTH 1 + +/* X11 display and screen variables */ + +Display *gXDisplay; +int gXScreenNumber; + +/* + * Information about the top level HyperDoc window + */ + +HDWindow *gWindow = NULL; /* the current window */ +HDWindow *gParentWindow =NULL; /* the parent window. The one that appears + * when you first start HyperDoc */ + +HashTable gSessionHashTable; /* hash table of HD windows */ +HashTable init_page_hash; /* initial hash table of HD pages */ +HashTable init_macro_hash; /* initial hash table of HD macros */ +HashTable init_patch_hash; /* initial hash table of HD patches */ + +/* The various Cursors we use */ + +Cursor gNormalCursor; /* The normal mouse cursor */ +Cursor gActiveCursor; /* The cursor in active regions */ +Cursor gBusyCursor; /* The clock cursor for when I am busy */ + + +HashTable gFileHashTable; /* hash table of HyperDoc files */ +HashTable gImageHashTable; /* hash table for images */ + + +/* Some things needed for Handling interupts properly */ + +int gIsEndOfOutput; /* set to true when spad has finished output */ +int received_window_request = 0;/* true iff Spad wants a pop-up */ +int in_next_event = 0; /* true when in XNextEvent */ +int make_input_file = 0; /* true when making input files from ht */ +int make_patch_files = 0; /* true when making patch files from ht */ +int gmake_record_file= 0; /* true when making record files from ht */ +int gverify_record_file = 0; /* true when verifying record files from ht */ +int gverify_dates = 0; /* true when we want hypertex to verify ht.db dates */ + +Sock *session_server; /* socket connecting to session manager */ + +int gIsAxiomServer = 0; /* true iff HyperDoc is acting as a */ + /* an Axiom server */ + +int kill_spad = 0; /* kill spad when finished with paste file */ + +int gSwitch_to_mono=0; /* will be set to 1 if at any time we don't have + enough colours for the images. We will know this + when read_pixmap_file returns -1. We will use this + when deciding what to do in case of \inputimage */ + +int gTtFontIs850=0; /* a flag that tells us if the Tt font is a IBM pagecode 850 + font and hence supports the graphics chars + set when the TtFont is opened*/ + +/* + * Global copies of the command line arguments, so they never have to be + * passed as parameters. This is also so any child process starting up also + * has the same values. + */ + +int gArgc; +char **gArgv; + +char **input_file_list; +int input_file_count; + +/* + * SIGUSR2 is raised by the spadbuf program when it is done with the current + * command + */ + +void +sigusr2_handler(int sig) +{ + gIsEndOfOutput = 1; + return ; +} + +void +sigcld_handler(int sig) +{ + + /* why were we waiting after the child had already died ?? + because we don't want zombies */ + + int x; + wait(&x); + +} + +extern jmp_buf env; + + +/* Clean up spad sockets on exit */ +void +clean_socket(void ) +{ + char name[256]; + + make_server_name(name, MenuServerName); + unlink(name); +} + +/* + * initialize hash tables, signal handlers and windows, then call the main + * event handling loop + */ + +int +main(int argc, char **argv) +{ + int ret_status; + + /* Initialize some global values */ +/* fprintf(stderr,"hyper:main:entered\n");*/ + gArgc = argc; + gArgv = argv; + gIsEndOfOutput = 1; + +/* fprintf(stderr,"hyper:main:calling check_arguments\n");*/ + check_arguments(); +/* fprintf(stderr,"hyper:main:returned check_arguments\n");*/ + + /* + * initialize the hash tables for the files and the windows and images + */ +/* fprintf(stderr,"hyper:main:calling init_hash\n");*/ + init_hash(); +/* fprintf(stderr,"hyper:main:returned init_hash\n");*/ + + /* + * initialize the parser keyword hash table + */ +/* fprintf(stderr,"hyper:main:calling parser_init\n");*/ + parser_init(); +/* fprintf(stderr,"hyper:main:returned parser_init\n");*/ + +/* fprintf(stderr,"hyper:main:calling read_ht_db\n");*/ + read_ht_db(&init_page_hash, &init_macro_hash, &init_patch_hash); +/* fprintf(stderr,"hyper:main:returned read_ht_db\n");*/ + + /* + * Now initialize x. This includes opening the display, setting the + * screen and display global values, and also gets all the fonts and + * colors we will need. + */ + + if (!make_input_file && !gmake_record_file && !gverify_record_file) { +/* fprintf(stderr,"hyper:main:calling initializeWindowSystem\n");*/ + initializeWindowSystem(); +/* fprintf(stderr,"hyper:main:returned initializeWindowSystem\n");*/ + + /* + * Initialize some of the global values used by the input string + * routines + */ +/* fprintf(stderr,"hyper:main:calling init_keyin\n");*/ + init_keyin(); +/* fprintf(stderr,"hyper:main:returned init_keyin\n");*/ + + /* + * regardless of what else happened, we should always pop up an + * initial window. + */ + +/* fprintf(stderr,"hyper:main:calling init_top_window\n");*/ + ret_status = init_top_window("RootPage"); +/* fprintf(stderr,"hyper:main:returned init_top_window\n");*/ + gParentWindow = gWindow; + if (ret_status == -1) { + fprintf(stderr, + "(HyperDoc) Could not find RootPage for top-level window.\n"); + exit(-1); + } + + /* + * Tell it how to handle the user defined signals I may get + */ + bsdSignal(SIGUSR2, sigusr2_handler,RestartSystemCalls); + bsdSignal(SIGUSR1, SIG_IGN,RestartSystemCalls); +#if defined(BSDplatform) || defined(MACOSXplatform) + bsdSignal(SIGCHLD, sigcld_handler,RestartSystemCalls); +#else + bsdSignal(SIGCLD, sigcld_handler,RestartSystemCalls); +#endif + bsdSignal(SIGINT, SIG_IGN,RestartSystemCalls); + + /* + * Now go to the main event loop. I will never return, so just end + * the main routine after that + */ + + /* + * make an input file if requested + */ + } + else { + + /* + * Try to establish all the socket connections I need. If I am an + * gIsAxiomServer and the routine fails, it will exit for me + */ +/* fprintf(stderr,"hyper:main:in else case\n");*/ +/* fprintf(stderr,"hyper:main:calling make_server_connections\n");*/ + make_server_connections(); +/* fprintf(stderr,"hyper:main:returned make_server_connections\n");*/ + + + if (make_input_file) ht2_input(); + if (gmake_record_file) make_record(); + if (gverify_record_file) verify_record(); + exit(0); + } + + /* + * Try to establish all the socket connections I need. If I am an + * gIsAxiomServer and the routine fails, it will exit for me + */ +/* fprintf(stderr,"hyper:main:calling make_server_connections\n");*/ + make_server_connections(); +/* fprintf(stderr,"hyper:main:returned make_server_connections\n");*/ + + +/* fprintf(stderr,"hyper:main:calling mainEventLoop\n");*/ + mainEventLoop(); +/* fprintf(stderr,"hyper:main:returned mainEventLoop\n");*/ + + return 0; +} + +/* + * Initializes the hash table for Files, and Windows + */ + +static void +init_hash(void) +{ + hash_init(&gFileHashTable, + FileHashSize, + (EqualFunction)string_equal, + (HashcodeFunction) string_hash); + hash_init(&gSessionHashTable, + SessionHashSize, + (EqualFunction) window_equal, + (HashcodeFunction) window_code); + hash_init(&gImageHashTable, + ImageHashSize, + (EqualFunction) string_equal, + (HashcodeFunction) string_hash); +} + +/* initialize the HyperDoc page hierarchy data structures */ + +void +init_page_structs(HDWindow *w) +{ + int i; + + w->fMemoStackIndex = 0; + for (i = 0; i < MaxMemoDepth; i++) { + w->fMemoStack[i] = NULL; + w->fDownLinkStackTop[i] = 0; + } + w->fDownLinkStackIndex = 0; + for (i = 0; i < MaxDownlinkDepth; i++) + w->fDownLinkStack[i] = NULL; +} + +static void +check_arguments(void) +{ + int i; + + /* + * Now check the command line arguments, to see if I am supposed to be a + * server or not + */ + for (i = 1; i < gArgc; i++) { + if (gArgv[i][0] == '-') + switch (gArgv[i][1]) { + case 'p': + gverify_dates=1; + break; + case 's': + if (!MenuServerOpened) { + fprintf(stderr, "(HyperDoc) Server already in use.\n"); + exit(-1); + } + gIsAxiomServer = 1; + break; + case 'i': + if (gArgv[i][2] == 'p') + make_patch_files = 1; + make_input_file = 1; + input_file_list = gArgv + i + 1; + input_file_count = gArgc - i - 1; + break; + case 'k': + kill_spad = 1; + break; + case 'r': + if (gArgv[i][2] == 'm') + gmake_record_file=1; + else if (gArgv[i][2] == 'v') + gverify_record_file=1; + else + fprintf(stderr, "(HyperDoc) v or m must follow -r\n"); + input_file_list = gArgv + i + 1; + input_file_count = gArgc - i - 1; + break; + default: + fprintf(stderr, "(HyperDoc) Unexpected Command Line Argument %s\n", gArgv[i]); + fprintf(stderr, " Usage: hypertex [-s]\n"); + break; + } + } +} + +static void +make_server_connections(void) +{ + int i, wait_time; + + /* + * Try to open the menuserver socket, if I can not, then set a flag + */ + + if (open_server(MenuServerName) == -2) { + fprintf(stderr, "(HyperDoc) Warning: Not connected to AXIOM Server!\n"); + MenuServerOpened = 0; + } + else + MenuServerOpened = 1; + + + /* + * If I have opened the MenuServer socket, then I should also try to open + * the SpadServer socket, so I can send stuff right to SPAD. + */ + + if (MenuServerOpened) { + + /* + * If I am a ht server, then I should not continue on unless I + * establish some sort of connection + */ + + /* + * Modified on 11/20 so that it prints an error message every ten for + * ten tries at opeing the socket. If it fails all ten times, it + * gives up and exits. + */ + + if (!gIsAxiomServer) + wait_time = 2; + else + wait_time = 1000; + + for (i = 0, spad_socket = NULL; i < 2 && spad_socket == NULL; i++) { + spad_socket = connect_to_local_server(SpadServer, + MenuServer, wait_time); + if (gIsAxiomServer && spad_socket == NULL) + fprintf(stderr, "(HyperDoc) Error opening AXIOM server. Retrying ...\n"); + else + i = 11; + } + if (! spad_socket) { + fprintf(stderr, "(HyperDoc) Couldn't connect to AXIOM server!\n"); + if (!gIsAxiomServer) + MenuServerOpened = 0; + else { + fprintf(stderr, "(HyperDoc) Couldn't connect to AXIOM server!\n"); + exit(-1); + } + } + else { + + /* + * Do the same thing for the SessionServer + */ + + for (i = 0, session_server = NULL; i < 2 && session_server == NULL + ; i++) { + session_server = + connect_to_local_server(SessionServer, MenuServer, + wait_time); + if (gIsAxiomServer && session_server == NULL) { + fprintf(stderr, + "(HyperDoc) Error opening SessionServer, Retrying ...\n"); + } + else + i = 11; + } + if (session_server == NULL) { + fprintf(stderr, "(HyperDoc) Connection attempt to session manager timed out.\n"); + if (gIsAxiomServer) { + fprintf(stderr, + "(HyperDoc) Server unable to connect to session server\n"); + exit(-1); + } + else { + MenuServerOpened = 0; + } + } + } + } +} +@ +\section{License} +<<license>>= +/* +Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + - Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + - Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in + the documentation and/or other materials provided with the + distribution. + + - Neither the name of The Numerical ALgorithms Group Ltd. nor the + names of its contributors may be used to endorse or promote products + derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS +IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED +TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER +OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +@ +<<*>>= +<<license>> +<<hyper.c>> +@ +\eject +\begin{thebibliography}{99} +\bibitem{1} nothing +\end{thebibliography} +\end{document} + + + + |