int main() { int arr[20]; int i, n, ep; prints("Enter the number of integers n: "); n = readi(&ep); prints("You entered n = "); printi(n); prints("\n"); prints("Enter n integers: "); for(i=0; i<n; i++) arr[i] = readi(&ep); sort(arr,n); prints("The n integers in ascending order: "); for(i=0; i<n; i++) { printi(arr[i]); prints(" "); } prints("\n"); return 0; }
int main(){ int mat[100][100]; char *c="\nPlease Enter Dimension of matrixr: "; char *d="\nPlease Enter the matrix row-wise: "; char *e="\nThe Entered matrix is: "; char *f="\nThe Transposed matrix is: "; char *sp=" "; char *ne="\n"; prints(c); int err,n,i,j,k; n = readi(&err); int temp; prints(d); for (i = 0; i < n; ++i) { for (j = 0; j < n; ++j) { mat[i][j]=readi(&err); } } prints(e); prints(ne); for (i = 0; i < n; ++i) { prints(ne); for (j = 0; j < n; ++j) { printi(mat[i][j]); prints(sp); } } prints(f); prints(ne); for (i = 0; i < n; ++i) { for (j = i+1; j < n; ++j) { temp=mat[j][i]; mat[j][i]=mat[i][j]; mat[i][j]=temp; } } for (i = 0; i < n; ++i) { prints(ne); for (j = 0; j < n; ++j) { printi(mat[i][j]); prints(sp); } } prints(ne); return 0; }
/* Driver program to test above function */ int main() { int arr[50], n, i, err; prints("Longest Increasing Subsequence\n"); prints("Enter number of elements ( < 50)\n"); n = readi(&err); prints("Enter array elements\n"); for(i = 0; i < n; i++) arr[i] = readi(&err); prints("Length of LIS is "); printi(lis( arr, n ) ); prints("\n"); return 0; }
// Write a new directory entry (name, inum) into the directory dp. int dirlink(struct inode *dp, char *name, uint inum) { int off; struct dirent de; struct inode *ip; // Check that name is not present. if((ip = dirlookup(dp, name, 0)) != 0){ iput(ip); return -1; } // Look for an empty dirent. for(off = 0; off < dp->size; off += sizeof(de)){ if(readi(dp, (char*)&de, off, sizeof(de)) != sizeof(de)) panic("dirlink read"); if(de.inum == 0) break; } strncpy(de.name, name, DIRSIZ); de.inum = inum; if(writei(dp, (char*)&de, off, sizeof(de)) != sizeof(de)) panic("dirlink"); return 0; }
// Load a program segment into pgdir. addr must be page-aligned // and the pages from addr to addr+sz must already be mapped. int //20160313-- loaduvm(pde_t *pgdir, char *addr, struct inode *ip, uint offset, uint sz) //loaduvm(pde_t *pgdir, char *addr, uint offset, uint sz) { //20160313-- uint i, pa, n; pte_t *pte; if((uint) addr % PGSIZE != 0) panic("loaduvm: addr must be page aligned"); for(i = 0; i < sz; i += PGSIZE){ if((pte = walkpgdir(pgdir, addr+i, 0)) == 0) panic("loaduvm: address should exist"); //20160313-- pa = PTE_ADDR(*pte); //20160313-- if(sz - i < PGSIZE) n = sz - i; else n = PGSIZE; //20160313-- if(readi(ip, p2v(pa), offset+i, n) != n) return -1; } return 0; }
// Load a program segment into pgdir. addr must be page-aligned // and the pages from addr to addr+sz must already be mapped. int loaduvm (pgd_t *pgdir, char *addr, struct inode *ip, uint offset, uint sz) { uint i, pa, n; pte_t *pte; if ((uint64) addr % PTE_SZ != 0) { panic("loaduvm: addr must be page aligned"); } for (i = 0; i < sz; i += PTE_SZ) { if ((pte = walkpgdir(pgdir, addr + i, 0)) == 0) { panic("loaduvm: address should exist"); } pa = PTE_ADDR(*pte); if (sz - i < PTE_SZ) { n = sz - i; } else { n = PTE_SZ; } if (readi(ip, p2v(pa), offset + i, n) != n) { return -1; } } return 0; }
int main() { int a,b; int *e; prints("***********************Some random outputs!!*************************\n"); b = 3; e = &b; prints("Passing pointers to function f!\n"); prints("Value passed to function: "); printi(b); prints("\n"); a = f(e); prints("Value returned from function s is: "); printi(a); prints("\n"); prints("Read an integer!!"); prints("\n"); b = readi(e); prints("The integer that was read is:"); printi(b); prints("\n"); return 0; }
//A test file to test the library functions written int main() { int n,err=0; prints("Write the integer n:"); n = readi(&err); if(err!=ERR) { prints("The integer read is : "); printi(n); } else { prints("Wrong Input\n"); } float x; prints("\nEnter the decimal number: "); err = readf(&x); if(err==OK) { prints("The floating number is :"); printd(x); } else { prints("Wrong Input\n"); } prints("\n"); return 0; }
int dirlink(struct inode *dp, char *dirname, uint32_t ino) { if(!ISDIR(dp->mode) || ino < 1) { return -1; } if(dirlookup(dp, dirname, 0)) return -1; struct dirent dir; int off; for(off = 0; off < dp->size; off+=sizeof(struct dirent)) { if(!readi(dp, (char *)&dir, off, sizeof(struct dirent))) { return -1; } // found a new entry if(!dir.ino) break; } dir.ino = ino; strcpy(dir.name, dirname); writei(dp, (char *)&dir, off, sizeof(struct dirent)); return 0; }
// Look for a directory entry in a directory. // If found, set *poff to byte offset of entry. struct inode* dirlookup(struct inode *dp, char *name, uint *poff) { uint off, inum; struct dirent de; if(dp->type != T_DIR) panic("dirlookup not DIR"); for(off = 0; off < dp->size; off += sizeof(de)){ if(readi(dp, (char*)&de, off, sizeof(de)) != sizeof(de)) panic("dirlink read"); if(de.inum == 0) continue; if(namecmp(name, de.name) == 0){ // entry matches path element if(poff) *poff = off; inum = de.inum; return iget(dp->dev, inum); } } return 0; }
// Read from file f. int fileread(struct file *f, char *addr, int n) { int r; if (f->readable == 0) { return -1; } if (f->type == FD_PIPE) { return piperead(f->pipe, addr, n); } if (f->type == FD_INODE) { ilock(f->ip); if ((r = readi(f->ip, addr, f->off, n)) > 0) { f->off += r; } iunlock(f->ip); return r; } panic("fileread"); }
void log_initialize() { struct inode *ip; uchar buffer[512]; int i, j; struct buf *bp; struct trans_start t_blk; for(j=0;j<512;j++) buffer[j] = 0; ip = iget(1, 3); ilock(ip); if(ip->size < 512*20){ cprintf("Creating Journal...\n"); for(i=0;i<20;i++){ writei(ip, buffer, i*512, sizeof(buffer)); } } else { readi(ip, &t_blk, 0, sizeof(t_blk)); if(t_blk.state == LOGGING){ cprintf("Inconsistency found in file system. Attempting to recover.\n"); for(i = 0; i < t_blk.num_blks; i++){ readi(ip, buffer, i*512+512, sizeof(buffer)); bp = bread(1, t_blk.sector[i]); cprintf("Recovering data in sector: %d\n", t_blk.sector[i]); memmove(bp->data, buffer, sizeof(buffer)); bwrite(bp); brelse(bp); } writei(ip, buffer, 0, sizeof(buffer)); cprintf("Recovery Complete.\n"); } } iunlock(ip); }
int main(){ int n1,result;int *ep;int temp; prints("Program to calculate factorial of a number:\n"); prints("Enter n1:"); n1=readi(); result=factorial(n1); prints("The factorial of the given number is:"); printi(result); prints("\n"); return 0; }
void j_init() { struct inode *ip; uchar buffer[512]; int i, j; struct buf *bp; struct t_start_blk t_blk; for(j=0;j<512;j++) buffer[j] = 0; ip = iget(1, 3); ilock(ip); if(ip->size < 512*20){ cprintf("alloc journal\n"); // allocate journal if too small for(i=0;i<20;i++){ writei(ip, buffer, i*512, sizeof(buffer)); } } else { readi(ip, &t_blk, 0, sizeof(t_blk)); // check if there is a valid not commited transaction if(t_blk.state == READY){ cprintf("~~~~~~~~~~RECOVERING!!!!!~~~~~~~~~~\n"); for(i = 0; i < t_blk.num_blks; i++){ readi(ip, buffer, i*512+512, sizeof(buffer)); bp = bread(1, t_blk.sector[i]); cprintf("recovering sector %d\n", t_blk.sector[i]); memmove(bp->data, buffer, sizeof(buffer)); bwrite(bp); brelse(bp); } writei(ip, buffer, 0, sizeof(buffer)); cprintf("~~~~~RECOVERY COMPLETE~~~~~~~~\n"); } } iunlock(ip); }
int main() { int a[100]; int i; int j; int n; int err; prints("Enter the total number of integers to sort :"); n = readi(&err); prints("Enter the number one by one:\n"); for(i=0;i<n;i++) { a[i] = readi(&err); } prints("Sorting the array. \n"); int temp; for(i=n;i>0;i--) { for(j=0;j<i-1;j++) { if(a[j+1]<a[j]) { temp = a[j]; a[j] = a[j+1]; a[j+1]=temp; } } } prints("Printing the sorted array. \n"); for(i=0;i<n;i++) { printi(a[i]); prints(" "); } prints("\n"); return 0; }
int main() { prints("Enter a number whose factorial you want to know: ") ; int n,err; n = readi(&err); int fact; fact = factorial(n); prints("The value is: "); printi(fact); prints("\n"); prints("Enter a number n whose fibonacci(n) you want to know: "); n = readi(&err); int fib; prints("The value is: "); fib = fibonacci(n); printi(fib); prints("\n"); return 0; }
Node::Node(const Block &blk) { // notice here char* mem = (char*)malloc(BLOCK_SIZE); memcpy(mem, blk.data, BLOCK_SIZE); isleaf = mem[0]; isroot = mem[1]; mem += 2*sizeof(char); int pSize = readi(mem), kSize = readi(mem), typeId = readi(mem), strLen = readi(mem); //system("pause"); int p = 0; for( int i = 0; i < pSize; i++ ) { p = readi(mem); P.push_back(p); } for( int i = 0; i < kSize; i++ ) { AttrType k; if( typeId == 0 ) { // int k = AttrType(readi(mem)); } else if( typeId == 1 ) { // float k = AttrType(readf(mem)); } else if( typeId == 2 ) { // string k = AttrType(reads(mem, strLen)); } K.push_back(k); } }
int main() { prints("Enter three numbers whose maximum among them you want to know\n"); int a,b,c,err; prints("Enter the first number: "); a = readi(&err); prints("Enter the second number: "); b = readi(&err); prints("Enter the third number: "); c = readi(&err); int max; max = findmax(a,b,c); prints("The max value is: "); printi(max); prints("\n"); prints("Lets do expression tests:\n"); prints("a = b*c*a = "); a = b*c*a; printi(a); prints("\n"); prints("b = a/c = "); b = a/c; printi(b); prints("\n"); prints("c = a%b = "); c = a%b; printi(c); prints("\n"); return 0; }
int16_t _read(void) { inoptr ino; uint8_t flag; if (!valaddr(buf, nbytes)) return -1; /* Set up u_base, u_offset, ino; check permissions, file num. */ if ((ino = rwsetup(true, &flag)) == NULLINODE) return -1; /* bomb out if error */ readi(ino, flag); updoff(); return (udata.u_count); }
int main() { float x; int y; prints("Enter a floating point number :"); if(!readf(&x)) printd(x); else prints("Invalid floating point number!"); prints("\nEnter an integer :"); if(!readi(&y)) printi(y); else prints("Invalid integer!"); prints("\n"); return 0; }
int main(){ u = prints("Enter a year \n"); int year,rem400,rem100,rem4; year = readi(&u); rem400 = year%400; rem100 = year%100; rem4 = year%4; if(rem400 == 0) u = prints("Given year is a leap year \n"); else if(rem100 == 0) u = prints("Given year is a leap year \n"); else if(rem4 == 0) u = prints("Given year is a leap year \n"); else u = prints("Given year is not a leap year \n"); return 0; }
int main() { prints("Enter 10 integers to sort:\n"); int a[10]; int i; int ep; for(i = 0; i<10; i++) a[i] = readi(&ep); // for(i = 0; i<10; i++) printi(a[i]); sort(a,10); prints("The sorted integers are:\n"); for(i = 0; i<10; i++) { printi(a[i]); prints(" "); } prints("\n"); return 0; }
// Load a program segment into pgdir. addr must be page-aligned // and the pages from addr to addr+sz must already be mapped. int loaduvm(pde_t *pgdir, char *addr, struct inode *ip, uint offset, uint sz) { uint i, pa, n; pte_t *pte; if((uint)addr % PGSIZE != 0) panic("loaduvm: addr must be page aligned\n"); for(i = 0; i < sz; i += PGSIZE){ if(!(pte = walkpgdir(pgdir, addr+i, 0))) panic("loaduvm: address should exist\n"); pa = PTE_ADDR(*pte); if(sz - i < PGSIZE) n = sz - i; else n = PGSIZE; if(readi(ip, (char *)pa, offset+i, n) != n) return 0; } return 1; }
struct inode *dirlookup(struct inode *dp, char *dirname, uint32_t *offp) { if(!ISDIR(dp->mode)) return NULL; struct dirent dir; for(int off = 0; off < dp->size; off+=sizeof(struct dirent)) { if(readi(dp, (char *)&dir, off, sizeof(struct dirent)) != sizeof(struct dirent)) return NULL; if(!strcmp(dir.name, dirname) && dir.ino) { if(offp) *offp = off; return iget(dp->dev, dir.ino); } } return NULL; }
int main() { int p,ll,ans,now; scanf("%d",&n); num[0] = - MAXL; if (n==1) ans=1; else { ans=0; scanf("%d",&num[1]); for (int i=1; i<=n; ++i) { num[(i+1) & MAXP]=readi(i+1); if (num[(i-1)&MAXP]<num[i &MAXP] && num[(i+1)&MAXP]<num[i&MAXP]) ++ans; } ans=ans*2-1; if (num[n&MAXP]<num[(n-1)&MAXP]) ++ans; } printf("%d",ans); return 0; }
int main(){ int a[10]; int i=1,j,x,t;int m,n; prints("Enter 10 numbers\n"); for(i=0;i<10;i=i+1){ x=readi(); a[i]=x; } prints("You entered:\n"); for(i=0;i<10;i=i+1){ j=a[i]; printi(j);prints("\n"); } for(i=0;i<10;i=i+1){ for(j=i+1;j<10;j=j+1){ m=a[i]; n=a[j]; if(m>n){ a[i]=n; a[j]=m; } else{ i=i; } i=i; } i=i; } prints("Sorted array is:\n"); for(i=0;i<10;i=i+1){ j=a[i]; printi(j);prints("\n"); } return 0; }
// Load a program segment into pgdir. addr must be page-aligned // and the pages from addr to addr+sz must already be mapped. int loaduvm(pde_t *pgdir, char *addr, struct inode *ip, uint offset, uint sz) { uint i, pa, n; pte_t *pte; if((uint) addr % PGSIZE != 0) panic("loaduvm: addr must be page aligned"); if((uint)addr + sz > USERBOUND) panic("loaduvm: user address space exceeds the allowed space (> 0x80000000)"); for(i = 0; i < sz; i += PGSIZE){ if((pte = walkpgdir(pgdir, addr+i, UVMPDXATTR, 0)) == 0) panic("loaduvm: address should exist"); pa = PTE_ADDR(*pte); if(sz - i < PGSIZE) n = sz - i; else n = PGSIZE; if(readi(ip, p2v(pa), offset+i, n) != n) return -1; } return 0; }
int main () { int a = 5, b = 2, c; char ch = 'x'; char* str; str = "abc\n"; char* str12; str12 = "abcd"; int read; read = 5; int eP; if (a<b) { a++; } else { c = a+b; } prints("Please enter a number: "); read = readi(&eP); prints("You Entered "); c = printi(read); prints("\n"); // prints(str); return; }
void Node::resetByBlock(const Block &blk) { char* mem = (char*)malloc(BLOCK_SIZE); memcpy(mem, blk.data, BLOCK_SIZE); isleaf = mem[0]; isroot = mem[1]; mem += 2*sizeof(char); int pSize = readi(mem), kSize = readi(mem), typeId = readi(mem), strLen = readi(mem); //system("pause"); std::vector<AttrType>::iterator iter_K=K.begin(); for ( ;iter_K!=K.end();) iter_K=K.erase(iter_K); std::vector<int>::iterator iter_P=P.begin(); for ( ;iter_P!=P.end();) iter_P=P.erase(iter_P); int p = 0; for( int i = 0; i < pSize; i++ ) { p = readi(mem); P.push_back(p); } for( int i = 0; i < kSize; i++ ) { AttrType k; if( typeId == 0 ) { // int k = AttrType(readi(mem)); } else if( typeId == 1 ) { // float k = AttrType(readf(mem)); } else if( typeId == 2 ) { // string k = AttrType(reads(mem, strLen)); } K.push_back(k); } }
int exec(char *path, char **argv) { char *s, *last; int i, off; uint argc, sz, sp, ustack[3+MAXARG+1]; struct elfhdr elf; struct inode *ip; struct proghdr ph; pde_t *pgdir, *oldpgdir; begin_op(); if((ip = namei(path)) == 0){ end_op(); return -1; } ilock(ip); pgdir = 0; // Check ELF header if(readi(ip, (char*)&elf, 0, sizeof(elf)) < sizeof(elf)) goto bad; if(elf.magic != ELF_MAGIC) goto bad; if((pgdir = setupkvm()) == 0) goto bad; // Load program into memory. sz = 0; for(i=0, off=elf.phoff; i<elf.phnum; i++, off+=sizeof(ph)){ if(readi(ip, (char*)&ph, off, sizeof(ph)) != sizeof(ph)) goto bad; if(ph.type != ELF_PROG_LOAD) continue; if(ph.memsz < ph.filesz) goto bad; if((sz = allocuvm(pgdir, sz, ph.vaddr + ph.memsz)) == 0) goto bad; if(loaduvm(pgdir, (char*)ph.vaddr, ip, ph.off, ph.filesz) < 0) goto bad; } iunlockput(ip); end_op(); ip = 0; // Allocate two pages at the next page boundary. // Make the first inaccessible. Use the second as the user stack. sz = PGROUNDUP(sz); if((sz = allocuvm(pgdir, sz, sz + 2*PGSIZE)) == 0) goto bad; clearpteu(pgdir, (char*)(sz - 2*PGSIZE)); sp = sz; // Push argument strings, prepare rest of stack in ustack. for(argc = 0; argv[argc]; argc++) { if(argc >= MAXARG) goto bad; sp = (sp - (strlen(argv[argc]) + 1)) & ~3; if(copyout(pgdir, sp, argv[argc], strlen(argv[argc]) + 1) < 0) goto bad; ustack[3+argc] = sp; } ustack[3+argc] = 0; ustack[0] = 0xffffffff; // fake return PC ustack[1] = argc; ustack[2] = sp - (argc+1)*4; // argv pointer sp -= (3+argc+1) * 4; if(copyout(pgdir, sp, ustack, (3+argc+1)*4) < 0) goto bad; // Save program name for debugging. for(last=s=path; *s; s++) if(*s == '/') last = s+1; safestrcpy(proc->name, last, sizeof(proc->name)); // Commit to the user image. oldpgdir = proc->pgdir; proc->pgdir = pgdir; proc->sz = sz; proc->tf->eip = elf.entry; // main proc->tf->esp = sp; switchuvm(proc); freevm(oldpgdir); return 0; bad: if(pgdir) freevm(pgdir); if(ip){ iunlockput(ip); end_op(); } return -1; }