gimme_alpha_types.c

Go to the documentation of this file.

/*
** gimme_alpha_types.c
** 
** Made by (Johnny Q. Hacker)
** Login   <solarion@borkborkbork>
** 

    Copyright (C) 2008 Joseph Pingenot

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Affero General Public License for more details.

    You should have received a copy of the GNU Affero General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

** Started on  Wed Oct 22 17:03:57 2008 Johnny Q. Hacker
** Last update Sun May 12 01:17:25 2002 Speed Blue
*/

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include "gimme_alpha_types.h"

___const char* format_string_for_type_scan(enum data_types t) {
  switch(t) {
  case INT_TYPE: return "%d";
  case LONG_INT_TYPE: return "%ld";
  case FLOAT_TYPE: return "%f";
  case DOUBLE_TYPE: return "%le";
  case LONG_DOUBLE_TYPE: return "%e";
  case COMPLEX_TYPE: return NULL;
  case STRING_TYPE: 
  default: 
    return "%s";
  }
}

___const char* format_string_for_type_print(enum data_types t) {
  switch(t) {
  case INT_TYPE: return "%d";
  case LONG_INT_TYPE: return "%ld";
  case FLOAT_TYPE: return "%f";
  case DOUBLE_TYPE: return "%G";
  case LONG_DOUBLE_TYPE: return "%lG";
  case COMPLEX_TYPE: return NULL;
  case STRING_TYPE: 
  default: 
    return "%s";
  }
}

___malloc void* string_to_data(char* s, enum data_types t) {
  if(t == STRING_TYPE) return s;
  if(t == COMPLEX_TYPE) return NULL;
  char *format = format_string_for_type_scan(t);
  if(unlikely(format == NULL)) return NULL;
  size_t size;
  switch(t) {
  case INT_TYPE: size = sizeof(int); break;
  case LONG_INT_TYPE: size = sizeof(long int); break;
  case FLOAT_TYPE: size = sizeof(float); break;
  case DOUBLE_TYPE: size = sizeof(double); break;
  case LONG_DOUBLE_TYPE: size = sizeof(long double); break;
  default:
    return NULL;
  }
  void* data;
  if(unlikely((data = malloc(size)) == NULL)) return NULL;
  int n;
  if(unlikely((n = sscanf(s, format, data)) != 1)) {
    free(data);
    return NULL;
  }
  return data;
}

___malloc void* string_to_data_x2(char* s1, char* s2, enum data_types t) {
  if(t == STRING_TYPE) {
    GString *s = g_string_new(s1);
    s = g_string_append(s, s2);
    char* ess = s->str;
    g_string_free(s, FALSE);
    return ess;
  }
  if(t == COMPLEX_TYPE) return NULL;
  char *format = format_string_for_type_scan(t);
  if(unlikely(format == NULL)) return NULL;
  size_t size;
  switch(t) {
  case INT_TYPE: size = sizeof(int); break;
  case LONG_INT_TYPE: size = sizeof(long int); break;
  case FLOAT_TYPE: size = sizeof(float); break;
  case DOUBLE_TYPE: size = sizeof(double); break;
  case LONG_DOUBLE_TYPE: size = sizeof(long double); break;
  default:
    return NULL;
  }
  char* data;
  if(unlikely((data = malloc(size*2)) == NULL)) return NULL;
  int n;
  if(unlikely((n = sscanf(s1, format, &data[0])) != 1)) {
    free(data);
    return NULL;
  }
  if(unlikely((n = sscanf(s2, format, &data[size])) != 1)) {
    free(data);
    return NULL;
  }
  return data;
}

___malloc void* string_to_data_xN(gchar** s, enum data_types t) {
  int N = g_strv_length(s);
  if(t == STRING_TYPE) {
    GString *gs = g_string_new(s[0]);
    for(int i=1; i<N; i++) {
      gs = g_string_append(gs, s[i]);
    }
    char* ess = gs->str;
    g_string_free(gs, FALSE);
    return ess;
  }
  if(t == COMPLEX_TYPE) return NULL;
  char *format = format_string_for_type_scan(t);
  if(unlikely(format == NULL)) return NULL;
  size_t size;
  switch(t) {
  case INT_TYPE: size = sizeof(int); break;
  case LONG_INT_TYPE: size = sizeof(long int); break;
  case FLOAT_TYPE: size = sizeof(float); break;
  case DOUBLE_TYPE: size = sizeof(double); break;
  case LONG_DOUBLE_TYPE: size = sizeof(long double); break;
  default:
    return NULL;
  }
  char* data;
  if(unlikely((data = malloc(size*N)) == NULL)) return NULL;
  int n;
  for(int i=0; i<N; i++) {
    if(unlikely((n = sscanf(s[i], format, &data[size*i])) != 1)) {
      free(data);
      return NULL;
    }
  }
  return data;
}

___malloc void* string_to_data_fortran(char* s, enum data_types t) {
  if(t == STRING_TYPE) return s;
  if(t == COMPLEX_TYPE) return NULL;
  char *format = format_string_for_type_scan(t);
  if(unlikely(format == NULL)) return NULL;
  size_t size;
  switch(t) {
  case INT_TYPE: size = sizeof(int); break;
  case LONG_INT_TYPE: size = sizeof(long int); break;
  case FLOAT_TYPE: size = sizeof(float); break;
  case DOUBLE_TYPE: size = sizeof(double); break;
  case LONG_DOUBLE_TYPE: size = sizeof(long double); break;
  default:
    return NULL;
  }
  void* data;
  if(unlikely((data = malloc(size)) == NULL)) return NULL;
  int n;
  if(unlikely((n = sscanf(s, format, data)) != 1)) {
    free(data);
    return NULL;
  }
  return data;
}


/*If it's a string, we'll make a copy*/
___malloc void* string_to_data_generic(char* s, enum data_types t, enum data_type_string_format_type fmt) {
  switch(fmt) {
  case STRING_FORMATTED_LIKE_C:
    return string_to_data(s, t);
  case STRING_FORMATTED_LIKE_FORTRAN:
    return string_to_data_fortran(s, t);
  default:
    return NULL;
  }
}