Exemple #1
0
/**
 * This method will check an array of strings for misspelled words.
 * This method needs a block to work proper. Each misspelled word is yielded,
 * a correct word as result from the block is assumed.
 * Common use:
 * 
 * a = Aspell.new(...)
 * text = ...
 * a.correct_lines(text) { |badword|
 *    puts "Error: #{badword}\n"
 *    puts a.suggest(badword).join(" | ")
 *    gets #the input is returned as right word
 * }
 * 
 * @param ary the array of strings to check.
 * @result an array holding all lines with corrected words.
 */
static VALUE aspell_correct_lines(VALUE self, VALUE ary) {
    VALUE result = ary;
    if (rb_block_given_p()) {
        //create checker
        AspellSpeller *speller = get_speller(self);
        AspellDocumentChecker * checker = get_checker(speller);
        AspellToken token;
        //some tmp values
        VALUE vline, sline;
        VALUE word, rword;
        char *line;
        int count=RARRAY_LEN(ary);
        int c=0;
        //create new result array
        result = rb_ary_new();
        //iterate over array
        while(c<count) {
            int offset=0;
            //fetch line
            vline = RARRAY_PTR(ary)[c];
            //save line
            sline = rb_funcall(vline, rb_intern("dup"), 0);
            //c representation
            line = STR2CSTR(vline);
            //process line
            aspell_document_checker_process(checker, line, -1);
            //iterate over all misspelled words
            while (token = aspell_document_checker_next_misspelling(checker), token.len != 0) {
                //extract word by start/length qualifier
                word = rb_funcall(vline, rb_intern("[]"), 2, INT2FIX(token.offset), INT2FIX(token.len));
                //get the right word from the block
                rword = rb_yield(word);
                //nil -> do nothing
                if(rword == Qnil) continue;
                //check for string
                if (TYPE(rword) != T_STRING) rb_raise(cAspellError, "%s", "Need a String to substitute");
                //chomp the string
                rb_funcall(rword, rb_intern("chomp!"), 0);
                //empty string -> do nothing
                if(strlen(STR2CSTR(rword)) == 0) continue;
                //remember word for later suggestion
                aspell_speller_store_replacement(speller, STR2CSTR(word), -1, STR2CSTR(rword), -1);
                //substitute the word by replacement
                rb_funcall(sline, rb_intern("[]="), 3, INT2FIX(token.offset+offset), INT2FIX(token.len), rword);
                //adjust offset
                offset += strlen(STR2CSTR(rword))-strlen(STR2CSTR(word));
                //printf("replace >%s< with >%s< (offset now %d)\n", STR2CSTR(word), STR2CSTR(rword), offset);
            }
            //push the substituted line to result
            rb_ary_push(result, sline);
            c++;
        }
        //free checker
        delete_aspell_document_checker(checker);
    } else {
        rb_raise(cAspellError, "%s", "No block given. How to correct?");
    }
    return result;
}
Exemple #2
0
//
// function to count the number of events for which amplitudes were generated.
//
//
VALUE count_amps(VALUE __self, VALUE __file_name){
  char *filename = STR2CSTR(__file_name);
  ifstream in_file;
  in_file.open(filename);
  int event = 0;
  complex<float> amp;

  while(!in_file.eof()){
    event++;
    in_file.read((char*)&amp,sizeof(amp));
  }
  return rb_int_new(event-1);
}
Exemple #3
0
static const gsl_rng_type* get_gsl_rng_type(VALUE t)
{
  switch (TYPE(t)) {
  case T_STRING:
    return get_gsl_rng_type_name(STR2CSTR(t));
    break;
  case T_FIXNUM:
    return get_gsl_rng_type_int(FIX2INT(t));
    break;
  default:
    rb_raise(rb_eTypeError, "String or Fixnum expected");
  }
}
Exemple #4
0
/**
 * Simple utility function to correct a file.
 * The file gets read, content will be checked and write back.
 * Please note: This method will change the file! - no backup and of course: no warranty!
 * @param filename the name of the file as String.
 * @exception Exception due to lack of read/write permissions.
 */
