static void
fsp_directory(FSP_SESSION *ses, struct uri *uri)
{
struct string buf;
FSP_DIR *dir;
unsigned char *data = get_uri_string(uri, URI_DATA);
unsigned char dircolor[8] = "";
if (!data)
fsp_error(connection_state(S_OUT_OF_MEM));
decode_uri(data);
if (!is_in_state(init_directory_listing(&buf, uri), S_OK))
fsp_error(connection_state(S_OUT_OF_MEM));
dir = fsp_opendir(ses, data);
if (!dir) fsp_error(connection_state_for_errno(errno));
fprintf(stderr, "text/html");
fclose(stderr);
puts(buf.source);
if (get_opt_bool("document.browse.links.color_dirs", NULL)) {
color_to_string(get_opt_color("document.colors.dirs", NULL),
dircolor);
}
sort_and_display_entries(dir, dircolor);
fsp_closedir(dir);
puts("</pre><hr/></body></html>");
fsp_close_session(ses);
exit(0);
}
static int
app_pipeline_fa_dscp_ls(struct app_params *app,
uint32_t pipeline_id)
{
struct app_pipeline_fa *p;
uint32_t i;
/* Check input arguments */
if (app == NULL)
return -1;
p = app_pipeline_data_fe(app, pipeline_id,
&pipeline_flow_actions);
if (p == NULL)
return -1;
if (p->params.dscp_enabled == 0)
return -1;
for (i = 0; i < RTE_DIM(p->dscp); i++) {
struct app_pipeline_fa_dscp *dscp = &p->dscp[i];
printf("DSCP = %2" PRIu32 ": Traffic class = %" PRIu32
", Color = %s\n",
i,
dscp->traffic_class,
color_to_string(dscp->color));
}
return 0;
}
/* First information such as permissions is gathered for each directory entry.
* Finally the sorted entries are added to the @data->fragment one by one. */
static inline void
add_dir_entries(struct directory_entry *entries, unsigned char *dirpath,
struct string *page)
{
unsigned char dircolor[8];
int dirpathlen = strlen((const char *)dirpath);
int i;
/* Setup @dircolor so it's easy to check if we should color dirs. */
if (get_opt_bool((const unsigned char *)"document.browse.links.color_dirs", NULL)) {
color_to_string(get_opt_color((const unsigned char *)"document.colors.dirs", NULL),
(unsigned char *) &dircolor);
} else {
dircolor[0] = 0;
}
for (i = 0; entries[i].name; i++) {
add_dir_entry(&entries[i], page, dirpathlen, dircolor);
mem_free(entries[i].attrib);
mem_free(entries[i].name);
}
/* We may have allocated space for entries but added none. */
mem_free_if(entries);
}
/**************************************************************************
Make a text tag for the selected text.
**************************************************************************/
void inputline_make_tag(GtkEntry *entry, enum text_tag_type type)
{
char buf[MAX_LEN_MSG];
GtkEditable *editable = GTK_EDITABLE(entry);
gint start_pos, end_pos;
gchar *selection;
if (!gtk_editable_get_selection_bounds(editable, &start_pos, &end_pos)) {
/* Let's say the selection starts and ends at the current position. */
start_pos = end_pos = gtk_editable_get_position(editable);
}
selection = gtk_editable_get_chars(editable, start_pos, end_pos);
if (type == TTT_COLOR) {
/* Get the color arguments. */
char fg_color_text[32], bg_color_text[32];
GdkColor *fg_color = g_object_get_data(G_OBJECT(entry), "fg_color");
GdkColor *bg_color = g_object_get_data(G_OBJECT(entry), "bg_color");
if (!fg_color && !bg_color) {
goto CLEAN_UP;
}
color_to_string(fg_color, fg_color_text, sizeof(fg_color_text));
color_to_string(bg_color, bg_color_text, sizeof(bg_color_text));
if (0 == featured_text_apply_tag(selection, buf, sizeof(buf),
TTT_COLOR, 0, FT_OFFSET_UNSET,
ft_color(fg_color_text,
bg_color_text))) {
goto CLEAN_UP;
}
} else if (0 == featured_text_apply_tag(selection, buf, sizeof(buf),
type, 0, FT_OFFSET_UNSET)) {
goto CLEAN_UP;
}
/* Replace the selection. */
gtk_editable_delete_text(editable, start_pos, end_pos);
end_pos = start_pos;
gtk_editable_insert_text(editable, buf, -1, &end_pos);
gtk_editable_select_region(editable, start_pos, end_pos);
CLEAN_UP:
g_free(selection);
}
static const char *
policer_action_to_string(struct pipeline_fa_policer_action *a)
{
if (a->drop)
return "D";
return color_to_string(a->color);
}
void write_color_option(GString *str, gint indent, gchar *label, GdkColor *color)
{
if (color)
{
gchar *colorstring = color_to_string(color);
write_char_option(str, indent, label, colorstring);
g_free(colorstring);
}
else
write_char_option(str, indent, label, "");
}
static int
computer_move(Gameinfo *gameinfo, int *passes)
{
int move;
float move_value;
int resign;
int resignation_declined = 0;
float upper_bound, lower_bound;
init_sgf(gameinfo);
/* Generate computer move. */
if (autolevel_on)
adjust_level_offset(gameinfo->to_move);
move = genmove(gameinfo->to_move, &move_value, &resign);
if (resignation_allowed && resign) {
int state = ascii_endgame(gameinfo, 2);
if (state != -1)
return state;
/* The opponent declined resignation. Remember not to resign again. */
resignation_allowed = 0;
resignation_declined = 1;
}
if (showscore) {
gnugo_estimate_score(&upper_bound, &lower_bound);
current_score_estimate = (int) ((lower_bound + upper_bound) / 2.0);
}
mprintf("%s(%d): %1m\n", color_to_string(gameinfo->to_move),
movenum + 1, move);
if (is_pass(move))
(*passes)++;
else
*passes = 0;
gnugo_play_move(move, gameinfo->to_move);
sgffile_add_debuginfo(sgftree.lastnode, move_value);
sgftreeAddPlay(&sgftree, gameinfo->to_move, I(move), J(move));
if (resignation_declined)
sgftreeAddComment(&sgftree, "GNU Go resignation was declined");
sgffile_output(&sgftree);
gameinfo->to_move = OTHER_COLOR(gameinfo->to_move);
return 0;
}
void
vgprintf(FILE *outputfile, const char *fmt, va_list ap)
{
if (fmt[0] == '%' && fmt[1] == 'o')
fmt += 2; /* cancel indent */
else if (stackp > 0)
fprintf(outputfile, "%.*s", stackp*2, " ");
for (; *fmt; ++fmt) {
if (*fmt == '%') {
switch (*++fmt) {
case 'c':
{
/* rules of promotion => passed as int, not char */
int c = va_arg(ap, int);
putc(c, outputfile);
break;
}
case 'd':
{
int d = va_arg(ap, int);
fprintf(outputfile, "%d", d);
break;
}
case 'x':
{
unsigned int d = va_arg(ap, unsigned int);
fprintf(outputfile, "%x", d);
break;
}
case 'f':
{
double f = va_arg(ap, double); /* passed as double, not float */
fprintf(outputfile, "%.2f", f);
break;
}
case 's':
{
char *s = va_arg(ap, char *);
fputs(s, outputfile);
break;
}
case '2':
fmt++;
if (*fmt != 'm' && *fmt != 'M') {
fprintf(outputfile, "\n\nUnknown format string '2%c'\n", *fmt);
break;
}
/* else fall through - 2 modifier on %m is default. */
case 'm':
case 'M':
{
char movename[4];
int m = va_arg(ap, int);
int n = va_arg(ap, int);
if (m == -1 && n == -1)
fputs("PASS", outputfile);
else if (!ON_BOARD2(m, n))
fprintf(outputfile, "[%d,%d]", m, n);
else {
/* Generate the move name. */
if (n < 8)
movename[0] = n + 65;
else
movename[0] = n + 66;
if (*fmt == 'm')
sprintf(movename+1, "%d", board_size - m);
else
sprintf(movename+1, "%-2d", board_size - m);
fputs(movename, outputfile);
}
break;
}
case '1':
fmt++;
if (*fmt != 'm' && *fmt != 'M') {
fprintf(outputfile, "\n\nUnknown format string '1%c'\n", *fmt);
break;
}
else {
char movename[4];
int pos = va_arg(ap, int);
int m = I(pos);
int n = J(pos);
if (pos == NO_MOVE)
fputs("PASS", outputfile);
else if (!ON_BOARD1(pos))
fprintf(outputfile, "[%d]", pos);
else {
/* Generate the move name. */
if (n < 8)
movename[0] = n + 65;
else
movename[0] = n + 66;
if (*fmt == 'm')
sprintf(movename + 1, "%d", board_size - m);
else
sprintf(movename + 1, "%-2d", board_size - m);
fputs(movename, outputfile);
}
break;
}
case 'H':
{
unsigned long h = va_arg(ap, unsigned long);
fprintf(outputfile, "%lx", h);
break;
}
case 'C':
{
int color = va_arg(ap, int);
fputs(color_to_string(color), outputfile);
break;
}
default:
fprintf(outputfile, "\n\nUnknown format character '%c'\n", *fmt);
break;
}
}
else
putc(*fmt, outputfile);
}
bool svg_attribute_color::write (QString &data, bool /*to_css*/) const
{
data = color_to_string (m_color);
return true;
}
static gboolean
cb_gnm_pango_attr_dump (PangoAttribute *attr, gpointer user_data)
{
g_print (" start=%u; end=%u\n", attr->start_index, attr->end_index);
switch (attr->klass->type) {
case PANGO_ATTR_FAMILY:
g_print (" family=\"%s\"\n", ((PangoAttrString *)attr)->value);
break;
case PANGO_ATTR_LANGUAGE:
g_print (" language=\"%s\"\n", pango_language_to_string (((PangoAttrLanguage *)attr)->value));
break;
case PANGO_ATTR_STYLE:
g_print (" style=%s\n",
enum_name (PANGO_TYPE_STYLE, ((PangoAttrInt *)attr)->value));
break;
case PANGO_ATTR_WEIGHT:
g_print (" weight=%s\n",
enum_name (PANGO_TYPE_WEIGHT, ((PangoAttrInt *)attr)->value));
break;
case PANGO_ATTR_VARIANT:
g_print (" variant=%s\n",
enum_name (PANGO_TYPE_VARIANT, ((PangoAttrInt *)attr)->value));
break;
case PANGO_ATTR_STRETCH:
g_print (" stretch=%s\n",
enum_name (PANGO_TYPE_STRETCH, ((PangoAttrInt *)attr)->value));
break;
case PANGO_ATTR_UNDERLINE:
g_print (" underline=%s\n",
enum_name (PANGO_TYPE_UNDERLINE, ((PangoAttrInt *)attr)->value));
break;
case PANGO_ATTR_STRIKETHROUGH:
g_print (" strikethrough=%d\n", ((PangoAttrInt *)attr)->value);
break;
case PANGO_ATTR_RISE:
g_print (" rise=%d\n", ((PangoAttrInt *)attr)->value);
break;
case PANGO_ATTR_FALLBACK:
g_print (" fallback=%d\n", ((PangoAttrInt *)attr)->value);
break;
case PANGO_ATTR_LETTER_SPACING:
g_print (" letter_spacing=%d\n", ((PangoAttrInt *)attr)->value);
break;
case PANGO_ATTR_SIZE:
g_print (" size=%d%s\n",
((PangoAttrSize *)attr)->size,
((PangoAttrSize *)attr)->absolute ? " abs" : "");
break;
case PANGO_ATTR_SCALE:
g_print (" scale=%g\n", ((PangoAttrFloat *)attr)->value);
break;
case PANGO_ATTR_FOREGROUND:
g_print (" foreground=%s\n", color_to_string (((PangoAttrColor *)attr)->color));
break;
case PANGO_ATTR_BACKGROUND:
g_print (" background=%s\n", color_to_string (((PangoAttrColor *)attr)->color));
break;
case PANGO_ATTR_UNDERLINE_COLOR:
g_print (" underline_color=%s\n", color_to_string (((PangoAttrColor *)attr)->color));
break;
case PANGO_ATTR_STRIKETHROUGH_COLOR:
g_print (" strikethrough_color=%s\n", color_to_string (((PangoAttrColor *)attr)->color));
break;
case PANGO_ATTR_FONT_DESC: {
char *desc = pango_font_description_to_string (((PangoAttrFontDesc*)attr)->desc);
g_print (" font=\"%s\"\n", desc);
g_free (desc);
break;
}
default:
g_print (" type=%s\n", enum_name (PANGO_TYPE_ATTR_TYPE, attr->klass->type));
}
return FALSE;
}
std::string card_to_string()
{
return "[" + rank_to_string(card_rank) + "~" + color_to_string(card_color) + "]" + Enter();
}
void
do_play_ascii(Gameinfo *gameinfo)
{
int m, num;
float fnum;
int passes = 0; /* two passes and its over */
int tmp;
char line[80];
char *line_ptr = line;
char *command;
char *tmpstring;
int state = 1;
if (have_time_settings())
clock_on = 1;
while (state == 1) {
state = 0;
/* No score is estimated yet. */
current_score_estimate = NO_SCORE;
/* Allow resignation at interface level (the engine may still be not
* allowed to resign.
*/
resignation_allowed = 1;
printf("\nBeginning ASCII mode game.\n\n");
gameinfo_print(gameinfo);
/* Does the computer play first? If so, make a move. */
if (gameinfo->computer_player == gameinfo->to_move)
state = computer_move(gameinfo, &passes);
/* main ASCII Play loop */
while (state == 0) {
/* Display game board. */
if (opt_showboard)
ascii_showboard();
#if !READLINE
/* Print the prompt */
mprintf("%s(%d): ", color_to_string(gameinfo->to_move), movenum + 1);
/* Read a line of input. */
line_ptr = line;
if (!fgets(line, 80, stdin))
return;
#else
snprintf(line, 79, "%s(%d): ",
color_to_string(gameinfo->to_move), movenum + 1);
if (!(line_ptr = readline(line)))
return;
add_history(line_ptr);
#endif
while (state == 0
&& (command = strtok(line_ptr, ";"), line_ptr = 0, command)) {
/* Get the command or move. */
switch (get_command(command)) {
case RESIGN:
state = ascii_endgame(gameinfo, 1);
break;
case END:
case EXIT:
case QUIT:
return;
case HELP:
show_commands();
break;
case CMD_HELPDEBUG:
printf(DEBUG_COMMANDS);
break;
case SHOWBOARD:
opt_showboard = !opt_showboard;
break;
case INFO:
printf("\n");
gameinfo_print(gameinfo);
break;
case SETBOARDSIZE:
if (sgf_initialized) {
printf("Boardsize cannot be changed after record is started!\n");
break;
}
command += 10;
if (sscanf(command, "%d", &num) != 1) {
printf("\nInvalid command syntax!\n");
break;
}
if (!check_boardsize(num, stdout))
break;
/* Init board. */
board_size = num;
clear_board();
/* In case max handicap changes on smaller board. */
gameinfo->handicap = place_fixed_handicap(gameinfo->handicap);
sgfOverwritePropertyInt(sgftree.root, "SZ", board_size);
sgfOverwritePropertyInt(sgftree.root, "HA", gameinfo->handicap);
break;
case SETHANDICAP:
if (sgf_initialized) {
printf("Handicap cannot be changed after game is started!\n");
break;
}
command += 9;
if (sscanf(command, "%d", &num) != 1) {
printf("\nInvalid command syntax!\n");
break;
}
if (num < 0 || num > MAX_HANDICAP) {
printf("\nInvalid handicap: %d\n", num);
break;
}
/* Init board. */
clear_board();
/* Place stones on board but don't record sgf
* in case we change more info. */
gameinfo->handicap = place_fixed_handicap(num);
printf("\nSet handicap to %d\n", gameinfo->handicap);
gameinfo->to_move = (gameinfo->handicap ? WHITE : BLACK);
break;
case FREEHANDICAP:
if (sgf_initialized) {
printf("Handicap cannot be changed after game is started!\n");
break;
}
while (*command && *command != ' ')
command++;
ascii_free_handicap(gameinfo, command);
break;
case SETKOMI:
if (sgf_initialized) {
printf("Komi cannot be modified after game record is started!\n");
break;
}
command += 5;
if (sscanf(command, "%f", &fnum) != 1) {
printf("\nInvalid command syntax!\n");
break;
}
komi = fnum;
printf("\nSet Komi to %.1f\n", komi);
break;
case SETDEPTH:
command += 6;
if (sscanf(command, "%d", &num) != 1) {
printf("\nInvalid command syntax!\n");
break;
}
mandated_depth = num;
printf("\nSet depth to %d\n", mandated_depth);
break;
case SETLEVEL:
command += 6;
if (sscanf(command, "%d", &num) != 1) {
printf("\nInvalid command syntax!\n");
break;
}
set_level(num);
printf("\nSet level to %d\n", num);
break;
case DISPLAY:
if (!opt_showboard)
ascii_showboard();
break;
case FORCE:
command += 6; /* skip the force part... */
switch (get_command(command)) {
case MOVE:
state = do_move(gameinfo, command, &passes, 1);
break;
case PASS:
state = do_pass(gameinfo, &passes, 1);
break;
default:
printf("Illegal forced move: %s %d\n", command,
get_command(command));
break;
}
break;
case MOVE:
state = do_move(gameinfo, command, &passes, 0);
break;
case PASS:
state = do_pass(gameinfo, &passes, 0);
break;
case PLAY:
command += 5;
if (sscanf(command, "%d", &num) != 1) {
printf("\nInvalid command syntax!\n");
break;
}
if (num >= 0)
for (m = 0; m < num; m++) {
gameinfo->computer_player
= OTHER_COLOR(gameinfo->computer_player);
state = computer_move(gameinfo, &passes);
if (state)
break;
if (passes >= 2)
break;
}
else {
printf("\nInvalid number of moves specified: %d\n", num);
break;
}
break;
case PLAYBLACK:
if (gameinfo->computer_player == WHITE)
gameinfo->computer_player = BLACK;
if (gameinfo->computer_player == gameinfo->to_move)
state = computer_move(gameinfo, &passes);
break;
case PLAYWHITE:
if (gameinfo->computer_player == BLACK)
gameinfo->computer_player = WHITE;
if (gameinfo->computer_player == gameinfo->to_move)
state = computer_move(gameinfo, &passes);
break;
case SWITCH:
gameinfo->computer_player = OTHER_COLOR(gameinfo->computer_player);
state = computer_move(gameinfo, &passes);
break;
case UNDO:
case CMD_BACK:
if (undo_move(1)) {
sgftreeAddComment(&sgftree, "undone");
sgftreeBack(&sgftree);
gameinfo->to_move = OTHER_COLOR(gameinfo->to_move);
}
else
printf("\nCan't undo.\n");
break;
case CMD_FORWARD:
if (sgftreeForward(&sgftree))
gameinfo->to_move = gnugo_play_sgfnode(sgftree.lastnode,
gameinfo->to_move);
else
printf("\nEnd of game tree.\n");
break;
case CMD_LAST:
while (sgftreeForward(&sgftree))
gameinfo->to_move = gnugo_play_sgfnode(sgftree.lastnode,
gameinfo->to_move);
break;
case COMMENT:
printf("\nEnter comment. Press ENTER when ready.\n");
fgets(line, 80, stdin);
sgftreeAddComment(&sgftree, line);
break;
case SCORE:
showscore = !showscore;
if (!showscore)
current_score_estimate = NO_SCORE;
break;
case CMD_DEAD:
silent_examine_position(FULL_EXAMINE_DRAGONS);
showdead = !showdead;
break;
case CMD_CAPTURE:
strtok(command, " ");
showcapture(strtok(NULL, " "));
break;
case CMD_DEFEND:
strtok(command, " ");
showdefense(strtok(NULL, " "));
break;
case CMD_SHOWMOYO:
tmp = printmoyo;
printmoyo = PRINTMOYO_MOYO;
silent_examine_position(EXAMINE_DRAGONS);
printmoyo = tmp;
break;
case CMD_SHOWTERRI:
tmp = printmoyo;
printmoyo = PRINTMOYO_TERRITORY;
silent_examine_position(EXAMINE_DRAGONS);
printmoyo = tmp;
break;
case CMD_SHOWAREA:
tmp = printmoyo;
printmoyo = PRINTMOYO_AREA;
silent_examine_position(EXAMINE_DRAGONS);
printmoyo = tmp;
break;
case CMD_SHOWDRAGONS:
silent_examine_position(EXAMINE_DRAGONS);
showboard(1);
break;
case CMD_GOTO:
strtok(command, " ");
ascii_goto(gameinfo, strtok(NULL, " "));
break;
case CMD_SAVE:
strtok(command, " ");
tmpstring = strtok(NULL, " ");
if (tmpstring) {
/* discard newline */
tmpstring[strlen(tmpstring) - 1] = 0;
/* make sure we are saving proper handicap */
init_sgf(gameinfo);
writesgf(sgftree.root, tmpstring);
printf("You may resume the game");
printf(" with -l %s --mode ascii\n", tmpstring);
printf("or load %s\n", tmpstring);
}
else
printf("Please specify filename\n");
break;
case CMD_LOAD:
strtok(command, " ");
tmpstring = strtok(NULL, " ");
if (tmpstring) {
/* discard newline */
tmpstring[strlen(tmpstring) - 1] = 0;
if (!sgftree_readfile(&sgftree, tmpstring)) {
fprintf(stderr, "Cannot open or parse '%s'\n", tmpstring);
break;
}
/* to avoid changing handicap etc. */
if (gameinfo_play_sgftree(gameinfo, &sgftree, NULL) == EMPTY)
fprintf(stderr, "Cannot load '%s'\n", tmpstring);
else {
sgf_initialized = 1;
sgfOverwritePropertyInt(sgftree.root, "HA", gameinfo->handicap);
}
}
else
printf("Please specify a filename\n");
break;
case CMD_LISTDRAGONS:
silent_examine_position(EXAMINE_DRAGONS);
show_dragons();
break;
default:
printf("\nInvalid command: %s", command);
break;
}
if (passes >= 2)
state = ascii_endgame(gameinfo, 0);
}
#if READLINE
free(line_ptr);
#endif
}
sgffile_output(&sgftree);
passes = 0;
/* Play a different game next time. */
update_random_seed();
/* Free the sgf tree and prepare for a new game. */
sgfFreeNode(sgftree.root);
sgftree_clear(&sgftree);
sgftreeCreateHeaderNode(&sgftree, board_size, komi, gameinfo->handicap);
sgf_initialized = 0;
gameinfo_clear(gameinfo);
}
}
