const char *cwd(const char *s)
{
#ifdef UNIX
if (s) {
errno = 0;
if (chdir(s)==-1)
test_file_error(NULL, errno);
}
# ifdef HAVE_GETCWD
assert(getcwd(string_buffer,STRING_BUFFER));
return mm_strdup(string_buffer);
# else
assert(getwd(string_buffer));
return mm_strdup(string_buffer);
# endif
#endif
#ifdef WIN32
char drv[2];
if (s)
errno = 0;
if (_chdir(s)==-1)
test_file_error(NULL, errno);
drv[0]='.'; drv[1]=0;
GetFullPathName(drv, STRING_BUFFER, string_buffer, &s);
return mm_strdup(string_buffer);
#endif
}
static const char *generic_name(at *p)
{
if (Class(p)->classname)
sprintf(string_buffer, "::%s:%p", NAMEOF(Class(p)->classname),Mptr(p));
else
sprintf(string_buffer, "::%p:%p", Class(p), Mptr(p));
return mm_strdup(string_buffer);
}
char *mm_typecode_to_str(MM_typecode matcode)
{
char buffer[MM_MAX_LINE_LENGTH];
char *types[4];
char *mm_strdup(const char *);
int error =0;
/* check for MTX type */
if (mm_is_matrix(matcode))
types[0] = MM_MTX_STR;
else
error=1;
/* check for CRD or ARR matrix */
if (mm_is_sparse(matcode))
types[1] = MM_SPARSE_STR;
else
if (mm_is_dense(matcode))
types[1] = MM_DENSE_STR;
else
return NULL;
/* check for element data type */
if (mm_is_real(matcode))
types[2] = MM_REAL_STR;
else
if (mm_is_complex(matcode))
types[2] = MM_COMPLEX_STR;
else
if (mm_is_pattern(matcode))
types[2] = MM_PATTERN_STR;
else
if (mm_is_integer(matcode))
types[2] = MM_INT_STR;
else
return NULL;
/* check for symmetry type */
if (mm_is_general(matcode))
types[3] = MM_GENERAL_STR;
else
if (mm_is_symmetric(matcode))
types[3] = MM_SYMM_STR;
else
if (mm_is_hermitian(matcode))
types[3] = MM_HERM_STR;
else
if (mm_is_skew(matcode))
types[3] = MM_SKEW_STR;
else
return NULL;
sprintf(buffer,"%s %s %s %s", types[0], types[1], types[2], types[3]);
return mm_strdup(buffer);
}
static const char *class_name(at *p)
{
class_t *cl = Mptr(p);
if (cl->classname)
sprintf(string_buffer, "::class:%s", NAMEOF(cl->classname));
else
sprintf(string_buffer, "::class:%p", cl);
if (!cl->live)
strcat(string_buffer, " (unlinked)");
return mm_strdup(string_buffer);
}
static const char *storage_name(at *p)
{
storage_t *st = (storage_t *)Mptr(p);
char *kind = "";
switch (st->kind) {
case STS_NULL: kind = "unallocated"; break;
case STS_MANAGED: kind = "managed"; break;
case STS_FOREIGN: kind = "foreign"; break;
case STS_MMAP: kind = "mmap"; break;
case STS_STATIC: kind = "static"; break;
default:
fprintf(stderr, "internal error: invalid storage kind");
abort();
}
const char *clname = nameof(Symbol(Class(p)->classname));
sprintf(string_buffer, "::%s:%s@%p:<%"PRIdPTR">", clname, kind, st->data, st->size);
return mm_strdup(string_buffer);
}
/*
* FUNCTION fgets
*/
extern_c char* C_fgets(FILE * L1_fp,int L1_maxsize)
{
TRACE_PUSH("C_fgets"); MM_ENTER;
{
char* L_Tmp0;
{
char* L2_1_result;
char *L2_0_str;
Mstr_alloc(L2_0_str, 0+1);
strcpy((char*)(L2_0_str),"");
L2_1_result = L2_0_str;
{
char buffer[(L1_maxsize)];
fgets(buffer,(L1_maxsize),(L1_fp));
(L2_1_result) = mm_strdup(buffer);
}
L_Tmp0 = L2_1_result;
}
TRACE_POP("C_fgets");
MM_EXIT; return L_Tmp0;
}
}
/*
* FUNCTION fscan-str
*/
extern_c char* C_fscan_str(FILE * L1_fp)
{
TRACE_PUSH("C_fscan_str"); MM_ENTER;
{
char* L_Tmp0;
{
char* L2_1_result;
char *L2_0_str;
Mstr_alloc(L2_0_str, 0+1);
strcpy((char*)(L2_0_str),"");
L2_1_result = L2_0_str;
{
char buffer[1024];
int s = fscanf((L1_fp),"%s",buffer);
if (s < 1) { buffer[0]=0; }
(L2_1_result) = mm_strdup(buffer);
}
L_Tmp0 = L2_1_result;
}
TRACE_POP("C_fscan_str");
MM_EXIT; return L_Tmp0;
}
}
static char * evdns_get_default_hosts_filename(void)
{
#ifdef WIN32
/* Windows is a little coy about where it puts its configuration
* files. Sure, they're _usually_ in C:\windows\system32, but
* there's no reason in principle they couldn't be in
* W:\hoboken chicken emergency\
*/
char path[MAX_PATH+1];
static const char hostfile[] = "\\drivers\\etc\\hosts";
char *path_out;
size_t len_out;
if (! SHGetSpecialFolderPathA(NULL, path, CSIDL_SYSTEM, 0))
return NULL;
len_out = strlen(path)+strlen(hostfile);
path_out = (char *)malloc(len_out+1);
evutil_snprintf(path_out, len_out+1, "%s%s", path, hostfile);
return path_out;
#else
return mm_strdup("/etc/hosts");
#endif
}
char *MM_strdup(const char *str)
{
if (mm_global == NULL)
return NULL;
return mm_strdup(mm_global, str);
}
/* lush_basename returns a new, managed string */
const char *lush_basename(const char *fname, const char *suffix)
{
#ifdef UNIX
if (strlen(fname) > STRING_BUFFER-4)
RAISEF("filename is too long",NIL);
char *s = strrchr(fname,'/');
if (s)
fname = s+1;
/* Process suffix */
if (suffix==0 || suffix[0]==0)
return mm_strdup(fname);
if (suffix[0]=='.')
suffix += 1;
if (suffix[0]==0)
return mm_strdup(fname);
strcpyif(string_buffer,fname);
int sl = strlen(suffix);
s = string_buffer + strlen(string_buffer);
if (s > string_buffer + sl) {
s = s - (sl + 1);
if (s[0]=='.' && strcmp(s+1,suffix)==0)
*s = 0;
}
return mm_strdup(string_buffer);
#endif
#ifdef WIN32
const char *p = fname;
const char *s = fname;
/* Special cases */
if (fname[0] && fname[1]==':') {
strcpyif(string_buffer,fname);
if (fname[2]==0)
return mm_strdup(string_buffer);
string_buffer[2] = '\\';
if (fname[3]==0 && (fname[2]=='/' || fname[2]=='\\'))
return mm_strdup(string_buffer);
}
/* Position p after last slash */
while (*s) {
if (s[0]=='\\' || s[0]=='/')
p = s + 1;
s++;
}
/* Copy into buffer */
if (strlen(p) > STRING_BUFFER-10)
RAISEF("filename too long",NIL);
s = string_buffer;
while (*p && *p!='/' && *p!='\\')
*s++ = *p++;
*s = 0;
/* Process suffix */
if (suffix==0 || suffix[0]==0)
return mm_strdup(string_buffer);
if (suffix[0]=='.')
suffix += 1;
if (suffix[0]==0)
return mm_strdup(string_buffer);
int sl = strlen(suffix);
if (s > string_buffer + sl) {
s = s - (sl + 1);
if (s[0]=='.' && stricmp(s+1,suffix)==0)
*s = 0;
}
return mm_strdup(string_buffer);
#endif
}
/* expects a managed string & returns a managed string */
const char *lush_dirname(const char *fname)
{
#ifdef UNIX
const char *s = fname;
const char *p = 0;
char *q = string_buffer;
while (*s) {
if (s[0]=='/' && s[1])
p = s;
s++;
}
if (!p) {
if (fname[0]=='/')
return fname;
else
return mm_strdup(".");
}
s = fname;
if (p-s > STRING_BUFFER-1)
RAISEF("filename is too long",NIL);
do {
*q++ = *s++;
} while (s<p);
*q = 0;
return mm_strdup(string_buffer);
#endif
#ifdef WIN32
char *s, *p;
char *q = string_buffer;
/* Handle leading drive specifier */
if (fname[0] && fname[1]==':') {
*q++ = *fname++;
*q++ = *fname++;
}
/* Search last non terminal / or \ */
p = 0;
s = fname;
while (*s) {
if (s[0]=='\\' || s[0]=='/')
if (s[1] && s[1]!='/' && s[1]!='\\')
p = s;
s++;
}
/* Cannot find non terminal / or \ */
if (p == 0) {
if (q>string_buffer) {
if (fname[0]==0 || fname[0]=='/' || fname[0]=='\\')
return mm_strdup("\\\\");
*q = 0;
return mm_strdup(string_buffer);
} else {
if (fname[0]=='/' || fname[0]=='\\')
return mm_strdup("\\\\");
else
return mm_strdup(".");
}
}
/* Single leading slash */
if (p == fname) {
strcpy(q,"\\");
return string_buffer;
}
/* Backtrack all slashes */
while (p>fname && (p[-1]=='/' || p[-1]=='\\'))
p--;
/* Multiple leading slashes */
if (p == fname)
return "\\\\";
/* Regular case */
s = fname;
if (p-s > STRING_BUFFER-4)
error(NIL,"filename is too long",NIL);
do {
*q++ = *s++;
} while (s<p);
*q = 0;
return mm_strdup(string_buffer);
#endif
}
int Trick::MemoryManager::assign_recursive(void* base_addr, ATTRIBUTES* attr, int curr_dim, int offset, V_TREE* v_tree, UCFn* cf) {
char* assign_addr;
int remaining_dimensions = attr->num_index - curr_dim;
if ( remaining_dimensions == 0 ) {
switch (attr->type) {
case TRICK_CHARACTER :
case TRICK_UNSIGNED_CHARACTER :
assign_addr = (char*)base_addr + offset * sizeof(char);
if (v_tree && v_tree->v_data) {
*(char*)assign_addr = vval_char(v_tree->v_data);
} else {
*(char*)assign_addr = '\0';
}
if (debug_level) {
std::cout << std::endl << "Assignment: *(char*)" << (void*)assign_addr
<< " = ";
if (isprint(*(char*)assign_addr)) {
std::cout << *(char*)assign_addr;
} else {
std::cout << (int)*(char*)assign_addr;
}
std::cout << ";" << std::endl;
std::cout.flush();
}
break;
case TRICK_WCHAR :
assign_addr = (char*)base_addr + offset * sizeof(wchar_t);
if (v_tree && v_tree->v_data) {
*(wchar_t*)assign_addr = vval_char(v_tree->v_data);
} else {
*(wchar_t*)assign_addr = 0;
}
if (debug_level) {
std::cout << std::endl << "Assignment: *(wchar_t*)" << (void*)assign_addr
<< " = " << *(wchar_t*)assign_addr << ";" << std::endl;
std::cout.flush();
}
break;
case TRICK_SHORT :
case TRICK_UNSIGNED_SHORT :
assign_addr = (char*)base_addr + offset * sizeof(short);
if (v_tree && v_tree->v_data) {
*(short *)assign_addr = vval_short(v_tree->v_data);
} else {
*(short *)assign_addr = 0;
}
if (debug_level) {
std::cout << std::endl << "Assignment: *(short*)" << (void*)assign_addr
<< " = " << *(short*)assign_addr << ";" << std::endl;
std::cout.flush();
}
break;
case TRICK_INTEGER :
case TRICK_UNSIGNED_INTEGER :
assign_addr = (char*)base_addr + offset * sizeof(int);
if (v_tree && v_tree->v_data) {
int input_value;
input_value = vval_int(v_tree->v_data);
if (cf == NULL) {
*(int *)assign_addr = input_value;
} else {
*(int *)assign_addr = input_value * cf->C[1] + cf->C[0];
}
} else {
*(int *)assign_addr = 0;
}
if (debug_level) {
std::cout << std::endl << "Assignment: *(int*)" << (void*)assign_addr
<< " = " << *(int*)assign_addr << ";" << std::endl;
std::cout.flush();
}
break;
case TRICK_BOOLEAN :
assign_addr = (char*)base_addr + offset * sizeof(bool);
if (v_tree && v_tree->v_data) {
*(bool *)assign_addr = (vval_short(v_tree->v_data)!=0);
} else {
*(bool *)assign_addr = false;
}
if (debug_level) {
std::cout << std::endl << "Assignment: *(bool*)" << (void*)assign_addr
<< " = " << *(bool*)assign_addr << ";" << std::endl;
std::cout.flush();
}
break;
case TRICK_ENUMERATED :
if (v_tree && v_tree->v_data) {
if ((size_t)attr->size == sizeof(int)) {
assign_addr = (char*)base_addr + offset * sizeof(int);
*(int *)assign_addr = vval_int(v_tree->v_data);
if (debug_level) {
std::cout << std::endl << "Assignment (Enum): *(int*)" << (void*)assign_addr
<< " = " << *(int*)assign_addr << ";" << std::endl;
std::cout.flush();
}
} else if ((size_t)attr->size == sizeof(short)) {
assign_addr = (char*)base_addr + offset * sizeof(short);
*(short *)assign_addr = vval_short(v_tree->v_data);
if (debug_level) {
std::cout << std::endl << "Assignment (Enum): *(short*)" << (void*)assign_addr
<< " = " << *(short*)assign_addr << ";" << std::endl;
std::cout.flush();
}
} else {
std::stringstream message;
message << "Enumeration of size " << attr->size << " is not supported.";
emitError(message.str());
}
} else {
emitError("v_tree data appears to be corrupted.");
}
break;
case TRICK_LONG :
case TRICK_UNSIGNED_LONG :
assign_addr = (char*)base_addr + offset * sizeof(long);
if (v_tree && v_tree->v_data) {
long input_value;
input_value = vval_long(v_tree->v_data);
if (cf == NULL) {
*(long *)assign_addr = input_value;
} else {
*(long *)assign_addr = input_value * cf->C[1] + cf->C[0];
}
} else {
*(long *)assign_addr = 0;
}
if (debug_level) {
std::cout << std::endl << "Assignment: *(long*)" << (void*)assign_addr
<< " = " << *(long*)assign_addr << ";" << std::endl;
std::cout.flush();
}
break;
case TRICK_FLOAT :
assign_addr = (char*)base_addr + offset * sizeof(float);
if (v_tree && v_tree->v_data) {
float input_value;
input_value = vval_float(v_tree->v_data);
if (cf == NULL) { // There is no units conversion.
*(float *)assign_addr = input_value;
} else { // There is units conversion.
*(float *)assign_addr = input_value * cf->C[1] + cf->C[0];
}
} else {
*(float *)assign_addr = 0;
}
if (debug_level) {
std::cout << std::endl << "Assignment: *(float*)" << (void*)assign_addr
<< " = " << *(float*)assign_addr << ";" << std::endl;
std::cout.flush();
}
break;
case TRICK_DOUBLE :
assign_addr = (char*)base_addr + offset * sizeof(double);
if (v_tree && v_tree->v_data) {
double input_value;
input_value = vval_double(v_tree->v_data);
if (cf == NULL) {
*(double *)assign_addr = input_value;
} else {
*(double *)assign_addr = input_value * cf->C[1] + cf->C[0];
}
} else {
*(double *)assign_addr = 0;
}
if (debug_level) {
std::cout << std::endl << "Assignment: *(double*)" << (void*)assign_addr
<< " = " << *(double*)assign_addr << ";" << std::endl;
std::cout.flush();
}
break;
case TRICK_LONG_LONG :
case TRICK_UNSIGNED_LONG_LONG :
assign_addr = (char*)base_addr + offset * sizeof(long long);
if (v_tree && v_tree->v_data) {
*(long long *)assign_addr = vval_longlong(v_tree->v_data);
} else {
*(long long *)assign_addr = 0;
}
if (debug_level) {
std::cout << std::endl << "Assignment: *(long long*)" << (void*)assign_addr
<< " = " << *(long long*)assign_addr << ";" << std::endl;
std::cout.flush();
}
break;
case TRICK_BITFIELD :
case TRICK_UNSIGNED_BITFIELD : {
int input_value;
assign_addr = (char*)base_addr + offset * (size_t)attr->size;
if (v_tree && v_tree->v_data) {
input_value = vval_int(v_tree->v_data);
} else {
input_value = 0;
}
if (attr->size == sizeof(int)) {
*(unsigned int*)assign_addr = insert_bitfield_any(
*(unsigned int*)assign_addr, input_value, attr->size, attr->index[0].start, attr->index[0].size);
} else if (attr->size == sizeof(short)) {
*(unsigned short*)assign_addr = insert_bitfield_any(
*(unsigned short*)assign_addr, input_value, attr->size, attr->index[0].start, attr->index[0].size);
} else if (attr->size == sizeof(char)) {
*(unsigned char*)assign_addr = insert_bitfield_any(
*(unsigned char*)assign_addr, input_value, attr->size, attr->index[0].start, attr->index[0].size);
} else {
std::stringstream message;
message << "Unhandled bitfield struct size (" << attr->size << ") in bitfield assignment.";
emitError(message.str());
}
if (debug_level) {
std::cout << std::endl << "Assignment: "
<< "Within the " << attr->size << " byte struct at " << (void*)assign_addr
<< ", the bitfield ["<< attr->index[0].start << ".."
<< attr->index[0].start + attr->index[0].size - 1
<< "] = " << input_value << ";"
<< std::endl;
std::cout.flush();
}
} break;
case TRICK_FILE_PTR :
if (debug_level) {
std::cout << std::endl << "Assignment: TRICK_FILE_PTR assignments not yet implemented."
<< std::endl;
std::cout.flush();
}
break;
case TRICK_VOID_PTR :
if (debug_level) {
std::cout << std::endl << "Assignment: TRICK_VOID_PTR assignments not yet implemented."
<< std::endl;
std::cout.flush();
}
break;
case TRICK_STRING :
assign_addr = (char*)base_addr + offset * sizeof(char*);
if (v_tree && v_tree->v_data) {
*(std::string*)assign_addr = vval_string(v_tree->v_data);
} else {
*(std::string*)assign_addr = "";
}
if (debug_level) {
std::cout << std::endl << "Assignment: *(std::string)" << (void*)assign_addr
<< " = \"" << *(std::string*)assign_addr << "\";" << std::endl;
std::cout.flush();
}
break;
default:
std::stringstream message;
message << "Unhandled Type (" << attr->type << ") in assignment.";
emitError(message.str());
return (1);
break;
}
} else if ( remaining_dimensions > 0 ) {
int size_of_curr_dim;
size_of_curr_dim = attr->index[curr_dim].size ;
assign_addr = (char*)base_addr + offset * sizeof(void*);
if ( size_of_curr_dim == 0) { // the remaining dimensions are pointer dimensions.
if (v_tree && v_tree->v_data) {
if ((remaining_dimensions == 1) && (v_tree->v_data->type == TRICK_STRING)) {
*(char**)assign_addr = mm_strdup( vval_string(v_tree->v_data));
} else {
*(void**)assign_addr = vval_voidp(v_tree->v_data);
}
} else {
*(void**)assign_addr = 0;
}
if (debug_level) {
std::cout << std::endl << "Assignment: *(void**)" << (void*)assign_addr
<< " = " << *(void**)assign_addr << ";" << std::endl;
std::cout.flush();
}
} else { // next dimension is fixed.
if ((attr->type == TRICK_CHARACTER) &&
(remaining_dimensions == 1) &&
(v_tree) &&
(v_tree->v_data)
) {
if ((v_tree->v_data->type == TRICK_STRING) &&
(v_tree->v_data->value.cp != NULL)) {
int rhs_len = (int)strlen(v_tree->v_data->value.cp) + 1;
if (rhs_len <= size_of_curr_dim ) {
strcpy((char*)assign_addr, v_tree->v_data->value.cp);
} else {
emitError("Memory Manager: char array is too small for the attempted string assignment.");
return (1);
}
} else {
*(char*)assign_addr = '\0';
}
} else if ( (attr->type == TRICK_WCHAR) &&
(remaining_dimensions == 1)) {
if ((v_tree) &&
(v_tree->v_data->type == TRICK_WSTRING) &&
(v_tree->v_data->value.wcp != NULL)) {
int rhs_len = (int)wcslen(v_tree->v_data->value.wcp) + 1;
if (rhs_len <= size_of_curr_dim ) {
wcscpy((wchar_t*)assign_addr, v_tree->v_data->value.wcp);
} else {
std::stringstream message;
message << "wchar_t array at [" << (void*)assign_addr
<< "] is to small for the attempted string assignment." ;
emitError(message.str());
return (1);
}
} else if ((v_tree) &&
(v_tree->v_data->type == TRICK_STRING) &&
(v_tree->v_data->value.cp != NULL)) {
int rhs_len = (int)ncs_to_wcs_len(v_tree->v_data->value.cp) + 1;
if (rhs_len <= size_of_curr_dim ) {
ncs_to_wcs( v_tree->v_data->value.cp, (wchar_t*)assign_addr, rhs_len);
} else {
std::stringstream message;
message << "wchar_t array at [" << (void*)assign_addr
<< "] is too small for the attempted string assignment." ;
emitError(message.str());
return (1);
}
} else {
*(wchar_t*)assign_addr = (wchar_t) NULL;
}
} else {
int ii;
V_TREE* curr_vt_node;
if (v_tree) {
curr_vt_node = v_tree->down;
} else {
curr_vt_node = NULL;
}
for (ii=0; ii < size_of_curr_dim; ii++) {
int ret;
ret = assign_recursive (base_addr,
attr,
curr_dim+1,
offset * size_of_curr_dim + ii,
curr_vt_node,
cf);
if (ret !=0) {
return(1);
}
if (curr_vt_node) {
curr_vt_node = curr_vt_node->next;
}
}
}
}
} else {
emitError("This is bad. In assign_recursive(), remaining_dimensions is negative.");
return (1);
}
return (0);
}
int tag_value_parse(tag_t *tag, const char *val, tag_value_t *tval, char *buf,
tagvalue_cmp_t cmp)
{
if (!val) return 1;
if (!*val && tag->valuetype != VT_NONE && cmp == CMP_EQ) {
tval->v_str = tag_value_null_marker;
return 0;
}
switch (tag->valuetype) {
case VT_WORD:
tval->v_str = buf ? val : mm_strdup(val);
return 0;
break;
case VT_STRING:
tval->v_str = str_enc2str(val, buf);
if (!tval->v_str) return 1;
return 0;
break;
case VT_INT:
if (!tv_parser_int64_t(val, &tval->val.v_int,
&tval->fuzz.f_int, cmp)) {
tval->v_str = 0;
return 0;
}
break;
case VT_UINT:
if (!tv_parser_uint64_t(val, &tval->val.v_uint,
&tval->fuzz.f_uint, cmp)) {
tval->v_str = 0;
return 0;
}
break;
case VT_FLOAT:
case VT_F_STOP:
case VT_STOP:
if (!tv_parser_double(val, &tval->val.v_double,
&tval->fuzz.f_double, cmp)) {
if (buf) {
tval->v_str = val;
} else {
tval->v_str = mm_strdup(val);
}
if (tag->valuetype == VT_F_STOP) {
scale_f_stop(tval);
} else if (tag->valuetype == VT_STOP) {
scale_stop(tval);
}
return 0;
}
break;
case VT_DATETIME:
if (!tv_parser_datetime(val, &tval->val.v_datetime,
&tval->fuzz.f_datetime, cmp)) {
if (buf) {
tval->v_str = val;
} else {
tval->v_str = mm_strdup(val);
}
return 0;
}
break;
case VT_GPS:
if (!tv_parser_gps(val, &tval->val.v_gps,
&tval->fuzz.f_gps)) {
if (buf) {
tval->v_str = val;
} else {
tval->v_str = mm_strdup(val);
}
return 0;
}
break;
default: // VT_NONE, or bad value
break;
}
return 1;
}
char *mm_typecode_to_str ( MM_typecode matcode )
/******************************************************************************/
/*
Purpose:
MM_TYPECODE_TO_STR converts the internal typecode to an MM header string.
Modified:
31 October 2008
*/
{
char buffer[MM_MAX_LINE_LENGTH];
char *types[4];
char *mm_strdup(const char *);
//int error =0;
/*
check for MTX type
*/
if (mm_is_matrix(matcode))
types[0] = MM_MTX_STR;
// else
// error=1;
/*
check for CRD or ARR matrix
*/
if (mm_is_sparse(matcode))
types[1] = MM_SPARSE_STR;
else
if (mm_is_dense(matcode))
types[1] = MM_DENSE_STR;
else
return NULL;
/*
check for element data type
*/
if (mm_is_real(matcode))
types[2] = MM_REAL_STR;
else
if (mm_is_complex(matcode))
types[2] = MM_COMPLEX_STR;
else
if (mm_is_pattern(matcode))
types[2] = MM_PATTERN_STR;
else
if (mm_is_integer(matcode))
types[2] = MM_INT_STR;
else
return NULL;
/*
check for symmetry type
*/
if (mm_is_general(matcode))
types[3] = MM_GENERAL_STR;
else
if (mm_is_symmetric(matcode))
types[3] = MM_SYMM_STR;
else
if (mm_is_hermitian(matcode))
types[3] = MM_HERM_STR;
else
if (mm_is_skew(matcode))
types[3] = MM_SKEW_STR;
else
return NULL;
sprintf(buffer,"%s %s %s %s", types[0], types[1], types[2], types[3]);
return mm_strdup(buffer);
}