static VALUE aspell_correct_file(VALUE self, VALUE filename) {
    if (rb_block_given_p()) {
        VALUE content = rb_funcall(rb_cFile, rb_intern("readlines"), 1, filename);
        VALUE newcontent = aspell_correct_lines(self, content);
        VALUE file = rb_file_open(STR2CSTR(filename), "w+");
        rb_funcall(file, rb_intern("write"), 1, newcontent);
        rb_funcall(file, rb_intern("close"), 0);
    } else {
        rb_raise(cAspellError, "%s", "No block given. How to correct?");
    }
    return self;

}
Exemple #5
0
static VALUE rb_gsl_permutation_printf(int argc, VALUE *argv, VALUE obj)
{
  gsl_permutation *h;
  int status;

  Data_Get_Struct(obj, gsl_permutation, h);
  if (argc == 0) {
    status = gsl_permutation_fprintf(stdout, h, "%u\n");
  } else {
    Check_Type(argv[0], T_STRING);
    status = gsl_permutation_fprintf(stdout, h, STR2CSTR(argv[0]));
  }
  return INT2FIX(status);
}
// service.setCustomThemes(regexps)
// @param regexps string
// @return nil
static VALUE wrap_ma_set_custom_themes(VALUE self, VALUE vstring) {
  const char *cstring;
  geoword::MAPtr *pServicePtr;
  Data_Get_Struct(self, geoword::MAPtr, pServicePtr);

  Check_Type(vstring, T_STRING);
  cstring = STR2CSTR(vstring);
  if (*cstring != '\0') {
    (*pServicePtr)->setCustomThemes(cstring);
  } else {
    (*pServicePtr)->resetCustomThemes();
  }
  return Qnil;
}
Exemple #7
0
VALUE rb_luxiobtree_get(VALUE self, VALUE _key)
{
    LuxIO *ptr;
    Data_Get_Struct(self, LuxIO, ptr);

    char *key = STR2CSTR(_key);
    Lux::IO::data_t lux_key = {key, strlen(key)};
    Lux::IO::data_t *lux_val = ptr->bt->get(&lux_key);

    if (lux_val) {
        return rb_str_new2((char *)lux_val->data);
    }
    return Qnil;
}
Exemple #8
0
VALUE rb_luxiobtree_open(VALUE self, VALUE _filename, VALUE _flag)
{
    LuxIO *ptr;
    Data_Get_Struct(self, LuxIO, ptr);

    char *filename = STR2CSTR(_filename);
    int flag = NUM2INT(_flag);

    ptr->bt = new Lux::IO::Btree(Lux::IO::CLUSTER);
    if (ptr->bt->open(filename, flag)){
        return Qtrue;
    }
    return Qnil;
}
Exemple #9
0
VALUE
rb_yp_match(VALUE self, VALUE domain, VALUE map, VALUE inkey)
{
    int res;
    char *val;
    int vallen;

    if( domain == Qnil ) {
        domain = rb_yp_get_default_domain(self);
    };

    res = yp_match(STR2CSTR(domain), STR2CSTR(map),
                   STR2CSTR(inkey), RSTRING(inkey)->len,
                   &val, &vallen);
    rb_yp_check_yperr(res);

    if( vallen > 0 ) {
        return rb_tainted_str_new(val, vallen);
    }
    else {
        return Qnil;
    };
};
Exemple #10
0
/**
 * Ctor for aspell objects:
 * Aspell.new(language, jargon, size, encoding)
 * Please note: All parameters are optional. If a parameter is omitted, a default value is assumed from
 *              the environment (eg lang from $LANG). To retain default values, you can use nil
 *              as value: to set only size: Aspell.new(nil, nil, "80")
 * @param language ISO639 language code plus optional ISO 3166 counry code as string (eg: "de" or "us_US")
 * @param jargon a special jargon of the selected language
 * @param size the size of the dictionary to chose (if there are options)
 * @param encoding the encoding to use
 * @exception Exception if the specified dictionary is not found.
 */
