main.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include "duktape.h"

Go to the source code of this file.

Functions
void	poll_register (duk_context *ctx)
void	ncurses_register (duk_context *ctx)
void	socket_register (duk_context *ctx)
void	fileio_register (duk_context *ctx)
void	eventloop_register (duk_context *ctx)
int	eventloop_run (duk_context *ctx)
static void	my_sighandler (int x)
static void	set_sigint_handler (void)
static void	print_error (duk_context *ctx, FILE *f)
int	wrapped_compile_execute (duk_context *ctx)
int	handle_fh (duk_context *ctx, FILE *f, const char *filename)
int	handle_file (duk_context *ctx, const char *filename)
int	handle_stdin (duk_context *ctx)
int	main (int argc, char *argv[])

Variables
static int	c_evloop = 0

Function Documentation

eventloop_register()

void eventloop_register ( duk_context * ctx )

extern

Definition at line 601 of file duktape-1.5.2/examples/eventloop/c_eventloop.c.

                                          {
    memset((void *) timer_list, 0, MAX_TIMERS * sizeof(ev_timer));
    memset((void *) &timer_expiring, 0, sizeof(ev_timer));
    memset((void *) poll_list, 0, MAX_FDS * sizeof(struct pollfd));
 
    /* Set global 'EventLoop'. */
    duk_push_global_object(ctx);
    duk_push_object(ctx);
    duk_put_function_list(ctx, -1, eventloop_funcs);
    duk_put_prop_string(ctx, -2, "EventLoop");
    duk_pop(ctx);
 
    /* Initialize global stash 'eventTimers'. */
    duk_push_global_stash(ctx);
    duk_push_object(ctx);
    duk_put_prop_string(ctx, -2, "eventTimers");
    duk_pop(ctx);
}

Referenced by main().

eventloop_run()

int eventloop_run ( duk_context * ctx )

extern

Definition at line 257 of file duktape-1.5.2/examples/eventloop/c_eventloop.c.

                                    {
    ev_timer *t;
    double now;
    double diff;
    int timeout;
    int rc;
    int i, n;
    int idx_eventloop;
    int idx_fd_handler;
 
    /* The Ecmascript poll handler is passed through EventLoop.fdPollHandler
     * which c_eventloop.js sets before we come here.
     */
    duk_push_global_object(ctx);
    duk_get_prop_string(ctx, -1, "EventLoop");
    duk_get_prop_string(ctx, -1, "fdPollHandler");  /* -> [ global EventLoop fdPollHandler ] */
    idx_fd_handler = duk_get_top_index(ctx);
    idx_eventloop = idx_fd_handler - 1;
 
    for (;;) {
        /*
         *  Expire timers.
         */
 
        expire_timers(ctx);
 
        /*
         *  If exit requested, bail out as fast as possible.
         */
 
        if (exit_requested) {
#if 0
            fprintf(stderr, "exit requested, exiting event loop\n");
            fflush(stderr);
#endif
            break;
        }
 
        /*
         *  Compact poll list by removing pollfds with fd == 0.
         */
 
        compact_poll_list();
 
        /*
         *  Determine poll() timeout (as close to poll() as possible as
         *  the wait is relative).
         */
 
        now = get_now();
        t = find_nearest_timer();
        if (t) {
            diff = t->target - now;
            if (diff < MIN_WAIT) {
                diff = MIN_WAIT;
            } else if (diff > MAX_WAIT) {
                diff = MAX_WAIT;
            }
            timeout = (int) diff;  /* clamping ensures that fits */
        } else {
            if (poll_count == 0) {
#if 0
                fprintf(stderr, "no timers and no sockets to poll, exiting\n");
                fflush(stderr);
#endif
                break;
            }
            timeout = (int) MAX_WAIT;
        }
 
        /*
         *  Poll for activity or timeout.
         */
 
#if 0
        fprintf(stderr, "going to poll, timeout %d ms, pollfd count %d\n", timeout, poll_count);
        fflush(stderr);
#endif
 
        rc = poll(poll_list, poll_count, timeout);
#if 0
        fprintf(stderr, "poll rc: %d\n", rc);
        fflush(stderr);
#endif
        if (rc < 0) {
            /* error */
        } else if (rc == 0) {
            /* timeout */
        } else {
            /* 'rc' fds active */
        }
 
        /*
         *  Check socket activity, handle all sockets.  Handling is offloaded to
         *  Ecmascript code (fd + revents).
         *
         *  If FDs are removed from the poll list while we're processing callbacks,
         *  the entries are simply marked unused (fd set to 0) without actually
         *  removing them from the poll list.  This ensures indices are not
         *  disturbed.  The poll list is compacted before next poll().
         */
 
        n = (rc == 0 ? 0 : poll_count);  /* if timeout, no need to check pollfd */
        for (i = 0; i < n; i++) {
            struct pollfd *pfd = poll_list + i;
 
            if (pfd->fd == 0) {
                /* deleted, perhaps by previous callback */
                continue;
            }
 
            if (pfd->revents) {
#if 0
                fprintf(stderr, "fd %d has revents: %d\n", (int) pfd->fd, (int) pfd->revents);
                fflush(stderr);
#endif
                duk_dup(ctx, idx_fd_handler);
                duk_dup(ctx, idx_eventloop);
                duk_push_int(ctx, pfd->fd);
                duk_push_int(ctx, pfd->revents);
                rc = duk_pcall_method(ctx, 2 /*nargs*/);
                if (rc) {
#if 0
                    fprintf(stderr, "fd callback failed for fd %d: %s\n", (int) pfd->fd, duk_to_string(ctx, -1));
                    fflush(stderr);
#endif
                }
                duk_pop(ctx);
 
                pfd->revents = 0;
            }
 
        }
    }
 
    duk_pop_n(ctx, 3);
 
    return 0;
}

