rt_public void wide_listen(void)
{
/* Listen on all the file descriptors opened for reading until the
* connected socket is broken.
*/
/* Make sure we listen on the connected socket and call the handling
* routine whenever data is available there.
*/
#ifdef EIF_WINDOWS
if (-1 == add_input(app_sp, (STREAM_FN) arqsthandle)) {
#else
if (-1 == add_input(app_sp, arqsthandle)) {
#endif
#ifdef USE_ADD_LOG
add_log(4, "add_input: %s (%s)", s_strerror(), s_strname());
#endif
dexit(1);
}
#ifdef USE_ADD_LOG
add_log(12, "in listen");
#endif
/* After having selected, we scan all our files to make sure none of them
* has been removed from the selection process. If at least one is missing,
* we are exiting immediately.
*/
#ifdef EIF_WINDOWS
while (0 <= do_select(0)) {
#ifdef USE_ADD_LOG
add_log(12, "in while do_select");
#endif
if (!has_input(app_sp)) { /* Socket connection broken? */
#ifdef USE_ADD_LOG
add_log(12, "in !has_input which is what we want");
#endif
return; /* Anyway, abort processing */
}
}
#ifdef USE_ADD_LOG
add_log(12, "out of listen");
#endif
#else
while (0 < do_select((struct timeval *) 0)) {
if (!has_input(app_sp)) /* Socket connection broken? */
return; /* Anyway, abort processing */
}
#endif
#ifdef USE_ADD_LOG
add_log(12, "do_select: %s (%s)", s_strerror(), s_strname());
#endif
}
void solve(Vector stack){
while(Vector_size(stack)){
struct Node *n;
Vector_pop(stack, &n);
if(n->type == Value){
add_input(stack, n->low, n->id);
}
else if(n->type == Bot){
add_input(stack, n->low, min(n->inputs[0], n->inputs[1]));
add_input(stack, n->high, max(n->inputs[0], n->inputs[1]));
}
}
}
void GLVertexDecompilerThread::insertMainStart(std::stringstream & OS)
{
insert_glsl_legacy_function(OS);
OS << "void main()" << std::endl;
OS << "{" << std::endl;
// Declare inside main function
for (const ParamType PT : m_parr.params[PF_PARAM_NONE])
{
for (const ParamItem &PI : PT.items)
{
OS << " " << PT.type << " " << PI.name;
if (!PI.value.empty())
OS << " = " << PI.value;
OS << ";" << std::endl;
}
}
for (const ParamType &PT : m_parr.params[PF_PARAM_IN])
{
for (const ParamItem &PI : PT.items)
add_input(OS, PI, rsx_vertex_program.rsx_vertex_inputs);
}
}
static int
passwd_input_cb(WINDOW *wnd, void *data, int key)
{
struct input *a = (struct input *) data;
char ipc_buf[IPC_MQSIZ+1];
memset(ipc_buf, '\0', IPC_MQSIZ+1);
switch (key) {
case UIKEY_ENTER:
ui_thrd_suspend();
memset(busy_str, '\0', BSTR_LEN+1);
ui_ipc_msgsend(MQ_PW, a->input);
clear_input(wnd, a);
deactivate_input(pw_input);
ui_thrd_resume();
ui_ipc_msgrecv(MQ_IF, ipc_buf, 3);
show_info_wnd(busywnd, "BUSY", ipc_buf, COLOR_PAIR(5), COLOR_PAIR(5), true, false);
sleep(3);
if (ui_ipc_getvalue(SEM_UI) > 0 &&
ui_ipc_msgrecv(MQ_IF, ipc_buf, 3) > 0)
{
show_info_wnd(errwnd, "ERROR", ipc_buf, COLOR_PAIR(4), COLOR_PAIR(4), true, true);
while (ui_wgetchtest(1500, '\n') != DOUI_KEY) { };
}
ui_thrd_suspend();
set_txtwindow_active(busywnd, false);
set_txtwindow_active(errwnd, false);
activate_input(pw_input);
ui_ipc_msgclear(MQ_IF);
ui_thrd_resume();
break;
case UIKEY_BACKSPACE:
del_input(wnd, a);
break;
case UIKEY_ESC:
ui_thrd_suspend();
clear_input(wnd, a);
deactivate_input(pw_input);
ui_thrd_resume();
show_info_wnd(errwnd, "QUIT", "bye bye", COLOR_PAIR(5), COLOR_PAIR(5), true, true);
sleep(2);
return DOUI_ERR;
case UIKEY_DOWN:
case UIKEY_UP:
case UIKEY_LEFT:
case UIKEY_RIGHT:
break;
case UIKEY_ACTIVATE:
break;
default:
ui_thrd_suspend();
add_input(wnd, a, key);
ui_thrd_resume();
}
return DOUI_OK;
}
/* Standard input is available.
*/
static void stdin_handler(struct file_info *fi, int events){
if (events & POLLIN) {
add_input(fi);
}
if (events & ~POLLIN) {
fprintf(stderr, "input_handler: unknown events %x\n", events);
}
}
gboolean timer(gpointer pointer)
{
if(waiting_for_timer == TRUE)
{
add_input();
waiting_for_timer = FALSE;
}
return FALSE;
}
Exit::Exit()
{
set_type("EXIT");
set_left(EXIT_LEFT);
set_bottom(EXIT_BOTTOM);
set_width(EXIT_WIDTH);
set_height(EXIT_HEIGHT);
add_input(CircuitObject());
close();
}
/// send a string or virtual key to the active window.
// @{input.lua} shows launching a process, waiting for it to be
// ready, and sending it some keys
// @param text either a key (like winapi.VK_SHIFT) or a string
// @return number of keys sent, or nil if an error
// @return any error string
// @function send_to_window
def send_to_window () {
const char *text;
int vkey, len = MAX_KEYS;
UINT res;
SHORT last_vk = 0;
INPUT *input, *pi;
if (lua_isnumber(L,1)) {
INPUT inp;
ZeroMemory(&inp,sizeof(INPUT));
vkey = lua_tointeger(L,1);
add_input(&inp,vkey,lua_toboolean(L,2));
SendInput(1,&inp,sizeof(INPUT));
return 0;
} else {
text = lua_tostring(L,1);
if (text == NULL) {
return push_error_msg(L,"not a string or number");
}
}
input = (INPUT *)malloc(sizeof(INPUT)*len);
pi = input;
ZeroMemory(input, sizeof(INPUT)*len);
for(; *text; ++text) {
SHORT vk = VkKeyScan(*text);
if (last_vk == vk) {
pi = add_input(pi,last_vk & 0xFF,TRUE);
}
if (vk & 0x100) pi = add_input(pi,VK_SHIFT,FALSE);
pi = add_input(pi,vk & 0xFF,FALSE);
if (vk & 0x100) pi = add_input(pi,VK_SHIFT,TRUE);
last_vk = vk;
}
res = SendInput(((DWORD_PTR)pi-(DWORD_PTR)input)/sizeof(INPUT), input, sizeof(INPUT));
free(input);
if (res > 0) {
lua_pushinteger(L,res);
return 1;
} else {
return push_error(L);
}
return 0;
}
void GLVertexDecompilerThread::insertMainStart(std::stringstream & OS)
{
insert_glsl_legacy_function(OS);
std::string parameters = "";
for (int i = 0; i < 16; ++i)
{
std::string reg_name = "dst_reg" + std::to_string(i);
if (m_parr.HasParam(PF_PARAM_NONE, "vec4", reg_name))
{
if (parameters.length())
parameters += ", ";
parameters += "inout vec4 " + reg_name;
}
}
OS << "void vs_main(" << parameters << ")" << std::endl;
OS << "{" << std::endl;
//Declare temporary registers, ignoring those mapped to outputs
for (const ParamType PT : m_parr.params[PF_PARAM_NONE])
{
for (const ParamItem &PI : PT.items)
{
if (PI.name.substr(0, 7) == "dst_reg")
continue;
OS << " " << PT.type << " " << PI.name;
if (!PI.value.empty())
OS << " = " << PI.value;
OS << ";" << std::endl;
}
}
for (const ParamType &PT : m_parr.params[PF_PARAM_IN])
{
for (const ParamItem &PI : PT.items)
add_input(OS, PI, rsx_vertex_program.rsx_vertex_inputs);
}
for (const ParamType &PT : m_parr.params[PF_PARAM_UNIFORM])
{
if (PT.type == "sampler2D")
{
for (const ParamItem &PI : PT.items)
{
OS << " vec2 " << PI.name << "_coord_scale = vec2(1.);" << std::endl;
}
}
}
}
Exit::Exit(const Exit& e)
{
set_type(e.type());
set_left(e.left());
set_bottom(e.bottom());
set_width(e.width());
set_height(e.height());
add_input(e.input());
if(e.is_open())
open();
else
close();
}
/*Moves a process from the future queue to the input queue*/
void future_to_input(MANAGER* mm, PROCESS* p) {
if (p->prev == NULL) {
mm->future_process = p->next;
if (p->next != NULL) {
p->next->prev = NULL;
}
} else {
p->prev->next = p->next;
if (p->next != NULL) {
p->next->prev = p->prev;
}
}
p->next = NULL;
p->prev = NULL;
add_input(mm, p);
}
int libcurses_add_input_by_name(t_screen *screen, char *input,
char *name)
{
t_panelist *it;
int all;
it = screen->panes;
all = ft_strequ(name, "all");
while (it != NULL)
{
if (it->pane && (all || ft_strequ(it->pane->name, name)))
{
if (add_input(it->pane, input) == LIBCURSES_NOK)
return (LIBCURSES_NOK);
}
it = it->next;
}
return (LIBCURSES_OK);
}
void RemoteReconfigSubjectImpl::swap(const char* addConfigurationString,
const char* removeConfigurationString)
throw(CORBA::SystemException)
{
jccl::Configuration add_elements, delete_elements;
std::string add_element_string(addConfigurationString);
std::string remove_element_string(removeConfigurationString);
//Loading from an istream
std::istringstream add_input(add_element_string);
std::istringstream remove_input(remove_element_string);
add_input >> add_elements;
remove_input >> delete_elements;
//Send pending changes to ConfigManager
jccl::ConfigManager::instance()->addConfigurationRemovals(&delete_elements);
jccl::ConfigManager::instance()->addConfigurationAdditions(&add_elements);
}
int libcurses_add_input_by_id(t_screen *screen, char *input, int id)
{
t_panelist *it;
int all;
it = screen->panes;
all = (id == -1);
while (it != NULL)
{
if (it->pane && (all || it->pane->id == id))
{
if (add_input(it->pane, input) == LIBCURSES_NOK)
return (LIBCURSES_NOK);
else if (!all)
return (LIBCURSES_OK);
}
it = it->next;
}
return (LIBCURSES_OK);
}
gboolean Lis_port(GIOChannel* src, GIOCondition cond, gpointer data)
{
gint bytes_read;
static gchar c[BUFFER_RECEPTION];
guint i;
bytes_read = BUFFER_RECEPTION;
while(bytes_read == BUFFER_RECEPTION)
{
bytes_read = read(serial_port_fd, c, BUFFER_RECEPTION);
if(bytes_read > 0)
{
put_chars(c, bytes_read, config.crlfauto);
if(config.car != -1 && waiting_for_char == TRUE)
{
i = 0;
while(i < bytes_read)
{
if(c[i] == config.car)
{
waiting_for_char = FALSE;
add_input();
i = bytes_read;
}
i++;
}
}
}
else if(bytes_read == -1)
{
if(errno != EAGAIN)
perror(config.port);
}
}
return TRUE;
}
/* Check if yytext is a macro and expand if it is. */
static int
expand_define(void)
{
struct defn *p;
char expbuf[DEFMAX];
char *args[NARGS];
char buf[DEFMAX];
char *q, *e, *b;
if (nexpands++ > EXPANDMAX)
{
lexerror("Too many macro expansions");
return 0;
}
p = lookup_define(yytext);
if (!p)
{
return 0;
}
if (p->nargs == -1)
{
add_input(p->exps);
}
else
{
int c, parcnt = 0, dquote = 0, squote = 0;
int n;
SKIPW;
if (c != '(')
{
lexerror("Missing '(' in macro call");
return 0;
}
SKIPW;
if (c == ')')
n = 0;
else
{
q = expbuf;
args[0] = q;
for (n = 0; n < NARGS; )
{
switch(c)
{
case '"':
if (!squote)
dquote ^= 1;
break;
case '\'':
if (!dquote)
squote ^= 1;
break;
case '(':
if (!squote && !dquote)
parcnt++;
break;
case ')':
if (!squote && !dquote)
parcnt--;
break;
case '\\':
if (squote || dquote)
{
*q++ = c;
c = mygetc();}
break;
case '\n':
if (squote || dquote)
{
lexerror("Newline in string");
return 0;
}
break;
}
if (c == ',' && !parcnt && !dquote && !squote)
{
*q++ = 0;
args[++n] = q;
}
else if (parcnt < 0)
{
*q++ = 0;
n++;
break;
}
else
{
if (c == EOF)
{
lexerror("Unexpected end of file");
return 0;
}
if (q >= expbuf + DEFMAX - 5)
{
lexerror("Macro argument overflow");
return 0;
}
else
{
*q++ = c;
}
}
if (!squote && ! dquote)
c = cmygetc();
else
c = mygetc();
}
if (n == NARGS)
{
lexerror("Maximum macro argument count exceeded");
return 0;
}
}
if (n != p->nargs)
{
lexerror("Wrong number of macro arguments");
return 0;
}
/* Do expansion */
b = buf;
e = p->exps;
while (*e)
{
if (*e == MARKS)
{
if (*++e == MARKS)
*b++ = *e++;
else
{
for (q = args[*e++ - MARKS - 1]; *q; )
{
*b++ = *q++;
if (b >= buf+DEFMAX)
{
lexerror("Macro expansion overflow");
return 0;
}
}
}
}
else
{
*b++ = *e++;
if (b >= buf+DEFMAX)
{
lexerror("Macro expansion overflow");
return 0;
}
}
}
*b++ = 0;
add_input(buf);
}
return 1;
}
static void handle_elif()
#endif
{
if (iftop) {
if (iftop->state == EXPECT_ELSE) {
/* last cond was false... */
int cond;
ifstate_t *p = iftop;
/* pop previous condition */
iftop = p->next;
FREE((char *) p);
#ifdef LEXER
*--outp = '\0';
add_input(sp);
#endif
cond = cond_get_exp(0);
#ifdef LEXER
if (*outp++) {
yyerror("Condition too complex in #elif");
while (*outp++);
#else
if (*outp != '\n') {
yyerror("Condition too complex in #elif");
#endif
} else handle_cond(cond);
} else {/* EXPECT_ENDIF */
/*
* last cond was true...skip to end of
* conditional
*/
skip_to("endif", (char *) 0);
}
} else {
yyerrorp("Unexpected %celif");
}
}
static void handle_else (void) {
if (iftop) {
if (iftop->state == EXPECT_ELSE) {
iftop->state = EXPECT_ENDIF;
} else {
skip_to("endif", (char *) 0);
}
} else {
yyerrorp("Unexpected %cendif");
}
}
static void handle_endif (void) {
if (iftop && (iftop->state == EXPECT_ENDIF ||
iftop->state == EXPECT_ELSE)) {
ifstate_t *p = iftop;
iftop = p->next;
FREE((char *) p);
} else {
yyerrorp("Unexpected %cendif");
}
}
#define BNOT 1
#define LNOT 2
#define UMINUS 3
#define UPLUS 4
#define MULT 1
#define DIV 2
#define MOD 3
#define BPLUS 4
#define BMINUS 5
#define LSHIFT 6
#define RSHIFT 7
#define LESS 8
#define LEQ 9
#define GREAT 10
#define GEQ 11
#define EQ 12
#define NEQ 13
#define BAND 14
#define XOR 15
#define BOR 16
#define LAND 17
#define LOR 18
#define QMARK 19
static char _optab[] =
{0, 4, 0, 0, 0, 26, 56, 0, 0, 0, 18, 14, 0, 10, 0, 22, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 30, 50, 40, 74,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 70, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 63, 0, 1};
static char optab2[] =
{BNOT, 0, 0, LNOT, '=', NEQ, 7, 0, 0, UMINUS, 0, BMINUS, 10, UPLUS, 0, BPLUS, 10,
0, 0, MULT, 11, 0, 0, DIV, 11, 0, 0, MOD, 11,
0, '<', LSHIFT, 9, '=', LEQ, 8, 0, LESS, 8, 0, '>', RSHIFT, 9, '=', GEQ, 8, 0, GREAT, 8,
0, '=', EQ, 7, 0, 0, 0, '&', LAND, 3, 0, BAND, 6, 0, '|', LOR, 2, 0, BOR, 4,
0, 0, XOR, 5, 0, 0, QMARK, 1};
#define optab1 (_optab-' ')
static int cond_get_exp (int priority)
{
int c;
int value, value2, x;
#ifdef LEXER
do
c = exgetc();
while (is_wspace(c));
if (c == '(') {
#else
if ((c = exgetc()) == '(') {
#endif
value = cond_get_exp(0);
#ifdef LEXER
do
c = exgetc();
while (is_wspace(c));
if (c != ')') {
yyerror("bracket not paired in #if");
if (!c) *--outp = '\0';
}
#else
if ((c = exgetc()) != ')') yyerrorp("bracket not paired in %cif");
#endif
} else if (ispunct(c)) {
if (!(x = optab1[c])) {
yyerrorp("illegal character in %cif");
return 0;
}
value = cond_get_exp(12);
switch (optab2[x - 1]) {
case BNOT:
value = ~value;
break;
case LNOT:
value = !value;
break;
case UMINUS:
value = -value;
break;
case UPLUS:
value = value;
break;
default:
yyerrorp("illegal unary operator in %cif");
}
} else {
int base;
if (!isdigit(c)) {
#ifdef LEXER
if (!c) {
#else
if (c == '\n') {
#endif
yyerrorp("missing expression in %cif");
} else
yyerrorp("illegal character in %cif");
return 0;
}
value = 0;
if (c != '0')
base = 10;
else {
c = *outp++;
if (c == 'x' || c == 'X') {
base = 16;
c = *outp++;
} else
base = 8;
}
for (;;) {
if (isdigit(c))
x = -'0';
else if (isupper(c))
x = -'A' + 10;
else if (islower(c))
x = -'a' + 10;
else
break;
x += c;
if (x > base)
break;
value = value * base + x;
c = *outp++;
}
outp--;
}
for (;;) {
#ifdef LEXER
do
c = exgetc();
while (is_wspace(c));
if (!ispunct(c))
break;
#else
if (!ispunct(c = exgetc()))
break;
#endif
if (!(x = optab1[c]))
break;
value2 = *outp++;
for (;; x += 3) {
if (!optab2[x]) {
outp--;
if (!optab2[x + 1]) {
yyerrorp("illegal operator use in %cif");
return 0;
}
break;
}
if (value2 == optab2[x])
break;
}
if (priority >= optab2[x + 2]) {
if (optab2[x]) *--outp = value2;
break;
}
value2 = cond_get_exp(optab2[x + 2]);
switch (optab2[x + 1]) {
case MULT:
value *= value2;
break;
case DIV:
if (value2)
value /= value2;
else
yyerrorp("division by 0 in %cif");
break;
case MOD:
if (value2)
value %= value2;
else
yyerrorp("modulo by 0 in %cif");
break;
case BPLUS:
value += value2;
break;
case BMINUS:
value -= value2;
break;
case LSHIFT:
value <<= value2;
break;
case RSHIFT:
value >>= value2;
break;
case LESS:
value = value < value2;
break;
case LEQ:
value = value <= value2;
break;
case GREAT:
value = value > value2;
break;
case GEQ:
value = value >= value2;
break;
case EQ:
value = value == value2;
break;
case NEQ:
value = value != value2;
break;
case BAND:
value &= value2;
break;
case XOR:
value ^= value2;
break;
case BOR:
value |= value2;
break;
case LAND:
value = value && value2;
break;
case LOR:
value = value || value2;
break;
case QMARK:
#ifdef LEXER
do
c = exgetc();
while (isspace(c));
if (c != ':') {
yyerror("'?' without ':' in #if");
outp--;
return 0;
}
#else
if ((c = exgetc()) != ':') yyerrorp("'?' without ':' in %cif");
#endif
if (value) {
cond_get_exp(1);
value = value2;
} else
value = cond_get_exp(1);
break;
}
}
outp--;
return value;
}
static void
handle_cond (int c)
{
ifstate_t *p;
if (!c)
skip_to("else", "endif");
p = ALLOCATE(ifstate_t, TAG_COMPILER, "handle_cond");
p->next = iftop;
iftop = p;
p->state = c ? EXPECT_ENDIF : EXPECT_ELSE;
}
void markov_add_input_from_stream(MarkovData* data, FILE* input) {
add_input(data, get_word_from_stream, input);
}
void send_raw_file(GtkAction *action, gpointer data)
{
GtkWidget *file_select;
file_select = gtk_file_chooser_dialog_new(_("Send RAW File"),
GTK_WINDOW(Fenetre),
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
NULL);
if(fic_defaut != NULL)
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(file_select), fic_defaut);
if(gtk_dialog_run(GTK_DIALOG(file_select)) == GTK_RESPONSE_ACCEPT)
{
gchar *fileName;
gchar *msg;
fileName = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(file_select));
if(!g_file_test(fileName, G_FILE_TEST_IS_REGULAR))
{
msg = g_strdup_printf(_("Error opening file\n"));
show_message(msg, MSG_ERR);
g_free(msg);
g_free(fileName);
gtk_widget_destroy(file_select);
return;
}
Fichier = open(fileName, O_RDONLY);
if(Fichier != -1)
{
GtkWidget *Bouton_annuler, *Box;
fic_defaut = g_strdup(fileName);
msg = g_strdup_printf(_("%s : transfer in progress..."), fileName);
gtk_statusbar_push(GTK_STATUSBAR(StatusBar), id, msg);
car_written = 0;
current_buffer_position = 0;
bytes_read = 0;
nb_car = lseek(Fichier, 0L, SEEK_END);
lseek(Fichier, 0L, SEEK_SET);
Window = gtk_dialog_new();
gtk_window_set_title(GTK_WINDOW(Window), msg);
g_free(msg);
Box = gtk_vbox_new(TRUE, 10);
gtk_container_add(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(Window))), Box);
ProgressBar = gtk_progress_bar_new();
gtk_box_pack_start(GTK_BOX(Box), ProgressBar, FALSE, FALSE, 5);
Bouton_annuler = gtk_button_new_with_label(_("Cancel"));
g_signal_connect(GTK_OBJECT(Bouton_annuler), "clicked", G_CALLBACK(close_all), NULL);
gtk_container_add(GTK_CONTAINER(gtk_dialog_get_action_area(GTK_DIALOG(Window))), Bouton_annuler);
g_signal_connect(GTK_OBJECT(Window), "delete_event", G_CALLBACK(close_all), NULL);
gtk_window_set_default_size(GTK_WINDOW(Window), 250, 100);
gtk_window_set_modal(GTK_WINDOW(Window), TRUE);
gtk_widget_show_all(Window);
add_input();
}
else
{
msg = g_strdup_printf(_("Cannot read file %s: %s\n"), fileName, strerror(errno));
show_message(msg, MSG_ERR);
g_free(msg);
}
g_free(fileName);
}
gtk_widget_destroy(file_select);
}
/* Activity on a socket: input, output, or error...
*/
static void message_handler(struct file_info *fi, int events){
printf("Message handler called\n");
char buf[512];
if (events & (POLLERR | POLLHUP)) {
double time;
int error;
socklen_t len = sizeof(error);
if (getsockopt(fi->fd, SOL_SOCKET, SO_ERROR, &error, &len) < 0) {
perror("getsockopt");
}
switch (error) {
case 0:
printf("Lost connection on socket %d\n", fi->fd);
time = timer_now() + 1;
break;
default:
printf("Error '%s' on socket %d\n", strerror(error), fi->fd);
time = timer_now() + 5;
}
close(fi->fd);
/* Start a timer to reconnect.
*/
if (fi->type == FI_OUTGOING) {
timer_start(time, timer_reconnect, fi->uid);
fi->fd = -1;
fi->u.fi_outgoing.status = FI_CONNECTING;
}
else {
fi->type = FI_FREE;
}
char *my_addr_str = addr_to_string(my_addr);
char *fi_addr_str = addr_to_string(fi->addr);
set_dist(nl, graph, nl_nsites(nl), fi_addr_str, my_addr_str, 0);
updateGraph();
send_gossip();
free (my_addr_str);
free (fi_addr_str);
return;
}
if (events & POLLOUT) {
int n = send(fi->fd, fi->output_buffer, fi->amount_to_send, 0);
if (n < 0) {
perror("send");
}
if (n > 0) {
if (n == fi->amount_to_send) {
fi->amount_to_send = 0;
}
else {
memmove(&fi->output_buffer[n], fi->output_buffer, fi->amount_to_send - n);
fi->amount_to_send -= n;
}
}
}
if (events & POLLIN) {
add_input(fi);
}
if (events & ~(POLLIN|POLLOUT|POLLERR|POLLHUP)) {
printf("message_handler: unknown events\n");
fi->events = 0;
}
}
static int
yylex1(void)
{
register char *yyp;
register int c;
register int c1, c2;
for (;;)
{
if (lex_fatal)
{
return -1;
}
switch(c = mygetc())
{
case EOF:
if (inctop)
{
struct incstate *p;
p = inctop;
(void)fclose(yyin);
/*(void)fprintf(stderr, "popping to %s\n", p->file);*/
free(current_file);
nexpands = 0;
current_file = p->file;
current_line = p->line + 1;
current_incfile = p->incfnum;
pragma_strict_types = p->pragma_strict_types;
yyin = p->yyin;
slast = p->slast;
lastchar = p->lastchar;
inctop = p->next;
if (p->nbuf)
{
nbuf = p->nbuf;
outp = defbuf + DEFMAX - nbuf;
memcpy(outp, p->outp, nbuf);
free((char *)p->outp);
}
else
{
nbuf = 0;
outp = defbuf + DEFMAX;
}
store_line_number_info(current_incfile, current_line);
incdepth--;
free((char *)p);
break;
}
if (iftop)
{
struct ifstate *p = iftop;
lexerror(p->state == EXPECT_ENDIF ? "Missing #endif" : "Missing #else");
while (iftop)
{
p = iftop;
iftop = p->next;
free((char *)p);
}
}
return -1;
case '\n':
{
nexpands=0;
store_line_number_info(current_incfile, current_line);
current_line++;
total_lines++;
}
/* FALLTHROUGH */
case ' ':
case '\t':
case '\f':
case '\v':
break;
case '+':
TRY('+', F_INC);
TRY('=', F_ADD_EQ);
return c;
case '-':
TRY('>', F_ARROW);
TRY('-', F_DEC);
TRY('=', F_SUB_EQ);
return c;
case '&':
TRY('&', F_LAND);
TRY('=', F_AND_EQ);
return c;
case '|':
TRY('|', F_LOR);
TRY('=', F_OR_EQ);
return c;
case '^':
TRY('=', F_XOR_EQ);
return c;
case '<':
if (gobble('<')) {
TRY('=', F_LSH_EQ);
return F_LSH;
}
TRY('=', F_LE);
return c;
case '>':
if (gobble('>'))
{
TRY('=', F_RSH_EQ);
return F_RSH;
}
TRY('=', F_GE);
return c;
case '*':
TRY('=', F_MULT_EQ);
return c;
case '%':
TRY('=', F_MOD_EQ);
return F_MOD;
case '/':
if (gobble('*'))
{
skip_comment();
break;
}
else if (gobble('/'))
{
skip_comment2();
break;
}
TRY('=', F_DIV_EQ);
return c;
case '=':
TRY('=', F_EQ);
return c;
case ';':
case '(':
case ')':
case ',':
case '{':
case '}':
case '~':
case '[':
case ']':
case '?':
case '@':
return c;
case '!':
TRY('=', F_NE);
return F_NOT;
case ':':
TRY(':', F_COLON_COLON);
return ':';
case '.':
if (gobble('.'))
{
if (gobble('.'))
return F_VARARG;
else
return F_RANGE;
}
return c;
case '#':
if (lastchar == '\n')
{
char *ssp = 0;
int quote;
yyp = yytext;
do
{
c = mygetc();
} while (isspace(c));
for (quote = 0;;)
{
if (c == '"')
quote ^= 1;
/*gc - handle comments cpp-like! 1.6.91 @@@*/
while (!quote && c == '/')
{
if (gobble('*'))
{
skip_comment();
c = mygetc();
}
else
break;
}
if (!ssp && isspace(c))
ssp = yyp;
if (c == '\n' || c == EOF)
break;
SAVEC;
c = mygetc();
}
if (ssp)
{
*ssp++ = 0;
while (isspace(*ssp))
ssp++;
}
else
{
ssp = yyp;
}
*yyp = 0;
if (strcmp("define", yytext) == 0)
{
handle_define(ssp);
}
else if (strcmp("if", yytext) == 0)
{
#if 0
short int nega=0; /*@@@ allow #if !VAR gc 1.6.91*/
if (*ssp=='!'){ ssp++; nega=1;}
if (isdigit(*ssp))
{
char *p;
long l;
l = strtol(ssp, &p, 10);
while (isspace(*p))
p++;
if (*p)
lexerror("Condition too complex in #if");
else
handle_cond(nega ? !(int)l : (int)l);
}
else if (isalunum(*ssp))
{
char *p = ssp;
while (isalunum(*p))
p++;
if (*p)
{
*p++ = 0;
while (isspace(*p))
p++;
}
if (*p)
lexerror("Condition too complex in #if");
else
{
struct defn *d;
d = lookup_define(ssp);
if (d)
{
handle_cond(nega ? !atoi(d->exps) : atoi(d->exps));/* a hack! */
}
else
{
handle_cond(nega?1:0); /* cpp-like gc*/
}
}
}
else
lexerror("Condition too complex in #if");
#else
int cond;
myungetc(0);
add_input(ssp);
cond = cond_get_exp(0);
if (mygetc())
{
lexerror("Condition too complex in #if");
while (mygetc())
;
}
else
handle_cond(cond);
#endif
}
else if (strcmp("ifdef", yytext) == 0)
{
deltrail(ssp);
handle_cond(lookup_define(ssp) != 0);
}
else if (strcmp("ifndef", yytext) == 0)
{
deltrail(ssp);
handle_cond(lookup_define(ssp) == 0);
}
else if (strcmp("else", yytext) == 0)
{
if (iftop && iftop->state == EXPECT_ELSE)
{
struct ifstate *p = iftop;
/*(void)fprintf(stderr, "found else\n");*/
iftop = p->next;
free((char *)p);
(void)skip_to("endif", (char *)0);
store_line_number_info(current_incfile, current_line);
current_line++;
total_lines++;
}
else
{
lexerror("Unexpected #else");
}
}
else if (strcmp("endif", yytext) == 0)
{
if (iftop && (iftop->state == EXPECT_ENDIF ||
iftop->state == EXPECT_ELSE))
{
struct ifstate *p = iftop;
/*(void)fprintf(stderr, "found endif\n");*/
iftop = p->next;
free((char *)p);
}
else
{
lexerror("Unexpected #endif");
}
}
else if (strcmp("undef", yytext) == 0)
{
struct defn *d;
deltrail(ssp);
if ((d = lookup_define(ssp)) != NULL )
d->undef++;
}
else if (strcmp("echo", yytext) == 0)
{
(void)fprintf(stderr, "%s\n", ssp);
}
else if (strcmp("include", yytext) == 0)
{
/*(void)fprintf(stderr, "including %s\n", ssp); */
handle_include(ssp, 0);
}
else if (strcmp("pragma", yytext) == 0)
{
deltrail(ssp);
handle_pragma(ssp);
}
else if (strcmp("error", yytext) == 0)
{
handle_exception(ERROR, ssp);
}
else if (strcmp("warning", yytext) == 0)
{
handle_exception(WARNING, ssp);
}
else
{
lexerror("Unrecognised # directive");
}
myungetc('\n');
break;
}
else
goto badlex;
case '\'':
yylval.number = mygetc();
if (yylval.number == '\\')
{
int tmp = mygetc();
switch (tmp)
{
case 'n': yylval.number = '\n'; break;
case 't': yylval.number = '\t'; break;
case 'b': yylval.number = '\b'; break;
case 'a': yylval.number = '\a'; break;
case 'v': yylval.number = '\v'; break;
case '\'':
case '\\':
case '"':
yylval.number = tmp; break;
default:
lexwarning("Bad character escape sequence");
yylval.number = tmp;
break;
}
}
if (!gobble('\''))
lexerror("Illegal character constant");
return F_NUMBER;
case '"':
yyp = yytext;
*yyp++ = c;
for (;;)
{
c = mygetc();
if (c == EOF)
{
lexerror("End of file in string");
return string("\"\"");
}
else if (c == '\n')
{
lexerror("Newline in string");
return string("\"\"");
}
SAVEC;
if (c == '"')
break;
if (c == '\\')
{
c = mygetc();
if ( c == '\n' )
{
yyp--;
store_line_number_info(current_incfile, current_line);
current_line++;
total_lines++;
}
else if ( c == EOF )
{
/* some operating systems give EOF only once */
myungetc(c);
}
else
*yyp++ = c;
}
}
*yyp = 0;
return string(yytext);
case '0':
c = mygetc();
if ( c == 'X' || c == 'x' || c == 'o')
{
char *endptr;
long long value;
int base = 16;
if (c == 'o')
base = 8;
yyp = yytext;
for (;;)
{
c = mygetc();
if (!isxdigit(c))
break;
SAVEC;
}
myungetc(c);
*yyp = '\0';
value = strtoll(yytext, &endptr, base);
if (*endptr != '\0')
{
fprintf(stderr, "%s\n", yytext);
lexwarning("Invalid digits in octal number number");
}
return number(value);
}
myungetc(c);
c = '0';
/* FALLTHROUGH */
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
yyp = yytext;
*yyp++ = c;
for (;;)
{
c = mygetc();
if (!isdigit(c))
break;
SAVEC;
}
if (c == '.')
{
if (isdigit(c1 = mygetc()))
{
SAVEC;
c = c1;
SAVEC;
for (c = mygetc(); isdigit(c); c = mygetc())
SAVEC;
if (c == 'e' || c == 'E')
{
c1 = mygetc();
if (c1 == '-' || c1 == '+')
{
c2 = mygetc();
if (isdigit(c2))
{
SAVEC;
c = c1;
SAVEC;
c = c2;
SAVEC;
for (c = mygetc(); isdigit(c); c = mygetc())
SAVEC;
}
else
{
myungetc(c2);
myungetc(c1);
}
}
else if (isdigit(c1))
{
SAVEC;
c = c1;
SAVEC;
for (c = mygetc(); isdigit(c); c = mygetc())
SAVEC;
}
else
myungetc(c1);
}
myungetc(c);
*yyp = 0;
return real(strtod(yytext, NULL));
}
myungetc(c1);
}
myungetc(c);
*yyp = 0;
if (*yytext == '0')
{
/* OCTALS */
char *endptr;
long long value;
value = strtoll(yytext, &endptr, 010);
if (*endptr != '\0')
lexwarning("Invalid digits in octal number");
if (value != 0)
lexwarning("Obsolete octal format used. Use 0o111 syntax");
return number(value);
}
return number(atoll(yytext));
default:
if (isalpha(c) || c == '_') {
int r;
yyp = yytext;
*yyp++ = c;
for (;;)
{
c = mygetc();
if (!isalunum(c))
break;
SAVEC;
}
*yyp = 0;
myungetc(c);
if (!expand_define())
{
r = lookup_resword(yytext);
if (r >= 0)
{
return r;
}
else
return ident(yytext);
}
break;
}
goto badlex;
}
}
badlex:
{
lexerror("Illegal character (hex %02x) '%c'", c, c);
return ' ';
}
}
rt_public int add_input(EIF_PSTREAM sp, STREAM_FN call)
/* `sp': Stream on which select must be done */
/* `call': Function to be called when input is available */
{
/* Add an input condition on file descriptor 'fd', with associated call
* back procedure and update internal informations.
* The function returns 0 if ok, -1 otherwise (call back pointer void or
* file descriptor invalid) and sets 's_errno'
*/
#ifdef EIF_WINDOWS
if (nfds >= NOFILE) { /* File descriptor out of range */
#else
int fd = readfd(sp);
if (fd < 0 || fd >= NOFILE) { /* File descriptor out of range */
#endif
s_errno = S_FDESC; /* Invalid file descriptor */
return -1;
}
if (call == NULL) { /* Null pointer for callback */
s_errno = S_CALBAK; /* Invalid callback pointer */
return -1;
}
#ifdef EIF_WINDOWS
if (callback(sp) != NULL) { /* Callback already set */
#else
if (callback[fd] != NULL) { /* Callback already set */
#endif
s_errno = S_CALSET; /* Cannot override old callback */
return -1;
}
#ifdef EIF_WINDOWS
set_callback(sp, call); /* Record callback */
set_multiple_mask(sp, rd_mask); /* Select will monitor this fd */
set_multiple_mask(sp, rd_tmask); /* Also set temporary mask */
#else
if ((fd + 1) > nfds) { /* Keep number of fd up-to-date */
nfds = fd + 1; /* Fd start at 0 */
}
callback[fd] = call; /* Record callback */
FD_SET(fd, &rd_mask); /* Select will monitor this fd */
FD_SET(fd, &rd_tmask); /* Also set temporary mask */
#endif
return 0; /* Ok status */
}
rt_public STREAM_FN new_callback(EIF_PSTREAM sp, STREAM_FN call)
/* `sp': STREAM on which select must be done */
/* `call': New function to be called when input is available */
{
/* Change the call back associated with the file descriptor and return the
* old call back. If no input was associated with that file descriptor,
* it is an error and a null pointer is returned.
*/
STREAM_FN old_call; /* The old call back set for that fd */
#ifdef EIF_WINDOWS
if (call == NULL) { /* Null pointer for callback */
s_errno = S_CALBAK; /* Invalid callback pointer */
return NULL;
}
old_call = callback(sp); /* Previously stored callback address */
set_callback(sp, NULL); /* Otherwise add_input() will fail */
if (-1 == add_input(sp, call)) { /* Failed, restore old status */
set_callback(sp,old_call); /* Reset old callback value */
return NULL; /* No change occurred */
}
#else
int fd = readfd(sp);
if (fd < 0 || fd >= NOFILE) { /* File descriptor out of range */
s_errno = S_FDESC; /* Invalid file descriptor */
return NULL;
}
if (call == NULL) { /* Null pointer for callback */
s_errno = S_CALBAK; /* Invalid callback pointer */
return NULL;
}
old_call = callback[fd]; /* Previously stored callback address */
callback[fd] = NULL; /* Otherwise add_input() will fail */
if (-1 == add_input(sp, call)) { /* Failed, restore old status */
callback[fd] = old_call; /* Reset old callback value */
return NULL; /* No change occurred */
}
#endif
return old_call; /* Success: return old value (cannot be null) */
}
int main(int argc, char *argv[]) {
char query[100];
const char *name, *sub;
int i, id, ts, inputid, maxid = 0;
double value;
input_t *input;
sqlite3_stmt *stmt;
if (argc > 1) read_config(argv[1]);
else read_config(NULL);
if (!settings.sqlitefile) {
fprintf(stderr, "No sqlite database defined in %s", argc>1?argv[1]:CONFIG_FILE);
return EXIT_FAILURE;
}
if (sqlite3_open(settings.sqlitefile, &settings.sqlitehandle) != SQLITE_OK) {
fprintf(stderr, "Failed to open sqlite database '%s': %s\n", settings.sqlitefile, sqlite3_errmsg(settings.sqlitehandle));
return EXIT_FAILURE;
}
sqlite3_prepare_v2(settings.sqlitehandle, "SELECT `id`, `name`, `sub` FROM inputs", 40, &stmt, NULL);
if (!stmt) {
fprintf(stderr, "Failed to prepare query for inputs on SQLite db: %s\n", sqlite3_errmsg(settings.sqlitehandle));
return EXIT_FAILURE;
}
while ((i = sqlite3_step(stmt)) == SQLITE_ROW) {
if (sqlite3_column_count(stmt) != 3) break;
id = sqlite3_column_int(stmt, 0);
name = sqlite3_column_text(stmt, 1);
sub = sqlite3_column_text(stmt, 2);
for (input = inputs; input; input = input->next) {
if (!strcmp(input->name, name)) {
if (sub) input = add_input((char *)sub, input);
input->sqlid = id;
}
}
}
if (i != SQLITE_DONE) {
fprintf(stderr, "Error while reading inputs from SQLite db: %s\n", sqlite3_errmsg(settings.sqlitehandle));
return EXIT_FAILURE;
}
snprintf(query, 100, "SELECT rowid, ts, value FROM data WHERE input = ? ORDER BY ts DESC LIMIT %d", block_width()-9);
signal(SIGWINCH, do_winch);
ioctl(0, TIOCGWINSZ, &settings.ws);
go_ncurses();
for (input = inputs; input; input = input->next) {
if (!input->sqlid) continue;
sqlite3_prepare_v2(settings.sqlitehandle, query, -1, &stmt, NULL);
if (!stmt) {
fprintf(stderr, "Failed to prepare query for latest data: %s\n", sqlite3_errmsg(settings.sqlitehandle));
return EXIT_FAILURE;
}
if (sqlite3_bind_int(stmt, 1, input->sqlid) != SQLITE_OK) {
fprintf(stderr, "Failed to bind param 1 on initial data query: %s\n", sqlite3_errmsg(settings.sqlitehandle));
return EXIT_FAILURE;
}
while ((i = sqlite3_step(stmt)) == SQLITE_ROW) {
if (sqlite3_column_count(stmt) != 3) break;
id = sqlite3_column_int(stmt, 0);
ts = sqlite3_column_int(stmt, 1);
value = sqlite3_column_double(stmt, 2);
if (id > maxid) maxid = id;
if (input->vallast-input->valhist == VALUE_HIST_SIZE-1) input->vallast = input->valhist;
else input->vallast++;
input->valcnt++;
if (input->update < ts) input->update = ts;
*input->vallast = value;
}
sqlite3_finalize(stmt);
if (i != SQLITE_DONE) fprintf(stderr, "Error while reading initial data from SQLite db: %s\n", sqlite3_errmsg(settings.sqlitehandle));
update_block(input);
}
while (1) {
if (settings.winch) {
ioctl(0, TIOCGWINSZ, &settings.ws);
refresh();
resizeterm(settings.ws.ws_row, settings.ws.ws_col);
arrange_blocks();
settings.winch = 0;
}
sqlite3_prepare_v2(settings.sqlitehandle, "SELECT rowid, input, ts, value FROM data WHERE rowid > ? ORDER BY ts", 69, &stmt, NULL);
if (!stmt) {
fprintf(stderr, "Failed to prepare query for latest data on SQLite db: %s\n", sqlite3_errmsg(settings.sqlitehandle));
return EXIT_FAILURE;
}
if (sqlite3_bind_int(stmt, 1, maxid) != SQLITE_OK) {
fprintf(stderr, "Error binding param 1 for latest data query: %s\n", sqlite3_errmsg(settings.sqlitehandle));
return EXIT_FAILURE;
}
while ((i = sqlite3_step(stmt)) == SQLITE_ROW) {
if (sqlite3_column_count(stmt) != 4) break;
id = sqlite3_column_int(stmt, 0);
inputid = sqlite3_column_int(stmt, 1);
ts = sqlite3_column_int(stmt, 2);
value = sqlite3_column_double(stmt, 3);
if (id > maxid) maxid = id;
for (input = inputs; input; input = input->next) {
if (inputid == input->sqlid) {
if (input->vallast-input->valhist == VALUE_HIST_SIZE-1) input->vallast = input->valhist;
else input->vallast++;
input->valcnt++;
input->update = ts;
*input->vallast = value;
update_block(input);
}
}
}
sqlite3_finalize(stmt);
if (i != SQLITE_DONE) fprintf(stderr, "Error while reading data from SQLite db: %s\n", sqlite3_errmsg(settings.sqlitehandle));
check_updates();
sleep(60);
}
}
static bool
read_config(const char *file_path, Context *ctx)
{
Variable *last_var = NULL;
GList *itr;
FILE *f;
char line[LINE_SIZE];
char name[NAME_SIZE];
int tmp;
// default values
ctx->read_freq = READ_FREQ;
ctx->days = DAYS;
ctx->time_blocks = TIME_BLOCKS;
ctx->read_counter = 0;
ctx->enable_time_input = 1;
ctx->enable_weekday_input = 1;
ctx->inputs = NULL;
ctx->outputs = NULL;
ctx->expectations = NULL;
ctx->expectation_blocks = NULL;
ctx->time = NULL;
ctx->weekday = NULL;
f = fopen(file_path, "r");
if (!f) {
fprintf(stderr, "Failed to open %s\n", file_path);
return false;
}
while (fgets(line, LINE_SIZE, f)) {
float min = 0, max = 0;
int ret;
// empty or comment line
if ((line[0] == '\n') || (line[0] == '#'))
continue;
ret = sscanf(line, "TIME_BLOCKS %d\n", &ctx->time_blocks);
if (ret > 0) {
last_var = NULL;
continue;
}
ret = sscanf(line, "DAYS %d\n", &ctx->days);
if (ret > 0) {
last_var = NULL;
continue;
}
ret = sscanf(line, "READ_FREQ %d\n", &ctx->read_freq);
if (ret > 0) {
last_var = NULL;
continue;
}
ret = sscanf(line, "ENABLE_TIME_INPUT %d\n",
&tmp);
if (ret > 0) {
ctx->enable_time_input = !!tmp;
last_var = NULL;
continue;
}
ret = sscanf(line, "ENABLE_WEEKDAY_INPUT %d\n",
&tmp);
if (ret > 0) {
ctx->enable_weekday_input = !!tmp;
last_var = NULL;
continue;
}
ret = sscanf(line, "INPUT " STR_FMT(NAME_SIZE) " %f %f\n",
name, &min, &max);
if (ret > 0) {
last_var = add_input(ctx, name, min, max);
continue;
}
ret = sscanf(line, "OUTPUT " STR_FMT(NAME_SIZE) " %f %f\n",
name, &min, &max);
if (ret > 0) {
last_var = add_output(ctx, name, min, max);
add_expectation(ctx, last_var, name);
continue;
}
ret = sscanf(line, "TERM " STR_FMT(NAME_SIZE) " %f %f\n",
name, &min, &max);
if (ret > 0) {
if (!last_var) {
fprintf(stderr, "Failed to find var for term %s\n", line);
goto error;
}
add_term(ctx, last_var, name, min, max);
continue;
}
fprintf(stderr, "Unknow configuration %s\n", line);
goto error;
}
ctx->reads = 24 * 60 / ctx->read_freq * ctx->days;
for (itr = ctx->inputs; itr; itr = itr->next) {
Variable *var = itr->data;
if (!var->terms)
variable_add_terms(ctx, var);
}
for (itr = ctx->outputs; itr; itr = itr->next) {
Variable *var = itr->data;
if (!var->terms)
variable_add_terms(ctx, var);
}
fclose(f);
return true;
error:
fclose(f);
return false;
}
/* Stuff to evaluate expression. I havn't really checked it. /LA
** Written by "J\"orn Rennecke" <*****@*****.**>
*/
static int
exgetc(void)
{
register char c, *yyp;
c = mygetc();
while (isalpha(c) || c == '_')
{
yyp = yytext;
do
{
SAVEC;
c = mygetc();
} while (isalunum(c));
myungetc(c);
*yyp = '\0';
if (strcmp(yytext, "defined") == 0)
{
/* handle the defined "function" in #if */
do
c = mygetc();
while (isspace(c));
if (c != '(')
{
lexerror("Missing ( in defined");
continue;
}
do
c = mygetc();
while (isspace(c));
yyp = yytext;
while (isalunum(c))
{
SAVEC;
c = mygetc();
}
*yyp = '\0';
while (isspace(c))
c = mygetc();
if (c != ')')
{
lexerror("Missing ) in defined");
continue;
}
/* Skip whitespace */
do
c = mygetc();
while (isspace(c));
myungetc(c);
if (lookup_define(yytext))
add_input(" 1 ");
else
add_input(" 0 ");
}
else
{
if (!expand_define()) add_input(" 0 ");
}
c = mygetc();
}
return c;
}