Form Engine

Parses Form Descriptions, Handles User Input, and Integrates with External Commands for Calculations and Data Processing. More...

Functions
unsigned int	display_form (Init *init)
	Display the form on the screen, including text elements and fields, and set up the form window based on the form configuration.
int	field_navigator (Form *form)
	Handle user input for field entry, allowing navigation between fields and looping until an exit action is selected.
int	form_desc_error (Form *form, int in_line_num, char *in_buf, char *em)
	Handle errors encountered while parsing the form description file, providing detailed error messages that include the file name, line number, and the specific error encountered.
void	form_display_fields (Form *form)
	Display form fields on the screen, populating field values and formatting them according to the form configuration.
int	form_engine (Init *init)
	Form main processing loop.
int	form_exec_cmd (Form *form)
	Execute a command specified in the form description file, passing form field values as arguments, and optionally redirecting output to a file.
int	form_exec_receiver (Init *init)
	Execute a command specified by the -R option on the form command line.
int	form_parse_desc (Form *form)
	Parse the form description file to populate the Form data structure with field definitions, text elements, and other configuration specified in the description file.
int	form_post (Init *init)
	Handle post-processing after field entry, allowing user to edit data, execute a provider command, or write data to an output file.
int	form_process (Init *init)
	Handle integration with a getter program which will provide field data.
int	form_read_data (Form *form)
	Read initial data for form fields from a specified input source, such as a file or standard input, and populate the form fields with the data.
int	form_write (Form *form)
	Write form field values to a specified output destination, such as a file or standard output, based on the form configuration and user input.
int	init_form (Init *init, int argc, char **argv, uint begy, uint begx)
	Initialize form data structure and parse description file.

Detailed Description

Parses Form Descriptions, Handles User Input, and Integrates with External Commands for Calculations and Data Processing.

Function Documentation

display_form()

unsigned int display_form

(

Init *

init

)

Display the form on the screen, including text elements and fields, and set up the form window based on the form configuration.

Parameters

init	A pointer to the Init structure containing form data and state.

Returns

0 on success, or a non-zero value if an error occurs while creating the form window or rendering the form elements.

Definition at line 527 of file form_engine.c.

                                      {
    uint n, flin, fcol;
    char tmp_str[MAXLEN];
 
    Form *form = init->form;
    form->lines = 0;
    for (n = 0; n < form->dcnt; n++)
        if (form->text[n]->line > form->lines)
            form->lines = form->text[n]->line;
    for (n = 0; n < form->fcnt; n++)
        if (form->field[n]->line > form->lines)
            form->lines = form->field[n]->line;
    form->lines += 3;
    if (form->lines > (LINES - form->begy))
        form->lines = LINES - form->begy;
    for (n = 0; n < form->fcnt; n++) {
        if (form->field[n]->line >= (form->lines - 2))
            form->fcnt = n;
    }
    form->cols += 2;
    if (form->cols > (COLS - form->begx - 3))
        form->cols = COLS - form->begx - 3;
    if (ui_tracked_sfc_box(form->lines, form->cols, form->begy, form->begx, form->title)) {
        strnz__cpy(tmp_str, _("ui_tracked_sfc_box failed: "), MAXLEN - 1);
        strnz__cat(tmp_str, form->title, MAXLEN - 1);
        ui_perror(tmp_str);
        return (1);
    }
    UiSurface *sfc = ui_surface[sfc_ptr];
#ifdef DEBUG_IMMEDOK
    ui_immedok(sfc, WIN, true);
    ui_immedok(sfc, BOX, true);
#endif
    for (form->fidx = 0; form->fidx < form->fcnt; form->fidx++) {
        if (form->brackets[0] != '\0' && form->brackets[1] != '\0') {
            flin = form->field[form->fidx]->line + 1;
            fcol = form->field[form->fidx]->col;
            ui_mvwadd_wch(sfc, BOX, flin, fcol, &cell_brktl);
            fcol += form->field[form->fidx]->len + 1;
            ui_mvwadd_wch(sfc, BOX, flin, fcol, &cell_brktr);
        }
    }
    for (n = 0; n < form->dcnt; n++) {
        strnz(form->text[n]->str, form->cols - 3);
        ui_mvwaddstr(sfc, WIN, form->text[n]->line, form->text[n]->col,
                     form->text[n]->str);
    }
    ui_render();
    form_display_fields(form);
    return 0;
}

References Form::begx, Form::begy, Form::brackets, cell_brktl, cell_brktr, Field::col, Text::col, Form::cols, Form::dcnt, Form::fcnt, Form::fidx, Form::field, Init::form, form_display_fields(), Field::len, Field::line, Text::line, Form::lines, sfc_ptr, Text::str, strnz(), strnz__cat(), strnz__cpy(), Form::text, Form::title, ui_mvwadd_wch(), ui_mvwaddstr(), ui_perror(), ui_render(), ui_surface, and ui_tracked_sfc_box().

Referenced by form_engine().

Here is the call graph for this function:

Here is the caller graph for this function:

field_navigator()

int field_navigator

(

Form *

form

)

Handle user input for field entry, allowing navigation between fields and looping until an exit action is selected.

Parameters

form	A pointer to the Form structure containing form data and state.

Returns

An integer status code indicating the next action for the form processing loop (e.g., FA_ACCEPT, FA_HELP, FA_CALC, FA_CANCEL).

This function manages user input for field entry, including navigation between fields and handling of special keys for accepting, canceling, requesting help, or performing calculations. The function loops until the user selects an exit action (e.g., accept or cancel).

Definition at line 466 of file form_engine.c.

                                {
 
    if (form->fidx >= form->fcnt)
        form->fidx = 0;
    while (1) {
        int cmd_key = field_editor(form);
        switch (cmd_key) {
        case UIKEY_F01: // F1 Help
            return (FA_HELP);
        case UIKEY_F02: // F2 Process
        case UIKEY_F03: // F3 Calculate
        case UIKEY_F04: // F4 Query
            if (form->f_process)
                return (FA_CALC);
            break;
        case UIKEY_F09: // F9 Cancel
            return (FA_CANCEL);
        case UIKEY_F10: // F10 Accept
            return (FA_ACCEPT);
        case 'k':
        case UIKEY_UP:
            if (form->fidx != 0)
                form->fidx--;
            break;
        case '\r':
        case UIKEY_ENTER:
            if (form->fidx < form->fcnt - 1)
                form->fidx++;
            else if (form->fidx == form->fcnt - 1)
                return (FA_ACCEPT);
            break;
        case 'j':
        case UIKEY_DOWN:
            if (form->fidx < form->fcnt - 1)
                form->fidx++;
            else if (form->fidx == form->fcnt - 1)
                return (FA_ACCEPT);
            break;
        case UIKEY_BUTTON1:
            break;
        default:
            break;
        }
    }
}

