Skip to main content

Program 7: Fibonacci Series

 **Program 7: Fibonacci Series**


```assembly

.model small

.stack 100h


.data

    count dw 10

    fib1 dw 0

    fib2 dw 1

    result dw ?


.code

    main proc

        mov cx, count       ; Load 'count' into CX

        

    fib_loop:

        add result, fib1    ; Add fib1 to result

        mov ax, fib1        ; Swap fib1 and fib2

        mov fib1, fib2

        mov fib2, ax

        loop fib_loop       ; Decrement CX and loop if not zero

        

        mov ah, 4Ch          ; Exit program

        int 21h

    main endp

end main

```


Explanation:

1. `.model small` and `.stack 100h`: Memory model and stack size definitions.

2. `.data` section: Declares the data segment.

   - `count dw 10`: Defines a word-sized variable named "count" with value 10.

   - `fib1 dw 0`: Defines a word-sized variable named "fib1" with initial value 0.

   - `fib2 dw 1`: Defines a word-sized variable named "fib2" with initial value 1.

   - `result dw ?`: Defines a word-sized uninitialized variable named "result".

3. `.code` section: Contains the main code.

   - `mov cx, count`: Move the value of "count" into the CX register.

   - `fib_loop:`: Label for


 the Fibonacci loop.

   - `add result, fib1`: Add the value of "fib1" to the "result".

   - `mov ax, fib1`: Swap the values of "fib1" and "fib2".

   - `mov fib1, fib2`: Move the value of "fib2" into "fib1".

   - `mov fib2, ax`: Move the value of "ax" (original "fib1") into "fib2".

   - `loop fib_loop`: Decrement CX and loop if CX is not zero.

   - `mov ah, 4Ch`: Set the exit code for DOS.

   - `int 21h`: Call DOS interrupt to exit the program.
Labels:

Comments

Post a Comment

Popular posts from this blog

6. Generate a YACC specification to recognize a valid arithmetic expression that uses operators +, – , *,/ and parenthesis.

Below is a YACC specification for recognizing valid arithmetic expressions that involve operators (+, -, *, /) and parentheses. I'll explain each line of the code afterward: ```yacc %{ #include <stdio.h> %} %token NUMBER %left '+' '-' %left '*' '/' %% expression: expression '+' expression            | expression '-' expression            | expression '*' expression            | expression '/' expression            | '(' expression ')'            | NUMBER            ; %% int yylex() {     // Code for tokenizing input and returning tokens } void yyerror(const char *s) {     fprintf(stderr, "Error: %s\n", s); } int main() {     yyparse();     return 0; } ``` Now, let's break down the YACC specification line by line: 1. `%{` ... `%}`: This is the C code section where y...
Post a Comment
Read more

1, Design and implement a lexical analyzer using C language to recognize all valid tokens in the input program. The lexical analyzer should ignore redundant spaces, tabs and newlines. It should also ignore comments

#include <stdio.h> #include <ctype.h> int main() {     char c;     while ((c = getchar()) != EOF) {         if (isspace(c)) {             // Ignore whitespace, tabs, and newlines             continue;         }         if (c == '/') {             // Check for comments             char nextChar = getchar();             if (nextChar == '/') {                 while ((nextChar = getchar()) != '\n');         ...
Post a Comment
Read more

17. Write a program to perform constant propagation.

Sure, I can provide you with a basic example of a constant propagation program along with explanations for each line. Please note that this example is simplified and might not cover all possible cases of constant propagation. ```c #include <stdio.h> #include <stdbool.h> // Structure to represent an assignment statement struct Assignment {     char variable;     int value;     bool isConstant; }; int main() {     // Example assignments (variable, value, isConstant)     struct Assignment assignments[] = {         {'a', 10, true},         {'b', 20, true},         {'c', 0, true},         {'d', 30, false},         {'e', 0, false}     };     int numAssignments = sizeof(assignments) / sizeof(assignments[0]);     // Perform constant propagation     for (int i = 0; i < numAssignments; i++) { ...
Post a Comment
Read more