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;
}