References Form::f_process, FA_ACCEPT, FA_CALC, FA_CANCEL, FA_HELP, Form::fcnt, Form::fidx, and field_editor().

Referenced by form_engine().

Here is the call graph for this function:

Here is the caller graph for this function:

form_desc_error()

int form_desc_error	(	Form *	form,
		int	in_line_num,
		char *	in_buf,
		char *	em )

Handle errors encountered while parsing the form description file, providing detailed error messages that include the file name, line number, and the specific error encountered.

Parameters

form	A pointer to the Form structure containing form data and state.
in_line_num	The line number in the description file where the error occurred.
in_buf	The content of the line that caused the error, for context.
em	A specific error message describing the nature of the error.

Returns

An integer status code indicating how the user responded to the error message (e.g., which key they pressed to acknowledge the error).

Definition at line 1150 of file form_engine.c.

                                                                         {
    int cmd_key;
    ssnprintf(em0, MAXLEN - 1, "%s: %s", __FILE__, em);
    ssnprintf(em1, MAXLEN - 1, _("Desc file: %s, line: %d"), form->mapp_spec,
              in_line_num);
    strnz__cpy(em2, in_buf, MAXLEN - 1);
    cmd_key = ui_display_error(em0, em1, em2, nullptr);
    return cmd_key;
}

References em0, em1, em2, Form::mapp_spec, ssnprintf(), strnz__cpy(), and ui_display_error().

Referenced by form_parse_desc().

Here is the call graph for this function:

Here is the caller graph for this function:

form_display_fields()

void form_display_fields

(

Form *

form

)

Display form fields on the screen, populating field values and formatting them according to the form configuration.

Parameters

form	A pointer to the Form structure containing form data and state.

This function iterates through the defined form fields, formats their display values based on the specified fill character and field length, and renders them on the form window. It also updates the chyron with available commands for user interaction.

Definition at line 587 of file form_engine.c.

                                     {
    uint y, x;
    uint pos = 0;
    for (form->fidx = 0; form->fidx < form->fcnt; form->fidx++) {
        if (form->field[form->fidx]->col + form->field[form->fidx]->len + 2 >
            form->cols)
            form->field[form->fidx]->len =
                form->cols - (form->field[form->fidx]->col + 2);
        // Make filler_cc
        size_t fl = form->field[form->fidx]->len;
        char *d = form->field[form->fidx]->filler_s;
        size_t char_bytes = strlen(form->fill_char);
        for (size_t i = 0; i < fl; i++) {
            memcpy(d, form->fill_char, char_bytes);
            d += char_bytes;
        }
        d = nullptr;
 
        if (form->field[form->fidx]->accept_s[0] != '\0') {
            strnz(form->field[form->fidx]->accept_s, form->field[form->fidx]->len);
            // d = form->field[form->fidx]->accept_s;
        } else {
            memset(form->field[form->fidx]->accept_s, 0, MAXLEN);
            // d = form->field[form->fidx]->accept_s;
        }
        strnz(form->field[form->fidx]->display_s, form->field[form->fidx]->len);
 
        y = form->field[form->fidx]->line;
        x = form->field[form->fidx]->col;
 
        UiSurface *sfc = ui_surface[sfc_ptr];
        pos = 0;
        ui_mbstr_to_cellstr(sfc, WIN,
                            form->field[form->fidx]->filler_cc,
                            form->field[form->fidx]->filler_s,
                            &cell_fill_char,
                            &pos,
                            form->field[form->fidx]->len + 1);
 
        ui_mvwadd_wchstr(sfc, WIN, y, x, form->field[form->fidx]->filler_cc);
        ui_render();
 
        pos = 0;
        ui_mbstr_to_cellstr(sfc, WIN, form->field[form->fidx]->display_cc, form->field[form->fidx]->display_s, &cell_nt, &pos, form->field[form->fidx]->len + 1);
 
        ui_mvwadd_wchnstr(sfc, WIN, y, x, form->field[form->fidx]->display_cc, form->field[form->fidx]->len);
        ui_render();
    }
    return;
}

References Field::accept_s, cell_fill_char, cell_nt, Field::col, Form::cols, Field::display_cc, Field::display_s, Form::fcnt, Form::fidx, Form::field, Form::fill_char, Field::filler_cc, Field::filler_s, Field::len, Field::line, sfc_ptr, strnz(), ui_mvwadd_wchnstr(), ui_mvwadd_wchstr(), ui_render(), and ui_surface.

Referenced by display_form(), and form_process().

Here is the call graph for this function:

Here is the caller graph for this function:

form_engine()

int form_engine

(

Init *

init

)

Form main processing loop.

Parameters

init	A pointer to the Init structure containing form data and state.

Returns

0 on successful completion, or a non-zero value if the user cancels the form or if an error occurs during processing.

1. Parse the form description file to populate the form data structure.
2. Read any initial data for the form fields from a specified input source.
3. Display the form on the screen with the initial field values.
4. Enter a loop to handle user input for field entry, calculation, help, and cancellation: a. If the user selects the accept action, perform any necessary calculations or post-processing, and then either return to field entry or exit the loop if the form is accepted. b. If the user selects the help action, display the help screen and return to the form after the user exits the help screen. c. If the user selects the cancel action, exit the loop and return a cancel status.

