In this blog post, we will explore an 8086 assembly language program designed to convert a binary number into its Binary-Coded Decimal (BCD) format. This conversion is essential in applications where binary numbers need to be represented in a decimal-like format, such as digital displays or interfaces that require human-readable numbers. The following assembly program performs the conversion:
This post explores how to convert a 4-digit binary number (entered as a decimal) into its equivalent Binary Coded Decimal (BCD) form using inline assembly in a C++ program.
In this blog post, we'll explore how to convert a BCD (Binary-Coded Decimal) number into its binary equivalent using an 8086 assembly language program. The following code snippet demonstrates this process:
This post demonstrates how to convert a Binary Coded Decimal (BCD) number into its binary equivalent using inline assembly within a C++ program. The conversion is done by isolating and processing each BCD digit and calculating its decimal equivalent.
This post explores how to reverse an array of integers using inline assembly within a C++ program. The program swaps elements from the start and end of the array using low-level assembly instructions. #include<iostream.h> #include<conio.h> void main() { int nos[5], x, y; cout << "\n Enter 5 numbers:"; int i, j; for(i = 0; i < 5; i++) { cin >> nos[i]; } for(i = 0, j = 4; i < 3; i++, j--) { x = nos[i]; y = nos[j]; _asm{ mov ax, x mov bx, y mov cx, ax mov ax, bx mov bx, cx mov x, ax mov y, bx } nos[i] = x; nos[j] = y; } cout << "\n Reverse:"; for(i = 0; i < 5; i++) { cout << nos[i] << " "; } getch(); }
This C++ program checks whether a given array of five integers is a palindrome (i.e., reads the same forwards and backwards) using inline 8086 assembly instructions. It utilizes basic comparison instructions and control flow to determine equality between symmetric elements. #include<iostream.h> #include<conio.h> void main() { int nos[5], x, y; cout << "\n Enter 5 numbers:"; int i, j; for (i = 0; i < 5; i++) { cin >> nos[i]; } for (i = 0, j = 4; i < 3; i++, j--) { x = nos[i]; y = nos[j]; _asm { mov ax, x mov bx, y cmp ax, bx jnz no } } cout << "\n Array is Palindrome."; goto end; no: cout << "\n Array is not palindrome."; end: getch(); }
This C++ program demonstrates how to search for a specific element within an array of 10 integers using 8086 assembly instructions embedded inline. The program uses the cmp and jz instructions to perform the comparison and detect a match. #include<iostream.h> #include<conio.h> void main() { int nos[10], j, t; int i, p; cout << "\n Enter 10 numbers:"; for (i = 0; i < 10; i++) { cin >> nos[i]; } cout << "\n Enter number to be searched:"; cin >> j; for (i = 0; i < 10; i++) { p = i; t = nos[i]; _asm { mov ax, t // Load current array element mov bx, j // Load number to be searched cmp ax, bx // Compare current element with target jz out // If match found, jump to output } } cout << "\n No is not found."; goto end; out: cout << "\n Number is found at " << p + 1 << " th position"; end: getch(); }
While high-level languages like C++ are well known for abstracting away low-level operations, sometimes it’s beneficial to peek under the hood to see how things really work at the machine level. In this post, we’ll explore a simple C++ program that incorporates inline assembly to add two 16-bit numbers. #include<iostream.h> #include<conio.h> #include<stdio.h> void main() { clrscr(); int a,b,c; cout<<"Enter First Number:"; cin>>a; cout<<"Enter Second Number:"; cin>>b; asm mov ax, a // Move first number into AX asm mov bx, b // Move second number into BX asm add ax, bx // Add BX to AX (binary addition) asm mov c, ax // Move result into variable 'c' cout<<"Result:"; cout<<c; getch(); }
While high-level programming languages like C++ make arithmetic operations incredibly simple, delving into inline assembly offers valuable insights into how the CPU processes instructions under the hood. Hence in this post, we’ll walk through a simple program that uses both C++ and inline assembly to add two integer values. Additionally, we will carry out decimal adjust after addition.
While modern high-level languages like C++ abstract away many low-level operations, sometimes it's useful to dive into assembly-level instructions for greater control and understanding. This example demonstrates subtraction using inline assembly in C++, with the addition of the DAS instruction to adjust the result for Binary Coded Decimal (BCD) operations. #include<iostream.h> #include<conio.h> #include<stdio.h> void main() { clrscr(); int a, b, c; cout << "Enter First Number:"; cin >> a; cout << "Enter Second Number:"; cin >> b; asm mov ax, a // Move 'a' into AX asm mov bx, b // Move 'b' into BX asm sub ax, bx // Subtract BX from AX asm das // Adjust AX for BCD subtraction asm mov c, ax // Store result in 'c' cout << "Result:"; cout << c; getch(); }