int
nurand (int A, int x, int y, int C, char *estado1, char *estado2)
{
/* ------------------------------------------------------- *\
|* Función que genera un número aleatório con distribución *|
|* no uniforme, según el método definifido en la cláusula *|
|* 2.1.6 del TPC-C. *|
|* ------------------------------------------------------- *|
|* Parámetro A: entero que determina el intervalo [0, A] *|
|* para determinar un núero aleatório necesário la *|
|* generación del núemro buscado. *|
|* Parámetro x: inicio del itervalo de selección. *|
|* Parámetro y: fin del itervalo de selección. *|
|* Parámetro C: constante seleccionada para cada atributo. *|
|* Parámetro estado1: estado para la generación de un *|
|* número aleatorio seleccionado entre x e y *|
|* Parámetro estado2: estado para la generación de un *|
|* número aleatorio seleccionado 0 y A *|
|* ------------------------------------------------------- *|
|* Retorna el número generado. *|
\* ------------------------------------------------------- */
int lon1, lon2;
setstate (estado1);
lon1 = aleat_int (x, y);
setstate (estado2);
lon2 = aleat_int (0, A);
/*Se obtienen el número según la cláusula 2.1.6 */
return (((lon2 | lon1) + C) % (y - x + 1)) + x;
};
/* play CD audio */
static int ioctl_command_play (int unitnum, int startlsn, int endlsn, int scan, play_status_callback statusfunc, play_subchannel_callback subfunc)
{
struct dev_info_ioctl *ciw = unitisopen (unitnum);
if (!ciw)
return 0;
ciw->cdda_play_finished = 0;
ciw->cdda_subfunc = subfunc;
ciw->cdda_statusfunc = statusfunc;
ciw->cdda_scan = scan > 0 ? 10 : (scan < 0 ? 10 : 0);
ciw->cdda_delay = setstate (ciw, -1);
ciw->cdda_delay_frames = setstate (ciw, -2);
setstate (ciw, AUDIO_STATUS_NOT_SUPPORTED);
if (!open_createfile (ciw, 0)) {
setstate (ciw, AUDIO_STATUS_PLAY_ERROR);
return 0;
}
if (!isaudiotrack (&ciw->di.toc, startlsn)) {
setstate (ciw, AUDIO_STATUS_PLAY_ERROR);
return 0;
}
if (!ciw->cdda_play) {
uae_start_thread (_T("ioctl_cdda_play"), cdda_play, ciw, NULL);
}
ciw->cdda_start = startlsn;
ciw->cdda_end = endlsn;
ciw->cd_last_pos = ciw->cdda_start;
ciw->cdda_play++;
return 1;
}
istream& istream::getline(char *str, streamsize n, char delim) {
FatPos_t pos;
int c;
m_gcount = 0;
if (n > 0) str[0] = '\0';
while (1) {
c = getch(&pos);
if (c < 0) {
break;
}
if (c == delim) {
m_gcount++;
break;
}
if ((m_gcount + 1) >= n) {
setpos(&pos);
setstate(failbit);
break;
}
str[m_gcount++] = c;
str[m_gcount] = '\0';
}
if (m_gcount == 0) setstate(failbit);
return *this;
}
/// \details
/// Registers a function as an event callback with an integer parameter to
/// be passed to the function when invoked. Multiple copies of the
/// function are allowed. If there are multiple callbacks, they are
/// invoked in the order they were registered.
void
ios_base::register_callback(event_callback fn __attribute__((unused)),
int index __attribute__((unused)))
{
size_t req_size = __event_size_ + 1;
if (req_size > __event_cap_)
{
size_t newcap;
const size_t mx = numeric_limits < size_t > ::max();
if (req_size < mx / 2)
newcap = _VSTD::max(2 * __event_cap_, req_size);
else
newcap = mx;
event_callback* fns = (event_callback*) realloc(__fn_,
newcap * sizeof(event_callback));
if (fns == 0)
setstate(badbit);
__fn_ = fns;
int* indxs = (int*) realloc(__index_, newcap * sizeof(int));
if (indxs == 0)
setstate(badbit);
__index_ = indxs;
}
__fn_[__event_size_] = fn;
__index_[__event_size_] = index;
++__event_size_;
}
void ostream::outstr(const char *d, const char *p)
{
if( opfx() )
{
int plen = p ? strlen(p) : 0;
int dlen = d ? strlen(d) : 0;
int pad = width(0) - plen - dlen;
// pad on left (right-adjust) if needed -- the default case
if( ! (x_flags & (ios::left | ios::internal)) )
{
while( --pad >= 0 )
{
if( bp->sputc(x_fill) == EOF )
{
setstate(ios::badbit);
break;
}
}
}
// output the prefix
if( ! fail() && plen )
if( bp->sputn(p, plen) != plen )
setstate(ios::badbit);
// internal padding if needed
if( ! fail() && (x_flags & ios::internal) )
{
while( --pad >= 0 )
{
if( bp->sputc(x_fill) == EOF )
{
setstate(ios::badbit);
break;
}
}
}
// output the data
if( ! fail() && dlen )
if( bp->sputn(d, dlen) != dlen )
setstate(ios::badbit);
// pad on right (left-adjust) if needed
if( ! fail() && (x_flags & ios::left) )
{
while( --pad >= 0 )
{
if( bp->sputc(x_fill) == EOF )
{
setstate(ios::badbit);
break;
}
}
}
}
osfx();
}
static void WINAPI ctrlproc(DWORD ctrl) {
if (ctrl == SERVICE_CONTROL_STOP) {
setstate(SERVICE_STOP_PENDING);
service->stop();
} else {
setstate(sta.dwCurrentState);
}
}
static int32_t
FcRandom(void)
{
int32_t result;
#if HAVE_RANDOM_R
static struct random_data fcrandbuf;
static char statebuf[256];
static FcBool initialized = FcFalse;
if (initialized != FcTrue)
{
initstate_r(time(NULL), statebuf, 256, &fcrandbuf);
initialized = FcTrue;
}
random_r(&fcrandbuf, &result);
#elif HAVE_RANDOM
static char statebuf[256];
char *state;
static FcBool initialized = FcFalse;
if (initialized != FcTrue)
{
state = initstate(time(NULL), statebuf, 256);
initialized = FcTrue;
}
else
state = setstate(statebuf);
result = random();
setstate(state);
#elif HAVE_LRAND48
result = lrand48();
#elif HAVE_RAND_R
static unsigned int seed = time(NULL);
result = rand_r(&seed);
#elif HAVE_RAND
static FcBool initialized = FcFalse;
if (initialized != FcTrue)
{
srand(time(NULL));
initialized = FcTrue;
}
result = rand();
#else
# error no random number generator function available.
#endif
return result;
}
static void WINAPI startproc(int argc, TCHAR **argv) {
hsta = RegisterServiceCtrlHandler(service_name, ctrlproc);
sta.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
sta.dwServiceSpecificExitCode = 0;
sta.dwControlsAccepted = SERVICE_ACCEPT_STOP;
sta.dwWin32ExitCode = 0;
sta.dwWaitHint = 3000;
sta.dwCheckPoint = 0;
setstate(SERVICE_RUNNING);
service->start(argc, argv);
setstate(SERVICE_STOPPED);
}
int
cad_alfa_num (int ini, int fin, char *cadena, char *estado1, char *estado2)
{
/* ------------------------------------------------------ *\
|* Función que genera una cadena de caracteres *|
|* alfanuméricos de tamaño comfrendido entre *|
|* 'ini' y 'fin' *|
|* ------------------------------------------------------ *|
|* Parámetro ini: inicio del entervalo de selección del *|
|* tamaño *|
|* Parámetro fin: fin del entervalo de selección del tamaño*|
|* Parámetro cadena: cadena donde se almacenan los *|
|* caractero aleatorios *|
|* Parámetro estado1: estado para la generación del *|
|* tamaño de la cadena aleatoria *|
|* Parámetro estado2: estado para la generación del *|
|* de los caracteres aleatorios *|
|* ------------------------------------------------------ *|
|* Retorna el tamaño de la cadena generada *|
\* ------------------------------------------------------ */
int tam, i;
char ch;
/* utilizamos estado1 para el tamaño de la cadena */
setstate (estado1);
tam = (int) aleat_int (ini, fin);
setstate (estado2);
/* utilizamos estado2 para los caracteres aleatorios (e_global) */
/*Se generan cada uno de los caracteres hasta completar el */
/*el tamaño generado */
for (i = 0; i < tam; i++)
{
ch = (char) aleat_int (32, 125); /*generamos aleatoriamente caracteres. */
if ((ch >= 32) && (ch <= 125))
{ /*sólo se contemplas caracteres alfanuméricos */
/*ATENCIÖN: si el caracter generado en el 39 (comilla simple ') se escoje el */
/*caracter 40. Esto se hace para evitar el error produce postgreSQL al */
/*introducir una comilla simple en un atributo. */
if (ch == 39)
ch++;
cadena[i] = ch;
}
else
{
printf ("ERROR EN LA FUNCION CAD_ALFA_NUM\n");
exit (0);
}
} /* de for */
cadena[i] = '\0'; /*se termina la cadena con el fin de cadena */
return tam; /*se retorna el tamaño de la cadena generada */
}
void fstreambase::setbuf( char *buf, int len ) {
filebuf *fb;
__lock_it( __i_lock );
fb = rdbuf();
if( fb == NULL ) {
setstate( ios::failbit );
} else {
__lock_it( fb->__b_lock );
if( fb->setbuf( buf, len ) == NULL ) {
setstate( ios::failbit );
}
}
}
void fstreambase::close() {
filebuf *fb;
__lock_it( __i_lock );
fb = rdbuf();
if( fb == NULL ) {
setstate( ios::failbit );
} else {
__lock_it( fb->__b_lock );
if( fb->close() == NULL ) {
setstate( ios::failbit );
}
}
}
locale
ios_base::imbue(const locale& loc)
{
locale result = *loc_;
#ifndef _EWL_NO_EXCEPTIONS
try
{
#endif // _EWL_NO_EXCEPTIONS
locale* newloc = new locale(loc);
#ifdef _EWL_NO_EXCEPTIONS
if (newloc == 0)
__ewl_error("ios_base::imbue out of memory");
#endif // _EWL_NO_EXCEPTIONS
delete loc_;
loc_ = newloc;
#ifndef _EWL_TINY_IO
do_callbacks(imbue_event);
#endif
#ifndef _EWL_NO_EXCEPTIONS
}
catch (...)
{
setstate(badbit);
}
#endif // _EWL_NO_EXCEPTIONS
return result;
}
void FileIOS::close()
{
if (!_buf.close())
{
setstate(ios_base::badbit);
}
}
// Set up first user process.
void
userinit(void)
{
struct proc *p;
extern uchar _binary_initcode_start[], _binary_initcode_size[];
p = copyproc(0);
p->sz = PAGE;
p->mem = kalloc(p->sz);
p->cwd = namei("/");
memset(p->tf, 0, sizeof(*p->tf));
p->tf->cs = (SEG_UCODE << 3) | DPL_USER;
p->tf->ds = (SEG_UDATA << 3) | DPL_USER;
p->tf->es = p->tf->ds;
p->tf->ss = p->tf->ds;
p->tf->eflags = FL_IF;
p->tf->esp = p->sz;
// Make return address readable; needed for some gcc.
p->tf->esp -= 4;
*(uint*)(p->mem + p->tf->esp) = 0xefefefef;
// On entry to user space, start executing at beginning of initcode.S.
p->tf->eip = 0;
memmove(p->mem, _binary_initcode_start, (int)_binary_initcode_size);
safestrcpy(p->name, "initcode", sizeof(p->name));
#ifdef LOTTERY
p->tickets = INIT_TICKETS;
#endif
p->state = UNUSED;
setstate(p, RUNNABLE);
initproc = p;
}
// Atomically release lock and sleep on chan.
// Reacquires lock when reawakened.
void
sleep(void *chan, struct spinlock *lk)
{
if(cp == 0)
panic("sleep");
if(lk == 0)
panic("sleep without lk");
// Must acquire proc_table_lock in order to
// change p->state and then call sched.
// Once we hold proc_table_lock, we can be
// guaranteed that we won't miss any wakeup
// (wakeup runs with proc_table_lock locked),
// so it's okay to release lk.
if(lk != &proc_table_lock){
acquire(&proc_table_lock);
release(lk);
}
// Go to sleep.
cp->chan = chan;
// cp->state = SLEEPING;
setstate(cp, SLEEPING);
sched();
// Tidy up.
cp->chan = 0;
// Reacquire original lock.
if(lk != &proc_table_lock){
release(&proc_table_lock);
acquire(lk);
}
}
// read the put pointer's position
streampos ostream::tellp()
{
streampos p = EOF;
if( bad() || (p = bp->seekoff(0, ios::cur, ios::out)) == EOF )
setstate(ios::failbit);
return p;
}
//------------------------------------------------------------------------------
void istream::getBool(bool *b) {
if ((flags() & boolalpha) == 0) {
getNumber(b);
return;
}
PGM_P truePtr = PSTR("true");
PGM_P falsePtr = PSTR("false");
const uint8_t true_len = 4;
const uint8_t false_len = 5;
bool trueOk = true;
bool falseOk = true;
uint8_t i = 0;
int c = readSkip();
while (1) {
falseOk = falseOk && c == pgm_read_byte(falsePtr + i);
trueOk = trueOk && c == pgm_read_byte(truePtr + i);
if (trueOk == false && falseOk == false) break;
i++;
if (trueOk && i == true_len) {
*b = true;
return;
}
if (falseOk && i == false_len) {
*b = false;
return;
}
c = getch();
}
setstate(failbit);
}
istream &istream::do_read( char *buf, streamsize len ) {
__lock_it( __i_lock );
streamsize offset = rdbuf()->sgetn( buf, len );
if( offset < len ) {
#if 0
setstate( ios::failbit );
#else
setstate( ( rdbuf()->underflow() == EOF )
? ios::failbit | ios::eofbit
: ios::failbit );
#endif
}
__last_read_length = offset;
return( *this );
}
/*-------------------------------------------------------------ostream::seekp-+
| |
+----------------------------------------------------------------------------*/
ostream & ostream::seekp(streampos pos)
{
if (!fail() && (rdbuf()->pubseekpos(pos, ios::out) == EOF)) {
setstate(failbit);
}
return *this;
}
/*******************************************************************************
raw_imemstream
*******************************************************************************/
raw_ios::pos_type raw_imemstream::seekoff(off_type offs, seekdir dir)
{
setstate(eofbit, false) ;
const pos_type from =
dir == cur ? _pos : (dir == beg ? pos_type() : (pos_type)_size) ;
return _pos = midval<pos_type>(0, _size, from + offs) ;
}
void rpcstream::verify(int ok) {
if (ok) {
clear();
} else {
setstate(ios::failbit);
}
}
void
TPUARTwrap::stopped()
{
setstate(T_new);
LowLevelFilter::stopped();
}
///
/// \details
/// The iword function provides access to an array of integers that can be
/// used for any purpose. The array grows as required to hold the
/// supplied index. All integers in the array are initialized to 0.
///
/// The implementation reserves several indices. You should use xalloc to
/// obtain an index that is safe to use. Also note that since the array
/// can grow dynamically, it is not safe to hold onto the reference.
long&
ios_base::iword(int index)
{
size_t req_size = static_cast<size_t>(index) + 1;
if (req_size > __iarray_cap_)
{
size_t newcap;
const size_t mx = numeric_limits < size_t > ::max();
if (req_size < mx / 2)
newcap = _VSTD::max(2 * __iarray_cap_, req_size);
else
newcap = mx;
long* iarray = (long*) realloc(__iarray_, newcap * sizeof(long));
if (iarray == 0)
{
setstate(badbit);
static long error;
error = 0;
return error;
}
__iarray_ = iarray;
for (long* p = __iarray_ + __iarray_size_; __iarray_cap_ < newcap;
++__iarray_cap_, ++p)
*p = 0;
}
__iarray_size_ = max < size_t > (__iarray_size_, req_size);
return __iarray_[index];
}
States::States(int r,QString tag_,QTreeWidget *parent) :
QTreeWidgetItem(parent)
{
tag = tag_;
number = r;
setstate(r);
}
//------------------------------------------------------------------------------
void istream::getStr(char *str) {
FatPos_t pos;
uint16_t i = 0;
uint16_t m = width() ? width() - 1 : 0XFFFE;
if (m != 0) {
getpos(&pos);
int c = readSkip();
while (i < m) {
if (c < 0) {
break;
}
if (isspace(c)) {
setpos(&pos);
break;
}
str[i++] = c;
c = getch(&pos);
}
}
str[i] = '\0';
if (i == 0) {
setstate(failbit);
}
width(0);
}
/*-------------------------------------------------------------ostream::seekp-+
| |
+----------------------------------------------------------------------------*/
ostream & ostream::seekp(streamoff off, ios::seekdir dir)
{
if (!fail() && (rdbuf()->pubseekoff(off, dir, ios::out) == EOF)) {
setstate(failbit);
}
return *this;
}
fstreambase::fstreambase( filedesc fd ) {
ios::init( &__flbuf );
if( __flbuf.attach( fd ) == NULL ) {
setstate( ios::failbit | ios::badbit );
}
}
//------------------------------------------------------------------------------
void SdStreamBase::putch(char c) {
if (c == '\n' && !(getmode() & ios::binary)) {
write('\r');
}
write(c);
if (writeError) setstate(badbit);
}
/* ------------------------------------------------------------------------- */
static int
lpc_random_restore_old_state(void)
{
int err = 0;
char *old_state = NULL;
if (lpc_random_old_state == NULL) {
goto bail;
}
old_state = setstate(lpc_random_old_state);
if (old_state == NULL) {
err = 1;
goto bail;
}
else if (old_state != lpc_random_state) {
/*
* Unexpected; what else would it have been, if we had put
* something into lpc_random_old_state?
*/
syslog(LOG_INFO, "Unexpected return from setstate(): %p", old_state);
}
bail:
return(err);
}
void iconvstream::open(std::ostream& sink_,
const char* tocode, const char* fromcode,
iconvstreambuf::mode_t mode)
{
if (!fail() && streambuf.open(sink_, tocode, fromcode, mode) == 0)
setstate(std::ios::failbit);
}
