/**
* Document-method: MessagePack::Unpacker#initialize
*
* call-seq:
* MessagePack::Unpacker.new(stream = nil)
*
* Creates instance of MessagePack::Unpacker.
*
* You can specify a _stream_ for input stream.
* It is required to implement *sysread* or *readpartial* method.
*
* With the input stream, buffers will be feeded into the deserializer automatically.
*
* Without the input stream, use *feed* method manually. Or you can manage the buffer manually
* with *execute*, *finished?*, *data* and *reset* methods.
*/
static VALUE MessagePack_Unpacker_initialize(int argc, VALUE *argv, VALUE self)
{
VALUE stream;
switch(argc) {
case 0:
stream = Qnil;
break;
case 1:
stream = argv[0];
break;
default:
rb_raise(rb_eArgError, "wrong number of arguments (%d for 0)", argc);
}
UNPACKER(self, mp);
template_init(mp);
mp->user.finished = 0;
mp->user.offset = 0;
mp->user.buffer.size = 0;
mp->user.buffer.free = 0;
mp->user.buffer.ptr = NULL;
mp->user.stream = stream;
mp->user.streambuf = rb_str_buf_new(MSGPACK_UNPACKER_BUFFER_RESERVE_SIZE);
mp->user.stream_append_method = append_method_of(stream);
return self;
}
bool msgpack_unpack_next(msgpack_unpacked* result,
const char* data, size_t len, size_t* off)
{
msgpack_unpacked_destroy(result);
size_t noff = 0;
if(off != NULL) { noff = *off; }
if(len <= noff) {
return false;
}
msgpack_zone* z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE);
template_context ctx;
template_init(&ctx);
ctx.user.z = z;
ctx.user.referenced = false;
int e = template_execute(&ctx, data, len, &noff);
if(e <= 0) {
msgpack_zone_free(z);
return false;
}
if(off != NULL) { *off = noff; }
result->zone = z;
result->data = template_data(&ctx);
return true;
}
void msgpack_unpacker_reset(msgpack_unpacker* mpac)
{
template_init(CTX_CAST(mpac->ctx));
/* Fluent Bit: refer to unpack.h for more details about this field */
mpac->last_parsed = mpac->parsed;
// don't reset referenced flag
mpac->parsed = 0;
}
msgpack_unpack_return
msgpack_unpack_next(msgpack_unpacked* result,
const char* data, size_t len, size_t* off)
{
size_t noff = 0;
msgpack_unpacked_destroy(result);
if(off != NULL) { noff = *off; }
if(len <= noff) {
return MSGPACK_UNPACK_CONTINUE;
}
if (!result->zone) {
result->zone = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE);
}
if (!result->zone) {
return MSGPACK_UNPACK_NOMEM_ERROR;
}
else {
int e;
template_context ctx;
template_init(&ctx);
ctx.user.z = result->zone;
ctx.user.referenced = false;
e = template_execute(&ctx, data, len, &noff);
if(e < 0) {
msgpack_zone_free(result->zone);
result->zone = NULL;
return MSGPACK_UNPACK_PARSE_ERROR;
}
if(e == 0) {
return MSGPACK_UNPACK_CONTINUE;
}
if(off != NULL) { *off = noff; }
result->data = template_data(&ctx);
return MSGPACK_UNPACK_SUCCESS;
}
}
bool msgpack_unpacker_init(msgpack_unpacker* mpac, size_t initial_buffer_size)
{
char* buffer;
void* ctx;
msgpack_zone* z;
if(initial_buffer_size < COUNTER_SIZE) {
initial_buffer_size = COUNTER_SIZE;
}
buffer = (char*)malloc(initial_buffer_size);
if(buffer == NULL) {
return false;
}
ctx = malloc(sizeof(template_context));
if(ctx == NULL) {
free(buffer);
return false;
}
z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE);
if(z == NULL) {
free(ctx);
free(buffer);
return false;
}
mpac->buffer = buffer;
mpac->used = COUNTER_SIZE;
mpac->free = initial_buffer_size - mpac->used;
mpac->off = COUNTER_SIZE;
mpac->parsed = 0;
mpac->last_parsed = 0;
mpac->initial_buffer_size = initial_buffer_size;
mpac->z = z;
mpac->ctx = ctx;
init_count(mpac->buffer);
template_init(CTX_CAST(mpac->ctx));
CTX_CAST(mpac->ctx)->user.z = mpac->z;
CTX_CAST(mpac->ctx)->user.referenced = false;
return true;
}
msgpack_unpack_return
msgpack_unpack(const char* data, size_t len, size_t* off,
msgpack_zone* result_zone, msgpack_object* result)
{
size_t noff = 0;
if(off != NULL) {
noff = *off;
}
if(len <= noff) {
// FIXME
return MSGPACK_UNPACK_CONTINUE;
}
template_context ctx;
template_init(&ctx);
ctx.user.z = result_zone;
ctx.user.referenced = false;
int e = template_execute(&ctx, data, len, &noff);
if(e < 0) {
return MSGPACK_UNPACK_PARSE_ERROR;
}
if(off != NULL) {
*off = noff;
}
if(e == 0) {
return MSGPACK_UNPACK_CONTINUE;
}
*result = template_data(&ctx);
if(noff < len) {
return MSGPACK_UNPACK_EXTRA_BYTES;
}
return MSGPACK_UNPACK_SUCCESS;
}
int
main(void)
{
unsigned int logged_in = 0;
char *username, *password = { NULL };
cookie_t *cookies = cookies_init();
cookie_t *our_cookie = cookie(COOKIE_NAME);
char *template_path = "templates/portal";
cookie_t *c = NULL;
// Check for session cookie
if (our_cookie) { // && cookie_valid(our_cookie)) {
logged_in = 1;
c = our_cookie;
c->expires = 3600;
} else {
// New connection or expired...
get_params();
username = param("username");
password = param("password");
logged_in = CheckUserCredentials(username, password);
if (logged_in) {
c = cookie_create(username, password);
c->expires = 3600;
} else
WebBork("HERE");
}
cookie_add(cookies, c);
content_type_cookies("text/html", cookies);
template_t **t = template_init();
template_input(t, "USERNAME", username);
template_output(template_path, t);
template_free(t);
exit(EXIT_SUCCESS);
}
void msgpack_unpacker_reset(msgpack_unpacker* mpac)
{
template_init(CTX_CAST(mpac->ctx));
// don't reset referenced flag
mpac->parsed = 0;
}
int main (int argc, char *argv[]) {
/* set up i18n */
bindtextdomain (PACKAGE, LOCALEDIR);
setlocale (LC_ALL, "");
textdomain (PACKAGE);
GError* error = NULL;
GOptionContext* context = g_option_context_new ("files");
g_option_context_add_main_entries (context, entries, PACKAGE);
g_option_context_parse (context, &argc, &argv, &error);
if (error) g_error("%s\n", error->message);
/* initialize GTK */
g_thread_init (NULL);
gdk_threads_init ();
gtk_init (&argc, &argv);
GError* ui_error = NULL;
GtkBuilder* builder = gtk_builder_new ();
gchar* ui = g_build_filename (DATADIR, "ui", "gummi.glade", NULL);
// exit program when gummi.glade can not be located:
if (!g_file_test (ui, G_FILE_TEST_EXISTS)) {
printf("Could not locate Glade interface file at:\n%s\n", ui);
return 0;
}
gtk_builder_add_from_file (builder, ui, &ui_error);
if (ui_error) {
g_error ("%s\n", ui_error->message);
}
gtk_builder_set_translation_domain (builder, PACKAGE);
g_free (ui);
/* Initialize logging */
slog_init (debug);
slog (L_INFO, PACKAGE_NAME" version: "PACKAGE_VERSION"\n");
/* Initialize configuration */
gchar* configname = g_build_filename (g_get_user_config_dir (), "gummi",
"gummi.cfg", NULL);
config_init (configname);
config_load ();
g_free (configname);
/* Initialize signals */
gummi_signals_register ();
/* Initialize Classes */
gchar* snippetsname = g_build_filename (g_get_user_config_dir (), "gummi",
"snippets.cfg", NULL);
// why do we not load this from environment, like gui-main does? -A
GuMotion* motion = motion_init ();
GuIOFunc* io = iofunctions_init();
GuLatex* latex = latex_init ();
GuBiblio* biblio = biblio_init (builder);
GuTemplate* templ = template_init (builder);
GuTabmanager* tabm = tabmanager_init ();
GuProject* proj = project_init ();
GuSnippets* snippets = snippets_init (snippetsname);
gummi = gummi_init (motion, io, latex, biblio, templ, snippets, tabm, proj);
slog (L_DEBUG, "Gummi created!\n");
g_free (snippetsname);
/* Initialize GUI */
gui = gui_init (builder);
slog_set_gui_parent (gui->mainwindow);
slog (L_DEBUG, "GummiGui created!\n");
/* Start compile thread */
if (external_exists (config_get_value("typesetter"))) {
typesetter_setup ();
motion_start_compile_thread (motion);
}
else {
infoscreengui_enable (gui->infoscreengui, "program_error");
slog (L_ERROR, "Could not locate the typesetter program\n");
}
/* Install acceleration group to mainwindow */
gtk_window_add_accel_group (gui->mainwindow, snippets->accel_group);
if (argc != 2)
tabmanager_create_tab (A_DEFAULT, NULL, NULL);
else {
if (!g_file_test(argv[1], G_FILE_TEST_EXISTS)) {
slog(L_ERROR, "Failed to open file '%s': No such file or "
"directory\n", argv[1]);
exit(1);
}
tabmanager_create_tab (A_LOAD, argv[1], NULL);
}
if (config_get_value ("autosaving")) iofunctions_start_autosave ();
gui_main (builder);
config_save ();
config_clean_up ();
return 0;
}
int main(int argc, char *argv[])
{
/* won't actually be called - just here to make linker happy */
template_init();
return 0;
}
