854 lines
19 KiB
Plaintext
854 lines
19 KiB
Plaintext
%{
|
|
/*-
|
|
* Copyright (c) 1995
|
|
* Paul Richards. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer,
|
|
* verbatim and that no modifications are made prior to this
|
|
* point in the file.
|
|
* 2. 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.
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
* must display the following acknowledgement:
|
|
* This product includes software developed by Paul Richards.
|
|
* 4. The name Paul Richards may not be used to endorse or promote products
|
|
* derived from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY PAUL RICHARDS ``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 PAUL RICHARDS 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.
|
|
*
|
|
*/
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
#include <forms.h>
|
|
|
|
char *cpstr(char *);
|
|
|
|
extern int yyleng;
|
|
int lineno = 1;
|
|
int charno = 1;
|
|
int off;
|
|
|
|
char *fieldname;
|
|
char *defname;
|
|
char *formname;
|
|
char *startname;
|
|
char *colortable;
|
|
char *formattr;
|
|
char *text;
|
|
char *label;
|
|
char *function;
|
|
char *up, *down, *left, *right, *next;
|
|
int height, width;
|
|
int y, x;
|
|
int width;
|
|
int limit;
|
|
char *attr;
|
|
char *selattr;
|
|
int type;
|
|
int lbl_flag;
|
|
int selected, no_options=0;
|
|
|
|
extern FILE *outf;
|
|
|
|
struct field_list {
|
|
char *fieldname;
|
|
char *defname;
|
|
char *attr;
|
|
char *selattr;
|
|
char *up;
|
|
char *down;
|
|
char *left;
|
|
char *right;
|
|
char *next;
|
|
struct field field;
|
|
struct field_list *next_field;
|
|
};
|
|
|
|
struct field_list *cur_field_def;
|
|
struct field_list *field_defs;
|
|
struct field_list *field;
|
|
struct field_list *cur_form_field;
|
|
struct field_list *form_field_list;
|
|
|
|
struct form_list {
|
|
char *formname;
|
|
struct form form;
|
|
struct form_list *next;
|
|
struct field_list *fields;
|
|
char *startfield;
|
|
char *formattr;
|
|
char *colortable;
|
|
};
|
|
|
|
struct form_list *cur_form;
|
|
struct form_list *form_list;
|
|
struct form_list *form;
|
|
|
|
struct menu_list {
|
|
char *option;
|
|
struct menu_list *next;
|
|
};
|
|
|
|
struct menu_list *cur_menu;
|
|
struct menu_list *menu_list;
|
|
struct menu_list *menu;
|
|
|
|
struct color_list {
|
|
char *foreground;
|
|
char *background;
|
|
struct color_list *next;
|
|
};
|
|
struct color_list *pair;
|
|
struct color_list *cur_pair;
|
|
struct color_list *color_list;
|
|
|
|
struct color_table {
|
|
char *tablename;
|
|
struct color_list *pairs;
|
|
struct color_table *next;
|
|
};
|
|
|
|
struct color_table *color_table;
|
|
struct color_table *cur_table;
|
|
struct color_table *color_tables;
|
|
|
|
%}
|
|
|
|
%union {
|
|
int ival;
|
|
char *sval;
|
|
}
|
|
|
|
%token <ival> FORM
|
|
%token <ival> COLORTABLE
|
|
%token <ival> COLOR
|
|
%token <ival> BLACK
|
|
%token <ival> RED
|
|
%token <ival> GREEN
|
|
%token <ival> YELLOW
|
|
%token <ival> BLUE
|
|
%token <ival> MAGENTA
|
|
%token <ival> CYAN
|
|
%token <ival> WHITE
|
|
%token <ival> PAIR
|
|
%token <sval> NAME
|
|
%token <sval> STRING
|
|
%token <ival> AT
|
|
%token <ival> AS
|
|
%token <ival> HEIGHT
|
|
%token <ival> EQUALS
|
|
%token <ival> NUMBER
|
|
%token <ival> WIDTH
|
|
%token <ival> STARTFIELD
|
|
%token <ival> COMMA
|
|
%token <ival> LBRACE
|
|
%token <ival> RBRACE
|
|
%token <ival> TEXT
|
|
%token <ival> ATTR
|
|
%token <ival> SELATTR
|
|
%token <ival> DEFAULT
|
|
%token <ival> LABEL
|
|
%token <ival> LIMIT
|
|
%token <ival> SELECTED
|
|
%token <ival> OPTIONS
|
|
%token <ival> ACTION
|
|
%token <ival> FUNC
|
|
%token <ival> LINK
|
|
%token <ival> UP
|
|
%token <ival> DOWN
|
|
%token <ival> LEFT
|
|
%token <ival> RIGHT
|
|
%token <ival> NEXT
|
|
%token <ival> DEF
|
|
|
|
%type <sval> a_color
|
|
|
|
%start spec
|
|
|
|
%%
|
|
|
|
spec: /* empty */
|
|
| spec fields
|
|
| spec forms
|
|
| spec colours
|
|
;
|
|
|
|
colours: COLOR NAME
|
|
{
|
|
color_table = malloc(sizeof (struct color_table));
|
|
if (!color_table) {
|
|
fprintf(stderr, "Couldn't allocate memory for a color table\n");
|
|
exit (1);
|
|
}
|
|
color_table->tablename = cpstr($2);
|
|
}
|
|
LBRACE color_pairs RBRACE
|
|
{
|
|
color_table->pairs = color_list;
|
|
cur_pair = 0;
|
|
if (!cur_table) {
|
|
color_tables = color_table;
|
|
cur_table = color_table;
|
|
} else {
|
|
cur_table->next = color_table;
|
|
cur_table = color_table;
|
|
}
|
|
}
|
|
;
|
|
|
|
color_pairs: /* empty */
|
|
| color_pairs pair
|
|
;
|
|
|
|
pair: PAIR EQUALS a_color
|
|
{
|
|
pair = malloc(sizeof (struct color_list));
|
|
if (!pair) {
|
|
fprintf(stderr, "Couldn't allocate memory for a color pair\n");
|
|
exit(1);
|
|
}
|
|
pair->foreground = cpstr($3);
|
|
}
|
|
COMMA a_color
|
|
{
|
|
pair->background = cpstr($6);
|
|
if (!cur_pair) {
|
|
color_list = pair;
|
|
cur_pair = pair;
|
|
} else {
|
|
cur_pair->next = pair;
|
|
cur_pair = pair;
|
|
}
|
|
}
|
|
;
|
|
|
|
a_color: BLACK
|
|
{ $$ = "COLOR_BLACK"; }
|
|
| RED
|
|
{ $$ = "COLOR_RED"; }
|
|
| GREEN
|
|
{ $$ = "COLOR_GREEN"; }
|
|
| YELLOW
|
|
{ $$ = "COLOR_YELLOW"; }
|
|
| BLUE
|
|
{ $$ = "COLOR_BLUE"; }
|
|
| MAGENTA
|
|
{ $$ = "COLOR_MAGENTA"; }
|
|
| CYAN
|
|
{ $$ = "COLOR_CYAN"; }
|
|
| WHITE
|
|
{ $$ = "COLOR_WHITE"; }
|
|
;
|
|
|
|
forms: FORM NAME
|
|
{ formname = cpstr($2); }
|
|
AT coord
|
|
{
|
|
form = malloc(sizeof (struct form_list));
|
|
if (!form) {
|
|
fprintf(stderr,"Failed to allocate memory for form\n");
|
|
exit(1);
|
|
}
|
|
form->form.y = y;
|
|
form->form.x = x;
|
|
}
|
|
LBRACE formspec RBRACE
|
|
{
|
|
form->startfield = startname;
|
|
form->formname = formname;
|
|
form->colortable = colortable;
|
|
form->form.height = height;
|
|
form->form.width = width;
|
|
form->formattr = formattr;
|
|
form->fields = form_field_list;
|
|
cur_form_field = 0;
|
|
if (!cur_form) {
|
|
form_list = form;
|
|
cur_form = form;
|
|
} else {
|
|
cur_form->next = form;
|
|
cur_form = form;
|
|
}
|
|
}
|
|
;
|
|
|
|
formspec: height width startfield colortable formattr fieldlocs
|
|
;
|
|
|
|
startfield: /* empty */
|
|
{ startname = 0;
|
|
printf("Warning: No start field specified for form %s\n", formname);
|
|
}
|
|
| STARTFIELD EQUALS NAME
|
|
{ startname = cpstr($3); }
|
|
;
|
|
|
|
colortable: /*empty */
|
|
{ colortable = 0; }
|
|
| COLORTABLE EQUALS NAME
|
|
{ colortable = cpstr($3); }
|
|
;
|
|
|
|
formattr: /* empty */
|
|
{ formattr = 0; }
|
|
| ATTR EQUALS NAME
|
|
{ formattr = cpstr($3); }
|
|
;
|
|
|
|
fieldlocs: /* empty */
|
|
| fieldlocs field_at
|
|
;
|
|
|
|
field_at: NAME
|
|
{ fieldname = cpstr($1); }
|
|
field_def AT coord
|
|
{
|
|
field = malloc(sizeof (struct field_list));
|
|
if (!field) {
|
|
fprintf(stderr,"Failed to allocate memory for form field\n");
|
|
exit(1);
|
|
}
|
|
field->fieldname = fieldname;
|
|
if (!defname)
|
|
field->defname = fieldname;
|
|
else
|
|
field->defname = defname;
|
|
field->field.y = y;
|
|
field->field.x = x;
|
|
}
|
|
links
|
|
{
|
|
field->up = up;
|
|
field->down = down;
|
|
field->left = left;
|
|
field->right = right;
|
|
field->next = next;
|
|
up = 0;
|
|
down = 0;
|
|
left = 0;
|
|
right = 0;
|
|
next = 0;
|
|
if (!cur_form_field) {
|
|
form_field_list = field;
|
|
cur_form_field = field;
|
|
} else {
|
|
cur_form_field->next_field = field;
|
|
cur_form_field = field;
|
|
}
|
|
}
|
|
;
|
|
|
|
fields: NAME
|
|
{ defname = cpstr($1); }
|
|
field_spec
|
|
{ define_field(defname, 0); }
|
|
;
|
|
|
|
field_def: /* empty */
|
|
{ defname = 0; }
|
|
| LBRACE NAME
|
|
{ defname = cpstr($2); }
|
|
RBRACE
|
|
| field_spec
|
|
{ defname = fieldname; define_field(defname, 0); }
|
|
;
|
|
|
|
field_spec: LBRACE height width attr selattr type RBRACE
|
|
;
|
|
|
|
links: /* empty */
|
|
| links COMMA conns
|
|
;
|
|
|
|
conns: UP EQUALS NAME
|
|
{ up = cpstr($3); }
|
|
| DOWN EQUALS NAME
|
|
{ down = cpstr($3); }
|
|
| LEFT EQUALS NAME
|
|
{ left = cpstr($3); }
|
|
| RIGHT EQUALS NAME
|
|
{ right = cpstr($3); }
|
|
| NEXT EQUALS NAME
|
|
{ next = cpstr($3); }
|
|
;
|
|
|
|
type: textfield
|
|
| inputfield
|
|
| menufield
|
|
| actionfield
|
|
;
|
|
|
|
textfield: TEXT EQUALS STRING
|
|
{ type = F_TEXT; text = cpstr($3); }
|
|
;
|
|
|
|
inputfield: inputspec
|
|
{ type = F_INPUT; }
|
|
;
|
|
|
|
inputspec: LABEL EQUALS STRING limit
|
|
{ lbl_flag = 1; label = cpstr($3); }
|
|
| DEFAULT EQUALS STRING limit
|
|
{ lbl_flag = 0; label = cpstr($3); }
|
|
;
|
|
|
|
limit: /* empty */
|
|
| LIMIT EQUALS NUMBER
|
|
{ limit = $3; }
|
|
|
|
menufield: SELECTED EQUALS NUMBER OPTIONS EQUALS menuoptions
|
|
{ type = F_MENU; selected = $3; }
|
|
;
|
|
|
|
menuoptions: menuoption
|
|
| menuoptions COMMA menuoption
|
|
;
|
|
|
|
menuoption: STRING
|
|
{ menu = malloc(sizeof(struct menu_list));
|
|
if (!menu) {
|
|
fprintf(stderr,
|
|
"Couldn't allocate memory for menu option\n");
|
|
exit (1);
|
|
}
|
|
menu->option = cpstr($1);
|
|
++no_options;
|
|
if (!cur_menu) {
|
|
menu_list = menu;
|
|
cur_menu = menu;
|
|
} else {
|
|
cur_menu->next = menu;
|
|
cur_menu = menu;
|
|
}
|
|
}
|
|
;
|
|
|
|
actionfield: ACTION EQUALS STRING FUNC EQUALS NAME
|
|
{ type = F_ACTION; text = cpstr($3); function = cpstr($6); }
|
|
;
|
|
|
|
height: /* empty */
|
|
{ height = 0; }
|
|
| HEIGHT EQUALS NUMBER
|
|
{ height = $3; }
|
|
;
|
|
|
|
width: /* empty */
|
|
{ width = 0; }
|
|
| WIDTH EQUALS NUMBER
|
|
{ width = $3; }
|
|
;
|
|
|
|
attr: /* empty */
|
|
{ attr = 0; }
|
|
| ATTR EQUALS NAME
|
|
{ attr = cpstr($3); }
|
|
;
|
|
|
|
selattr: /* empty */
|
|
{ selattr = 0; }
|
|
| SELATTR EQUALS NAME
|
|
{ selattr = cpstr($3); }
|
|
;
|
|
|
|
coord: NUMBER COMMA NUMBER
|
|
{ y = $1; x = $3; }
|
|
;
|
|
|
|
%%
|
|
|
|
yyerror (char *error)
|
|
{
|
|
fprintf(stderr, "%s at line %d\n",error, lineno);
|
|
exit(1);
|
|
}
|
|
|
|
yywrap()
|
|
{
|
|
return(1);
|
|
}
|
|
|
|
char *
|
|
cpstr(char *ostr)
|
|
{
|
|
char *nstr;
|
|
|
|
nstr = malloc(strlen(ostr)+1);
|
|
if (!nstr) {
|
|
fprintf(stderr, "Couldn't allocate memory for string\n");
|
|
exit(1);
|
|
}
|
|
strcpy(nstr, ostr);
|
|
return (nstr);
|
|
}
|
|
|
|
output_field(struct field_list *fields, char *fieldname, FILE *outf)
|
|
{
|
|
struct menu_list *menu;
|
|
int i, lim, len;
|
|
|
|
switch(fields->field.type) {
|
|
case F_TEXT:
|
|
if (!fieldname) {
|
|
if (!fields->field.width)
|
|
fields->field.width = strlen(fields->field.field.text->text);
|
|
if (!fields->field.height)
|
|
calc_field_height(&fields->field, fields->field.field.text->text);
|
|
|
|
fprintf(outf, "struct text_field %s = {\"%s\"};\n",
|
|
fields->defname,
|
|
fields->field.field.text->text);
|
|
}
|
|
break;
|
|
case F_INPUT:
|
|
/* Force height to one regardless */
|
|
fields->field.height = 1;
|
|
if (!fields->field.width && !fields->field.field.input->limit) {
|
|
fields->field.width = strlen(fields->field.field.input->label);
|
|
fields->field.field.input->limit = fields->field.width;
|
|
} else if (!fields->field.width)
|
|
fields->field.width = fields->field.field.input->limit;
|
|
else if (!fields->field.field.input->limit)
|
|
fields->field.field.input->limit = fields->field.width;
|
|
if (fields->field.field.input->limit < fields->field.width)
|
|
fields->field.width = fields->field.field.input->limit;
|
|
fprintf(outf, "struct input_field %s = {%d, \"%s\", 0, %d};\n",
|
|
(fieldname)?fieldname:fields->defname,
|
|
(fields->field.field.input->lbl_flag ? 1 : 0),
|
|
fields->field.field.input->label,
|
|
fields->field.field.input->limit);
|
|
break;
|
|
case F_MENU:
|
|
/* Force height to one regardless */
|
|
fields->field.height = 1;
|
|
if (!fieldname) {
|
|
fprintf(outf, "char *%s_options[] = {",
|
|
fields->defname);
|
|
menu = (struct menu_list *)fields->field.field.menu->options;
|
|
lim = 0;
|
|
for (i=0; i < fields->field.field.menu->no_options - 1; i++) {
|
|
fprintf(outf, "\"%s\", ", menu->option);
|
|
len = strlen(menu->option);
|
|
if (len > lim)
|
|
lim = len;
|
|
menu = menu->next;
|
|
}
|
|
if (!fields->field.width)
|
|
fields->field.width = lim;
|
|
fprintf(outf, "\"%s\"};\n", menu->option);
|
|
}
|
|
fprintf(outf, "struct menu_field %s = {%d, %d, %s_options};\n",
|
|
(fieldname)?fieldname:fields->defname,
|
|
fields->field.field.menu->no_options,
|
|
fields->field.field.menu->selected,
|
|
fields->defname);
|
|
break;
|
|
case F_ACTION:
|
|
if (!fields->field.width)
|
|
fields->field.width = strlen(fields->field.field.action->text);
|
|
if (!fields->field.height)
|
|
calc_field_height(&fields->field, fields->field.field.action->text);
|
|
fprintf(outf, "struct action_field %s = {\"%s\", &%s};\n",
|
|
(fieldname)?fieldname:fields->defname,
|
|
fields->field.field.action->text,
|
|
fields->field.field.action->fn);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
output_forms(FILE *outf)
|
|
{
|
|
struct form_list *forms;
|
|
struct field_list *fields;
|
|
|
|
/* Output the general field definitions */
|
|
for (fields = field_defs; fields; fields=fields->next_field)
|
|
output_field(fields, 0, outf);
|
|
|
|
for(forms=form_list; forms; forms = forms->next) {
|
|
parse_form(forms, outf);
|
|
}
|
|
}
|
|
|
|
output_coltab(struct color_table *coltab, FILE *outf)
|
|
{
|
|
struct color_list *pairs;
|
|
|
|
/* Output the color pair table */
|
|
|
|
fprintf(outf, "struct col_pair %s_coltab[] = {\n",coltab->tablename);
|
|
|
|
if (color_list) {
|
|
for(pairs=coltab->pairs; pairs; pairs=pairs->next)
|
|
fprintf(outf, "\t{%s, %s},\n",
|
|
pairs->foreground, pairs->background);
|
|
} else {
|
|
/* Output a default color table */
|
|
fprintf(outf, "\t{7, 0}\n};");
|
|
}
|
|
fprintf(outf, "\t{-1, -1}\n};\n\n");
|
|
}
|
|
|
|
parse_form(struct form_list *form, FILE *outf)
|
|
{
|
|
struct field_list *fields;
|
|
struct field_list *defs;
|
|
struct field_list *info;
|
|
struct color_table *coltab;
|
|
char *fieldname;
|
|
int no_fields = 0;
|
|
|
|
/* If there's a color table defined find it and output it */
|
|
if (form->colortable) {
|
|
for (coltab = color_tables; coltab; coltab = coltab->next)
|
|
if (!strcmp(form->colortable, coltab->tablename)) {
|
|
output_coltab(coltab, outf);
|
|
break;
|
|
}
|
|
if (!coltab) {
|
|
fprintf(stderr, "Color table for form %s not found\n",
|
|
form->formname);
|
|
form->colortable = 0;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Run through the specific instances of the fields referenced by
|
|
* this form, filling in the link structures and outputing a field
|
|
* definition for this particular instance.
|
|
*/
|
|
for(fields=form->fields; fields; fields=fields->next_field) {
|
|
|
|
/* Fill in link values */
|
|
|
|
fields->field.up = field_id(fields->up, form->fields);
|
|
fields->field.down = field_id(fields->down, form->fields);
|
|
fields->field.left = field_id(fields->left, form->fields);
|
|
fields->field.right = field_id(fields->right, form->fields);
|
|
fields->field.next = field_id(fields->next, form->fields);
|
|
|
|
/* Search field list for definition of this field */
|
|
|
|
for(defs=field_defs; defs; defs=defs->next_field) {
|
|
if (!strcmp(fields->defname, defs->defname))
|
|
break;
|
|
}
|
|
|
|
if (!defs) {
|
|
fprintf(stderr,
|
|
"%s not found in field definitions, field not output\n",
|
|
fields->defname);
|
|
fields->fieldname = 0;
|
|
} else {
|
|
fields->field.type = defs->field.type;
|
|
fields->field.height = defs->field.height;
|
|
fields->field.width = defs->field.width;
|
|
fields->attr = defs->attr;
|
|
fields->selattr = defs->selattr;
|
|
if (strcmp(fields->defname, fields->fieldname))
|
|
output_field(defs, fields->fieldname, outf);
|
|
}
|
|
}
|
|
|
|
/* Output the field table for this form */
|
|
|
|
fprintf(outf, "struct field %s_fields[] = {\n", form->formname);
|
|
|
|
for(fields=form->fields; fields; fields=fields->next_field) {
|
|
if (fields->fieldname) {
|
|
++no_fields;
|
|
fprintf(outf, "\t{%d, %d, %d, %d, %d, %s, %s, ",
|
|
fields->field.type, fields->field.y, fields->field.x,
|
|
fields->field.height, fields->field.width,
|
|
(fields->attr ? fields->attr : "F_DEFATTR"),
|
|
(fields->selattr ? fields->selattr : "F_SELATTR"));
|
|
fprintf(outf, "%d, %d, %d, %d, %d, ",
|
|
fields->field.next,
|
|
fields->field.up,
|
|
fields->field.down,
|
|
fields->field.left,
|
|
fields->field.right);
|
|
fprintf(outf, "(struct text_field *)&%s},\n",
|
|
fields->fieldname);
|
|
}
|
|
}
|
|
|
|
fprintf(outf, "\t{%d, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}\n};\n", F_END);
|
|
|
|
/* If no start field set then find first non-text field */
|
|
if (!form->startfield)
|
|
for (fields = form->fields; fields; fields = fields->next_field)
|
|
if (fields->field.type != F_TEXT) {
|
|
form->startfield = fields->fieldname;
|
|
break;
|
|
}
|
|
|
|
fprintf(outf,
|
|
"struct form %s = {%d, %d, %d, %s_fields, %d, %d, %d, %d, %s, ",
|
|
form->formname, no_fields,
|
|
field_id(form->startfield, form->fields),
|
|
field_id(form->startfield, form->fields),
|
|
form->formname, form->form.height, form->form.width,
|
|
form->form.y, form->form.x,
|
|
(form->formattr ? form->formattr : "F_DEFATTR"));
|
|
if (form->colortable)
|
|
fprintf(outf, "%s_coltab, ", form->colortable);
|
|
else
|
|
fprintf(outf, "0, ");
|
|
fprintf(outf, "0};\n\n");
|
|
|
|
}
|
|
|
|
/*
|
|
* Search a field list for a particular fieldname
|
|
* and return an integer id for that field based on
|
|
* it's position in the list [0..n]. Return -1 if
|
|
* there's no match.
|
|
*/
|
|
|
|
int
|
|
field_id(char *fieldname, struct field_list *field_list)
|
|
{
|
|
struct field_list *fields;
|
|
int id=0;
|
|
|
|
/* If the strings null then fail immediately */
|
|
|
|
if (!fieldname)
|
|
return (-1);
|
|
|
|
for (fields = field_list; fields; fields = fields->next_field, id++) {
|
|
if (!strcmp(fieldname, fields->fieldname))
|
|
return (id);
|
|
}
|
|
|
|
fprintf(stderr, "Field %s, not found in specification\n", fieldname);
|
|
return (-1);
|
|
}
|
|
|
|
/* Calculate a default height for a field */
|
|
|
|
calc_field_height(struct field *field, char *string)
|
|
{
|
|
|
|
int len;
|
|
|
|
len = strlen(string);
|
|
|
|
if (!field->width) {
|
|
/*
|
|
* This is a failsafe, this routine shouldn't be called
|
|
* with a width of 0, the width should be determined
|
|
* first.
|
|
*/
|
|
field->height = 1;
|
|
return;
|
|
}
|
|
|
|
if (len < field->width) {
|
|
field->height = 1;
|
|
return;
|
|
} else
|
|
field->height = len / field->width;
|
|
|
|
if ((field->height*field->width) < len)
|
|
field->height++;
|
|
|
|
return;
|
|
}
|
|
|
|
/* Add a field to the pre-defined fields list */
|
|
|
|
define_field(char *defname, char *fieldname)
|
|
{
|
|
field = malloc(sizeof (struct field_list));
|
|
if (!field) {
|
|
fprintf(stderr,"Failed to allocate memory for form field\n");
|
|
exit(1);
|
|
}
|
|
field->fieldname = fieldname;
|
|
field->defname = defname;
|
|
field->field.type = type;
|
|
field->field.height = height;
|
|
field->field.width = width;
|
|
field->attr = attr;
|
|
field->selattr = selattr;
|
|
switch (type) {
|
|
case F_TEXT:
|
|
field->field.field.text = malloc(sizeof (struct text_field));
|
|
if (!field->field.field.text) {
|
|
fprintf(stderr,
|
|
"Failed to allocate memory for text field\n");
|
|
exit (1);
|
|
}
|
|
field->field.field.text->text = text;
|
|
break;
|
|
case F_INPUT:
|
|
field->field.field.input = malloc(sizeof (struct input_field));
|
|
if (!field->field.field.input) {
|
|
fprintf(stderr,
|
|
"Failed to allocate memory for input field\n");
|
|
exit (1);
|
|
}
|
|
field->field.field.input->lbl_flag = lbl_flag;
|
|
field->field.field.input->label = label;
|
|
field->field.field.input->limit = limit;
|
|
break;
|
|
case F_MENU:
|
|
field->field.field.menu = malloc(sizeof (struct menu_field));
|
|
if (!field->field.field.menu) {
|
|
fprintf(stderr,
|
|
"Failed to allocate memory for menu field\n");
|
|
exit (1);
|
|
}
|
|
field->field.field.menu->selected = selected;
|
|
field->field.field.menu->no_options = no_options;
|
|
no_options = 0;
|
|
field->field.field.menu->options = (char **)menu_list;
|
|
cur_menu = 0;
|
|
break;
|
|
case F_ACTION:
|
|
field->field.field.action = malloc(sizeof (struct action_field));
|
|
if (!field->field.field.action) {
|
|
fprintf(stderr,
|
|
"Failed to allocate memory for action field\n");
|
|
exit (1);
|
|
}
|
|
field->field.field.action->text = text;
|
|
field->field.field.action->fn = (void *) function;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
if (!cur_field_def) {
|
|
field_defs = field;
|
|
cur_field_def = field;
|
|
} else {
|
|
cur_field_def->next_field = field;
|
|
cur_field_def = field;
|
|
}
|
|
width=0;
|
|
height = 0;
|
|
attr=0;
|
|
selattr=0;
|
|
limit=0;
|
|
}
|