Referenced by wrapped_compile_execute().

fileio_register()

void fileio_register ( duk_context * ctx )

extern

Definition at line 62 of file duktape-1.5.2/examples/eventloop/fileio.c.

                                       {
    /* Set global 'FileIo'. */
    duk_push_global_object(ctx);
    duk_push_object(ctx);
    duk_put_function_list(ctx, -1, fileio_funcs);
    duk_put_prop_string(ctx, -2, "FileIo");
    duk_pop(ctx);
}

Referenced by main().

handle_fh()

int handle_fh	(	duk_context *	ctx,
		FILE *	f,
		const char *	filename )

Definition at line 101 of file vendor/civetweb/third_party/duktape-1.5.2/examples/eventloop/main.c.

                                                               {
    char *buf = NULL;
    int len;
    int got;
    int rc;
    int retval = -1;
 
    if (fseek(f, 0, SEEK_END) < 0) {
        goto error;
    }
    len = (int) ftell(f);
    if (fseek(f, 0, SEEK_SET) < 0) {
        goto error;
    }
    buf = (char *) malloc(len);
    if (!buf) {
        goto error;
    }
 
    got = fread((void *) buf, (size_t) 1, (size_t) len, f);
 
    duk_push_lstring(ctx, buf, got);
    duk_push_string(ctx, filename);
 
    free(buf);
    buf = NULL;
 
    rc = duk_safe_call(ctx, wrapped_compile_execute, 2 /*nargs*/, 1 /*nret*/);
    if (rc != DUK_EXEC_SUCCESS) {
        print_error(ctx, stderr);
        goto error;
    } else {
        duk_pop(ctx);
        retval = 0;
    }
    /* fall thru */
 
 error:
    if (buf) {
        free(buf);
    }
    return retval;
}

References DUK_EXEC_SUCCESS, duk_pop(), duk_push_lstring(), duk_push_string(), duk_safe_call(), error(), fread(), free, malloc, NULL, print_error(), and wrapped_compile_execute().

Referenced by handle_file(), and handle_stdin().

handle_file()

int handle_file	(	duk_context *	ctx,
		const char *	filename )

Definition at line 145 of file vendor/civetweb/third_party/duktape-1.5.2/examples/eventloop/main.c.

                                                        {
    FILE *f = NULL;
    int retval;
 
    f = fopen(filename, "rb");
    if (!f) {
        fprintf(stderr, "failed to open source file: %s\n", filename);
        fflush(stderr);
        goto error;
    }
 
    retval = handle_fh(ctx, f, filename);
 
    fclose(f);
    return retval;
 
 error:
    return -1;
}

References error(), handle_fh(), and NULL.

Referenced by main().

handle_stdin()

int handle_stdin

(

duk_context *

ctx

)

Definition at line 165 of file vendor/civetweb/third_party/duktape-1.5.2/examples/eventloop/main.c.

                                   {
    int retval;
 
    retval = handle_fh(ctx, stdin, "stdin");
 
    return retval;
}

