/*-------------------------------------------------------------------------*
* NEED_SPACE *
* *
*-------------------------------------------------------------------------*/
static void
Need_Space(int c)
{
int c_type = pl_char_type[c];
int space;
switch (pl_last_writing)
{
case W_NUMBER_0:
if (c_type == QT)
{
space = TRUE;
break;
} /* then in W_NUMBER */
case W_NUMBER:
space = (c_type & (UL | CL | SL | DI)) || c == '.';
break;
case W_IDENTIFIER:
space = (c_type & (UL | CL | SL | DI)) || c == '[' || c == '{';
break;
case W_QUOTED:
space = (c_type == QT);
break;
case W_GRAPHIC:
space = (c_type == GR);
break;
default:
space = FALSE;
}
if (space || (c == '(' && last_prefix_op != W_NO_PREFIX_OP))
Pl_Stream_Putc(' ', pstm_o);
else if (c_type == DI && last_prefix_op == W_PREFIX_OP_MINUS)
{
#ifdef MINUS_SIGN_CANNOT_BE_FOLLOWED_BY_SPACES
Pl_Stream_Putc(' ', pstm_o);
#else
(*p_bracket_minus)++;
/* to show it is an operator notation we also display a space (not strictly necessary) */
#if 1
Pl_Stream_Putc(' ', pstm_o);
#endif
Pl_Stream_Putc('(', pstm_o);
#endif
}
last_prefix_op = W_NO_PREFIX_OP;
pl_last_writing = W_NOTHING;
}
/*-------------------------------------------------------------------------*
* CTRL_C_MANAGER *
* *
*-------------------------------------------------------------------------*/
static PlLong
Ctrl_C_Manager(int from_callback)
{
StmInf *pstm = pl_stm_tbl[pl_stm_top_level_output];
PredInf *pred;
int c;
CodePtr to_execute;
// Pl_Reset_Prolog_In_Signal();
Restore_Machine_Regs(buff_save_machine_regs);
start:
Pl_Stream_Printf(pstm, "\nProlog interruption (h for help) ? ");
Pl_Stream_Flush(pstm);
c = Pl_Stream_Get_Key(pl_stm_tbl[pl_stm_top_level_input], TRUE, FALSE);
Pl_Stream_Putc('\n', pstm);
switch (c)
{
case 'a': /* abort */
to_execute = Prolog_Predicate(ABORT, 0);
if (from_callback)
return (PlLong) to_execute;
Pl_Execute_A_Continuation(to_execute);
break;
case 'b': /* break */
Pl_Call_Prolog(Prolog_Predicate(BREAK, 0));
goto start;
break;
case 'c': /* continue */
break;
case 'e': /* exit */
Pl_Exit_With_Value(0);
case 't': /* trace */
case 'd': /* debug */
if (SYS_VAR_DEBUGGER)
{
pred = Pl_Lookup_Pred(Pl_Create_Atom((c == 't') ? "trace" : "debug"), 0);
if (pred == NULL)
Pl_Fatal_Error(ERR_DEBUGGER_NOT_FOUND); /* should not occur */
Pl_Call_Prolog((CodePtr) pred->codep);
break;
}
default: /* help */
Pl_Stream_Printf(pstm, " a abort b break\n");
Pl_Stream_Printf(pstm, " c continue e exit\n");
if (SYS_VAR_DEBUGGER)
Pl_Stream_Printf(pstm, " d debug t trace\n");
Pl_Stream_Printf(pstm, " h/? help\n");
goto start;
}
return 0;
}
/*-------------------------------------------------------------------------*
* OUT_CHAR *
* *
*-------------------------------------------------------------------------*/
static void
Out_Char(int c)
{
Need_Space(c);
Pl_Stream_Putc(c, pstm_o);
}
/*-------------------------------------------------------------------------*
* OUT_SPACE *
* *
*-------------------------------------------------------------------------*/
static void
Out_Space(void)
{
Pl_Stream_Putc(' ', pstm_o);
pl_last_writing = W_NOTHING;
}
/*-------------------------------------------------------------------------*
* FORMAT *
* *
*-------------------------------------------------------------------------*/
static void
Format(StmInf *pstm, char *format, WamWord *lst_adr)
#define IMPOSS -12345678
{
WamWord word;
Bool has_n;
long generic;
long n, n1;
char *p;
long x;
double d;
int lg, stop;
int i, k;
char *format_stack[256];
char **top_stack = format_stack;
char buff[2048];
*top_stack++ = format;
do
{
format = *--top_stack;
while (*format)
{
if (*format == '%') /* C printf format */
{
if (format[1] == '%')
{
Pl_Stream_Putc('%', pstm);
format += 2;
continue;
}
p = buff;
n = n1 = IMPOSS;
do
if ((*p++ = *format++) == '*')
{
if (n == IMPOSS)
n = Arg_Integer(&lst_adr);
else
n1 = Arg_Integer(&lst_adr);
}
while ((char *) strchr("diouxXpnceEfgGs", p[-1]) == NULL);
*p = '\0';
if (strchr("eEfgG", p[-1]) == NULL)
{
generic = (p[-1] == 's') ? (long) Arg_Atom(&lst_adr)
: Arg_Integer(&lst_adr);
if (n != IMPOSS)
{
if (n1 != IMPOSS)
Pl_Stream_Printf(pstm, buff, n, n1, generic);
else
Pl_Stream_Printf(pstm, buff, n, generic);
}
else
Pl_Stream_Printf(pstm, buff, generic);
}
else
{
d = Arg_Float(&lst_adr);
if (n != IMPOSS)
{
if (n1 != IMPOSS)
Pl_Stream_Printf(pstm, buff, n, n1, d);
else
Pl_Stream_Printf(pstm, buff, n, d);
}
else
Pl_Stream_Printf(pstm, buff, d);
}
continue;
}
if (*format != '~')
{
Pl_Stream_Putc(*format, pstm);
format++;
continue;
}
if (*++format == '*')
{
n = Arg_Integer(&lst_adr);
format++;
has_n = TRUE;
}
else
{
p = format;
n = strtol(format, &format, 10);
has_n = (format != p);
}
switch (*format)
{
case 'a':
p = Arg_Atom(&lst_adr);
if (has_n)
Pl_Stream_Printf(pstm, "%*s", -n, p);
else
Pl_Stream_Puts(p, pstm);
break;
case 'c':
x = Arg_Integer(&lst_adr);
if (!Is_Valid_Code(x))
Pl_Err_Representation(pl_representation_character_code);
do
Pl_Stream_Putc(x, pstm);
while (--n > 0);
break;
case 'e':
case 'E':
case 'f':
case 'g':
case 'G':
x = *format;
d = Arg_Float(&lst_adr);
if (has_n)
sprintf(buff, "%%.%ld%c", n, (char) x);
else
sprintf(buff, "%%%c", (char) x);
Pl_Stream_Printf(pstm, buff, d);
break;
case 'd':
case 'D':
x = Arg_Integer(&lst_adr);
if (n == 0 && *format == 'd')
{
Pl_Stream_Printf(pstm, "%ld", x);
break;
}
if (x < 0)
{
Pl_Stream_Putc('-', pstm);
x = -x;
}
sprintf(buff, "%ld", x);
lg = strlen(buff) - n;
if (lg <= 0)
{
Pl_Stream_Puts("0.", pstm);
for (i = 0; i < -lg; i++)
Pl_Stream_Putc('0', pstm);
Pl_Stream_Printf(pstm, "%ld", x);
break;
}
stop = (*format == 'D') ? lg % 3 : -1;
if (stop == 0)
stop = 3;
for (p = buff, i = 0; *p; p++, i++)
{
if (i == lg)
Pl_Stream_Putc('.', pstm), stop = -1;
if (i == stop)
Pl_Stream_Putc(',', pstm), stop += 3;
Pl_Stream_Putc(*p, pstm);
}
break;
case 'r':
case 'R':
x = Arg_Integer(&lst_adr);
if (!has_n || n < 2 || n > 36)
n = 8;
k = ((*format == 'r') ? 'a' : 'A') - 10;
if (x < 0)
{
Pl_Stream_Putc('-', pstm);
x = -x;
}
p = buff + sizeof(buff) - 1;
*p = '\0';
do
{
i = x % n;
x = x / n;
--p;
*p = (i < 10) ? i + '0' : i + k;
}
while (x);
Pl_Stream_Puts(p, pstm);
break;
case 's':
case 'S':
word = Read_Arg(&lst_adr);
if (*format == 's')
p = Pl_Rd_Codes_Check(word);
else
p = Pl_Rd_Chars_Check(word);
if (has_n)
Pl_Stream_Printf(pstm, "%-*.*s", n, n, p);
else
Pl_Stream_Printf(pstm, "%s", p);
break;
case 'i':
do
Read_Arg(&lst_adr);
while (--n > 0);
break;
case 'k':
word = Read_Arg(&lst_adr);
Pl_Write_Term(pstm, -1, MAX_PREC,
WRITE_IGNORE_OP | WRITE_QUOTED, word);
break;
case 'q':
word = Read_Arg(&lst_adr);
Pl_Write_Term(pstm, -1, MAX_PREC, WRITE_NUMBER_VARS |
WRITE_NAME_VARS | WRITE_QUOTED, word);
break;
case 'p': /* only work if print.pl is linked */
word = Read_Arg(&lst_adr);
Pl_Write_Term(pstm, -1, MAX_PREC, WRITE_NUMBER_VARS |
WRITE_NAME_VARS | WRITE_PORTRAYED, word);
break;
case 'w':
word = Read_Arg(&lst_adr);
Pl_Write_Term(pstm, -1, MAX_PREC, WRITE_NUMBER_VARS |
WRITE_NAME_VARS, word);
break;
case '~':
Pl_Stream_Putc('~', pstm);
break;
case 'N':
if (pstm->line_pos == 0)
break;
case 'n':
do
Pl_Stream_Putc('\n', pstm);
while (--n > 0);
break;
case '?':
if (format[1])
*top_stack++ = format + 1;
format = Arg_Atom(&lst_adr);
continue;
default:
Pl_Err_Domain(pl_domain_format_control_sequence,
Tag_ATM(ATOM_CHAR(*format)));
}
format++;
}
}
while (top_stack > format_stack);
}