diff options
Diffstat (limited to 'src/hyper/spadint.pamphlet')
| -rw-r--r-- | src/hyper/spadint.pamphlet | 1289 |
1 files changed, 1289 insertions, 0 deletions
diff --git a/src/hyper/spadint.pamphlet b/src/hyper/spadint.pamphlet new file mode 100644 index 00000000..0c0869e6 --- /dev/null +++ b/src/hyper/spadint.pamphlet @@ -0,0 +1,1289 @@ +\documentclass{article} +\usepackage{axiom} +\begin{document} +\title{\$SPAD/src/spadint} +\author{The Axiom Team} +\maketitle +\begin{abstract} +\end{abstract} +\eject +\tableofcontents +\eject +\section{spadint.c} +<<spadint.c>>= +/* Still a problem with close_client */ + +/* Communication interface for external AXIOM buffers */ +#define _SPADINT_C +#include "axiom-c-macros.h" +#include "useproto.h" +#include "debug.h" + +#include <signal.h> + +#include "hyper.h" +#include "cond.h" +#include "mem.h" +#include "parse.h" +#include "bsdsignal.h" + +#include "all_hyper_proto.H1" +#include "sockio-c.H1" +#include "bsdsignal.H1" + + +typedef struct sock_list { /* linked list of Sock */ + Sock Socket; + struct sock_list *next; +} Sock_List; + +Sock_List *plSock = (Sock_List *) 0; +Sock *spad_socket = (Sock *) 0; /* to_server socket for SpadServer */ + +/* issue a AXIOM command to the buffer associated with a page */ +void +issue_spadcommand(HyperDocPage *page, TextNode *command, int immediate, + int type) +{ + char *buf; + int ret_val; + + ret_val = connect_spad(); + if (ret_val == NotConnected || ret_val == SpadBusy) + return; + + if (page->sock == NULL) + start_user_buffer(page); + ret_val = send_int(page->sock, TestLine); + if (ret_val == -1) { + page->sock = NULL; + clear_execution_marks(page->depend_hash); + issue_spadcommand(page, command, immediate, type); + return; + } + issue_dependent_commands(page, command, type); + ret_val = send_int(page->sock, ReceiveInputLine); + buf = print_to_string(command); + if (immediate) { + buf[strlen(buf) + 1] = '\0'; + buf[strlen(buf)] = '\n'; + } + if (type == Spadsrc) + send_pile(page->sock, buf); + else + send_string(page->sock, buf); + mark_as_executed(page, command, type); + gIsEndOfOutput = 0; +} +static void +send_pile(Sock *sock,char * str) +{ + FILE *f; + char name[512], command[512]; + + sprintf(name, "/tmp/hyper%s.input", getenv("SPADNUM")); + f = fopen(name, "w"); + if (f == NULL) { + fprintf(stderr, "Can't open temporary input file %s\n", name); + return; + } + fprintf(f, "%s", str); + fclose(f); + sprintf(command, ")read %s\n", name); + send_string(sock, command); +} +static void +issue_dependent_commands(HyperDocPage *page, TextNode *command,int type) +{ + TextNode *node, *depend_label; + SpadcomDepend *depend; + int end_type = (type == Spadcommand || type == Spadgraph) ? + (Endspadcommand) : (Endspadsrc); + + for (node = command->next; node->type != end_type; + node = node->next) + if (node->type == Free) + for (depend_label = node->data.node; depend_label != NULL; + depend_label = depend_label->next) + if (depend_label->type == Word) { + depend = (SpadcomDepend *) + hash_find(page->depend_hash, depend_label->data.text); + if (depend == NULL) { + fprintf(stderr, "Error: dependency on undefined label: %s\n", + depend_label->data.text); + continue; + } + if (!depend->executed) { + issue_spadcommand(page, depend->spadcom->next, 1, + depend->spadcom->type); + while (!gIsEndOfOutput) + pause(); + sleep(1); + } + } +} +static void +mark_as_executed(HyperDocPage *page, TextNode *command,int type) +{ + TextNode *node, *depend_label; + SpadcomDepend *depend; + int end_type = (type == Spadcommand || type == Spadgraph) + ? (Endspadcommand) : (Endspadsrc); + + for (node = command; node->type != end_type; node = node->next) + if (node->type == Bound) + for (depend_label = node->data.node; depend_label != NULL; + depend_label = depend_label->next) + if (depend_label->type == Word) { + depend = (SpadcomDepend *) + hash_find(page->depend_hash, depend_label->data.text); + if (depend == NULL) { + fprintf(stderr, "No dependency entry for label: %s\n", + depend_label->data.text); + continue; + } + depend->executed = 1; + } +} + +/* start a spad buffer for the page associated with the give */ +static void +start_user_buffer(HyperDocPage *page) +{ + char buf[1024], *title; + char *SPAD; + char spadbuf[250]; + char complfile[250]; + int ret_val; + + SPAD = (char *) getenv("AXIOM"); + if (SPAD == NULL) { + sprintf(SPAD, "/spad/mnt/rios"); + } + sprintf(spadbuf, "%s/lib/spadbuf", SPAD); + sprintf(complfile, "%s/lib/command.list", SPAD); + title = print_to_string(page->title); + if (access(complfile, R_OK) == 0) + + /* + * TTT says : why not invoke with "-name axiomclient" and set any + * defaults in the usual way + */ +#ifdef RIOSplatform + sprintf(buf, + "aixterm -sb -sl 500 -name axiomclient -n '%s' -T '%s' -e %s %s %s&", + title, title, spadbuf, page->name, complfile); + else + sprintf(buf, + "aixterm -sb -sl 500 -name axiomclient -n '%s' -T '%s' -e %s %s&", + title, title, spadbuf, page->name); +#else +#ifdef SUNplatform + sprintf(buf, + "xterm -sb -sl 500 -name axiomclient -n '%s' -T '%s' -e %s %s %s&", + title, title, spadbuf, page->name, complfile); + else + sprintf(buf, + "xterm -sb -sl 500 -name axiomclient -n '%s' -T '%s' -e %s %s&", + title, title, spadbuf, page->name); +#else + sprintf(buf, + "xterm -sb -sl 500 -name axiomclient -n '%s' -T '%s' -e %s %s %s&", + title, title, spadbuf, page->name, complfile); + else + sprintf(buf, + "xterm -sb -sl 500 -name axiomclient -n '%s' -T '%s' -e %s '%s'&", + title, title, spadbuf, page->name); +#endif +#endif + ret_val = system(buf); + if (ret_val == -1 || ret_val == 127) { + + /* + * perror("running the xterm spadbuf program"); exit(-1); + */ + } + accept_menu_server_connection(page); + sleep(2); +} + +/* Clears the execution marks in a hash table when a buffer has been killed */ +static void +clear_execution_marks(HashTable *depend_hash) +{ + int i; + HashEntry *h; + SpadcomDepend *depend; + + if (depend_hash == 0) + return; + for (i = 0; i < depend_hash->size; i++) + for (h = depend_hash->table[i]; h != NULL; h = h->next) { + depend = (SpadcomDepend *) h->data; + depend->executed = 0; + } +} + +Sock * +accept_menu_connection(Sock *server_sock) +{ + int sock_fd /*, session, ret_code*/; + Sock_List *pls; + /*Sock local_sock;*/ + + /* Could only be InterpWindow */ + + pls = (Sock_List *) halloc(sizeof(Sock_List),"SockList"); + sock_fd = accept(server_sock->socket, 0, 0); + if (sock_fd == -1) { + perror("session : accepting connection"); + return 0; + } + (pls->Socket).socket = sock_fd; + get_socket_type((Sock *) pls); + +#ifdef DEBUG + fprintf(stderr, + "session: accepted InterpWindow , fd = %d\n", sock_fd); +#endif + + + /* put new item at head of list */ + + if (plSock == (Sock_List *) 0) { + plSock = pls; + plSock->next = (Sock_List *) 0; + } + else { + pls->next = plSock; + plSock = pls; + } + + /* need to maintain socket_mask since we roll our own accept */ + + FD_SET(plSock->Socket.socket, &socket_mask); + return (Sock *) plSock; +} + +static void +accept_menu_server_connection(HyperDocPage *page) +{ + + /* + * TTT thinks this code should just provide a Sock to the page. The only + * client assumed is a spadbuf. Since spadbuf was invoked with the page + * name, it just passes it back here as a check (get_string line). + */ + int ret_code/*, i*/; + fd_set rd; + Sock *sock; + char *buf_name; + HyperDocPage *npage; + + if (page->sock != NULL) + return; + while (1) { + rd = server_mask; + ret_code = sselect(FD_SETSIZE, &rd, 0, 0, NULL); + if (ret_code == -1) { + perror("Session manager select"); + continue; + } + + if (server[1].socket > 0 && FD_ISSET(server[1].socket, &rd)) { + sock = accept_menu_connection(server + 1); + if (sock == 0) + return; + if (sock->purpose == InterpWindow) { + buf_name = get_string(sock); + npage = (HyperDocPage *) + hash_find(gWindow->fPageHashTable, buf_name); + if (npage == NULL) { + + /* + * Lets just try using the current page TTT doesn't know + * why this could be detrimental + * + * fprintf(stderr, "connecting spadbuf to unknown page: + * %s\n", buf_name); + */ + page->sock = sock; + return; + } + else { + + /* + * For some reason npage and page may be different TTT + * thinks this happens when a dynamic page has the same + * name as an existing static page. + */ + npage->sock = sock; + page->sock = sock; + } + if (!strcmp(buf_name, page->name)) { + return; + } + } + } + } +} + + +/* + * This procedure takes a HyperDoc node, and expands it into string + */ + +char *p2sBuf = NULL; +int p2sBufSize = 0; + +/* + * This routine takes a text node and creates a string out of it. This is for + * use with things such as spad commands. There are a very limited set of + * node types it can handle, so be careful + */ + +char * +print_to_string(TextNode *command) +{ + int len = 0; + + print_to_string1(command, &len); + p2sBuf = resizeBuffer(len, p2sBuf, &p2sBufSize); + return print_to_string1(command, NULL); +} + +/* +see the code in ht-util.boot + $funnyQuote := char 127 + $funnyBacks := char 128 +*/ +#define funnyEscape(c) ((c) == '"' ? '\177' : ((c) == '\\' ? '\200' : c)) +#define funnyUnescape(c) ((c) == '\177' ? '"' : ((c) == '\200' ? '\\' : c)) +#define storeChar(ch) if (sizeBuf) (*sizeBuf)++; else *c++ = (ch) +#define storeString(str) for (s=str;*s;s++) {storeChar(*s);} + +extern int include_bf; + +char * +print_to_string1(TextNode *command,int * sizeBuf) +{ + char *c = p2sBuf; + char *s; + InputItem *item; + LineStruct *curr_line; + int lcount; + InputBox *box; + int num_spaces; + int count; + TextNode *node; + + /* + * Init the stack of text nodes, things are pushed on here when I trace + * through a nodes data.node. This way I always no where my next is. + */ + + for (node = command; node != NULL;) { + switch (node->type) { + case Newline: + storeChar('\n'); + node = node->next; + break; + case Ifcond: + if (check_condition(node->data.ifnode->cond)) + node = node->data.ifnode->thennode; + else + node = node->data.ifnode->elsenode; + break; + case Endarg: + case Endspadcommand: + case Endspadsrc: + case Endpix: + storeChar('\0'); + return p2sBuf; + case Endverbatim: + case Endif: + case Fi: + case Endmacro: + case Endparameter: + case Rbrace: + case Endgroup: + node = node->next; + break; + case Punctuation: + + /* + * Simply copy the piece of text + */ + if (node->space & FRONTSPACE) { storeChar(' '); } + for (s = node->data.text; *s; s++) { storeChar(*s); } + node = node->next; + break; + case WindowId: + + /* + * Simply copy the piece of text + */ + if (node->space) { storeChar(' '); } + for (s = node->data.text; *s; s++) { storeChar(*s); } + storeChar(' '); + node = node->next; + break; + case Verbatim: + case Spadsrctxt: + + /* + * Simply copy the piece of text + */ + if (node->space) { storeChar(' '); } + for (s = node->data.text; *s; s++) { storeChar(*s); } + + /* + * now add the eol + */ + + /* + * if(node->next && node->next->type != Endspadsrc) + * storeChar('\n'); + */ + node = node->next; + break; + case Dash: + case Rsquarebrace: + case Lsquarebrace: + case Word: + + /* + * Simply copy the piece of text + */ + if (node->space) { storeChar(' '); } + for (s = node->data.text; *s; s++) { storeChar(*s); } + node = node->next; + break; + case BoxValue: + box = + (InputBox *) hash_find(gWindow->page->box_hash, node->data.text); + if (box == NULL) { + fprintf(stderr, + "Print_to_string:Box %s Has no symbol table entry\n", + node->data.text); + exit(-1); + } + storeChar(' '); + if (box->picked) { + storeChar('t'); + } + else { + storeChar('n'); + storeChar('i'); + storeChar('l'); + } + node = node->next; + break; + case StringValue: + item = return_item(node->data.text); + if (item != NULL) { + if (node->space) + storeChar(' '); + curr_line = item->lines; + while (curr_line != NULL) { + for (lcount = 0, s = curr_line->buffer; *s && lcount < item->size; + s++, lcount++) { + storeChar(funnyUnescape(*s)); + } + if (curr_line->len <= item->size && curr_line->next) + storeChar('\n'); + curr_line = curr_line->next; + } + } + else if ((box = (InputBox *) hash_find(gWindow->page->box_hash, + node->data.text)) != NULL) { + if (node->space) { storeChar(' '); } + if (box->picked) { + storeChar('t'); + } + else { + storeChar('n'); + storeChar('i'); + storeChar('l'); + } + } + else { + fprintf(stderr, "Error, Symbol %s has no symbol table entry\n", + node->data.text); + exit(-1); + } + node = node->next; + break; + case Space: + num_spaces = (node->data.node != NULL ? + atoi(node->data.node->data.text) : 1); + for (count = 0; count < num_spaces; count++) + storeChar(' '); + node = node->next; + break; + case Titlenode: + case Endtitle: + case Center: + case Endcenter: + case BoldFace: + case Emphasize: + case Indentrel: + node = node->next; + break; + case Bound: + if (include_bf) { + int len, i; + TextNode *n2 = node->data.node; + + storeChar('\\'); + storeChar('b'); + storeChar('o'); + storeChar('u'); + storeChar('n'); + storeChar('d'); + storeChar('{'); + for (; n2->type != Endarg; n2 = n2->next) { + if (n2->type == Word) { + len = strlen(n2->data.text); + for (i = 0; i < len; i++) + storeChar(n2->data.text[i]); + storeChar(' '); + } + } + storeChar('}'); + } + node = node->next; + break; + case Free: + if (include_bf) { + int len, i; + TextNode *n2 = node->data.node; + + storeChar('\\'); + storeChar('f'); + storeChar('r'); + storeChar('e'); + storeChar('e'); + storeChar('{'); + for (; n2->type != Endarg; n2 = n2->next) { + if (n2->type == Word) { + len = strlen(n2->data.text); + for (i = 0; i < len; i++) + storeChar(n2->data.text[i]); + storeChar(' '); + } + } + storeChar('}'); + } + node = node->next; + break; + case Macro: + node = node->next; + break; + case Pound: + if (node->space) { storeChar(' '); } + node = node->next; + break; + case Group: + node = node->next; + break; + case Indent: + num_spaces = (node->data.node != NULL ? + atoi(node->data.node->data.text) : 1); + for (count = 0; count < num_spaces; count++) + storeChar(' '); + node = node->next; + break; + default: + fprintf(stderr, + "Print_to_string: Unrecognized Keyword Type %d\n", + node->type); + node=node->next; + break; + } + } + storeChar('\0'); + return p2sBuf; +} + +/* + * Send a lisp or spad command to the AXIOM server for execution , if + * type is link, then we wait for a HyperDoc card to be returned + */ + +HyperDocPage * +issue_server_command(HyperLink *link) +{ + TextNode *command = (TextNode *) link->reference.node; + int ret_val; + char *buf; + HyperDocPage *page; + + ret_val = connect_spad(); + if (ret_val == NotConnected) { + page = (HyperDocPage *) hash_find(gWindow->fPageHashTable, "SpadNotConnectedPage"); + if (page == NULL) + fprintf(stderr, "No SpadNotConnectedPage found\n"); + return page; + } + if (ret_val == SpadBusy) { + page = (HyperDocPage *) hash_find(gWindow->fPageHashTable, "SpadBusyPage"); + if (page == NULL) + fprintf(stderr, "No SpadBusyPage found\n"); + return page; + } + switch_frames(); + switch (link->type) { + case Qspadcall: + case Qspadcallquit: + case Spadlink: + case Spaddownlink: + case Spadmemolink: + send_int(spad_socket, QuietSpadCommand); + break; + case Spadcall: + case Spadcallquit: + send_int(spad_socket, SpadCommand); + break; + default: + send_int(spad_socket, LispCommand); + break; + } + buf = print_to_string(command); + send_string(spad_socket, buf); + if (link->type == Lispcommand || link->type == Spadcall + || link->type == Spadcallquit || link->type == Qspadcallquit + || link->type == Qspadcall || link->type == Lispcommandquit) + return NULL; + page = parse_page_from_socket(); + return page; +} + +int +issue_serverpaste(TextNode *command) +{ + char *buf; + int ret_val; + + ret_val = connect_spad(); + if (ret_val == NotConnected || ret_val == SpadBusy) + return 1; + switch_frames(); + send_int(spad_socket, LispCommand); + buf = print_to_string(command); + send_string(spad_socket, buf); + return 1; +} + +/* + * issue a unix command + */ +void +issue_unixcommand(TextNode *node) +{ + char *buf; + char *copy; + + + buf = print_to_string(node); + copy =(char *) halloc((strlen(buf)+2)*sizeof(char),"Unixcommand"); + strcpy(copy,buf); + copy[strlen(buf) + 1] = '\0'; + copy[strlen(buf)] = '&'; + system(copy); + free(copy); + return; +} + +HyperDocPage * +issue_unixlink(TextNode *node) +{ + HyperDocPage *page; + char *buf; + + buf = print_to_string(node); + if ((unixfd = popen(buf, "r")) == NULL) { + fprintf(stderr, "Error popening %s\n", buf); + exit(-1); + } + bsdSignal(SIGUSR2,SIG_IGN,0); + page = parse_page_from_unixfd(); + bsdSignal(SIGUSR2,sigusr2_handler,0); + return page; +} + +int +issue_unixpaste(TextNode *node) +{ + char *buf; + + buf = print_to_string(node); + if ((unixfd = popen(buf, "r")) == NULL) { + fprintf(stderr, "Error popening %s\n", buf); + exit(-1); + } + return 1; +} + + +/* + * called when session_server selects + */ +void +service_session_socket(void) +{ + int cmd, pid; + + cmd = get_int(session_server); + switch (cmd) { + case CloseClient: + pid = get_int(session_server); + if (pid != -1) + close_client(pid); + break; + default: + fprintf(stderr, + "(HyperDoc) Unknown command from SessionServer %d\n", cmd); + break; + } +} + + +/* + * let spad know which frame to issue command via + */ +static void +switch_frames(void) +{ + if (session_server == NULL) { + fprintf(stderr, "(HyperDoc) No session manager connected!\n"); + return; + } + if (gWindow->fAxiomFrame == -1) { + fprintf(stderr, "(HyperDoc) No AXIOM frame associated with top level window!\n"); + return; + } + send_int(session_server, SwitchFrames); + send_int(session_server, gWindow->fAxiomFrame); +} +void +send_lisp_command(char *command) +{ + int ret_val; + + ret_val = connect_spad(); + if (ret_val == NotConnected || ret_val == SpadBusy) { + return; + } + send_int(spad_socket, LispCommand); + send_string(spad_socket, command); +} +void +escape_string(char *s) +{ + char *st; + + for (st = s; *st; st++) + *st = funnyEscape(*st); +} +void +unescape_string(char *s) +{ + char *st; + + for (st = s; *st; st++) + *st = funnyUnescape(*st); +} +static void +close_client(int pid) +{ + /*int i;*/ + Sock_List *pSock, *locSock; + + /* + * just need to drop the list item + */ + + if (plSock == (Sock_List *) 0) + return; + + /* + * first check head + */ + + if ((plSock->Socket.pid == pid)) { + locSock = plSock; + if ((*plSock).next == (Sock_List *) 0) { + plSock = (Sock_List *) 0; + } + else { + plSock = plSock->next; + } + free(locSock); + } + + /* + * now check the rest + */ + + else { + for (pSock = plSock; pSock->next != (Sock_List *) 0; pSock = pSock->next) + if (pSock->next->Socket.pid == pid) { + locSock = pSock->next; + if (pSock->next->next == (Sock_List *) 0) { + pSock->next = (Sock_List *) 0; + } + else { + pSock->next = pSock->next->next; + } + free(locSock); + break; + } + } +} + + + +char * +print_source_to_string(TextNode *command) +{ + int len = 0; + + print_source_to_string1(command, &len); + p2sBuf = resizeBuffer(len, p2sBuf, &p2sBufSize); + return print_source_to_string1(command, NULL); +} +char * +print_source_to_string1(TextNode *command,int * sizeBuf) +{ + char *c = p2sBuf; + char *s; + InputItem *item; + LineStruct *curr_line; + int lcount; + InputBox *box; + int num_spaces; + int count; + TextNode *node; + + /* + print out HyperDoc source for what you see + */ + + for (node = command; node != NULL;) { + switch (node->type) { + case Newline: + storeString("\\newline\n"); + node = node->next; + break; + case Par: + storeString("\n\n"); + node = node->next; + break; + case Indentrel: + storeString("\\indentrel{"); + storeString(node->data.node->data.text); + storeChar('}'); + node = node->next; + break; + case Tab: + storeString("\\tab{"); + storeString(node->data.node->data.text); + storeChar('}'); + node = node->next; + break; + case Ifcond: + if (check_condition(node->data.ifnode->cond)) + node = node->data.ifnode->thennode; + else + node = node->data.ifnode->elsenode; + break; + case Endarg: + case Endspadsrc: + case Endpix: + case Endbutton: + storeChar('}'); + node = node->next; + break; + case Endverbatim: + case Endif: + case Fi: + case Endmacro: + case Endparameter: + case Rbrace: + node = node->next; + break; + case Punctuation: + + /* + * Simply copy the piece of text + */ + if (node->space & FRONTSPACE) { storeChar(' '); } + for (s = node->data.text; *s; s++) { storeChar(*s); } + node = node->next; + break; + case WindowId: + storeString("\\windowid "); + node = node->next; + break; + case Verbatim: + case Spadsrctxt: + if (node->space) { storeChar(' '); } + for (s = node->data.text; *s; s++) { storeChar(*s); } + node = node->next; + break; + case Dash: + case Rsquarebrace: + case Lsquarebrace: + case Word: + if (node->space) { storeChar(' '); } + for (s = node->data.text; *s; s++) { storeChar(*s); } + node = node->next; + break; + case BoxValue: + box = (InputBox *) hash_find(gWindow->page->box_hash, node->data.text); + if (box == NULL) { + fprintf(stderr, "Print_to_string:Box %s Has no symbol table entry\n", + node->data.text); + exit(-1); + } + storeChar(' '); + if (box->picked) { + storeChar('t'); + } + else { + storeChar('n'); + storeChar('i'); + storeChar('l'); + } + node = node->next; + break; + case StringValue: + item = return_item(node->data.text); + if (item != NULL) { + if (node->space) { storeChar(' '); } + curr_line = item->lines; + while (curr_line != NULL) { + for (lcount = 0, s = curr_line->buffer; + *s && lcount < item->size; + s++, lcount++) { + storeChar(funnyUnescape(*s)); + } + if (curr_line->len <= item->size && curr_line->next) + storeChar('\n'); + curr_line = curr_line->next; + } + } + else if ((box = (InputBox *) hash_find(gWindow->page->box_hash, + node->data.text)) != NULL) { + if (node->space) { storeChar(' '); } + if (box->picked) { + storeChar('t'); + } + else { + storeChar('n'); + storeChar('i'); + storeChar('l'); + } + } + else { + fprintf(stderr, "Error, Symbol %s has no symbol table entry\n", + node->data.text); + exit(-1); + } + node = node->next; + break; + case Space: + num_spaces = (node->data.node != NULL ? + atoi(node->data.node->data.text) : 1); + for (count = 0; count < num_spaces; count++) + storeChar(' '); + node = node->next; + break; + case Emphasize: + storeString("\\em "); + node = node->next; + break; + case BoldFace: + storeString("\\bf "); + node = node->next; + break; + case Sl: + storeString("\\it "); + node = node->next; + break; + case Rm: + storeString("\\rm "); + node = node->next; + break; + case It: + storeString("\\it "); + node = node->next; + break; + case Tt: + storeString("\\tt "); + node = node->next; + break; + case Group: +/* skip {} */ + if (node->next->type==Endgroup){ + node=node->next->next; + break; + } + storeChar('{'); + node = node->next; + break; + case Endgroup: + storeChar('}'); + node = node->next; + break; + case Box: + storeString("\\box{"); + node = node->next; + break; + case Endbox: + storeChar('}'); + node = node->next; + break; + case Center: + storeString("\\center{"); + node = node->next; + break; + case Endcenter: + storeString("}"); + storeChar('\n'); + node = node->next; + break; + case Titlenode: + case Endtitle: + node = node->next; + break; + case Bound: + { + TextNode *n2 = node->data.node; + + storeString("\\bound{"); + for (; n2->type != Endarg; n2 = n2->next) { + if (n2->type == Word) { + storeString(n2->data.text); + storeChar(' '); + } + } + storeChar('}'); + } + node = node->next; + break; + case Free: + { + TextNode *n2 = node->data.node; + + storeString("\\free{"); + for (; n2->type != Endarg; n2 = n2->next) { + if (n2->type == Word) { + storeString(n2->data.text); + storeChar(' '); + } + } + storeChar('}'); + } + node = node->next; + break; + case Macro: + storeChar(' '); + node = node->next; + break; + case Pound: + if (node->space) { storeChar(' '); } + node = node->next; + break; + case Indent: + num_spaces = (node->data.node != NULL ? + atoi(node->data.node->data.text) : 1); + for (count = 0; count < num_spaces; count++) + storeChar(' '); + node = node->next; + break; + case Inputbitmap: + storeString("\\inputbitmap{"); + storeString(node->data.text); + storeString("}\n"); + node = node->next; + break; + case Endscrolling: + storeString("\\end{scroll}\n"); + node = node->next; + break; + case Scrollingnode: + storeString("\\begin{scroll}\n"); + storeString("% This is the scrolling area\n"); + node = node->next; + break; + case Horizontalline: + storeString("\\horizontalline\n"); + node = node->next; + break; + case Endtable: + storeChar('}'); + node = node->next; + break; + case Table: + storeString("\\table{"); + node = node->next; + break; + case Tableitem: + storeChar('{'); + node = node->next; + break; + case Endtableitem: + storeChar('}'); + node = node->next; + break; + case Beginitems: + storeString("\\begin{items}"); + node = node->next; + break; + case Item: + storeString("\n\\item"); + node = node->next; + break; + case Enditems: + storeString("\n\\end{items}"); + node = node->next; + break; +/*** LINKS ***/ +/* all these guys are ended by Endbutton +we close the brace then */ + case Spadlink: + storeString("\\fauxspadlink{"); + node = node->next; + break; + case Unixlink: + storeString("\\fauxunixlink{"); + node = node->next; + break; + case Lisplink: + storeString("\\fauxlisplink{"); + node = node->next; + break; + case Link: + storeString("\\fauxlink{"); + node = node->next; + break; + case LispDownLink: + storeString("\\fauxlispdownlink{"); + node = node->next; + break; + case LispMemoLink: + storeString("\\fauxlispmemolink{"); + node = node->next; + break; + case Memolink: + storeString("\\fauxmemolink{"); + node = node->next; + break; + case Windowlink: + storeString("\\fauxwindowlink{"); + node = node->next; + break; + case Downlink: + storeString("\\fauxdownlink{"); + node = node->next; + break; +/** END OF LINKS **/ + case Unixcommand: + storeString("\\unixcommand{"); + node = node->next; + break; + case Lispcommand: + storeString("\\lispcommand{"); + node = node->next; + break; + case Spadgraph: + storeString("\\spadgraph{"); + node = node->next; + break; + case Spadcommand: + storeString("\\spadcommand{"); + node = node->next; + break; + case Endspadcommand: + storeChar('}'); + node = node->next; + break; + case Footernode: + storeString("% This is the footer\n"); + node = node->next; + break; + case Endfooter: + storeString("% This is the end of the footer\n"); + node = node->next; + break; + case Endheader: + storeString("% This is the end of the header\n"); + node = node->next; + break; + case Headernode: + storeString("% This is the header\n"); + node = node->next; + break; + default: + fprintf(stderr, + "Print_to_string: Unrecognized Keyword Type %d\n", + node->type); + node=node->next; + break; + } + } + storeChar('\0'); + return p2sBuf; +} +@ +\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>> +<<spadint.c>> +@ +\eject +\begin{thebibliography}{99} +\bibitem{1} nothing +\end{thebibliography} +\end{document} + + + + |