/* -----------------------------------------------------------------------------
 * See the LICENSE file for information on copyright, usage and redistribution
 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
 *
 * gst.cxx
 *
 * gst language module for SWIG.
 * ----------------------------------------------------------------------------- */

/* rbw */
char cvsroot_gst_cxx[] = "$Header: /cvsroot/swig/SWIG/Source/Modules/gst.cxx,v 1.12 2006/11/28 10:19:50 rbwatson Exp $";

#include "swigmod.h"
#include <ctype.h>
#include <limits.h>

class GST:public Language {
public:
  File *f_st;
  String *module;
  virtual void main(int argc, char *argv[]);
  virtual int top(Node *n);
  virtual int functionWrapper(Node *n);
  virtual int constantWrapper(Node *n);
  virtual int classDeclaration(Node *n);
  virtual int enumDeclaration(Node *n);
private:
  String *get_ffi_type(SwigType *ty);
  String *convert_literal(String *num_param, String *type);
  String *strip_parens(String *string);
  String *camel_case(bool, String *string);
  int extern_all_flag;
  int pseudo_enums_flag;
  int cstructs_flag;
  int is_function;
};

//converted 
void GST::main(int argc, char *argv[]) {
  int i;

  SWIG_library_directory("gst");
  SWIG_config_file("gst.swg");
  extern_all_flag = 0;
  pseudo_enums_flag = 0;
  cstructs_flag = 0;

  for (i = 1; i < argc; i++) {

    if (!strcmp(argv[i], "-help")) {
      Printf(stdout, "gst Options (available with -gst)\n");
      Printf(stdout,
	     " -extern-all\n"
	     "\t If this option is given then gst definitions for all the functions\n"
	     "will be created otherwise only definitions for externed functions\n"
	     "are created.\n"
	     " -generate-pseudo-enums\n"
	     "\t If this option is given then methods will be created for enum\n"
	     "names and values.\n"
	     " -generate-cstructs\n"
	     "\t If this option is given then cstructs will be created.\n");

    } else if ((Strcmp(argv[i], "-extern-all") == 0)) {
      extern_all_flag = 1;
      Swig_mark_arg(i);
    }

    else if ((Strcmp(argv[i], "-generate-pseudo-enums") == 0)) {
      pseudo_enums_flag = 1;
      Swig_mark_arg(i);
    }

    else if ((Strcmp(argv[i], "-generate-cstructs") == 0)) {
      cstructs_flag = 1;
      Swig_mark_arg(i);
    }

  }
}

int GST::top(Node *n) {

  File *f_null = NewString("");
  /* Get the output file name */
  String *outfile = Getattr(n, "outfile");
  String *output_filename;

  module = camel_case(true, Getattr(n, "name"));

  if (!outfile)
    output_filename = outfile;
  else {
    output_filename = NewString("");
    Printf(output_filename, "%s%s.st", SWIG_output_directory(),Getattr(n, "name"));
  }

  f_st = NewFile(output_filename, "w+");

  if (!f_st) {
    FileErrorDisplay(output_filename);
    SWIG_exit(EXIT_FAILURE);
  }

  Swig_register_filebyname("header", f_null);
  Swig_register_filebyname("runtime", f_null);
  Swig_register_filebyname("wrapper", f_null);
  String *header =
      NewStringf
      ("\"This is an automatically generated file. Make changes as you feel are necessary\"\n\"(but remember that if you try to regenerate this file, your changes will be lost.)\" \n\nObject subclass: #%s\n    instanceVariableNames: \'\'\n    classVariableNames: \'\'\n    poolDictionaries: \'\'\n    category: \'%s wrapper\'!\n!\n\nDLD addLibrary: \'+Libraryname\'!\n",
       module, module);

  Language::top(n);
  long len = Tell(f_st);
  Printf(f_st, "%s", header);
  long end = Tell(f_st);

  for (len--; len >= 0; len--) {
    end--;
    Seek(f_st, len, SEEK_SET);
    int ch = Getc(f_st);
    Seek(f_st, end, SEEK_SET);
    Putc(ch, f_st);
  }

  Seek(f_st, 0, SEEK_SET);
  Write(f_st, Char(header), Len(header));
  Close(f_st);
  Delete(f_st);
  return SWIG_OK;
}