static VALUE aspell_s_new(int argc, VALUE *argv, VALUE klass) {
    VALUE vlang, vjargon, vsize, vencoding;
    const char *tmp;
    //aspell values
    AspellCanHaveError * ret;
    AspellSpeller * speller;
    AspellConfig * config;

    //create new config
    config = new_aspell_config();

    //extract values
    rb_scan_args(argc, argv, "04", &vlang, &vjargon, &vsize, &vencoding);

    //language:
    if (RTEST(vlang)) set_option(config, "lang", STR2CSTR(vlang));
    //jargon:
    if (RTEST(vjargon)) set_option(config, "jargon", STR2CSTR(vjargon));
    //size:
    if (RTEST(vsize)) set_option(config, "size", STR2CSTR(vsize));
    //encoding:
    if (RTEST(vencoding)) set_option(config, "encoding", STR2CSTR(vencoding));

    //create speller:
    ret = new_aspell_speller(config);
    delete_aspell_config(config);
    if (aspell_error(ret) != 0) {
        tmp = strdup(aspell_error_message(ret));
        delete_aspell_can_have_error(ret);
        rb_raise(cAspellError, "%s", tmp);
    }

    speller = to_aspell_speller(ret);

    //wrap pointer
    return Data_Wrap_Struct(klass, 0, aspell_free, speller);
}
Exemple #11
0
static VALUE connectionToString(VALUE self)