Definition at line 118 of file form_engine.c.

                            {
    char tmp_str[MAXLEN];
    int form_action;
    char *eargv[MAXARGS];
    int eargc;
 
    Form *form = init->form;
    if (form == nullptr) {
        ui_perror(_("FORM: form data structure is nullptr"));
    }
    if (form_parse_desc(form)) {
        return 0;
    }
    form_read_data(form);
    display_form(init);
    form->chyron = ui_new_chyron(ui_surface[sfc_ptr], WIN);
    ui_set_chyron_key(form->chyron, 1, _("F1 Help"), UIKEY_F01);
    ui_set_chyron_key_cb(form->chyron, 2, _("F2 Process"), UIKEY_F02, cell_nt_hl_rev);
    ui_set_chyron_key_cb(form->chyron, 3, _("F3 Calculate"), UIKEY_F03, cell_nt_hl_rev);
    ui_set_chyron_key_cb(form->chyron, 4, _("F4 Query"), UIKEY_F04, cell_nt_hl_rev);
    ui_set_chyron_key_cb(form->chyron, 5, _("F5 Edit"), UIKEY_F05, cell_nt_hl_rev);
    ui_set_chyron_key(form->chyron, 9, _("F9 Cancel"), UIKEY_F09);
    ui_set_chyron_key(form->chyron, 10, _("F10 Accept"), UIKEY_F10);
    ui_set_chyron_key(form->chyron, 18, "INS", UIKEY_IC);
    form->chyron->key[2]->active = false;  // F2 Process
    form->chyron->key[3]->active = false;  // F3 Calculate
    form->chyron->key[4]->active = false;  // F4 Query
    form->chyron->key[5]->active = false;  // F5 Edit
    form->chyron->key[18]->active = false; // Insert
    ui_compile_chyron(form->chyron);
    UiSurface *sfc = ui_surface[sfc_ptr];
    ui_display_chyron(sfc, 1, form->chyron, form->lines - 1, form->chyron->l);
    // 1 F1 Help
    // 2 F2 Process
    // 3 F3 Calculate
    // 4 F4 Query
    // 5 F5 Edit
    // 9 F9 Cancel
    // 10 F10 Accept
    form->fidx = 0;
    form_action = 0;
    while (1) {
        if (form_action == 0 || form_action == FA_CONTINUE)
            form_action = field_navigator(form);
        form->chyron->key[18]->active = false; // Insert
        switch (form_action) {
        case FA_ACCEPT:
            if (form->f_process || form->f_calculate || form->f_query)
                form_action = form_process(init);
            else
                form_action = form_post(init);
            if (form_action == FA_HELP || form_action == FA_CANCEL ||
                form_action == FA_CONTINUE || form_action == FA_END)
                continue;
            if (form_action == FA_ACCEPT) {
                form_action = FA_END;
                continue;
            }
            break;
        case FA_END:
            if (form->f_out_spec || form->out_spec[0] != '\0')
                form_write(form);
            if (form->f_receiver_cmd || form->receiver_cmd[0] != '\0')
                form_exec_receiver(init);
            break;
        case FA_HELP:
            if (form->f_help_spec && form->help_spec[0] != '\0')
                strnz__cpy(tmp_str, form->help_spec, MAXLEN - 1);
            else {
                strnz__cpy(tmp_str, init->mapp_help, MAXLEN - 1);
                strnz__cat(tmp_str, "/", MAXLEN - 1);
                strnz__cat(tmp_str, FORM_HELP_FILE, MAXLEN - 1);
            }
            eargc = 0;
            eargv[eargc++] = strdup("view");
            eargv[eargc++] = strdup("-Nf");
            eargv[eargc++] = strdup(tmp_str);
            eargv[eargc] = nullptr;
            init->lines = 30;
            init->cols = 66;
            init->begy = form->begy + 1;
            init->begx = form->begx + 1;
            strnz__cpy(init->title, _("Form Help"), MAXLEN - 1);
            popup_view(init, eargc, eargv, init->lines, init->cols, init->begy,
                       init->begx);
            destroy_argv(eargc, eargv);
            form_action = FA_CONTINUE;
            break;
        case FA_CANCEL:
            return FA_CANCEL;
        default:
            form_action = FA_CONTINUE;
            break;
        }
        if (form_action == FA_END)
            break;
    }
    return 0;
}

References Form::begx, Init::begx, Form::begy, Init::begy, cell_nt_hl_rev, Form::chyron, Init::cols, destroy_argv(), display_form(), Form::f_calculate, Form::f_help_spec, Form::f_out_spec, Form::f_process, Form::f_query, Form::f_receiver_cmd, FA_ACCEPT, FA_CANCEL, FA_CONTINUE, FA_END, FA_HELP, Form::fidx, field_navigator(), Init::form, form_exec_receiver(), form_parse_desc(), form_post(), form_process(), form_read_data(), form_write(), Form::help_spec, Form::lines, Init::lines, Init::mapp_help, Form::out_spec, popup_view(), Form::receiver_cmd, sfc_ptr, strnz__cat(), strnz__cpy(), Init::title, ui_compile_chyron(), ui_display_chyron(), ui_new_chyron(), ui_perror(), ui_set_chyron_key(), ui_set_chyron_key_cb(), and ui_surface.

Referenced by init_form().

Here is the call graph for this function:

Here is the caller graph for this function:

form_exec_cmd()

int form_exec_cmd

(

Form *

form

)

Execute a command specified in the form description file, passing form field values as arguments, and optionally redirecting output to a file.

Parameters

form	A pointer to the Form structure containing form data and state.

Returns

0 on success, or a non-zero value if an error occurs while constructing or executing the command.

Definition at line 909 of file form_engine.c.

                              {
    char earg_str[MAXLEN + 1];
    uint i;
    strnz__cpy(earg_str, form->receiver_cmd, MAXLEN - 1);
    for (i = 0; i < form->fcnt; i++) {
        strnz__cat(earg_str, " ", MAXLEN - 1);
        strnz__cat(earg_str, form->field[i]->accept_s, MAXLEN - 1);
    }
    if (form->f_out_spec && form->f_process) {
        strnz__cat(earg_str, " >", MAXLEN - 1);
        strnz__cat(earg_str, form->out_spec, MAXLEN - 1);
    }
    shell(earg_str);
    return 0;
}

References Field::accept_s, Form::f_out_spec, Form::f_process, Form::fcnt, Form::field, Form::out_spec, Form::receiver_cmd, shell(), strnz__cat(), and strnz__cpy().

Here is the call graph for this function:

form_exec_receiver()

int form_exec_receiver

(

Init *

init

)

Execute a command specified by the -R option on the form command line.

Parameters

init	A pointer to the Init structure

Returns

0 on success, or a non-zero value if an error occurs while constructing or executing the command.

This function constructs a command by taking the receiver_cmd appending field values as arguments, and handling special cases such as multiple command arguments or placeholder substitution. It then executes the command, either displaying the output in a popup view if the command is "view", or executing it directly in a child process for other commands. The function also handles error cases and ensures that resources are properly freed.

This is the line that gets the selected objects

initialize popup_view arguments and execute popup_view to display command output within form interface

fork failed, free eargv and return error

Prevent child process from writing to terminal

Child process to execute command

If execvp returns, it means execution failed, so free eargv and print error message before exiting

