Re: [Denemo-devel] The missing regex in mxe build

[Richard Shann]

On Sun, 2013-02-17 at 13:51 -0600, Jeremiah Benham wrote:
> For me it was in the usr/i686*/bin dir. I made a symbolic link into
> usr/bin. This allowed me to proceed.

Well, I haven't got that working, but I think I have discovered that the
code modifications needed to link in the pdf backend statically are
actually very small. Below is the entire ev-module.c file, in which
there are just two small changes indicated by #if 0 #else #endif
What these do is to skip the loading of the dll and instead expect the
function register_evince_backend() to be statically linked (it is
defined in backend/pdf/ev-poppler.cc).

If I try to make evince with this version of ev-module.c it fails
because it tries to build the executable evince (which we don't need).
This is expected, since it will not have libpdfdocument.a on its link
line.

I tried to make it not build the executable, but I can't find the right
way to adjust the Makefile stuff.

I wonder if you could take this version of ev-module.c and substitute it
in the libdocument directory and then adjust the make system so that it
will build evince? (Either disabling the build of the executable, or
adding backend/pdf/xxxx.o to the object files included in libevince.
I am not really expecting that this will then be the job done - I
imagine there may be a few wrinkles, but with a make system doing the
right thing I am fairly confident we can build a static evince.

Richard
Below is ev-module.c cut and pasted, but I attach it as well as that is
better for file transmission.

/*
 * ev-module.c
 * This file is part of Evince
 *
 * Copyright (C) 2005 - Paolo Maggi 
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, 
 * Boston, MA 02110-1301, USA.
 */
 
/* This is a modified version of ephy-module.c from Epiphany source
code.
 * Here the original copyright assignment:
 *
 *  Copyright (C) 2003 Marco Pesenti Gritti
 *  Copyright (C) 2003, 2004 Christian Persch
 *
 */

/*
 * Modified by the gedit Team, 2005. See the AUTHORS file for a 
 * list of people on the gedit Team.  
 * See the ChangeLog files for a list of changes. 
 *
 * $Id: gedit-module.c 5367 2006-12-17 14:29:49Z pborelli $
 */

/* Modified by evince team */

#include "config.h"

#include "ev-module.h"

#include <gmodule.h>

typedef struct _EvModuleClass EvModuleClass;

struct _EvModuleClass {
        GTypeModuleClass parent_class;
};

struct _EvModule {
        GTypeModule parent_instance;

        GModule *library;
        gboolean resident;

        gchar *path;
        GType type;
};

typedef GType (*EvModuleRegisterFunc) (GTypeModule *);

static void ev_module_init       (EvModule *action);
static void ev_module_class_init (EvModuleClass *class);

G_DEFINE_TYPE (EvModule, ev_module, G_TYPE_TYPE_MODULE)

static gboolean
ev_module_load (GTypeModule *gmodule)
{
        EvModule *module = EV_MODULE (gmodule);
        EvModuleRegisterFunc register_func;
#if 0
        module->library = g_module_open (module->path, 0);

        if (!module->library) {
                g_warning ("%s", g_module_error ());

                return FALSE;
        }

        /* extract symbols from the lib */
        if (!g_module_symbol (module->library,
"register_evince_backend",
                              (void *) &register_func)) {
                g_warning ("%s", g_module_error ());
                g_module_close (module->library);

                return FALSE;
        }

        /* symbol can still be NULL even though g_module_symbol
         * returned TRUE */
        if (!register_func) {
                g_warning ("Symbol 'register_evince_backend' should not
be NULL");
                g_module_close (module->library);

                return FALSE;
        }
#else
extern GType register_evince_backend (GTypeModule *module);
        register_func = register_evince_backend;
#endif
        module->type = register_func (gmodule);

        if (module->type == 0) {
                g_warning ("Invalid evince backend contained by module %
s", module->path);
                
                return FALSE;
        }
#if 0
        if (module->resident)
                g_module_make_resident (module->library);
#endif
        return TRUE;
}

static void
ev_module_unload (GTypeModule *gmodule)
{
#if 0
        EvModule *module = EV_MODULE (gmodule);

        g_module_close (module->library);

        module->library = NULL;
        module->type = 0;
#else
        g_warning("Nothing done for ev_module_unload");
#endif
}

const gchar *
ev_module_get_path (EvModule *module)
{
        g_return_val_if_fail (EV_IS_MODULE (module), NULL);

        return module->path;
}

GObject *
ev_module_new_object (EvModule *module)
{
        g_return_val_if_fail (EV_IS_MODULE (module), NULL);
        
        if (module->type == 0)
                return NULL;

        return g_object_new (module->type, NULL);
}

GType
ev_module_get_object_type (EvModule *module)
{
        g_return_val_if_fail (EV_IS_MODULE (module), 0);

        return module->type;
}

static void
ev_module_init (EvModule *module)
{
}

static void
ev_module_finalize (GObject *object)
{
        EvModule *module = EV_MODULE (object);

        g_free (module->path);

        G_OBJECT_CLASS (ev_module_parent_class)->finalize (object);
}

static void
ev_module_class_init (EvModuleClass *class)
{
        GObjectClass *object_class = G_OBJECT_CLASS (class);
        GTypeModuleClass *module_class = G_TYPE_MODULE_CLASS (class);

        object_class->finalize = ev_module_finalize;

        module_class->load = ev_module_load;
        module_class->unload = ev_module_unload;
}

EvModule *
ev_module_new (const gchar *path,
               gboolean     resident)
{
        EvModule *result;

        g_return_val_if_fail (path != NULL && path[0] != '\0', NULL);

        result = g_object_new (EV_TYPE_MODULE, NULL);

        g_type_module_set_name (G_TYPE_MODULE (result), path);
        result->path = g_strdup (path);
        result->resident = resident;

        return result;
}

> 
> Jeremiah
> 
> On Feb 17, 2013 1:10 PM, "Richard Shann" <address@hidden>
> wrote:
>         On Sun, 2013-02-17 at 17:09 +0000, Richard Shann wrote:
>         > On Sun, 2013-02-17 at 08:03 -0600, Jeremiah Benham wrote:
>         > > I am sure we will encounter an issue or two. Theoretically
>         though, we
>         > > should only have to create such a system like this once.
>         Then we will
>         > > only have to occasionally add update the dependencies now
>         and then. I
>         > > think if we are going to do dynamic, we should fork our
>         own mxe on
>         > > github. We can create a sed script to replace
>         --disable-shared
>         > > --enable-shared and --enable-static to --disable-static on
>         all the
>         > > src/*.mk.
>         > Well, of the two routes (hacking evince or converting mxe to
>         build dlls)
>         > I feel more confident about the first and I suspect you
>         would be better
>         > at the second. The advantage of the first is that we would
>         get mxe
>         > support as the libraries change over time, the disadvantage
>         would be we
>         > would be on our own with any changes we might want to follow
>         in evince.
>         >  I guess we should push ahead with seeing which is feasible.
>         I'll look
>         > some more at evince - in principle I just need to replace
>         the g*module*
>         > stuff with stuff to point directly at the ev-poppler.cc
>         code, bringing
>         > that in to directly linked sources.
>         
>         Well, I fell at the first hurdle. I wanted to build evince on
>         Debian
>         first to trace what it did, and it would not configure for
>         lack of
>         glib-compile-schemas. So I built glib and that generated
>         glib-compile-schemas (it isn't present on my Debian box) and I
>         put it in
>         the path, but it still says it can't find it... sigh!
>         
>         Richard
>         
>

ev-module.c
Description: Text Data