static int get_path_class_ext(pString **tokens, pString arg) {
#define EXT_TOKENS 2
// index last path/file separator
int fp_index = SEND(arg, lastIndexOfChar, *file_separator);
// index of filename/suffix separator
int ssep_index = SEND(arg, lastIndexOfChar, '.');
if(fp_index < 0) { //no new path
return ERR_FAIL;
} else {
// copy path token
// alloc result String array
*tokens = (pString *)internal_allocate(EXT_TOKENS * sizeof(pString));
(*tokens)[0] = SEND(arg, substring, 0, fp_index - 1);
}
// copy filename to 2nd slot
// strip suffix if present
ssep_index = ( (ssep_index >= 0) && (ssep_index > fp_index)) ?
(ssep_index - 1):
SEND(arg, length);
// copy substring
(*tokens)[1] = SEND(arg, substring, fp_index + 1, ssep_index);
return ERR_SUCCESS;
}
/**
* Allocate a new Hashmap
*/
pHashmap Hashmap_new(void) {
pHashmap result = (pHashmap)internal_allocate(sizeof(Hashmap));
if(result) {
result->_vtable = Hashmap_vtable();
INIT(result, HASHMAP_DEFAULT_SIZE);
}
return result;
}
pHashmapElem HashmapElem_new(void* k, void* v) {
pHashmapElem result = (pHashmapElem)internal_allocate(sizeof(HashmapElem));
if(result) {
result->_vtable = HashmapElem_vtable();
INIT(result, (pOOObject)k, (pOOObject)v);
}
return result;
}
/**
* Allocate a new List
*/
pList List_new(void) {
pList result = (pList)internal_allocate(sizeof(List));
if(result) {
result->_vtable = List_vtable();
INIT(result);
}
return result;
}
pListElem ListElem_new(void* data) {
pListElem result = (pListElem)internal_allocate(sizeof(ListElem));
if(result) {
result->_vtable = ListElem_vtable();
INIT(result, data);
}
return result;
}
void JNiftiImage2Private::copy_from(const JNiftiImage2 &X) {
internal_allocate(X.d->m_data_type,X.d->m_N1,X.d->m_N2,X.d->m_N3,X.d->m_N4);
for (int tt=0; tt<m_N4; tt++) {
q->setDataXYZ(X.dataXYZ(tt),tt);
}
m_header_parameters=X.d->m_header_parameters;
m_transformation=X.d->m_transformation;
}
void _BigInteger_asString(pVMObject object, pVMFrame frame) {
pVMBigInteger self = (pVMBigInteger)SEND(frame, pop);
// temporary storage for the number string
// use c99 snprintf-goodie
int64_t bigint = SEND(self, get_embedded_biginteger);
char* strbuf = (char*)internal_allocate(snprintf(0, 0, "%lld", bigint) +1);
sprintf(strbuf, "%lld", bigint);
SEND(frame, push, (pVMObject)Universe_new_string(strbuf));
internal_free(strbuf);
}
void allocate(const dtype& dt) {
delete[] m_storage;
m_storage = 0;
if (m_metadata) {
m_dtype.extended()->metadata_destruct(m_metadata);
delete[] m_metadata;
m_metadata = NULL;
}
m_dtype = dt;
internal_allocate();
}
/**
* Set up the Hashmap object
*/
void _Hashmap_init(void* _self, ...) {
pHashmap self = (pHashmap)_self;
SUPER(OOObject, self, init);
va_list argp;
va_start(argp, _self);
self->size = va_arg(argp, size_t);
va_end(argp);
self->elems =
(pHashmapElem*)internal_allocate(self->size * sizeof(pHashmapElem));
SEND(self, clear);
}
void allocate(const ndt::type &dt)
{
delete[] m_storage;
m_storage = 0;
if (m_arrmeta) {
m_type.extended()->arrmeta_destruct(m_arrmeta);
delete[] m_arrmeta;
m_arrmeta = NULL;
}
m_type = dt;
internal_allocate();
}
void _VMArray_set_indexable_field(void* _self, int index, pVMObject value) {
pVMArray self = (pVMArray)_self;
//CHECK_INDEX;
if(index >= SEND(self, get_number_of_indexable_fields) || index < 0) {
char* s = (char*)internal_allocate(128);
if(index >= SEND(self, get_number_of_indexable_fields))
sprintf(s, "index too large in array access: %d", index);
else
sprintf(s, "index too small in array access: %d", index);
Universe_error_exit(s);
}
// set the indexable field with the given index to the given value
self->fields[index + SEND(self, _get_offset)] = value;
}
Lexer* Lexer_create(const FILE* fp, const char* file_name) {
Lexer* lexer = internal_allocate(sizeof(Lexer));
lexer->infile = (FILE*)fp;
lexer->file_name = file_name;
lexer->line_num = 0;
lexer->sym = NONE;
lexer->symc = 0;
lexer->text[0] = 0;
lexer->peekDone = false;
lexer->nextSym = NONE;
lexer->nextSymc = 0;
lexer->nextText[0] = 0;
lexer->buf[0] = 0;
lexer->bufp = 0;
return lexer;
}
void _Hashmap_rehash(void* _self, size_t newSize) {
pHashmap self = (pHashmap)_self;
size_t oldSize = self->size;
pHashmapElem* oldElems = self->elems;
self->size = newSize;
self->elems = (pHashmapElem*)internal_allocate(
self->size * sizeof(pHashmapElem));
SEND(self, clear);
for(size_t i = 0; i < oldSize; i++)
if(oldElems[i]) {
if(!attemptPut(self, oldElems[i],
hashf(self, SEND(oldElems[i], key_hash))))
// not good, can't help
Universe_error_exit("Hashmap overflow while rehashing.\n");
else
oldElems[i] = NULL;
}
internal_free(oldElems);
}
pVMClass VMClass_assemble(class_generation_context* cgc) {
// build class class name
const char* cgc_name = SEND(cgc->name, get_chars);
char* ccname =
(char*)internal_allocate(strlen(cgc_name) + 6 + 1); // 6: " class"
strcpy(ccname, cgc_name);
strcat(ccname, " class");
pVMSymbol ccname_sym = Universe_symbol_for(ccname);
internal_free(ccname);
// Load the super class
pVMClass super_class = Universe_load_class(cgc->super_name);
// Allocate the class of the resulting class
pVMClass result_class = Universe_new_class(metaclass_class);
// Initialize the class of the resulting class
SEND(result_class, set_instance_fields,
Universe_new_array_list(cgc->class_fields));
SEND(result_class, set_instance_invokables,
Universe_new_array_list(cgc->class_methods));
SEND(result_class, set_name, ccname_sym);
pVMClass super_mclass = SEND(super_class, get_class);
SEND(result_class, set_super_class, super_mclass);
// Allocate the resulting class
pVMClass result = Universe_new_class(result_class);
// Initialize the resulting class
SEND(result, set_instance_fields,
Universe_new_array_list(cgc->instance_fields));
SEND(result, set_instance_invokables,
Universe_new_array_list(cgc->instance_methods));
SEND(result, set_name, cgc->name);
SEND(result, set_super_class, super_class);
return result;
}
inline buffer_storage(const dtype& dt)
: m_storage(NULL), m_metadata(NULL), m_dtype(dt)
{
internal_allocate();
}
inline buffer_storage(const buffer_storage& rhs)
: m_storage(NULL), m_metadata(NULL), m_dtype(rhs.m_dtype)
{
internal_allocate();
}
inline buffer_storage(const ndt::type &tp)
: m_storage(NULL), m_arrmeta(NULL), m_type(tp)
{
internal_allocate();
}
