Libraries in Pure-data

Even worse, consider the following directory structure:

/usr/lib/pd/extra/foo/foo.pd
/usr/lib/pd/extra/foo/foo.pd_linux
/home/user/project1/MAIN.pd
/home/user/project1/foo.pd
/home/user/project1/foo.pd_linux
/home/user/project2/MAIN.pd
/home/user/project2/foo.pd
/home/user/project2/foo.pd_linux

Package-qualified imports

With the -XPackageImports flag, GHC allows import declarations to be qualified by the package name that the module is intended to be imported from. For example:

import "network" Network.Socket

would import the module Network.Socket from the package network (any version). This may be used to disambiguate an import when the same module is available from multiple packages, or is present in both the current package being built and an external package.

Note: you probably don't need to use this feature, it was added mainly so that we can build backwards-compatible versions of packages when APIs change. It can lead to fragile dependencies in the common case: modules occasionally move from one package to another, rendering any package-qualified imports broken.

Currently vanilla Pd does something like this:

function create(objectname, args)
  if objectmaker.method[objectname] then
    objectmaker.method[objectname](objectname, args)
  else
    success = loadlibrary(canvas, objectname)
    if success then
      -- real code guards against infinite recursion
      create(objectname, args)
    else
      createabstraction(canvas, objectname, args)
    end
  end
end

function loadlibrary(canvas, objectname)
  for loader in loaders do
    success = loader.load(canvas, objectname)
    if success then return success
  end
  return failure
end

function example_loader.load(canvas, objectname)
  filename = objectname .. ".eg"
  success, file, dir = searchpaths(canvas, filename)
  if success then
    execute(dir .. "/" .. file)
  end
  return success
end

Reserved words

There needs to be a small set of reserved words which are in the global namespace and cannot be overridden.

pd
inlet
outlet
inlet~
outlet~
declare
import

depth first message passing

In Pd whenever a message is initiated, the receiver may then send out further messages in turn, and the receivers of those messages can send yet others. So each message sets off a tree of consequent messages. This tree is executed in depth first fashion. For instance in the patch below:

[A]
 |\_
 |  \
[B] [C]
     |
    [D]

the order of arrival of messages is either A-B-C-D or A-C-D-B. The "C" message is not done until the "D" one is also, and the "A" is not done until all four are. It is indeterminate which of "B" or "C" is done first; this depends on what order you made the connections in (in Max, it's automatically sorted right to left).

Foo.hs

module Foo (quux) where quux = 1

Bar.hs

module Bar (quux) where quux = 1

Baz.hs

module Main (main) where
import Foo
import Bar
main = print quux

ambiguity error at point of use

$ ghc --make Baz.hs 
[1 of 3] Compiling Bar              ( Bar.hs, Bar.o )
[2 of 3] Compiling Foo              ( Foo.hs, Foo.o )
[3 of 3] Compiling Main             ( Baz.hs, Baz.o )

Baz.hs:4:13:
  Ambiguous occurrence `quux'
  It could refer to either
      `Foo.quux', imported from Foo at Baz.hs:2:0-9
                    (defined at Foo.hs:1:24)
   or `Bar.quux', imported from Bar at Baz.hs:3:0-9
                    (defined at Bar.hs:1:24)

m_imp.h

typedef struct _class {
  ...
  t_methodentry *c_methods; /* other than bang, etc */
  int c_nmethod;            /* number of methods */
  ...
} t_class;

m_class.c

t_class *class_new(...) {
  ...
  c->c_methods = t_getbytes(0);
  c->c_nmethod = 0;
  ...
}

void class_addmethod(t_class *c, t_method fn,
  t_symbol *sel, t_atomtype arg1, ...) {
  ...
  /* rename any existing method of the same name */
  /* resize array for the additional method */
  /* copy new method into the last array slot */
  ...
}

Asymptotic complexities of container data structures:

A map can be implemented as a sorted array:

function binarysearch(array, key, lowindex, highindex)
  ...
end
function move(array, from, to, length) ... end
function access(array, key)
  index = binarysearch(array, key, -1, array.size)
  -- succeed when array[index].key == key
end
function insert(array, value)
  index = binarysearch(array, value.key, -1, array.size)
  if array[index].key == value.key then
    -- overwrite existing value
  else
    resize(array, array.size, array.size + 1)
    move(array, index, index + 1, array.size - index)
    array[index] = value
  end
end

g_canvas.c

void canvas_savedeclarationsto(t_canvas *x, t_binbuf *b) {
  t_gobj *y;
  for (y = x->gl_list; y; y = y->g_next) {
    if (pd_class(&y->g_pd) == declare_class) {
      binbuf_addv(b, "s", gensym("#X"));
      binbuf_addbinbuf(b, ((t_declare *)y)->x_obj.te_binbuf);
      binbuf_addv(b, ";");
    } else if (pd_class(&y->g_pd) == canvas_class) {
      canvas_savedeclarationsto((t_canvas *)y, b);
    }
  }
}

g_readwrite.c

/* save to a binbuf, called recursively */
static void canvas_saveto(t_canvas *x, t_binbuf *b) {
  if (x->gl_owner && !x->gl_env) { /* subpatch */
    /* find out how we were named. */
  } else { /* root or abstraction */
    binbuf_addv(b, /* "#N canvas x y w h font;" */)
    canvas_savedeclarationsto(x, b);
  }
  /* save objects */
  /* save lines */
  /* save coords */
}

#define pd_objectmaker (*pd_objectmaker2)
extern t_pd *pd_objectmaker2;
#define pd_objectmaker3 ((t_libspace *)pd_objectmaker2)

/* these two functions manipulate pd_objectmaker */
t_libspace *libspace_push(t_libspace *ls);
void libspace_pop(t_libspace *old);

/* called when no more-specific method is found, this happens
   at the top level factory, so we can switch the default
   pd_objectmaker before too much damage is done... */
void libspace_anything
    (t_libspace *ls, t_symbol *s, int argc, t_atom *argv) {
  newest = 0;
  t_libspace_list *n;
  for (n = ls->children; n; n = n->next) {
    t_libspace *old = libspace_push(n->libspace);
    /* typedmess tests for pd_objectmaker */
    typedmess(&pd_objectmaker, s, argc, argv);
    libspace_pop(old);
    if (newest) { return; }
  }
  /* load library and import it automatically (TODO)
     but only when -strict-imports is not set (TODO) */
  /* load abstraction (TODO) */
}