]> git.donarmstrong.com Git - lilypond.git/blobdiff - lily/lily-guile.cc
release: 1.2.4
[lilypond.git] / lily / lily-guile.cc
index 0205684901198f8340faeaf7cf2b5403826a1f51..96e140707b3baa31f4c292c02b8ea87236614a09 100644 (file)
 
   source file of the GNU LilyPond music typesetter
 
-  (c) 1998 Jan Nieuwenhuizen <janneke@gnu.org>
+  (c) 1998--1999 Jan Nieuwenhuizen <janneke@gnu.org>
 
   Han-Wen Nienhuys <hanwen@cs.uu.nl>
 */
 
+
 #include <stdio.h>
+#include <stdlib.h>
+
 #include "libc-extension.hh"
 #include "lily-guile.hh"
 #include "main.hh"
 #include "simple-file-storage.hh"
 #include "file-path.hh"
+#include "debug.hh"
 
 SCM
-ly_list1 (SCM a)
+ly_ch_C_to_scm (char const*c)
 {
-  return gh_list (a, SCM_UNDEFINED);
+  // this all really sucks, guile should take char const* arguments!
+  return gh_str02scm ((char*)c);
 }
 
+SCM
+ly_ch_C_eval_scm (char const*c)
+{
+  // this all really sucks, guile should take char const* arguments!
+  return gh_eval_str ((char*)c);
+}
 
 /*
   scm_m_quote doesn't use any env, but needs one for a good signature in GUILE.
-
-  Why there is no gh_quote () in GUILE  beats me.
 */
 
 SCM
 ly_quote_scm (SCM s)
 {
-  //  return scm_m_quote (s, SCM_UNDEFINED);
-  return scm_cons2 (scm_i_quote, s, SCM_EOL);
-  
+  return scm_m_quote (scm_cons2 (SCM_EOL, s, SCM_EOL) ,SCM_EOL); // apparently env arg is ignored.
 }
 
+/*
+  See: libguile/symbols.c
+
+  SCM
+  scm_string_to_symbol(s)
+  
+*/
 SCM
-ly_eval (SCM a)
+ly_symbol (String name)
 {
-  return gh_call1 (gh_eval_str ("eval"), a);
+  return gh_car (scm_intern ((char*)name.ch_C(), name.length_i()));
 }
 
-SCM
-ly_lambda_o ()
+String
+symbol_to_string (SCM s)
 {
-  return gh_eval_str ("'(lambda (o))");
+  return String((Byte*)SCM_CHARS (s), (int) SCM_LENGTH(s));
 }
 
 SCM
-ly_func_o (char const* name)
+ly_set_scm (String name, SCM val)
 {
-  char buf[200];               // ugh.
-  snprintf (buf, 200, "'(%s o)", name);
-  return gh_eval_str (buf);
+  return scm_sysintern ((char*)name.ch_C(), val);
+  
 }
 
-/*
-  See: libguile/symbols.c
+/**
+   Read a file, and shove it down GUILE.  GUILE also has file read
+   functions, but you can't fiddle with the path of those.
+ */
+void
+read_lily_scm_file (String fn)
+{
+  String s = global_path.find (fn);
+  if (s == "")
+    {
+      String e = _f ("Can not find file `%s\'", fn);
+      e += " ";
+      e += _f ("(Load path is `%s\'", global_path.str ());
+      error (e);
+    }
+  else
+    *mlog << '[' << s;
 
-  SCM
-  scm_string_to_symbol(s)
+
+  Simple_file_storage f(s);
   
-*/
-SCM
-ly_symbol (String name)
-{
-  return gh_car (scm_intern (name.ch_C(), name.length_i()));
+  ly_ch_C_eval_scm ((char *) f.ch_C());
+  *mlog << ']' << flush;  
 }
 
+
 SCM
-lambda_scm (String str, Array<int> args_arr)
+ly_gulp_file (SCM name)
 {
-  if (str.empty_b ())
+  String fn (ly_scm2string (name));
+ String s = global_path.find (fn);
+  if (s == "")
     {
-      str = "empty";
-      args_arr.clear ();
+      String e = _f ("Can not find file `%s\'", fn);
+      e += " ";
+      e += _f ("(Load path is `%s\'", global_path.str ());
+      error (e);
     }
-  SCM args_scm = SCM_EOL;
-  for (int i = args_arr.size () - 1; i >= 0; i--)
-    args_scm = gh_cons (gh_int2scm (args_arr[i]), args_scm);
-  args_scm = gh_cons (ly_symbol (str.ch_l ()), args_scm);
-  return args_scm;
+  else
+    *mlog << '[' << s;
+
+
+  Simple_file_storage f(s);
+  return ly_ch_C_to_scm (f.ch_C());
+}
+
+void
+ly_display_scm (SCM s)
+{
+  gh_display (s);
+  gh_newline ();
+}
+
+String
+ly_scm2string (SCM s)
+{
+  int len; 
+  char * p = gh_scm2newstr (s , &len);
+  
+  String r (p);
+  //  delete p;
+  free (p);
+  return r;
 }
 
-// scm_top_level_env(SCM_CDR(scm_top_level_lookup_closure_var)))
 SCM
-lambda_scm (String str, Array<Scalar> args_arr)
+index_cell (SCM s, Direction d)
 {
-  if (str.empty_b ())
-    {
-      str = "empty";
-      args_arr.clear ();
-    }
-  SCM args_scm = SCM_EOL;
-  for (int i = args_arr.size (); i--; )
-    args_scm = gh_cons (gh_str02scm (args_arr[i].ch_l ()), args_scm);
-  args_scm = gh_cons (ly_symbol (str.ch_l ()), args_scm);
-  return args_scm;
+  assert (d);
+  return (d == LEFT) ? SCM_CAR (s) : SCM_CDR (s);
 }
 
+  
 SCM
-lambda_scm (String str, Array<Real> args_arr)
+array_to_list (SCM *a , int l)
 {
-  if (str.empty_b ())
+  SCM list = SCM_EOL;
+  for (int i= l; i--;  )
     {
-      str = "empty";
-      args_arr.clear ();
+      list =  gh_cons (a[i], list);
     }
-  SCM args_scm = SCM_EOL;
-  for (int i = args_arr.size (); i--; )
-    args_scm = gh_cons (gh_double2scm (args_arr[i]), args_scm);
-  
-  args_scm = gh_cons (ly_symbol (str.ch_l ()), args_scm);
-  return args_scm;
+  return list;
 }
 
-/**
+SCM
+ly_warning (SCM str)
+{
+  assert (gh_string_p (str));
+  warning ("lily-guile: " + ly_scm2string (str));
+  return SCM_BOOL_T;
+}
 
-   Read a file, and shove it down GUILE.  GUILE also has file read
-   functions, but you can't fiddle with the path of those.
-   
- */
+void
+init_functions ()
+{
+  scm_make_gsubr ("ly-warn", 1, 0, 0, (SCM(*)(...))ly_warning);
+  scm_make_gsubr ("ly-gulp-file", 1,0, 0, (SCM(*)(...))ly_gulp_file);
+}
+
+extern void init_symbols ();
 
 void
-read_lily_scm_file (String fn)
+init_lily_guile ()
 {
-  String s = global_path.find (fn);
-  Simple_file_storage f(s);
-  
-  gh_eval_str ((char *) f.ch_C());
+  init_symbols();
+  init_functions ();
 }