C/C++ Tokens – GeeksforGeeks

In C/C++ tokens are the smallest element of a program. Tokens can be split into the following

1. Keywords
Predefined tokens in a programming language having fixed meaning.
e.g:- switch, case, int,return etc.

C++ has 31 additional keywords
few of the common ones used are
bool, class,static_cast,try, catch etc

2. Identifiers
Identifiers are used to name variables, labels etc. There are certain rules for the identifiers
a. They can start only with a letter or underscore(_).
b. They must contain only digits, letters and underscore.
c. They cannot contain white space.
d. maximum up to 31 characters long.
e. white space not allowed.

3. Constants
Constants refer to fixed values. e.g:- integer constants, floating point constants, character constants, octal or hexadecimal constants and string constants.
char *p=”Yogi”;
int age=43;

In the above examples “Yogi” and 43 are string and integer constants.

4. Strings
They are array of characters ended with null character(\0)

eg:- char test[20]=”Yogi”;

5. Symbols
Symbols have special meaning.
a. Brackets[]- used for array subscripts.
b. Paranthesis() – used for function calls and parameter passing.
c. Braces{} – Used for separating blocks of code. A variable defined inside the brace will have the scope within the brace.
d. comma, – separates statements and parameters.
e. asterisk * – Use to dereference a pointer.

There are other set of symbols also used and each has its own meaning.

6. Operators
Operators are symbols that are used to perform with operands to create a statement.
Based on the number of operands operator can act upon, operators can be classified as

a. Unary operator – i++, i–;
b. Binary operators – Arithmetic, relational, logical, assignment, conditional, bitwise
c. Ternary operator – ?:

Source: C/C++ Tokens – GeeksforGeeks

Line Splicing 

In C and C++ you can join the next line to the current line using Line spicing. Requires ‘\’ to be added at the end of the line.


Example code to demostrate line splicing.

[yogi@192 devel]$ cat linesplice.c
#include <stdio.h>

int main(int argc, char *argv[])
// test line splice

return 0;
[yogi@192 devel]$ gcc -o linesplice linesplice.c
[yogi@192 devel]$ ./linesplice
[yogi@192 devel]$ vi linesplice.c
[yogi@192 devel]$ cat linesplice.c
#include <stdio.h>

int main(int argc, char *argv[])
// test line splice \

return 0;
[yogi@192 devel]$ gcc -o linesplice linesplice.c
[yogi@192 devel]$ ./linesplice
[yogi@192 devel]$ vi linesplice.c
[yogi@192 devel]$ gcc -o linesplice linesplice.c
[yogi@192 devel]$ cat linesplice.c
#include <stdio.h>

int main(int argc, char *argv[])
// test line splice \
printf(“Hello\n”); \

return 0;
[yogi@192 devel]$ ./linesplice
[yogi@192 devel]$


Source: Line Splicing in C/C++ – GeeksforGeeks

Signals in C

Signals are one of the IPC mechanism used to communicate between 2 processes or between OS and a process. If a program hits a serious error, the OS may raise the respective signal for the process to be terminated after a core dump file is generated.


The common error signals are

SIGFPE:- some arithhmetic errors or floating point errors like divide by zero.

SIGILL:- Illegal instruction. Usually happens when an unknown instruction or an elevated privilege instructions is run. Common scenario is object file is corrupted or a stack overflow happens.

SIGSEGV:- Happens when a process access the physical memory which it doesn’t have access to. Common scenario is accessing a NULL pointer, stack or heap corruption.

SIGBUS:- Bus error. Invalid memory is accessed. In case of bus error the memory accessed itself is invalid. One scenario is issues with HW where the memory mapped address access fails to read the data from the hardware.

SIGABRT:- The signal is raised when the program calls abort() api. assert() in C++ uses internally abort().

SIGSYS:- The signal is raised when a process passes invalid arguments to a system call.

SIGTRAP:- This signal is raised in conjunction when a debugger is attached to the process. When the code hits a debug point the SIGTRAP can be raised.

Source: Program error signals – GeeksforGeeks

To be continued…

Compiling a C program. Various stages involved.

C is a high level programming language which converts a C code to executable which can be run in the respective target OS environment.

