fftw_status fftw_import_wisdom(int (*g)(void *), void *data)
{
int n;
int flags;
fftw_direction dir;
enum fftw_node_type type;
int signature;
get_input = g;
input_error = FFTW_SUCCESS;
read_char(data);
eat_blanks(data);
EXPECT('(');
eat_blanks(data);
EXPECT_STRING(WISDOM_FORMAT_VERSION);
eat_blanks(data);
while (next_char != ')') {
EXPECT('(');
EXPECT_INT(n);
EXPECT_INT(flags);
EXPECT_INT(dir);
EXPECT_INT(type);
EXPECT_INT(signature);
eat_blanks(data);
EXPECT(')');
/* the wisdom has been read properly. Add it */
fftw_wisdom_add(n, flags, dir, type, signature);
/* prepare for next morsel of wisdom */
eat_blanks(data);
}
return FFTW_SUCCESS;
}
token analyzer::get_token()
{
refresh();
drop_garbage();
if( peek_char() == EOF )
return token("END_OF_FILE","") ;
int first_pos = comp_f_stream.tellg();
string value = "" ;
while( true ){
int c = read_char();
value.push_back(c);
if( current_state->is_valid_transition(c) ){
current_state = current_state->next_state(c);
if( current_state->is_acceptance_state() ){
last_acceptance = current_state ;
acceptace_pos = comp_f_stream.tellg();
}
}
else{//dead end
if( last_acceptance != NULL ){
int len = comp_f_stream.tellg()-acceptace_pos ;
for(int i = 0 ; i < len ; ++i){
value.pop_back();
}
restore_pos();
return token(last_acceptance->name,value);
}
else{//error checking
//return fix_error(token("BAD_TOKEN",value));
return token("BAD_TOKEN",value);
}
}
}
}
/**
* @brief Read command from stdin
*
* @param buffer buffer to read command to
*
* @return false on exit
*/
static
bool read_command() {
ssize_t num_read = BUF_SIZE;
int c;
while (num_read == BUF_SIZE) {
do {
print_prompt();
num_read = read(0, buffer, BUF_SIZE);
} while (num_read == EINTR); // skip interrupt
if (num_read == BUF_SIZE) {
while (buffer[BUF_SIZE - 1] != '\n'
&& (c = read_char()) != '\n'
&& c != CHAR_EOF)
;
print_error(ERR_LONG_INPUT);
if (c == CHAR_EOF) {
write(1, CMD_EXIT, strlen(CMD_EXIT));
write(1, "\n", 1);
return false;
}
}
if (num_read == 0) {
write(1, CMD_EXIT, strlen(CMD_EXIT));
write(1, "\n", 1);
return false;
}
if (strlen(buffer) == 1 && buffer[0] == '\n')
num_read = BUF_SIZE; // empty line, read next
}
buffer[num_read - 1] = '\0';
return true;
}
static char *
read_identifier (struct parsebuf *p)
{
/* Index of the first character of the identifier in p->buf. */
int start;
/* Next index after the last character of the identifer in p->buf. */
int end;
skip_whitespace (p);
/* Capture the start of the identifier. */
start = p->pos;
/* Scan for the end. */
while (is_identifier_char (peek_char (p)))
read_char (p);
end = p->pos;
if (end - start < 1)
return 0;
return grub_new_substring (p->buf, start, end);
}
Token* Scanner::read_general_string(char delimiter, Token::TokenType tokenType) {
fint l = line;
fint col = column - 1;
const char* ss = sourceAddr() - 1;
char* b = buffer;
fint c;
bool cannot_be_a_delimeter;
do {
Token* t = read_char(b, cannot_be_a_delimeter);
if (t) return t; // Error return.
c = *b++;
if (b >= &buffer[ScannerBufferSize]) {
return TokenizingError("string literal or comment too long");
}
} while (cannot_be_a_delimeter || (c != delimiter && c != EOF));
if (c == EOF) {
return TokenizingError("missing trailing ' of string literal or comment");
}
b[-1] = '\0';
return new Token(tokenType,
new String(copy_string(buffer, b-buffer), b-buffer-1),
l, col, ss);
}
FAXPP_Error
xml_decl_encoding_value_state(FAXPP_TokenizerEnv *env)
{
read_char(env);
switch(env->current_char) {
case '"':
env->state = xml_decl_encoding_value_quot_state1;
next_char(env);
token_start_position(env);
break;
case '\'':
env->state = xml_decl_encoding_value_apos_state1;
next_char(env);
token_start_position(env);
break;
LINE_ENDINGS
default:
next_char(env);
return INVALID_CHAR_IN_XML_DECL;
}
return NO_ERROR;
}
scanner::token scanner::read_symbol(char ch) {
bool escape = false;
if (m_smt2)
m_string.pop_back(); // remove leading '|'
while (ch != '|' || escape) {
if (ch == EOF) {
// TODO: use error reporting
m_err << "ERROR: unexpected end of file.\n";
return EOF_TOKEN;
}
if (ch == '\n') {
++m_line;
}
escape = (ch == '\\');
m_string.push_back(ch);
ch = read_char();
}
if (!m_smt2)
m_string.push_back(ch); // don't add trailing '|'
m_string.push_back(0);
m_id = m_string.begin();
return ID_TOKEN;
}
FAXPP_Error
dec_char_reference_state(FAXPP_TokenizerEnv *env)
{
while(1) {
read_char(env);
switch(env->current_char) {
case ';':
retrieve_state(env);
token_end_position(env);
report_token(DEC_CHAR_REFERENCE_TOKEN, env);
next_char(env);
token_start_position(env);
return NO_ERROR;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
next_char(env);
break;
LINE_ENDINGS
default:
next_char(env);
return INVALID_CHAR_IN_CHAR_REFERENCE;
}
}
// Never happens
return NO_ERROR;
}
char *read_line(FILE *fin, char *line, size_t maxlen)
{
char c, *ptr;
size_t n;
int eof = 0;
if (line == NULL && maxlen == 0)
return NULL;
ptr = line;
for (n = 1; n < maxlen; n++) { /* start from 1 to ensure there always one character space for '\0' */
c = read_char(fin);
if (c == '\n')
break;
if (c == EOF) {
eof = 1;
break;
}
*ptr++ = c;
}
*ptr = '\0';
if (eof)
return NULL;
return line;
}
FAXPP_Error
xml_decl_standalone_state1(FAXPP_TokenizerEnv *env)
{
read_char(env);
switch(env->current_char) {
WHITESPACE:
next_char(env);
break;
case '?':
env->state = xml_decl_seen_question_state;
token_start_position(env);
next_char(env);
break;
case 's':
env->state = xml_decl_standalone_state2;
next_char(env);
break;
default:
next_char(env);
return INVALID_CHAR_IN_XML_DECL;
}
return NO_ERROR;
}
FAXPP_Error
xml_decl_encoding_value_apos_state1(FAXPP_TokenizerEnv *env)
{
read_char(env);
switch(env->current_char) {
case '\'':
env->state = xml_decl_standalone_ws_state;
next_char(env);
return INVALID_ENCODING_VALUE;
case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G': case 'H': case 'I': case 'J': case 'K': case 'L': case 'M':
case 'N': case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T': case 'U': case 'V': case 'W': case 'X': case 'Y': case 'Z':
case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g': case 'h': case 'i': case 'j': case 'k': case 'l': case 'm':
case 'n': case 'o': case 'p': case 'q': case 'r': case 's': case 't': case 'u': case 'v': case 'w': case 'x': case 'y': case 'z':
env->state = xml_decl_encoding_value_apos_state2;
break;
LINE_ENDINGS
default:
next_char(env);
return INVALID_ENCODING_VALUE;
}
next_char(env);
return NO_ERROR;
}
void play()
{
gc_init();
Hash *h = get_basic_hash();
t_point parsed;
char c;
while ((c = read_char()) != EOF) {
if (c == OPEN_TAG) {
parsed = parse_pipe(h, 0);
if (parsed != NIL && quiet) {
resolve_Thunk(parsed);
} else if (parsed != NIL && !quiet) {
print_Symbol(parsed);
} else if (prompt && !quiet)
printf("OK\n");
gc();
}
}
#ifdef DEBUG
printf("\n\n"); gc_score();
#endif
}
Cell* read_string(char* in) {
ReaderState rs;
Cell stack_root[100];
rs.state = PST_ATOM;
rs.cell = 0;
rs.level = 0;
rs.stack = (void*)&stack_root;
int i=0;
int len = strlen(in);
for (i=0; i<len; i++) {
read_char(in[i], &rs);
if (rs.state>=10) {
//print("<read error %d at %d.>\n",rs.state,i);
break;
}
//printf("rs %c: %d\n", in[i], rs.state);
}
if (rs.level!=0) {
//print("<missing %d closing parens.>\n",rs.level);
}
if (rs.state!=PST_ATOM) {
//printf("<read error: unexpected end of input.>\n");
}
Cell* root = *rs.stack;
if (root) {
Cell* ret = car(root);
//if (root->next) free(root->next);
//free(root);
return ret;
}
return alloc_error(ERR_SYNTAX);
}
static inline uint8_t read(char* string, uint16_t timeout = 0) {
static unsigned char buffer;
uint8_t i = 0;
do {
if (read_char(buffer, timeout) == READ_TIMEOUT)
return READ_TIMEOUT;
if (i == 0 && buffer == '\r') {
return READ_SUCCESS;
}
if (i == 0 && buffer == '\n') {
continue;
}
string[i] = static_cast<char>(buffer);
i++;
} while (string[i - 1] != '\r');
string[i - 1] = '\0';
return READ_SUCCESS;
}
void read_next_value(parser_t *p, char *s, size_t n)
{
int i = 0;
char c;
while (isblank(c = read_char(p)))
p->column++;
if (c != '"') {
printf("[read_next_value] Error: \" expected in line %i.\n", p->row);
exit(1);
}
c = fgetc(p->f);
p->column++;
while (c != '"' && c != '\n' && c != '\r') {
s[i] = c;
i++;
if (i >= n) {
s[i] = 0;
printf("[read_next_value] Error: Token too long in line %i. Token = '%s'\n", p->row, s);
exit(1);
}
c = fgetc(p->f);
p->column++;
}
s[i] = 0;
p->column++;
if (c != '"') {
printf("[read_next_value] Error: End-of-line encountered before '\"' in line %i.\n", p->row);
exit(1);
}
}
/*
* 创建图(自己输入)
*/
Graph* create_graph()
{
char c1, c2;
int v, e;
int i, j, weight, p1, p2;
Graph* pG;
// 输入"顶点数"和"边数"
printf("input vertex number: ");
scanf("%d", &v);
printf("input edge number: ");
scanf("%d", &e);
if ( v < 1 || e < 1 || (e > (v * (v-1))))
{
printf("input error: invalid parameters!\n");
return NULL;
}
if ((pG=(Graph*)malloc(sizeof(Graph))) == NULL )
return NULL;
memset(pG, 0, sizeof(Graph));
// 初始化"顶点数"和"边数"
pG->vexnum = v;
pG->edgnum = e;
// 初始化"顶点"
for (i = 0; i < pG->vexnum; i++)
{
printf("vertex(%d): ", i);
pG->vexs[i] = read_char();
}
// 1. 初始化"边"的权值
for (i = 0; i < pG->vexnum; i++)
{
for (j = 0; j < pG->vexnum; j++)
{
if (i==j)
pG->matrix[i][j] = 0;
else
pG->matrix[i][j] = INF;
}
}
// 2. 初始化"边"的权值: 根据用户的输入进行初始化
for (i = 0; i < pG->edgnum; i++)
{
// 读取边的起始顶点，结束顶点，权值
printf("edge(%d):", i);
c1 = read_char();
c2 = read_char();
scanf("%d", &weight);
p1 = get_position(*pG, c1);
p2 = get_position(*pG, c2);
if (p1==-1 || p2==-1)
{
printf("input error: invalid edge!\n");
free(pG);
return NULL;
}
pG->matrix[p1][p2] = weight;
pG->matrix[p2][p1] = weight;
}
return pG;
}
/*----------------------------------------------------------------------
Prompt user for a choice among alternatives
Args -- utf8prompt: The prompt for the question/selection
line: The line to prompt on, if negative then relative to bottom
esc_list: ESC_KEY_S list of keys
dflt: The selection when the <CR> is pressed (should probably
be one of the chars in esc_list)
on_ctrl_C: The selection when ^C is pressed
help_text: Text to be displayed on bottom two lines
flags: Logically OR'd flags modifying our behavior to:
RB_FLUSH_IN - Discard any pending input chars.
RB_ONE_TRY - Only give one chance to answer. Returns
on_ctrl_C value if not answered acceptably
on first try.
RB_NO_NEWMAIL - Quell the usual newmail check.
RB_SEQ_SENSITIVE - The caller is sensitive to sequence number
changes so return on_ctrl_C if an
unsolicited expunge happens while we're
viewing a message.
RB_RET_HELP - Instead of the regular internal handling
way of handling help_text, this just causes
radio_buttons to return 3 when help is
asked for, so that the caller handles it
instead.
Note: If there are enough keys in the esc_list to need a second
screen, and there is no help, then the 13th key will be
put in the help position.
Result -- Returns the letter pressed. Will be one of the characters in the
esc_list argument, or dflt, or on_ctrl_C, or SEQ_EXCEPTION.
This will pause for any new status message to be seen and then prompt the user.
The prompt will be truncated to fit on the screen. Redraw and resize are
handled along with ^Z suspension. Typing ^G will toggle the help text on and
off. Character types that are not buttons will result in a beep (unless one_try
is set).
----*/
int
radio_buttons(char *utf8prompt, int line, ESCKEY_S *esc_list, int dflt,
int on_ctrl_C, HelpType help_text, int flags)
{
UCS ucs;
register int ch, real_line;
char *q, *ds = NULL;
unsigned maxcol;
int max_label, i, start, fkey_table[12];
int km_popped = 0;
struct key rb_keys[12];
struct key_menu rb_keymenu;
bitmap_t bitmap;
struct variable *vars = ps_global->vars;
COLOR_PAIR *lastc = NULL, *promptc = NULL;
#ifdef _WINDOWS
int cursor_shown;
if (mswin_usedialog()){
MDlgButton button_list[25];
LPTSTR free_names[25];
LPTSTR free_labels[25];
int b, i, ret;
char **help;
memset(&free_names, 0, sizeof(LPTSTR) * 25);
memset(&free_labels, 0, sizeof(LPTSTR) * 25);
memset(&button_list, 0, sizeof (MDlgButton) * 25);
b = 0;
if(flags & RB_RET_HELP){
if(help_text != NO_HELP)
alpine_panic("RET_HELP and help in radio_buttons!");
button_list[b].ch = '?';
button_list[b].rval = 3;
button_list[b].name = TEXT("?");
free_labels[b] = utf8_to_lptstr(N_("Help"));
button_list[b].label = free_labels[b];
++b;
}
for(i = 0; esc_list && esc_list[i].ch != -1 && i < 23; ++i){
if(esc_list[i].ch != -2){
button_list[b].ch = esc_list[i].ch;
button_list[b].rval = esc_list[i].rval;
free_names[b] = utf8_to_lptstr(esc_list[i].name);
button_list[b].name = free_names[b];
free_labels[b] = utf8_to_lptstr(esc_list[i].label);
button_list[b].label = free_labels[b];
++b;
}
}
button_list[b].ch = -1;
/* assumption here is that HelpType is char ** */
help = help_text;
ret = mswin_select(utf8prompt, button_list, dflt, on_ctrl_C, help, flags);
for(i = 0; i < 25; i++){
if(free_names[i])
fs_give((void **) &free_names[i]);
if(free_labels[i])
fs_give((void **) &free_labels[i]);
}
return (ret);
}
#endif /* _WINDOWS */
suspend_busy_cue();
flush_ordered_messages(); /* show user previous status msgs */
mark_status_dirty(); /* clear message next display call */
real_line = line > 0 ? line : ps_global->ttyo->screen_rows + line;
MoveCursor(real_line, RAD_BUT_COL);
CleartoEOLN();
/*---- Find widest label ----*/
max_label = 0;
for(i = 0; esc_list && esc_list[i].ch != -1 && i < 11; i++){
if(esc_list[i].ch == -2) /* -2 means to skip this key and leave blank */
continue;
if(esc_list[i].name)
max_label = MAX(max_label, utf8_width(esc_list[i].name));
}
if(ps_global->ttyo->screen_cols - max_label - 1 > 0)
maxcol = ps_global->ttyo->screen_cols - max_label - 1;
else
maxcol = 0;
/*
* We need to be able to truncate q, so copy it in case it is
* a readonly string.
*/
q = cpystr(utf8prompt);
/*---- Init structs for keymenu ----*/
for(i = 0; i < 12; i++)
memset((void *)&rb_keys[i], 0, sizeof(struct key));
memset((void *)&rb_keymenu, 0, sizeof(struct key_menu));
rb_keymenu.how_many = 1;
rb_keymenu.keys = rb_keys;
/*---- Setup key menu ----*/
start = 0;
clrbitmap(bitmap);
memset(fkey_table, NO_OP_COMMAND, 12 * sizeof(int));
if(flags & RB_RET_HELP && help_text != NO_HELP)
alpine_panic("RET_HELP and help in radio_buttons!");
/* if shown, always at position 0 */
if(help_text != NO_HELP || flags & RB_RET_HELP){
rb_keymenu.keys[0].name = "?";
rb_keymenu.keys[0].label = N_("Help");
setbitn(0, bitmap);
fkey_table[0] = ctrl('G');
start++;
}
if(on_ctrl_C){
rb_keymenu.keys[1].name = "^C";
rb_keymenu.keys[1].label = N_("Cancel");
setbitn(1, bitmap);
fkey_table[1] = ctrl('C');
start++;
}
start = start ? 2 : 0;
/*---- Show the usual possible keys ----*/
for(i=start; esc_list && esc_list[i-start].ch != -1; i++){
/*
* If we have an esc_list item we'd like to put in the non-existent
* 13th slot, and there is no help, we put it in the help slot
* instead. We're hacking now...!
*
* We may also have invisible esc_list items that don't show up
* on the screen. We use this when we have two different keys
* which are synonyms, like ^P and KEY_UP. If all the slots are
* already full we can still fit invisible keys off the screen to
* the right. A key is invisible if it's label is "".
*/
if(i >= 12){
if(esc_list[i-start].label
&& esc_list[i-start].label[0] != '\0'){ /* visible */
if(i == 12){ /* special case where we put it in help slot */
if(help_text != NO_HELP)
alpine_panic("Programming botch in radio_buttons(): too many keys");
if(esc_list[i-start].ch != -2)
setbitn(0, bitmap); /* the help slot */
fkey_table[0] = esc_list[i-start].ch;
rb_keymenu.keys[0].name = esc_list[i-start].name;
if(esc_list[i-start].ch != -2
&& esc_list[i-start].rval == dflt
&& esc_list[i-start].label){
size_t l;
l = strlen(esc_list[i-start].label) + 2;
ds = (char *)fs_get((l+1) * sizeof(char));
snprintf(ds, l+1, "[%s]", esc_list[i-start].label);
ds[l] = '\0';
rb_keymenu.keys[0].label = ds;
}
else
rb_keymenu.keys[0].label = esc_list[i-start].label;
}
else
alpine_panic("Botch in radio_buttons(): too many keys");
}
}
else{
if(esc_list[i-start].ch != -2)
setbitn(i, bitmap);
fkey_table[i] = esc_list[i-start].ch;
rb_keymenu.keys[i].name = esc_list[i-start].name;
if(esc_list[i-start].ch != -2
&& esc_list[i-start].rval == dflt
&& esc_list[i-start].label){
size_t l;
l = strlen(esc_list[i-start].label) + 2;
ds = (char *)fs_get((l+1) * sizeof(char));
snprintf(ds, l+1, "[%s]", esc_list[i-start].label);
ds[l] = '\0';
rb_keymenu.keys[i].label = ds;
}
else
rb_keymenu.keys[i].label = esc_list[i-start].label;
}
}
for(; i < 12; i++)
rb_keymenu.keys[i].name = NULL;
ps_global->mangled_footer = 1;
#ifdef _WINDOWS
cursor_shown = mswin_showcaret(1);
#endif
if(pico_usingcolor() && VAR_PROMPT_FORE_COLOR &&
VAR_PROMPT_BACK_COLOR &&
pico_is_good_color(VAR_PROMPT_FORE_COLOR) &&
pico_is_good_color(VAR_PROMPT_BACK_COLOR)){
lastc = pico_get_cur_color();
if(lastc){
promptc = new_color_pair(VAR_PROMPT_FORE_COLOR,
VAR_PROMPT_BACK_COLOR);
(void)pico_set_colorp(promptc, PSC_NONE);
}
}
else
StartInverse();
draw_radio_prompt(real_line, RAD_BUT_COL, maxcol, q);
while(1){
fflush(stdout);
/*---- Paint the keymenu ----*/
if(lastc)
(void)pico_set_colorp(lastc, PSC_NONE);
else
EndInverse();
draw_keymenu(&rb_keymenu, bitmap, ps_global->ttyo->screen_cols,
1 - FOOTER_ROWS(ps_global), 0, FirstMenu);
if(promptc)
(void)pico_set_colorp(promptc, PSC_NONE);
else
StartInverse();
MoveCursor(real_line, MIN(RAD_BUT_COL+utf8_width(q), maxcol+1));
if(flags & RB_FLUSH_IN)
flush_input();
newcmd:
/* Timeout 5 min to keep imap mail stream alive */
ucs = read_char(600);
dprint((2,
"Want_to read: %s (0x%x)\n", pretty_command(ucs), ucs));
if((ucs < 0x80) && isupper((unsigned char) ucs))
ucs = tolower((unsigned char) ucs);
if(F_ON(F_USE_FK,ps_global)
&& (((ucs < 0x80) && isalpha((unsigned char) ucs) && !strchr("YyNn",(int) ucs))
|| ((ucs >= PF1 && ucs <= PF12)
&& (ucs = fkey_table[ucs - PF1]) == NO_OP_COMMAND))){
/*
* The funky test above does two things. It maps
* esc_list character commands to function keys, *and* prevents
* character commands from input while in function key mode.
* NOTE: this breaks if we ever need more than the first
* twelve function keys...
*/
if(flags & RB_ONE_TRY){
ch = ucs = on_ctrl_C;
goto out_of_loop;
}
Writechar(BELL, 0);
continue;
}
switch(ucs){
default:
for(i = 0; esc_list && esc_list[i].ch != -1; i++)
if(ucs == esc_list[i].ch){
int len, n;
MoveCursor(real_line,len=MIN(RAD_BUT_COL+utf8_width(q),maxcol+1));
for(n = 0, len = ps_global->ttyo->screen_cols - len;
esc_list[i].label && esc_list[i].label[n] && len > 0;
n++, len--)
Writechar(esc_list[i].label[n], 0);
ch = esc_list[i].rval;
goto out_of_loop;
}
if(flags & RB_ONE_TRY){
ch = on_ctrl_C;
goto out_of_loop;
}
Writechar(BELL, 0);
break;
case ctrl('M'):
case ctrl('J'):
ch = dflt;
for(i = 0; esc_list && esc_list[i].ch != -1; i++)
if(ch == esc_list[i].rval){
int len, n;
MoveCursor(real_line,len=MIN(RAD_BUT_COL+utf8_width(q),maxcol+1));
for(n = 0, len = ps_global->ttyo->screen_cols - len;
esc_list[i].label && esc_list[i].label[n] && len > 0;
n++, len--)
Writechar(esc_list[i].label[n], 0);
break;
}
goto out_of_loop;
case ctrl('C'):
if(on_ctrl_C || (flags & RB_ONE_TRY)){
ch = on_ctrl_C;
goto out_of_loop;
}
Writechar(BELL, 0);
break;
case '?':
case ctrl('G'):
if(FOOTER_ROWS(ps_global) == 1 && km_popped == 0){
km_popped++;
FOOTER_ROWS(ps_global) = 3;
line = -3;
real_line = ps_global->ttyo->screen_rows + line;
if(lastc)
(void)pico_set_colorp(lastc, PSC_NONE);
else
EndInverse();
clearfooter(ps_global);
if(promptc)
(void)pico_set_colorp(promptc, PSC_NONE);
else
StartInverse();
draw_radio_prompt(real_line, RAD_BUT_COL, maxcol, q);
break;
}
if(flags & RB_RET_HELP){
ch = 3;
goto out_of_loop;
}
else if(help_text != NO_HELP && FOOTER_ROWS(ps_global) > 1){
mark_keymenu_dirty();
if(lastc)
(void)pico_set_colorp(lastc, PSC_NONE);
else
EndInverse();
MoveCursor(real_line + 1, RAD_BUT_COL);
CleartoEOLN();
MoveCursor(real_line + 2, RAD_BUT_COL);
CleartoEOLN();
radio_help(real_line, RAD_BUT_COL, help_text);
sleep(5);
MoveCursor(real_line, MIN(RAD_BUT_COL+utf8_width(q), maxcol+1));
if(promptc)
(void)pico_set_colorp(promptc, PSC_NONE);
else
StartInverse();
}
else
Writechar(BELL, 0);
break;
case NO_OP_COMMAND:
goto newcmd; /* misunderstood escape? */
case NO_OP_IDLE: /* UNODIR, keep the stream alive */
if(flags & RB_NO_NEWMAIL)
goto newcmd;
i = new_mail(0, VeryBadTime, NM_DEFER_SORT);
if(sp_expunge_count(ps_global->mail_stream)
&& flags & RB_SEQ_SENSITIVE){
if(on_ctrl_C)
ch = on_ctrl_C;
else
ch = SEQ_EXCEPTION;
goto out_of_loop;
}
if(i < 0)
break; /* no changes, get on with life */
/* Else fall into redraw to adjust displayed numbers and such */
case KEY_RESIZE:
case ctrl('L'):
real_line = line > 0 ? line : ps_global->ttyo->screen_rows + line;
if(lastc)
(void)pico_set_colorp(lastc, PSC_NONE);
else
EndInverse();
ClearScreen();
redraw_titlebar();
if(ps_global->redrawer != NULL)
(*ps_global->redrawer)();
if(FOOTER_ROWS(ps_global) == 3 || km_popped)
redraw_keymenu();
if(ps_global->ttyo->screen_cols - max_label - 1 > 0)
maxcol = ps_global->ttyo->screen_cols - max_label - 1;
else
maxcol = 0;
if(promptc)
(void)pico_set_colorp(promptc, PSC_NONE);
else
StartInverse();
draw_radio_prompt(real_line, RAD_BUT_COL, maxcol, q);
break;
} /* switch */
}
out_of_loop:
#ifdef _WINDOWS
if(!cursor_shown)
mswin_showcaret(0);
#endif
fs_give((void **) &q);
if(ds)
fs_give((void **) &ds);
if(lastc){
(void) pico_set_colorp(lastc, PSC_NONE);
free_color_pair(&lastc);
if(promptc)
free_color_pair(&promptc);
}
else
EndInverse();
fflush(stdout);
resume_busy_cue(0);
if(km_popped){
FOOTER_ROWS(ps_global) = 1;
clearfooter(ps_global);
ps_global->mangled_body = 1;
}
return(ch);
}
static void read_field(struct csv *csv)
{ /* read field from csv data file */
/* check for end of file */
if (csv->c == EOF)
{ csv->what = CSV_EOF;
strcpy(csv->field, "EOF");
goto done;
}
/* check for end of record */
if (csv->c == '\n')
{ csv->what = CSV_EOR;
strcpy(csv->field, "EOR");
read_char(csv);
if (csv->c == ',')
err1: { xprintf("%s:%d: empty field not allowed\n", csv->fname,
csv->count);
longjmp(csv->jump, 0);
}
if (csv->c == '\n')
{ xprintf("%s:%d: empty record not allowed\n", csv->fname,
csv->count);
longjmp(csv->jump, 0);
}
#if 1 /* 01/VI-2010 */
/* skip comment records; may appear only before the very first
record containing field names */
if (csv->c == '#' && csv->count == 1)
{ while (csv->c == '#')
{ while (csv->c != '\n')
read_char(csv);
read_char(csv);
csv->nskip++;
}
}
#endif
goto done;
}
/* skip comma before next field */
if (csv->c == ',')
read_char(csv);
/* read field */
if (csv->c == '\'' || csv->c == '"')
{ /* read a field enclosed in quotes */
int quote = csv->c, len = 0;
csv->what = CSV_STR;
/* skip opening quote */
read_char(csv);
/* read field characters within quotes */
for (;;)
{ /* check for closing quote and read it */
if (csv->c == quote)
{ read_char(csv);
if (csv->c == quote)
;
else if (csv->c == ',' || csv->c == '\n')
break;
else
{ xprintf("%s:%d: invalid field\n", csv->fname,
csv->count);
longjmp(csv->jump, 0);
}
}
/* check the current field length */
if (len == CSV_FDLEN_MAX)
err2: { xprintf("%s:%d: field too long\n", csv->fname,
csv->count);
longjmp(csv->jump, 0);
}
/* add the current character to the field */
csv->field[len++] = (char)csv->c;
/* read the next character */
read_char(csv);
}
/* the field has been read */
if (len == 0) goto err1;
csv->field[len] = '\0';
}
else
{ /* read a field not enclosed in quotes */
int len = 0;
double temp;
csv->what = CSV_NUM;
while (!(csv->c == ',' || csv->c == '\n'))
{ /* quotes within the field are not allowed */
if (csv->c == '\'' || csv->c == '"')
{ xprintf("%s:%d: invalid use of single or double quote wi"
"thin field\n", csv->fname, csv->count);
longjmp(csv->jump, 0);
}
/* check the current field length */
if (len == CSV_FDLEN_MAX) goto err2;
/* add the current character to the field */
csv->field[len++] = (char)csv->c;
/* read the next character */
read_char(csv);
}
/* the field has been read */
if (len == 0) goto err1;
csv->field[len] = '\0';
/* check the field type */
if (str2num(csv->field, &temp)) csv->what = CSV_STR;
}
done: return;
}
/* Set properties on the view based on settings from the specified
theme file. */
grub_err_t
grub_gfxmenu_view_load_theme (grub_gfxmenu_view_t view, const char *theme_path)
{
grub_file_t file;
struct parsebuf p;
p.view = view;
p.theme_dir = grub_get_dirname (theme_path);
file = grub_file_open (theme_path, GRUB_FILE_TYPE_THEME);
if (! file)
{
grub_free (p.theme_dir);
return grub_errno;
}
p.len = grub_file_size (file);
p.buf = grub_malloc (p.len);
p.pos = 0;
p.line_num = 1;
p.col_num = 1;
p.filename = theme_path;
if (! p.buf)
{
grub_file_close (file);
grub_free (p.theme_dir);
return grub_errno;
}
if (grub_file_read (file, p.buf, p.len) != p.len)
{
grub_free (p.buf);
grub_file_close (file);
grub_free (p.theme_dir);
return grub_errno;
}
if (view->canvas)
view->canvas->component.ops->destroy (view->canvas);
view->canvas = grub_gui_canvas_new ();
if (!view->canvas)
goto fail;
((grub_gui_component_t) view->canvas)
->ops->set_bounds ((grub_gui_component_t) view->canvas,
&view->screen);
while (has_more (&p))
{
/* Skip comments (lines beginning with #). */
if (peek_char (&p) == '#')
{
advance_to_next_line (&p);
continue;
}
/* Find the first non-whitespace character. */
skip_whitespace (&p);
/* Handle the content. */
if (peek_char (&p) == '+')
{
/* Skip the '+'. */
read_char (&p);
read_object (&p, view->canvas);
}
else
{
read_property (&p);
}
if (grub_errno != GRUB_ERR_NONE)
goto fail;
}
/* Set the new theme path. */
grub_free (view->theme_path);
view->theme_path = grub_strdup (theme_path);
goto cleanup;
fail:
if (view->canvas)
{
view->canvas->component.ops->destroy (view->canvas);
view->canvas = 0;
}
cleanup:
grub_free (p.buf);
grub_file_close (file);
grub_free (p.theme_dir);
return grub_errno;
}
/* Read a GUI object specification from the theme file.
Any components created will be added to the GUI container PARENT. */
static grub_err_t
read_object (struct parsebuf *p, grub_gui_container_t parent)
{
grub_video_rect_t bounds;
char *name;
name = read_identifier (p);
if (! name)
goto cleanup;
grub_gui_component_t component = 0;
if (grub_strcmp (name, "label") == 0)
{
component = grub_gui_label_new ();
}
else if (grub_strcmp (name, "image") == 0)
{
component = grub_gui_image_new ();
}
else if (grub_strcmp (name, "vbox") == 0)
{
component = (grub_gui_component_t) grub_gui_vbox_new ();
}
else if (grub_strcmp (name, "hbox") == 0)
{
component = (grub_gui_component_t) grub_gui_hbox_new ();
}
else if (grub_strcmp (name, "canvas") == 0)
{
component = (grub_gui_component_t) grub_gui_canvas_new ();
}
else if (grub_strcmp (name, "progress_bar") == 0)
{
component = grub_gui_progress_bar_new ();
}
else if (grub_strcmp (name, "circular_progress") == 0)
{
component = grub_gui_circular_progress_new ();
}
else if (grub_strcmp (name, "boot_menu") == 0)
{
component = grub_gui_list_new ();
}
else
{
/* Unknown type. */
grub_error (GRUB_ERR_IO, "%s:%d:%d unknown object type `%s'",
p->filename, p->line_num, p->col_num, name);
goto cleanup;
}
if (! component)
goto cleanup;
/* Inform the component about the theme so it can find its resources. */
component->ops->set_property (component, "theme_dir", p->theme_dir);
component->ops->set_property (component, "theme_path", p->filename);
/* Add the component as a child of PARENT. */
bounds.x = 0;
bounds.y = 0;
bounds.width = -1;
bounds.height = -1;
component->ops->set_bounds (component, &bounds);
parent->ops->add (parent, component);
skip_whitespace (p);
if (read_char (p) != '{')
{
grub_error (GRUB_ERR_IO,
"%s:%d:%d expected `{' after object type name `%s'",
p->filename, p->line_num, p->col_num, name);
goto cleanup;
}
while (has_more (p))
{
skip_whitespace (p);
/* Check whether the end has been encountered. */
if (peek_char (p) == '}')
{
/* Skip the closing brace. */
read_char (p);
break;
}
if (peek_char (p) == '#')
{
/* Skip comments. */
advance_to_next_line (p);
continue;
}
if (peek_char (p) == '+')
{
/* Skip the '+'. */
read_char (p);
/* Check whether this component is a container. */
if (component->ops->is_instance (component, "container"))
{
/* Read the sub-object recursively and add it as a child. */
if (read_object (p, (grub_gui_container_t) component) != 0)
goto cleanup;
/* After reading the sub-object, resume parsing, expecting
another property assignment or sub-object definition. */
continue;
}
else
{
grub_error (GRUB_ERR_IO,
"%s:%d:%d attempted to add object to non-container",
p->filename, p->line_num, p->col_num);
goto cleanup;
}
}
char *property;
property = read_identifier (p);
if (! property)
{
grub_error (GRUB_ERR_IO, "%s:%d:%d identifier expected in theme file",
p->filename, p->line_num, p->col_num);
goto cleanup;
}
skip_whitespace (p);
if (read_char (p) != '=')
{
grub_error (GRUB_ERR_IO,
"%s:%d:%d expected `=' after property name `%s'",
p->filename, p->line_num, p->col_num, property);
grub_free (property);
goto cleanup;
}
skip_whitespace (p);
char *value;
value = read_expression (p);
if (! value)
{
grub_free (property);
goto cleanup;
}
/* Handle the property value. */
if (grub_strcmp (property, "left") == 0)
parse_proportional_spec (value, &component->x, &component->xfrac);
else if (grub_strcmp (property, "top") == 0)
parse_proportional_spec (value, &component->y, &component->yfrac);
else if (grub_strcmp (property, "width") == 0)
parse_proportional_spec (value, &component->w, &component->wfrac);
else if (grub_strcmp (property, "height") == 0)
parse_proportional_spec (value, &component->h, &component->hfrac);
else
/* General property handling. */
component->ops->set_property (component, property, value);
grub_free (value);
grub_free (property);
if (grub_errno != GRUB_ERR_NONE)
goto cleanup;
}
cleanup:
grub_free (name);
return grub_errno;
}
static value unserialize_rec( sbuffer *b, value loader ) {
switch( read_char(b) ) {
case 'N':
return val_null;
case 'T':
return val_true;
case 'F':
return val_false;
case 'i':
return alloc_int(read_int(b));
case 'I':
return alloc_int32(read_int(b));
case 'f':
{
tfloat d;
read_str(b,sizeof(tfloat),&d);
return alloc_float(d);
}
case 's':
{
int l = read_int(b);
value v;
if( l < 0 || l > max_string_size )
ERROR();
v = alloc_empty_string(l);
add_ref(b,v);
read_str(b,l,(char*)val_string(v));
return v;
}
case 'o':
{
int f;
value o = alloc_object(NULL);
add_ref(b,o);
while( (f = read_int(b)) != 0 ) {
value fval = unserialize_rec(b,loader);
alloc_field(o,(field)f,fval);
}
switch( read_char(b) ) {
case 'p':
{
value v = unserialize_rec(b,loader);
if( !val_is_object(v) )
ERROR();
((vobject*)o)->proto = (vobject*)v;
}
break;
case 'z':
break;
default:
ERROR();
}
return o;
}
case 'r':
{
int n = read_int(b);
if( n < 0 || n >= b->nrefs )
ERROR();
return b->trefs[b->nrefs - n - 1];
}
case 'a':
{
int i;
int n = read_int(b);
value o;
value *t;
if( n < 0 || n > max_array_size )
ERROR();
o = alloc_array(n);
t = val_array_ptr(o);
add_ref(b,o);
for(i=0;i<n;i++)
t[i] = unserialize_rec(b,loader);
return o;
}
case 'p':
{
int nargs = read_int(b);
vfunction *f = (vfunction*)alloc_function((void*)1,nargs,NULL);
vfunction *f2;
value name;
add_ref(b,(value)f);
name = unserialize_rec(b,loader);
f2 = (vfunction*)val_ocall2(loader,id_loadprim,name,alloc_int(nargs));
if( !val_is_function(f2) || val_fun_nargs(f2) != nargs )
failure("Loader returned not-a-function");
f->t = f2->t;
f->addr = f2->addr;
f->module = f2->module;
return (value)f;
}
case 'L':
{
vfunction *f = (vfunction*)alloc_function((void*)1,0,NULL);
value mname;
int pos;
int nargs;
value env;
add_ref(b,(value)f);
mname = unserialize_rec(b,loader);
pos = read_int(b);
nargs = read_int(b);
env = unserialize_rec(b,loader);
if( !val_is_array(env) )
ERROR();
{
value exp = val_ocall2(loader,id_loadmodule,mname,loader);
value mval;
unsigned int i;
int_val *mpos;
neko_module *m;
if( !val_is_object(exp) ) {
buffer b = alloc_buffer("module ");
val_buffer(b,mname);
buffer_append(b," is not an object");
bfailure(b);
}
mval = val_field(exp,id_module);
if( !val_is_kind(mval,neko_kind_module) ) {
buffer b = alloc_buffer("module ");
val_buffer(b,mname);
buffer_append(b," has invalid type");
bfailure(b);
}
m = (neko_module*)val_data(mval);
mpos = m->code + pos;
for(i=0;i<m->nglobals;i++) {
vfunction *g = (vfunction*)m->globals[i];
if( val_is_function(g) && g->addr == mpos && g->module == m && g->nargs == nargs ) {
f->t = VAL_FUNCTION;
f->env = env;
f->addr = mpos;
f->nargs = nargs;
f->module = m;
return (value)f;
}
}
{
buffer b = alloc_buffer("module ");
val_buffer(b,mname);
buffer_append(b," has been modified");
bfailure(b);
}
}
return val_null;
}
case 'x':
{
value mname = unserialize_rec(b,loader);
value data = unserialize_rec(b,loader);
value exports = val_ocall2(loader,id_loadmodule,mname,loader);
value s;
if( !val_is_object(exports) ) {
buffer b = alloc_buffer("module ");
val_buffer(b,mname);
buffer_append(b," is not an object");
bfailure(b);
}
s = val_field(exports,id_unserialize);
if( !val_is_function(s) || (val_fun_nargs(s) != 1 && val_fun_nargs(s) != VAR_ARGS) ) {
buffer b = alloc_buffer("module ");
val_buffer(b,mname);
buffer_append(b," has invalid __unserialize function");
}
s = val_call1(s,data);
add_ref(b,s);
return s;
}
case 'h':
{
int i;
vhash *h = (vhash*)alloc(sizeof(vhash));
h->ncells = read_int(b);
h->nitems = read_int(b);
h->cells = (hcell**)alloc(sizeof(hcell*)*h->ncells);
for(i=0;i<h->ncells;i++)
h->cells[i] = NULL;
for(i=0;i<h->nitems;i++) {
hcell **p;
hcell *c = (hcell*)alloc(sizeof(hcell));
c->hkey = read_int(b);
c->key = unserialize_rec(b,loader);
c->val = unserialize_rec(b,loader);
c->next = NULL;
p = &h->cells[c->hkey % h->ncells];
while( *p != NULL )
p = &(*p)->next;
*p = c;
}
return alloc_abstract(k_hash,h);
}
default:
ERROR();
return val_null;
}
}
static void
skip_whitespace (struct parsebuf *p)
{
while (has_more (p) && is_whitespace(peek_char (p)))
read_char (p);
}
// Returns the current input stream position to the mark.
void utf8iterator_reset(Utf8Iterator* iter) {
iter->_start = iter->_mark;
iter->_pos = iter->_mark_pos;
read_char(iter);
}
scanner::token scanner::read_id(char first_char) {
char ch;
m_string.reset();
m_params.reset();
m_string.push_back(first_char);
bool is_arith = (m_normalized[(unsigned char) first_char] == '+');
bool is_alpha = (m_normalized[(unsigned char) first_char] == 'a');
ch = read_char();
// In SMT2 "-20" is an identifier.
if (!m_smt2 && state_ok() && first_char == '-' && m_normalized[(unsigned char) ch] == '0') {
return read_number(ch, false);
}
if (state_ok() && first_char == '|') {
return read_symbol(ch);
}
while (state_ok()) {
switch(m_normalized[(unsigned char) ch]) {
case '+':
if (is_arith) {
m_string.push_back(ch);
break;
}
// strings can have hyphens.
if (!is_alpha || ch != '-') {
goto bail_out;
}
case 'a':
case ':':
case '.':
case '0':
if (is_arith) {
goto bail_out;
}
m_string.push_back(ch);
break;
case '[':
m_string.push_back(0);
m_id = m_string.begin();
if (read_params()) {
return ID_TOKEN;
}
else {
return m_state;
}
default:
goto bail_out;
}
ch = read_char();
}
return m_state;
bail_out:
m_string.push_back(0);
m_id = m_string.begin();
unread_char();
return ID_TOKEN;
}
int main(int argc, char** argv)
{
cvector_void contacts;
char choice;
int quit = 0;
cvec_void(&contacts, 0, 10, sizeof(contact), free_contact, NULL);
saved = 1;
print_menu();
while (!quit) {
puts("What action would you like to perform?");
choice = read_char(stdin, SPACE_SET, 0, 1);
switch (choice) {
case 'A':
case 'a':
add_contact(&contacts);
break;
case 'D':
case 'd':
display_contacts(&contacts);
break;
case 'E':
case 'e':
edit_contacts(&contacts);
break;
case 'V':
case 'v':
save_contacts(&contacts);
break;
case 'L':
case 'l':
load_contacts(&contacts);
break;
case 'R':
case 'r':
remove_contact(&contacts);
break;
case 'S':
case 's':
sort_contacts(&contacts);
break;
case 'F':
case 'f':
find_contacts(&contacts, NULL, 1);
break;
case 'Q':
case 'q':
//TODO
if (!saved) {
puts("You have unsaved changes! Are you sure you want to quit? (y/N)");
choice = read_char(stdin, SPACE_SET_NO_NEWLINE, 0, 1);
if (choice == 'y' || choice == 'y')
quit = 1;
else
quit = 0;
} else {
quit = 1;
}
break;
case '?':
print_menu();
break;
}
putchar('\n');
}
cvec_free_void(&contacts);
return 0;
}
LPX *lpx_read_cpxlp(const char *fname)
{ /* read problem data in CPLEX LP format */
struct dsa _dsa, *dsa = &_dsa;
if (setjmp(dsa->jump)) goto fail;
dsa->lp = NULL;
dsa->fname = fname;
dsa->fp = NULL;
dsa->count = 0;
dsa->c = '\n';
dsa->token = T_EOF;
dsa->image[0] = '\0';
dsa->imlen = 0;
dsa->value = 0.0;
dsa->n_max = 100;
dsa->map = xcalloc(1+dsa->n_max, sizeof(int));
memset(&dsa->map[1], 0, dsa->n_max * sizeof(int));
dsa->ind = xcalloc(1+dsa->n_max, sizeof(int));
dsa->val = xcalloc(1+dsa->n_max, sizeof(double));
dsa->lb = xcalloc(1+dsa->n_max, sizeof(double));
dsa->ub = xcalloc(1+dsa->n_max, sizeof(double));
print("lpx_read_cpxlp: reading problem data from `%s'...",
dsa->fname);
dsa->fp = xfopen(dsa->fname, "r");
if (dsa->fp == NULL)
{ print("lpx_read_cpxlp: unable to open `%s' - %s", dsa->fname,
strerror(errno));
goto fail;
}
dsa->lp = lpx_create_prob();
lpx_create_index(dsa->lp);
#if 0
/* read very first character */
read_char(dsa);
#endif
/* scan very first token */
scan_token(dsa);
/* parse definition of the objective function */
if (!(dsa->token == T_MINIMIZE || dsa->token == T_MAXIMIZE))
fatal(dsa, "`minimize' or `maximize' keyword missing");
parse_objective(dsa);
/* parse constraints section */
if (dsa->token != T_SUBJECT_TO)
fatal(dsa, "constraints section missing");
parse_constraints(dsa);
/* parse optional bounds section */
if (dsa->token == T_BOUNDS) parse_bounds(dsa);
/* parse optional general, integer, and binary sections */
while (dsa->token == T_GENERAL ||
dsa->token == T_INTEGER ||
dsa->token == T_BINARY) parse_integer(dsa);
/* check for the keyword 'end' */
if (dsa->token == T_END)
scan_token(dsa);
else if (dsa->token == T_EOF)
print("%s:%d: warning: keyword `end' missing", dsa->fname,
dsa->count);
else
fatal(dsa, "symbol `%s' in wrong position", dsa->image);
/* nothing must follow the keyword 'end' (except comments) */
if (dsa->token != T_EOF)
fatal(dsa, "extra symbol(s) detected beyond `end'");
/* set bounds of variables */
{ int j, type;
double lb, ub;
for (j = lpx_get_num_cols(dsa->lp); j >= 1; j--)
{ lb = dsa->lb[j];
ub = dsa->ub[j];
if (lb == +DBL_MAX) lb = 0.0; /* default lb */
if (ub == -DBL_MAX) ub = +DBL_MAX; /* default ub */
if (lb == -DBL_MAX && ub == +DBL_MAX)
type = LPX_FR;
else if (ub == +DBL_MAX)
type = LPX_LO;
else if (lb == -DBL_MAX)
type = LPX_UP;
else if (lb != ub)
type = LPX_DB;
else
type = LPX_FX;
lpx_set_col_bnds(dsa->lp, j, type, lb, ub);
}
}
/* print some statistics */
{ int m = lpx_get_num_rows(dsa->lp);
int n = lpx_get_num_cols(dsa->lp);
int nnz = lpx_get_num_nz(dsa->lp);
print("lpx_read_cpxlp: %d row%s, %d column%s, %d non-zero%s",
m, m == 1 ? "" : "s", n, n == 1 ? "" : "s", nnz, nnz == 1 ?
"" : "s");
}
if (lpx_get_class(dsa->lp) == LPX_MIP)
{ int ni = lpx_get_num_int(dsa->lp);
int nb = lpx_get_num_bin(dsa->lp);
char s[50];
if (nb == 0)
strcpy(s, "none of");
else if (ni == 1 && nb == 1)
strcpy(s, "");
else if (nb == 1)
strcpy(s, "one of");
else if (nb == ni)
strcpy(s, "all of");
else
sprintf(s, "%d of", nb);
print("lpx_read_cpxlp: %d integer column%s, %s which %s binary"
, ni, ni == 1 ? "" : "s", s, nb == 1 ? "is" : "are");
}
print("lpx_read_cpxlp: %d lines were read", dsa->count);
xfclose(dsa->fp);
xfree(dsa->map);
xfree(dsa->ind);
xfree(dsa->val);
xfree(dsa->lb);
xfree(dsa->ub);
lpx_delete_index(dsa->lp);
lpx_order_matrix(dsa->lp);
return dsa->lp;
fail: if (dsa->lp != NULL) lpx_delete_prob(dsa->lp);
if (dsa->fp != NULL) xfclose(dsa->fp);
if (dsa->map != NULL) xfree(dsa->map);
if (dsa->ind != NULL) xfree(dsa->ind);
if (dsa->val != NULL) xfree(dsa->val);
if (dsa->lb != NULL) xfree(dsa->lb);
if (dsa->ub != NULL) xfree(dsa->ub);
return NULL;
}
static void scan_token(struct dsa *dsa)
{ /* scan next token */
int flag;
dsa->token = -1;
dsa->image[0] = '\0';
dsa->imlen = 0;
dsa->value = 0.0;
loop: flag = 0;
/* skip non-significant characters */
while (dsa->c == ' ') read_char(dsa);
/* recognize and scan current token */
if (dsa->c == EOF)
dsa->token = T_EOF;
else if (dsa->c == '\n')
{ read_char(dsa);
/* if the next character is letter, it may begin a keyword */
if (isalpha(dsa->c))
{ flag = 1;
goto name;
}
goto loop;
}
else if (dsa->c == '\\')
{ /* comment; ignore everything until end-of-line */
while (dsa->c != '\n') read_char(dsa);
goto loop;
}
else if (isalpha(dsa->c) || dsa->c != '.' && strchr(CHAR_SET,
dsa->c) != NULL)
name: { /* symbolic name */
dsa->token = T_NAME;
while (isalnum(dsa->c) || strchr(CHAR_SET, dsa->c) != NULL)
add_char(dsa);
if (flag)
{ /* check for keyword */
if (the_same(dsa->image, "minimize"))
dsa->token = T_MINIMIZE;
else if (the_same(dsa->image, "minimum"))
dsa->token = T_MINIMIZE;
else if (the_same(dsa->image, "min"))
dsa->token = T_MINIMIZE;
else if (the_same(dsa->image, "maximize"))
dsa->token = T_MAXIMIZE;
else if (the_same(dsa->image, "maximum"))
dsa->token = T_MAXIMIZE;
else if (the_same(dsa->image, "max"))
dsa->token = T_MAXIMIZE;
else if (the_same(dsa->image, "subject"))
{ if (dsa->c == ' ')
{ read_char(dsa);
if (tolower(dsa->c) == 't')
{ dsa->token = T_SUBJECT_TO;
dsa->image[dsa->imlen++] = ' ';
dsa->image[dsa->imlen] = '\0';
add_char(dsa);
if (tolower(dsa->c) != 'o')
fatal(dsa, "keyword `subject to' incomplete");
add_char(dsa);
if (isalpha(dsa->c))
fatal(dsa, "keyword `%s%c...' not recognized",
dsa->image, dsa->c);
}
}
}
else if (the_same(dsa->image, "such"))
{ if (dsa->c == ' ')
{ read_char(dsa);
if (tolower(dsa->c) == 't')
{ dsa->token = T_SUBJECT_TO;
dsa->image[dsa->imlen++] = ' ';
dsa->image[dsa->imlen] = '\0';
add_char(dsa);
if (tolower(dsa->c) != 'h')
err: fatal(dsa, "keyword `such that' incomplete");
add_char(dsa);
if (tolower(dsa->c) != 'a') goto err;
add_char(dsa);
if (tolower(dsa->c) != 't') goto err;
add_char(dsa);
if (isalpha(dsa->c))
fatal(dsa, "keyword `%s%c...' not recognized",
dsa->image, dsa->c);
}
}
}
else if (the_same(dsa->image, "st"))
dsa->token = T_SUBJECT_TO;
else if (the_same(dsa->image, "s.t."))
dsa->token = T_SUBJECT_TO;
else if (the_same(dsa->image, "st."))
dsa->token = T_SUBJECT_TO;
else if (the_same(dsa->image, "bounds"))
dsa->token = T_BOUNDS;
else if (the_same(dsa->image, "bound"))
dsa->token = T_BOUNDS;
else if (the_same(dsa->image, "general"))
dsa->token = T_GENERAL;
else if (the_same(dsa->image, "generals"))
dsa->token = T_GENERAL;
else if (the_same(dsa->image, "gen"))
dsa->token = T_GENERAL;
else if (the_same(dsa->image, "integer"))
dsa->token = T_INTEGER;
else if (the_same(dsa->image, "integers"))
dsa->token = T_INTEGER;
else if (the_same(dsa->image, "int"))
dsa->token = T_INTEGER;
else if (the_same(dsa->image, "binary"))
dsa->token = T_BINARY;
else if (the_same(dsa->image, "binaries"))
dsa->token = T_BINARY;
else if (the_same(dsa->image, "bin"))
dsa->token = T_BINARY;
else if (the_same(dsa->image, "end"))
dsa->token = T_END;
}
}
else if (isdigit(dsa->c) || dsa->c == '.')
{ /* numeric constant */
dsa->token = T_NUMBER;
/* scan integer part */
while (isdigit(dsa->c)) add_char(dsa);
/* scan optional fractional part (it is mandatory, if there is
no integer part) */
if (dsa->c == '.')
{ add_char(dsa);
if (dsa->imlen == 1 && !isdigit(dsa->c))
fatal(dsa, "invalid use of decimal point");
while (isdigit(dsa->c)) add_char(dsa);
}
/* scan optional decimal exponent */
if (dsa->c == 'e' || dsa->c == 'E')
{ add_char(dsa);
if (dsa->c == '+' || dsa->c == '-') add_char(dsa);
if (!isdigit(dsa->c))
fatal(dsa, "numeric constant `%s' incomplete",
dsa->image);
while (isdigit(dsa->c)) add_char(dsa);
}
/* convert the numeric constant to floating-point */
if (str2num(dsa->image, &dsa->value))
fatal(dsa, "numeric constant `%s' out of range",
dsa->image);
}
else if (dsa->c == '+')
dsa->token = T_PLUS, add_char(dsa);
else if (dsa->c == '-')
dsa->token = T_MINUS, add_char(dsa);
else if (dsa->c == ':')
dsa->token = T_COLON, add_char(dsa);
else if (dsa->c == '<')
{ dsa->token = T_LE, add_char(dsa);
if (dsa->c == '=') add_char(dsa);
}
else if (dsa->c == '>')
{ dsa->token = T_GE, add_char(dsa);
if (dsa->c == '=') add_char(dsa);
}
else if (dsa->c == '=')
{ dsa->token = T_EQ, add_char(dsa);
if (dsa->c == '<')
dsa->token = T_LE, add_char(dsa);
else if (dsa->c == '>')
dsa->token = T_GE, add_char(dsa);
}
else
fatal(dsa, "character `%c' not recognized", dsa->c);
/* skip non-significant characters */
while (dsa->c == ' ') read_char(dsa);
return;
}
int
optionally_enter(char *utf8string, int y_base, int x_base, int utf8string_size,
char *utf8prompt, ESCKEY_S *escape_list, HelpType help, int *flags)
{
UCS *string = NULL, ucs;
size_t string_size;
UCS *s2;
UCS *saved_original = NULL;
char *candidate;
UCS *kill_buffer = NULL;
UCS *k, *kb;
int field_pos; /* offset into array dline.vl */
int i, j, return_v, cols, prompt_width, too_thin,
real_y_base, km_popped, passwd;
char **help_text;
long fkey_table[12];
struct key_menu *km;
bitmap_t bitmap;
COLOR_PAIR *lastc = NULL, *promptc = NULL;
struct variable *vars = ps_global->vars;
struct display_line dline;
#ifdef _WINDOWS
int cursor_shown;
#endif
dprint((5, "=== optionally_enter called ===\n"));
dprint((9, "utf8string:\"%s\" y:%d x:%d length: %d append: %d\n",
utf8string ? utf8string : "",
x_base, y_base, utf8string_size,
(flags && *flags & OE_APPEND_CURRENT)));
dprint((9, "passwd:%d utf8prompt:\"%s\" label:\"%s\"\n",
(flags && *flags & OE_PASSWD_NOAST) ? 10 :
(flags && *flags & OE_PASSWD) ? 1 : 0,
utf8prompt ? utf8prompt : "",
(escape_list && escape_list[0].ch != -1 && escape_list[0].label)
? escape_list[0].label: ""));
if(!ps_global->ttyo)
return(pre_screen_config_opt_enter(utf8string, utf8string_size, utf8prompt,
escape_list, help, flags));
#ifdef _WINDOWS
if (mswin_usedialog ())
return(win_dialog_opt_enter(utf8string, utf8string_size, utf8prompt,
escape_list, help, flags));
#endif
/*
* Utf8string comes in as UTF-8. We'll convert it to a UCS-4 array and operate on
* that array, then convert it back before returning. Utf8string_size is the size
* of the utf8string array but that doesn't help us much for the array we need to
* operate on here. We'll just allocate a big array and then cut it off when
* sending it back.
*
* This should come before the specialized calls above but those aren't
* converted to use UCS-4 yet.
*/
string = utf8_to_ucs4_cpystr(utf8string);
dline.vused = ucs4_strlen(string);
string_size = (2 * MAX(utf8string_size,dline.vused) + 100);
fs_resize((void **) &string, string_size * sizeof(UCS));
suspend_busy_cue();
cols = ps_global->ttyo->screen_cols;
prompt_width = utf8_width(utf8prompt);
too_thin = 0;
km_popped = 0;
if(y_base > 0)
real_y_base = y_base;
else{
real_y_base = y_base + ps_global->ttyo->screen_rows;
real_y_base = MAX(real_y_base, 0);
}
flush_ordered_messages();
mark_status_dirty();
if(flags && *flags & OE_APPEND_CURRENT) /* save a copy in case of cancel */
saved_original = ucs4_cpystr(string);
/*
* build the function key mapping table, skipping predefined keys...
*/
memset(fkey_table, NO_OP_COMMAND, 12 * sizeof(long));
for(i = 0, j = 0; escape_list && escape_list[i].ch != -1 && i+j < 12; i++){
if(i+j == OE_HELP_KEY)
j++;
if(i+j == OE_CANCEL_KEY)
j++;
if(i+j == OE_ENTER_KEY)
j++;
fkey_table[i+j] = escape_list[i].ch;
}
/* assumption that HelpType is char ** */
help_text = help;
if(help_text){ /*---- Show help text -----*/
int width = ps_global->ttyo->screen_cols - x_base;
if(FOOTER_ROWS(ps_global) == 1){
km_popped++;
FOOTER_ROWS(ps_global) = 3;
clearfooter(ps_global);
y_base = -3;
real_y_base = y_base + ps_global->ttyo->screen_rows;
}
for(j = 0; j < 2 && help_text[j]; j++){
MoveCursor(real_y_base + 1 + j, x_base);
CleartoEOLN();
if(width < utf8_width(help_text[j])){
char *tmp = cpystr(help_text[j]);
(void) utf8_truncate(tmp, width);
PutLine0(real_y_base + 1 + j, x_base, tmp);
fs_give((void **) &tmp);
}
else
PutLine0(real_y_base + 1 + j, x_base, help_text[j]);
}
}
else{
clrbitmap(bitmap);
clrbitmap((km = &oe_keymenu)->bitmap); /* force formatting */
if(!(flags && (*flags) & OE_DISALLOW_HELP))
setbitn(OE_HELP_KEY, bitmap);
setbitn(OE_ENTER_KEY, bitmap);
if(!(flags && (*flags) & OE_DISALLOW_CANCEL))
setbitn(OE_CANCEL_KEY, bitmap);
setbitn(OE_CTRL_T_KEY, bitmap);
/*---- Show the usual possible keys ----*/
for(i=0,j=0; escape_list && escape_list[i].ch != -1 && i+j < 12; i++){
if(i+j == OE_HELP_KEY)
j++;
if(i+j == OE_CANCEL_KEY)
j++;
if(i+j == OE_ENTER_KEY)
j++;
oe_keymenu.keys[i+j].label = escape_list[i].label;
oe_keymenu.keys[i+j].name = escape_list[i].name;
setbitn(i+j, bitmap);
}
for(i = i+j; i < 12; i++)
if(!(i == OE_HELP_KEY || i == OE_ENTER_KEY || i == OE_CANCEL_KEY))
oe_keymenu.keys[i].name = NULL;
draw_keymenu(km, bitmap, cols, 1-FOOTER_ROWS(ps_global), 0, FirstMenu);
}
if(pico_usingcolor() && VAR_PROMPT_FORE_COLOR &&
VAR_PROMPT_BACK_COLOR &&
pico_is_good_color(VAR_PROMPT_FORE_COLOR) &&
pico_is_good_color(VAR_PROMPT_BACK_COLOR)){
lastc = pico_get_cur_color();
if(lastc){
promptc = new_color_pair(VAR_PROMPT_FORE_COLOR,
VAR_PROMPT_BACK_COLOR);
(void)pico_set_colorp(promptc, PSC_NONE);
}
}
else
StartInverse();
/*
* if display length isn't wide enough to support input,
* shorten up the prompt...
*/
if((dline.dwid = cols - (x_base + prompt_width)) < MIN_OPT_ENT_WIDTH){
char *p;
unsigned got_width;
/*
* Scoot prompt pointer forward at least (MIN_OPT_ENT_WIDTH - dline.dwid) screencells.
*/
p = utf8_count_forw_width(utf8prompt, MIN_OPT_ENT_WIDTH-dline.dwid, &got_width);
if(got_width < MIN_OPT_ENT_WIDTH-dline.dwid)
p = utf8_count_forw_width(utf8prompt, MIN_OPT_ENT_WIDTH+1-dline.dwid, &got_width);
if(p){
prompt_width = utf8_width(p);
dline.dwid = cols - (x_base + prompt_width);
utf8prompt = p;
}
}
/*
* How many UCS-4 characters will we need to make up the width dwid? It could be
* unlimited because of zero-width characters, I suppose, but realistically it
* isn't going to be much more than dwid.
*/
dline.dlen = 2 * dline.dwid + 100;
dline.dl = (UCS *) fs_get(dline.dlen * sizeof(UCS));
dline.olddl = (UCS *) fs_get(dline.dlen * sizeof(UCS));
memset(dline.dl, 0, dline.dlen * sizeof(UCS));
memset(dline.olddl, 0, dline.dlen * sizeof(UCS));
dline.movecursor = MoveCursor;
dline.writechar = Writewchar;
dline.row = real_y_base;
dline.col = x_base + prompt_width;
dline.vl = string;
dline.vlen = --string_size; /* -1 for terminating zero */
dline.vbase = field_pos = 0;
#ifdef _WINDOWS
cursor_shown = mswin_showcaret(1);
#endif
PutLine0(real_y_base, x_base, utf8prompt);
/*
* If appending, position field_pos at end of input.
*/
if(flags && *flags & OE_APPEND_CURRENT)
while(string[field_pos])
field_pos++;
passwd = (flags && *flags & OE_PASSWD_NOAST) ? 10 :
(flags && *flags & OE_PASSWD) ? 1 : 0;
line_paint(field_pos, &dline, &passwd);
/*----------------------------------------------------------------------
The main loop
loops until someone sets the return_v.
----------------------------------------------------------------------*/
return_v = -10;
while(return_v == -10) {
#ifdef MOUSE
mouse_in_content(KEY_MOUSE, -1, -1, 0x5, 0);
register_mfunc(mouse_in_content,
real_y_base, x_base + prompt_width,
real_y_base, ps_global->ttyo->screen_cols);
#endif
#ifdef _WINDOWS
mswin_allowpaste(MSWIN_PASTE_LINE);
g_mc_row = real_y_base;
g_mc_col = x_base + prompt_width;
mswin_mousetrackcallback(pcpine_oe_cursor);
#endif
/* Timeout 10 min to keep imap mail stream alive */
ps_global->conceal_sensitive_debugging = passwd ? 1 : 0;
ucs = read_char(600);
ps_global->conceal_sensitive_debugging = 0;
#ifdef MOUSE
clear_mfunc(mouse_in_content);
#endif
#ifdef _WINDOWS
mswin_allowpaste(MSWIN_PASTE_DISABLE);
mswin_mousetrackcallback(NULL);
#endif
/*
* Don't want to intercept all characters if typing in passwd.
* We select an ad hoc set that we will catch and let the rest
* through. We would have caught the set below in the big switch
* but we skip the switch instead. Still catch things like ^K,
* DELETE, ^C, RETURN.
*/
if(passwd)
switch(ucs){
case ctrl('F'):
case KEY_RIGHT:
case ctrl('B'):
case KEY_LEFT:
case ctrl('U'):
case ctrl('A'):
case KEY_HOME:
case ctrl('E'):
case KEY_END:
case TAB:
goto ok_for_passwd;
}
if(too_thin && ucs != KEY_RESIZE && ucs != ctrl('Z') && ucs != ctrl('C'))
goto bleep;
switch(ucs){
/*--------------- KEY RIGHT ---------------*/
case ctrl('F'):
case KEY_RIGHT:
if(field_pos >= string_size || string[field_pos] == '\0')
goto bleep;
line_paint(++field_pos, &dline, &passwd);
break;
/*--------------- KEY LEFT ---------------*/
case ctrl('B'):
case KEY_LEFT:
if(field_pos <= 0)
goto bleep;
line_paint(--field_pos, &dline, &passwd);
break;
/*-------------------- WORD SKIP --------------------*/
case ctrl('@'):
/*
* Note: read_char *can* return NO_OP_COMMAND which is
* the def'd with the same value as ^@ (NULL), BUT since
* read_char has a big timeout (>25 secs) it won't.
*/
/* skip thru current word */
while(string[field_pos]
&& isalnum((unsigned char) string[field_pos]))
field_pos++;
/* skip thru current white space to next word */
while(string[field_pos]
&& !isalnum((unsigned char) string[field_pos]))
field_pos++;
line_paint(field_pos, &dline, &passwd);
break;
/*-------------------- RETURN --------------------*/
case PF4:
if(F_OFF(F_USE_FK,ps_global)) goto bleep;
case ctrl('J'):
case ctrl('M'):
return_v = 0;
break;
/*-------------------- Destructive backspace --------------------*/
case '\177': /* DEL */
case ctrl('H'):
/* Try and do this with by telling the terminal to delete a
a character. If that fails, then repaint the rest of the
line, acheiving the same much less efficiently
*/
if(field_pos <= 0)
goto bleep;
field_pos--;
/* drop thru to pull line back ... */
/*-------------------- Delete char --------------------*/
case ctrl('D'):
case KEY_DEL:
if(field_pos >= string_size || !string[field_pos])
goto bleep;
dline.vused--;
for(s2 = &string[field_pos]; *s2 != 0; s2++)
*s2 = s2[1];
*s2 = 0; /* Copy last NULL */
line_paint(field_pos, &dline, &passwd);
if(flags) /* record change if requested */
*flags |= OE_USER_MODIFIED;
break;
/*--------------- Kill line -----------------*/
case ctrl('K'):
if(kill_buffer != NULL)
fs_give((void **) &kill_buffer);
if(field_pos != 0 || string[0]){
if(!passwd && F_ON(F_DEL_FROM_DOT, ps_global))
dline.vused -= ucs4_strlen(&string[i = field_pos]);
else
dline.vused = i = 0;
kill_buffer = ucs4_cpystr(&string[field_pos = i]);
string[field_pos] = '\0';
line_paint(field_pos, &dline, &passwd);
if(flags) /* record change if requested */
*flags |= OE_USER_MODIFIED;
}
break;
/*------------------- Undelete line --------------------*/
case ctrl('U'):
if(kill_buffer == NULL)
goto bleep;
/* Make string so it will fit */
kb = ucs4_cpystr(kill_buffer);
if(ucs4_strlen(kb) + ucs4_strlen(string) > string_size)
kb[string_size - ucs4_strlen(string)] = '\0';
if(string[field_pos] == '\0') {
/*--- adding to the end of the string ----*/
for(k = kb; *k; k++)
string[field_pos++] = *k;
string[field_pos] = '\0';
}
else{
int shift;
shift = ucs4_strlen(kb);
/* shift field_pos ... end to right */
for(k = &string[field_pos] + ucs4_strlen(&string[field_pos]);
k >= &string[field_pos]; k--)
*(k+shift) = *k;
for(k = kb; *k; k++)
string[field_pos++] = *k;
}
if(*kb && flags) /* record change if requested */
*flags |= OE_USER_MODIFIED;
dline.vused = ucs4_strlen(string);
fs_give((void **) &kb);
line_paint(field_pos, &dline, &passwd);
break;
/*-------------------- Interrupt --------------------*/
case ctrl('C'): /* ^C */
if(F_ON(F_USE_FK,ps_global) || (flags && ((*flags) & OE_DISALLOW_CANCEL)))
goto bleep;
goto cancel;
case PF2:
if(F_OFF(F_USE_FK,ps_global) || (flags && ((*flags) & OE_DISALLOW_CANCEL)))
goto bleep;
cancel:
return_v = 1;
if(saved_original){
for(i = 0; saved_original[i]; i++)
string[i] = saved_original[i];
string[i] = 0;
}
break;
case ctrl('A'):
case KEY_HOME:
/*-------------------- Start of line -------------*/
line_paint(field_pos = 0, &dline, &passwd);
break;
case ctrl('E'):
case KEY_END:
/*-------------------- End of line ---------------*/
line_paint(field_pos = dline.vused, &dline, &passwd);
break;
/*-------------------- Help --------------------*/
case ctrl('G') :
case PF1:
if(flags && ((*flags) & OE_DISALLOW_HELP))
goto bleep;
else if(FOOTER_ROWS(ps_global) == 1 && km_popped == 0){
km_popped++;
FOOTER_ROWS(ps_global) = 3;
clearfooter(ps_global);
if(lastc)
(void)pico_set_colorp(lastc, PSC_NONE);
else
EndInverse();
draw_keymenu(km, bitmap, cols, 1-FOOTER_ROWS(ps_global),
0, FirstMenu);
if(promptc)
(void)pico_set_colorp(promptc, PSC_NONE);
else
StartInverse();
mark_keymenu_dirty();
y_base = -3;
dline.row = real_y_base = y_base + ps_global->ttyo->screen_rows;
PutLine0(real_y_base, x_base, utf8prompt);
memset(dline.dl, 0, dline.dlen * sizeof(UCS));
memset(dline.olddl, 0, dline.dlen * sizeof(UCS));
line_paint(field_pos, &dline, &passwd);
break;
}
if(FOOTER_ROWS(ps_global) > 1){
mark_keymenu_dirty();
return_v = 3;
}
else
goto bleep;
break;
#ifdef MOUSE
/* Mouse support untested in pine 5.00 */
case KEY_MOUSE :
{
MOUSEPRESS mp;
int w;
mouse_get_last (NULL, &mp);
switch(mp.button){
case M_BUTTON_LEFT : /* position cursor */
mp.col -= dline.col;
/*
* We have to figure out which character is under the cursor.
* This is complicated by the fact that characters may
* be other than one cell wide.
*/
/* the -1 is for the '<' when text is offscreen left */
w = (dline.vbase > 0) ? mp.col-1 : mp.col;
if(mp.col <= 0)
field_pos = dline.vbase - 1;
else{
if(dline.vused <= dline.vbase
|| ucs4_str_width_a_to_b(dline.vl,dline.vbase,dline.vused-1) <= w)
field_pos = dline.vused;
else{
/*
* Find index of 1st character that causes the
* width to be > w.
*/
for(i = 0;
ucs4_str_width_a_to_b(dline.vl,dline.vbase,dline.vbase+i) <= w;
i++)
;
field_pos = dline.vbase + i;
}
}
field_pos = MIN(MAX(field_pos, 0), dline.vused);
/* just allow line_paint to choose vbase */
line_paint(field_pos, &dline, &passwd);
break;
case M_BUTTON_RIGHT :
#ifdef _WINDOWS
/*
* Same as M_BUTTON_LEFT except we paste in text after
* moving the cursor.
*/
mp.col -= dline.col;
/* the -1 is for the '<' when text is offscreen left */
w = (dline.vbase > 0) ? mp.col-1 : mp.col;
if(mp.col <= 0)
field_pos = dline.vbase - 1;
else{
if(dline.vused <= dline.vbase
|| ucs4_str_width_a_to_b(dline.vl,dline.vbase,dline.vused-1) <= w)
field_pos = dline.vused;
else{
/*
* Find index of 1st character that causes the
* width to be > w.
*/
for(i = 0;
ucs4_str_width_a_to_b(dline.vl,dline.vbase,dline.vbase+i) <= w;
i++)
;
field_pos = dline.vbase + i;
}
}
field_pos = MIN(MAX(field_pos, 0), dline.vused);
line_paint(field_pos, &dline, &passwd);
mswin_allowpaste(MSWIN_PASTE_LINE);
mswin_paste_popup();
mswin_allowpaste(MSWIN_PASTE_DISABLE);
break;
#endif
case M_BUTTON_MIDDLE : /* NO-OP for now */
default: /* just ignore */
break;
}
}
break;
#endif
case NO_OP_IDLE:
/*
* Keep mail stream alive by checking for new mail.
* If we're asking for a password in a login prompt
* we don't want to check for new_mail because the
* new mail check might be what got us here in the first
* place (because of a filter trying to save a message).
* If we need to wait for the user to come back then
* the caller will just have to deal with the failure
* to login.
*/
i = -1;
if(!ps_global->no_newmail_check_from_optionally_enter)
i = new_mail(0, 2, NM_DEFER_SORT);
if(sp_expunge_count(ps_global->mail_stream) &&
flags && ((*flags) & OE_SEQ_SENSITIVE))
goto cancel;
if(i < 0){
line_paint(field_pos, &dline, &passwd);
break; /* no changes, get on with life */
}
/* Else fall into redraw */
/*-------------------- Redraw --------------------*/
case ctrl('L'):
/*---------------- re size ----------------*/
case KEY_RESIZE:
dline.row = real_y_base = y_base > 0 ? y_base :
y_base + ps_global->ttyo->screen_rows;
if(lastc)
(void)pico_set_colorp(lastc, PSC_NONE);
else
EndInverse();
ClearScreen();
redraw_titlebar();
if(ps_global->redrawer != (void (*)(void))NULL)
(*ps_global->redrawer)();
redraw_keymenu();
if(promptc)
(void)pico_set_colorp(promptc, PSC_NONE);
else
StartInverse();
PutLine0(real_y_base, x_base, utf8prompt);
cols = ps_global->ttyo->screen_cols;
too_thin = 0;
if(cols < x_base + prompt_width + 4){
Writechar(BELL, 0);
PutLine0(real_y_base, 0, "Screen's too thin. Ouch!");
too_thin = 1;
}
else{
dline.col = x_base + prompt_width;
dline.dwid = cols - (x_base + prompt_width);
dline.dlen = 2 * dline.dwid + 100;
fs_resize((void **) &dline.dl, (size_t) dline.dlen * sizeof(UCS));
fs_resize((void **) &dline.olddl, (size_t) dline.dlen * sizeof(UCS));
memset(dline.dl, 0, dline.dlen * sizeof(UCS));
memset(dline.olddl, 0, dline.dlen * sizeof(UCS));
line_paint(field_pos, &dline, &passwd);
}
fflush(stdout);
dprint((9,
"optionally_enter RESIZE new_cols:%d too_thin: %d\n",
cols, too_thin));
break;
case PF3 : /* input to potentially remap */
case PF5 :
case PF6 :
case PF7 :
case PF8 :
case PF9 :
case PF10 :
case PF11 :
case PF12 :
if(F_ON(F_USE_FK,ps_global)
&& fkey_table[ucs - PF1] != NO_OP_COMMAND)
ucs = fkey_table[ucs - PF1]; /* remap function key input */
default:
if(escape_list){ /* in the escape key list? */
for(j=0; escape_list[j].ch != -1; j++){
if(escape_list[j].ch == ucs){
return_v = escape_list[j].rval;
break;
}
}
if(return_v != -10)
break;
}
if(ucs < 0x80 && FILTER_THIS((unsigned char) ucs)){
bleep:
putc(BELL, stdout);
continue;
}
ok_for_passwd:
/*--- Insert a character -----*/
if(dline.vused >= string_size)
goto bleep;
/*---- extending the length of the string ---*/
for(s2 = &string[++dline.vused]; s2 - string > field_pos; s2--)
*s2 = *(s2-1);
string[field_pos++] = ucs;
line_paint(field_pos, &dline, &passwd);
if(flags) /* record change if requested */
*flags |= OE_USER_MODIFIED;
} /*---- End of switch on char ----*/
}
#ifdef _WINDOWS
if(!cursor_shown)
mswin_showcaret(0);
#endif
if(dline.dl)
fs_give((void **) &dline.dl);
if(dline.olddl)
fs_give((void **) &dline.olddl);
if(saved_original)
fs_give((void **) &saved_original);
if(kill_buffer)
fs_give((void **) &kill_buffer);
/*
* Change string back into UTF-8.
*/
candidate = ucs4_to_utf8_cpystr(string);
if(string)
fs_give((void **) &string);
if(candidate){
strncpy(utf8string, candidate, utf8string_size);
utf8string[utf8string_size-1] = '\0';
fs_give((void **) &candidate);
}
if (!(flags && (*flags) & OE_KEEP_TRAILING_SPACE))
removing_trailing_white_space(utf8string);
if(lastc){
(void)pico_set_colorp(lastc, PSC_NONE);
free_color_pair(&lastc);
if(promptc)
free_color_pair(&promptc);
}
else
EndInverse();
MoveCursor(real_y_base, x_base); /* Move the cursor to show we're done */
fflush(stdout);
resume_busy_cue(0);
if(km_popped){
FOOTER_ROWS(ps_global) = 1;
clearfooter(ps_global);
ps_global->mangled_body = 1;
}
return(return_v);
}
/*----------------------------------------------------------------------
Read a character from keyboard with timeout
Input: none
Result: Returns command read via read_char
Times out and returns a null command every so often
Calculates the timeout for the read, and does a few other house keeping
things. The duration of the timeout is set in pine.c.
----------------------------------------------------------------------*/
UCS
read_command(char **utf8str)
{
int tm = 0, more_freq_timeo;
UCS ucs;
long dtime;
static unsigned char utf8buf[7];
unsigned char *newdestp;
/*
* timeo is the mail-check-interval. What we want to do (ignoring the
* messages_queued part) is timeout more often than timeo but only
* check for new mail every timeo or so seconds. The reason we want to
* timeout more often is so that we will have a chance to catch the user
* in an idle period where we can do a check_point(). Otherwise, with
* a default mail-check-interval, we are almost always calling newmail
* right after the user presses a key, making it the worst possible
* time to do a checkpoint.
*/
more_freq_timeo = MIN(get_input_timeout(), IDLE_TIMEOUT);
if(more_freq_timeo == 0)
more_freq_timeo = IDLE_TIMEOUT;
cancel_busy_cue(-1);
tm = (messages_queued(&dtime) > 1) ? (int)dtime : more_freq_timeo;
if(utf8str)
*utf8str = NULL;
ucs = read_char(tm);
if(ucs != NO_OP_COMMAND && ucs != NO_OP_IDLE && ucs != KEY_RESIZE)
zero_new_mail_count();
#ifdef BACKGROUND_POST
/*
* Any expired children to report on?
*/
if(ps_global->post && ps_global->post->pid == 0){
int winner = 0;
if(ps_global->post->status < 0){
q_status_message(SM_ORDER | SM_DING, 3, 3, "Abysmal failure!");
}
else{
(void) pine_send_status(ps_global->post->status,
ps_global->post->fcc, tmp_20k_buf, SIZEOF_20KBUF,
&winner);
q_status_message(SM_ORDER | (winner ? 0 : SM_DING), 3, 3,
tmp_20k_buf);
}
if(!winner)
q_status_message(SM_ORDER, 0, 3,
"Re-send via \"Compose\" then \"Yes\" to \"Continue INTERRUPTED?\"");
if(ps_global->post->fcc)
fs_give((void **) &ps_global->post->fcc);
fs_give((void **) &ps_global->post);
}
#endif
/*
* The character we get from read_char() is a UCS-4 char. Or it could be a special
* value like KEY_UP or NO_OP_IDLE or something similar. From here on out
* we're going to operate with UTF-8 internally. This is the point where we
* convert the UCS-4 input (actually whatever sort of input the user is typing
* was converted to UCS-4 first) to UTF-8. It's easy in this read_command
* case because if user types a non-ascii character as a command it's going to be
* an error. All commands are ascii. In order to present a reasonable error
* message we pass back the UTF-8 string to the caller.
*/
if(ucs >= 0x80 && ucs < KEY_BASE){
/*
* User typed a character that is non-ascii. Convert it to
* UTF-8.
*/
memset(utf8buf, 0, sizeof(utf8buf));
newdestp = utf8_put(utf8buf, (unsigned long) ucs);
if(newdestp - utf8buf > 1){ /* this should happen */
if(utf8str)
*utf8str = (char *) utf8buf;
dprint((9, "Read command: looks like user typed non-ascii command 0x%x %s: returning KEY_UTF8\n", ucs, pretty_command(ucs)));
ucs = KEY_UTF8;
}
else{
dprint((9, "Read command: looks like user typed unknown, non-ascii command 0x%x %s: returning KEY_UNKNOWN\n", ucs, pretty_command(ucs)));
ucs = KEY_UNKNOWN; /* best we can do, shouldn't happen */
}
}
else{
dprint((9, "Read command returning: 0x%x %s\n", ucs, pretty_command(ucs)));
}
return(ucs);
}
void input_schema(Pschema s, char *attr_name, int spaces, int pretty, FILE *in_file){ // reads a schema and puts it on the top op tstack
if(attr_name!=NULL && pretty){
print_spaces(spaces, stdout);
fprintf(stdout, "Input record attribute \"%s\"\n",attr_name);
}
if(pretty){
print_spaces(spaces, stdout);
}
if(s->type == TY_RECORD || s->type == TY_ARRAY || s->type == TY_ATTR){
int size = get_schema_size(s);
int nfields = 0;
switch(s->type){
case TY_RECORD:{
if(pretty){
fprintf(stdout,"Input for a record\n");
}
Pschema temp = s->child;
while(temp){
input_schema(temp->child, temp->id, spaces+1, pretty, in_file);
nfields++;
temp = temp->brother;
}
break;
}
case TY_ARRAY:{
int i;
if(pretty){
fprintf(stdout, "Input for an array\n");
}
nfields = s->size;
for(i=0; i<nfields; i++){
input_schema(s->child, NULL, spaces+1, pretty, in_file);
}
break;
}
default: print_schema(s,0); machine_error("TY_ATTR cannot be used in input_schema()."); break;
}
exec_cat(nfields,size);
} else{
switch(s->type){
case TY_INT: {
int in = read_int(stdout, in_file, "Insert an integer: ", pretty);
push_int(in);
break;
}
case TY_CHAR: {
char in = read_char(stdout, in_file, "Insert a char: ", pretty);
push_char(in);
break;
}
case TY_REAL: {
float in = read_real(stdout, in_file, "Insert a number of type real: ", pretty);
push_real(in);
break;
}
case TY_STRING: {
char *in = read_string(stdout, in_file, "Insert a string: ", pretty);
char *strig_to_store = stringtable_store(in, stringtable);
freemem(in, strlen(in) + 1);
push_string(strig_to_store);
break;
}
case TY_BOOL: {
char in = read_char(stdout, in_file, "Insert a boolean (0 or 1): ", pretty);
push_bool(in == '1');
break;
}
default: {machine_error("Unknown type of schema in input_schema()."); break;}
}
}
}