{

   VALUE            result      = rb_str_new2("(CLOSED)");

   ConnectionHandle *connection = NULL;

   

   Data_Get_Struct(self, ConnectionHandle, connection);

   if(connection->handle != 0)

   {

      VALUE database = rb_iv_get(self, "@database"),

            user     = rb_iv_get(self, "@user"),

            file     = rb_iv_get(database, "@file");

      char  text[256];

      

      sprintf(text, "%s@%s (OPEN)", STR2CSTR(user), STR2CSTR(file));

      result = rb_str_new2(text);

   }

   

   return(result);

}
Exemple #12
0
static const gsl_odeiv_step_type* rb_gsl_odeiv_step_type_get(VALUE tt)
{
  const gsl_odeiv_step_type *T;
  int type;
  char name[64];
  switch (TYPE(tt)) {
  case T_FIXNUM:
    type = FIX2INT(tt);
    switch (type) {
    case GSL_ODEIV_STEP_RK2: T = gsl_odeiv_step_rk2; break;
    case GSL_ODEIV_STEP_RK4: T = gsl_odeiv_step_rk4; break;
    case GSL_ODEIV_STEP_RKF45: T = gsl_odeiv_step_rkf45; break;
    case GSL_ODEIV_STEP_RKCK: T = gsl_odeiv_step_rkck; break;
    case GSL_ODEIV_STEP_RK8PD: T = gsl_odeiv_step_rk8pd; break;
    case GSL_ODEIV_STEP_RK2IMP: T = gsl_odeiv_step_rk2imp; break;
    case GSL_ODEIV_STEP_RK4IMP: T = gsl_odeiv_step_rk4imp; break;
    case GSL_ODEIV_STEP_BSIMP: T = gsl_odeiv_step_bsimp; break;
    case GSL_ODEIV_STEP_GEAR1: T = gsl_odeiv_step_gear1; break;
    case GSL_ODEIV_STEP_GEAR2: T = gsl_odeiv_step_gear2; break;
    case GSL_ODEIV_STEP_RK2SIMP: T = gsl_odeiv_step_rk2simp; break;
    default:
      rb_raise(rb_eArgError, "wrong argument type (Fixnum expected)");
      break;
    }
    break;
  case T_STRING:
    strcpy(name, STR2CSTR(tt));
    if (str_tail_grep(name, "rk2") == 0) T = gsl_odeiv_step_rk2;
    else if (str_tail_grep(name, "rk4") == 0) T = gsl_odeiv_step_rk4;
    else if (str_tail_grep(name, "rkf45") == 0) T = gsl_odeiv_step_rkf45;
    else if (str_tail_grep(name, "rkck") == 0) T = gsl_odeiv_step_rkck;
    else if (str_tail_grep(name, "rk8pd") == 0) T = gsl_odeiv_step_rk8pd;
    else if (str_tail_grep(name, "rk2imp") == 0) T = gsl_odeiv_step_rk2imp;
    else if (str_tail_grep(name, "rk4imp") == 0) T = gsl_odeiv_step_rk4imp;
    else if (str_tail_grep(name, "bsimp") == 0) T = gsl_odeiv_step_bsimp;
    else if (str_tail_grep(name, "gear1") == 0) T = gsl_odeiv_step_gear1;
    else if (str_tail_grep(name, "gear2") == 0) T = gsl_odeiv_step_gear2;
    else if (str_tail_grep(name, "rk2simp") == 0) T = gsl_odeiv_step_rk2simp;
    else {
      rb_raise(rb_eArgError, "wrong argument type %s", name);
    }
    break;
  default:
    rb_raise(rb_eArgError, "wrong argument type %s (String or Fixnum expected)",
             rb_class2name(CLASS_OF(tt)));
    break;
  }
  return T;
}
Exemple #13
0
static VALUE proj_initialize(VALUE self, VALUE proj_params){
  _wrap_pj* wpj;
  int size = RARRAY(proj_params)->len; 
  char** c_params = (char **) malloc(size*sizeof(char *));
  VALUE *ptr = RARRAY(proj_params)->ptr; 
  int i;
  for (i=0; i < size; i++, ptr++)
    c_params[i]= STR2CSTR(*ptr); 
  Data_Get_Struct(self,_wrap_pj,wpj);
  wpj->pj = pj_init(size,c_params);
  if(wpj->pj == 0)
    rb_raise(rb_eArgError,"invalid initialization parameters");
  free(c_params);
  return self;
}
// service.getGeowordEntries(str)
// @param str string
// @return array of Geoword
static VALUE wrap_ma_get_geoword_entries(VALUE self, VALUE vstring) {
  const char *cstring;
  geoword::MAPtr *pServicePtr;
  Data_Get_Struct(self, geoword::MAPtr, pServicePtr);

  Check_Type(vstring, T_STRING);
  cstring = STR2CSTR(vstring);
  std::map<ID, geoword::Geoword> geowords = (*pServicePtr)->getGeowordEntries(cstring);

  VALUE rb_geowords = rb_hash_new();
  for (std::map<ID, geoword::Geoword>::iterator it = geowords.begin(); it != geowords.end(); it++) {
    rb_hash_aset(rb_geowords, INT2FIX((*it).first), _geoword_to_ruby_hash(&((*it).second)));
  }
  return rb_geowords;
}
Exemple #15
0
VALUE rh_new(VALUE tds_socket, VALUE sqlstring)
{
 VALUE oSybRes;
 SYBRESULT *sybres;

 sybres = ALLOC(SYBRESULT);
 Data_Get_Struct(tds_socket, TDSSOCKET, sybres->tds);
 sybres->sqlstring=STR2CSTR(sqlstring);

 oSybRes = Data_Wrap_Struct(cResultHandle, 0, rh_free, sybres);
 
 rb_obj_call_init(oSybRes, 0, 0);
 
 return oSybRes;
} // rh_new
Exemple #16
0
/* This functions is used as a predicate function. Every function name
for which it returns true will be removed from the blank object
dictionary.
*/
VALUE blank_undef_if(VALUE name, VALUE klass)
{
	VALUE mname = rb_funcall(name, rb_intern("to_s"), 0);
	VALUE methodRe = rb_str_new2("(?:^__)|(?:\\?$)|(?:^send$)|(?:^class$)");
	
	if(rb_funcall(mname, rb_intern("match"), 1, methodRe) == Qnil)
	{
		rb_undef_method(klass, STR2CSTR(mname));
		return Qtrue;
	}
	else
	{
		return Qfalse;
	}
}
Exemple #17
0
PyObject* rtopString(VALUE rString)
{

	PyObject* pString;
	char* cString;
	char* cStringCopy;

	cString = STR2CSTR(rString);
	cStringCopy = malloc(strlen(cString) * sizeof(char));
	strcpy(cStringCopy, cString);

	pString = PyString_FromString(cStringCopy);

	return pString;
}
Exemple #18
0
static VALUE lorcon_device_open(int argc, VALUE *argv, VALUE self) {
	struct rldev *rld;
	int ret = 0;
	int drivertype = INJ_NODRIVER;
	char *driver, *intf;
	VALUE rbdriver, rbintf;
	VALUE obj;

	rb_scan_args(argc, argv, "2", &rbintf, &rbdriver);
	
	driver = STR2CSTR(rbdriver);
	intf   = STR2CSTR(rbintf);

	obj = Data_Make_Struct(cDevice, struct rldev, 0, lorcon_device_free, rld);

	drivertype = tx80211_resolvecard(driver);
	if (drivertype == INJ_NODRIVER) {
		rb_raise(rb_eArgError, "Lorcon did not recognize the specified driver");
		return(Qnil);
	}
	
	if (tx80211_init(&rld->in_tx, intf, drivertype) < 0) {
		rb_raise(rb_eRuntimeError, "Lorcon could not initialize the interface: %s", tx80211_geterrstr(&rld->in_tx));
		return(Qnil);
	}

	/* Open the interface to get a socket */
	ret = tx80211_open(&rld->in_tx);
	if (ret < 0) {
		rb_raise(rb_eRuntimeError, "Lorcon could not open the interface: %s", tx80211_geterrstr(&rld->in_tx));
		return(Qnil);
	}	

	rb_obj_call_init(obj, 0, 0);	
	return(obj);
}
Exemple #19
0
static VALUE rb_gsl_object_info(VALUE obj)
{
  char buf[256];
  VALUE s;
  sprintf(buf, "Class:      %s\n", rb_class2name(CLASS_OF(obj)));
#ifdef RUBY_1_9_LATER
  sprintf(buf, "%sSuperClass: %s\n", buf, rb_class2name(RCLASS_SUPER(CLASS_OF(obj))));
#else
  sprintf(buf, "%sSuperClass: %s\n", buf, rb_class2name(RCLASS(CLASS_OF(obj))->super));
#endif
  s = rb_rescue(rb_gsl_call_name, obj, rb_gsl_call_rescue, obj);
  if (s) sprintf(buf, "%sType:       %s\n", buf, STR2CSTR(s));
  s = rb_rescue(rb_gsl_call_size, obj, rb_gsl_call_rescue, obj);
  if (s) sprintf(buf, "%sSize:       %d\n", buf, (int) FIX2INT(s));
  return rb_str_new2(buf);
}
Exemple #20
0
static VALUE rb_gsl_combination_printf(int argc, VALUE *argv, VALUE obj)
{
  gsl_combination *h = NULL;
  int status;
  Data_Get_Struct(obj, gsl_combination, h);
  switch (argc) {
  case 0:
    status = gsl_combination_fprintf(stdout, h, "%u\n");
    break;
  default:
    Check_Type(argv[0], T_STRING);
    status = gsl_combination_fprintf(stdout, h, STR2CSTR(argv[0]));
    break;
  }
  return INT2FIX(status);
}
Exemple #21
0
/*
 * PhysicsFS::File#write buffer, obj_size, num_objects
 *
 * return nil on failure or number of objects written.
 */
