static void
screen_scroll_right(Screen *s)
{
s->x_pos++;
if (s->x_pos > maxlen(s,s->x_col)) {
s->x_pos = 0;
s->x_col++;
if (s->x_col >= numfields(s)) {
s->x_col = rightmost(s);
s->x_pos = maxlen(s,s->x_col);
}
}
}
int main(){
maxlen(); //sets maxlen to 3
straight();
mixed();
straightRev();
singlecount();
conversion();
return 0;
}
/*
* Scroll left/right by adjusting both the current column and column offset
*/
static void
screen_scroll_left(Screen *s)
{
s->x_pos--;
if (s->x_pos < 0) {
s->x_col--;
if (s->x_col < 0) {
s->x_col = 0;
s->x_pos = 0;
}
else
{
s->x_pos = maxlen(s, s->x_col);
}
}
}
static void
fill_schedule (td_t *td, endpoint_t *ep, int length, unsigned char *data,
int *toggle)
{
switch (ep->direction) {
case IN: td->token = UHCI_IN; break;
case OUT: td->token = UHCI_OUT; break;
case SETUP: td->token = UHCI_SETUP; break;
}
td->token |= ep->dev->address << TD_DEVADDR_SHIFT |
(ep->endpoint & 0xf) << TD_EP_SHIFT |
maxlen (length) << TD_MAXLEN_SHIFT |
(*toggle & 1) << TD_TOGGLE_SHIFT;
td->bufptr = virt_to_phys (data);
td->ctrlsts = ((ep->direction == SETUP?3:0) << TD_COUNTER_SHIFT) |
(ep->dev->speed?TD_LOWSPEED:0) |
TD_STATUS_ACTIVE;
*toggle ^= 1;
}
void TextCtrlTestCase::MaxLength()
{
#if wxUSE_UIACTIONSIMULATOR
EventCounter updated(m_text, wxEVT_TEXT);
EventCounter maxlen(m_text, wxEVT_TEXT_MAXLEN);
m_text->SetFocus();
wxYield();
m_text->SetMaxLength(10);
wxUIActionSimulator sim;
sim.Text("abcdef");
wxYield();
CPPUNIT_ASSERT_EQUAL(0, maxlen.GetCount());
sim.Text("ghij");
wxYield();
CPPUNIT_ASSERT_EQUAL(0, maxlen.GetCount());
CPPUNIT_ASSERT_EQUAL(10, updated.GetCount());
maxlen.Clear();
updated.Clear();
sim.Text("k");
wxYield();
CPPUNIT_ASSERT_EQUAL(1, maxlen.GetCount());
CPPUNIT_ASSERT_EQUAL(0, updated.GetCount());
maxlen.Clear();
updated.Clear();
m_text->SetMaxLength(0);
sim.Text("k");
wxYield();
CPPUNIT_ASSERT_EQUAL(0, maxlen.GetCount());
CPPUNIT_ASSERT_EQUAL(1, updated.GetCount());
#endif
}
static void
fill_schedule (td_t *td, endpoint_t *ep, int length, unsigned char *data,
int *toggle)
{
switch (ep->direction) {
case IN: td->pid = UHCI_IN; break;
case OUT: td->pid = UHCI_OUT; break;
case SETUP: td->pid = UHCI_SETUP; break;
}
td->dev_addr = ep->dev->address;
td->endp = ep->endpoint & 0xf;
td->maxlen = maxlen (length);
if (ep->direction == SETUP)
td->counter = 3;
else
td->counter = 0;
td->data_toggle = *toggle & 1;
td->lowspeed = ep->dev->speed;
td->bufptr = virt_to_phys (data);
td->status_active = 1;
*toggle ^= 1;
}
void longest_increasing_subset(const std::vector<triple_t >&fatmouse,std::vector<int>&output )
{
int i,j;
int n = fatmouse.size();
std::pair<int,int> pos;
std::vector<std::pair<int,int> >maxlen(n);
maxlen[0] = std::make_pair(1,-1);
pos = std::make_pair(1,0);
for( i = 1; i < n; i++ )
{
maxlen[i] = std::make_pair(1,-1);
for( j = 0; j < i; j++ )
{
if( fatmouse[i].second < fatmouse[j].second &&
fatmouse[i].first != fatmouse[j].first &&
maxlen[j].first + 1 > maxlen[i].first )
maxlen[i] = std::make_pair(maxlen[j].first+1,j);
}
if( pos.first < maxlen[i].first )
pos = std::make_pair(maxlen[i].first,i);
}
#ifdef DEBUG
std::cout << "--------------------" << std::endl;
for( size_t k = 0; k < maxlen.size(); k++ )
std::cout << maxlen[k].first << " ";
std::cout << std::endl;
std::cout << "--------------------" << std::endl;
#endif
i = pos.second;
while( i > 0 )
{
output.push_back(i);
i = maxlen[i].second;
}
}
/*
* Render a row, taking column, x_pos and padding into account.
*
* Note - render in this context means send the data to ncurses, the tty
* won't be updated until refresh() is called
*/
static inline void
render_row(Screen *s, Row *row, char sep)
{
size_t i = 0;
for (i = s->x_col; i < RowSize(row); ++i)
{
size_t padlen = maxlen(s, i);
char *fv = RowFieldValue(row, i);
size_t fn = RowFieldLength(row, i);
if (i == s->x_col) {
if (s->x_pos < fn) {
printw("%s", fv + s->x_pos);
printwpad(padlen - fn);
}
else {
printwpad(padlen - s->x_pos);
}
}
else
{
printw("%s", fv);
printwpad(padlen - fn);
}
if (i != (RowSize(row) - 1))
printw("%c", sep);
}
clrtoeol();
printw("\n");
}
bool won(int colour) {
for (int r = 0; r < N; ++r)
for (int c = 0; c < N; ++c)
if (b[r][c] == colour && maxlen(r, c) >= K) return true;
return false;
}
void functions (char * text[], int linesNum){
char c [80], k [80];
char * ptr = &c;
int i, j = 0, l = 0, number;
int white_text = FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE |FOREGROUND_INTENSITY;
help (linesNum);
PosColor (5, 7 + linesNum, white_text);
printf ("Please, enter the needed function without a number\n\n HERE>> ");
gets (c);
for (i = 0; i < 80; i++){
if (c[i] != ' '){
k[j] = c[i];
j++;
l = 1;
}
if (c[i] == ' ' && l == 1){
k[j] = c[i];
j++;
k[j] = 0;
break;
}
}
if (strcmp(k, "random") == 0 || strcmp(k, "shorterthan") == 0 || strcmp(k, "longerthan") == 0){
printf ("Enter the number >> ");
scanf ("%i", &number);
printf ("\n");
printf ("%i", number);
}
clearaftertable (linesNum);
if (strcmp(k, "help") == 0){
help (linesNum);
} else
if (strcmp(k, "exit") == 0){
PosColor (0,0,0);
system ("cls");
getch();
initRectf();
} else
if (strcmp(k, "length") == 0){
lenofstrings (text, linesNum);
} else
if (strcmp(k, "longest") == 0){
maxlen (text, linesNum);
}
if (strcmp(k, "shortest") == 0){
minlen (text, linesNum);
}
if (strcmp(k, "random") == 0){
randomletters(text, linesNum, number);
}
if (strcmp(k, "swap") == 0){
change (text, linesNum);
}
if (strcmp(k, "shorterthan") == 0){
findlessthan (text, linesNum, number);
}
if (strcmp(k, "longerthan") == 0){
findmorethan (text, linesNum, number);
}
if (strcmp(k, "numberofwords") == 0){
wordcount (text, linesNum);
}
if (strcmp(k, "integer") == 0){
findNumInAllStrings(text, linesNum);
}
functions(text, linesNum);
}
/* create and hook-up an intr queue into device schedule */
static void*
uhci_create_intr_queue (endpoint_t *ep, int reqsize, int reqcount, int reqtiming)
{
u8 *data = malloc(reqsize*reqcount);
td_t *tds = memalign(16, sizeof(td_t) * reqcount);
qh_t *qh = memalign(16, sizeof(qh_t));
if (!data || !tds || !qh)
fatal("Not enough memory to create USB intr queue prerequisites.\n");
qh->elementlinkptr = virt_to_phys(tds);
intr_q *q = malloc(sizeof(intr_q));
if (!q)
fatal("Not enough memory to create USB intr queue.\n");
q->qh = qh;
q->tds = tds;
q->data = data;
q->lastread = 0;
q->total = reqcount;
q->reqsize = reqsize;
q->last_td = &tds[reqcount - 1];
memset (tds, 0, sizeof (td_t) * reqcount);
int i;
for (i = 0; i < reqcount; i++) {
tds[i].ptr = virt_to_phys (&tds[i + 1]);
switch (ep->direction) {
case IN: tds[i].token = UHCI_IN; break;
case OUT: tds[i].token = UHCI_OUT; break;
case SETUP: tds[i].token = UHCI_SETUP; break;
}
tds[i].token |= ep->dev->address << TD_DEVADDR_SHIFT |
(ep->endpoint & 0xf) << TD_EP_SHIFT |
maxlen (reqsize) << TD_MAXLEN_SHIFT |
(ep->toggle & 1) << TD_TOGGLE_SHIFT;
tds[i].bufptr = virt_to_phys (data);
tds[i].ctrlsts = (0 << TD_COUNTER_SHIFT) |
(ep->dev->speed?TD_LOWSPEED:0) |
TD_STATUS_ACTIVE;
ep->toggle ^= 1;
data += reqsize;
}
tds[reqcount - 1].ptr = 0 | TD_TERMINATE;
/* insert QH into framelist */
uhci_t *const uhcic = UHCI_INST(ep->dev->controller);
const u32 def_ptr = virt_to_phys(uhcic->qh_prei) | FLISTP_QH;
int nothing_placed = 1;
qh->headlinkptr = def_ptr;
for (i = 0; i < 1024; i += reqtiming) {
/* advance to the next free position */
while ((i < 1024) && (uhcic->framelistptr[i] != def_ptr)) ++i;
if (i < 1024) {
uhcic->framelistptr[i] = virt_to_phys(qh) | FLISTP_QH;
nothing_placed = 0;
}
}
if (nothing_placed) {
usb_debug("Error: Failed to place UHCI interrupt queue "
"head into framelist: no space left\n");
uhci_destroy_intr_queue(ep, q);
return NULL;
}
return q;
}
static int
uhci_control (usbdev_t *dev, direction_t dir, int drlen, void *devreq, int dalen,
unsigned char *data)
{
int endp = 0; /* this is control: always 0 */
int mlen = dev->endpoints[0].maxpacketsize;
int count = (2 + (dalen + mlen - 1) / mlen);
unsigned short req = ((unsigned short *) devreq)[0];
int i;
td_t *tds = memalign (16, sizeof (td_t) * count);
memset (tds, 0, sizeof (td_t) * count);
count--; /* to compensate for 0-indexed array */
for (i = 0; i < count; i++) {
tds[i].ptr = virt_to_phys (&tds[i + 1]) | TD_DEPTH_FIRST;
}
tds[count].ptr = 0 | TD_DEPTH_FIRST | TD_TERMINATE;
tds[0].token = UHCI_SETUP |
dev->address << TD_DEVADDR_SHIFT |
endp << TD_EP_SHIFT |
TD_TOGGLE_DATA0 |
maxlen(drlen) << TD_MAXLEN_SHIFT;
tds[0].bufptr = virt_to_phys (devreq);
tds[0].ctrlsts = (3 << TD_COUNTER_SHIFT) |
(dev->speed?TD_LOWSPEED:0) |
TD_STATUS_ACTIVE;
int toggle = 1;
for (i = 1; i < count; i++) {
switch (dir) {
case SETUP: tds[i].token = UHCI_SETUP; break;
case IN: tds[i].token = UHCI_IN; break;
case OUT: tds[i].token = UHCI_OUT; break;
}
tds[i].token |= dev->address << TD_DEVADDR_SHIFT |
endp << TD_EP_SHIFT |
maxlen (min (mlen, dalen)) << TD_MAXLEN_SHIFT |
toggle << TD_TOGGLE_SHIFT;
tds[i].bufptr = virt_to_phys (data);
tds[i].ctrlsts = (3 << TD_COUNTER_SHIFT) |
(dev->speed?TD_LOWSPEED:0) |
TD_STATUS_ACTIVE;
toggle ^= 1;
dalen -= mlen;
data += mlen;
}
tds[count].token = ((dir == OUT) ? UHCI_IN : UHCI_OUT) |
dev->address << TD_DEVADDR_SHIFT |
endp << TD_EP_SHIFT |
maxlen(0) << TD_MAXLEN_SHIFT |
TD_TOGGLE_DATA1;
tds[count].bufptr = 0;
tds[count].ctrlsts = (0 << TD_COUNTER_SHIFT) | /* as Linux 2.4.10 does */
(dev->speed?TD_LOWSPEED:0) |
TD_STATUS_ACTIVE;
UHCI_INST (dev->controller)->qh_data->elementlinkptr =
virt_to_phys (tds) & ~(FLISTP_QH | FLISTP_TERMINATE);
td_t *td = wait_for_completed_qh (dev->controller,
UHCI_INST (dev->controller)->
qh_data);
int result;
if (td == 0) {
result = 0;
} else {
usb_debug ("control packet, req %x\n", req);
td_dump (td);
result = 1;
}
free (tds);
return result;
}
/* create and hook-up an intr queue into device schedule */
static void*
uhci_create_intr_queue (endpoint_t *ep, int reqsize, int reqcount, int reqtiming)
{
u8 *data = malloc(reqsize*reqcount);
td_t *tds = memalign(16, sizeof(td_t) * reqcount);
qh_t *qh = memalign(16, sizeof(qh_t));
if (!data || !tds || !qh)
fatal("Not enough memory to create USB intr queue prerequisites.\n");
qh->elementlinkptr.ptr = virt_to_phys(tds);
qh->elementlinkptr.queue_head = 0;
qh->elementlinkptr.terminate = 0;
intr_q *q = malloc(sizeof(intr_q));
if (!q)
fatal("Not enough memory to create USB intr queue.\n");
q->qh = qh;
q->tds = tds;
q->data = data;
q->lastread = 0;
q->total = reqcount;
q->reqsize = reqsize;
q->last_td = &tds[reqcount - 1];
memset (tds, 0, sizeof (td_t) * reqcount);
int i;
for (i = 0; i < reqcount; i++) {
tds[i].ptr = virt_to_phys (&tds[i + 1]);
tds[i].terminate = 0;
tds[i].queue_head = 0;
tds[i].depth_first = 0;
switch (ep->direction) {
case IN: tds[i].pid = UHCI_IN; break;
case OUT: tds[i].pid = UHCI_OUT; break;
case SETUP: tds[i].pid = UHCI_SETUP; break;
}
tds[i].dev_addr = ep->dev->address;
tds[i].endp = ep->endpoint & 0xf;
tds[i].maxlen = maxlen (reqsize);
tds[i].counter = 0;
tds[i].data_toggle = ep->toggle & 1;
tds[i].lowspeed = ep->dev->speed;
tds[i].bufptr = virt_to_phys (data);
tds[i].status_active = 1;
ep->toggle ^= 1;
data += reqsize;
}
tds[reqcount - 1].ptr = 0;
tds[reqcount - 1].terminate = 1;
tds[reqcount - 1].queue_head = 0;
tds[reqcount - 1].depth_first = 0;
for (i = reqtiming; i < 1024; i += reqtiming) {
/* FIXME: wrap in another qh, one for each occurance of the qh in the framelist */
qh->headlinkptr.ptr = UHCI_INST (ep->dev->controller)->framelistptr[i].ptr;
qh->headlinkptr.terminate = 0;
UHCI_INST (ep->dev->controller)->framelistptr[i].ptr = virt_to_phys(qh);
UHCI_INST (ep->dev->controller)->framelistptr[i].terminate = 0;
UHCI_INST (ep->dev->controller)->framelistptr[i].queue_head = 1;
}
return q;
}
static int
uhci_control (usbdev_t *dev, direction_t dir, int drlen, void *devreq, int dalen,
unsigned char *data)
{
int endp = 0; /* this is control: always 0 */
int mlen = dev->endpoints[0].maxpacketsize;
int count = (2 + (dalen + mlen - 1) / mlen);
unsigned short req = ((unsigned short *) devreq)[0];
int i;
td_t *tds = memalign (16, sizeof (td_t) * count);
memset (tds, 0, sizeof (td_t) * count);
count--; /* to compensate for 0-indexed array */
for (i = 0; i < count; i++) {
tds[i].ptr = virt_to_phys (&tds[i + 1]);
tds[i].depth_first = 1;
tds[i].terminate = 0;
}
tds[count].ptr = 0;
tds[count].depth_first = 1;
tds[count].terminate = 1;
tds[0].pid = UHCI_SETUP;
tds[0].dev_addr = dev->address;
tds[0].endp = endp;
tds[0].maxlen = maxlen (drlen);
tds[0].counter = 3;
tds[0].data_toggle = 0;
tds[0].lowspeed = dev->speed;
tds[0].bufptr = virt_to_phys (devreq);
tds[0].status_active = 1;
int toggle = 1;
for (i = 1; i < count; i++) {
switch (dir) {
case SETUP: tds[i].pid = UHCI_SETUP; break;
case IN: tds[i].pid = UHCI_IN; break;
case OUT: tds[i].pid = UHCI_OUT; break;
}
tds[i].dev_addr = dev->address;
tds[i].endp = endp;
tds[i].maxlen = maxlen (min (mlen, dalen));
tds[i].counter = 3;
tds[i].data_toggle = toggle;
tds[i].lowspeed = dev->speed;
tds[i].bufptr = virt_to_phys (data);
tds[i].status_active = 1;
toggle ^= 1;
dalen -= mlen;
data += mlen;
}
tds[count].pid = (dir == OUT) ? UHCI_IN : UHCI_OUT;
tds[count].dev_addr = dev->address;
tds[count].endp = endp;
tds[count].maxlen = maxlen (0);
tds[count].counter = 0; /* as per linux 2.4.10 */
tds[count].data_toggle = 1;
tds[count].lowspeed = dev->speed;
tds[count].bufptr = 0;
tds[count].status_active = 1;
UHCI_INST (dev->controller)->qh_data->elementlinkptr.ptr =
virt_to_phys (tds);
UHCI_INST (dev->controller)->qh_data->elementlinkptr.queue_head = 0;
UHCI_INST (dev->controller)->qh_data->elementlinkptr.terminate = 0;
td_t *td = wait_for_completed_qh (dev->controller,
UHCI_INST (dev->controller)->
qh_data);
int result;
if (td == 0) {
result = 0;
} else {
debug ("control packet, req %x\n", req);
td_dump (td);
result = 1;
}
free (tds);
return result;
}