References handle_fh().

Referenced by main().

main()

int main	(	int	argc,
		char *	argv[] )

Definition at line 173 of file vendor/civetweb/third_party/duktape-1.5.2/examples/eventloop/main.c.

                                 {
    duk_context *ctx = NULL;
    int retval = 0;
    const char *filename = NULL;
    int i;
 
#ifndef NO_SIGNAL
    set_sigint_handler();
 
    /* This is useful at the global level; libraries should avoid SIGPIPE though */
    /*signal(SIGPIPE, SIG_IGN);*/
#endif
 
    for (i = 1; i < argc; i++) {
        char *arg = argv[i];
        if (!arg) {
            goto usage;
        }
        if (strcmp(arg, "-c") == 0) {
            c_evloop = 1;
        } else if (strlen(arg) > 1 && arg[0] == '-') {
            goto usage;
        } else {
            if (filename) {
                goto usage;
            }
            filename = arg;
        }
    }
    if (!filename) {
        goto usage;
    }
 
    ctx = duk_create_heap_default();
 
    poll_register(ctx);
    ncurses_register(ctx);
    socket_register(ctx);
    fileio_register(ctx);
 
    if (c_evloop) {
        fprintf(stderr, "Using C based eventloop (omit -c to use Ecmascript based eventloop)\n");
        fflush(stderr);
 
        eventloop_register(ctx);
        duk_eval_file(ctx, "c_eventloop.js");
    } else {
        fprintf(stderr, "Using Ecmascript based eventloop (give -c to use C based eventloop)\n");
        fflush(stderr);
 
        duk_eval_file(ctx, "ecma_eventloop.js");
    }
 
    fprintf(stderr, "Executing code from: '%s'\n", filename);
    fflush(stderr);
 
    if (strcmp(filename, "-") == 0) {
        if (handle_stdin(ctx) != 0) {
            retval = 1;
            goto cleanup;
        }
    } else {
        if (handle_file(ctx, filename) != 0) {
            retval = 1;
            goto cleanup;
        }
    }
 
 cleanup:
    if (ctx) {
        duk_destroy_heap(ctx);
    }
 
    return retval;
 
 usage:
    fprintf(stderr, "Usage: evloop [-c] <filename>\n");
    fprintf(stderr, "\n");
    fprintf(stderr, "Uses an Ecmascript based eventloop (ecma_eventloop.js) by default.\n");
    fprintf(stderr, "If -c option given, uses a C based eventloop (c_eventloop.{c,js}).\n");
    fprintf(stderr, "If <filename> is '-', the entire STDIN executed.\n");
    fflush(stderr);
    exit(1);
}

References arg, c_evloop, duk_create_heap_default, duk_destroy_heap(), duk_eval_file, eventloop_register(), fileio_register(), handle_file(), handle_stdin(), ncurses_register(), NULL, poll_register(), set_sigint_handler(), socket_register(), and usage().

my_sighandler()

static void my_sighandler ( int x )

static

Definition at line 27 of file vendor/civetweb/third_party/duktape-1.5.2/examples/eventloop/main.c.

                                 {
    fprintf(stderr, "Got signal %d\n", x);
    fflush(stderr);
}

Referenced by set_sigint_handler().

ncurses_register()

void ncurses_register ( duk_context * ctx )

extern

Definition at line 98 of file duktape-1.5.2/examples/eventloop/ncurses.c.

                                        {
    /* Set global 'Ncurses'. */
    duk_push_global_object(ctx);
    duk_push_object(ctx);
    duk_put_function_list(ctx, -1, ncurses_funcs);
    duk_put_prop_string(ctx, -2, "Ncurses");
    duk_pop(ctx);
}

References duk_pop(), duk_push_global_object(), duk_push_object(), duk_put_function_list(), duk_put_prop_string(), and ncurses_funcs.

Referenced by main().

poll_register()

void poll_register ( duk_context * ctx )

extern

Definition at line 103 of file duktape-1.5.2/examples/eventloop/poll.c.

                                     {
    /* Set global 'Poll' with functions and constants. */
    duk_push_global_object(ctx);
    duk_push_object(ctx);
    duk_put_function_list(ctx, -1, poll_funcs);
    duk_put_number_list(ctx, -1, poll_consts);
    duk_put_prop_string(ctx, -2, "Poll");
    duk_pop(ctx);
}

