Usenet 1994 October/usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso/unix/volume26/cforms/part02

LaTeX Document | 1992-05-18 | 39KB | 1,140 lines

Newsgroups: comp.sources.unix
From: [e-mail] (Lars Berntzon)
Subject: v26i057: cforms - forms management front end for curses(3), Part02/03
Sender: [e-mail]
Approved: [e-mail]
Submitted-By: [e-mail] (Lars Berntzon)
Posting-Number: Volume 26, Issue 57
Archive-Name: cforms/part02
#! /bin/sh
# This is a shell archive.  Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file".  To overwrite existing
# files, type "sh file -c".  You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g..  If this archive is complete, you
# will see the following message at the end:
#        "End of archive 2 (of 3)."
# Contents:  doc/cforms.tex src/get_field.c src/output.c src/token.c
# Wrapped by [e-mail] on Tue May 19 19:14:29 1992
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'doc/cforms.tex' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'doc/cforms.tex'\"
echo shar: Extracting \"'doc/cforms.tex'\" \(13964 characters\)
sed "s/^X//" >'doc/cforms.tex' <<'END_OF_FILE'
X% LATEX Documentation for CForms
X% By Lars Berntzon
X% $Log:    cforms.tex,v $
X% Revision 1.2  92/01/25  18:08:54  lasse
X% Adde how to compile
X% Revision 1.1  92/01/19  12:41:08  lasse
X% Initial revision
X\newcommand{\synopsys}[1]{\verb!\newline
XSynopsys: {#1}!
X\documentstyle{article}
X\title{CForms v 1.0}
X\author{Lars Berntzon, E-Mail: [e-mail]}
X\begin{document}
X\maketitle
X\section{Introduction}
X    CForms is a formular manager for building applications to be used for
X    many types of terminals though it uses the {\em curses} library.
X    CForms is built up by a language that consists of the objects: modules,
X    pictures, fields, literals and events.
X    An application is built by one or more modules that contains one or more
X    pictures that handles the various functions in the application.
X    Each picture may contain any number of fields and text literal
X    that describes the appearance of the picture.
X    Fields are defined by their name and may be specified with any type,
X    size, special attributes and event handling functions.
X    CForms may be intermixed with C-code modules in any way.
X\section{Language description}
X     Currently you can only have one module (file) with CForms language,
X    but i plan to make a CForms 'linker' and thus make it possible to
X    have multiple files.
X    The language is not case sensitive exept thoose parts
X    that are pure C-code (in events- and ccode statements).
X\subsection{Viewports}
X    To create a picture you first need to create a viewport, wich
X    describes the size and position on the real screen where the picture
X    should appear. A viewport is defined by its name, wich later should
X    be referenced in the picture. Several pictures may share the same
X    viewport.
X    Syntax for a viewport is:
X    \begin{verbatim}
X        VIEWPORT <name> {
X            POS <column>, <row>;
X            SIZE <width>, <height>;
X        }
X    \end{verbatim}
X    Example:
X    \begin{verbatim}
X        Viewport stdscreen {
X            Pos 1,1;
X            Size 80, 24;
X        }
X    \end{verbatim}
X\subsection{CCode}
X    The CCode statement introduces a C-code block that may contain any
X    code such as global variables, functions, preprocessor statements.
X    This means that there is no need to have separated form-files and
X    C-files with support functions. Ccodes may only be used in outer
X    scopes, i.e. not inside pictures, literals or fields.
X    Syntax for Ccode is:
X        \begin{verbatim}
X        CCODE {
X            <Any C code>
X        }
X        \end{verbatim}
X    Example:
X        \begin{verbatim}
X        CCode {
X            cleanup()
X            {
X                free_all_mem();
X                cforms_end();
X                exit();
X            }
X        }
X        \end{verbatim}
X\subsection{Pictures}
X    A picture is what shows up on the terminal when the application is
X    running. Pictures contains fields - which are places for input or
X    output, literals - which are static texts and events -
X    events doesn't show but defines C-code functions to be called when
X    certain things happens. Events specified in pictures are actually
X    used by fields, but they are automatically specified for all fields
X    in that pictures (unless specifically turned off), in other worlds a
X    default event for all fields.
X    A pictures is defined by its name, and the first picture to be started
X    in the application is determined in the main routine (or a descendant)
X    through the function {\em pic\_call}.
X    Syntax for a picture is:
X    \begin{verbatim}
X        PICTURE <picture-name> VIEWPORT <viewport-name> {
X            <literals>   \
X            <fields>      > in any order
X            <events>     /
X        }
X    \end{verbatim}
X    Example:
X    \begin{verbatim}
X        Picture main Viewport stdscreen {
X            Literal 10, 10, "Welcome, enter your name: ";
X            Field Name {
X                Pos +0, +1;
X                Type Char(10);
X            }
X        }
X    \end{verbatim}
X\subsection{Fields}
X    Fields are placesholders in pictures that may be used to input from
X    operator and/or as output from the application. A field may be of
X    many kind of types and sizes. Fields can also contain events that
X    will be called when the specified event occurs. It is also possible
X    to specify literal text to appear immediately before and immediately
X    after the actual field, this makes it possible to have text belonging
X    to fields that are not depending of the fields position.
X    The position of a field may be specified in absolute- or relative
X    coordinates. For relative coordinates the column- and row number is
X    prepended by a minus or a plus sign to indikate positive or negative
X    relative position.
X    Finally it is possible to specify a couple of modifiers for the field that
X    modifies adjustment, visibility, protection e.t.c.
X    Valid types for a field is:
X    \begin{itemize}
X       \item{INT} Field may only contain digits.
X       \item{STR} Field may only contain alphanumeric characters.
X       \item{CHAR} Field may contain any printable character.
X    \end{itemize}
X    The size of a field is by default 1, but may be altered as a number
X    within brackets after the type.
X    Valid modifiers are:
X    \begin{itemize}
X        \item{PROTECTED}    - Field may not be altered.
X        \item{UPPERCASE}    - All alpha characters are in uppercase.
X    \end{itemize}
X    Syntax for a field is:
X    \begin{verbatim}
X        FIELD <name> {
X            <type> [(<size>)];
X            POS [+-]<column>, [+-]<row>;
X            LVALUE "<left value>";
X            RVALUE "<right value>";
X            [UPPERCASE;]
X            [PROTECTED;]
X        }
X    \end{verbatim}
X    Example:
X    \begin{verbatim}
X        Field adress {
X            Pos 20, +1;
X            Type Char(20);
X            LValue "Adress: ";
X            Uppercase;
X        }
X    \end{verbatim}
X\subsection{Literals}
X    Literals is static text to be visualized in the picture, literals
X    is below fields if a collission should occur. Syntax of a literal
X    is:
X    \begin{verbatim}
X        Literal [+-]<column>, [+-]<row>, "<text>";
X    \end{verbatim}
X    Example:
X    \begin{verbatim}
X        Literal +0, +1, "List of persons";
X    \end{verbatim}
X\subsection{Events}
X    Events are used to define functions keys and other special cases for eg.
X    refresh display and so on. An event is specified by its event type
X    and either a block of C-code to execute when the event occurres, or the
X    word 'forget' wich means that the specified event should be disabled for
X    this field.
X    Type of events is:
X    \begin{itemize}
X       \item[KEY] A key has been pressed. An event of the type KEY must
X              have one of the following modifiers:
X       \begin{itemize}
X           \item[F0 - F20 -] Function keys
X           \item[UP -] Up arrow
X           \item[DOWN -] Down arrow
X           \item[LEFT -] Left arrow
X           \item[RIGHT -] Right arrow
X           \item[CR -] Carriage return
X           \item[BS -] Backspace
X           \item[TAB -] Horizontal tab
X           \item[FIND -] Search
X           \item[INSERT -] Insert
X       \end{itemize}
X       \item[REFRESH] Refresh the picture
X       \item[DRAW] Only available from pictures, is called
X                   when a pictures is first drawn.
X       \item[LEFT] When trying to move to the left of the field
X       \item[RIGHT] When trying to move to the left of the field
X       \item[ENTRY] When field is entered
X       \item[EXIT] When field is left
X    \end{itemize}
X
X    Syntax for an event is:
X    \begin{verbatim}
X        EVENT <type> [<type modifier>] {
X            <C-code statements>
X        }
X    \end{verbatim}
X    \begin{verbatim}
X        EVENT <type> [<type modifier>] FORGET;
X    \end{verbatim}
X    Example:
X    \begin{verbatim}
X        Event Entry {
X            fld_set(current.field, "X");
X        }
X        Event Key DOWN  {
X            fld_move(fld_down(current.field));
X        }
X    \end{verbatim}
X\section{EVENT and CCODE programing}
X    For all event- and ccode blocks the developer can use a set
X    library functions that comes with cforms. Most functions returning
X    integers returns ether OK or FAIL exept for those like fld\_len that
X    returns the value expected. Those returning pointers return NULL
X    uppon failure.
X    This is a list and a description of all functions:
X    \subsection{Start/stop functions}
X         \subsubsection{cforms\_init} Initiate CForms, this must be done
X        before any cforms functions can be called.
X            \synopsys{int cforms\_init(void)}
X        \subsubsection{cforms\_end} Stop CForms.
X        \synopsys{int cforms\_end(void)}
X     \subsection{Picture functions}
X         \subsubsection{pic\_call} Call picture.
X           \synopsys{int pic\_call(struct picture *, field *)}\\
X        Where picture is a pointer to the picture to call and field
X        is where the cursor lands on, NULL means the first field in
X        picture.
X        \subsubsection{pic\_clear} Clear all fields for picture.
X        \synopsys{int pic\_clear(struct picture *)}\\
X        If picture is NULL current.picture is cleared.
X        \subsubsection{pic\_leave} Leave current picture after current
X        event has finished.
X        \synopsys{int pic\_leave(void)}
X        \subsubsection{picture} Get picture with name.
X        \synopsys{struct picture *picture(char *fmt, ...)}\\
X        Returns a pointer to a picture with the name generated
X        with 'fmt' and its arguments the same way that printf works.
X    \subsection{Field functions}
X        \subsubsection{field} Get field with name
X        \synopsys{struct field *field(char *fmt, ...)}\\
X        Returns a pointer to a field with the name generated
X        with 'fmt' and its arguments the same way that printf works.
X        If the field name is prepended by the picture name and a
X        colon, i.e.  "picture:field", a field can be found in another
X        picture than current.picture.
X        \subsubsection{fld\_isempty} Check if field is empty, i.e.
X        full of spaces, tabs or null.
X        \synopsys{int fld\_isempty(struct field *)}\\
X        Returns TRUE or FALSE condition.
X        \subsubsection{fld\_first} Find first field of picture.
X        \synopsys{struct field *fld\_first(void)}
X        \subsubsection{fld\_last} Find last field of picture.
X        \synopsys{struct field *fld\_last(void)}
X        \subsubsection{fld\_next} Find next field for picture.
X        \synopsys{struct field *fld\_next(struct field *)}\\
X        Returns the field after field given by argument (or
X        current.field if NULL).
X        \subsubsection{fld\_previous} Find previous field for picture.
X        \synopsys{struct field *fld\_previous(struct field *)}\\
X        Returns the field berfore field given by argument (or
X        current.field if NULL).
X        \subsubsection{fld\_left} Find left field.
X        \synopsys{struct field *fld\_left(struct field *)}\\
X        Returns the field to the left of the field given by argument
X        (or current.field if NULL).
X        \subsubsection{fld\_right} Find right field.
X        \synopsys{struct field *fld\_right(struct field *)}\\
X        Returns the field to the right of the field given by argument
X        (or current.field if NULL).
X        \subsubsection{fld\_up} Find field above current.
X        \synopsys{struct field *fld\_up(struct field *)}\\
X        Returns the field above the field given by argument
X        (or cur\-rent.\-field if\- NULL).
X        \subsubsection{fld\_down} Find field below current.
X        \synopsys{struct field *fld\_down(struct field *)}\\
X        Returns the field below the field given by argument
X        (or current.\-field if\- NULL).
X        \subsubsection{fld\_set} Set value for field.
X        \synopsys{int fld\_set(struct field *, char *)}\\
X        If field is NULL set value for current.field.
X        \subsubsection{fld\_nset} Set value for field but max n chars.
X        \synopsys{int fld\_nset(struct field *, char *)}\\
X        If field is NULL set value for current.field.
X        \subsubsection{fld\_get} Get value of field.
X        \synopsys{char *fld\_get(struct field *)}\\
X        If field is NULL get value for current.field.
X        \subsubsection{fld\_len} Return length of field.
X        \synopsys{int fld\_len(struct field *)}\\
X        If field is NULL return length for current.field.
X        \subsubsection{fld\_ismodified} Return true if field has been
X        modified since last fld\_set or fld\_nset.
X        \synopsys{int fld\_ismodified(struct field *)}\\
X        If field is NULL return modified for current.field.
X        \subsubsection{fld\_touch} Make field not modified.
X        \synopsys{int fld\_touch(struct field *)}\\
X        If field is NULL touch current.field.
X     \subsection{General functions}
X         \subsubsection{message} Give message (line 24).
X        \synopsys{int message(char *fmt, ...)}
X        \subsubsection{strequ} Compare two strings, but case insensitive.
X        \synopsys{int strequ(char *s1, char *s2)}
X    \subsection{Global variables}
X        \subsubsection{current.picture} Allways points to current picture
X        (can be NULL).
X        \synopsys{struct picture *current.picture}
X        \subsubsection{current.field} Allways points to current field
X        (can be NULL).
X        \synopsys{struct field *current.field}
X\section{How to compile and install CForms}
XWhen you have unpacked the CForms archive you just do cd to the directory
Xwhere you unpacked it and change the DEST-variable in the Makefile to
Xwhere you want CForms installed.
XAfter that you should do a 'make' followed by an 'make install'.
XYou can also compile the example application in the example subdirectory
Xby doing 'make example', look it up to see what an application might look
Xlike.
X\section{How to compile CForms applications}
XLets say you just installed CForms with DEST set to {\em /usr/local},
Xthat means that the CForms compiler resides in /usr/local/bin, the
Xcforms include file resides in /usr/local/include and the library
Xlibcforms.a in /usr/local/lib, then this is how to compile a CForms
Xapplication:
XFirst you run the CForms compiler, {\em cfc}, on your inputfile:
X    \begin{verbatim}
X    cfc <yourfile>
X    \end{verbatim}
XThis will generate the compiler output file, {\em cforms.c}. That file
Xshould be compiled with you ordinary c-compiler by doing something like:
X    \begin{verbatim}
X    cc -o <yourapp> -I/usr/local/include -L/usr/local/lib \
X         cforms.c -lcforms -lcurses
X    \end{verbatim}
XObserve that the -L flag must be there beccause the cforms library is in
X/usr/\-local/\-lib.
XNow you should be able to run you application.
X\newpage
X\tableofcontents
X\end{document}
END_OF_FILE
if test 13964 -ne `wc -c <'doc/cforms.tex'`; then
    echo shar: \"'doc/cforms.tex'\" unpacked with wrong size!
# end of 'doc/cforms.tex'
if test -f 'src/get_field.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'src/get_field.c'\"
echo shar: Extracting \"'src/get_field.c'\" \(6000 characters\)
sed "s/^X//" >'src/get_field.c' <<'END_OF_FILE'
X/*******************************************************************************
X *        G E T _ F I E L D . C
X *        ---------------------
X * Description:
X *    Compiles a field statement.
X * Included functions:
X *    get_field    - Does the job.
X * Revision:
X *    Ver    Date    By        Reason
X *    ---    ----    --        ------
X *    1.00    900625    Lars Berntzon    Created
X ******************************************************************************/
X#include <stdio.h>
X#include <ctype.h>
X#include <string.h>
X#include "token.h"
X#include "comp.h"
X#define isnormal(ch) (isalnum(ch) || (ch) == '_')
Xstatic int found_pos();
Xstatic int found_event();
Xstatic int found_lvalue();
Xstatic int found_rvalue();
Xstatic int found_type();
Xstatic int found_protected();
Xstatic int found_uppercase();
Xstatic struct lookup_s lookup[] = {
X    "LVALUE",     found_lvalue,
X    "RVALUE",     found_rvalue,
X    "POS",     found_pos,
X    "EVENT",     found_event,
X    "TYPE",     found_type,
X    "PROTECTED", found_protected,
X    "UPPERCASE", found_uppercase
Xstruct field *get_field()
X    char token[TOKENSIZE];
X    struct field *fp = NULL;
X    int i;
X
X    if (GetTokNC(token) == NULL || !isnormal(token[0])) {
X        error("expected name of field");
X        return NULL;
X    }
X
X    fp = memalloc(sizeof *fp);
X    link_name(&fp->link, token);
X
X    if (GetTokNC(token) == NULL || strcmp(token, "{")) {
X        error("expected '{'");
X        unget_field(fp);
X        return NULL;
X    }
X
X    while(GetTokNC(token) != NULL) {
X    if(strcmp(token, "}") == 0) break;
X    else if (strcmp(token, "{") == 0) {
X        UnGetTok("{");
X        skip_stmt();
X        continue;
X    for(i = 0; i < N_CMDS; i++) {
X        if (strequ(token, lookup[i].cmd) == 0) break;
X    if (i < N_CMDS) {
X        if ((*lookup[i].func)(fp) != OK) {
X            unget_field(fp);
X            return NULL;
X        }
X    else {
X        error("unknown token for field");
X    }
X    if (fp->lvalue && fp->pos.x - (int) strlen(fp->lvalue) < 1) {
X        error("field has position to far left");
X    }
X    if (fp->rvalue && fp->pos.x + fp->len +  (int) strlen(fp->rvalue) >= 80) {
X        error("field has position to far left");
X    }
X    if (fp->type == NULL) {
X        error("undefined type for field");
X        unget_field(fp);
X        return NULL;
X    }
X    return fp;
Xstruct field *unget_field(struct field *fp)
X    struct field *next;
X    struct event *ep;
X    if (fp == NULL) return NULL;
X    next = (struct field *)fp->link.next;
X
X    for(ep = fp->event; ep != NULL; ep = unget_event(ep))
X    if (fp->link.name) free(fp->link.name);
X    if (fp->lvalue) free(fp->lvalue);
X    if (fp->rvalue) free(fp->rvalue);
X    free(fp);
X    return next;
Xstatic int found_lvalue(fp)
X    struct field *fp;
X    char token[TOKENSIZE];
X
X    if (GetTokNC(token) == NULL || token[0] != '"') {
X        error("expected lvalue");
X        return FAIL;
X    }
X    token[strlen(token) - 1] = 0;
X
X    fp->lvalue = memalloc(strlen(token));
X    strcpy(fp->lvalue, token + 1);
X    if (GetTokNC(token) == NULL || strcmp(token, ";")) {
X        error("expected ';'");
X        return FAIL;
X    }
X    return OK;
Xstatic int found_rvalue(fp)
X    struct field *fp;
X    char token[TOKENSIZE];
X
X    if (GetTokNC(token) == NULL || token[0] != '"') {
X        error("expected rvalue");
X        return FAIL;
X    }
X    token[strlen(token) - 1] = 0;
X
X    fp->rvalue = memalloc(strlen(token));
X    strcpy(fp->rvalue, token + 1);
X    if (GetTokNC(token) == NULL || strcmp(token, ";")) {
X        error("expected ';'");
X        return FAIL;
X    }
X    return OK;
Xstatic int found_pos(fp)
X    struct field *fp;
X    char token[TOKENSIZE];
X
X    if (GetPos(&fp->pos.x, & fp->pos.y) != OK) return FAIL;
X
X    if (GetTokNC(token) == NULL || strcmp(token, ";")) {
X        error("expected ';'");
X        return FAIL;
X    }
X    return OK;
Xstatic int found_event(fp)
X    struct field *fp;
X    struct event *ep;
X
X    if ((ep = get_event()) == NULL) return FAIL;
X
X    link((struct link **)&fp->event, &ep->link, TYPE_EVENT);
X
X    return OK;
Xstatic int found_type(fp)
X    struct field *fp;
X    char token[TOKENSIZE];
X    int i;
X
X    static struct {
X        char *name;
X        char *code;
X    } type[] = {
X        "INT",     "FLD_INT",
X        "CHAR",  "FLD_STR",
X        "ALNUM", "FLD_ALNUM",
X        NULL, NULL
X    };
X
X    if (GetTokNC(token) == NULL) {
X        error("unexpected end of file for field");
X        return FAIL;
X    }
X
X    for(i = 0; type[i].name != NULL; i++) {
X        if (strequ(token, type[i].name) == 0) break;
X    }
X    if (type[i].name == NULL) {
X        error("unknown type for field");
X        return FAIL;
X    }
X
X    fp->type = type[i].code;
X    fp->len = 1;
X
X    if (GetTokNC(token) == NULL) {
X        error("unexpected end of file for field");
X        return FAIL;
X    }
X
X    if (strcmp(token, ";") == 0) return OK;
X
X    if (strcmp(token, "(") != 0) {
X        error("expected '(' or ';' after field type");
X        return FAIL;
X    }
X
X    if (GetTokNC(token) == NULL || !isdigit(token[0])) {
X        error("field size must be integer");
X        return FAIL;
X    }
X
X    fp->len = atoi(token);
X
X    if (GetTokNC(token) == NULL || strcmp(token, ")")) {
X        error("expected ')' after field");
X        return FAIL;
X    }
X    if (GetTokNC(token) == NULL || strcmp(token, ";")) {
X        error("expected ';' after field");
X        return FAIL;
X    }
X    return OK;
Xstatic int found_protected(fp)
X    struct field *fp;
X    char token[TOKENSIZE];
X
X    fp->flags |= FLD_PROTECTED;
X
X    if (GetTokNC(token) == NULL) {
X        error("unexpected end of file for field");
X        return FAIL;
X    }
X    if (strcmp(token, ";") != 0) {
X        error("expetced ';'");
X        return FAIL;
X    }
X
X    return OK;
Xstatic int found_uppercase(fp)
X    struct field *fp;
X    char token[TOKENSIZE];
X
X    fp->flags |= FLD_UPPERCASE;
X
X    if (GetTokNC(token) == NULL) {
X        error("unexpected end of file for field");
X        return FAIL;
X    }
X    if (strcmp(token, ";") != 0) {
X        error("expetced ';'");
X        return FAIL;
X    }
X
X    return OK;
END_OF_FILE
if test 6000 -ne `wc -c <'src/get_field.c'`; then
    echo shar: \"'src/get_field.c'\" unpacked with wrong size!
# end of 'src/get_field.c'
if test -f 'src/output.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'src/output.c'\"
echo shar: Extracting \"'src/output.c'\" \(8094 characters\)
sed "s/^X//" >'src/output.c' <<'END_OF_FILE'
X/*******************************************************************************
X *        O U T P U T . C
X *        ---------------
X * Description:
X *    Generates the C-code for CForms.
X * Included functions:
X *    output        - Does the job
X * Revision:
X *    Ver    Date    By        Reason
X *    ---    ----    --        ------
X *    1.00    900627    Lars Berntzon    Created
X ******************************************************************************/
X#include "config.h"
X#include <stdio.h>
X#include <ctype.h>
X#include <string.h>
X#include <assert.h>
X#include "token.h"
X#include "comp.h"
Xvoid output()
X    struct viewport *vp;
X    struct picture *pp;
X    struct field *fp;
X    struct event *ep;
X    struct stmt *sp;
X    struct literal *lp;
X    struct ccode *cp;
X    int n_fields, n_events, n_literals, n_pictures;
X    FILE *out;
X
X    if ((out = fopen("cforms.c", "w")) == NULL) {
X        fprintf(stderr, "failed to open output file.\n");
X        cleanup(1);
X    }
X
X    /*
X     * G e n e r a t e   H e a d e r.
X     */
X
X     fprintf(out, "/* Generated by C-Forms version %s */\n\n", version);
X     fprintf(out, "#include <stdio.h>\n\n");
X     fprintf(out, "#include <curses.h>\n");
X     fprintf(out, "#include \"cforms.h\"\n\n");
X#if 0
X     /*
X      * C r e a t e   v i e w p o r t s.
X      */
X     if (list.viewport) {
X         fprintf(out, "    /* V i e w p o r t s */\n\n");
X         for(vp = list.viewport; vp != NULL; vp = NEXT_VIEWPORT(vp))
X         {
X             fprintf(out, "WINDOW *win_%s;\n", vp->link.name);
X         }
X         fprintf(out, "\n");
X    }
X#endif
X
X    /*
X     * C r e a t e   C - c o d e s.
X     */
X    if (list.ccode) fprintf(out, "    /* C - c o d e s */\n\n");
X    for(cp = list.ccode; cp != NULL; cp = NEXT_CCODE(cp))
X    {
X        for(sp = cp->stmt; sp != NULL; sp = sp->next) {
X            fprintf(out, "%s\n", sp->txt);
X        }
X        fprintf(out, "\n");
X    }
X
X    /*
X     * C r e a t e   p i c t u r e s.
X     */
X    if (list.picture) fprintf(out, "    /* P i c t u r e s */\n\n");
X    for(pp = list.picture; pp != NULL; pp = NEXT_PICTURE(pp))
X    {
X        /*
X         * E v e n t s   f o r   a l l   f i e l d s.
X         */
X        n_fields = 0;
X        n_literals = 0;
X
X    for(fp = pp->field; fp != NULL; fp = NEXT_FIELD(fp))
X    {
X        /* Event routines for field */
X
X    for(ep = fp->event; ep != NULL; ep = NEXT_EVENT(ep))
X        if (ep->stmt) {
X            fprintf(out, "static void event_%s_%s_%s()\n{\n",
X            pp->link.name, fp->link.name, ep->link.name);
X        for(sp = ep->stmt; sp != NULL; sp = sp->next)
X            fprintf(out, "    %s\n", sp->txt);
X        fprintf(out, "}\n");
X        }
X        /* Event table for field */
X    if (fp->event) {
X        fprintf(out, "static struct event etab_%s_%s[] = {\n",
X            pp->link.name, fp->link.name);
X        for(ep = fp->event; ep != NULL; ep = NEXT_EVENT(ep))
X        {
X            fprintf(out, "    %s, %s, ", ep->type, ep->code);
X
X            if (ep->stmt) {
X                fprintf(out, "event_%s_%s_%s",
X                    pp->link.name, fp->link.name, ep->link.name);
X            }
X            else {
X                fprintf(out, "NULL");
X            }
X            fprintf(out, "%s\n", NEXT_EVENT(ep) ? "," : "");
X        }
X        fprintf(out, "};\n\n");
X    /*
X     * F i e l d   d a t a   a r r a y.
X     */
X    fprintf(out, "static char field_%s_%s[%d];\n\n",
X          pp->link.name, fp->link.name, fp->len + 1);
X    fprintf(out, "/***************************************************/\n");
X    }
X
X    /*
X     * T a b l e   o f   a l l   f i e l d s.
X     */
X    if (pp->field) {
X        fprintf(out, "static struct field ftab_%s[] = {\n", pp->link.name);
X
X    for(fp = pp->field; fp != NULL; n_fields++, fp = NEXT_FIELD(fp))
X        fprintf(out, "   {\"%s\", ", fp->link.name);
X        fprintf(out, "%s, %d, ", fp->type, fp->len);
X        fprintf(out, "field_%s_%s, ", pp->link.name, fp->link.name);
X        fprintf(out, "%d, %d, \"%s\", \"%s\", ", fp->pos.x, fp->pos.y,
X            fp->lvalue ? fp->lvalue : "", fp->rvalue ? fp->rvalue : "");
X        if (fp->event) {
X            fprintf(out, "etab_%s_%s", pp->link.name, fp->link.name);
X        }
X        else {
X            fprintf(out, "NULL");
X        }
X        for(n_events = 0, ep = fp->event; ep != NULL;
X            n_events++, ep = NEXT_EVENT(ep))
X            ;
X        fprintf(out, ", %d, %d", n_events, fp->flags);
X        fprintf(out, ", 0"); /* Modified flag */
X        fprintf(out, ", NULL"); /* Modified flag */
X        fprintf(out, "}%s", NEXT_FIELD(fp) ? ",\n" : "\n");
X    fprintf(out, "};\n\n");
X    }
X
X    /*
X     * T a b l e   o f   l i t e r a l s.
X     */
X    if (pp->literal) {
X        fprintf(out, "static struct literal ltab_%s[] = {\n", pp->link.name);
X        for(lp = pp->literal; lp != NULL; n_literals++, lp = NEXT_LITERAL(lp))
X        {
X            fprintf(out, "    %d, %d, \"%s\", %d%s\n",
X                lp->pos.x, lp->pos.y,
X                lp->link.name, lp->display_flags,
X                NEXT_LITERAL(lp) ? "," : "");
X        }
X        fprintf(out, "};\n\n");
X    }
X
X    /*
X     * E v e n t s   f o r   p i c t u r e.
X     */
X
X    for(ep = pp->event; ep != NULL; ep = NEXT_EVENT(ep))
X    {
X        if (ep->stmt) {
X        fprintf(out, "static void event_%s_%s()\n{\n",
X            pp->link.name, ep->link.name);
X        for(sp = ep->stmt; sp != NULL; sp = sp->next)
X        {
X            fprintf(out, "    %s\n", sp->txt);
X        }
X        fprintf(out, "}\n\n");
X    }
X
X    n_events = 0;
X    if(pp->event) {
X        fprintf(out, "static struct event etab_%s[] = {\n",
X            pp->link.name);
X        for(ep = pp->event; ep != NULL; n_events++, ep = NEXT_EVENT(ep))
X        {
X            fprintf(out, "    %s, %s, ", ep->type, ep->code);
X
X            if (ep->stmt) {
X                fprintf(out, "event_%s_%s", pp->link.name, ep->link.name);
X            }
X            else {
X                fprintf(out, "NULL");
X            }
X            fprintf(out, "%s\n", NEXT_EVENT(ep) ? "," : "");
X        }
X        fprintf(out, "};\n\n");
X    }
X    }
X
X    /*
X     * T a b l e   o f   p i c t u r e s.
X     */
X    if(list.picture) {
X        fprintf(out, "static struct picture ptab[] = {\n");
X    }
X    n_pictures = 0;
X    for(pp = list.picture; pp != NULL; n_pictures++, pp = NEXT_PICTURE(pp))
X    {
X        fprintf(out, "    {\"%s\", ", pp->link.name);
X            /* Fields */
X    for(n_fields = 0, fp = pp->field; fp; fp = NEXT_FIELD(fp)) {
X        n_fields++;
X    if (pp->field) {
X        fprintf(out, "ftab_%s, %d, ", pp->link.name, n_fields);
X    else fprintf(out, "NULL, 0, ");
X        /* Literals */
X    for(n_literals = 0, lp = pp->literal; lp; lp = NEXT_LITERAL(lp)) {
X        n_literals++;
X    if (pp->literal) {
X        fprintf(out, "ltab_%s, %d, ", pp->link.name, n_literals);
X    else fprintf(out, "NULL, 0, ");
X        /* Events */
X    for(n_events = 0, ep = pp->event; ep; ep = NEXT_EVENT(ep)) {
X        n_events++;
X    if (pp->event) {
X        fprintf(out, "etab_%s, %d", pp->link.name, n_events);
X    else fprintf(out, "NULL, 0");
X    fprintf(out, ", %d,%d, %d,%d}", pp->viewport->pos.x, pp->viewport->pos.y,
X        pp->viewport->size.x, pp->viewport->size.y);
X    if (NEXT_PICTURE(pp)) {
X        fprintf(out, ",");
X    fprintf(out, "\n");
X    }
X    if(list.picture) {
X        fprintf(out, "};\n\n");
X    }
X    /*
X     * Event functions for module.
X     */
X    for(ep = list.event; ep != NULL; ep = NEXT_EVENT(ep))
X    {
X        if (ep->stmt) {
X        fprintf(out, "static void event_%s()\n{\n", ep->link.name);
X        for(sp = ep->stmt; sp != NULL; sp = sp->next)
X        {
X            fprintf(out, "    %s\n", sp->txt);
X        }
X        fprintf(out, "}\n\n");
X    }
X    n_events = 0;
X    if(list.event) {
X        fprintf(out, "static struct event etab[] = {\n");
X        for(ep = list.event; ep != NULL; n_events++, ep = NEXT_EVENT(ep))
X        {
X            fprintf(out, "    %s, %s, ", ep->type, ep->code);
X
X            if (ep->stmt) {
X                fprintf(out, "event_%s", ep->link.name);
X            }
X            else {
X                fprintf(out, "NULL");
X            }
X            fprintf(out, "%s\n", NEXT_EVENT(ep) ? "," : "");
X        }
X        fprintf(out, "};\n\n");
X    }
X    fprintf(out, "struct module _module = { ");
X    if (list.picture) fprintf(out, "ptab, %d, ", n_pictures);
X    else fprintf(out, "NULL, 0, ");
X    if (list.event)  fprintf(out, "etab, %d", n_events);
X    else fprintf(out, "NULL, 0");
X    fprintf(out, "};\n");
END_OF_FILE
if test 8094 -ne `wc -c <'src/output.c'`; then
    echo shar: \"'src/output.c'\" unpacked with wrong size!
# end of 'src/output.c'
if test -f 'src/token.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'src/token.c'\"
echo shar: Extracting \"'src/token.c'\" \(6503 characters\)
sed "s/^X//" >'src/token.c' <<'END_OF_FILE'
X/*******************************************************************************
X*        T O K E N . C
X*        -------------
X* Description:
X*    Reads tokens from input file. Tokens are the C-stype tokens. It is
X*    allso possible to unget tokens for later recall by GetTok().
X* Included functions:
X*    GetTok()    - Get token
X*    GetTokNC()    - Get token but skip comment
X*    UnGetTok()    - Unget token
X*    OpenTok()    - Open file to read tokens from
X* Revision:
X*    Ver    Date   By        Reason
X*    ---    ----   --        ------
X*    1.00   900619 Lars Berntzon    Created
X******************************************************************************/
X#include "config.h"
X#include <stdio.h>
X#include <ctype.h>
X#include <string.h>
X#ifdef STDLIB_H
X#include <stdlib.h>
X#endif
X#ifdef MALLOC_H
X#include <malloc.h>
X#endif
X#include "token.h"
X#define isnormal(c) (isalnum(c) || (c) == '_')
X    /* G l o b a l   v a r i a b l e s */
Xint newline = 1;       /* Number of newlines before this token    */
Xint line = 1;           /* Current line number            */
XFILE *in;           /* The input file pointer            */
X    /* L o c a l   v a r i a b l e */
Xstatic struct saved {       /* Queue of ungotten tokens            */
X    struct saved *next;
X    char token[TOKENSIZE];
X} *saved = NULL;
Xtypedef void *(*state_t)(char *);
X/*******************************************************************************
X *        G E T O K
X *        ---------
X * Description:
X *    Reads one token from input file (or from ungotten token).
X * Output:
X *    str    - String where data wil be put (if not NULL).
X * Return:
X *    String containing token, NULL if end of file.
X ******************************************************************************/
Xchar *GetTok(char *str)
X    static char token[TOKENSIZE];
X    static int ch = ' ';
X    struct saved *p;
X    int pos;
X    enum { gt_init, gt_got_delim, gt_normal,
X           gt_searching_quote, gt_got_backslash } state = gt_init;
X    if (p = saved) {
X    strncpy(token, saved->token, TOKENSIZE);
X    saved = p->next;
X    free(p);
X    pos = 1;
X    goto found;
X    }
X
X    token[0] = 0;
X
X    newline = 0;
X
X    if (ch == EOF) return NULL;
X
X    for(pos = 0; ch != EOF; ch = getc(in)) {
X    if (ch == '\n') {
X        line++;
X        newline++;
X    switch(state)
X    case gt_init:
X        if (isspace(ch)) {
X            break;
X        }
X        else if (ch == '"') {
X        token[pos++] = ch;
X        state = gt_searching_quote;
X        }
X        else if (!isnormal(ch)) {
X        token[pos++] = ch;
X        token[pos++] = 0;
X        ch = ' ';
X        goto found;
X        }
X        else if (isnormal(ch)) {
X            token[pos++] = ch;
X            state = gt_normal;
X        }
X        break;
X    case gt_normal:
X        if (isnormal(ch)) {
X            token[pos++] = ch;
X        }
X        else {
X        token[pos++] = 0;
X        goto found;
X        }
X        break;
X    case gt_searching_quote:
X        token[pos++] = ch;
X        if (ch == '\\') {
X            state = gt_got_backslash;
X        }
X        else {
X            if (ch == '"') {
X                token[pos++] = 0;
X                ch = ' ';
X                goto found;
X            }
X        }
X        break;
X    case gt_got_backslash:
X        token[pos++] = ch;
X        state = gt_searching_quote;
X        break;
X    }
Xfound:
X    if (pos == 0) return NULL;
X    if (str) return strcpy(str, token);
X    return token;
X/*******************************************************************************
X *        G E T T O K N C
X *        ---------------
X * Description:
X *    Reads one token from input file (or from ungotten token) and skips
X *    C-style comments.
X * Output:
X *    str    - String where data will be put (if not NULL).
X * Return:
X *    String containing token, NULL if EOF.
X ******************************************************************************/
Xstatic void *nc_init(char *);
Xstatic void *nc_found_leading_slash(char *);
Xstatic void *nc_searching_star(char *);
Xstatic void *nc_expect_slash(char *);
Xchar *GetTokNC(char *token)
X    char *ret;
X    state_t state = nc_init;
X    while((ret = GetTok(token)) != NULL &&
X          (state = (state_t) (*state)(ret)) != NULL) {
X    }
X    return ret;
Xstatic void *nc_init(char *token)
X    if(strcmp(token, "/") != 0) return NULL;
X    return (void *)nc_found_leading_slash;
Xstatic void *nc_found_leading_slash(char *token)
X    if(strcmp(token, "*") == 0) return (void *)nc_searching_star;
X    UnGetTok(token);
X    strcpy(token, "/");
X    return NULL;
Xstatic void *nc_searching_star(char *token)
X    if(strcmp(token, "*") == 0) return (void *)nc_expect_slash;
X    return (void *)nc_searching_star;
Xstatic void *nc_expect_slash(char *token)
X    if (strcmp(token, "/") == 0) return (void *)nc_init;
X    UnGetTok(token);
X    return (void *)nc_searching_star;
X/*******************************************************************************
X *        U N G E T T O K
X *        ---------------
X * Description:
X *    Returns a token to be read later by GetTok().
X * Input:
X *    str    - String to be put back.
X ******************************************************************************/
Xvoid
XUnGetTok(char *str)
X    struct saved *p = NULL;
X
X    if ((p = (struct saved *)malloc(sizeof *p)) == NULL) {
X    fprintf(stderr, "Out of memory");
X    return;
X    }
X    p->next = saved;
X    saved = p;
X    strncpy(saved->token, str, TOKENSIZE);
X/*******************************************************************************
X *        O P E N T O K
X *        -------------
X * Description:
X *    Open a file to read tokens from.
X * Input:
X *    name    - Name of file.
X * Return:
X *    Opened files pointer, of NULL if failure.
X ******************************************************************************/
XFILE *OpenTok(char *name)
X    if (in != NULL) {
X    fclose(in);
X    }
X    return in = fopen(name, "r");
X#ifdef STANDALONE
X/*******************************************************************************
X *        M A I N
X *        -------
X * Description:
X *    Main routine when compiled as standalone.
X *    This is only used for test.
X ******************************************************************************/
Xmain()
X    char filename[100];
X    char *p;
X
X    printf("Enter filename of 'stdin': ");
X    scanf("%s", filename);
X    if (strcmp(filename, "stdin") == 0) {
X    printf("Using stdin\n");
X    in = stdin;
X    }
X    else if (OpenTok(filename) == NULL) {
X    fprintf(stderr, "Can't open file '%s'\n", filename);
X    exit(1);
X    }
X    while(p = GetTokNC(NULL)) printf("'%s'\n", p);
X    UnGetTok("ungotten 1");
X    while(p = GetTokNC(NULL)) printf("'%s'\n", p);
X    UnGetTok("ungotten 2");
X    UnGetTok("ungotten 3");
X    while(p = GetTokNC(NULL)) printf("'%s'\n", p);
X    printf("END\n");
X#endif /* STANDALONE */
END_OF_FILE
if test 6503 -ne `wc -c <'src/token.c'`; then
    echo shar: \"'src/token.c'\" unpacked with wrong size!
# end of 'src/token.c'
echo shar: End of archive 2 \(of 3\).
cp /dev/null ark2isdone
MISSING=""
for I in 1 2 3 ; do
    if test ! -f ark${I}isdone ; then
    MISSING="${MISSING} ${I}"
    fi
if test "${MISSING}" = "" ; then
    echo You have unpacked all 3 archives.
    rm -f ark[1-9]isdone
    echo You still need to unpack the following archives:
    echo "        " ${MISSING}
##  End of shell archive.
exit 0