int GST::functionWrapper(Node *n) {
  is_function = 1;
  String *storage = Getattr(n, "storage");
  if (!extern_all_flag && (!storage || (Strcmp(storage, "extern") && Strcmp(storage, "externc"))))
    return SWIG_OK;

  String *func_name = Getattr(n, "sym:name");
  ParmList *pl = Getattr(n, "parms");
  int argnum = 0, first = 1;

  //  Printf(f_st, "\n!%s class methodsFor: \'C call-outs\'!\n", module);
  Printf(f_st, "\n%s", camel_case(false, func_name));

  for (Parm *p = pl; p; p = nextSibling(p), argnum++) {
    String *argname = Getattr(p, "name");
    String *ffitype = get_ffi_type(Getattr(p, "type"));
    int tempargname = 0;

    if (!argname) {
      argname = NewStringf("arg%d", argnum);
      tempargname = 1;
    }

    if(first) {
      Printf(f_st, ": a%s%d ", camel_case(true, ffitype), argnum);
      first = 0;
    }
    else {
      Printf(f_st, "%s: a%s%d ", camel_case(false, argname), camel_case(true, ffitype), argnum);
    }
    
    Delete(ffitype);

    if (tempargname)
      Delete(argname);
  }

  Printf(f_st, "\n    <cCall: \'%s\' returning: #", func_name);
  String *ffitype = get_ffi_type(Getattr(n, "type"));

  if (Strcmp(ffitype, "NIL")) {	//when return type is not nil
    Printf(f_st, "%s ", ffitype);
  }
  else {
    Printf(f_st, "void ");
  }

  Printf(f_st, "\n        args: #(");

  for (Parm *p = pl; p; p = nextSibling(p), argnum++) {
    String *ffitype = get_ffi_type(Getattr(p, "type"));
    Printf(f_st, "#%s ",  ffitype);
    Delete(ffitype);
  }

  Printf(f_st, " )>!\n");
  return SWIG_OK;
}

int GST::constantWrapper(Node *n) {
  is_function = 0;
  String *type = Getattr(n, "type");
  String *converted_value = convert_literal(Getattr(n, "value"), type);
  String *name = Getattr(n, "sym:name");

  //  Printf(f_st, "\n!%s class methodsFor: 'Constants'!\n", module);
  Replace(converted_value, "\"", "\'", DOH_REPLACE_ANY);
  Printf(f_st, "\n%s\n    ^%s!\n", camel_case(false, name), converted_value);
  Delete(converted_value);
  return SWIG_OK;
}

int GST::enumDeclaration(Node *n) {
  is_function = 0;
  int count = 0;

  if(!pseudo_enums_flag)
    return SWIG_OK;

  //  Printf(f_st, "\n!%s class methodsFor: 'Constants'!\n", module);
  Printf(f_st, "\n\"Start enum analogue\"\n");    

  for (Node *c = firstChild(n); c; c = nextSibling(c)) {
    String *slot_name = Getattr(c, "name");
    String *slot_value = Getattr(c, "enumvalue");
    int len = Len(slot_value);

    if(len == 0) {
      Printf(f_st, "\n%s\n    ^%d!\n", camel_case(false, slot_name), count);
      ++count;
    } else {
      Printf(f_st, "\n%s\n    ^$%s!\n", camel_case(false, slot_name), slot_value);
    }

    Delete(slot_name);
    Delete(slot_value);
  }

  Printf(f_st, "\n\"End enum analogue\"\n");  
  return SWIG_OK;
}

