inline void exchange_vars(char *lhs, char *rhs, char *err) { /* * Variable Exchange Function, swaps the value * stored in two variable lhs & rhs. If they * don't exist error message is stored in *err, * and function is returned. * ------------------------------------------------ * WARNING: Strings *rhs and *lhs are subject to * changes, forget them after calling this function. */ rhs++; /* to avoid '>' */ trims(rhs,' '); /* now exchange */ int32 *value = getint32(rhs); if(value!=NULL) { /* okay, rhs is valid */ int32 rvalue = *value; value = getint32(lhs); if(value!=NULL) { /* now swap the values */ * getint32(rhs) = * value; * value = rvalue; printf("%s => %s\n",lhs,rhs); } else sprintf(err,"LHS Variable '%s' does not exist.",lhs); } else sprintf(err,"RHS Variable '%s' does not exist.",rhs); }
int32 * lex_int32(const char *str, int32 *value) { /* Abstract Lexical Analysis Function * ------------------------------------ * lex peforms abstract lexical analysis. * It accepts abstract entities, such as * function calls, variable names, e.t.c * for analysis. Assignment operations, * definitions, declarations, constants * (strings, numbers,..) are NOT accepted. * * First it analyses a string, and finds * out it's value (if there exists one). * The value should be a int32. If not, * then it will be typecasted to int32. * * If *str describes some pointable matter * (eg. variable names), then a pointer to * the variable is returned and the int32 * pointed to by *lex is give it's value. * * If the *str describes volatile matter * (eg. functions returns), then it is * evaluated & stored in the variable * pointed at by *lex. * * Whereas if no value can be found, a * description of the error is written * into *err & the NULL is returned. */ *value = (getint32(str)==NULL) ? 0:*getint32(str); return (getint32(str)==NULL) ? NULL : getint32(str); return NULL; }
int32 * newint32(const char *id) { /* This function creates a new integer * whose name is defined by the string *id, * and returns an integer pointer to it. **/ /* --- WARNING --- [ CHECK *id VALIDITY BEFORE PASSING ] * newint() does not check the validity of variable names, * _even_ null variable names, are accepted. The caller * should check the validity of the string being passed. */ /* check if a variable with the same name exists */ if((getint32(id))!=NULL) return NULL; struct int32_table_struct * table_ptr; /* increment table size by 1 for 1 new variable */ int32_table_size += 1; /* reallocate table structure with new size */ if((table_ptr = (struct int32_table_struct *) realloc (int32_table, sizeof(struct int32_table_struct)* int32_table_size))==NULL) msg(system_no_mem,3); else /* set the variable */ int32_table = table_ptr; /* set the variable name */ int32_table[int32_table_size-1].ids = clones(id); /* initiaze the variable to 0 */ int32_table[int32_table_size-1].var = 0; /* return a pointer to the variable */ return &int32_table[int32_table_size-1].var; }
int32 * lex_int32(const char *str, int32 *value) { /* Abstract Lexical Analysis Function * ------------------------------------ * lex peforms abstract lexical analysis. * It accepts abstract entities, such as * function calls, variable names, e.t.c * for analysis. Assignment operations, * definitions, declarations, constants * (strings, numbers,..) are NOT accepted. * * First it analyses a string, and finds * out it's value (if there exists one). * The value should be a int32. If not, * then it will be typecasted to int32. * * If *str describes some pointable matter * (eg. variable names), then a pointer to * the variable is returned and the int32 * pointed to by *lex is give it's value. * * If the *str describes volatile matter * (eg. functions returns), then it is * evaluated & stored in the variable * pointed at by *lex. * * Whereas if no value can be found, a * description of the error is written * into *err & the NULL is returned. */ // <-------------- NOT COMPLETED ------------------> /* junk: , delete this code... */ *value = (getint32(str)==NULL) ? 0:*getint32(str); const char fn_sqrt[] = "sqrt"; if(!strncmp(str,fn_sqrt,strlen(fn_sqrt))) { str += strlen(fn_sqrt); for(;(*str<='0'||*str>='9')&&str!='\0';str++); *value = atoi(str); printf("\n%s -> %ld\n", fn_sqrt,*value); *value = (int32) sqrt(*value); } return (getint32(str)==NULL) ? NULL : getint32(str); // <-------------- NOT COMPLETED ------------------> }
void Archive::Open(IO::Stream* stream) { m_p->m_stream = stream; TRY { uint32 signature; while ((signature = getint32()) == 0x04034b50) { File* file = new File(this); file->m_bytepos = m_p->m_stream->GetPosition(); uint16 version_needed_to_extract = getshort();// 2 bytes uint16 general_purpose_bit_flag = getshort();// 2 bytes file->m_compression_method = getshort();// 2 bytes uint16 last_mod_file_time = getshort();// 2 bytes uint16 last_mod_file_date = getshort();// 2 bytes file->m_crc_32 = getint32();// 4 bytes file->m_compressed_size = getint32();// 4 bytes file->m_uncompressed_size = getint32();// 4 bytes uint16 file_name_length = getshort();// 2 bytes uint16 extra_field_length = getshort();// 2 bytes file->m_name = String(string_alloc<char>(file_name_length)); m_p->m_stream->Read(file->m_name.GetData8(), file_name_length); m_p->m_stream->Seek(extra_field_length, IO::STREAM_SEEK_CUR); file->m_dataoffset = m_p->m_stream->GetPosition() - file->m_bytepos; m_p->m_stream->Seek(file->m_compressed_size, IO::STREAM_SEEK_CUR); m_p->m_filesByName[file->m_name] = file; m_p->m_files.push_back(file); } while (signature == 0x02014b50) { signature = getint32(); } } CATCH (Exception* e) { } }
void exec(const char *str) { int32 strn = 0; /* check validity of equation in number of brackets */ int32 brackets = 0; for(;*str!='\0';str++,strn++) { if(*str=='(') brackets++; else if(*str==')') brackets--; } if(brackets!=0) { strcpy(lisp_error,"Invalid Syntax, incorrect number of parentheses."); return; } str -= strn; char *lhs = allocs(strn); char *rhs = allocs(strn); /* here the rhs & lhs are obtained */ { char *sptr = NULL; /* sptr points at const *str */ for(sptr=lhs;*str!='\0'&&*str!='=';str++) *sptr++ = *str; *sptr = '\0'; if(*str=='=') { for(sptr=rhs,str++;*str!='\0';str++) { *sptr++ = *str; *sptr = '\0'; } } else { *rhs = '\0'; } trims(lhs,' '); } if(*rhs=='\0') { /* <- empty rhs, so no assignment involved. */ /* check if rhs is a variable */ int32 *value = NULL; value = getint32(lhs); if(value==NULL) { /* rhs is NOT a variable */ int32 val=0; eval_int32(lhs,&val); printf("\n%ld\n",val); } else printf("%s = %ld\n",lhs,*value); } else { /* rhs exists */ /* check for [=>] exchange directive */ if(*rhs=='>') exchange_vars(lhs,rhs,lisp_error); else { /* variable creation/assignment */ void asgn(char *rhs, char *lhs); asgn(rhs,lhs); } } /* free memeory */ free(lhs); free(rhs); }
int MIDIFile::parsemidifile(MIDIEvents *me_){ this->me=me_; //read the header int chunk=getint32();//MThd if (chunk!=0x4d546864) return(-1); int size=getint32(); if (size!=6) return(-1);//header is always 6 bytes long int format=getint16(); printf("format %d\n",format); int ntracks=getint16();//this is always 1 if the format is "0" printf("ntracks %d\n",ntracks); int division=getint16(); printf("division %d\n",division); if (division>=0){//delta time units in each a quater note // tick=???; } else {//SMPTE (frames/second and ticks/frame) printf("ERROR:in MIDIFile.C::parsemidifile() - SMPTE not implemented yet."); }; if (ntracks>=NUM_MIDI_TRACKS) ntracks=NUM_MIDI_TRACKS-1; for (int n=0;n<ntracks;n++){ if (parsetrack(n)<0) { clearmidifile(); return(-1); }; }; printf("\n\nCURRENT File position is = 0x%x\n",midifilek); printf("\nMIDI file succesfully parsed.\n"); // printf("\n0x%x\n",getbyte()); this->me=NULL; return(0); };
int wrap_getint32(const char *s, int32_t *valp) { struct protstream *prot; char *b; int c; b = xstrdup(s); /* work around bug in prot_ungetc */ prot = prot_readmap(b, strlen(b)); *valp = CANARY; c = getint32(prot, valp); free(b); prot_free(prot); return c; }
void asgn(char *rhs, char *lhs) { /* * Variable Assignment Function; * perfroms a variable assignment * on var with names rhs & lhs, then * does the appropriate post-evaluation * operations and if errored, then gives * a description about the error in *err. * ------------------------------------------------ * WARNING: Strings *rhs and *lhs are subject to * changes, forget them after calling this function. */ int32 *value = NULL; int32 rvalue = 0; /* to find assignment operator */ char esymbol=0; rvalue=strlen(lhs)-1; lhs += rvalue; /* now find the assignment operator */ if(*lhs=='*'||*lhs=='/'|| *lhs=='+'||*lhs=='-'|| *lhs=='%'||*lhs=='^'|| *lhs=='~'||*lhs==':'|| *lhs=='<'||*lhs=='>'|| *lhs=='|'||*lhs=='&'|| *lhs=='!'||*lhs=='=') { esymbol = *lhs; *lhs = '\0'; } /* set lhs ptr to origin */ lhs -= rvalue; /* evaluate rhs */ eval_int32(rhs,&rvalue); value = newint32(lhs); /* if variable elready exists, get it. */ if(value==NULL) value = getint32(lhs); /* set the value */ if(value!=NULL) mov_int32(value,&rvalue,esymbol); else /* getint32() hasn't worked properly */ strcpy(lisp_error,"Fatal Data Transfer Error."); printf("%s = %ld\n",lhs,*value); }
void proxy_copy(const char *tag, char *sequence, char *name, int myrights, int usinguid, struct backend *s) { char mytag[128]; struct d { char *idate; char *flags; unsigned int seqno, uid; struct d *next; } *head, *p, *q; int c; /* find out what the flags & internaldate for this message are */ proxy_gentag(mytag, sizeof(mytag)); prot_printf(backend_current->out, "%s %s %s (Flags Internaldate)\r\n", tag, usinguid ? "Uid Fetch" : "Fetch", sequence); head = (struct d *) xmalloc(sizeof(struct d)); head->flags = NULL; head->idate = NULL; head->seqno = head->uid = 0; head->next = NULL; p = head; /* read all the responses into the linked list */ for (/* each FETCH response */;;) { unsigned int seqno = 0, uidno = 0; char *flags = NULL, *idate = NULL; /* read a line */ c = prot_getc(backend_current->in); if (c != '*') break; c = prot_getc(backend_current->in); if (c != ' ') { /* protocol error */ c = EOF; break; } /* check for OK/NO/BAD/BYE response */ if (!isdigit(c = prot_getc(backend_current->in))) { prot_printf(imapd_out, "* %c", c); pipe_to_end_of_response(backend_current, 0); continue; } /* read seqno */ prot_ungetc(c, backend_current->in); c = getuint32(backend_current->in, &seqno); if (seqno == 0 || c != ' ') { /* we suck and won't handle this case */ c = EOF; break; } c = chomp(backend_current->in, "fetch ("); if (c == EOF) { c = chomp(backend_current->in, "exists\r"); if (c == '\n') { /* got EXISTS response */ prot_printf(imapd_out, "* %d EXISTS\r\n", seqno); continue; } } if (c == EOF) { /* XXX the "exists" check above will eat "ex" */ c = chomp(backend_current->in, "punge\r"); if (c == '\n') { /* got EXPUNGE response */ prot_printf(imapd_out, "* %d EXPUNGE\r\n", seqno); continue; } } if (c == EOF) { c = chomp(backend_current->in, "recent\r"); if (c == '\n') { /* got RECENT response */ prot_printf(imapd_out, "* %d RECENT\r\n", seqno); continue; } } /* huh, don't get this response */ if (c == EOF) break; for (/* each fetch item */;;) { /* looking at the first character in an item */ switch (c) { case 'f': case 'F': /* flags? */ c = chomp(backend_current->in, "lags"); if (c != ' ') { c = EOF; } else c = prot_getc(backend_current->in); if (c != '(') { c = EOF; } else { flags = grab(backend_current->in, ')'); c = prot_getc(backend_current->in); } break; case 'i': case 'I': /* internaldate? */ c = chomp(backend_current->in, "nternaldate"); if (c != ' ') { c = EOF; } else c = prot_getc(backend_current->in); if (c != '"') { c = EOF; } else { idate = grab(backend_current->in, '"'); c = prot_getc(backend_current->in); } break; case 'u': case 'U': /* uid */ c = chomp(backend_current->in, "id"); if (c != ' ') { c = EOF; } else c = getuint32(backend_current->in, &uidno); break; default: /* hmm, don't like the smell of it */ c = EOF; break; } /* looking at either SP seperating items or a RPAREN */ if (c == ' ') { c = prot_getc(backend_current->in); } else if (c == ')') break; else { c = EOF; break; } } /* if c == EOF we have either a protocol error or a situation we can't handle, and we should die. */ if (c == ')') c = prot_getc(backend_current->in); if (c == '\r') c = prot_getc(backend_current->in); if (c != '\n') { c = EOF; free(flags); free(idate); break; } /* if we're missing something, we should echo */ if (!flags || !idate) { char sep = '('; prot_printf(imapd_out, "* %d FETCH ", seqno); if (uidno) { prot_printf(imapd_out, "%cUID %d", sep, uidno); sep = ' '; } if (flags) { prot_printf(imapd_out, "%cFLAGS %s", sep, flags); sep = ' '; } if (idate) { prot_printf(imapd_out, "%cINTERNALDATE %s", sep, flags); sep = ' '; } prot_printf(imapd_out, ")\r\n"); if (flags) free(flags); if (idate) free(idate); continue; } /* add to p->next */ p->next = xmalloc(sizeof(struct d)); p = p->next; p->idate = idate; p->flags = editflags(flags); p->uid = uidno; p->seqno = seqno; p->next = NULL; } if (c != EOF) { prot_ungetc(c, backend_current->in); /* we should be looking at the tag now */ pipe_until_tag(backend_current, tag, 0); } if (c == EOF) { /* uh oh, we're not happy */ fatal("Lost connection to selected backend", EC_UNAVAILABLE); } /* start the append */ prot_printf(s->out, "%s Append {" SIZE_T_FMT "+}\r\n%s", tag, strlen(name), name); prot_printf(backend_current->out, "%s %s %s (Rfc822.peek)\r\n", mytag, usinguid ? "Uid Fetch" : "Fetch", sequence); for (/* each FETCH response */;;) { unsigned int seqno = 0, uidno = 0; /* read a line */ c = prot_getc(backend_current->in); if (c != '*') break; c = prot_getc(backend_current->in); if (c != ' ') { /* protocol error */ c = EOF; break; } /* check for OK/NO/BAD/BYE response */ if (!isdigit(c = prot_getc(backend_current->in))) { prot_printf(imapd_out, "* %c", c); pipe_to_end_of_response(backend_current, 0); continue; } /* read seqno */ prot_ungetc(c, backend_current->in); c = getuint32(backend_current->in, &seqno); if (seqno == 0 || c != ' ') { /* we suck and won't handle this case */ c = EOF; break; } c = chomp(backend_current->in, "fetch ("); if (c == EOF) { /* not a fetch response */ c = chomp(backend_current->in, "exists\r"); if (c == '\n') { /* got EXISTS response */ prot_printf(imapd_out, "* %d EXISTS\r\n", seqno); continue; } } if (c == EOF) { /* not an exists response */ /* XXX the "exists" check above will eat "ex" */ c = chomp(backend_current->in, "punge\r"); if (c == '\n') { /* got EXPUNGE response */ prot_printf(imapd_out, "* %d EXPUNGE\r\n", seqno); continue; } } if (c == EOF) { /* not an exists response */ c = chomp(backend_current->in, "recent\r"); if (c == '\n') { /* got RECENT response */ prot_printf(imapd_out, "* %d RECENT\r\n", seqno); continue; } } if (c == EOF) { /* huh, don't get this response */ break; } /* find seqno in the list */ p = head; while (p->next && seqno != p->next->seqno) p = p->next; if (!p->next) break; q = p->next; p->next = q->next; for (/* each fetch item */;;) { int sz = 0; switch (c) { case 'u': case 'U': c = chomp(backend_current->in, "id"); if (c != ' ') { c = EOF; } else c = getuint32(backend_current->in, &uidno); break; case 'r': case 'R': c = chomp(backend_current->in, "fc822"); if (c == ' ') c = prot_getc(backend_current->in); if (c != '{') { /* NIL? */ eatline(backend_current->in, c); c = EOF; } else c = getint32(backend_current->in, &sz); if (c == '}') c = prot_getc(backend_current->in); if (c == '\r') c = prot_getc(backend_current->in); if (c != '\n') c = EOF; if (c != EOF) { /* append p to s->out */ prot_printf(s->out, " (%s) \"%s\" {%d+}\r\n", q->flags, q->idate, sz); while (sz) { char buf[2048]; int j = (sz > (int) sizeof(buf) ? (int) sizeof(buf) : sz); j = prot_read(backend_current->in, buf, j); if(!j) break; prot_write(s->out, buf, j); sz -= j; } c = prot_getc(backend_current->in); } break; /* end of case */ default: c = EOF; break; } /* looking at either SP seperating items or a RPAREN */ if (c == ' ') { c = prot_getc(backend_current->in); } else if (c == ')') break; else { c = EOF; break; } } /* if c == EOF we have either a protocol error or a situation we can't handle, and we should die. */ if (c == ')') c = prot_getc(backend_current->in); if (c == '\r') c = prot_getc(backend_current->in); if (c != '\n') { c = EOF; break; } /* free q */ free(q->idate); free(q->flags); free(q); } if (c != EOF) { char *appenduid, *b; int res; /* pushback the first character of the tag we're looking at */ prot_ungetc(c, backend_current->in); /* nothing should be left in the linked list */ assert(head->next == NULL); /* ok, finish the append; we need the UIDVALIDITY and UIDs to return as part of our COPYUID response code */ prot_printf(s->out, "\r\n"); /* should be looking at 'mytag' on 'backend_current', 'tag' on 's' */ pipe_until_tag(backend_current, mytag, 0); res = pipe_until_tag(s, tag, 0); if (res == PROXY_OK) { if (myrights & ACL_READ) { appenduid = strchr(s->last_result.s, '['); /* skip over APPENDUID */ if (appenduid) { appenduid += strlen("[appenduid "); b = strchr(appenduid, ']'); if (b) *b = '\0'; prot_printf(imapd_out, "%s OK [COPYUID %s] %s\r\n", tag, appenduid, error_message(IMAP_OK_COMPLETED)); } else prot_printf(imapd_out, "%s OK %s\r\n", tag, s->last_result.s); } else { prot_printf(imapd_out, "%s OK %s\r\n", tag, error_message(IMAP_OK_COMPLETED)); } } else { prot_printf(imapd_out, "%s %s", tag, s->last_result.s); } } else { /* abort the append */ prot_printf(s->out, " {0+}\r\n\r\n"); pipe_until_tag(backend_current, mytag, 0); pipe_until_tag(s, tag, 0); /* report failure */ prot_printf(imapd_out, "%s NO inter-server COPY failed\r\n", tag); } /* free dynamic memory */ while (head) { p = head; head = head->next; if (p->idate) free(p->idate); if (p->flags) free(p->flags); free(p); } }
void vals_int32(const char *str, int32 * const value) { /* Elementry Evaluator (int32) * ============================== * This function evaluates, the int32 * value of an exprssion element. * Operations ~,!,!! and factorial are carried * out here. Function calls are made and * values of variables are retrieved too. * --------------------------------------- * Note: *str sould be trimmed of spaces * before being passed here. */ *value = 0; /* Out the 4 operations (!,!!,~,fact), * only 3 operations ~,! and !! appear * on L.H.S. of str, where ! and !! can * never coincide, but ~ can coincide with * the other two. These operations can be * permuted in the following ways: * ---------------------- * nothing -> 0 * ! only -> 1 * !! only -> 2 * ~ only -> 3 * ~ and ! -> 4 * ~ and !! -> 5 * - - - - - - - - - - - - * in case factorial needs * to be found then add 10: * - - - - - - - - - - - - * nothing -> 10 * ! only -> 11 * !! only -> 12 * ~ only -> 13 * ~ and ! -> 14 * ~ and !! -> 15 * ---------------------- * The number is kept in ops. */ uchar ops = 0; /* now find ops */ if(*str=='~'||*str=='!') { if(*str++=='~') { ops += 3; if(*str++=='!') { ops++; if(*str=='!') { ops++; str++; } } else str--; } else { /* (*str=='!') */ ops++; if(*str++=='!') ops++; else str--; } } if(str[strlen(str)-1]=='!') ops += 10; printf("lex: %s -> %d\n",str,ops); /* extract the value */ if(!strncmp(str,"0x",2)) sscanf(str,"%lx",value); else if((*str>='0'&&*str<='9')|| (*str=='-'&&str[1]>='0'&&str[1]<='9')) *value = atol(str); else { /* get the value */ //*value = (getint32(str)==NULL) ? 0:*getint32(str); lex_int32(str, value); /* now operate on the value */ if(ops==1||ops==2||ops==4||ops==5|| ops==11||ops==12||ops==14||ops==15) { /* nullify variable */ int32 *tmp; tmp = getint32(str); if(tmp!=NULL) *tmp = 0; } else if(ops==2||ops==5|| ops==12||ops==15) { /* destroy variable */ } } /* find factorial & complement if needed */ if(ops>=10) { *value = factorial(*value); ops -= 10; } if(ops>=3) *value = ~*value; }
int MIDIFile::parsetrack(int ntrack){ printf("\n--==*Reading track %d **==--\n",ntrack); int chunk=getint32();//MTrk if (chunk!=0x4d54726b) return(-1); int size=getint32(); printf("size = %d\n",size); int oldmidifilek=midifilek; unsigned char lastmsg=0; unsigned int dt=0; while(!midieof){ unsigned int msgdeltatime=getvarint32(); /// printf("MSGDELTATIME = %d\n",msgdeltatime); // dt+=msgdeltatime; int msg=peekbyte(); /// printf("raw msg=0x%x ",msg); if (msg<0x80) { msg=lastmsg; } else { lastmsg=msg; getbyte(); }; /// printf("msg=0x%x\n",msg); // dt+=msgdeltatime; add_dt(ntrack, msgdeltatime); unsigned int mtype,mlength; /* switch(msg) { case 0x80 ... 0x8f: //note on off parsenoteoff(ntrack,msg & 0x0f,dt); dt=0; break; case 0x90 ... 0x9f: //note on (or note off) parsenoteon(ntrack,msg & 0x0f,dt); dt=0; break; case 0xa0 ... 0xaf: //aftertouch - ignored skipnbytes(2); break; case 0xb0 ... 0xbf: //control change parsecontrolchange(ntrack,msg & 0x0f,dt); dt=0; break; case 0xc0 ... 0xcf: //program change - ignored skipnbytes(1); break; case 0xd0 ... 0xdf: //channel pressure - ignored skipnbytes(1); break; case 0xe0 ... 0xef: //channel mode messages skipnbytes(2); break; case 0xf0: //sysex - ignored while (getbyte()!=0xf7) { if (midieof) break; }; break; case 0xf7: //sysex (another type) - ignored skipnbytes(getvarint32()); break; case 0xff: //meta-event mtype=getbyte(); mlength=getbyte(); parsemetaevent(mtype,mlength); break; default: getbyte(); printf("UNKNOWN message! 0x%x\n",msg); return(-1); break; }; */ switch(msg & 0x0f) { case 0x80: //note on off parsenoteoff(ntrack,msg & 0x0f,dt); dt=0; break; case 0x90: //note on (or note off) parsenoteon(ntrack,msg & 0x0f,dt); dt=0; break; case 0xa0: //aftertouch - ignored skipnbytes(2); break; case 0xb0: //control change parsecontrolchange(ntrack,msg & 0x0f,dt); dt=0; break; case 0xc0: //program change - ignored skipnbytes(1); break; case 0xd0: //channel pressure - ignored skipnbytes(1); break; case 0xe0: //channel mode messages skipnbytes(2); break; case 0xf0: //sysex - ignored while (getbyte()!=0xf7) { if (midieof) break; }; break; case 0xf7: //sysex (another type) - ignored skipnbytes(getvarint32()); break; case 0xff: //meta-event mtype=getbyte(); mlength=getbyte(); parsemetaevent(mtype,mlength); break; default: getbyte(); printf("UNKNOWN message! 0x%x\n",msg); return(-1); break; }; if (midieof) return(-1); if ((midifilek-oldmidifilek)==size) break; else if((midifilek-oldmidifilek)>size) return(-1); // if (size!=6) return(-1);//header is always 6 bytes long }; printf("End Track\n\n"); return(0); };