anchor.diff:      "code_change(_OldVsn, State, _Extra) -> {ok, State}."
     ]].
     
  -%% Default methods that Reia objects respond to
  -default_methods(Module) ->
  -  NameString = lists:concat(["reia_string:from_list(\"#<", Module, ">\")"]),
  -  [default_method(Function) || Function <- [
  -    "class() -> {constant, '" ++ atom_to_list(Module) ++ "'}.",
  -    "initialize() -> nil.",
  -    "to_s() -> " ++ NameString ++ ".",
  -    "inspect() -> " ++ NameString ++ ".",
  -    "'_'(Method, _Args) -> throw({error, {Method, \"undefined\"}})."
  -  ]].
  -  
  -%% Parse a default function and return a dict entry for it
  -default_method(String) ->
  -  Form = parse_function(String),
  -  {function, _, Name, _, _} = Form,
  -  {Name, Form}.
  -  
   %% Functions for starting a new object
   start_functions(Module) ->
     [start_function(Module, Function) || Function <- [{"spawn", "start"}, {"spawn_link", "start_link"}]].
  
positive.code:   
    add_ancestor(Methods, AncestorClass);
  add_ancestor(Methods, {class, _Line, {constant, _, AncestorName}, AncestorMethods}) ->
    lists:foldr(
      fun(Function, Dict) ->
        {function, _, {identifier, _, Name}, _, _} = Function,
        dict:store(Name, {method, AncestorName, Function}, Dict) 
      end,
      Methods,
  
negative.code:   lists:flatten([
      start_functions(Module),
      default_functions(),
      method_functions(Methods)
    ]).
    
  %% Build a dispatch_method function and functions for each of the mangled methods
  method_functions(Methods) ->
    % Decompose the function clauses for methods into handle_call clauses
    {Clauses, Functions} = process_methods(Methods),
    [build_method_dispatch_function(Clauses)|Functions].
   
  %% Process methods into a list of clauses for dispatch_method and functions
  %% with mangled names for each method
  process_methods(Methods) ->
    {NewClauses, NewFunctions} = lists:foldl(fun(Method, {Clauses, Functions}) ->
      {Name, Function} = extract_mangled_name_and_function(Method),
      {Clause, Function2} = build_dispatcher_clause_and_function(Function, Name),
      {[Clause|Clauses], [Function2|Functions]}
    end, {[],[]}, Methods),
    {lists:reverse(NewClauses), lists:reverse(NewFunctions)}.
    
  %% Extract a method into its dispatch_method clause and mangled form
  extract_mangled_name_and_function({method, Ancestor, {function, _, Name, _, _} = Function}) ->
    {reia_mangle:method(Ancestor, Name), Function};
  extract_mangled_name_and_function({function, _, Name, _, _} = Function) ->
    {reia_mangle:method(Name), Function}.
    
  %% Construct the new function and dispatcher clause
  build_dispatcher_clause_and_function({function, Line, Name, _Arity, Clauses}, MangledName) ->
    DispatcherClause = dispatcher_clause(Name, MangledName, Line),
    Function = {function, Line, MangledName, 3,
      [process_method_clause(Clause) || Clause <- Clauses]
  