VALUE physfs_file_write (VALUE self, VALUE buf, VALUE objSize, VALUE objCount)
{
    int result;
    PHYSFS_File *file;

    Data_Get_Struct (self, PHYSFS_File, file);
    if (file == 0)
	return Qnil;

    result = PHYSFS_write (file, STR2CSTR(buf), 
                           FIX2UINT(objSize), FIX2UINT(objCount));
    if (result == -1)
        return Qnil;

    return INT2FIX(result);
}
Exemple #22
0
static VALUE dh_do(VALUE self, VALUE sqlstring)
{
 TDSSOCKET *tds;

 Data_Get_Struct(rb_iv_get(self, "@tds_socket"), TDSSOCKET, tds);

 if(tds_submit_query(tds,STR2CSTR(sqlstring)) != TDS_SUCCEED)
 {
  rb_raise(rb_eRuntimeError, "SQL-query failed (1)");
 }
  else
 {
  process_results(tds);
 }

 return Qnil;
} // dh_do
Exemple #23
0
static VALUE dh_init(int argc, VALUE* argv, VALUE self)
{
 VALUE db_user,
       db_pass,
       db_args,
       db_name,
       db_host,
       tds_socket;

 TDSSOCKET *tds;
        
 /* Let's fill our variables... */
       
 rb_scan_args(argc, argv, "2*", &db_user, &db_pass, &db_args);
 
 db_args = rb_ary_shift(db_args);

 if(db_args != Qnil)
 {
  db_args = rb_str_split(db_args, ":");
  db_name = rb_ary_entry(db_args, 0);
  db_host = rb_ary_entry(db_args, 1);
 }
 
 if(db_host == Qnil) { db_host = rb_str_new2("localhost"); }
  
 /* Get a TDSSOCKET */ 
 tds_socket = tdss_new(db_host, db_user, db_pass);
 rb_iv_set(self, "@tds_socket", tds_socket);
 Data_Get_Struct(tds_socket, TDSSOCKET, tds);

 /* If the user submited a database-name, change to it */ 
 if(db_name != Qnil)
 {
  if(tds_submit_query(tds,STR2CSTR(rb_str_concat(rb_str_new2("USE "), db_name))) != TDS_SUCCEED)
  {
   rb_raise(rb_eRuntimeError, "SQL-USE failed (1)");
  }
  else
  {
   process_results(tds);
  } 
 }
   
 return self;
} // dh_init
Exemple #24
0
const gsl_interp_type* get_interp_type(VALUE t)
{
  int type;
  char name[32];
  switch (TYPE(t)) {
  case T_FIXNUM:
    type = FIX2INT(t);
    switch (type) {
    case GSL_INTERP_LINEAR: return gsl_interp_linear; break;
#ifdef GSL_1_1_LATER
    case GSL_INTERP_POLYNOMIAL: return gsl_interp_polynomial; break;
#endif
    case GSL_INTERP_CSPLINE: return gsl_interp_cspline; break;
    case GSL_INTERP_CSPLINE_PERIODIC: return gsl_interp_cspline_periodic; break;
    case GSL_INTERP_AKIMA: return gsl_interp_akima; break;
    case GSL_INTERP_AKIMA_PERIODIC: return gsl_interp_akima_periodic; break;
    default:
      rb_raise(rb_eTypeError, "unknown type %d\n", type);
      break;
    }
    break;
  case T_STRING:
    strcpy(name, STR2CSTR(t));
    if (str_tail_grep(name, "linear") == 0) {
      return gsl_interp_linear;
#ifdef GSL_1_1_LATER
    } else if (str_tail_grep(name, "polynomial") == 0) {
      return gsl_interp_polynomial;
#endif
    } else if (str_tail_grep(name, "cspline") == 0) {
      return gsl_interp_cspline;
    } else if (str_tail_grep(name, "cspline_periodic") == 0) {
      return gsl_interp_cspline_periodic;
    } else if (str_tail_grep(name, "akima") == 0) {
      return gsl_interp_akima;
    } else if (str_tail_grep(name, "akima_periodic") == 0) {
      return gsl_interp_akima_periodic;
    } else {
      rb_raise(rb_eTypeError, "Unknown type");
    }
    break;
  default:
    rb_raise(rb_eTypeError, "Unknown type");
    break;
  }
}
Exemple #25
0
static const gsl_multimin_fdfminimizer_type* get_fdfminimizer_type(VALUE t)
{
  char name[64];
  switch (TYPE(t)) {
  case T_STRING:
    strcpy(name, STR2CSTR(t));
    if (str_tail_grep(name, "conjugate_fr") == 0) 
      return gsl_multimin_fdfminimizer_conjugate_fr;
    else if (str_tail_grep(name, "conjugate_pr") == 0) 
      return gsl_multimin_fdfminimizer_conjugate_pr;
    else if (str_tail_grep(name, "vector_bfgs") == 0) 
      return gsl_multimin_fdfminimizer_vector_bfgs;
    else if (str_tail_grep(name, "steepest_descent") == 0) 
      return gsl_multimin_fdfminimizer_steepest_descent;
#ifdef GSL_1_9_LATER
    else if (str_tail_grep(name, "vector_bfgs2") == 0) 
      return gsl_multimin_fdfminimizer_vector_bfgs2;
#endif
    else
      rb_raise(rb_eTypeError, "%s: unknown minimizer type", name);
    break;
  case T_FIXNUM:
    switch (FIX2INT(t)) {
    case GSL_FDFMINIMIZER_CONJUGATE_FR:
      return gsl_multimin_fdfminimizer_conjugate_fr; break;
    case GSL_FDFMINIMIZER_CONJUGATE_PR:
      return gsl_multimin_fdfminimizer_conjugate_pr; break;
    case GSL_FDFMINIMIZER_VECTOR_BFGS:
      return gsl_multimin_fdfminimizer_vector_bfgs; break;
    case GSL_FDFMINIMIZER_STEEPEST_DESCENT:
      return gsl_multimin_fdfminimizer_steepest_descent; break;
#ifdef GSL_1_9_LATER
    case GSL_FDFMINIMIZER_VECTOR_BFGS2:
      return gsl_multimin_fdfminimizer_vector_bfgs2; break;
#endif      
    default:
      rb_raise(rb_eTypeError, "%d: unknown type", FIX2INT(t));
      break;
    }
    break;
  default:
    rb_raise(rb_eTypeError, "type is given by a String or a Fixnum");
    break;
  }
}
static VALUE with_image(VALUE self, VALUE _input) {
  char * input = STR2CSTR(_input);

        FREE_IMAGE_FORMAT fif = FIF_UNKNOWN; 

        fif = FreeImage_GetFileType(input, 0); 
        if (fif == FIF_UNKNOWN) fif = FreeImage_GetFIFFromFilename(input); 
        if ((fif != FIF_UNKNOWN) && FreeImage_FIFSupportsReading(fif)) { 
          FIBITMAP *bitmap;
          VALUE result = Qnil;
          int flags = fif == FIF_JPEG ? JPEG_ACCURATE : 0;
          if (bitmap = FreeImage_Load(fif, input, flags)) {
            result = wrap_and_yield(bitmap, self, fif);
          }
          return (result);
        }
        rb_raise(rb_eTypeError, "Unknown file format");
      }