Usually a C program code is written with an extension .c. An IDE or editor is used to add code to the programs. Once done a compiler is used to compile the program code to executable. Some IDE provide built-in compiler while others provide option to select the compiler and debugger.

Steps involved in creating and executable.

  1. Add code using an editor.
  2. Compile using a compiler to create the executable binary. Linux uses gcc and windows uses Microsoft visual studio integrated compiler cl. There are other compilers available in multiple OS environments like borland C compiler.
  3. Fix any coding issues and move to step 1. Otherwise go to step 4.
  4. Run the final executable.
  5. Fix and run time found issues and move to step 1. Otherwise go to step 6.
  6. Final program ready.

The compilation phase can be split into 4.

  1. Pre-processing phase.
  2. Compilation phase.
  3. Assembly phase.
  4. Linking phase.

Pre-processing phase includes the following sub phases. This will generate filename.s file(in linux) which does have the below steps completed.

  • Removal of Comments.
  • Expansion of Macros.
  • Expansion of the included files.
  • Conditional compilation.

Compilation phase takes the pre-processed file and convert to assembly instructions. In case of linux it will generate the GNU assembly code.

Assembly phase include converting the assembly code into object code. filename.s will be converted to filename.o in Linux. This file will contain machine level instruction.

Linking phase is the final phase where the static libraries are linked as well as symbol lookup done for the dynamic libraries which are going to be loaded as part of run time load. The linker also add the extra code to call the main function as well as handling the exit from the program.

Note:- gcc uses dynamic linking for the standard C library functions like printf.


Source: Compiling a C program:- Behind the Scenes – GeeksforGeeks

Use -save-temps gcc option to generate the intermediate files.
gcc -Wall -save-temps -o sample -L .  -I . application.c -lcall_lib

yogi@192 0830]$ ls application.*
application.c application.i application.o application.s

application.c – program code.

application.i – preprocessed file.

application.s – assembly file

application.o – object file with machine instructions.

sample – Final program.

Static and Dynamic Libraries 

One of the task of the compiler is to invoke the linker to link the libraries to add the code to the main executable program. There are 2 types of libraries.

Statically linked libraries vs Dynamically linked libraries.

Statically linked libraries can be created as .a(linux) and (.lib) windows. The code and data will be statically shared to the application.

In case of dynamically linked libraries , the object file created will have .so(linux) and .dll(windows) extension.

These are the parameters you can consider to chose whether you want statically linked library or dynamically linked library.

  1. Size – Dynamically linked library will share the code. Hence collectively the size of all the executable using the library will be less compared to statically linked.
  2. Memory foot print – Same copy of code can be resident in the memory at the same time when the applications using the same static library is running. This can be optimized if you use dynamically linked library.
  3. Performance and loading time – Statically linked libraries will take less time to load compared to dynamically linked library since it doesn’t need to load the library at the runtime or load time and resolve the symbols.
  4. Version dependency – Since the code is compiled into the binary there won’t be any run time version dependency for the applications that statically link libraries.
  5. Recompilation requirement – DLL doesn’t need any recompilation for the applications if the re is a bug fix. Only the DLL needs to be recompiled.

Note: Any time you use to implement DLL suggest to use some capability or versions, so that your application can avoid run time symbol check to verify the API or feature is supported or not.

Source: Static and Dynamic Libraries | Set 1 – GeeksforGeeks


int add(int a, int b);

#include "call_lib.h"

int add(int a, int b)
	int ret = 0;

	ret = a + b;

	return ret;


#include <stdio.h>
#include "call_lib.h"

#define FIRST_NUM 2
#define SECOND_NUM 3

int main(int argc, char *argv[])
	printf("output is %d\n", add(FIRST_NUM , SECOND_NUM));

	return 0;

to build the library
ar rcs libcall_lib.a call_lib.o

To build the final library
gcc -o sample -L . -I . application.c -lcall_lib

Amazon.in: OPPO Smart Watch 41MM WiFi (Black) Review and recommendation

