C, C++, and Assembly Language Programs & Tutorials

Electronic Polling System in C++ Language

noreply@blogger.com (Maaz Ali) — Thu, 20 Oct 2016 09:01:00 +0000

Problem

Implement (a part of) electronic Pakistani election Scenario where following political parties are participating in election: PPP, PML and PTI. Create a class PollingStation where it stores the vote’s count, against each party, cast by the Pakistani legal registered voters. Your program must query the voter for its ID card number before he/she cast the vote and check it against voter list. (Suppose voter list is already with you). If voter is not found in the voter’s list, your program throws the exception IllegalVoter() and discard that voter. The Application again starts working in normal state and terminates only when user wants to quit it. At the end of the day (or whenever user wants) it generates report about the vote count against each party including header that contains date, day and location.

Code

// Poling station.cpp : Defines the entry point for the console application.
//
//HEADER FILES
#include "stdafx.h" //ESSENTIAL TO WORK ON VISUAL STUDIO
#include<fstream> //FOR FILE
#include<conio.h> //FOR GETCH FUNCTION
#include<string> //fOR STRINGS USAGE
#include<iostream> //FOR COUT AND CIN
using namespace std;
//CLASS BEGINS
class PollingStation
{
private: //VARIABLES DECLARED PRIVATLY, ONLY ACCESSABLE IN THIS CLASS
int votes_count_ppp;
int votes_count_pml;
int votes_count_pti;
int total_votes,hr,mn,sc,flag,choice,offset;
string line,day,location;

public: //EXCEPTION CLASS
class IllegalVoter
{ };
//CONSTRUCTOR OF POLLING STATION CLASS
PollingStation(): votes_count_ppp(0), votes_count_pml(0), votes_count_pti(0),total_votes(0),
hr(0),mn(0),sc(0),flag(0),line(""),choice(0)
{ }
//DESTRUCTOR OF POLLING STATION CLASS
~PollingStation()
{
cout<<"polling Station Destructor";
}
//GETING THE DATA FROM USER(DAY,DTAE & LOCATION)
void start()
{ //GET DAY
system("cls");
cout<<"Enter Day: ";
cin>>day;
//GET LOCATION
system("cls");
cout<<"\nEnter Location: ";
cin>>location;
//GET TIME
system("cls");
cout<<"\nEnter time: "<<endl;
cout<<"Enter Hour: ";
cin>>hr;
cout<<"Enter Minutes: ";
cin>>mn;
}
//CHECKING WHETHER THE PERSON IS ILLEGIBEL FOR VOTE
void checkdata(string search)
{
ifstream Myfile; //OPENING THE FILE FOR READING
Myfile.open ("VOTERS_LIST.txt");
{
if(Myfile.is_open())
{ //READING UNTIL END OF FILE
while(!Myfile.eof())
{
getline(Myfile,line); //CHECKIMG
if ((offset = line.find(search)) != string::npos)
{
flag = 1;
}
}
Myfile.close();
} //IF FILE IS NOT OPENED
else
cout<<"Unable to open this file."<<endl;
}
if(flag == 0) //THROWING EXCEPTION
throw IllegalVoter();
}
//PERSON WILL CAST HIS/HER VOTE
void cast_vote()
{
system("cls");
cout<<"CAST YOUR VOTE:"<<endl;
cout<<"1. PPP"<<endl;
cout<<"2. PML"<<endl;
cout<<"3. PTI"<<endl;

cout<<"\nEnter Your Choice: ";
cin>>choice;
//IF USER HAS VOTED FOR PPP
if(choice == 1)
{
votes_count_ppp++;
total_votes++;
} //IF USER HAS VOTED FOR PML
else if(choice == 2)
{
votes_count_pml++;
total_votes++;
} //IF USER HAS VOTED FOR PTI
else if (choice == 3)
{
votes_count_pti++;
total_votes++;
} //IF USER HAS ENTERED WRONG CHOICE
else
{
system("cls");
cout<<"Invalid Key."<<endl;
cout<<"Press Any Key To Continue."<<endl;
getch();
}
}
//DISPLYING RESULTS
void display()
{
system("cls");
cout<<"\n\n********************************************************************************";
cout<<"Time = "<<hr<<" : "<<mn<<"\t\t\tDay = "<<day<<"\t\tLocation = "<<location<<endl;
cout<<"\n********************************************************************************";

cout<<"Total number of votes voted for:"<<endl<<endl;
cout<<"\tPPP = "<<votes_count_ppp<<endl;
cout<<"\tPML = "<<votes_count_pml<<endl;
cout<<"\tPTI = "<<votes_count_pti<<endl<<endl;
cout<<"\tTotal = "<<total_votes<<endl;
}
};