Exemple #27
0
static const gsl_wavelet_type* rb_gsl_wavelet_get_type(VALUE t)
{
  const gsl_wavelet_type *T;
  switch (TYPE(t)) {
  case T_STRING:
    T = rb_gsl_wavelet_get_type_str(STR2CSTR(t));
    break;
  case T_FIXNUM:
    T = rb_gsl_wavelet_get_type_int(FIX2INT(t));
    break;
  default:
    rb_raise(rb_eTypeError, 
	     "wrong type of argument %s (String or Fixnum expected)",
	     rb_class2name(CLASS_OF(t)));
    break;
  }
  return T;
}
Exemple #28
0
static VALUE
fortran_file_close(int argc, VALUE *argv, VALUE klass)
{
  VALUE vlun, vstatus;
  int lun;
  char *status;

  rb_scan_args(argc, argv, "11", &vlun, &vstatus);

  lun = FIX2INT(vlun);
  if (NIL_P(vstatus))
    status = "KEEP";
  else
    status = STR2CSTR(vstatus);

  fortfileclose_(&lun, status, strlen(status));

  return Qnil;
}
Exemple #29
0
static VALUE rb_gsl_fsolver_new(VALUE klass, VALUE t)
{
  gsl_root_fsolver *s = NULL;
  const gsl_root_fsolver_type *T;
  char name[32];
  switch (TYPE(t)) {
  case T_STRING:
    strcpy(name, STR2CSTR(t));
    if (!str_tail_grep(name, "bisection")) {
      T = gsl_root_fsolver_bisection;
    } else if (!str_tail_grep(name, "falsepos")) {
      T = gsl_root_fsolver_falsepos;
    } else if (!str_tail_grep(name, "brent")) {
      T = gsl_root_fsolver_brent;
    } else {
      rb_raise(rb_eTypeError, 
	       "type must be \"bisection\" or \"falsepos\", or \"brent\".");
    }
    break;
  case T_FIXNUM:
    switch (FIX2INT(t)) {
    case GSL_ROOT_FSOLVER_BISECTION:
      T = gsl_root_fsolver_bisection;
      break;
    case GSL_ROOT_FSOLVER_FALSEPOS:
      T = gsl_root_fsolver_falsepos;
      break;
    case GSL_ROOT_FSOLVER_BRENT:
      T = gsl_root_fsolver_brent;
      break;
    default:
      rb_raise(rb_eTypeError, "type must be BISECTION or FALSEPOS, or BRENT.");
      break;
    }
    break;
  default:
    rb_raise(rb_eTypeError, "wrong argument type %s (String or Fixnum expected)",
	     rb_class2name(CLASS_OF(t)));
    break;
  }
  s = gsl_root_fsolver_alloc(T);
  return Data_Wrap_Struct(klass, 0, gsl_root_fsolver_free, s);
}
Exemple #30
0
static char* value_to_cstr(VALUE value) {
	VALUE str;
	char* result = NULL;
	int max;
	
	if(RTEST(value)) {
		str = value;
		if( TYPE(str) != T_STRING ) {
			str = rb_str_to_str(str);
		}
		str = StringValue(value);
		max = RSTRING(str)->len;
		result = malloc(max+1);
		bzero(result, max+1);
		strncpy(result, STR2CSTR(str), max);		
	}
	
	return result;
}