int main(int argc, char *argv[])
{
init();
if(init_setting() != 0){
print_errmsg("ERROR: SETTING init fail. \n");
return 1;
}
if(gc_init() != 0){
print_errmsg("ERROR: G_CODE init fail. \n");
return 1;
}
if (cm_init() == false)
{
print_errmsg("ERROR: USB-DEV init fail. \n");
return 1;
}
if (cmd_init() == false)
{
print_errmsg("ERROR: G code init fail.\n");
cm_close();
return 1;
}
if (tp_init() == false)
{
print_errmsg("ERROR: Temperature library init fail. \n");
cmd_close();
cm_close();
return 1;
}
plan_init();
Config_ResetDefault();
st_init();
while(1) {
LCD(10UL);
getCommand(10UL);
process_commands(50UL);
stepper(1000L);
manageHeater(10UL);
}
st_close();
plan_close();
tp_close();
cmd_close();
cm_close();
//debug
//sfp_close();
return 0;
}
/*
* cmd_escapestring: certain strings sent to a database should be properly
* escaped -- for instance, quotes need to be escaped to insure that
* a query string is properly formatted. cmd_escapestring does whatever
* is necessary to escape the special characters in a string.
*
* Inputs:
* cmd->argv[0]: connection name
* cmd->argv[1]: string to escape
*
* Returns:
* this command CANNOT fail. The return string is null-terminated and
* stored in the data field of the modret_t structure.
*
* Notes:
* Different languages may escape different characters in different ways.
* A backend should handle this correctly, where possible. If there is
* no client library function to do the string conversion, it is strongly
* recommended that the backend module writer do whatever is necessry (read
* the database documentation and figure it out) to do the conversion
* themselves in this function.
*
* A backend MUST supply a working escapestring implementation. Simply
* copying the data from argv[0] into the data field of the modret allows
* for possible SQL injection attacks when this backend is used.
*/
MODRET cmd_escapestring(cmd_rec * cmd) {
conn_entry_t *entry = NULL;
db_conn_t *conn = NULL;
modret_t *cmr = NULL;
char *unescaped = NULL;
char *escaped = NULL;
cmd_rec *close_cmd;
size_t unescaped_len = 0;
#ifdef HAVE_POSTGRES_PQESCAPESTRINGCONN
int pgerr = 0;
#endif
sql_log(DEBUG_FUNC, "%s", "entering \tpostgres cmd_escapestring");
_sql_check_cmd(cmd, "cmd_escapestring");
if (cmd->argc != 2) {
sql_log(DEBUG_FUNC, "%s", "exiting \tpostgres cmd_escapestring");
return PR_ERROR_MSG(cmd, MOD_SQL_POSTGRES_VERSION, "badly formed request");
}
/* get the named connection */
entry = _sql_get_connection(cmd->argv[0]);
if (!entry) {
sql_log(DEBUG_FUNC, "%s", "exiting \tpostgres cmd_escapestring");
return PR_ERROR_MSG(cmd, MOD_SQL_POSTGRES_VERSION,
"unknown named connection");
}
conn = (db_conn_t *) entry->data;
/* Make sure the connection is open. */
cmr = cmd_open(cmd);
if (MODRET_ERROR(cmr)) {
sql_log(DEBUG_FUNC, "%s", "exiting \tpostgres cmd_escapestring");
return cmr;
}
unescaped = cmd->argv[1];
unescaped_len = strlen(unescaped);
escaped = (char *) pcalloc(cmd->tmp_pool, sizeof(char) *
(unescaped_len * 2) + 1);
#ifdef HAVE_POSTGRES_PQESCAPESTRINGCONN
PQescapeStringConn(conn->postgres, escaped, unescaped, unescaped_len, &pgerr);
if (pgerr != 0) {
sql_log(DEBUG_FUNC, "%s", "exiting \tpostgres cmd_escapestring");
return _build_error(cmd, conn);
}
#else
PQescapeString(escaped, unescaped, unescaped_len);
#endif
close_cmd = _sql_make_cmd(cmd->tmp_pool, 1, entry->name);
cmd_close(close_cmd);
SQL_FREE_CMD(close_cmd);
sql_log(DEBUG_FUNC, "%s", "exiting \tpostgres cmd_escapestring");
return mod_create_data(cmd, (void *) escaped);
}
static int do_open(const char *path, int flags, mode_t mode, char *pathbuf)
{
int serverfh;
int holderfd;
int fh;
serverfh = cmd_open(path, flags, mode, pathbuf, &holderfd);
if(serverfh < 0) {
real_close(holderfd, 1);
return serverfh;
}
fh = get_handle();
if(fh < 0) {
cmd_close(serverfh);
real_close(holderfd, 1);
return fh;
}
fcntl(holderfd, F_SETFD, FD_CLOEXEC);
__av_dtable[fh].serverfh = serverfh;
__av_dtable[fh].holderfd = holderfd;
return fh;
}
static int
stroke_rect_element(svg_state_t *s, htsmsg_t *attribs)
{
const char *str_width = htsmsg_get_str(attribs, "width");
const char *str_height = htsmsg_get_str(attribs, "height");
const char *str_x = htsmsg_get_str(attribs, "x");
const char *str_y = htsmsg_get_str(attribs, "y");
if(str_width == NULL || str_height == NULL || str_x == NULL || str_y == NULL)
return -1;
float width = my_str2double(str_width, NULL);
float height = my_str2double(str_height, NULL);
float x = my_str2double(str_x, NULL);
float y = my_str2double(str_y, NULL);
float v[2];
v[0] = x;
v[1] = y;
cmd_move_abs(s, v);
v[0] += width;
cmd_lineto_abs(s, v);
v[1] += height;
cmd_lineto_abs(s, v);
v[0] = x;
cmd_lineto_abs(s, v);
cmd_close(s);
return 0;
}
/* use common shell processing for all commands - this prevent static linking
of EXTCMD or VDISK modules for shl_ramdisk/shl_mem functions. */
static void shell_cmd(const char *cmd, const char *args) {
char *cstr = strcat_dyn(sprintf_dyn(cmd), args);
cmd_state cs = cmd_init(cstr, 0);
cmd_run(cs, CMDR_ECHOOFF);
cmd_close(cs);
free(cstr);
}
/*
* cmd_exit: closes all open connections.
*
* Inputs:
* None
*
* Returns:
* A simple non-error modret_t.
*/
static modret_t *cmd_exit(cmd_rec *cmd) {
register unsigned int i = 0;
sql_log(DEBUG_FUNC, "%s", "entering \tpostgres cmd_exit");
for (i = 0; i < conn_cache->nelts; i++) {
conn_entry_t *entry = ((conn_entry_t **) conn_cache->elts)[i];
if (entry->connections > 0) {
cmd_rec *close_cmd = _sql_make_cmd(conn_pool, 2, entry->name, "1");
cmd_close(close_cmd);
destroy_pool(close_cmd->pool);
}
}
sql_log(DEBUG_FUNC, "%s", "exiting \tpostgres cmd_exit");
return PR_HANDLED(cmd);
}
/*
* sql_timer_cb: when a timer goes off, this is the function that gets called.
* This function makes assumptions about the db_conn_t members.
*/
static int sql_timer_cb(CALLBACK_FRAME) {
conn_entry_t *entry = NULL;
int i = 0;
cmd_rec *cmd = NULL;
for (i = 0; i < conn_cache->nelts; i++) {
entry = ((conn_entry_t **) conn_cache->elts)[i];
if (entry->timer == p2) {
sql_log(DEBUG_INFO, "timer expired for connection '%s'", entry->name);
cmd = _sql_make_cmd( conn_pool, 2, entry->name, "1" );
cmd_close( cmd );
SQL_FREE_CMD(cmd);
entry->timer = 0;
}
}
return 0;
}
static int virt_close(int fd, int undersc)
{
int res;
if(!FD_OK(fd) || !ISVIRTUAL(fd))
res = real_close(fd, undersc);
else {
int errnosave = errno;
res = cmd_close(SERVERFH(fd));
real_close(__av_dtable[fd].holderfd, 1);
free_handle(fd);
if(res < 0)
errno = -res, res = -1;
else
errno = errnosave;
}
return res;
}
string builder::flush() {
if (m_lazy) {
while (m_counters[syntaxtag::A] > 0) cmd_close(true);
while (m_counters[syntaxtag::B] > 0) background_close(true);
while (m_counters[syntaxtag::F] > 0) color_close(true);
while (m_counters[syntaxtag::T] > 0) font_close(true);
while (m_counters[syntaxtag::U] > 0) line_color_close(true);
while (m_counters[syntaxtag::u] > 0) underline_close(true);
while (m_counters[syntaxtag::o] > 0) overline_close(true);
}
string output = m_output.data();
// reset values
m_output.clear();
for (auto& counter : m_counters) counter.second = 0;
for (auto& value : m_colors) value.second = "";
m_fontindex = 1;
return string_util::replace_all(output, string{BUILDER_SPACE_TOKEN}, " ");
}
/*
* cmd_insert: executes an INSERT query, properly constructing the query
* based on the inputs.
*
* cmd_insert takes either exactly two inputs, or exactly four. If only
* two inputs are given, the second is a monolithic query string. See
* the examples below.
*
* Inputs:
* cmd->argv[0]: connection name
* cmd->argv[1]: table
* cmd->argv[2]: field string
* cmd->argv[3]: value string
*
* Returns:
* either a properly filled error modret_t if the insert failed, or a
* simple non-error modret_t.
*
* Example:
* These are example queries that would be executed for Postgres; other
* backends will have different SQL syntax.
*
* argv[] = "default","log","userid, date, count", "'aah', now(), 2"
* query = "INSERT INTO log (userid, date, count) VALUES ('aah', now(), 2)"
*
* argv[] = "default"," INTO foo VALUES ('do','re','mi','fa')"
* query = "INSERT INTO foo VALUES ('do','re','mi','fa')"
*
* Notes:
* none
*/
MODRET cmd_insert(cmd_rec *cmd) {
conn_entry_t *entry = NULL;
db_conn_t *conn = NULL;
modret_t *cmr = NULL;
modret_t *dmr = NULL;
char *query = NULL;
cmd_rec *close_cmd;
sql_log(DEBUG_FUNC, "%s", "entering \tpostgres cmd_insert");
_sql_check_cmd(cmd, "cmd_insert");
if ((cmd->argc != 2) && (cmd->argc != 4)) {
sql_log(DEBUG_FUNC, "%s", "exiting \tpostgres cmd_insert");
return PR_ERROR_MSG(cmd, MOD_SQL_POSTGRES_VERSION, "badly formed request");
}
/* get the named connection */
entry = _sql_get_connection(cmd->argv[0]);
if (!entry) {
sql_log(DEBUG_FUNC, "%s", "exiting \tpostgres cmd_insert");
return PR_ERROR_MSG(cmd, MOD_SQL_POSTGRES_VERSION,
"unknown named connection");
}
conn = (db_conn_t *) entry->data;
cmr = cmd_open(cmd);
if (MODRET_ERROR(cmr)) {
sql_log(DEBUG_FUNC, "%s", "exiting \tpostgres cmd_insert");
return cmr;
}
/* construct the query string */
if (cmd->argc == 2) {
query = pstrcat(cmd->tmp_pool, "INSERT ", cmd->argv[1], NULL);
} else {
query = pstrcat( cmd->tmp_pool, "INSERT INTO ", cmd->argv[1], " (",
cmd->argv[2], ") VALUES (", cmd->argv[3], ")",
NULL );
}
/* log the query string */
sql_log(DEBUG_INFO, "query \"%s\"", query);
/* perform the query. if it doesn't work, log the error, close the
* connection then return the error from the query processing.
*/
if (!(conn->result = PQexec(conn->postgres, query)) ||
(PQresultStatus(conn->result) != PGRES_COMMAND_OK)) {
dmr = _build_error( cmd, conn );
if (conn->result) PQclear(conn->result);
close_cmd = _sql_make_cmd( cmd->tmp_pool, 1, entry->name );
cmd_close(close_cmd);
SQL_FREE_CMD(close_cmd);
sql_log(DEBUG_FUNC, "%s", "exiting \tpostgres cmd_insert");
return dmr;
}
PQclear(conn->result);
/* close the connection and return HANDLED. */
close_cmd = _sql_make_cmd( cmd->tmp_pool, 1, entry->name );
cmd_close(close_cmd);
SQL_FREE_CMD(close_cmd);
sql_log(DEBUG_FUNC, "%s", "exiting \tpostgres cmd_insert");
return PR_HANDLED(cmd);
}
/*
* cmd_select: executes a SELECT query. properly constructing the query
* based on the inputs. See mod_sql.h for the definition of the _sql_data
* structure which is used to return the result data.
*
* cmd_select takes either exactly two inputs, or more than two. If only
* two inputs are given, the second is a monolithic query string. See
* the examples below.
*
* Inputs:
* cmd->argv[0]: connection name
* cmd->argv[1]: table
* cmd->argv[2]: select string
* Optional:
* cmd->argv[3]: where clause
* cmd->argv[4]: requested number of return rows (LIMIT)
*
* etc. : other options, such as "GROUP BY", "ORDER BY",
* and "DISTINCT" will start at cmd->arg[5]. All
* backends MUST support 'DISTINCT', the other
* arguments are optional (but encouraged).
*
* Returns:
* either a properly filled error modret_t if the select failed, or a
* modret_t with the result data filled in.
*
* Example:
* These are example queries that would be executed for Postgres; other
* backends will have different SQL syntax.
*
* argv[] = "default","user","userid, count", "userid='aah'","2"
* query = "SELECT userid, count FROM user WHERE userid='aah' LIMIT 2"
*
* argv[] = "default","usr1, usr2","usr1.foo, usr2.bar"
* query = "SELECT usr1.foo, usr2.bar FROM usr1, usr2"
*
* argv[] = "default","usr1","foo",,,"DISTINCT"
* query = "SELECT DISTINCT foo FROM usr1"
*
* argv[] = "default","bar FROM usr1 WHERE tmp=1 ORDER BY bar"
* query = "SELECT bar FROM usr1 WHERE tmp=1 ORDER BY bar"
*
* Notes:
* certain selects could return huge amounts of data. do whatever is
* possible to minimize the amount of data copying here.
*/
MODRET cmd_select(cmd_rec *cmd) {
conn_entry_t *entry = NULL;
db_conn_t *conn = NULL;
modret_t *cmr = NULL;
modret_t *dmr = NULL;
char *query = NULL;
int cnt = 0;
cmd_rec *close_cmd;
sql_log(DEBUG_FUNC, "%s", "entering \tpostgres cmd_select");
_sql_check_cmd(cmd, "cmd_select");
if (cmd->argc < 2) {
sql_log(DEBUG_FUNC, "%s", "exiting \tpostgres cmd_select");
return PR_ERROR_MSG(cmd, MOD_SQL_POSTGRES_VERSION, "badly formed request");
}
/* get the named connection */
entry = _sql_get_connection(cmd->argv[0]);
if (!entry) {
sql_log(DEBUG_FUNC, "%s", "exiting \tpostgres cmd_select");
return PR_ERROR_MSG(cmd, MOD_SQL_POSTGRES_VERSION,
"unknown named connection");
}
conn = (db_conn_t *) entry->data;
cmr = cmd_open(cmd);
if (MODRET_ERROR(cmr)) {
sql_log(DEBUG_FUNC, "%s", "exiting \tpostgres cmd_select");
return cmr;
}
/* construct the query string */
if (cmd->argc == 2) {
query = pstrcat(cmd->tmp_pool, "SELECT ", cmd->argv[1], NULL);
} else {
query = pstrcat( cmd->tmp_pool, cmd->argv[2], " FROM ",
cmd->argv[1], NULL );
if ((cmd->argc > 3) && (cmd->argv[3]))
query = pstrcat( cmd->tmp_pool, query, " WHERE ", cmd->argv[3], NULL );
if ((cmd->argc > 4) && (cmd->argv[4]))
query = pstrcat( cmd->tmp_pool, query, " LIMIT ", cmd->argv[4], NULL );
if (cmd->argc > 5) {
/* handle the optional arguments -- they're rare, so in this case
* we'll play with the already constructed query string, but in
* general we should probably take optional arguments into account
* and put the query string together later once we know what they are.
*/
for (cnt=5; cnt < cmd->argc; cnt++) {
if ((cmd->argv[cnt]) && !strcasecmp("DISTINCT",cmd->argv[cnt])) {
query = pstrcat( cmd->tmp_pool, "DISTINCT ", query, NULL);
}
}
}
query = pstrcat( cmd->tmp_pool, "SELECT ", query, NULL);
}
/* log the query string */
sql_log(DEBUG_INFO, "query \"%s\"", query);
/* perform the query. if it doesn't work, log the error, close the
* connection then return the error from the query processing.
*/
if (!(conn->result = PQexec(conn->postgres, query)) ||
(PQresultStatus(conn->result) != PGRES_TUPLES_OK)) {
dmr = _build_error( cmd, conn );
if (conn->result) PQclear(conn->result);
close_cmd = _sql_make_cmd( cmd->tmp_pool, 1, entry->name );
cmd_close(close_cmd);
SQL_FREE_CMD(close_cmd);
sql_log(DEBUG_FUNC, "%s", "exiting \tpostgres cmd_select");
return dmr;
}
/* get the data. if it doesn't work, log the error, close the
* connection then return the error from the data processing.
*/
dmr = _build_data( cmd, conn );
PQclear(conn->result);
if (MODRET_ERROR(dmr)) {
sql_log(DEBUG_FUNC, "%s", "exiting \tpostgres cmd_select");
close_cmd = _sql_make_cmd( cmd->tmp_pool, 1, entry->name );
cmd_close(close_cmd);
SQL_FREE_CMD(close_cmd);
return dmr;
}
/* close the connection, return the data. */
close_cmd = _sql_make_cmd( cmd->tmp_pool, 1, entry->name );
cmd_close(close_cmd);
SQL_FREE_CMD(close_cmd);
sql_log(DEBUG_FUNC, "%s", "exiting \tpostgres cmd_select");
return dmr;
}
static void
stroke_path(svg_state_t *state, const char *str)
{
float values[6];
int num_params = 0;
int cur_param = 0;
void (*cur_cmd)(svg_state_t *state, const float *params) = NULL;
while(*str) {
if(*str < 33) {
str++;
continue;
}
if(cur_cmd != NULL) {
const char *endptr;
double d = my_str2double(str, &endptr);
if(endptr != str) {
values[cur_param] = d;
cur_param++;
if(cur_param == num_params) {
cur_cmd(state, values);
cur_param = 0;
}
str = endptr;
while(*str < 33 && *str)
str++;
if(*str == ',')
str++;
while(*str < 33 && *str)
str++;
continue;
}
}
while(*str < 33 && *str)
str++;
char mode = *str++;
switch(mode) {
case 'M':
cur_cmd = cmd_move_abs;
num_params = 2;
break;
case 'm':
cur_cmd = cmd_move_rel;
num_params = 2;
break;
case 'c':
cur_cmd = cmd_curveto_rel;
num_params = 6;
break;
case 'C':
cur_cmd = cmd_curveto_abs;
num_params = 6;
break;
case 'l':
cur_cmd = cmd_lineto_rel;
num_params = 2;
break;
case 'L':
cur_cmd = cmd_lineto_abs;
num_params = 2;
break;
case 'z':
case 'Z':
cur_cmd = NULL;
num_params = 0;
cmd_close(state);
break;
default:
printf("Cant handle mode %c\n", mode);
return;
}
}
}
/*
* cmd_query: executes a freeform query string, with no syntax checking.
*
* cmd_query takes exactly two inputs, the connection and the query string.
*
* Inputs:
* cmd->argv[0]: connection name
* cmd->argv[1]: query string
*
* Returns:
* depending on the query type, returns a modret_t with data, a non-error
* modret_t, or a properly filled error modret_t if the query failed.
*
* Example:
* None. The query should be passed directly to the backend database.
*
* Notes:
* None.
*/
MODRET cmd_query(cmd_rec *cmd) {
conn_entry_t *entry = NULL;
db_conn_t *conn = NULL;
modret_t *cmr = NULL;
modret_t *dmr = NULL;
char *query = NULL;
cmd_rec *close_cmd;
sql_log(DEBUG_FUNC, "%s", "entering \tpostgres cmd_query");
_sql_check_cmd(cmd, "cmd_query");
if (cmd->argc != 2) {
sql_log(DEBUG_FUNC, "%s", "exiting \tpostgres cmd_query");
return ERROR_MSG(cmd, MOD_SQL_POSTGRES_VERSION, "badly formed request");
}
/* get the named connection */
entry = _sql_get_connection(cmd->argv[0]);
if (!entry) {
sql_log(DEBUG_FUNC, "%s", "exiting \tpostgres cmd_query");
return ERROR_MSG(cmd, MOD_SQL_POSTGRES_VERSION, "unknown named connection");
}
conn = (db_conn_t *) entry->data;
cmr = cmd_open(cmd);
if (MODRET_ERROR(cmr)) {
sql_log(DEBUG_FUNC, "%s", "exiting \tpostgres cmd_query");
return cmr;
}
query = pstrcat(cmd->tmp_pool, cmd->argv[1], NULL);
/* log the query string */
sql_log( DEBUG_INFO, "query \"%s\"", query);
/* perform the query. if it doesn't work, log the error, close the
* connection then return the error from the query processing.
*/
if (!(conn->result = PQexec(conn->postgres, query)) ||
((PQresultStatus(conn->result) != PGRES_TUPLES_OK) &&
(PQresultStatus(conn->result) != PGRES_COMMAND_OK))) {
dmr = _build_error( cmd, conn );
if (conn->result) PQclear(conn->result);
close_cmd = _sql_make_cmd( cmd->tmp_pool, 1, entry->name );
cmd_close(close_cmd);
SQL_FREE_CMD(close_cmd);
sql_log(DEBUG_FUNC, "%s", "exiting \tpostgres cmd_select");
return dmr;
}
/* get data if necessary. if it doesn't work, log the error, close the
* connection then return the error from the data processing.
*/
if ( PQresultStatus( conn->result ) == PGRES_TUPLES_OK ) {
dmr = _build_data( cmd, conn );
PQclear(conn->result);
if (MODRET_ERROR(dmr)) {
sql_log(DEBUG_FUNC, "%s", "exiting \tpostgres cmd_query");
}
} else {
dmr = HANDLED(cmd);
}
/* close the connection, return the data. */
close_cmd = _sql_make_cmd( cmd->tmp_pool, 1, entry->name );
cmd_close(close_cmd);
SQL_FREE_CMD(close_cmd);
sql_log(DEBUG_FUNC, "%s", "exiting \tpostgres cmd_query");
return dmr;
}
/**
* Read user input.
*
* @param prompt Prompt
* @return The read line (dynamically allocated) or NULL
*/
char *
readline(const char *prompt)
{
char *out;
const int sleep_time_milliseconds = 90;
volatile struct readline_session_context *ctx;
wchar_t *buf_p = &g_push_back_buf[0];
ctx = new_session(prompt);
if (setjmp(g_readline_loc_info) != 0) {
session_destroy(ctx);
mutex_unlock(&g_puts_mutex);
return NULL;
}
g_readline_loop = true;
g_resize_requested = false;
g_hist_next = false;
g_hist_prev = false;
mutex_lock(&g_puts_mutex);
write_cmdprompt(ctx->act, ctx->prompt, ctx->prompt_size);
mutex_unlock(&g_puts_mutex);
do {
wint_t wc;
ctx->insert_mode = (ctx->bufpos != ctx->n_insert);
ctx->no_bufspc = (ctx->n_insert + 1 >= readline_buffersize);
if (*buf_p) {
wc = *buf_p++;
} else if (wget_wch(ctx->act, &wc) == ERR) {
(void) napms(sleep_time_milliseconds);
continue;
}
mutex_lock(&g_puts_mutex);
switch (wc) {
case CTRL_A:
while (ctx->bufpos != 0) {
case_key_left(ctx);
ctx->insert_mode = (ctx->bufpos != ctx->n_insert);
}
break;
case CTRL_E:
while (ctx->insert_mode) {
case_key_right(ctx);
ctx->insert_mode = (ctx->bufpos != ctx->n_insert);
}
break;
case MY_KEY_DLE:
window_select_prev();
break; /* CTRL+P */
case MY_KEY_SO:
window_select_next();
break; /* CTRL+N */
case KEY_DOWN:
g_hist_next = true;
session_destroy(ctx);
mutex_unlock(&g_puts_mutex);
return NULL;
case KEY_UP:
g_hist_prev = true;
session_destroy(ctx);
mutex_unlock(&g_puts_mutex);
return NULL;
case KEY_LEFT: case MY_KEY_STX:
case_key_left(ctx);
break;
case KEY_RIGHT: case MY_KEY_ACK:
case_key_right(ctx);
break;
case KEY_BACKSPACE: case MY_KEY_BS:
case_key_backspace(ctx);
break;
case KEY_F(5): case BLINK:
handle_key(ctx, btowc(BLINK));
break;
case KEY_F(6): case BOLD_ALIAS:
handle_key(ctx, btowc(BOLD));
break;
case KEY_F(7): case COLOR:
handle_key(ctx, btowc(COLOR));
break;
case KEY_F(8): case NORMAL:
handle_key(ctx, btowc(NORMAL));
break;
case KEY_F(9): case REVERSE:
handle_key(ctx, btowc(REVERSE));
break;
case KEY_F(10): case UNDERLINE:
handle_key(ctx, btowc(UNDERLINE));
break;
case KEY_F(11):
cmd_close("");
break;
case KEY_F(12):
window_close_all_priv_conv();
break;
case KEY_DC: case MY_KEY_EOT:
case_key_dc(ctx);
break;
case KEY_NPAGE:
window_scroll_down(g_active_window);
break;
case KEY_PPAGE:
window_scroll_up(g_active_window);
break;
case '\t':
break;
case '\n': case KEY_ENTER: case WINDOWS_KEY_ENTER:
g_readline_loop = false;
break;
case KEY_RESIZE:
case MY_KEY_RESIZE:
g_resize_requested = true;
/*FALLTHROUGH*/
case '\a':
session_destroy(ctx);
mutex_unlock(&g_puts_mutex);
return NULL;
default:
if (iswprint(wc)) {
handle_key(ctx, wc);
}
break;
}
mutex_unlock(&g_puts_mutex);
} while (g_readline_loop);
if (ctx->n_insert > 0) {
ctx->buffer[ctx->n_insert] = 0L;
} else {
session_destroy(ctx);
return NULL;
}
mutex_lock(&g_puts_mutex);
write_cmdprompt(ctx->act, "", 0);
mutex_unlock(&g_puts_mutex);
out = finalize_out_string(ctx->buffer);
session_destroy(ctx);
return out;
}
static void
svg_parse_element(const svg_state_t *s0, htsmsg_t *element,
int (*element_parser)(svg_state_t *s, htsmsg_t *element))
{
svg_state_t s = *s0;
// FT_Outline ol;
// FT_UInt points;
// FT_UInt contours;
int fill_color = 0xffffffff;
int stroke_color = 0xffffffff;
int stroke_width = 0;
htsmsg_t *a = htsmsg_get_map(element, "attrib");
if(a == NULL)
return;
const char *st = htsmsg_get_str(a, "style");
if(st != NULL) {
char *style, *tmp = NULL, *n, *attr;
n = style = strdup(st);
while((attr = strtok_r(n, ";", &tmp)) != NULL) {
char *value = strchr(attr, ':');
if(value != NULL) {
*value++ = 0;
while(*value < 33 && *value)
value++;
if(!strcmp(attr, "fill")) {
if(!strcmp(value, "none"))
fill_color = 0;
else {
fill_color = (fill_color & 0xff000000) | html_makecolor(value);
}
} else if(!strcmp(attr, "stroke")) {
if(!strcmp(value, "none"))
stroke_color = 0;
else {
stroke_color = (stroke_color & 0xff000000) | html_makecolor(value);
}
} else if(!strcmp(attr, "stroke-width")) {
stroke_width = atoi(value);
}
}
n = NULL;
}
free(style);
}
if(s.pm == NULL)
return;
const char *transform = htsmsg_get_str(a, "transform");
if(transform != NULL)
svg_parse_transform(&s, transform);
vec_emit_0(s.pm, VC_BEGIN);
if(fill_color) {
vec_emit_i1(s.pm, VC_SET_FILL_ENABLE, 1);
vec_emit_i1(s.pm, VC_SET_FILL_COLOR, fill_color);
}
if(stroke_width) {
vec_emit_i1(s.pm, VC_SET_STROKE_WIDTH, stroke_width);
vec_emit_i1(s.pm, VC_SET_STROKE_COLOR, stroke_color);
}
s.cur[0] = 0;
s.cur[1] = 0;
if(element_parser(&s, a))
return;
cmd_close(&s);
vec_emit_0(s.pm, VC_END);
}
void builder::node(string str, bool add_space) {
string::size_type n, m;
string s(str);
while (true) {
if (s.empty()) {
break;
} else if ((n = s.find("%{F-}")) == 0) {
color_close(!m_lazy);
s.erase(0, 5);
} else if ((n = s.find("%{F#")) == 0 && (m = s.find("}")) != string::npos) {
if (m - n - 4 == 2)
color_alpha(s.substr(n + 3, m - 3));
else
color(s.substr(n + 3, m - 3));
s.erase(n, m + 1);
} else if ((n = s.find("%{B-}")) == 0) {
background_close(!m_lazy);
s.erase(0, 5);
} else if ((n = s.find("%{B#")) == 0 && (m = s.find("}")) != string::npos) {
background(s.substr(n + 3, m - 3));
s.erase(n, m + 1);
} else if ((n = s.find("%{T-}")) == 0) {
font_close(!m_lazy);
s.erase(0, 5);
} else if ((n = s.find("%{T")) == 0 && (m = s.find("}")) != string::npos) {
font(std::atoi(s.substr(n + 3, m - 3).c_str()));
s.erase(n, m + 1);
} else if ((n = s.find("%{U-}")) == 0) {
line_color_close(!m_lazy);
s.erase(0, 5);
} else if ((n = s.find("%{U#")) == 0 && (m = s.find("}")) != string::npos) {
line_color(s.substr(n + 3, m - 3));
s.erase(n, m + 1);
} else if ((n = s.find("%{+u}")) == 0) {
underline();
s.erase(0, 5);
} else if ((n = s.find("%{+o}")) == 0) {
overline();
s.erase(0, 5);
} else if ((n = s.find("%{-u}")) == 0) {
underline_close(true);
s.erase(0, 5);
} else if ((n = s.find("%{-o}")) == 0) {
overline_close(true);
s.erase(0, 5);
} else if ((n = s.find("%{A}")) == 0) {
cmd_close(true);
s.erase(0, 4);
} else if ((n = s.find("%{")) == 0 && (m = s.find("}")) != string::npos) {
append(s.substr(n, m + 1));
s.erase(n, m + 1);
} else if ((n = s.find("%{")) > 0) {
append(s.substr(0, n));
s.erase(0, n);
} else
break;
}
if (!s.empty())
append(s);
if (add_space)
space();
}