int main()
{
PollingStation p; //OBJECT OF POLLING STATION CLASS
char another; //VARIABLES
string id;

p.start(); //CALLING THE FUNTION TO GET DATA

do{ //LOOP UNTIL USER WANTS
try{
system("cls"); //USER WILL ENTER HIS/HER ID CARD NUMBER
cout<<"Enter ID Card Number: ";
cin>>id;
p.checkdata(id); //CHECKING
p.cast_vote(); //CASTING VOTE(IF ILLEGIBLE)
}
catch(PollingStation::IllegalVoter) //IF NOT ILLEGIBLE THEN
{
cout<<"NO ENTRY WITH THIS ID"<<endl;
cout<<"Press any key to continue...";
getch();
}

system("cls"); //ASKING USER WHETHER HE/SHE WANTS TO ENTER DATA
cout<<"Enter another phone number(y/n)? ";
another = getch();
}while(another == 'Y' || another == 'y'); //LOOP TERMINATION CONDITION

ofstream file; //OPENING FILE FOR WRITTING
file.open("POLLING_RESULTS.DAT", ios::binary);
p.display(); //DISPLYING THE DATA & WRITTING TO THE FILE
file.write(reinterpret_cast<char*>(&p),sizeof(p)); //SO THAT IT COULD BE DSPLAYED ANYTIME
file.close(); //USER WANTS & THEN CLOSING THE FILE

cout<<"\nFile Written"<<endl;
cout<<"Press any key to exit"<<endl;
getch();
return 0;
}

Output

CD player simulator using c++

noreply@blogger.com (Maaz Ali) — Fri, 14 Oct 2016 06:07:00 +0000

Problem

Design a simple CD player simulator. The CD player has the following buttons: "POWER", "EJECT", "PLAY" and "STOP", and a tray where a CD is loaded. User can load a CD only if the tray is open. The tray can be opened only if the power is turned on (regard it as something like a motor-driven tray installed on a PC). If the power is turned off with the tray open, the tray will keep open and the power is turned off.
Implement the following actions of the CD player as methods of class CDPlayer.

pushPower() -- simulates pushing POWER(on/off) button.

if the power is turned off, turn on the power, and display "Power turned on."
if the power is turned on,

if playing, stop it.

turn off the power, and display "Power turned off."

pushEject() -- simulates pushing EJECT(tray open/close) button

if the power is not turned on, display "Power not turned on."
if the power is turned on,

if the tray is not open, open the tray and display "Tray opened."
if the tray is open, close the tray and display "Tray closed."

pushPlay() -- simulates pushing PLAY button

if the power is turned on,

if the media is loaded and tray is closed, begin to play and display "Now playing..."
otherwise, display "No CD loaded or tray is open."

pushStop() -- simulates pushing STOP button

if the power is turned on,

if it's playing, stop playing and display "Playing stopped."

loadUnloadMedia() -- simulates loading/unloading media to/from the tray (tray must be open when loading/unloading)

if the tray is open,

if the media is loaded, unload the media and display "Media unloaded."
if the media is not loaded, load the media and display "Media loaded."

if the tray is not open,

display "Tray is not open."

Code

#include<iostream>

#include<conio.h>

using namespace std;

class CDplayer