// Includes structs
int GST::classDeclaration(Node *n) {
  is_function = 0;

  if(!cstructs_flag)
    return SWIG_OK;

  String *name = Getattr(n, "sym:name");
  String *kind = Getattr(n, "kind");

  if (Strcmp(kind, "struct")) {
    Printf(stderr, "Don't know how to deal with %s kind of class yet.\n", kind);
    Printf(stderr, " (name: %s)\n", name);
  //SWIG_exit(EXIT_FAILURE);
  }


  Printf(f_st, "\nCStruct subclass: #%s\n", camel_case(true, name));
  Printf(f_st, "    declaration: #(");

  for (Node *c = firstChild(n); c; c = nextSibling(c)) {

    if (Strcmp(nodeType(c), "cdecl")) {
      Printf(stderr, "Structure %s has a slot that we can't deal with.\n", name);
      Printf(stderr, "nodeType: %s, name: %s, type: %s\n", nodeType(c), Getattr(c, "name"), Getattr(c, "type"));
      //SWIG_exit(EXIT_FAILURE);
      Printf(f_st, ")>!\n");
      return SWIG_OK; /* xxx */
    }

    String *temp = Copy(Getattr(c, "decl"));
    Append(temp, Getattr(c, "type"));	//appending type to the end, otherwise wrong type
    String *lisp_type = get_ffi_type(temp);
    Delete(temp);

    String *slot_name = Getattr(c, "sym:name");
    Printf(f_st, "\n        (#%s #%s)", camel_case(false, slot_name), lisp_type);
    Delete(lisp_type);  
  }

  Printf(f_st, ")\n");
  Printf(f_st, "    classVariableNames: \'\'\n");
  Printf(f_st, "    poolDictionaries: \'\'\n");
  Printf(f_st, "    category: \'%s Wrapper\'!\n", camel_case(true, name));
  
return SWIG_OK;
}

/* utilities */
/* returns new string w/ parens stripped */
String *GST::strip_parens(String *string) {
  char *s = Char(string), *p;
  int len = Len(string);
  String *res;

  if (len == 0 || s[0] != '(' || s[len - 1] != ')') {
    return NewString(string);
  }

  p = (char *) malloc(len - 2 + 1);

  if (!p) {
    Printf(stderr, "Malloc failed\n");
    SWIG_exit(EXIT_FAILURE);
  }

  strncpy(p, s + 1, len - 1);
  p[len - 2] = 0;		/* null terminate */

  res = NewString(p);
  free(p);
  return res;
}

/* returns a camel-case string */
String *GST::camel_case(bool isclass, String *string) {
  char *s = Char(Swig_string_lower(string)), *p;
  String *cb;
  int i = 0, j = 0, hump = 0;

  p = (char *) malloc(Len(string) + 1);

  if (!p) {
    Printf(stderr, "Malloc failed\n");
    SWIG_exit(EXIT_FAILURE);
  }

  for( ; s[i]; i++ ) {

    if(s[i] == '_') {
      hump = 1;
    } else {
      if(hump) {
	p[j] = toupper(s[i]);
	hump = 0;
      }
      else {
	p[j] = s[i];
      }
      j++;
    }
  }
  p[j] = '\0';

  if(isclass == true)
    p[0] = toupper(p[0]);
  else
    p[0] = tolower(p[0]);

  cb = NewString(p);
  free(p);
  return cb;
}

String *GST::convert_literal(String *num_param, String *type) {
  String *num = strip_parens(num_param), *res;
  char *s = Char(num);

  /* Make sure doubles use 'd' instead of 'e' */
  if (!Strcmp(type, "double")) {
    String *updated = Copy(num);

    if (Replace(updated, "e", "d", DOH_REPLACE_ANY) > 1) {
      Printf(stderr, "Weird!! number %s looks invalid.\n", num);
      SWIG_exit(EXIT_FAILURE);
    }

    Delete(num);
    return updated;
  }

  if (SwigType_type(type) == T_CHAR) {
    /* Use GST syntax for character literals */
    return NewStringf("$%s", num_param);
  } else if (SwigType_type(type) == T_STRING) {
    /* Use GST syntax for string literals */
    return NewStringf("\'%s\'", num_param);
  }

  if (Len(num) < 2 || s[0] != '0') {
    return num;
  }

  /* octal or hex */
  res = NewStringf("%s%s", s[1] == 'x' ? "16r" : "8r", s + 2);
  Delete(num);
  return res;
}