Definition at line 936 of file form_engine.c.

                                   {
    int rc = -1;
    uint eargc;
    char *eargv[MAXARGS];
    char tmp_str[MAXLEN] = {'\0'};
    char title[MAXLEN];
    char sav_arg[MAXLEN];
    char *out_s;
    uint eargx = 0;
    uint i = 0;
    pid_t pid = 0;
    bool f_append_values = false;
 
    title[0] = '\0';
    Form *form = init->form;
    if (form->receiver_cmd[0] == '\0')
        return -1;
    // Eliminate leading and trailing quotes
    if (form->receiver_cmd[0] == '\\' || form->receiver_cmd[0] == '\"') {
        size_t len = strlen(form->receiver_cmd);
        if (len > 1 && form->receiver_cmd[len - 1] == '\"') {
            memmove(form->receiver_cmd, form->receiver_cmd + 1, len - 2);
            form->receiver_cmd[len - 2] = '\0';
        }
    }
    eargc = str_to_args(eargv, form->receiver_cmd, MAXARGS - 1);
    tmp_str[0] = '\0';
    if (form->f_multiple_cmd_args) {
        // concatenate fields into a single argument
        for (i = 0; i < form->fcnt; i++) {
            if (form->field[i]->accept_s[0] && eargc < MAXARGS) {
                if (tmp_str[0] != '\0')
                    strnz__cat(tmp_str, " ", MAXLEN - 1);
                strnz__cat(tmp_str, form->field[i]->accept_s, MAXLEN - 1);
            }
        }
        eargv[eargc++] = strdup(tmp_str);
    } else {
        f_append_values = false;
        // find lines with "%%" to determine where to insert field values
        i = 0;
        while (i < eargc) {
            if (strstr(eargv[i], "%%") != nullptr) {
                tmp_str[0] = '\0';
                f_append_values = true;
                strnz__cpy(sav_arg, eargv[i], MAXLEN - 1);
                eargx = i;
                break;
            }
            i++;
        }
        for (i = 0; i < form->fcnt; i++) {
            // concatenate field values onto tmp_str
            if (form->field[i]->accept_s[0] && eargc < MAXARGS - 1) {
                if (f_append_values == true) {
                    if (tmp_str[0] != '\0')
                        strnz__cat(tmp_str, " ", MAXLEN - 1);
                    strnz__cat(tmp_str, form->field[i]->accept_s, MAXLEN - 1);
                    continue;
                }
                eargv[eargc++] = strdup(form->field[i]->accept_s);
            }
        }
        // replace "%%" with concatenated field values
        if (f_append_values == true) {
            if (eargv[eargx] != nullptr) {
                free(eargv[eargx]);
                eargv[eargx] = nullptr;
            }
            out_s = rep_substring(sav_arg, "%%", tmp_str);
            if (out_s == nullptr || out_s[0] == '\0') {
                i = 0;
                while (i < eargc) {
                    if (eargv[i] != nullptr)
                        free(eargv[i]);
                    i++;
                }
                ui_perror(_("rep_substring() failed in form_exec_objects"));
                return 1;
            }
            strnz__cpy(title, out_s, MAXLEN - 1);
            eargv[eargx] = strdup(out_s);
            if (out_s != nullptr) {
                free(out_s);
                out_s = nullptr;
            }
        }
    }
    if (eargc > 0)
        eargv[eargc] = nullptr;
    base_name(tmp_str, eargv[0]);
    if (tmp_str[0] != '\0' && (strcmp(tmp_str, "view") == 0)) {
        init->lines = 60;
        init->cols = 80;
        init->begy = form->begy + 1;
        init->begx = form->begx + 1;
        if (title[0] != '\0')
            strnz__cpy(init->title, title, MAXLEN - 1);
        else
            strnz__cpy(init->title, eargv[eargc], MAXLEN - 1);
        popup_view(init, eargc, eargv, init->lines, init->cols, init->begy,
                   init->begx);
        i = 0;
        while (i < eargc) {
            if (eargv[i] != nullptr)
                free(eargv[i]);
            i++;
        }
        return 0;
    } else {
        ui_endwin();
        if ((pid = fork()) == -1) {
            i = 0;
            while (i < eargc) {
                if (eargv[i] != nullptr)
                    free(eargv[i]);
                i++;
            }
            ui_perror(_("fork() failed in form_exec_objects"));
            return (1);
        }
        if (pid == 0) {
            int dev_null = open("/dev/null", O_WRONLY);
            if (dev_null == -1) {
                ui_perror(_("open(/dev/null) failed in init_form child process"));
                exit(EXIT_FAILURE);
            }
            dup2(dev_null, STDERR_FILENO);
            close(dev_null);
            execvp(eargv[0], eargv);
            strnz__cpy(tmp_str, _("Can't exec form cmd: "), MAXLEN - 1);
            strnz__cat(tmp_str, eargv[0], MAXLEN - 1);
            ui_perror(tmp_str);
            exit(EXIT_FAILURE);
        }
    }
    waitpid(pid, nullptr, 0);
    destroy_argv(eargc, eargv);
    sig_prog_mode();
    ui_restore_wins();
    return rc;
}

References Field::accept_s, base_name(), Form::begx, Init::begx, Form::begy, Init::begy, Init::cols, destroy_argv(), Form::f_multiple_cmd_args, Form::fcnt, Form::field, Init::form, Init::lines, popup_view(), Form::receiver_cmd, rep_substring(), sig_prog_mode(), str_to_args(), strnz__cat(), strnz__cpy(), Init::title, ui_endwin(), ui_perror(), and ui_restore_wins().

Referenced by form_engine().

Here is the call graph for this function:

Here is the caller graph for this function:

form_parse_desc()

int form_parse_desc

(

Form *

form

)

Parse the form description file to populate the Form data structure with field definitions, text elements, and other configuration specified in the description file.

Parameters

form	A pointer to the Form structure containing form data and state.

Returns

0 on success, or a non-zero value if an error occurs while parsing the description file (e.g., file not found, invalid format, missing directives).

