There are four phases for a c program to be execute,

1.pre-processor

2.compiler

3.assembler

4.linker

let’s start with the first one,

#Pre-Processor- The pre-processor removes the comments and include header files in source code, replace macro name with code.

Basically, it is a program that processes its input data to produce output that can be used by another program as its input. Obviously, compiler is the next one,

#Compiler- A compiler is a program that processes your written data which is in your language convert into machine language i.e. binary form(0 &1).

Basically, it generates the assembly code of the file, it converts the (.i) file into the (.s) file. Any file entering into compiler program passes through lexical analysis, syntax analysis, intermediate code generation, code optimization, object code generation. And the next one is,

#Assembler- An assembler is a program that converts assembly language or assembly code into machine code or object code. Assemblers are similar to compilers in that they produce executable codes.

It converts the (.s) file into the (.o) file. Finally, the last one is,

#Linker- A linker is a computer program that takes one or more object files generated by a compiler and combines them into one, executable program.

There are two types of linker i.e. static linking and dynamic linking.

Static linkingis the result of the linker copying all library routines used in the program into the executable image.

Dynamic linking is done during load or run-time and not when the exe is created.

It converts the (.o) file into the executable file for example (.elf) file.

Now let’s create a simple program,

First we write our program in the vim editor* *(you can use any editor)

#include<stdio.h>

int main()

{

printf(“Hello, This is Ritik Sharma\n”);

return 0;

}

save the file with a name and (.c) extension and then exit from the vim editor

now compile the file with the compiler for example gcc,

then execute the file which is ./a.out and you can see the output as given below,

Hello, This is Ritik Sharma

nice! You got the output. If any error occurred during compiling the program then note that error and try to correct that error.

_THANK YOU_

C is a general purpose high level programming language used to develop portable applications and firmware. It is originally designed to develop system software and operating systems. C was invented by Dennis’s Ritchie at bell labs in the 1972s. C has a primary application of Unix operating system. C have a main features low-level access to memory, simple set of keywords and clean style. Because of these features, this language is a suitable language for operating system development. After C, I follow the syntax of many developed language PHP, Java, Java script etc. C was initially used for system development work, particularly program of the system operating system. C was adopted a system language because it produce code that runs nearly as fast as the written code of assembly language.

Developing programs using c requires software called integrated development environment (IDE) such as turbo c, codeblocks, visiual studio etc. the integrated development environment mainly three programs:

1. Text editor 2. Compiler 3.Debugger.

1 . Text editor :- it is used to type of instructions of program which is called of source code. Source code is stored in c file.

2. compiler:- it is used to translate instructions of program into machine language which is called binary code.

3. Debugger:- it is used to find bugs(errors) within programs.

Keyword:- keywords are p redefined word for performing various type of c. there are total 32 keywords

available in c. example :- char,float,int etc.

Variable:- variable are new words created by us for storing data. Its value changes during execution programs. Example :-a,b,c, num, sum etc.

Constant:- Constant refer to the fixed value of that does not change during execution of program. No matter where we use it in program, it meaning always remains same. Example :-5, 34.33, -71 etc.

Operator :- symbols that are used to perform operations between variable are called operators. Example:- +,-,*, / = etc.

Application and Uses Language:-

C is mainly used to develop system software such as operating system, compiler etc. But it can also be used for developing and kind of application software such as commercial, scientific, games etc.

Advantage of C Language:-

1. C language is a building block for many other currently known language. C language has variety of data types and powerful operator. Due to this, program written in c language are efficient,fast and easy to understand.

2. C is highly portable language. This means that c programs written for one computer can easily run on another computer without any change or by doing a little change.

3. There are only 32 keywords in ANSI c and its strength in built in functions,several standard functions are available which can be used for developing program.

Disadvantage of C:-

1. C does not have concept of oops, that’s why c++ is developed.

2. there is no run time checking in c language.

3. there is no strict type checking.

4. C does not have the concept of name space.

5. C does not have the concept of constructor or destructor.

Gcc compiler

Compilation Process:

Any c file, a user wants to compile is not directly compiled. For example, there is c file having a name hello.c, this hello.c file is not directly provided to the compiler. Hello.c file first of all provided to the gcc preprocessor , this preprocessor converts this hello.c file into hello.i file. This hello.i file consists of two file stdio.h and hello.c file. The combination these two files together makes a new file which is hello.c file . This hello.c file is provided to the gcc compiler. The gcc compiler is basically a two pass compiler which passes file two times . Then the file moves to the lexical analysis ,this lexical analysis breaks the content of file into tokens , then the tokens are provided to the syntax analysis which analysis all the tokens of file according to the c format ,this analysis gave us an errors ,saying that tokens used are appropriate or not .After the analysis process, file passes through the intermediate code generation, code optimization and object code generation. After the 2-pass compilation process, the format of file changes into different format which is in hello.s format .The output of the compiler is provided to the assembly, which is in the format of hello.s file. This hello.s file through assembly passes to the assembler. Assembler converts this hello.s file into hello.o file. This hello.o file passes through the symbol table, data segment and code segment process . After passing through these processes, file is provided to linker .The output of linker generates a new file named as a.out file which is in executable format. This executable file is then provided to the executable linkable format (elf), data segment and code segment.

After this whole process loader loads the file into the RAM. File spreads out in the ram. Ram is basically a process context (virtual address space content ) which consists of stack segment, file descripter, data segment and code segment. Stack segment consists of local variable of the file. File descripter consists of three ports 0,1,2 . These three ports are connected to the standard input, standard output and standard error respectively via stream. Stream is used for moving data wheather for input, output or for error. Standard input is used for entering the data to the port 0. standard output takes out the data from port 1. And standard error is to takes out the error from port 2. Data segment consists of various variables like global variable, static variable, extreme variable, register variable, volatile variable, constant variable, macros variable and preprocessor directive. Code segment consists of compiled code. Stack segment, file directive, data segment and code segment all these have some logical addresses.

the c programe are work in 5 process-

• Preprocessor
• compiler
• assembler
• linker
• loader

Preprocessor-In the preprocessor a preprocessor directive (#) and a header file (stdio.h)

int main() the programe are start for exicute.

after that type a code “hello world” use c libraries.

and the last format is return 0; in this point the programe is success full exicute.

after that this process the preprocessor also give a hello.i file.

in hello.i file are include 2. files stdio.h+hello.c file.

Compiler-in this process the compiler are work in 2 pras.

1.pras 

• lexical analysis
• syntax analysis
• intermediate code genration
• code optimization

the 1st pras process is create a symbol table.

2. pras

• lexical analysis
• syntax analysis
• intermediate code genration
• code optimization
• object code genration

and the 2nd pras is compile the code use symbol table.

and compiler create a ” hello.s” file.

Lexical analysis-in lexical process the code is break in tokken,

example- hello world  –>h e l l o w o r l d. 

Syntax analysis-in syntax process the cheak the code in right format.

example (),:,<,>,”””.

Intermediate code genration-in intermediate code genration process the code token also arrange in  highest priority order.

Code optimization-in code optimization process the compiler also optimize code  and resolve  minor error.

Object code genration-in object code genration process the compiler are genrate the full code in objective form.

 in this process the fully code also link of symbol table.

in hello.s file, include “code,data segment,symbol table”.

Assembler-   after the compiler process the code also convert in  assembly language.

and make a hello.o file in .o file include links,data ,code, refrence symbol table.

linker- the linker process  also linked the code for c library and symbol table.

and make exicutable linkable format and output file-> a.out.

in this file stored in secondry memory .

programe  compiling process is complete

Loader- the programe exicutable linkable format file (secondry memory) to process context (primary memory) through loader.

]]> https://www.emblogic.com/blog/02/compiler-process-in-c/feed/ 0 https://www.emblogic.com/blog/12/what-is-function-pointer/ https://www.emblogic.com/blog/12/what-is-function-pointer/#comments Thu, 29 Dec 2016 05:25:43 +0000 http://www.emblogic.com/blog/?p=13820 Continue reading →]]> A function pointer (or subroutine pointer or procedure pointer) is a type of pointer supported by third-generation programming languages (such as PL/I, COBOL, Fortran,[1] dBASE dBL, and C) and object-oriented programming languages (such as C++ and D).[2]