{

private:

int power;

int eject;

int tray;

int media;

int play;

public:

CDplayer():power(0),eject(0),tray(0),media(0),play(0)

{

}

void pushPower()

{

cout<<"\n\nNOTE: Press one(1) to turn on and zero(0) to turn off.";

cout<<"\nWant to turn on the power? ";

cin>>power;

if(power == 1)

cout<<"Power is ON.";

else if (power == 0)

cout<<"Power is OFF.";

else

cout<<"Invalid key";

cout<<"\n\nPress any key to continue.";

getch();

}

void pushEject()

{

if(power == 1)

{

if(tray == 0)

{

tray = 1;

cout<<"Tray opened.";

}

else if(tray == 1)

{

tray = 0;

cout<<"Tray closed.";

}

else if(power == 0)

cout<<"Power not turned on.";

cout<<"\n\nPress any key to continue.";

getch();

}

void pushPlay()

{

if(power == 1)

{

if(media == 1 && tray == 0)

{

play = 1;

cout<<"Now playing...";

}

else

cout<<"No CD loaded or tray is open.";

}

else if(power == 0)

cout<<"Power not turned on.";

cout<<"\n\nPress any key to continue.";

getch();

}

void pushStop()

{

if(power == 1)

{

if(play == 1)

{

play = 0;

cout<<"Playing stopped.";

}

cout<<"\n\nPress any key to continue.";

getch();

}

void loadUnloadMedia()

{

if(tray == 1)

{

if(media == 1)

{

media = 0;

cout<<"Media unloaded.";

}

else if(media == 0)

{

media = 1;

cout<<"Media loaded.";

}

else if(tray == 0)

cout<<"Tray is not open.";

cout<<"\n\nPress any key to continue.";

getch();

}

};

int main()

{

CDplayer c1;

int s;

while(1)

{

system ("cls");

cout<<"\n\nPlease, Press one of the following buttons: ";

cout<<"\n1. POWER(on/off)";

cout<<"\n2. EJECT(tray open/close)";

cout<<"\n3. PLAY";

cout<<"\n4. STOP";

cout<<"\n5. Load/Unload media to/from the tray(tray will be opened)";

cout<<"\n6. Close CDplayer";

cout<<"\n\nEnter your choice: ";

cin>>s;

switch(s)

{

case 1:

system ("cls");

c1.pushPower();

break;

case 2:

system ("cls");

c1.pushEject();

break;

case 3:

system ("cls");

c1.pushPlay();

break;

case 4:

system ("cls");

c1.pushStop();

break;

case 5:

system ("cls");

c1.loadUnloadMedia();

break;

case 6:

exit(0);

}

getch();

return 0;

}

Output

CD player simulator using c++

Write a simulator for the assembly language ISA design in C language.

noreply@blogger.com (Maaz Ali) — Wed, 05 Oct 2016 09:46:00 +0000

Code

#include "stdafx.h"

#include <stdio.h>

#include <conio.h>

#include <stdlib.h>

//initializing the memory and registers

void initialization(int a[]){

for(int i=0;i<16;i++)

a[i] = (i+1)*10;

}

//number of instructions

int input_instructions(){

int x;

printf("Enter the number of instructions you want to perform: ");

scanf_s ("%d",&x);

return x;

}

//loading the register from memory

void load(int row, int inst[][3]){

inst[row][0] = 1;

printf("Enter the number of register ranging from 1 to 16: ");

scanf_s("%d",&inst[row][1]);

printf("Enter the number of memory from which you want to load ranging from 1 to 16: ");

scanf_s("%d",&inst[row][2]);

}

//adding the two registers

void add(int row,int inst[][3]){

inst[row][0] = 5;

printf("Enter the destination register number: ");

scanf_s("%d",&inst[row][1]);

printf("Enter the source register number: ");

scanf_s("%d",&inst[row][2]);

}

//storing the value to the memory

void store(int row,int inst[][3]){

inst[row][0] = 3;

printf("Enter the register number: ");

scanf_s("%d",&inst[row][1]);

printf("Enter the memory number: ");

scanf_s("%d",&inst[row][2]);

}

//display the instruction memory

void display_pattern(int no_of_ins,int inst[][3]){

system("cls");

printf("\********************************************************************************");

printf("\n****************************** Instruction Memory ******************************");

printf("\n********************************************************************************");

for(int i=0;i<no_of_ins;i++){

printf("\n\t\t\t\t%d\t%d\t%d\n",inst[i][0],inst[i][1],inst[i][2]);

}

printf("\n\n");

for(int i=0;i<no_of_ins;i++){

if(inst[i][0] == 1){

printf("\t\t\t\tLoadR\tR%d\tM%d\n\n",inst[i][1],inst[i][2]);

}

else if(inst[i][0] == 3){

printf("\t\t\t\tStoreR\tR%d\tM%d\n\n",inst[i][1],inst[i][2]);

}

else if(inst[i][0] == 5){

printf("\t\t\t\tAddR\tR%d\tR%d\n\n",inst[i][1],inst[i][2]);

}

printf("\n\n\n\nPress any key to continue...");

_getch();

}

//display registers and memorys

void display_reg_mem(int reg[],int mem[]){

printf("\n\nRegister: ");

for(int j=0;j<16;j++)

printf("%d ",reg[j]);

printf("\n-----------------------------------------------------------------------------");

printf("\nMemory: ");

for(int j=0;j<16;j++)

printf("%d ",mem[j]);

}

//ISA simulator

void display_cycles(int no_of_inst,int inst[][3],int reg[],int mem[]){

for(int i=0;i<no_of_inst;i++){

system("cls");

printf("********************************************************************************");

printf("\n****************************** ISA Simulator ***********************************");

printf("\n********************************************************************************");

printf("\n\n\n\n\n******************************* Instruction # %d ********************************",(i+1));

printf("\n\n\n\n\nFetch Instruction:\t %d\t%d\t%d\n",inst[i][0],inst[i][1],inst[i][2]);

display_reg_mem(reg,mem);

if(inst[i][0] == 1){

printf("\n\n\n\n\nDecode Instruction:\t LoadR\tRegister%d\tMemory%d\n",inst[i][1],inst[i][2]);

display_reg_mem(reg,mem);

printf("\n\n\n\n\nExecute Instruction:\t Register updated Succesfully\n");

reg[(inst[i][1]-1)] = mem[(inst[i][2]-1)];

display_reg_mem(reg,mem);

}

if(inst[i][0] == 5){

printf("\n\n\n\n\nDecode Instruction:\t AddR\tRegister%d\tRegister%d\n",inst[i][1],inst[i][2]);

display_reg_mem(reg,mem);

printf("\n\n\n\n\nExecute Instruction:\t Register updated Succesfully\n");

reg[(inst[i][1]-1)] = reg[(inst[i][1]-1)] + reg[(inst[i][2]-1)];

display_reg_mem(reg,mem);

}

if(inst[i][0] == 3){

printf("\n\n\n\n\nDecode Instruction:\t StoreR\tRegister%d\tMemory%d\n",inst[i][1],inst[i][2]);

display_reg_mem(reg,mem);

printf("\n\n\n\n\nExecute Instruction:\t Memory updated Succesfully\n");

mem[(inst[i][2]-1)] = reg[(inst[i][1]-1)];

display_reg_mem(reg,mem);

}

printf("\n\n\n\nPress any key to continue...");

_getch();

}

int main(){

system("color 3f");

int choice,count=0,row=0,lines;

int registers[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

int memorys[16];

initialization(memorys);

lines = input_instructions();

int instructions[100][3];

for(int i=0;i<lines;i++){

system("cls");

printf("Select one of the following instruction type from the following:\n");

printf("\t1. Load \n");

printf("\t2. Add \n");

printf("\t3. Store \n");

printf("\t4. Exit \n\n");

printf("Enter your choice: ");

choice = _getche();

switch (choice)

{

case '1': //load

system("cls");

load(row,instructions);

row++;

break;

case '2': //add

system("cls");

add(row,instructions);

row++;

break;

case '3': //store

system("cls");

store(row,instructions);

row++;

break;

case '4': //exit

exit(0);

default:

system("cls");

printf("\n\nInvalid input! Press any key to continue.");

break;

}

system("cls");

display_pattern(lines,instructions);

system("cls");

display_cycles(lines,instructions,registers,memorys);

exit(0);

return 0;

}

Program Output - Screen Shots

Screen 01

In the above screen 01 user must enter the instructions to run the program. For example we want to run our code for 4 instructions, so we will write 4 and hit enter.

The following screen will be displayed.

Screen 02

There are 4 options 1^st option is used to load the register from memory, 2^nd option add the two registers, 3^rd option stores the value from register to the memory, and the 4^th option is used to quit the program. For example, we press 1 and hit enter.

The following screen will be displayed.

Screen 03

User will be asked to enter the register number and the memory number. We will enter 2 for register and 7 for memory.

Screen 04

Same procedure will be followed again i.e. steps for screen 02.

Screen 05

This time we will enter 3 for register and 6 for the memory.

After you have entered the value in the memory hit enter… the program will show you the following screen.

Screen 06

This time press 2 and hit enter.

Screen 07

It will ask you to enter two register numbers one by one. The 1^st register is the destination and the 2^nd register is the source i.e. after the value is entered, the value of the destination will be overwritten with the sum of the two registers in the add instruction. Here we have entered 2 and 3 register numbers where 2^nd register will be overwritten after the execution with the sum of the register no 2 and 3.

Screen 08

After you enter the register number, the above screen will be displayed again, press 3 this time and hit enter.

Screen 09

The above screen will be shown asking the user to enter the register number from which he/she wants to store data and then the program will ask for the memory number. For instance, we enter 2 for register and 6 for memory and press enter.

Screen 10

As, we have entered 4 instructions (2 load, 1 add and 1 store). The above screen will be displayed asking the user to press any key to continue if he/she have viewed the instructions. After we hit enter the following screen will be displayed.

Screen 11

The program will show the user ISA simulator with the 1^st instruction. As, the 1^st instruction was to load the register from the memory i.e. 1 2 7. After the execution the register’s value will be updated and as we can see in our example it has updated the 2^nd register with the value 70 taken from the memory’s 7^th location.

Let’s have a closer look at the above screen 11, we can see there are three steps involved are involved for each cycle (instruction).

1^st step - the fetch instruction

It fetches the instruction from the memory and loads it into the processor.

2^nd step - the decode instruction

After the 1^st step the 2^nd step takes place: It decodes the instruction after it has been fetched, so that the computer can perform its specific operation.

3^rd step - execute instruction

It executes the instruction and updates the values according to the instruction, for instance in this instruction it will update the value of the 2^nd register.

Screen 12

Similarly 2^nd instruction will be displayed. It will update the 3^rd register with the value 60.

Screen 13

The third instruction was to add the 2^nd and 3^rd register and answer have to be stored in the 2^nd register as it was the destination register. Hence, we can see the value of the 2^nd register have been updated to 130 from 70.

Screen 14

The last and 4^th instruction that we entered was to store the result of add instruction from the 3^rd instruction to the memory. In the above example we have stored the value of the 2^nd register in the 6^th memory location.

The user will be asked to press any key to continue and the program will be terminated as there were no more instructions to show.

Load Add and Store Instructions in Assembly Language | Instruction set Architecture

noreply@blogger.com (Maaz Ali) — Fri, 30 Sep 2016 07:42:00 +0000

We already know (from the previous lectures) how an instruction is formed and what the basic structure of an instruction is. Let’s go through few examples of it.

Instruction Set

An instruction set is composed of two parts:

Opcode
Operand (s)

Opcode

Opcode defines the number of operation supported by this instruction format and used for indexing that operation. For example: 0000 is the opcode for LOADI operation.

Operand (s)

Operands can be a register address, memory address, and immediate value.
In our ISA design, the length of instruction is 16 bits. Such that: 4 bits for opcode, and 12 bits for operand(s).

Opcode (4-bits)

Operands (12-bits)

Operations

For this tutorial we will be focusing on the three basic operations, i.e. how to load, add, and store data in assembly language. Following are the few operations along with their opcodes:

OPCODE	Operation
0000	LOADI
0001	LOADM
0010	STOREI
0011	STORER
0100	ADDI
0101	ADDR
0110	SUBI
…	…
…	…
1111	…

In above operations I is for immediate, M is for memory, and R is for register. Let’s look at the registers and memory first before proceeding to the operations.

Registers

There are 16 registers hence 4 bits are required to address them. Registers are named as R0 to R15.

Register Address	Register
0000	R0
0001	R1
0010	R2
0011	R3
0100	R4
0101	R5
0110	R6
…	…
…	…
1111	R15

Memory

There are 28 memory locations where data may reside. Hence 8 bits are required to address them. Memory locations are named as M0 to M255.

Memory Address	Memory
00000000	M0
00000001	M1
00000010	M2
00000011	M3
00000100	M4
00000101	M5
00000110	M6
…	…
…	…
11111111	M255

LOADM Instruction

Definition

It loads an operand value from a memory location to a register.

Bit allocation

LOADM

MEMORY ADDRESS

4 bits for Opcode
4 bits for Register address
8 bits for Memory address

Working

Consider an example:
Assembly Code: LOADM R4 M6
Machine Code: 0001010000000110

LOADM

In the above instruction operand value i.e. 87 from a memory (M6) copied to a register (R4).

STORER Instruction

Define:

It stores an operand value from a register to a Memory location.

Bit allocation:

STORER

MEMORY ADDRESS

4 bits for Opcode
4 bits for Register address
8 bits for Memory address

Working

Consider an example:
Assembly Code: STORER R4 M6
Machine Code: 0011010000000110

STORER

In the above instruction operand value (67) is stored from a register (R4) to a Memory (M6) location.

ADDR Instruction

Define:

It adds register values and keeps the result in the destination register.

Bit allocation:

ADDR

Reg. Address

4 bits for Opcode
4 bits for each Register address

4 bits for Source
4 bits for Destination

Working

Consider an example:
Assembly Code: ADDR R2 R1
Machine Code: 0101 0010 0001 0000

ADDR

Sample Example

LOADM      R1       M25     ; load from memory M25 and store the value in register R1
LOADM      R2      M69      ; load from memory M69 and store the value in register R2
ADDR         R2       R1          ; add values of register R1 and R2
STORER      R2       M2        ; store the value of register R2 to memory M2

Execution of a Assembly Language Instruction

Our CPU will use three stages for executing a single assembly language instruction. These are:

Fetch:

CPU fetches the instruction from Instruction memory (Maintained in a 2D Array).
Decode:

Operation and operands are determined.
Execute:

Operation is performed on the operands.

To see these steps in practical follow the below program written in c language.

Program

A simulator for the discussed ISA design is written in C language. Click on the below link:

Write A Simulator For The Assembly Language ISA Design In C Language.

Debugging Assembly Language | Introduction to

noreply@blogger.com (Maaz Ali) — Tue, 27 Sep 2016 07:12:00 +0000

If you are interested in writing code on command prompt and like writing code in command prompt than this tutorial is for you. Debugging assembly language is easy. Following picture shows an example of it:

What is Debugging?

Debug is a dos program which allows programmers to see execution of the program closely in depth. It is used to:

Change and see memory contents
Enter and execute programs
Hold the program at a specific instruction to check the data values or change them.

Debugging commands Assembly language

Below are the command examples of debugging an assembly language code:

Debug: Enter a program

Q: Quit the program.

R: See register contents/values.

R<register>: see particular register content/value also change it.

Practice Program: See AX register contents and change the value to 2, 34, 543, and GE.

A: this command assembles the program. You can enter assembly instructions into the memory.

A <starting address>: starting address can be an offset of code segment or you can also specify segment register.

Example – your turn: a 100 or a cs: 100 are the same, type a 100 and debug it.

U: a command that un-assembles the program. You can see machine code of your program by using this command. You can also specify the starting and ending addresses of memory section you want to see the code of, U<starting address> (space) <ending address>.

G: G is a go command that allows the program to run until it reaches the breakpoint. At the end register contents are displayed to the programmer.

F: F command is used to fill into the memory. Format of this command is: F<starting address> <ending address> <data>.

E: E command is used to enter any data or change into the memory. For example: E 200 ‘HELLO WORLD’.

D: D command is used to see the register contents. You can also use this command to fill segment providing offset. For example: F 10 10F FF, fills 16bytes with FF.

Assembly Language Instructions With Examples | Introduction

noreply@blogger.com (Maaz Ali) — Tue, 20 Sep 2016 07:58:00 +0000

Instructions

Instructions are statements that execute when we assemble the program. The instructions (written in assembly language) are translated into machine language bytes, as we have already discussed in the lecture 02. These machine language instructions/bytes are then executed by the CPU.

Example instruction: mov ax, bx

An assembly instruction has 4 basic parts:

Label (optional)
Mnemonic (required)
Operand (depends on the instruction)
Comment (optional)

Syntax of assembly language instruction is as follows:

[label:] mnemonic [operands] [;comment]

Note: We will be using Intel IA-32 for this tutorial and onwards.

Labels

There are two types of labels:

Data Labels
Code Labels

Data Label

Data labels are just like variables in any other language. For example, C language instruction: int myVar 10; we know that myVar is a variable name i.e. data label of int type containing value 10. Similarly, in assembly language we use data labels as variables which hold value (s) for us. For example, count is a variable in the following instruction:

count DWORD 100

Data labels are declared in data segment of the code.

Code Label

Code labels are just the names which are used by other instructions to jump from particular position to that position where data label is located. It must end with a semicolon ( : ). Code labels are declared in code segment. For example:

target: mov ax, bx ... jmp target

target is the data label, which is called by the jmp instruction.

Use: code labels are used as targets for jumping while using loops.

Mnemonics

A small word that acts as an identifier for the instruction. The mnemonics are written in code segment. In following examples mov, sub, add, jmp, call, and mul are the mnemonics:

mov Move/assign one value to another (label)
sub Subtract one value from another
add Adds two values
jmp Jump to a specific location
call Call a procedure/module
mul Multiply two values

Operands

Operand is the remaining part of the instruction. There can be 0 to 3 operands. Where each operand is either a memory operand, a register, an input/output port, or a constant expression.

Following are the operand types:

constant expression
constant
memory (data label)
register

Examples

0 operands
stc ; set Carry flag
1 operand
inc myByte ; memory
inc eax ; register
2 operands
sub myByte,25 ; memory, constant
add ebx,ecx ; register, register
add eax,36 * 25 ; register, constant-expression

Comments

You should have used comments in your programs before. As you know there are two types of comments: 1. Single-line and 2. Multi-line comments. In assembly single-line comments begin with ; (semicolon) whereas, multi-line comments begin with a comment directive and symbol/character selected by the programmer itself and also end with the same symbol/character.

Why you should use comments in your programs?

explains the program's purpose
tricky coding techniques
revision information
by whom and when it was written
application-specific explanations

Assembly Language Fundamentals

noreply@blogger.com (Maaz Ali) — Mon, 19 Sep 2016 08:08:00 +0000

We need to know few basics of assembly language before we start writing programs in assembly language. The assembly programs run in little memory, consisted of primarily simple operations.

Basic Elements in Assembly Language

Now, let’s discuss the basic elements and syntax of the assembly language, which will help you in writing your first assembly program.

Integer constants

The integer constants consist of leading sign (optional), digits (one or more), and suffix character (optional), the suffix character is also known as radix. The general syntax of an integer constant is:
[+/-] digits [radix]

Sign can be negative or positive.
Digits can be decimal, binary, octal or hexadecimal digits.
Radixcan be d for decimal, b for binary, o/q for octal and h for hexadecimal.

If you do not provide any radix, the number will be considered decimal and if you do not specify any sign, the number will be considered positive by the assembler. Following are the few examples:

Integer Constant	Numeric System
26	Decimal
42o	Octal
26d	Decimal
1Ah	Hexadecimal
11010011b	Binary
0A3h	Hexadecimal
42q	Octal

Table 3.1 Integer Constants

Integer Expressions

Combining arithmetic operators (+,-, etc.) and integer values (0, 1, 2…) gives an integer expression, which is also known as a mathematical expression. The integer can be stored in 32 bits (0-FFFFFFFFh). Following are the operator’s w.r.t. their precedence levels:

Operator	Name	Precedence Level
( )	Parentheses	1
+, -	Unary plus, minus	2
*, /	Multiply, Divide	3
MOD	Modulus	3
+, -	Add, Subtract	4

Examples:

Expression	Value
16/5	3
- (3 + 4) * (6 - 1)	-35
- 3 + 4 * 6 - 1	20
25 mod 3	1

Character constants

Declare the character constants with single or double quotes. Each character occupies 1 byte in the memory.
Examples: ‘A’ or “A”, etc.

String constants

Declare the string constants with single or double quotes. Each character occupies one character, hence the number of characters a string has, is the size of the string.
Examples: ‘Hello World’ or “Hello World”, etc.
The size of the hello world string is 11.

Reserved words

You cannot use few words, known as keywords, when you are programming in any language. These words have special meaning. In assembly language these words are:

Mnemonics
Directives
Type attributes
Operators
Predefined symbols

Note: mnemonics and directives are discussed below.

Identifiers

You (programmer) can make use of your own words while writing programs called identifier. The identifiers might be:

variable
constant
procedure
code label

There are rules that must be followed by an identifier. An identifier:

Should be 1 to 247 characters long.
Is not case sensitive.
First character must be a letter (A...Z, a...z), underscore (_), @, ?, or $.
Subsequent characters may also be digits.
Cannot be the same as an assembler reserved word.

Directives

The commands that are recognized and acted upon by the assembler, known as directives. Directives are not same as instructions, for example: the DWORD directive tells the assembler to reserve space in the memory for a double word variable. But the MOV instruction, on the other hand, executes at runtime, copying the contents of variable (myVar) to the register (EAX) as shown below:
myVar DWORD 26 ; DWORD directive
mov eax, myVar ; MOV instruction

In next tutorial, we will talk about the instruction set of assembly language.

Configure Microsoft Visual Studio for Assembly Language | How to

noreply@blogger.com (Maaz Ali) — Sat, 10 Sep 2016 06:40:00 +0000

I know you are itching to start writing programs in assembly language, but before we start our fantastic journey of learning how to code in assembly language, there are certain tools that you should have:

Assembly Editor
Debugging Tool

I personally would suggest Microsoft visual studio (latest version).
Note: For this tutorial we will be using MS-Visual Studio. To download MS-Visual Studio to your computer, visit the following link:
http://www.visualstudio.com/downloads/download-visual-studio-vs
If you have any troubles installing MS-Visual Studio, visit the following link:
http://msdn.microsoft.com/en-us/library/e2h7fzkw.aspx
Now, you have installed the tools required to get going, you should configure it for the assembly language.

Configuration of MS-Visual Studio for MASM

Follow the following steps to configure Microsoft visual studio for assembly language:

Open the Microsoft visual studio from your desktop, which you have installed earlier.
Go to the TOOLS (located at the toolbar) and click on the CUSTOMIZE option. Following window will appear on your screen.

Click on the Commands tab and then click on the Add Command. You should see the following screen on your monitor/lid.

Click on the debug option and then select Start/Continue. And click OK.
Now again click on the TOOLS button, and then click on the Options button. New window will appear on your screen as shown in the following figure 3.3.

Double click on the Text Editor option, and then from the pull-down menu select All Languages and then click on Tabs.
Enter 5 in the text field present in front of the Tab Size and enter 5 in the text field in front of the Indent Size, as shown in the above figure 3.3, and press OK.

Congratulations, now we are ready to write and execute programs in assembly language.

Let’s Run A Program:

Go to the following link to download the zip file. Which will help us later in writing code.

For MS-Visual Studio 2010

http://kipirvine.com/asm/examples/IrvineExamplesVS2010a.zip

For MS-Visual Studio 2012

http://kipirvine.com/asm/examples/IrvineExamplesVS2012.zip

For any other version of MS-Visual Studio

http://kipirvine.com/asm/

Make a new folder in C drive and rename it to Irvine.
Now copy the downloaded zip file and extract it into the Irvine folder, you should see the following files (fig 3. 4) on your monitor/lid.

Note:

Open MS-Visual Studio and click on the File button. Go to Open and from the pull down menu click on the Project/Solution. A new window will appear on the screen.
From the new window:

Open C drive.
Open Irvine folder
Open Examples folder.
Open ch03 folder.
Open Project folder.
Open Project.sln file.

You should see the following screen on your window. If you don’t see the code on your screen, double click on the AddSum.asm from the solution explorer.

Press ctrl+F5 and you should see the following console window on your screen. Which shows the output of the program written in addsum.asm file.

Advantages and Disadvantages of Assembly Language | Virtual Machines and Machine Levels

noreply@blogger.com (Maaz Ali) — Fri, 09 Sep 2016 06:57:00 +0000

Advantages and Disadvantages of Assembly Language

Let’s discuss few advantages and disadvantages of a level 3 i.e. assembly language.

Advantages of Assembly Language

Programs written in machine language are replaceable by mnemonics which are easier to remember.
Memory Efficient.
It is not required to keep track of memory locations.
Faster in speed.
Easy to make insertions and deletions.
Hardware Oriented.
Requires fewer instructions to accomplish the same result.

Disadvantages of Assembly Language

Long programs written in such languages cannot be executed on small sized computers.
It takes lot of time to code or write the program, as it is more complex in nature.
Difficult to remember the syntax.
Lack of portability of program between computers of different makes.
No SDKs (System Development Kit).

Concept of Virtual Machines

Virtual machines involves two concepts:

Virtual Machines
Machine Levels

Virtual Machines

We know that each computer has its own native machine language that effects the hardware of the computer directly, generally known as language L0. It is difficult to write programs in machine language, therefore, a new language could have been constructed, which was easy and more human friendly, called language L1. Following are the two ways to achieve this:

Interpretation
Translation

Let’s, discuss both ideas one by one:

Interpretation

The program written in L1 is converted into machine language (L0). The relation between L1 and L0 is one-to-one i.e. every instruction of L1 is being interpreted by the L0 and then executed.

Translation

The program of language L1 is completely translated into language L0 and then executed.

Machine Levels

There are four machine levels as shown in the following figure 2.2:

High Level Language - Level 4

The programs written in high level (application oriented) languages like: C, C++, Java, etc. are compiled into assembly language.

Assembly Language - Level 3

The relation between assembly language and machine language is one-to-one i.e. every instruction mnemonic of assembly language is being interpreted by the machine language.

Machine Language - Level 2

The level 2 is also known as ISA (Instruction set Architecture) and it is executed by the level 1 i.e. Digital Logic.

Digital Logic - Level 1

The CPU (central processing unit) is being constructed from the digital logic gates, which is part of the computer hardware.

Comparison of High Level Language, Assembly Language and Machine Language

noreply@blogger.com (Maaz Ali) — Thu, 08 Sep 2016 07:13:00 +0000

Relation between Assembly Language and Machine Language

Assembly Language	Machine Language
Assembly language is a numeric language. It is only understood by the systems CPU.	All processors understand same machine language e.g. x86 processors.
It has mnemonics like add, mov, etc.	Every machine language instruction corresponds to the single assembly language instruction.

Table 1.2 relation between AL and ML

Differences between High Level languages and Assembly Language | High Level Language vs Assembly Language

Assembly language is different from higher level languages like java, C++, etc. in many ways, let’s discuss them one by one:

High level languages like java, C++, etc. have one to many relationship with machine code and assembly language. One statement of java or C++ expands into many assembly language commands.

For Example: we have following two instructions in C++ and when they are converted in assembly language, number of instructions is 5. So, there is a one to many relationship for the high level languages with the assembly language.

C++ code	Assembly code
Int varY; Int varX = (varY + 14) * 13;	mov edx, vary add edx,14 mov ecx,13 imul ecx mov varX,edx

Table 1.2 C++ and assembly language difference

Programs written using high level languages like c#, etc. have the ability to run on just any computer but the assembly language is written for that exact processor family.
High level language is converted into assembly language and then into machine code as shown below in the diagram.

Assembly language can control the machine code better as compared to high level languages.
Manipulation of bits is easier in assembly language as compared to high level languages.
Assembly language can access any memory but the high level languages can’t.
As high level languages are structures, so they are easy to maintain as compared to assembly language.
In high level languages the executable code is huge and hence it sometimes not efficient. But the assembly language is more efficient as it has smaller executable code.
The assembly language programmer must know about the hardware such as registers, etc. but the high level language programmer doesn’t need to know such kind of stuff.
In assembly language we deal with the pointers at the physical level but in the high level languages the pointers details are hidden.

Applications of Assembly Language | Advantages of Assembly Language

There are number of applications of assembly language:
Different programming languages are used to make different applications or sometimes a part of the application. There are few applications like: hardware interface, device drivers, etc. are written using assembly. But the scientific, commercial, etc. applications are written more efficiently in high level languages. Following are the various applications that are made using assembly language. Hence, it is used:

For writing business apps. Which are used at single/multiple organization platforms.
For drivers which are used in hardware devices like: VGA drivers etc. as they have to effect directly to the computer’s hardware.
In developing games played on computer systems. As, they have to utilize specific amount of memory to deal with a specific event.
Also for embedded systems.
In bios of the system for boot code.

Assembly Language favored over High Level Languages

Assembly Language is favored over a lot of applications as compared to high level languages. Following are the few examples of it:

Hardware device drivers

While writing programs for the drivers of the systems (hardware devices) assembly language is preferred as the assembly can directly access the hardware. As the programs for the drivers are short hence they are fast and effective.

Embedded Systems

Embedded system programs should be written in assembly language so that the program could run fast.

Computer Games

Games require some specific amount of memory locations and the direct access to the computer’s hardware which is provided by the assembly language but not by the high level languages.

Introduction to Assembly Language

noreply@blogger.com (Maaz Ali) — Wed, 07 Sep 2016 07:11:00 +0000

Overview

The low level computer programming language is the assembly language and it has direct access to the system’s hardware such as registers, flags, memory locations etc. That is why, you should have some knowledge about the computer hardware/architecture.

In this tutorial, we will be focusing on the assembly programming of x86 microprocessors compatible with the ‘Intel’ instruction architecture (IA-32) that runs on MS-Windows. We will also provide sample codes and execution results for an assembler in tutorial topics i.e. Microsoft Macro Assembler (MASM).

Background You Should Have

You should have knowledge about:

Any high level language (C, C++, or Java)
Digital logic design
And number representations (Binary numbers, decimal numbers, hexadecimal and their conversions).

Stuff You Need Have

You should have an editor to write Assembly Langue code. I personally will recommend ‘Microsoft Visual Studio’ (latest version). The step by step instructions are given here: How to download and configure MS Visual Studio for Assembly Language.

Execution Steps of Assembly Language

The steps that are followed by the system/assembler to create an executable file of the code is as follow:

Step 1

Text-editor is used by the programmer who produces the source file as an ASCII text file.

Step 2

Source file is then used by the assembler that produces machine language translation of a program known as object file. Other than this it produces the listing file, if any error occurs it goes back to the step1.

Step 3

The linker checks the program in the object file, that whether there is a library call or not. If present, linker provides procedure from the library and combines it to object file. This results in making the execution file.

Step 4

Finally the programs begin to execute when the loader reads the executable file into the memory and pointing the CPU to programs starting address.

Programs You Will Create

You will be able to write programs in two general classes:

Real Address Mode (16-bit)
Protected Mode (32-bit)

Real Address Mode (16-bit)

Real mode programs run in Console window of the OS (Operating System).

Protected Mode (32-bit)

Protected mode programs run in windows and hence they are easy to write and understand.

You Will Learn

In this tutorial, you will learn:

About computer architecture
About Boolean logic and its implementation
Management of memory in real and protected mode programs
Translation of high level languages like C, C++, Java, etc. to assembly languages and then to machine language.
Representation of different types of data like: integer, signed integer, real numbers, etc.
Machine level debugging of programs
Interaction of the application programs with the operating system, such as interrupt handlers, etc.
Creating assembly language programs.

C, C++, and Assembly Language Programs & Tutorials

Electronic Polling System in C++ Language

Problem

Code

Output

CD player simulator using c++

Problem

Code

Output

Write a simulator for the assembly language ISA design in C language.

Code

Program Output - Screen Shots

1st step - the fetch instruction

2nd step - the decode instruction

3rd step - execute instruction

Load Add and Store Instructions in Assembly Language | Instruction set Architecture

Instruction Set

Opcode

Operand (s)

Operations

Registers

Memory

LOADM Instruction

Definition

Bit allocation

Working

STORER Instruction

Define:

Bit allocation:

Working

ADDR Instruction

Define:

Bit allocation:

Working

Sample Example

Execution of a Assembly Language Instruction

Fetch:

Decode:

Execute:

Program

Debugging Assembly Language | Introduction to

What is Debugging?

Debugging commands Assembly language

Assembly Language Instructions With Examples | Introduction

Instructions

Labels

Data Label

Code Label

Mnemonics

Operands

Examples

Comments

Why you should use comments in your programs?

Assembly Language Fundamentals

Basic Elements in Assembly Language

Integer constants

Integer Expressions

Character constants

String constants

Reserved words

Identifiers

Directives

Configure Microsoft Visual Studio for Assembly Language | How to

Configuration of MS-Visual Studio for MASM

Let’s Run A Program:

Advantages and Disadvantages of Assembly Language | Virtual Machines and Machine Levels

Advantages and Disadvantages of Assembly Language

Advantages of Assembly Language

Disadvantages of Assembly Language

Concept of Virtual Machines

Virtual Machines

Interpretation

Translation

Machine Levels

High Level Language - Level 4

Assembly Language - Level 3

Machine Language - Level 2

Digital Logic - Level 1

Comparison of High Level Language, Assembly Language and Machine Language

Relation between Assembly Language and Machine Language

1^st step - the fetch instruction

2^nd step - the decode instruction

3^rd step - execute instruction