Definition at line 646 of file form_engine.c.

                                {
    FILE *form_desc_fp;
    char *token;
    char *s;
    uint cols = 0;
    uint i, l;
    int in_line_num = 0;
    char in_buf[BUFSIZ];
    char tmp_buf[BUFSIZ];
    char *tmp_buf_p;
    char tmp_str[BUFSIZ];
    char delim[5];
    char directive;
 
    form_desc_fp = fopen(form->mapp_spec, "r");
    if (form_desc_fp == nullptr) {
        ssnprintf(em0, MAXLEN - 1, "%s, line: %d", __FILE__, __LINE__ - 2);
        strnz__cpy(em1, "fopen ", MAXLEN - 1);
        strnz__cat(em1, form->mapp_spec, MAXLEN - 1);
        strerror__r(errno, em2, MAXLEN);
        ui_display_error(em0, em1, em2, nullptr);
        return (1);
    }
    for (i = 0; i < FIELD_MAXCNT; i++) {
        form->field[i] = calloc(1, sizeof(Field));
        if (!form->field[i]) {
            sprintf(tmp_str, _("FORM: calloc failed for fields"));
            ui_abend(EXIT_FAILURE, tmp_str);
        }
    }
    for (i = 0; i < FIELD_MAXCNT; i++) {
        form->text[i] = calloc(1, sizeof(Text));
        if (!form->text[i]) {
            sprintf(tmp_str, _("FORM: calloc failed for text"));
            ui_abend(EXIT_FAILURE, tmp_str);
        }
    }
    form->didx = 0;
    form->fidx = 0;
    form->fcnt = 0;
    form->cols = 34;
    while ((fgets(in_buf, MAXLEN, form_desc_fp)) != nullptr) {
        s = in_buf;
        in_line_num++;
        l = trim(in_buf);
        if (l == 0)
            continue;
        if (*s == D_COMMENT)
            continue;
        delim[0] = '\n';
        delim[1] = in_buf[1];
        delim[2] = '\0';
        strnz__cpy(tmp_buf, in_buf, MAXLEN - 1);
        tmp_buf_p = tmp_buf;
        if (!(token = strtok(tmp_buf_p, delim))) {
            continue;
        }
        directive = *token;
        switch ((int)directive) {
        case D_COMMENT:
            break;
        case D_CALC:
            form->f_calculate = true;
            break;
        case D_QUERY:
            form->f_query = true;
            break;
        case D_GETTER:
            form->f_process = true;
            break;
        case D_CMD:
            if (!(token = strtok(nullptr, delim))) {
                form_desc_error(form, in_line_num, in_buf,
                                _("FORM: receiver_cmd delimiter"));
                continue;
            }
            strnz__cpy(form->receiver_cmd, token, MAXLEN - 1);
            break;
        case D_HELP:
            if (!(token = strtok(nullptr, delim))) {
                form_desc_error(form, in_line_num, in_buf,
                                _("FORM: help_spec delimiter"));
            }
            strnz__cpy(form->help_spec, token, MAXLEN - 1);
            break;
        case D_FIELD:
            if (form->field[form->fidx] == nullptr) {
                sprintf(tmp_str, _("FORM: calloc failed for fields"));
                ui_abend(EXIT_FAILURE, tmp_str);
            }
            if (!(token = strtok(nullptr, delim))) {
                form_desc_error(form, in_line_num, in_buf,
                                _("FORM: line number delimiter"));
                return 1;
            }
            form->field[form->fidx]->line = atoi(token);
            if (form->field[form->fidx]->line >= FIELD_MAXCNT) {
                form_desc_error(form, in_line_num, in_buf,
                                _("FORM: invalid line number"));
                return 1;
            }
            if (!(token = strtok(nullptr, delim))) {
                form_desc_error(form, in_line_num, in_buf,
                                _("FORM: column number delimiter"));
                return 1;
            }
            form->field[form->fidx]->col = atoi(token);
            if (form->field[form->fidx]->col >= FIELD_MAXLEN) {
                form_desc_error(form, in_line_num, in_buf,
                                _("FORM: invalid column number"));
                break;
            }
            if (!(token = strtok(nullptr, delim))) {
                strnz__cpy(tmp_str, in_buf, MAXLEN - 1);
                form_desc_error(form, in_line_num, tmp_str, _("FORM: length delimiter"));
                break;
            }
            form->field[form->fidx]->len = atoi(token);
            if (form->field[form->fidx]->len > FIELD_MAXLEN) {
                form_desc_error(form, in_line_num, in_buf, _("FORM: invalid length"));
                break;
            }
            if (!(token = strtok(nullptr, delim))) {
                form_desc_error(form, in_line_num, in_buf,
                                _("FORM: validation code delimiter"));
                break;
            }
            form->field[form->fidx]->ff = 0;
            for (i = 0; i < FF_INVALID; i++) {
                str_to_lower(token);
                str_to_lower(ff_tbl[i]);
                if (!strcmp(token, ff_tbl[i])) {
                    form->field[form->fidx]->ff = i;
                    break;
                }
            }
            if (form->field[form->fidx]->ff >= FF_INVALID) {
                form_desc_error(form, in_line_num, in_buf,
                                _("FORM: invalid format code"));
                break;
            }
            cols =
                form->field[form->fidx]->col + form->field[form->fidx]->len + 1;
            if (cols > form->cols)
                form->cols = cols;
            form->fidx++;
            form->fcnt = form->fidx;
            break;
        case D_TEXT:
            if (form->text[form->didx] == nullptr) {
                sprintf(tmp_str, _("FORM: calloc failed for text"));
                ui_abend(EXIT_FAILURE, tmp_str);
            }
            if (!(token = strtok(nullptr, delim))) {
                form_desc_error(form, in_line_num, in_buf,
                                _("FORM: line number delimiter"));
                break;
            }
            form->text[form->didx]->line = atoi(token);
            if (form->text[form->didx]->line >= FIELD_MAXCNT) {
                form_desc_error(form, in_line_num, in_buf,
                                _("FORM: invalid line number"));
                break;
            }
            if (!(token = strtok(nullptr, delim))) {
                form_desc_error(form, in_line_num, in_buf,
                                _("FORM: column number delimiter"));
                break;
            }
            form->text[form->didx]->col = atoi(token);
            if (form->text[form->didx]->col >= FIELD_MAXLEN) {
                form_desc_error(form, in_line_num, in_buf,
                                _("FORM: invalid column number"));
                break;
            }
            if (!(token = strtok(nullptr, delim))) {
                form_desc_error(form, in_line_num, in_buf, _("FORM: text delimiter"));
                break;
            }
            strnz__cpy(form->text[form->didx]->str, token, MAXLEN - 1);
            form->text[form->didx]->len = strlen(form->text[form->didx]->str);
            if (form->text[form->didx]->len > FIELD_MAXLEN) {
                form_desc_error(form, in_line_num, in_buf, _("FORM: invalid length"));
                break;
            }
            cols =
                form->text[form->didx]->col + form->text[form->didx]->len + 1;
            if (cols > form->cols)
                form->cols = cols;
            form->didx++;
            form->dcnt = form->didx;
            break;
        case D_HEADER:
            if ((token = strtok(nullptr, delim))) {
                strnz__cpy(form->title, token, MAXLEN - 1);
            }
            break;
        default:
            form_desc_error(form, in_line_num, in_buf, _("invalid directive"));
            break;
        }
    }
    fclose(form_desc_fp);
    if (form->didx < 1 && form->fidx < 1) {
        ssnprintf(em0, MAXLEN - 1, _("%s, line: %d"), __FILE__, __LINE__);
        ssnprintf(em1, MAXLEN - 1, "%s", _("Error in description file:"));
        ssnprintf(em2, MAXLEN - 1, "%s", form->mapp_spec);
        ui_display_error(em0, em1, em2, nullptr);
        return (1);
    }
    return (0);
}