References duk_pop(), duk_push_global_object(), duk_push_object(), duk_put_function_list(), duk_put_number_list(), duk_put_prop_string(), poll_consts, and poll_funcs.

Referenced by main().

print_error()

static void print_error ( duk_context * ctx, FILE * f )

static

Definition at line 37 of file vendor/civetweb/third_party/duktape-1.5.2/examples/eventloop/main.c.

                                                   {
    if (duk_is_object(ctx, -1) && duk_has_prop_string(ctx, -1, "stack")) {
        /* XXX: print error objects specially */
        /* XXX: pcall the string coercion */
        duk_get_prop_string(ctx, -1, "stack");
        if (duk_is_string(ctx, -1)) {
            fprintf(f, "%s\n", duk_get_string(ctx, -1));
            fflush(f);
            duk_pop_2(ctx);
            return;
        } else {
            duk_pop(ctx);
        }
    }
    duk_to_string(ctx, -1);
    fprintf(f, "%s\n", duk_get_string(ctx, -1));
    fflush(f);
    duk_pop(ctx);
}

References duk_get_prop_string(), duk_get_string(), duk_has_prop_string(), duk_is_object(), duk_is_string(), duk_pop(), duk_pop_2(), and duk_to_string().

Referenced by handle_fh().

set_sigint_handler()

static void set_sigint_handler ( void )

static

Definition at line 31 of file vendor/civetweb/third_party/duktape-1.5.2/examples/eventloop/main.c.

                                     {
    (void) signal(SIGINT, my_sighandler);
}

References my_sighandler().

Referenced by main().

socket_register()

void socket_register ( duk_context * ctx )

extern

Definition at line 279 of file duktape-1.5.2/examples/eventloop/socket.c.

                                       {
    /* Set global 'Socket'. */
    duk_push_global_object(ctx);
    duk_push_object(ctx);
    duk_put_function_list(ctx, -1, socket_funcs);
    duk_put_prop_string(ctx, -2, "Socket");
    duk_pop(ctx);
}

References duk_pop(), duk_push_global_object(), duk_push_object(), duk_put_function_list(), duk_put_prop_string(), and socket_funcs.

Referenced by main().

wrapped_compile_execute()

int wrapped_compile_execute

(

duk_context *

ctx

)

Definition at line 57 of file vendor/civetweb/third_party/duktape-1.5.2/examples/eventloop/main.c.

                                              {
    int comp_flags = 0;
    int rc;
 
    /* Compile input and place it into global _USERCODE */
    duk_compile(ctx, comp_flags);
    duk_push_global_object(ctx);
    duk_insert(ctx, -2);  /* [ ... global func ] */
    duk_put_prop_string(ctx, -2, "_USERCODE");
    duk_pop(ctx);
#if 0
    printf("compiled usercode\n");
#endif
 
    /* Start a zero timer which will call _USERCODE from within
     * the event loop.
     */
    fprintf(stderr, "set _USERCODE timer\n");
    fflush(stderr);
    duk_eval_string(ctx, "setTimeout(function() { _USERCODE(); }, 0);");
    duk_pop(ctx);
 
    /* Finally, launch eventloop.  This call only returns after the
     * eventloop terminates.
     */
    if (c_evloop) {
        fprintf(stderr, "calling eventloop_run()\n");
        fflush(stderr);
        rc = duk_safe_call(ctx, eventloop_run, 0 /*nargs*/, 1 /*nrets*/);
        if (rc != 0) {
            fprintf(stderr, "eventloop_run() failed: %s\n", duk_to_string(ctx, -1));
            fflush(stderr);
        }
        duk_pop(ctx);
    } else {
        fprintf(stderr, "calling EventLoop.run()\n");
        fflush(stderr);
        duk_eval_string(ctx, "EventLoop.run();");
        duk_pop(ctx);
    }
 
    return 0;
}

References c_evloop, duk_compile, duk_eval_string, duk_insert(), duk_pop(), duk_push_global_object(), duk_put_prop_string(), duk_safe_call(), duk_to_string(), eventloop_run(), and printf.

Referenced by handle_fh().

Variable Documentation

c_evloop

int c_evloop = 0

static

Definition at line 24 of file vendor/civetweb/third_party/duktape-1.5.2/examples/eventloop/main.c.

Referenced by main(), and wrapped_compile_execute().