Instead of referring to data values, a function pointer points to executable code within memory. When dereferenced, a function pointer can be used to invoke the function it points to and pass its arguments just like a normal function call. Such an invocation is also known as an “indirect” call, because the function is being invoked indirectly through a variable instead of directly through a fixed name or address.

Function pointers can be used to simplify code by providing a simple way to select a function to execute based on run-time values.

The simplest implementation of a function (or subroutine) pointer is as a variable containing the address of the function within executable memory. Older third-generation languages such as PL/I and COBOL, as well as more modern languages such as Pascal and C generally implement function pointers in this manner.[3]

The following C program illustrates the use of two function pointers:

func1 takes one double-precision (double) parameter and returns another double, and is assigned to a function which converts centimetres to inches
func2 takes a pointer to a constant character array as well as an integer and returns a pointer to a character, and is assigned to a string library function which returns a pointer to the first occurrence of a given character in a character array

#include /* for printf */
#include /* for strchr */

double cm_to_inches(double cm) {
return cm / 2.54;
}

int main(void) {
double (*func1)(double) = cm_to_inches;
char * (*func2)(const char *, int) = strchr;
printf(“%f %s”, func1(15.0), func2(“Wikipedia”, ‘p’));
/* prints “5.905512 pedia” */
return 0;
}

The next program uses a function pointer to invoke one of two functions (sin or cos) indirectly from another function (compute_sum, computing an approximation of the function’s Riemann integration). The program operates by having function main call function compute_sum twice, passing it a pointer to the library function sin the first time, and a pointer to function cos the second time. Function compute_sum in turn invokes one of the two functions indirectly by dereferencing its function pointer argument funcp multiple times, adding together the values that the invoked function returns and returning the resulting sum. The two sums are written to the standard output by main.

#include
#include

// Function taking a function pointer as an argument
double compute_sum(double (*funcp)(double), double lo, double hi) {
double sum = 0.0;

// Add values returned by the pointed-to function ‘*funcp’
int i;
for(i = 0; i <= 100; i++) {
double x, y;

// Use the function pointer 'funcp' to invoke the function
x = i / 100.0 * (hi – lo) + lo;
y = (*funcp)(x);
sum += y;
}
return sum / 101.0;
}

int main(void) {
double (*fp)(double); // Function pointer
double sum;

// Use 'sin()' as the pointed-to function
fp = sin;
sum = compute_sum(fp, 0.0, 1.0);
printf("sum(sin): %f\n", sum);

// Use 'cos()' as the pointed-to function
fp = cos;
sum = compute_sum(fp, 0.0, 1.0);
printf("sum(cos): %f\n", sum);
return 0;
}

int main()
{
int temp;
int *t;
int a=100,b=200;
//Using 3 variables
//1.1
temp = a;
a = b;
b = temp;
printf(“%d %d\n”,a,b);
//1.2
swap(&a,&b);
printf(“%d %d\n”,a,b);

//Using 2 variables
//2.1
a += b;
b = a-b;
a = a-b;
printf(“%d %d\n”,a,b);
//2.2
if(a!=0 && b!=0)
{
a *= b;
b = a/b;
a = a/b;
printf(“%d %d\n”,a,b);
}
//2.3
a = a^b;
b = a^b;
a = a^b;
printf(“%d %d\n”,a,b);
//Using 2 variables in single step
//3.1
a = b+a-(b=a);
printf(“%d %d\n”,a,b);
//3.2
a = b*a/(b=a);
printf(“%d %d\n”,a,b);
//3.3
a ^=b^=a^=b;
printf(“%d %d\n”,a,b);
return 0;
}
void swap(int *x,int *y)
{
int tmp;
tmp = *x;
*x = *y;
*y = tmp;
}