References Field::col, Text::col, Form::cols, Form::dcnt, Form::didx, em0, em1, em2, Form::f_calculate, Form::f_process, Form::f_query, Form::fcnt, Field::ff, FF_INVALID, ff_tbl, Form::fidx, Form::field, form_desc_error(), Form::help_spec, Field::len, Text::len, Field::line, Text::line, Form::mapp_spec, Form::receiver_cmd, ssnprintf(), Text::str, str_to_lower(), strerror__r(), strnz__cat(), strnz__cpy(), Form::text, Form::title, trim(), ui_abend(), and ui_display_error().

Referenced by form_engine().

Here is the call graph for this function:

Here is the caller graph for this function:

form_post()

int form_post

(

Init *

init

)

Handle post-processing after field entry, allowing user to edit data, execute a provider command, or write data to an output file.

Parameters

init	A pointer to the Init structure containing form data and state.

Returns

An integer status code indicating the next action for the form processing loop (e.g., FA_CONTINUE, FA_CANCEL, FA_ACCEPT, FA_HELP).

Definition at line 223 of file form_engine.c.

                          {
    bool loop = true;
    int c, rc;
    click_y = click_x = -1;
    Form *form = init->form;
    UiSurface *sfc = ui_surface[sfc_ptr];
    UiEvent event;
    uint maxy, maxx;
    ui_cursor_move(sfc, WIN, form->lines - 1, 0);
    ui_wclrtoeol(sfc, WIN);
    // 1 F1 Help
    // 2 F2 Process
    // 3 F3 Calculate
    // 4 F4 Query
    // 5 F5 Edit
    // 9 F9 Cancel
    // 10 F10 Continue
    // 11 F10 Commit
    // 18 INS Insert
    form->chyron->key[5]->active = true;   // F5 Edit
    form->chyron->key[10]->active = false; // F10 Continue
    form->chyron->key[18]->active = false; // INS Insert
    ui_compile_chyron(form->chyron);
    rc = -1;
    while (loop) {
        if (rc == -1) {
            ui_display_chyron(sfc, WIN, form->chyron, form->lines - 1, form->chyron->l);
            c = ui_get_event(sfc, WIN, form->chyron, &event, -1);
            ui_getmaxyx(sfc, WIN, &maxy, &maxx);
            if (event.in_win == 1 && event.y == maxy - 1)
                c = ui_get_chyron_key(form->chyron, event.x);
        }
        switch (c) {
        case UIKEY_F01:
            return FA_HELP;
        case UIKEY_F05: // F5 Edit
            if (ui_is_set_chyron_key(form->chyron, 5)) {
                loop = false;
                rc = FA_CONTINUE;
                break;
            }
            continue;
        case UIKEY_F09:
            loop = false;
            rc = FA_CANCEL;
            break;
        case UIKEY_F10:
            loop = false;
            rc = FA_ACCEPT;
            break;
        case UIKEY_BUTTON1:
            continue;
        default:
            break;
        }
    }
    form->chyron->key[5]->active = false; // F5 Edit
    return rc;
}

References Form::chyron, click_x, click_y, FA_ACCEPT, FA_CANCEL, FA_CONTINUE, FA_HELP, Init::form, UiEvent::in_win, Form::lines, sfc_ptr, ui_compile_chyron(), ui_cursor_move(), ui_display_chyron(), ui_get_chyron_key(), ui_get_event(), ui_getmaxyx(), ui_is_set_chyron_key(), ui_surface, ui_wclrtoeol(), UiEvent::x, and UiEvent::y.

Referenced by form_engine().

Here is the call graph for this function:

Here is the caller graph for this function:

form_process()

int form_process

(

Init *

init

)

Handle integration with a getter program which will provide field data.

Parameters

init	A pointer to the Init structure containing form data and state.

Returns

An integer status code indicating the next action for the form processing loop (e.g., FA_CONTINUE, FA_CANCEL, FA_ACCEPT, FA_HELP).

This function provides integration with getter programs. The requirements are:

1. The form description file must have a line containing only 'C' (calculate), 'Q' (query), org 'G' (getter) to indicate that the form supports a getter.
2. The form description file must specify the provider command using a line starting with '!' followed by the command and its arguments.
3. The getter program must be able to accept field data from a file, from standard input, or as command line parameters.
4. The getter program must output field values in a format that can be read by the form (e.g., one value per line), either to a file or to standard output.

    The sequence of operations is as follows:
   
    1. The 'C', 'Q', or 'G' option causes Form to pause and display an
   

   UIKEY_F05 Calculate, Query, or Getter. option on the chyron.

1. The user can then cancel the operation by pressing UIKEY_F09 or activate the getter option by pressing UIKEY_F05.
2. Form outputs its data to file, standard output, or as command line parameters.
3. Form executes the getter program.
4. The getter program processes the data and outputs the results.
5. Form reads the results and populates the appropriate form fields.
6. Form presents the user with an option to edit the data, and the sequence restarts at 1.

This function forks and executes the getter executable as a child process, creates a pipe to read the output from the provider command, reads the output, and updates the Form fields.

Prevent child process from writing to terminal

