Clean Guile code from C program

[Jose Martin]

Hi all, I need to use a program in C that is designed to be used in Guile. I'm 
not a Guile user myself so I don't know well how to remove the Guile code from 
the C program, so that I can run it without Guile (Please, don't be ofended for 
that ;) ).



I looked at the program's code and it looks a bit difficult to change it, and I 
must say I'm a beginner in C. Could anyone give me the steps of the changes I'd 
need to remove Guile-dependent code from C code?



The program has about 10 files, so here I'm pasting only one of the files. The 
code is open-source so I could share it if anyone wants to see the other files.



I'd massively appreciate any help. Thanks,



Jose



-- ATTACHED CODE --



#include <guile/gh.h>

...



#define INFO contain

#define TEXTMGRP(x) (SCM_NIMP(x) && SCM_CAR(x) == (SCM)scm_tc16_textmgr)

#define TEXTMGR(x) ((TextFile*) SCM_CDR(x))



long scm_tc16_textmgr;



SCM mark_textmgr(SCM obj)

{

  SCM_SETGC8MARK(obj);

  return SCM_BOOL_F;

}



size_t free_textmgr(SCM obj)

{

  if (TEXTMGR(obj)) {

    TEXTMGR(obj)->foreach(markref);

    TEXTMGR(obj)->hashtable()->foreach(decref);

    delete TEXTMGR(obj);

  }

  return 0;

}



int print_textmgr(SCM obj, SCM port, scm_print_state * pstate)

{

  scm_puts("#<TEXT: ", port);

  scm_puts(TEXTMGR(obj)->filename(), port);

  scm_puts(">", port);

  return 1;

}



SCM textmgr2scm(TextFile* text)

{

  SCM result;

  SCM_NEWCELL(result);

  SCM_SETCAR(result, (SCM) scm_tc16_textmgr);

  SCM_SETCDR(result, (SCM) text);

  return result;

}





SCM_PROC(s_open_text, "open-text", 1, 0, 0, open_text);

SCM open_text(SCM name)

{

  SCM txt;

  if (scm_string_p(name) != SCM_BOOL_T)

    scm_wrong_type_arg(s_open_text, 1, name);

  txt = textmgr2scm(new TextFile(SCM_CHARS(name)));

  TEXTMGR(txt)->foreach(markref);

  TEXTMGR(txt)->hashtable()->foreach(incref);

  return txt;

}



SCM_PROC(s_append_text, "append-text", 2, 0, 0, append_text);

SCM append_text(SCM obj, SCM name)

{

  if (!TEXTMGRP(obj))

    scm_wrong_type_arg(s_append_text, 1, obj);

  if (!TEXTMGR(obj))

    scm_misc_error(s_append_text, "Text object is empty", SCM_EOL);

  if (scm_string_p(name) != SCM_BOOL_T)

    scm_wrong_type_arg(s_append_text, 2, name);

  TEXTMGR(obj)->foreach(markref);

  TEXTMGR(obj)->hashtable()->foreach(decref);

  TEXTMGR(obj)->append(SCM_CHARS(name));

  TEXTMGR(obj)->foreach(markref);

  TEXTMGR(obj)->hashtable()->foreach(incref);

  return obj;

}



SCM_PROC(s_close_text, "close-text", 1, 0, 0, close_text);

SCM close_text(SCM obj)

{

  if (!TEXTMGRP(obj))

    scm_wrong_type_arg(s_close_text, 1, obj);

  if (TEXTMGR(obj)) {

    scm_gc();

    TEXTMGR(obj)->foreach(markref);

    TEXTMGR(obj)->hashtable()->foreach(decref);

    TEXTMGR(obj)->hashtable()->removeif(delrefp);

    delete TEXTMGR(obj);

    SCM_SETCDR(obj, 0);

  }

  return SCM_UNSPECIFIED;

}



SCM_PROC(s_rewind_text, "rewind-text", 1, 0, 0, rewind_text);

SCM rewind_text(SCM obj)

{

  if (!TEXTMGRP(obj))

    scm_wrong_type_arg(s_rewind_text, 1, obj);

  if (!TEXTMGR(obj))

    scm_misc_error(s_rewind_text, "Text object is empty", SCM_EOL);

  TEXTMGR(obj)->rewind();

  return SCM_UNSPECIFIED;

}



SCM_PROC(s_get_next_word, "get-next-word", 1, 0, 0, get_next_word);

SCM get_next_word(SCM obj)

{

  contain* cn;

  if (!TEXTMGRP(obj))

    scm_wrong_type_arg(s_get_next_word, 1, obj);

  if (!TEXTMGR(obj))

    scm_misc_error(s_get_next_word, "Text object is empty", SCM_EOL);

  cn = TEXTMGR(obj)->getnext();

  if (cn)

    return cn->content;

  else

    return SCM_BOOL_F;

}



SCM_PROC(s_get_word, "get-word", 2, 0, 0, get_word);

SCM get_word(SCM obj, SCM n)

{

  contain* cn;

  if (!TEXTMGRP(obj))

    scm_wrong_type_arg(s_get_word, 1, obj);

  if (!TEXTMGR(obj))

    scm_misc_error(s_get_word, "Text object is empty", SCM_EOL);

  if (scm_integer_p(n) != SCM_BOOL_T)

    scm_wrong_type_arg(s_get_word, 2, n);

  cn = TEXTMGR(obj)->get(gh_scm2int(n));

  if (cn)

    return cn->content;

  else

    return SCM_BOOL_F;

}



SCM_PROC(s_scramble_text, "scramble-text", 1, 0, 0, scramble_text);

SCM scramble_text(SCM obj)

