void en_socket_datagram_connect (EIF_INTEGER fd, EIF_INTEGER fd1, EIF_POINTER sockaddr) {
SOCKETADDRESS* him;
int family;
EIF_INTEGER fdc = -1;
int ipv6_supported;
int connect_res;
EIF_NET_INITIALIZE;
ipv6_supported = en_ipv6_available();
him = (SOCKETADDRESS*) sockaddr;
family = him->him.sa_family;
if (family == AF_INET6 && !ipv6_supported) {
eraise ("Protocol family not supported", EN_PROG);
return;
}
fdc = (family == AF_INET? fd: fd1);
connect_res = connect(fdc, (struct sockaddr *)him, SOCKETADDRESS_LEN(him));
if ( connect_res == -1) {
eraise("Unable to establish connection", EN_PROG);
}
}
rt_private void parsing_store_write(size_t size)
{
RT_GET_CONTEXT
char* cmps_out_ptr = cmps_general_buffer;
lzo_uint cmps_out_size = (lzo_uint) cmp_buffer_size;
int signed_cmps_out_size;
REQUIRE("cmp_buffer_size not too big", cmp_buffer_size <= 0x7FFFFFFF);
REQUIRE("size not too big", size <= 0x7FFFFFFF);
lzo1x_1_compress (
(unsigned char *) general_buffer, /* Current buffer location */
(lzo_uint) size, /* Current buffer size */
(unsigned char *) cmps_out_ptr, /* Output buffer for compressed data */
&cmps_out_size, /* Size of output buffer and then size of compressed data */
wrkmem); /* Memory allocator */
signed_cmps_out_size = (int) cmps_out_size;
/* Write size of compressed data */
if (parsing_char_write ((char *) &signed_cmps_out_size, sizeof(int)) <= 0)
eraise ("Unable to write compressed data size", EN_IO);
/* Write compressed data */
if (parsing_char_write (cmps_out_ptr, signed_cmps_out_size) <= 0)
eraise ("Unable to write on specified device", EN_IO);
}
EIF_INTEGER en_socket_datagram_rcv_from (EIF_INTEGER fd, EIF_INTEGER fd1, EIF_INTEGER *a_last_fd, EIF_POINTER buf, EIF_INTEGER len, EIF_INTEGER flags, EIF_INTEGER timeout, SOCKETADDRESS *him) {
int nsockets = 0;
int fduse = 0;
int result;
int lenn = sizeof(SOCKETADDRESS);
int ipv6_supported = en_ipv6_available();
if (fd > 0) {
nsockets++;
}
if (fd1 > 0) {
nsockets++;
}
if (nsockets == 2) { /* need to choose one of them */
int ret, t = (timeout == 0) ? -1: timeout;
ret = net_timeout2 (fd, fd1, t, &fduse);
if (ret == 2) {
fduse = check_last_fd (a_last_fd, fd, fd1);
} else if (ret == 0) {
if (ret == 0) {
eraise("Receive timed out", EN_PROG);
} else {
eraise("Receive error", EN_PROG);
}
return -1;
}
} else if (!ipv6_supported) {
fduse = fd;
} else if (fd >= 0) {
/* ipv6 supported: and this socket bound to an IPV6 only address */
fduse = fd1;
} else {
/* ipv6 supported: and this socket bound to an IPV4 only address */
fduse = fd;
}
if (timeout && nsockets == 1) {
int ret;
ret = net_timeout(fduse, timeout);
if (ret <= 0) {
if (ret == 0) {
eraise("Receive timed out", EN_PROG);
} else {
eraise("Receive error", EN_PROG);
}
return -1;
}
}
result = recvfrom ((SOCKET) fduse, (char *) buf, (int) len, (int) flags, (struct sockaddr *) him, &lenn);
eif_net_check (result);
return (EIF_INTEGER) result;
}
/*
* Current position within file.
*/
EIF_INTEGER eif_file_tell(FILE *f) {
long res;
if (f == (FILE *) 0) {
eraise("invalid file pointer", EN_EXT);
}
res = ftell(f);
if (res == -1) {
eraise("error occurred", EN_EXT);
}
return (EIF_INTEGER) res;
}
/*
* Return the associated file descriptor.
*/
EIF_INTEGER eif_file_fd(FILE *f) {
int res;
if (!f) {
res = 0;
eraise("invalid file pointer", EN_EXT);
} else {
res = fileno(f);
if (res == -1) {
eraise("error occurred", EN_EXT);
}
}
return (EIF_INTEGER) res;
}
rt_private void parsing_store_append(struct rt_store_context *a_context, EIF_REFERENCE object, fnptr mid, fnptr nid)
{
RT_GET_CONTEXT
struct rt_traversal_context traversal_context;
int gc_stopped;
make_index = mid;
need_index = nid;
gc_stopped = !eif_gc_ison();
eif_gc_stop(); /* Procedure `make_index' may call the GC
* while creating objects. */
/* Need to hold mutex here since we are using traversal. */
EIF_EO_STORE_LOCK;
#ifdef DEBUG
(void) nomark(object);
#endif
/* Do the traversal: mark and count the objects to store */
memset(&traversal_context, 0, sizeof(struct rt_traversal_context));
traversal_context.is_for_persistence = 1;
traversal(&traversal_context, object);
current_position = 0;
end_of_buffer = 0;
/* Write in file `file_descriptor' the count of stored objects */
buffer_write((char *) (&traversal_context.obj_nb), sizeof(uint32));
#ifndef DEBUG
(void) pst_store(a_context, object,0L); /* Recursive store process */
#else
{
uint32 nb_stored = pst_store(a_context, object,0L);
if (traversal_context.obj_nb != nb_stored) {
printf("obj_nb = %d nb_stored = %d\n", traversal_context.obj_nb, nb_stored);
eraise ("Eiffel partial store", EN_IO);
}
}
if (traversal_context.obj_nb != nomark(object))
eraise ("Partial store inconsistency", EN_IO);
#endif
a_context->flush_buffer_function(); /* Flush the buffer */
EIF_EO_STORE_UNLOCK; /* Unlock our mutex. */
if (!gc_stopped)
eif_gc_run(); /* Restart GC */
}
rt_public long store_append(EIF_INTEGER f_desc, char *object, fnptr mid, fnptr nid, EIF_REFERENCE s)
{
/* Append `object' in file `f', and applies routine `mid'
* on server `s'. Return position in the file where the object is
* stored. */
/* Initialization */
server = s;
if ((file_position = lseek ((int) f_desc, 0, SEEK_END)) == -1)
eraise ("Unable to seek on internal data files", EN_SYS);
/* Initialize store context used to store objects for appending. */
rt_setup_store (&parsing_context, BASIC_STORE);
parsing_store_append(&parsing_context, object, mid, nid);
/* Write `parsing_buffer' onto `f_desc'. If we cannot write `parsing_position' bytes
* we have a failure. */
if (write (f_desc, parsing_buffer, parsing_position) != parsing_position) {
eio();
}
parsing_position = 0;
return file_position;
}
void set_matrix(SquareBinaryMatrix &m) {
if((uint_t)m.get_size() != key_len)
eraise(InvalidMatrix) << "Size of matrix '" << m.get_size()
<< "' not equal to key length '" << key_len << "'";
hash_matrix = m;
hash_inverse_matrix = m.inverse();
}
bloom_filter(size_t m, unsigned long k, const HashPair& fns = HashPair()) :
mem_block_t(super::nb_bytes__(m)),
super(m, k, (unsigned char*)mem_block_t::get_ptr(), fns)
{
if(!mem_block_t::get_ptr())
eraise(std::runtime_error) << "Failed to allocate " << super::nb_bytes__(m) << " bytes of memory for bloom_filter";
}
rt_private void parsing_compiler_write(size_t size)
{
RT_GET_CONTEXT
char* cmps_out_ptr = cmps_general_buffer;
lzo_uint cmps_out_size = (lzo_uint) cmp_buffer_size;
int signed_cmps_out_size;
int number_written;
REQUIRE("cmp_buffer_size not too big", cmp_buffer_size <= 0x7FFFFFFF);
REQUIRE("size not too big", size <= 0x7FFFFFFF);
lzo1x_1_compress (
(unsigned char *) general_buffer, /* Current buffer location */
(lzo_uint) size, /* Current buffer size */
(unsigned char *) cmps_out_ptr, /* Output buffer for compressed data */
&cmps_out_size, /* Size of output buffer and then size of compressed data */
wrkmem); /* Memory allocator */
signed_cmps_out_size = (int) cmps_out_size;
/* Write size of compressed data */
if (write (file_descriptor, (char *) &signed_cmps_out_size, sizeof(int)) <= 0)
eraise ("Unable to write compressed data size", EN_IO);
/* Write compressed data */
while (signed_cmps_out_size > 0) {
number_written = write (file_descriptor, cmps_out_ptr, signed_cmps_out_size);
if (number_written <= 0)
eio();
signed_cmps_out_size -= number_written;
cmps_out_ptr += number_written;
}
}
void
priv_queue::log_call(processor *client, call_data *call)
{
bool will_sync = call_data_sync_pid (call) != NULL_PROCESSOR_ID;
push (pq_message (pq_message::e_normal, client, call));
if (will_sync)
{
processor *client = registry[call_data_sync_pid (call)];
call_stack_msg = client->result_notify.wait();
for (;
call_stack_msg.type == notify_message::e_callback;
call_stack_msg = client->result_notify.wait())
{
(*client)(call_stack_msg.client, call_stack_msg.call);
call_stack_msg.call = NULL;
}
if (call_stack_msg.type == notify_message::e_dirty)
{
char *msg = "EVE/Qs dirty processor exception";
eraise (msg, 32);
}
}
synced = will_sync;
}
rt_private EIF_INTEGER private_object_id(EIF_REFERENCE object, struct stack *st, EIF_INTEGER *max_value_ptr)
{
register unsigned int stack_number = 0;
register struct stchunk *end;
register EIF_INTEGER Result;
char *address;
if (-1 == epush(st, object)) { /* Cannot record object */
eraise("object id", EN_MEM); /* No more memory */
return (EIF_INTEGER) 0; /* They ignored it */
}
address = (char *) (st->st_top - 1); /* Was allocated here */
eif_access(address) = object; /* Record object's physical address */
/* Get the stack number */
for(end = st->st_hd;
end != st->st_cur;
stack_number++)
end = end->sk_next;
Result = (EIF_INTEGER) (stack_number*STACK_SIZE+1-(st->st_cur->sk_arena-(char **)address));
if (Result>*max_value_ptr)
*max_value_ptr = Result;
#ifdef DEBUG
dprintf (2) ("eif_object_id %d %lx %lx\n", Result, address, object);
#endif
return Result;
}
bloom_filter(double fp, size_t n, const HashPair& fns = HashPair()) :
mem_block_t(super::nb_bytes__(super::opt_m(fp, n))),
super(super::opt_m(fp, n), super::opt_k(fp), (unsigned char*)mem_block_t::get_ptr(), fns)
{
if(!mem_block_t::get_ptr())
eraise(std::runtime_error) << "Failed to allocate " << super::nb_bytes__(super::opt_m(fp, n))
<< " bytes of memory for bloom_filter";
}
/*
doc: <routine name="ht_force" export="shared">
doc: <summary>Put value `val' associated with key `key' in table `ht'. If `ht' is full, we will resize `ht' and try again. If `resizing' failed or if we cannot find a suitable position, an exception is thrown. In other words, it is the same as `ht_safe_force' modulo an exception instead of an error code.</summary>
doc: <param name="ht" type="struct htable *">Table to initialize.</param>
doc: <param name="key" type="rt_uint_ptr">Key to insert in `ht'.</param>
doc: <param name="val" type="void *">Value to insert in `ht'.</param>
doc: <thread_safety>Not Safe</thread_safety>
doc: <synchronization>None</synchronization>
doc: </routine>
*/
rt_shared void ht_force(struct htable *ht, rt_uint_ptr key, void * val)
{
int l_error;
REQUIRE("ht not null", ht);
REQUIRE("key not null", key);
l_error = ht_safe_force (ht, key, val);
if (l_error != 0) {
if (l_error == -1) {
eraise ("Hash table resizing failure", EN_FATAL);
} else {
CHECK("valid error code", l_error == -2);
eraise ("Hash table insertion failure", EN_FATAL);
}
}
}
void map(const char *filename) {
int fd = open(filename, O_RDONLY);
struct stat stat;
if(fd < 0)
eraise(ErrorMMap) << "Can't open file '" << filename << "'" << err::no;
if(fstat(fd, &stat) < 0)
eraise(ErrorMMap) << "Can't stat file '" << filename << "'" << err::no;
_length = stat.st_size;
_base = (char *)mmap(NULL, _length, PROT_READ, MAP_SHARED, fd, 0);
if(_base == MAP_FAILED)
eraise(ErrorMMap) << "Can't mmap file '" << filename << "'" << err::no;
close(fd);
_end = _base + _length;
}
void resize() {
_capacity *= 2;
void * ndata = realloc(_data, sizeof(T) * _capacity);
if(ndata == 0) {
free(ndata);
_data = 0;
_capacity = _capacity / 2;
eraise(SimpleGrowingArrayError) << "Out of memory" << err::no;
}
_data = (T*)ndata;
}
double_fifo_input<T>::double_fifo_input(unsigned long _nb_buckets) :
rq(_nb_buckets), wq(_nb_buckets), nb_buckets(_nb_buckets), state(WORKING),
input_id(0)
{
buckets = new T[nb_buckets];
for(unsigned long i = 0; i < nb_buckets; ++i)
wq.enqueue(&buckets[i]);
if(pthread_create(&input_id, 0, static_input_routine, (void *)this) != 0)
eraise(Error) << "Failed creating input thread" << err::no;
}
void host_address_from_name (EIF_POINTER addr, EIF_POINTER name)
/*x 32-bits netid/hostid set in addr from hostname name */
{
struct hostent *hp;
#ifdef VXWORKS
int h_errno = 0;
#endif
EIF_NET_INITIALIZE;
#ifdef VXWORKS
hp = NULL;
#else
hp = gethostbyname((char *) name);
#endif
if (hp == (struct hostent *) 0) {
#ifdef EIF_WINDOWS
eif_net_check(EIFNET_ERROR_HAPPENED);
#else
/* On Unix, `gethostbyname' does not set errno, but h_errno. This is why
* we cannot use `eif_net_check'. */
errno = h_errno;
if (h_errno == HOST_NOT_FOUND) {
eraise ("The specified host is unknown.", EN_ISE_IO);
} else if (h_errno == NO_ADDRESS || h_errno == NO_DATA) {
eraise ("The requested name is valid but does not have an IP address.", EN_ISE_IO);
} else if (h_errno == NO_RECOVERY) {
eraise ("A non-recoverable name server error occurred.", EN_ISE_IO);
} else if (h_errno == TRY_AGAIN) {
eraise ("A temporary error occurred on an authoritative name server. Try again later.", EN_ISE_IO);
} else {
eio();
}
#endif
}
((struct in_addr *) addr)->s_addr = ((struct in_addr *) (hp->h_addr))->s_addr;
}
rt_public void eif_extend_object_id_stack (EIF_INTEGER nb_chunks)
/* extends of `nb_chunks the size of `object_id_stack' */
{
#ifdef ISE_GC
RT_GET_CONTEXT
struct stack *st = &object_id_stack;
char **top;
struct stchunk * current;
char **end;
EIF_OBJECT_ID_LOCK;
if (st->st_top == (char **) 0) {
top = st_alloc(st, eif_stack_chunk); /* Create stack */
if (top == (char **) 0) {
EIF_OBJECT_ID_UNLOCK;
eraise ("Couldn't allocate object id stack", EN_MEM);
}
/* No memory */
st->st_top = top; /* Update new top */
}
current = st->st_cur; /* save previous current stchunk */
top = st->st_top; /* save previous top of stack */
end = st->st_end; /*save previous st_end of stack */
SIGBLOCK; /* Critical section */
while (--nb_chunks) {
if (-1 == st_extend(st, eif_stack_chunk)) {
EIF_OBJECT_ID_UNLOCK;
eraise ("Couldn't allocate object id stack", EN_MEM);
}
}
st->st_cur = current; /* keep previous Current */
st->st_top = top; /* keep previous top */
st->st_end = end;
SIGRESUME; /* End of critical section */
EIF_OBJECT_ID_UNLOCK;
#endif
}
static SOCKET check_socket_bounds (SOCKET l_socket) {
#ifdef EIF_64_BITS
/* On 64-bit system `SOCKET' is actually a pointer. For the moment, we check that
* it is not coded on the whole 64-bit. */
if (l_socket != INVALID_SOCKET) {
if ((l_socket & RTU64C(0x00000000FFFFFFFF)) != l_socket) {
/* We are in trouble. Raise an exception for the moment. */
eraise ("Descriptor too big to be represented as INTEGER_32", EN_PROG);
}
}
#endif
return l_socket;
}
generator_manager(const char* cmds, int nb_pipes, const char* shell = 0) :
cmds_(cmds),
pipes_(nb_pipes),
manager_pid_(-1),
shell_(shell),
kill_signal_(0)
{
if(!cmds_.good())
eraise(std::runtime_error) << "Failed to open cmds file '" << cmds << "'";
if(!shell_)
shell_ = getenv("SHELL");
if(!shell_)
shell_ = "/bin/sh";
}
rt_public void run_idr_init (size_t idrf_size, int type)
{
RT_GET_CONTEXT
idrf_buffer_size = idrf_size;
run_idr_read_func = run_idr_read;
/* Because we might mark the first `n' bytes of the buffer (see above
* instruction), we need to make sure that we have enough allocated memory
* to read or store `idrf_buffer_size' bytes.
*/
if (-1 == idrf_create (&idrf, idrf_size + sizeof(int32)))
eraise ("cannot allocate idrf", EN_MEM);
/* Reset amount_read */
amount_read = 0;
/* When writting a storable we mark some space at the front of the buffer
* to store upon writting the size of block, so that only one write operation
* is performed */
if (type) {
idr_setpos (&idrf.i_encode, sizeof(int32));
}
#ifdef EIF_64_BITS
idr_ref_table_counter = 0;
idr_ref_table = (struct htable*) eif_rt_xmalloc (sizeof (struct htable), C_T, GC_OFF);
if (idr_ref_table == NULL) {
eraise ("Cannot allocate 64-32 mapping table", EN_MEM);
xraise (EN_MEM);
} else {
if (ht_create (idr_ref_table, 10000, sizeof(rt_uint_ptr)) == -1) {
eraise ("Cannot create 64-32 mapping table", EN_MEM);
}
}
#endif
}
/* {STRING_SEARCHER}.make */
void F131_1906 (EIF_REFERENCE Current)
{
GTCX
char *l_feature_name = "make";
RTEX;
EIF_TYPED_VALUE ui4_1x = {{0}, SK_INT32};
#define ui4_1 ui4_1x.it_i4
EIF_REFERENCE tr1 = NULL;
EIF_INTEGER_32 ti4_1;
RTCDT;
RTSN;
RTDA;
RTLD;
RTLI(2);
RTLR(0,Current);
RTLR(1,tr1);
RTLU (SK_VOID, NULL);
RTLU (SK_REF, &Current);
RTEAA(l_feature_name, 130, Current, 0, 0, 1851);
RTSA(dtype);
RTSC;
RTME(dtype, 0);
RTGC;
RTDBGEAA(130, Current, 1851);
RTIV(Current, RTAL);
RTHOOK(1);
RTDBGAA(Current, dtype, 1748, 0xF800020D, 0); /* deltas */
ti4_1 = (((FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTWF(1743, dtype))(Current)).it_i4);
ui4_1 = (EIF_INTEGER_32) (ti4_1 + ((EIF_INTEGER_32) 1L));
if (ui4_1< 0) {
eraise ("non_negative_argument", EN_RT_CHECK);
}
tr1 = RTLNSP2(eif_non_attached_type(RTWCT(1748, dtype, Dftype(Current))),0,ui4_1,sizeof(EIF_INTEGER_32), EIF_TRUE);
RT_SPECIAL_COUNT(tr1) = 0;
RTAR(Current, tr1);
*(EIF_REFERENCE *)(Current + RTWA(1748, dtype)) = (EIF_REFERENCE) tr1;
RTVI(Current, RTAL);
RTRS;
RTHOOK(2);
RTDBGLE;
RTMD(0);
RTLE;
RTLO(2);
RTEE;
#undef ui4_1
}
/// Open the next file with given prefix. If one_file is false,
/// append _0, _1, etc. to the prefix for actual file name. If
/// one_file is true, the prefix is the file name. The first time
/// the file is open in trunc mode, the subsequent times in append
/// mode.
void open_next_file(const char *prefix, std::ofstream &out) {
std::ostringstream name;
name << prefix;
std::ios::openmode mode = std::ios::out;
if(one_file_) {
mode |= (index_++ ? std::ios::ate : std::ios::trunc);
} else {
name << index_++;
mode |= std::ios::trunc;
}
file_names_.push_back(name.str());
out.open(name.str().c_str());
if(out.fail())
eraise(ErrorWriting) << "'" << name.str() << "': "
<< "Can't open file for writing" << err::no;
}
int net_char_read(char *pointer, int size)
{
GTCX
int i;
#ifdef EIF_VMS
int rcvbuf = get_socket_maxrecv (socket_fides);
int chunksize = size;
if (size > rcvbuf) chunksize = rcvbuf;
#endif
retry:
#ifdef EIF_WINDOWS
i = recv(socket_fides, pointer, size, 0);
#elif defined EIF_VMS
i = recv(socket_fides, pointer, chunksize, 0);
#else
i = read(socket_fides, pointer, size);
#endif
if (i == SOCKET_ERROR && GET_SOCKET_ERROR == EWOULDBLOCK)
{
if (!net_socket_ready(1))
{
/* The desired socket is not ready. Raise an
exception. */
eraise(SOCKET_UNAVAILABLE_FOR_READING, EN_RETR);
} else {
/* Should not issue a recursive call here as this may
potentially lead to an unbounded number of recursive
calls, thus causing stack overflow should the
socket issue this error many times in succession. */
goto retry;
}
}
else if (i > 0 && i < size)
{
int prev = i;
/* A recursive call here is bounded because the remaining
number of bytes is guaranteed to decrease each call. */
i = net_char_read(pointer + i, size - i);
if (i > 0)
i += prev;
}
return i;
}
/* Return a buffer large enough to hold the specified minimum size.
*/
rt_private char* net_buffer (int min_size)
{
static char* buffer = NULL;
static int buffer_size = 0;
if (buffer_size < min_size)
{
if (buffer == NULL)
buffer = (char*) malloc (min_size);
else
buffer = (char*) realloc (buffer, min_size);
if (buffer == NULL)
eraise ("Out of memory in buffered_write", EN_RETR);
else
buffer_size = min_size;
}
return buffer;
}
array(size_t _size, uint_t _key_len, uint_t _val_len,
uint_t _reprobe_limit, size_t *_reprobes) :
lsize(ceilLog2(_size)), size(((size_t)1) << lsize),
size_mask(size - 1),
reprobe_limit(_reprobe_limit, _reprobes, size), key_len(_key_len),
key_mask(key_len <= lsize ? 0 : (((word)1) << (key_len - lsize)) - 1),
key_off(key_len <= lsize ? 0 : key_len - lsize),
offsets(key_off + bitsize(reprobe_limit.val() + 1), _val_len,
reprobe_limit.val() + 1),
mem_block(div_ceil(size, (size_t)offsets.get_block_len()) * offsets.get_block_word_len() * sizeof(word)),
data((word *)mem_block.get_ptr()), reprobes(_reprobes),
hash_matrix(key_len),
hash_inverse_matrix(hash_matrix.init_random_inverse())
{
if(!data)
eraise(ErrorAllocation) << "Failed to allocate "
<< (div_ceil(size, (size_t)offsets.get_block_len()) * offsets.get_block_word_len() * sizeof(word))
<< " bytes of memory";
}
rt_shared void do_init(void)
{
WORD wVersionRequested;
WSADATA wsaData;
int err;
static BOOL done = FALSE;
if (!done) {
wVersionRequested = MAKEWORD(2, 0);
err = WSAStartup(wVersionRequested, &wsaData);
if (err != 0) {
fprintf (stderr, "Communications error %d", err);
eraise ("Unable to start WINSOCK", EN_PROG);
}
#ifndef EIF_IL_DLL
eif_register_cleanup(eif_winsock_cleanup);
#endif
done = TRUE;
}
}
// key_len passed in bits
binary_query_base(const char* data, unsigned int key_len, unsigned int val_len, const RectangularBinaryMatrix& m, size_t mask,
size_t size) :
data_(data),
val_len_(val_len),
key_len_(key_len / 8 + (key_len % 8 != 0)),
m_(m),
mask_(mask),
record_len_(val_len + key_len_),
last_id_(size / record_len_),
first_key_(key_len / 2),
last_key_(key_len / 2),
mid_key_(key_len / 2)
{
if(size % record_len_ != 0)
eraise(std::length_error) << "Size of database (" << size << ") must be a multiple of the length of a record ("
<< record_len_ << ")";
key_at(0, first_key_);
first_pos_ = key_pos(first_key_);
key_at(last_id_ - 1, last_key_);
last_pos_ = key_pos(last_key_);
}
/* {TO_SPECIAL}.make_empty_area */
void F202_1852 (EIF_REFERENCE Current, EIF_TYPED_VALUE arg1x)
{
GTCX
char *l_feature_name = "make_empty_area";
RTEX;
#define arg1 arg1x.it_i4
EIF_TYPED_VALUE up1x = {{0}, SK_POINTER};
#define up1 up1x.it_p
EIF_TYPED_VALUE ui4_1x = {{0}, SK_INT32};
#define ui4_1 ui4_1x.it_i4
EIF_REFERENCE tr1 = NULL;
EIF_INTEGER_32 ti4_1;
RTCDT;
RTSN;
RTDA;
RTLD;
if ((arg1x.type & SK_HEAD) == SK_REF) arg1x.it_i4 = * (EIF_INTEGER_32 *) arg1x.it_r;
RTLI(2);
RTLR(0,Current);
RTLR(1,tr1);
RTLU (SK_VOID, NULL);
RTLU(SK_INT32,&arg1);
RTLU (SK_REF, &Current);
RTEAA(l_feature_name, 201, Current, 0, 1, 2360);
RTSA(dtype);
RTSC;
RTME(dtype, 0);
RTGC;
RTDBGEAA(201, Current, 2360);
RTIV(Current, RTAL);
if ((RTAL & CK_REQUIRE) || RTAC) {
RTHOOK(1);
RTCT("non_negative_argument", EX_PRE);
RTTE((EIF_BOOLEAN) (arg1 >= ((EIF_INTEGER_32) 0L)), label_1);
RTCK;
RTJB;
label_1:
RTCF;
}
body:;
RTHOOK(2);
RTDBGAA(Current, dtype, 1556, 0xF80000B1, 0); /* area */
ui4_1 = arg1;
if (ui4_1< 0) {
eraise ("non_negative_argument", EN_RT_CHECK);
}
tr1 = RTLNSP2(eif_non_attached_type(RTWCT(1556, dtype, Dftype(Current))),EO_REF,ui4_1,sizeof(EIF_REFERENCE), EIF_FALSE);
RT_SPECIAL_COUNT(tr1) = 0;
RTAR(Current, tr1);
*(EIF_REFERENCE *)(Current + RTWA(1556, dtype)) = (EIF_REFERENCE) tr1;
if (RTAL & CK_ENSURE) {
RTHOOK(3);
RTCT("area_allocated", EX_POST);
tr1 = ((up1x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTWF(1556, dtype))(Current)), (((up1x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up1x.it_r = RTBU(up1x))), (up1x.type = SK_POINTER), up1x.it_r);
if ((EIF_BOOLEAN)(tr1 != NULL)) {
RTCK;
} else {
RTCF;
}
RTHOOK(4);
RTCT("capacity_set", EX_POST);
tr1 = ((up1x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTWF(1556, dtype))(Current)), (((up1x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up1x.it_r = RTBU(up1x))), (up1x.type = SK_POINTER), up1x.it_r);
RTNHOOK(4,1);
ti4_1 = (((FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTVF(1624, "capacity", tr1))(tr1)).it_i4);
if ((EIF_BOOLEAN)(ti4_1 == arg1)) {
RTCK;
} else {
RTCF;
}
RTHOOK(5);
RTCT("count_set", EX_POST);
tr1 = ((up1x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTWF(1556, dtype))(Current)), (((up1x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up1x.it_r = RTBU(up1x))), (up1x.type = SK_POINTER), up1x.it_r);
RTNHOOK(5,1);
ti4_1 = (((FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTVF(1623, "count", tr1))(tr1)).it_i4);
if ((EIF_BOOLEAN)(ti4_1 == ((EIF_INTEGER_32) 0L))) {
RTCK;
} else {
RTCF;
}
}
RTVI(Current, RTAL);
RTRS;
RTHOOK(6);
RTDBGLE;
RTMD(0);
RTLE;
RTLO(3);
RTEE;
#undef up1
#undef ui4_1
#undef arg1
}
