FILE* rb_gsl_open_readfile(VALUE io, int *flag)
{
#ifdef RUBY_1_9_LATER
rb_io_t *fptr = NULL;
#else
OpenFile *fptr = NULL;
#endif
FILE *fp = NULL;
char *name;
switch (TYPE(io)) {
case T_STRING:
name = RSTRING_PTR(io);
fp = fopen(name, "r");
*flag = 1;
break;
case T_FILE:
GetOpenFile(io, fptr);
name = fptr->path;
rb_io_check_readable(fptr);
#ifdef RUBY_1_9_LATER
fp = rb_io_stdio_file(fptr);
#else
fp = fptr->f;
#endif
*flag = 0;
break;
default:
rb_raise(rb_eTypeError, "argv 1 String or File expected");
break;
}
if (fp == NULL) rb_raise(rb_eIOError, "Cannot open file %s.", name);
return fp;
}
FILE* rb_gsl_open_readfile(VALUE io, int *flag)
{
rb_io_t *fptr = NULL;
FILE *fp = NULL;
char *name;
switch (TYPE(io)) {
case T_STRING:
name = RSTRING_PTR(io);
fp = fopen(name, "r");
*flag = 1;
break;
case T_FILE:
GetOpenFile(io, fptr);
rb_io_check_readable(fptr);
fp = rb_io_stdio_file(fptr);
*flag = 0;
break;
default:
rb_raise(rb_eTypeError, "argv 1 String or File expected");
break;
}
// if (fp == NULL) rb_raise(rb_eIOError, "Cannot open file %s.", name);
if (fp == NULL) rb_raise(rb_eIOError, "Cannot open file");
return fp;
}
VALUE frostbitten_message_write_to_io(VALUE self, VALUE io) {
fb_message *message;
Data_Get_Struct(self, fb_message, message);
frostbitten_header_write_to_io(message->header, io);
uint32_t arrayLength = (uint32_t)RARRAY_LEN(message->words);
uint32_t packetSize = 0;
char** strings = frostbitten_message_generate(message, &packetSize);
packetSize += sizeof(uint32_t); // Header
packetSize += sizeof(uint32_t); // packetSize
packetSize += sizeof(uint32_t); // wordCount
rb_io_t *fptr;
GetOpenFile(io, fptr);
rb_io_check_readable(fptr);
FILE *fp = rb_io_stdio_file(fptr);
fwrite((const void*)&packetSize,sizeof(uint32_t),1,fp);
fwrite((const void*)&arrayLength,sizeof(uint32_t),1,fp);
for(uint32_t i=0; i < arrayLength; i++) {
char *str = strings[i];
uint32_t len = (uint32_t)strlen(str);
fwrite((const void*)&len, sizeof(uint32_t), 1, fp);
fwrite(str, sizeof(char), strlen(str)+1, fp);
}
fflush(fp);
return self;
}
VALUE Wikitext_parser_flush(VALUE self,VALUE file){
rb_io_t * file_p_struct;
FILE * file_p;
Check_Type(file,T_FILE);
rb_io_binmode(file);
GetOpenFile(file,file_p_struct);
file_p = rb_io_stdio_file(file_p_struct);
fflush(file_p);
return Qnil;
}
static VALUE rb_gsl_ieee_fprintf_double(int argc, VALUE *argv, VALUE obj)
{
#ifdef RUBY_1_9_LATER
rb_io_t *fptr = NULL;
#else
OpenFile *fptr = NULL;
#endif
FILE *fp = NULL;
int flag = 0;
VALUE vtmp;
switch (argc) {
case 2:
switch (TYPE(argv[0])) {
case T_STRING:
fp = fopen(RSTRING_PTR(argv[0]), "w");
flag = 1;
break;
case T_FILE:
GetOpenFile(argv[0], fptr);
rb_io_check_writable(fptr);
#ifdef RUBY_1_9_LATER
fp = rb_io_stdio_file(fptr);
#else
fp = GetWriteFile(fptr);
#endif
break;
default:
rb_raise(rb_eTypeError, "wrong type argument %s (IO or String expected)",
rb_class2name(CLASS_OF(argv[0])));
}
vtmp = argv[1];
break;
case 1:
vtmp = argv[0];
fp = stdout;
break;
default:
rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc);
}
if (TYPE(vtmp) != T_FLOAT)
rb_raise(rb_eTypeError, "wrong argument type %s (Float expected)",
rb_class2name(CLASS_OF(vtmp)));
#ifdef RUBY_1_9_LATER
double rbfv = rb_float_value(vtmp);
gsl_ieee_fprintf_double(fp, &rbfv);
#else
gsl_ieee_fprintf_double(fp, &(RFLOAT(vtmp)->value));
#endif
if (fp == stdout) fprintf(stdout, "\n");
if (flag == 1) fclose(fp);
return obj;
}
VALUE frostbitten_message_read_from_io(VALUE self, VALUE io) {
fb_message *message;
Data_Get_Struct(self, fb_message, message);
rb_io_t *fptr;
GetOpenFile(io, fptr);
rb_io_check_readable(fptr);
FILE *fp = rb_io_stdio_file(fptr);
fb_packet_buffer *buffer = read_buffer_from_io(fp);
if ( !message->header ) {
message->header = rb_class_new_instance(0, NULL, c_frostbitten_header);
frostbitten_header_parse_from_buffer(message->header, buffer);
}
frostbitten_read_words_from_file(message, fp, buffer);
return self;
}
static VALUE MARC_nextmarc(VALUE self, VALUE file) {
struct RECORD *r = NULL;
rb_io_t *fptr;
FILE *fp;
if (TYPE (file) != T_FILE) {
rb_raise (rb_eTypeError, "must provide a file handle.");
}
GetOpenFile(file, fptr);
fp = rb_io_stdio_file(fptr);
r = next_marc(fp);
if (r == (struct RECORD *)NULL) {
return Qnil;
}
/* By default in Ruby 1.9+, this should be returned encoded */
/* as ASCII-8BIT */
return rb_str_new2(r->txt);
}
FILE* rb_gsl_open_writefile(VALUE io, int *flag)
{
#ifdef HAVE_RUBY_IO_H
rb_io_t *fptr = NULL;
#else
OpenFile *fptr = NULL;
#endif
FILE *fp = NULL;
char *name;
switch (TYPE(io)) {
case T_STRING:
name = RSTRING_PTR(io);
fp = fopen(name, "w");
*flag = 1;
break;
case T_FILE:
GetOpenFile(io, fptr);
/*
#ifdef HAVE_RUBY_IO_H
name = STR2CSTR(fptr->pathv);
#else
name = fptr->path;
#endif
*/
rb_io_check_writable(fptr);
#ifdef HAVE_RUBY_IO_H
fp = rb_io_stdio_file(fptr);
#else
fp = GetWriteFile(fptr);
#endif
*flag = 0;
break;
default:
rb_raise(rb_eTypeError, "argv 1 String or File expected");
break;
}
// if (fp == NULL) rb_raise(rb_eIOError, "Cannot open file %s.", name);
if (fp == NULL) rb_raise(rb_eIOError, "Cannot open file.");
return fp;
}
VALUE frostbitten_message_complete(VALUE self, VALUE io) {
rb_io_t *fptr;
GetOpenFile(io, fptr);
rb_io_check_readable(fptr);
FILE *fp = rb_io_stdio_file(fptr);
fb_packet_buffer *buffer = read_buffer_from_io(fp);
if (is_packet_valid(buffer)) {
VALUE msg = rb_obj_alloc(c_frostbitten_message);
rb_obj_call_init(msg, 0, 0);
fb_message *message;
Data_Get_Struct(msg, fb_message, message);
frostbitten_read_words_from_file(message, fp, buffer);
if (rb_block_given_p()) {
return rb_yield(msg);
} else {
return msg;
}
}
free(buffer);
return Qnil;
}
FILE *get_io_ptr(VALUE self) {
VALUE io;
io = rb_iv_get(self,"@io");
return rb_io_stdio_file(RFILE(io)->fptr);
}
// for testing and debugging only
VALUE Wikitext_parser_tokenize(VALUE self, VALUE string, VALUE file1, VALUE file2,
VALUE doc_id_v)
{
if (NIL_P(string))
return Qnil;
int doc_id = FIX2INT(doc_id_v);
rb_io_t * file_p_struct;
Check_Type(file1,T_FILE);
rb_io_binmode(file1);
GetOpenFile(file1,file_p_struct);
rb_io_check_writable(file_p_struct);
FILE * file_p1 = rb_io_stdio_file(file_p_struct);
Check_Type(file2,T_FILE);
rb_io_binmode(file2);
GetOpenFile(file2,file_p_struct);
rb_io_check_writable(file_p_struct);
FILE * file_p2 = rb_io_stdio_file(file_p_struct);
string = StringValue(string);
VALUE tokens = rb_ary_new();
char *p = RSTRING_PTR(string);
long len = RSTRING_LEN(string);
char *pe = p + len;
const char *type = NULL;
int state = DEFAULT;
int ts[1000];
int ss[1000];
int ts_size = 1 ;
int ss_size = 1 ;
ss[0] = 0;
ts[0] = 0;
token_t token;
token_t stack1[1000]; //tail, TODO add checks
token_t stack2[1000]; //head, TODO add checks
int s1_size = 0;
int s2_size = 0;
int start = 1;
do
{
//printf("%i %i\n",s1_size,s2_size);
if(start) {
next_token(&token, NULL, p, pe, ts, ss, &ts_size, &ss_size, file_p1, doc_id);
start = 0;
} else {
next_token(&token, &token, NULL, pe, ts, ss, &ts_size, &ss_size, file_p1, doc_id);
}
//rb_funcall(rb_mKernel, rb_intern("puts"), 1, wiki_token(&token));
if(token.type == END_OF_FILE){
if(state == POST_LINK) {
finish_link1(&s1_size,&s2_size,stack1,stack2,file_p1,file_p2,doc_id);
}
break;
}
switch(token.type) {
case SEPARATOR :
memcpy(stack2,stack1,sizeof(token_t)*s1_size);
s2_size = s1_size;
s1_size = 0;
state = SEPARATOR;
break;
case LINK_START :
state = LINK;
break;
case LINK_END :
if(state != SEPARATOR) {
memcpy(stack2,stack1,sizeof(token_t)*s1_size);
s2_size = s1_size;
}
state = POST_LINK;
break;
case EXT_LINK_START :
state = EXT_LINK;
break;
case EXT_LINK_END :
// TODO print what should be printed
s1_size = 0;
s2_size = 0;
break;
case ALNUM :
if(state == POST_LINK){
finish_link(&s1_size,&s2_size,stack1,stack2,file_p1,file_p2,doc_id,&token);
state = DEFAULT;
} else {
if(s1_size < 1000)
memcpy(&(stack1[s1_size++]),&token,sizeof(token_t));
else
printf("[%i]Token stack overflow\n",doc_id);
}
break;
case SPACE :
type = space_type;
case PRINTABLE :
case DEFAULT :
if(type == NULL) type = printable_type;
case NUM :
if(type == NULL) type = num_type;
if(state == POST_LINK) {
finish_link1(&s1_size,&s2_size,stack1,stack2,file_p1,file_p2,doc_id);
wikitext_print_token(&token,file_p1,doc_id,type);
state = DEFAULT;
} else {
if(s1_size < 1000)
memcpy(&(stack1[s1_size++]),&token,sizeof(token_t));
else
printf("[%i]Token stack overflow\n",doc_id);
}
break;
case CRLF :
if(state == POST_LINK){
finish_link1(&s1_size,&s2_size,stack1,stack2,file_p1,file_p2,doc_id);
wikitext_print_crlf(&token,file_p1,doc_id);
state = DEFAULT;
} else {
if(s1_size < 1000)
memcpy(&(stack1[s1_size++]),&token,sizeof(token_t));
else
printf("[%i]Token stack overflow\n",doc_id);
}
break;
case SKIP :
if(state == POST_LINK){
finish_link1(&s1_size,&s2_size,stack1,stack2,file_p1,file_p2,doc_id);
state = DEFAULT;
}
break;
}
type = NULL;
} while(1);
return tokens;
}