String *GST::get_ffi_type(SwigType *ty) {
  Hash *typemap = Swig_typemap_search("in", ty, "", 0);

  if (typemap) {
    String *typespec = Getattr(typemap, "code");
    return NewString(typespec);
  } else if (SwigType_ispointer(ty)) {
    SwigType *cp = Copy(ty);
    SwigType_del_pointer(cp);
    String *inner_type = get_ffi_type(cp);

    if (SwigType_isfunction(cp)) {
      return inner_type;
    }

    String *str = NewStringf("cObject");

    Delete(cp);
    Delete(inner_type);
    return str;
  } else if (SwigType_isarray(ty)) {
    SwigType *cp = Copy(ty);
    String *array_dim = SwigType_array_getdim(ty, 0);

    if (!Strcmp(array_dim, "")) {	//dimension less array convert to pointer
      Delete(array_dim);
      SwigType_del_array(cp);
      SwigType_add_pointer(cp);
      String *str = get_ffi_type(cp);
      Delete(cp);
      return str;
    } else {
      SwigType_pop_arrays(cp);
      String *inner_type = get_ffi_type(cp);
      Delete(cp);

      int ndim = SwigType_array_ndim(ty);
      String *dimension;

      if (ndim == 1) {
	dimension = array_dim;
      } else {
	dimension = array_dim;

	for (int i = 1; i < ndim; i++) {
	  array_dim = SwigType_array_getdim(ty, i);
	  Append(dimension, " ");
	  Append(dimension, array_dim);
	  Delete(array_dim);
	}

	String *temp = dimension;
	dimension = NewStringf("(%s)", dimension);
	Delete(temp);
      }

      String *str;

      if (is_function)
	// str = NewStringf("(ffi:c-ptr (ffi:c-array %s %s))", inner_type, dimension);
      	str = NewStringf("cObject");
      else
	// str = NewStringf("(ffi:c-array %s %s)", inner_type, dimension);
	str = NewStringf("cObjectPtr");

      Delete(inner_type);
      Delete(dimension);
      return str;
    }
  } else if (SwigType_isfunction(ty)) {
    SwigType *cp = Copy(ty);
    SwigType *fn = SwigType_pop_function(cp);
    String *args = NewString("");
    ParmList *pl = SwigType_function_parms(fn);

    if (ParmList_len(pl) != 0) {
      Printf(args, "(:arguments ");
    }

    int argnum = 0, first = 1;

    for (Parm *p = pl; p; p = nextSibling(p), argnum++) {
      String *argname = Getattr(p, "name");
      SwigType *argtype = Getattr(p, "type");
      String *ffitype = get_ffi_type(argtype);
      int tempargname = 0;

      if (!argname) {
	argname = NewStringf("arg%d", argnum);
	tempargname = 1;
      }

      if (!first) {
	Printf(args, "\n\t\t");
      }

      Printf(args, "(%s %s)", argname, ffitype);
      first = 0;
      Delete(ffitype);

      if (tempargname)
	Delete(argname);
    }

    if (ParmList_len(pl) != 0) {
      Printf(args, ")\n");	/* finish arg list */
    }

    String *ffitype = get_ffi_type(cp);
    String *str = NewStringf("(ffi:c-function %s \t\t\t\t(:return-type %s))", args, ffitype);
    Delete(fn);
    Delete(args);
    Delete(cp);
    Delete(ffitype);
    return str;
  }

  String *str = SwigType_str(ty, 0);

  if (str) {
    char *st = Strstr(str, "struct");

    if (st) {
      st += 7;
      return NewString(st);
    }

    char *cl = Strstr(str, "class");

    if (cl) {
      cl += 6;
      return NewString(cl);
    }

  }
  return str;
}

extern "C" Language *swig_gst(void) {
  return new GST();
}