Line 2 :-
*7. int main(  -> error: expected declaration specifiers or ‘…’ before ‘{’ token
*8. int main   -> error: expected ‘=’, ‘,’, ‘;’, ‘asm’ or ‘__attribute__’ before ‘{’ token
*9. in main()  -> error: unknown type name ‘in’
*10. int main(*) -> error: expected declaration specifiers or ‘…’ before ‘*’ token
*11. int main(‘) ->  error: missing terminating ‘ character
*12. If no main() -> error: expected identifier or ‘(’ before ‘{’ token

Line 3 :-
*13. if no {  -> error: expected declaration specifiers before ‘printf’
error: expected declaration specifiers before ‘return’
error: expected declaration specifiers before ‘}’ token
*14. ..{  -> error: expected ‘{’ at end of input
*15. {..  -> error: expected expression before ‘.’ token

Line 4 :-
*16. printf(“Hello World”). -> error: expected identifier before ‘return’
*17. printf(“Hello World”) -> error: expected ; before ‘return’
*18. printf(“Hello World”) -> error: expected ‘)’ before ‘;’ token
error: expected ‘;’ before ‘}’ token
*19. print(“Hello World”)  -> undefined reference to `print’
*20. print(Hello World)  -> error: ‘Hello’ undeclared (first use in this function)
*21. print(“Hello World)  -> warning: missing terminating ” character [enabled by default]
error: missing terminating ” character
error: expected expression before ‘return’
error: expected ‘;’ before ‘}’ token
Line 5 :-
*22. return c; -> error: ‘c’ undeclared (first use in this function)
Line 6 :-
*23. missing } -> error: expected declaration or statement at end of inpu

*/

/* Warnings

w1. If u remove header -> warning: incompatible implicit declaration of built-in function ‘printf’
*w2. #include<stdio.h> -> warning: extra tokens at end of #include directive [enabled by default]
*w3. return NULL       -> warning: return makes integer from pointer without a cast

*/ Special Case :-
/* ; -> You can freely put ; or ;; anywhere in main (before fn., after fn., blank line etc.)
*      Except you can’t put ; after main();
*      ;int main() -> Valid
*      {; ->         Valid
*      }; ->         Valid
*      printf(“Hello World”);; -> Valid
*    Shows warning if used after #include<stdio.h>;
*/

int main()
{
int r,c,k;
printf(“enter the size of rows\n”);
scanf(“%d”,&r);
printf(“enter the size of columns\n”);
scanf(“%d”,&c);
int **a,**b,**d,i,j;
a=(int **)malloc(sizeof(int*)*3);
if(!a)
{
perror(“malloc”);
goto x;
}
for(i=0;i<3;i++)
*(a+i)=(int *)malloc(sizeof(int)*3);
if(!(*(a+i)))
{
perror("malloc");
goto x;
}
b=(int **)malloc(sizeof(int*)*3);
if(!b)
{
perror("malloc");
goto x;
}
for(i=0;i<3;i++)
*(b+i)=(int *)malloc(sizeof(int)*3);
if(!(*(b+i)))
{
perror("malloc");
goto x;
}
d=(int **)malloc(sizeof(int*)*3);
if(!d)
{
perror("malloc");
goto x;
}
for(i=0;i<3;i++)
*(d+i)=(int *)malloc(sizeof(int)*3);
if(!(*(d+i)))
{
perror("malloc");
goto x;
}

printf("enter the element of 1st matrix\n");
for(i=0;i<r;i++)
{
for(j=0;j<c;j++)
{
scanf("%d",*(a+i)+j);
}
}

printf("enter the element of 2nd matrix\n");
for(i=0;i<r;i++)
{
for(j=0;j<c;j++)
{
scanf("%d",*(b+i)+j);
}
}

printf("the element of 1st matrix\n");
for(i=0;i<r;i++)
{
for(j=0;j<c;j++)
{
printf("%d\t",*(*(a+i)+j));
}
printf("\n");
}

printf("\nthe element of 2nd matrix\n");
for(i=0;i<r;i++)
{
for(j=0;j<c;j++)
{
printf("%d\t",*(*(b+i)+j));
}
printf("\n");
}

for(i=0;i<r;i++)
{

for(j=0;j<c;j++)

{
*((*(d+i)+j)) = *((*(a+i))+j) + *((*(b+i))+j);

}
}

printf("\naddition is\n");

for(i=0;i<r;i++)
{
for(j=0;j<c;j++)

{
printf("%d\t",*((*(d+i))+j));
}
printf("\n");
}
return 0;
x:
return -1;
}

when a object is deleted or de allocated without modifying the value of the pointer that time dangling pointer arise.

uninitialized pointer are known as wild pointer beacause they point to some other memory location .

#include<stdio.h>
#include<stdlib.h>
int main()
{
system(“clear”);
int r,c,i,j,a[10][10],b[10][10],d[10][10];
printf(“Enter Row\n”);
scanf(“%d”,&r);
printf(“Enter Column\n”);
scanf(“%d”,&c);
printf(“Enter Element of Matrix1\n”);
for(i=0;i<r;i++)
{
for(j=0;j<c;j++)
{
scanf(“%d”,&a[i][j]);
}
}
printf(“Enter Element of Matrix2\n”);
for(i=0;i<r;i++)
{
for(j=0;j<c;j++)
{
scanf(“%d”,&b[i][j]);
}
}
for(i=0;i<r;i++)
{
for(j=0;j<c;j++)
{
d[i][j]=a[i][j]-b[i][j];
}
}
printf(“Subtraction of two Matrixs\n”);
for(i=0;i<r;i++)
{
for(j=0;j<c;j++)
{
printf(“%d-%d=%d\n”,a[i][j],b[i][j],d[i][j]);
}
}
}

RCS file: ./header.h,v
Working file: ./header.h
head: 1.4
branch:
locks: strict
root: 1.4
access list:
symbolic names:
keyword substitution: kv
total revisions: 4; selected revisions: 4
description:
This is the header file
—————————-
revision 1.4 locked by: root;
date: 2015/10/29 15:19:42; author: root; state: Exp; lines: +1 -1
*** empty log message ***
—————————-
revision 1.3
date: 2015/10/29 14:38:28; author: root; state: Exp; lines: +8 -1
*** empty log message ***
—————————-
revision 1.2
date: 2015/10/29 14:29:02; author: root; state: Exp; lines: +2 -1
*** empty log message ***
—————————-
revision 1.1
date: 2015/10/29 14:00:38; author: root; state: Exp;
Initial revision
=============================================================================

RCS file: ./main.c,v
Working file: ./main.c
head: 1.3
branch:
locks: strict
root: 1.3
access list:
symbolic names:
keyword substitution: kv
total revisions: 3; selected revisions: 3
description:
This is the main file
—————————-
revision 1.3 locked by: root;
date: 2015/10/31 16:15:42; author: root; state: Exp; lines: +4 -4
*** empty log message ***
—————————-
revision 1.2
date: 2015/10/29 14:29:04; author: root; state: Exp; lines: +11 -8
*** empty log message ***
—————————-
revision 1.1
date: 2015/10/29 14:23:27; author: root; state: Exp;
Initial revision
=============================================================================
RCS file: ./ma.c,v
Working file: ./ma.c
head: 1.2
branch:
locks: strict
root: 1.2
access list:
symbolic names:
keyword substitution: kv
total revisions: 2; selected revisions: 2
description:
This file is to find the master array
—————————-
revision 1.2 locked by: root;
date: 2015/10/31 17:37:53; author: root; state: Exp; lines: +4 -3
*** empty log message ***
—————————-
revision 1.1
date: 2015/10/29 14:00:38; author: root; state: Exp;
Initial revision
=============================================================================

RCS file: ./mdc.c,v
Working file: ./mdc.c
head: 1.3
branch:
locks: strict
root: 1.3
access list:
symbolic names:
keyword substitution: kv
total revisions: 3; selected revisions: 3
description:
This is the main file
—————————-
revision 1.3 locked by: root;
date: 2015/10/31 17:37:51; author: root; state: Exp; lines: +1 -1
*** empty log message ***
—————————-
revision 1.2
date: 2015/10/29 14:23:35; author: root; state: Exp; lines: +2 -25
*** empty log message ***
—————————-
revision 1.1
date: 2015/10/29 14:00:38; author: root; state: Exp;
Initial revision
=============================================================================

RCS file: ./cl.c,v
Working file: ./cl.c
head: 1.1
branch:
locks: strict
root: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
This file is to find the codelength
—————————-
revision 1.1 locked by: root;
date: 2015/10/29 14:00:38; author: root; state: Exp;
Initial revision
=============================================================================

RCS file: ./compress.c,v
Working file: ./compress.c
head: 1.16
branch:
locks: strict
root: 1.16
access list:
symbolic names:
keyword substitution: kv
total revisions: 16; selected revisions: 16
description:
This file is compress the file
—————————-
revision 1.16 locked by: root;
date: 2015/11/05 07:36:34; author: root; state: Exp; lines: +4 -4
*** empty log message ***
—————————-
revision 1.15
date: 2015/11/05 07:30:51; author: root; state: Exp; lines: +10 -10
*** empty log message ***
—————————-
revision 1.14
date: 2015/10/31 17:37:54; author: root; state: Exp; lines: +13 -0
*** empty log message ***
—————————-
revision 1.13
date: 2015/10/30 10:53:09; author: root; state: Exp; lines: +1 -1
*** empty log message ***
—————————-
revision 1.12
date: 2015/10/30 10:45:30; author: root; state: Exp; lines: +71 -11
*** empty log message ***
—————————-
revision 1.11
date: 2015/10/30 07:05:04; author: root; state: Exp; lines: +3 -3
*** empty log message ***
—————————-
revision 1.10
date: 2015/10/30 07:01:47; author: root; state: Exp; lines: +1 -1
*** empty log message ***
—————————-
revision 1.9
date: 2015/10/30 06:47:32; author: root; state: Exp; lines: +3 -0
*** empty log message ***
—————————-
revision 1.8
date: 2015/10/29 17:12:00; author: root; state: Exp; lines: +3 -0
*** empty log message ***
—————————-
revision 1.7
date: 2015/10/29 17:04:29; author: root; state: Exp; lines: +2 -2
*** empty log message ***
—————————-
revision 1.6
date: 2015/10/29 16:55:22; author: root; state: Exp; lines: +1 -0
*** empty log message ***
—————————-
revision 1.5
date: 2015/10/29 16:18:57; author: root; state: Exp; lines: +46 -0
*** empty log message ***
—————————-
revision 1.4
date: 2015/10/29 15:19:44; author: root; state: Exp; lines: +75 -21
*** empty log message ***
—————————-
revision 1.3
date: 2015/10/29 14:50:01; author: root; state: Exp; lines: +13 -0
*** empty log message ***
—————————-
revision 1.2
date: 2015/10/29 14:38:30; author: root; state: Exp; lines: +15 -2
*** empty log message ***
—————————-
revision 1.1
date: 2015/10/29 14:00:38; author: root; state: Exp;
Initial revision
=============================================================================

RCS file: ./decompress.c,v
Working file: ./decompress.c
head: 1.27
branch:
locks: strict
root: 1.27
access list:
symbolic names:
keyword substitution: kv
total revisions: 27; selected revisions: 27
description:
This file is to decompress
—————————-
revision 1.27 locked by: root;
date: 2015/11/05 07:45:47; author: root; state: Exp; lines: +8 -8
*** empty log message ***
—————————-
revision 1.26
date: 2015/11/05 07:36:35; author: root; state: Exp; lines: +10 -10
*** empty log message ***
—————————-
revision 1.25
date: 2015/11/05 07:33:46; author: root; state: Exp; lines: +1 -1
*** empty log message ***
—————————-
revision 1.24
date: 2015/11/05 07:30:53; author: root; state: Exp; lines: +14 -14
*** empty log message ***
—————————-
revision 1.23
date: 2015/10/31 17:37:54; author: root; state: Exp; lines: +5 -9
*** empty log message ***
—————————-
revision 1.22
date: 2015/10/30 14:53:55; author: root; state: Exp; lines: +5 -0
*** empty log message ***
—————————-
revision 1.21
date: 2015/10/30 14:52:43; author: root; state: Exp; lines: +4 -2
*** empty log message ***
—————————-
revision 1.20
date: 2015/10/30 14:51:23; author: root; state: Exp; lines: +1 -1
*** empty log message ***
—————————-
revision 1.19
date: 2015/10/30 14:49:39; author: root; state: Exp; lines: +1 -1
*** empty log message ***
—————————-
revision 1.18
date: 2015/10/30 14:48:48; author: root; state: Exp; lines: +1 -1
*** empty log message ***
—————————-
revision 1.17
date: 2015/10/30 14:46:45; author: root; state: Exp; lines: +2 -3
*** empty log message ***
—————————-
revision 1.16
date: 2015/10/30 10:45:31; author: root; state: Exp; lines: +47 -1
*** empty log message ***
—————————-
revision 1.15
date: 2015/10/29 17:18:49; author: root; state: Exp; lines: +8 -0
*** empty log message ***
—————————-
revision 1.14
date: 2015/10/29 17:14:50; author: root; state: Exp; lines: +1 -1
*** empty log message ***
—————————-
revision 1.13
date: 2015/10/29 17:14:30; author: root; state: Exp; lines: +0 -8
*** empty log message ***
—————————-
revision 1.12
date: 2015/10/29 17:13:12; author: root; state: Exp; lines: +9 -8
*** empty log message ***
—————————-
revision 1.11
date: 2015/10/29 17:12:01; author: root; state: Exp; lines: +8 -0
*** empty log message ***
—————————-
revision 1.10
date: 2015/10/29 16:59:58; author: root; state: Exp; lines: +2 -2
*** empty log message ***
—————————-
revision 1.9
date: 2015/10/29 16:55:23; author: root; state: Exp; lines: +38 -1
*** empty log message ***
—————————-
revision 1.8
date: 2015/10/29 15:35:17; author: root; state: Exp; lines: +1 -0
*** empty log message ***
—————————-
revision 1.7
date: 2015/10/29 15:34:15; author: root; state: Exp; lines: +0 -1
*** empty log message ***
—————————-
revision 1.6
date: 2015/10/29 15:33:58; author: root; state: Exp; lines: +0 -3
*** empty log message ***
—————————-
revision 1.5
date: 2015/10/29 15:32:47; author: root; state: Exp; lines: +2 -2
*** empty log message ***
—————————-
revision 1.4
date: 2015/10/29 15:32:19; author: root; state: Exp; lines: +61 -18
*** empty log message ***
—————————-
revision 1.3
date: 2015/10/29 14:50:02; author: root; state: Exp; lines: +19 -7
*** empty log message ***
—————————-
revision 1.2
date: 2015/10/29 14:38:31; author: root; state: Exp; lines: +25 -1
*** empty log message ***
—————————-
revision 1.1
date: 2015/10/29 14:00:38; author: root; state: Exp;
Initial revision
=============================================================================

#include<stdio.h>
int main()
{
int n;
printf(“Enter a value\n”);
scanf(“%d”,&n);
if((n &(n-1))==0)
printf(“no. is power of 2\n”);
else
printf(“no. is not power of 2\n”);
return 0;
}

#include<stdio.h>
int main()
{
int n,r=0,num;
printf(“Enter a number:\n”);
scanf(“%d”,&n);
num=n;
while(n!=0)
{
r=r*10;
r=r+n%10;
n=n/10;
}
printf(“Reverse number is %d\n”,r);
if(num==r)
printf(“Palindrome number\n”);
else
printf(“Not a Palindrome\n”);
return 0;
}

#include<stdio.h>
int main()
{
int i,j,k,n,space,temp;
printf(“enter value of n\n”);
scanf(“%d”,&n);
temp=n;
for(i=1;i<=n;i++)
{
for(j=i;j<n;j++)
{
printf(” “);
}
for(k=1;k<(2*i);k++)
{
printf(“*”);
}
printf(“\n”);
}
temp=1;
for(i=n-1;i>=1;i–)
{
for(j=1;j<=temp;j++)
{
printf(” “);
}
temp++;
for(k=1;k<(i*2);k++)
{
printf(“*”);
}
printf(“\n”);
}
}