{

  if (!TEXTMGRP(obj))

    scm_wrong_type_arg(s_scramble_text, 1, obj);

  if (!TEXTMGR(obj))

    scm_misc_error(s_scramble_text, "Text object is empty", SCM_EOL);

  return textmgr2scm(TEXTMGR(obj)->scramble());

}



static SCM currentproc = 0;



void iterproc(contain* cn)

{

  gh_call1(currentproc, cn->content);

}



SCM_PROC(s_for_each_word, "for-each-word", 2, 0, 0, for_each_word);

SCM for_each_word(SCM obj, SCM proc)

{

  SCM lastproc = currentproc;

  if (!TEXTMGRP(obj))

    scm_wrong_type_arg(s_for_each_word, 1, obj);

  if (!TEXTMGR(obj))

    scm_misc_error(s_for_each_word, "Text object is empty", SCM_EOL);

  currentproc = proc;

  TEXTMGR(obj)->foreach(iterproc);

  currentproc = lastproc;

  return SCM_UNSPECIFIED;

}



SCM_PROC(s_for_each_unique_word, "for-each-unique-word", 1, 0, 0, 
for_each_unique_word);

SCM for_each_unique_word(SCM proc)

{

  SCM lastproc = currentproc;

  currentproc = proc;

  TextFile::table.foreach(iterproc);

  currentproc = lastproc;

  return SCM_UNSPECIFIED;

}



SCM_PROC(s_lookup_word, "lookup-word", 1, 0, 0, lookup_word);

SCM lookup_word(SCM obj)

{

  contain* cn;

  if (scm_string_p(obj) != SCM_BOOL_T)

    scm_wrong_type_arg(s_lookup_word, 1, obj);

  cn = TextFile::table.get(SCM_CHARS(obj));

  if (cn)

    return cn->content;

  else

    return SCM_BOOL_F;

}



SCM_PROC(s_create_word, "create-word", 0, 0, 1, create_word);

SCM create_word(SCM args)

{

  SCM obj;

  contain* cn;

  if (scm_ilength(args) < 1)

    scm_wrong_num_args(scm_makfrom0str(s_create_word));

  obj = SCM_CAR(args);

  if (scm_string_p(obj) != SCM_BOOL_T)

    scm_wrong_type_arg(s_create_word, 1, obj);

  cn = TextFile::table.insert(SCM_CHARS(obj));

  cn->refcount += 2;

  SCM_SETCDR(cn->content, SCM_CDR(args));

  return cn->content;

}



SCM_PROC(s_check_text_sections, "check-text-sections", 1, 0, 0, 
check_text_sections);

SCM check_text_sections(SCM tag)

{

  if (tag == SCM_BOOL_F) {

    TextFile::CheckNewline = 0;

  } else if (tag == SCM_BOOL_F) {

    TextFile::CheckNewline = 1;

  } else if (scm_string_p(tag) == SCM_BOOL_T) {

    TextFile::CheckNewline = 1;

    TextFile::CheckNewlineResult = strcpy(new char[strlen(SCM_CHARS(tag))], 
SCM_CHARS(tag));

  } else

    scm_wrong_type_arg(s_check_text_sections, 1, tag);

  return SCM_UNSPECIFIED;

}



static SCM globalport;



void csave(contain* cn)

{

  scm_write(cn->content, globalport);

  scm_newline(globalport);

}



SCM cread()

{

  SCM res;

  res = scm_read(globalport);

  if (res == SCM_EOF_VAL || !SCM_CONSP(res) ||

      scm_string_p(SCM_CAR(res)) != SCM_BOOL_T)

    return SCM_BOOL_F;

  else

    return res;

}



SCM_PROC(s_export_words, "export-words", 1, 0, 0, export_words);

SCM export_words(SCM obj)

{

  if (scm_string_p(obj) != SCM_BOOL_T)

    scm_wrong_type_arg(s_export_words, 1, obj);

  globalport = scm_open_file(obj, scm_makfrom0str("w"));

  scm_protect_object(globalport);

  TextFile::table.foreach(csave);

  scm_close_port(globalport);

  scm_unprotect_object(globalport);

  return SCM_UNSPECIFIED;

}



SCM_PROC(s_import_words, "import-words", 1, 0, 0, import_words);

SCM import_words(SCM obj)

{

  SCM ele;

  if (scm_string_p(obj) != SCM_BOOL_T)

    scm_wrong_type_arg(s_import_words, 1, obj);

  globalport = scm_open_file(obj, scm_makfrom0str("r"));

  scm_protect_object(globalport);

  while ((ele = cread()) != SCM_BOOL_F)

    SCM_SETCDR(TextFile::table.insert(SCM_CHARS(SCM_CAR(ele)))->content,

               SCM_CDR(ele));

  scm_close_port(globalport);

  scm_unprotect_object(globalport);

  return SCM_UNSPECIFIED;

}



void init_gltext()

{

  scm_tc16_textmgr = scm_make_smob_type("textmgr", 0);

  scm_set_smob_mark(scm_tc16_textmgr, mark_textmgr);

  scm_set_smob_free(scm_tc16_textmgr, free_textmgr);

  scm_set_smob_print(scm_tc16_textmgr, print_textmgr);

#include "gltext.x"

}



-------------------------------------------------------------------------------------

#include <guile/gh.h>

...



void main2(int argc, char** argv)

{

...



  scm_eval_0str("(define-module (guile) :use-module (ice-9 readline))"); 

  scm_eval_0str("(define-module (guile-user) :use-module (ice-9 readline))"); 

  scm_eval_0str("(activate-readline)"); 

  scm_eval_0str("(set-repl-prompt! \"gsdm> \")");

  scm_shell (argc, argv);

}



int main(int argc, char** argv)

{

  gh_enter(argc, argv, main2);

  return 0;

}

_______________________________________________
Join Excite! - http://www.excite.com
The most personalized portal on the Web!