Definition at line 320 of file form_engine.c.

                             {
    uint i, c;
    int rc;
    char earg_str[MAXLEN + 1];
    char *eargv[MAXARGS];
    int eargc;
    char file_spec[MAXLEN];
    bool loop = true;
    pid_t pid;
    int pipe_fd[2];
    UiSurface *sfc = ui_surface[sfc_ptr];
    UiEvent event;
    Form *form = init->form;
    ui_cursor_move(sfc, WIN, form->lines - 1, 0);
    uint maxy, maxx;
    //
    // 1 F1 Help
    // 2 F2 Process
    // 3 F3 Calculate
    // 4 F4 Query
    // 5 F5 Edit
    // 9 F9 Cancel
    // 10 F10 Continue
    // 11 F10 Commit
    form->chyron->key[2]->active = form->f_process > 0 ? true : false;
    form->chyron->key[3]->active = form->f_calculate > 0 ? true : false;
    form->chyron->key[4]->active = form->f_query > 0 ? true : false; // PgUp
    form->chyron->key[10]->active = false;                           // F10 Continue
    form->chyron->key[18]->active = false;                           // INS Insert
 
    while (loop) {
        ui_compile_chyron(form->chyron);
        ui_display_chyron(sfc, 1, form->chyron, form->lines - 1, form->chyron->l);
        click_y = click_x = -1;
        c = ui_get_event(sfc, WIN, form->chyron, &event, -1);
        ui_getmaxyx(sfc, WIN, &maxy, &maxx);
        if (event.in_win == 1 && event.y == maxy - 1)
            c = ui_get_chyron_key(form->chyron, event.x);
 
        switch (c) {
        case UIKEY_F01:
            return FA_HELP;
        case UIKEY_F02: // F2 Process
        case UIKEY_F03: // F3 Calculate
        case UIKEY_F04: // F4 Query
            if (form->f_out_spec)
                form_write(form);
            if (form->f_provider_cmd) {
                strnz__cpy(earg_str, form->provider_cmd, MAXLEN - 1);
                for (i = 0; i < form->fcnt; i++) {
                    strnz__cat(earg_str, " ", MAXLEN - 1);
                    strnz__cat(earg_str, form->field[i]->accept_s, MAXLEN - 1);
                }
                eargc = str_to_args(eargv, earg_str, MAXARGS);
                strnz__cpy(file_spec, eargv[0], MAXLEN - 1);
                base_name(eargv[0], file_spec);
                if (pipe(pipe_fd) == -1) {
                    destroy_argv(eargc, eargv);
                    ui_perror(_("pipe(pipe_fd) failed in init_form"));
                    return (1);
                }
                if ((pid = fork()) == -1) {
                    destroy_argv(eargc, eargv);
                    ui_perror(_("fork() failed in init_form"));
                    return (1);
                }
                if (pid == 0) { // Child
                    int dev_null = open("/dev/null", O_WRONLY);
                    if (dev_null == -1) {
                        ui_perror(_("open(/dev/null) failed in init_pick child process"));
                        exit(EXIT_FAILURE);
                    }
                    dup2(dev_null, STDERR_FILENO);
                    close(dev_null);
                    close(pipe_fd[P_READ]);
                    dup2(pipe_fd[P_WRITE], STDOUT_FILENO);
                    stdio_fdnames(stdio_names_str, "form_engine.c:367");
                    close(pipe_fd[P_WRITE]);
                    execvp(eargv[0], eargv);
                    ssnprintf(em0, MAXLEN, _("%s, line: %d"), __FILE__,
                              __LINE__ - 2);
                    strnz__cpy(em1, "execvp(", MAXLEN - 1);
                    strnz__cat(em1, eargv[0], MAXLEN - 1);
                    strnz__cat(em1, ", ", MAXLEN - 1);
                    strnz__cat(em1, earg_str, MAXLEN - 1);
                    strnz__cat(em1, ")", MAXLEN - 1);
                    strerror__r(errno, em2, MAXLEN);
                    ui_display_error(em0, em1, em2, nullptr);
                    exit(EXIT_FAILURE);
                } // Back to parent
                close(pipe_fd[P_WRITE]);
                form->in_fp = fdopen(pipe_fd[P_READ], "rb");
                form->f_in_pipe = true;
                form_read_data(form);
                close(pipe_fd[P_READ]);
                waitpid(pid, nullptr, 0);
                stdio_fdnames(stdio_names_str, "form_engine.c:387");
                destroy_argv(eargc, eargv);
                form_display_fields(form);
                form->chyron->key[2]->active = false; // F2 Process
                form->chyron->key[3]->active = false; // F3 Calculate
                form->chyron->key[4]->active = false; // F4 Query
                form->chyron->key[5]->active = true;  // F5 Edit
                form->chyron->key[10]->active = true; // F10 Accept
                ui_compile_chyron(form->chyron);
                continue;
            }
            break;
        case UIKEY_F05:
            if (ui_is_set_chyron_key(form->chyron, 5)) {
                loop = false;
                rc = FA_CONTINUE;
                break;
            }
            continue;
        case UIKEY_F09:
            loop = false;
            rc = FA_CANCEL;
            break;
        case UIKEY_F10:
            loop = false;
            rc = FA_ACCEPT;
            break;
        case UIKEY_BUTTON1:
            break;
        default:
            break;
        }
    }
    form->chyron->key[2]->active = false; // F2 Process
    form->chyron->key[3]->active = false; // F3 Calculate
    form->chyron->key[4]->active = false; // F4 Query
    form->chyron->key[5]->active = false; // F5 Edit
    return rc;
}

References Field::accept_s, base_name(), Form::chyron, click_x, click_y, destroy_argv(), em0, em1, em2, Form::f_calculate, Form::f_in_pipe, Form::f_out_spec, Form::f_process, Form::f_provider_cmd, Form::f_query, FA_ACCEPT, FA_CANCEL, FA_CONTINUE, FA_HELP, Form::fcnt, Form::field, Init::form, form_display_fields(), form_read_data(), form_write(), Form::in_fp, UiEvent::in_win, Form::lines, Form::provider_cmd, sfc_ptr, ssnprintf(), stdio_fdnames(), stdio_names_str, str_to_args(), strerror__r(), strnz__cat(), strnz__cpy(), ui_compile_chyron(), ui_cursor_move(), ui_display_chyron(), ui_display_error(), ui_get_chyron_key(), ui_get_event(), ui_getmaxyx(), ui_is_set_chyron_key(), ui_perror(), ui_surface, UiEvent::x, and UiEvent::y.

Referenced by form_engine().

Here is the call graph for this function:

Here is the caller graph for this function:

form_read_data()

int form_read_data

(

Form *

form

)

Read initial data for form fields from a specified input source, such as a file or standard input, and populate the form fields with the data.

Parameters

form	A pointer to the Form structure containing form data and state.

Returns

0 on success, or a non-zero value if an error occurs while reading the data or if the specified input source is invalid or empty.

