void grid() { // setbkcolor(LIGHTGREEN); setfillstyle(1,LIGHTGREEN); floodfill(0,0,15); setlinestyle(0,0,3); setcolor(RED); settextjustify(1,1); // settextstyle(0,0,1); for(int i=0;i<=480;i+=48) line(0,i,479,i); line(0,479,479,479); for(i=0;i<=480;i+=48) line(i,0,i,479); int k=1;int a=9; char h[3]; setfillstyle(1,LIGHTBLUE); floodfill(639,479,RED); setcolor(BROWN); setlinestyle(0,0,3); ladd(110,452,412); ladd(350,452,364); ladd(206,404,316); ladd(398,308,268); ladd(110,260,220); ladd(254,260,172); ladd(206,164,28); ladd(350,164,124); ladd(62,116,76); snake(168, 374, 264, 447); snake(360, 278, 312, 399); snake(168, 230, 72, 351); snake(408,182,312,255); snake(120, 86, 168, 303); snake(264, 38, 360, 111); snake(72, 38, 72,159); snake(264, 134, 216, 255); setcolor(RED); settextstyle(4,0,1); while(a>0) { for(i=0;i<10;i++) { sprintf(h,"%d",k++); outtextxy(i*48+24,a*48+24,h); } a--; for(i=9;i>=0;i--) { sprintf(h,"%d",k++); outtextxy(i*48+24,a*48+24,h); } a--; } }
/*---------------------------------------------------------------------- | insert_ln | | insert data, listnode - insert data just before the list item | pointed to by 'ln'. | | This routine is not intended to be called directly by the user | because the validity of ln is not checked. This routine is called | by list manipulation routines within this module, in which ln is | known to point to a valid list node. ----------------------------------------------------------------------*/ static int insert_ln ( LIST * l, LISTNODE * ln, void * data_ptr ) { LISTNODE * lnptr; CKLMAGIC(l); if (ln==NULL) { ladd ( l, data_ptr ); CKLMAGIC(l); return 0; } lnptr = get_listnode(l); if (lnptr == NULL) { #ifdef BOS breakpoint(); #endif return -1; } CKMAGIC(lnptr); lnptr->data = data_ptr; if (ln==l->top) { /*------------------------------ | insert before the list head ------------------------------*/ lnptr->next = ln; lnptr->prev = NULL; ln->prev = lnptr; l->top = lnptr; } else if (ln==NULL) { /*----------------- | list was empty -----------------*/ lnptr->next = NULL; lnptr->prev = l->bottom; l->bottom->next = lnptr; l->bottom = lnptr; } else { /*----------------------------------- | insert in the middle of the list -----------------------------------*/ lnptr->next = ln; lnptr->prev = ln->prev; lnptr->next->prev = lnptr; lnptr->prev->next = lnptr; } l->num++; CKLMAGIC(l); return 0; }
int hdr_AddTextHeader( msg_Headers headers, const char * key, const char * value ) { msg_Header header = hdr_FindHeader( headers->text, key ); if( !header ) { header = Calloc( sizeof(struct _msg_Header), 1 ); if( !header ) return 0; header->name = Strdup( key ); if( !header->name ) { Free( header ); return 0; } header->values = slcreate(); if( !header->values ) { del_Header( header ); return 0; } if( !sladd( header->values, value ) ) { del_Header( header ); return 0; } } return ladd( headers->text, header ) != NULL; }
int main(int argc, char* argv[]){ if(argc > 2) { List* la = int2list(atoi(argv[1])); List* lb = int2list(atoi(argv[2])); List* lc = ladd(la,lb); /* la->print(); lb->print(); lc->print(); */ List* lar = la->reverse(); List* lbr = lb->reverse(); List* lcr = laddrev(lar,lbr); lar->print(); lbr->print(); lcr->print(); delete lar; delete lbr; delete lc; delete lcr; } }
void OperandStack::lsub(){ if(size < 4) { printf("Error :op_stack.lsub\n"); exit(0); } lneg(); ladd(); }
int main(void) { short a[N + 2] = {1999, 4444, 7777, 2222, 9999}, b[N + 2] = { 111, 6666, 3333, 8888, 1111}, c[N + 2]; ladd(a, b, c); print(c); lsub(a, b, c); print(c); return 0; }
char *sladd( List list, const char *data ) { if( list && data ) { char *dup = Strdup( data ); if( dup ) { char *rc = ladd( list, dup ); if( rc ) { return rc; } Free( dup ); } } return NULL; }
/*------------------------------------------------------------ | lcat | | catenate - catenate l2 to l1, return pointer to l1. ------------------------------------------------------------*/ LISTID lcat ( LISTID lid1, LISTID lid2 ) { CKLMAGIC(((LIST *)lid1)); CKLMAGIC(((LIST *)lid2)); while (lsize(lid2)) { ladd ( lid1, lrmv_n(lid2,1) ); } CKLMAGIC(((LIST *)lid1)); CKLMAGIC(((LIST *)lid2)); return lid1; }
int main() { CList *head = new CList; head->value = 0; head->next = NULL; printf("Counting - for every round of a cyclic list remove the k-th element, while not in the list will be only one. Enter the length of the list and number of the last element. Will be calculated the numbers of k before n!. \n\nn = "); int n = 0; scanf("%i", &n); printf("\nlast = "); int last = 0; scanf("%i", &last); long nFact = 1; for (int i = 1; i <= n; i++) nFact = nFact * i; List *lhead = new List; lhead->next = NULL; for (int k = 1; k <= nFact; k++) { fill(head, n); CList *tmp = head; while (lengh(head) != 1) { for (int c = 1; c < k; c++) { tmp = tmp->next; } del(head, returnNum(head, tmp->next)); } if (tmp->next->value == last) ladd(lhead, k, 1000); del(head, 1); } printf("\n\nk = {"); lprintList(lhead); printf("}\n"); removeList(head); lremoveList(lhead); scanf("%*"); delete lhead; delete head; return 0; }
void set_knight(){ if(lev==max_lev){ cnt=ladd(cnt,a); cnt=ladd(cnt,b); cnt=ladd(cnt,c); cnt=ladd(cnt,o); return; } /* printf("lev=%ld :",lev); printlnum(a); printf(" "); printlnum(b); printf(" "); printlnum(c); printf(" "); printlnum(o); printf(" \n"); */ lev++; an=a; bn=b; cn=c; on=o; a=bn; a=ladd(a,bn); a=ladd(a,cn); a=ladd(a,cn); b=an; b=ladd(b,on); b=ladd(b,on); c=an; o=bn; set_knight(); }
/** Returns map of instances **/ list *parse_object(lwm2m_object *object, char *message, int message_len) { list *instances = list_new(); char *curr = message; while (curr < message + message_len) { tlv_header instance_header; curr = parse_tlv_header(curr, &instance_header); lwm2m_instance *instance = (lwm2m_instance *) malloc(sizeof(lwm2m_instance)); instance->id = instance_header.id; instance->resources = parse_instance(object, curr, instance_header.length); ladd(instances, instance->id, instance); curr = curr + instance_header.length; } return instances; }
// TODO in multiple resource map there should be map <ID, lwm2m_resource*> list *parse_multiple_resource(lwm2m_object *object, int resource_id, char *message, int message_len) { list *resources = list_new(); tlv_header resource_header; char *curr = message; while (curr < message + message_len) { curr = parse_tlv_header(curr, &resource_header); lwm2m_resource *resource_instance = create_resource(object, resource_id); resource_instance->id = resource_header.id; lwm2m_value value = parse_value(curr, resource_header.length, resource_instance->type); __set_value(resource_instance, &value, resource_header.length); ladd(resources, resource_instance->id, resource_instance); curr = curr + resource_header.length; } return resources; }
/*----------------------------------------------------------------- | lins_n | | Insert data before the nth item in the list. -----------------------------------------------------------------*/ int lins_n ( LISTID lid, void * data_ptr, unsigned int n ) { int i; LIST * l; LISTNODE * ln; l = (LIST *)lid; CKLMAGIC(l); if ((n<1)||(n>(l->num+1))) { return -1; } if (l->num == 0) { return ladd ( lid, data_ptr ); } /*---------------------------------- | locate the nth item in the list ----------------------------------*/ ln = l->top; i = 1; while (ln && (i!=n)) { CKMAGIC(ln); ln = ln->next; i++; } if (!ln) { CKLMAGIC(l); return -1; } CKLMAGIC(l); /*----------------------------------------- | insert before the nth item in the list -----------------------------------------*/ return insert_ln ( l, ln, data_ptr ); }
list *create_example_objects() { list *objects = list_new(); lwm2m_object *example_object = lwm2m_object_new(); example_object->id = 123; example_object->mandatory = false; example_object->multiple = true; example_object->object_urn = "urn:oma:lwm2m:oma:123"; example_object->attributes = list_new(); example_object->resource_def = create_example_resources(123); example_object->resource_def_len = 10; // Set object's minimum period attribute to 10 sec // TODO new way of declaring attributes // lwm2m_attribute *pmin_attribute = new_int_attribute("pmin", 10, ATTR_READ | ATTR_WRITE); // lwm2m_map_put_string(example_object->attributes, "pmin", pmin_attribute); ladd(objects, example_object->id, (void*) example_object); return objects; }
/** Returns map of resources **/ list *parse_instance(lwm2m_object *object, char *message, int message_len) { list *resources = list_new(); tlv_header resource_header; char *curr = message; while (curr < message + message_len) { curr = parse_tlv_header(curr, &resource_header); lwm2m_resource *resource = create_resource(object, resource_header.id); if (resource_header.type == MULTIPLE_RESOURCE_TYPE) { resource->instances = parse_multiple_resource(object, resource->id, curr, resource_header.length); resource->multiple = true; } else { lwm2m_value value = parse_value(curr, resource_header.length, resource->type); __set_value(resource, &value, resource_header.length); } ladd(resources, resource->id, resource); curr = curr + resource_header.length; } return resources; }
/*------------------------------------------------------------ | laddo | | add list, ordered - add item p to the list, use 'compare' | function to place 'p' when the comparison 'p' is less than | the next item. Return 0 if this was a unique entry, | else return 1 indicating a duplicate entry, i.e., the | compare function returned 0 while inserting the element. ------------------------------------------------------------*/ int laddo ( LISTID lid, void * p, int (*compare)(const void *p1,const void *p2), LNODEID * firstdup ) { LIST * l; LISTNODE * ln; int dup, cmp; l = (LIST *)lid; CKLMAGIC(l); dup = 0; ln = l->top; while (ln!=NULL) { CKMAGIC(ln); cmp = compare(p,ln->data); if (cmp == 0) { dup = 1; if (firstdup) *firstdup = ln; } if (cmp < 0) { insert_ln(l,ln,p); CKLMAGIC(l); return dup; } else { ln = ln->next; } } ladd(l,p); CKLMAGIC(l); return dup; }
int hdr_AddMailHeader( msg_Headers headers, const char * key, const char * mail ) { msg_Header header = hdr_FindHeader( headers->text, key ); if( !header ) { Pair addr = addr_Create( mail ); if( !addr ) return 0; header = Calloc( sizeof(struct _msg_Header), 1 ); if( !header ) return 0; header->name = Strdup( key ); if( !header->name ) { pair_Delete( addr ); Free( header ); return 0; } header->values = plcreate(); if( !header->values ) { pair_Delete( addr ); del_Header( header ); return 0; } if( !pladd( header->values, A_NAME( addr ), A_EMAIL( addr ) ) ) { pair_Delete( addr ); del_Header( header ); return 0; } pair_Delete( addr ); } return ladd( headers->mail, header ) != NULL; }
sdlclock clock_new(int frequency) { sclock *c = malloc(sizeof(sclock)); c->lkptable = malloc(sizeof(int) * frequency); c->frequency = frequency; c->index = 0; c->ticks = SDL_GetTicks(); int i; for(i=0;i<frequency;i++) c->lkptable[i] = ((1000*(i+1)) / frequency) - ((1000*i) / frequency); #ifdef DEBUG int s = 0; for(i=0;i<frequency;i++) s += c->lkptable[i]; assert(s==1000); #endif ladd(_clocks, c); return (sdlclock)c; }
/*--------------------------------------------------------------------------- | laddu | | add list, ordered, unique - add item p to the list, use 'compare' | function to place 'p' when the comparison 'p' is less than the next | item. Return 1 if the item was added, 0 if not. | --------------------------------------------------------------------------*/ int laddu ( LISTID lid, void * p, int (*compare)(const void *p1,const void *p2) ) { LIST * l; LISTNODE * ln; int cmp; l = (LIST *)lid; CKLMAGIC(l); ln = l->top; while (ln!=NULL) { CKMAGIC(ln); cmp = compare(p,ln->data); if (cmp == 0) { CKLMAGIC(l); return 0; } if (cmp < 0) { insert_ln(l,ln,p); CKLMAGIC(l); return 1; } else { ln = ln->next; } } ladd(l,p); CKLMAGIC(l); return 1; }
list_t *create_ir_lookup_table_from_ping(servo_data_t *servo, timer_prescaler_t prescaler) { int maxVoltage = 1023; int minVoltage = 130; int avg = 5; int speed = 50; //50 mm per second int delay_for_5_mm = 100; oi_set_wheels(0, 0); servo_set_position_deg(servo, 90); printf0("Put roomba in front of flat surface like a wall. Press 'c' when ready...\r\n"); while (getChar0() != 'c') printf0("Put roomba in front of flat surface like a wall. Press 'c' when ready...\r\n"); unsigned voltage = ir_read_voltage_avg(avg); printf0("start: %u\r\n", voltage); while (voltage != maxVoltage) { printf0("%u\r\n", voltage); oi_set_wheels(-speed, -speed); _delay_ms(2 * delay_for_5_mm); //1 cm oi_set_wheels(0, 0); voltage = ir_read_voltage_avg(avg); } _delay_ms(100); unsigned peakVoltage_distance_mm = ping_mm_busy_wait(prescaler); while (voltage == maxVoltage) { printf0("[%u v], %u p_mm \r\n", voltage, peakVoltage_distance_mm); oi_set_wheels(-speed, -speed); _delay_ms(delay_for_5_mm * 2); oi_set_wheels(0, 0); _delay_ms(100); peakVoltage_distance_mm = ping_mm_busy_wait(prescaler); voltage = ir_read_voltage_avg(avg); } list_t *ret = lalloc(); ladd(ret, (void *) new_ir_measurement(maxVoltage, peakVoltage_distance_mm)); unsigned oldMm = peakVoltage_distance_mm; while (voltage > minVoltage) { _delay_ms(100); unsigned mm = ping_mm_busy_wait(prescaler); printf0("reading [%u v], %u mm >? %u oldMm \r\n", voltage, mm, oldMm); while (mm <= oldMm) { printf0("Non increasing ping value: [OLD: %u] [NEW: %u]\r\n", oldMm, mm); _delay_ms(100); mm = ping_mm_busy_wait(prescaler); oi_set_wheels(-speed, -speed); _delay_ms(delay_for_5_mm); //5mm oi_set_wheels(0, 0); } printf0(" adding [%u v], %u mm \r\n", voltage, mm); ladd(ret, (void *) new_ir_measurement(voltage, mm)); oi_set_wheels(-speed, -speed); _delay_ms(delay_for_5_mm * 2); //1cm oi_set_wheels(0, 0); voltage = ir_read_voltage_avg(avg); oldMm = mm; } printf0("sorting...\r\n"); lmergesort(ret, 0, ret->length - 1, (int (*)(const void *, const void *)) compare_ir_measurements); printf0("done\r\n"); return ret; }
list_t *create_jims_ir_sensor_lookup_table() { list_t *lookup_table = lalloc(); ladd(lookup_table, (void *) new_ir_measurement(118, 360)); ladd(lookup_table, (void *) new_ir_measurement(146, 300)); ladd(lookup_table, (void *) new_ir_measurement(169, 245)); ladd(lookup_table, (void *) new_ir_measurement(199, 215)); ladd(lookup_table, (void *) new_ir_measurement(215, 195)); ladd(lookup_table, (void *) new_ir_measurement(224, 175)); ladd(lookup_table, (void *) new_ir_measurement(245, 165)); ladd(lookup_table, (void *) new_ir_measurement(250, 155)); ladd(lookup_table, (void *) new_ir_measurement(265, 145)); ladd(lookup_table, (void *) new_ir_measurement(279, 135)); ladd(lookup_table, (void *) new_ir_measurement(303, 125)); ladd(lookup_table, (void *) new_ir_measurement(327, 115)); ladd(lookup_table, (void *) new_ir_measurement(370, 105)); ladd(lookup_table, (void *) new_ir_measurement(394, 95)); ladd(lookup_table, (void *) new_ir_measurement(409, 85)); ladd(lookup_table, (void *) new_ir_measurement(457, 75)); ladd(lookup_table, (void *) new_ir_measurement(522, 65)); ladd(lookup_table, (void *) new_ir_measurement(562, 55)); ladd(lookup_table, (void *) new_ir_measurement(696, 45)); ladd(lookup_table, (void *) new_ir_measurement(912, 35)); ladd(lookup_table, (void *) new_ir_measurement(1019, 27)); return lookup_table; }
int main() { struct pf_nattrack_hash *pfnth = NULL; struct pf_nattrack_list *item, *item2; struct pf_nattrack_list *lastlist = NULL, *freelist; struct pf_nattrack node, *nodep; int i, dev; initialize(); dev = open("/dev/pf", O_RDWR); if (dev < 0) { printerror("open(/dev/pf)"); return 1; } do { //printf("\n\n===================================\n"); //printf("Nova rodada\n"); //printf("===================================\n"); freelist = lastlist; lastlist = NULL; struct pfioc_states ps; struct pfsync_state *p; char *inbuf = NULL, *newinbuf = NULL; unsigned int len = 0; int i, opts = 0; memset(&ps, 0, sizeof(ps)); for (;;) { ps.ps_len = len; if (len) { newinbuf = realloc(inbuf, len); if (newinbuf == NULL) { printerror("error realloc - out of memory?"); goto done; } ps.ps_buf = inbuf = newinbuf; } if (ioctl(dev, DIOCGETSTATES, &ps) < 0) { printerror("failed to get states from PF device"); goto done; } if (ps.ps_len + sizeof(struct pfioc_states) < len) break; if (len == 0 && ps.ps_len == 0) goto done; if (len == 0 && ps.ps_len != 0) len = ps.ps_len; if (ps.ps_len == 0) goto done; /* no states */ len *= 2; } p = ps.ps_states; for (i = 0; i < ps.ps_len; i += sizeof(*p), p++) { if (!convert_state(p, &node)) continue; pfnth = &pfnt_hash[hashkey(&node)]; item = lfind(pfnth->list, &node); if (item) { //printf("Item found! Deleting from freelist\n"); item2 = item->ref; *(item2->nt) = node; ldel(&freelist, item2); } else { //printf("Not found. Inserting...\n"); nodep = (struct pf_nattrack *)malloc(sizeof(struct pf_nattrack)); *nodep = node; item = (struct pf_nattrack_list *)malloc( sizeof(struct pf_nattrack_list)); item->nt = nodep; item2 = (struct pf_nattrack_list *)malloc( sizeof(struct pf_nattrack_list)); item2->nt = nodep; ladd(&pfnth->list, item); item->ref = item2; } ladd(&lastlist, item2); item2->ref = item; } done: free(inbuf); free_list(&freelist); sleep(PFTM_INTERVAL); } while(1); /* comentando para trabalhar com o get_states while ( scanf("\n%d", &i) != EOF && i != 0) { if (!read_input(&node)) continue; pfnth = &pfnt_hash[hashkey(&node)]; item = lfind(pfnth->list, &node); if (item) { //printf("Item found! Deleting from freelist\n"); item2 = item->ref; ldel(&freelist, item2); } else { //printf("Not found. Inserting...\n"); nodep = (struct pf_nattrack *)malloc(sizeof(struct pf_nattrack)); *nodep = node; item = (struct pf_nattrack_list *)malloc( sizeof(struct pf_nattrack_list)); item->nt = nodep; item2 = (struct pf_nattrack_list *)malloc( sizeof(struct pf_nattrack_list)); item2->nt = nodep; ladd(&pfnth->list, item); item->ref = item2; } ladd(&lastlist, item2); item2->ref = item; } //printf("done\n"); //printf("-> removendo itens da freelist\n"); free_list(&freelist); //printf("-> items armazenados:\n"); //for(i=0; i <= pf_hashmask; i++) { // for(item=pfnt_hash[i].list; item; item=item->next) { // print_nattrack(item->nt, 0); // } //} //printf("Nova rodada? (1 = sim) "); } while(scanf("\n%d", &i) != EOF && i != 0); */ // comentando para get_states free_list(&lastlist); free(pfnt_hash); return 0; }
static void filler(decayDiagram ar) {int nf=0, k, l=1; ni = 0; nk = 0; se = 100; nn:if (nk > 3) ladd(&l); { knot *with1 = &kn[nk]; with1->pt = abs(ar[l-1]); ladd(&l); with1->fr = nf; with1->ty = 0; with1->e3 = 0; ll: if (ar[l-1] > 0) { if (tpc == 1 || se != 100) ni++; if (se == 100) se = nk; with1->ty++; if (with1->ty == 2) { with1->e2 = ar[l-1]; with1->n2 = ni; ladd(&l); goto pp; } with1->e1 = ar[l-1]; with1->n1 = ni; ladd(&l); goto ll; } nf = nk; with1->e2 = -(++nk); goto nn; } pp:for (k = nk; k >= 0; k--) { knot *with1 = &kn[k]; if (with1->ty == 0) if (ar[l-1] > 0) { with1->e1 = ar[l-1]; if (tpc == 1 || se != 100) with1->n1 = ++ni; if (se == 100) se = k; ladd(&l); with1->ty = 1; } else { nf = k; with1->ty = -1; with1->e1 = -(++nk); goto nn; } } for (k = 0; k <= nk; k++) { knot *with1 = &kn[k]; if (with1->ty < 0) with1->ty = 0; if (tpc == 1 || k != se) order(&with1->e1,&with1->e2,&with1->n1,&with1->n2); } kl = elong(0) + 1; kt = empt(0); kk = kl - 2 - kt; if (tpc == 2) kn[se].e1 = prtclbase[kn[se].e1-1].anti; se1 = se; ks = 0; if (kt > 0) triplet(0); }