Key features

  • 41MM (1.6-inch) Rigid AMOLED display with 320×360 screen resolution.
  • 300mAh lithium Polymer Battery | 14 days of Battery Life | VOOC Flash Charging.
  • Built in GPS | Google Assistant |Heart rate monitoring |Sleep monitoring |Get Up Reminder|Guided breathing exercises

Its almost 2 weeks I purchased OPPO 41mm smart watch. I was fond on the look and feel of the watch and the cost at which a smart phone with Apple equivalent design and features offered. Hence gone for the same. After unboxing I felt I was cheated due to the battery life it showed as 2 hours to drain for a fully charged to empty by the app. Right now I will say you just need to erase all your assumptions on battery life expectations and adjust to it. These are the things I did to save battery life.

  1. Reset to defaults.
  2. Upgrade the software to latest. (After this the battery life increased from 2 to 12 hrs)
  3. Disabled the hand gestures.(12 hrs to 18 hrs)
  4. Don’t install any extra app other than compass and GPS navigator. Google music its up to your style. Should not expect much battery life with those applications.
  5. Set the world clock as watch face. Instead of other clocks I set alarm, steps, heart points and distance covered.
  6. Keep unwanted sensors off.
  7. Wifi Off. I wanted wifi so I didn’t, but it seems like it will save lot of battery life.
  8. Keep location of – Saves a lot of battery.
  9. Modify the notifications – Select only those apps which are genuinely use.

I liked always on feature. But heard with 41mm(300mAh) we can achieve 24+ hours battery life. When it comes very less battery the watch will enable automatically the battery saver feature, which I didn’t test to see how long it hold, but found to be a useful feature which will make sure your watch will be up till you find a charging point in a remote village. One thing I felt not to return the watch is its fast charging, 30 minutes to charge from 40% to 100%. So I never felt the battery draining a problem. The combination of fast charging and battery saver saved Oppo. I recommend go ahead and buy it. If you change your life style of charging and expectations, this is a good addition.


  • You can attend the call via watch, speaker is pretty good.
  • Square in design so maximum use of the screen.
    No issues using in sunlight.
  • Impressive response with user interface and touch.
  • Amazing Display.
  • Very comfortable on the wrist.
  • Good Fitness tracking.
  • Power saving mode helps to keep the watch for long time.
  • Fast charging 40-100% in less than 30 minutes.


  • Battery life ( you cannot use all the smart watch features and expect it to have battery life).
  • Even though blue tooth is used to sync the watch and mobile. Apps like Weather are not synced with blue tooth and requires wifi.

Quick summary on shared libraries

Shared libraries are reusable libraries which can be used by multiple applications at the same time. The advantages of shared libraries are

  1. Can be loaded at application start or on demand at run time.
  2. Can be upgraded separately and reloaded.

Only disadvantage compared to statically linked library is, there is an overhead for loading the library and resolving the symbols at run time.

In case of loading during application start, the loader will load the library into process virtual address space and resolve before the application is launched.

In case of loading dynamically the same can be achieved with the respective system library apis when in need..

Windows it will be a dynamically linked library(*.dll) and uses the same PE format as windows executable.

Linux it will be a shared object(*.so) and uses the ELF format as a normal linux executable.

In linux use the -shared gcc option to create a shared object. if your library name provided is abc.so, the linux linker will create it as libabc.so.

While statically linking, the option -labc should be provided to link with the same.

If you are using dynamic linking, you need to use dlopen(3) ,dlsym(3) and dlclose(3) apis to load, access the symbol and unload the library.

Sample codes


#include <stdio.h>
#include “call_lib.h”

int main(int argc, char * argv[])
printf(“In application\n”);

return 0;


int call_lib(int num);


#include <stdio.h>
#include “call_lib.h”

int call_lib(int num)
printf(“passed value is %d\n”, num);

return 0;

To compile the library code
gcc -shared -fPIC -o library.so library.c

To compile the application code
gcc -o sample -L /home/yogi/libs -lrary application.c

Running the executable

set first the library path

$export LD_LIBRARY_PATH=/home/yogi/libs:$LD_LIBRARY_PATH
$ ./sample
In application
passed value is 3

Source: Working with Shared Libraries | Set 1 – GeeksforGeeks

Page 3 of 187
1 2 3 4 5 187