Definition at line 866 of file form_engine.c.

                               {
    struct stat sb;
    char in_buf[MAXLEN];
    char field[MAXLEN];
    int cmd_key;
 
    if (!form->f_in_pipe) {
        if (form->f_in_spec && form->in_spec[0] != '\0') {
            if ((lstat(form->in_spec, &sb) == -1) || (sb.st_size == 0) ||
                ((form->in_fp = fopen(form->in_spec, "rb")) == nullptr)) {
                strnz__cat(em0, form->in_spec, MAXLEN - 1);
                if (sb.st_size == 0)
                    strnz__cpy(em1, _("File is empty"), MAXLEN - 1);
                else
                    strnz__cpy(em1, _("File does not exist"), MAXLEN - 1);
                strnz__cpy(em2, _("Fields will be blank or zero"), MAXLEN - 1);
                cmd_key = ui_display_error(em0, em1, em2, nullptr);
                if (cmd_key == UIKEY_F09)
                    return (1);
            }
            if (form->in_fp == nullptr)
                return (1);
        } else
            return (0);
    }
    form->fidx = 0;
    if (form->in_fp != nullptr) {
        while ((fgets(in_buf, MAXLEN, form->in_fp)) != nullptr) {
            if (form->fidx < FIELD_MAXCNT)
                strnz__cpy(field, in_buf, MAXLEN - 1);
            form_fmt_field(form, field);
            form->fidx++;
        }
        fclose(form->in_fp);
    }
    return (0);
}

References em0, em1, em2, Form::f_in_pipe, Form::f_in_spec, Form::fidx, form_fmt_field(), Form::in_fp, Form::in_spec, strnz__cat(), strnz__cpy(), and ui_display_error().

Referenced by form_engine(), and form_process().

Here is the call graph for this function:

Here is the caller graph for this function:

form_write()

int form_write

(

Form *

form

)

Write form field values to a specified output destination, such as a file or standard output, based on the form configuration and user input.

Parameters

form	A pointer to the Form structure containing form data and state.

Returns

0 on success, or a non-zero value if an error occurs while writing the data or if the specified output destination is invalid.

Definition at line 1094 of file form_engine.c.

                           {
    uint n;
    if (form->out_spec[0] == '\0' || strcmp(form->out_spec, "-") == 0 ||
        strcmp(form->out_spec, "/dev/stdout") == 0) {
        strnz__cpy(form->out_spec, "/dev/stdout", MAXLEN - 1);
        close(form->out_fd);
        // form->out_fd = open(form->out_spec, O_CREAT | O_RDWR | O_TRUNC,
        // 0644);
        form->out_fd = dup(STDOUT_FILENO);
        if (form->out_fd == -1) {
            ssnprintf(em0, MAXLEN - 1, _("%s, line: %d"), __FILE__, __LINE__ - 1);
            strnz__cpy(em1, "open ", MAXLEN - 1);
            strnz__cat(em1, form->out_spec, MAXLEN - 1);
            strerror__r(errno, em2, MAXLEN);
            ui_display_error(em0, em1, em2, nullptr);
            return (1);
        }
        // dup2(form->out_fd, STDOUT_FILENO);
        form->out_fp = fdopen(form->out_fd, "w");
        form->f_out_spec = true;
        form->f_out_pipe = true;
    } else {
        if ((form->out_fp = fopen(form->out_spec, "w")) == nullptr) {
            ssnprintf(em0, MAXLEN - 1, _("%s, line: %d"), __FILE__, __LINE__ - 1);
            strerror__r(errno, em2, MAXLEN);
            ui_display_error(em0, em1, em2, nullptr);
            return (1);
        }
    }
    if (form->out_fp == nullptr) {
        ssnprintf(em0, MAXLEN - 1, _("%s, line: %d"), __FILE__, __LINE__ - 1);
        strnz__cpy(em1, "fopen ", MAXLEN - 1);
        strnz__cat(em1, form->out_spec, MAXLEN - 1);
        strerror__r(errno, em2, MAXLEN);
        ui_display_error(em0, em1, em2, nullptr);
        return (1);
    }
    for (n = 0; n < form->fcnt; n++)
        fprintf(form->out_fp, "%s\n", form->field[n]->accept_s);
    if (form->out_fp != nullptr)
        fclose(form->out_fp);
    return (0);
}

References Field::accept_s, em0, em1, em2, Form::f_out_pipe, Form::f_out_spec, Form::fcnt, Form::field, Form::out_fd, Form::out_fp, Form::out_spec, ssnprintf(), strerror__r(), strnz__cat(), strnz__cpy(), and ui_display_error().

Referenced by form_engine(), and form_process().

Here is the call graph for this function:

Here is the caller graph for this function:

init_form()

int init_form	(	Init *	init,
		int	argc,
		char **	argv,
		uint	begy,
		uint	begx )

Initialize form data structure and parse description file.

Parameters

init	A pointer to the Init structure containing form data and state.
argc	The number of command line arguments passed to the form.
argv	The array of command line arguments passed to the form.
begy	The y-coordinate for the top-left corner of the form window.
begx	The x-coordinate for the top-left corner of the form window.

Returns

0 on success, or a non-zero value if an error occurs during

Definition at line 61 of file form_engine.c.

                                                                       {
    int rc;
    char tmp_str[MAXLEN];
    if (init->form != nullptr)
        destroy_form(init);
    init->form = new_form(init, argc, argv, begy, begx);
    Form *form = init->form;
    if (!form->f_mapp_spec) {
        if (form->mapp_spec[0] == '\0') {
            rc = ui_perror(_("Error: No form specification file given"));
        } else {
            strnz__cpy(tmp_str, "form->mapp_spec: ", MAXLEN - 1);
            strnz__cat(tmp_str, form->mapp_spec, MAXLEN - 1);
            strnz__cat(tmp_str, _(" not found"), MAXLEN - 1);
            rc = ui_perror(tmp_str);
        }
        destroy_form(init);
        return rc;
    }
    if (begy != 0)
        form->begy = begy;
    if (begx != 0)
        form->begx = begx;
    if ((form->f_in_spec && (form->in_spec[0] == '\0')) ||
        (strcmp(form->in_spec, "-") == 0) ||
        strcmp(form->in_spec, "/dev/stdin") == 0) {
        strnz__cpy(form->in_spec, "/dev/stdin", MAXLEN - 1);
        form->f_in_pipe = true;
    }
    if (form->title[0] == '\0')
        strnz__cpy(form->title, form->in_spec, MAXLEN - 1);
    rc = form_engine(init);
    UiSurface *sfc = ui_surface[sfc_ptr];
    ui_destroy_chyron(form->chyron);
    if (sfc)
        ui_cm_surface_destroy(sfc);
    destroy_form(init);
    return rc;
}

References Form::begx, Form::begy, Form::chyron, destroy_form(), Form::f_in_pipe, Form::f_in_spec, Form::f_mapp_spec, Init::form, form_engine(), Form::in_spec, Form::mapp_spec, new_form(), sfc_ptr, strnz__cat(), strnz__cpy(), Form::title, ui_cm_surface_destroy(), ui_destroy_chyron(), ui_perror(), and ui_surface.

Referenced by main(), and popup_form().

Here is the call graph for this function:

Here is the caller graph for this function: