How to check for out-of-bounds to fix segmentation fault?

Question

1.00/5 (1 vote)

See more:

C

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h> // for sleep() function
#include <errno.h>

enum direction { UP, DOWN, LEFT, RIGHT };

struct ant {
    int row;
    int col;
    enum direction dir;
};

void print_map(char **map, int rows, int cols, struct ant langton_ant, struct ant random_ant) {
    system("clear"); // Clear the console

    // Print the borders of the map
    for (int j = 0; j < cols+2; j++) {
        printf("* ");
    }
    printf("\n");

    // Print the map contents
    for (int i = 0; i < rows; i++) {
        printf("* ");
        for (int j = 0; j < cols; j++) {
            if (i == langton_ant.row && j == langton_ant.col) {
                printf("\x1b[41m"); // Red background color for Langton's ant
                if (langton_ant.dir == UP) {
                    printf("^ ");
                } else if (langton_ant.dir == RIGHT) {
                    printf("> ");
                } else if (langton_ant.dir == LEFT) {
                    printf("< ");
                } else if (langton_ant.dir == DOWN) {
                    printf("v ");
                }
                printf("\x1b[0m"); // Reset color to default
            } else if (i == random_ant.row && j == random_ant.col) {
                printf("\x1b[44m"); // Blue background color for random ant
                if (random_ant.dir == UP) {
                    printf("^ ");
                } else if (random_ant.dir == RIGHT) {
                    printf("> ");
                } else if (random_ant.dir == LEFT) {
                    printf("< ");
                } else if (random_ant.dir == DOWN) {
                    printf("v ");
                }
                printf("\x1b[0m"); // Reset color to default
            } else if (i == rows/2 && j == cols/2) {
                printf("\x1b[42m"); // Green background color for center of the map
                printf("  ");
                printf("\x1b[0m"); // Reset color to default
            } else {
                printf("%c ", map[i][j]);
            }
        }
        printf("*\n");
    }

    // Print the borders of the map
    for (int j = 0; j < cols+2; j++) {
        printf("* ");
    }
    printf("\n");
}
int main(int argc, char *argv[]) {
    if (argc != 3) {
        printf("Error: Invalid number of arguments\n");
        return 1;
    }

    int waiting_time = atof(argv[1]); // get waiting time from command line argument
    int num_steps = atoi(argv[2]); // get number of steps from command line argument
    FILE *input_file = fopen("input.txt", "r");
    if (input_file == NULL) {
        printf("Error: Unable to open input file\n");
        return 1;
    }

    int rows, cols, ant1_row, ant1_col, ant2_row, ant2_col;

    if (fscanf(input_file, "%d %d %d %d %d %d", &rows, &cols, &ant1_row, &ant1_col, &ant2_row, &ant2_col) != 6) {
        printf("Error: Invalid input format\n");
        return 1;
    }

    char **map = (char**)malloc(rows * sizeof(char*));

    for (int i = 0; i < rows; i++) {
        map[i] = (char*)malloc(cols * sizeof(char));
        for (int j = 0; j < cols; j++) {
            if (i == 0 || i == rows - 1 || j == 0 || j == cols - 1) {
                map[i][j] = ' ';
            } else {
                map[i][j] = ' ';
            }
        }
    }

    // Initialize the first ant
    struct ant langton_ant = { ant1_row, ant1_col, UP };

    // Initialize the second ant
    struct ant random_ant = { ant2_row, ant2_col, DOWN };

    srand(time(NULL)); // Seed the random number generator with the current time

    int wait_time = 1; //default wait time between each step is 1 second
    if (argc > 1) {
        wait_time = atof(argv[1]);
    }

    // Run the simulation
    for (int step = 0; step < num_steps; step++) {
        // Update the direction of the Langton ant based on the color of the cell
        int langton_ant_row = langton_ant.row;
        int langton_ant_col = langton_ant.col;

     if (map[langton_ant_row][langton_ant_col] == '*') {
            langton_ant.dir = (langton_ant.dir + 1) % 4;
        } else {
            langton_ant.dir = (langton_ant.dir - 1 + 4) % 4;
        }

     // Update the color of the cell and move the Langton ant
     if (map[langton_ant_row][langton_ant_col] == '*') {
         map[langton_ant_row][langton_ant_col] = ' ';
     } else {
          map[langton_ant_row][langton_ant_col] = '*';
      }
        if (langton_ant.dir == UP) {
            langton_ant.row--;
        } else if (langton_ant.dir == RIGHT) {
            langton_ant.col++;
        } else if (langton_ant.dir == LEFT) {
            langton_ant.col--;
        } else if (langton_ant.dir == DOWN) {
            langton_ant.row++;
        }

        // Update the direction of the random ant based on a random number
        int random_number = rand() % 4;
        if (random_number == 0) {
           random_ant.dir = UP;
        } else if (random_number == 1) {
            random_ant.dir = RIGHT;
        } else if (random_number == 2) {
            random_ant.dir = LEFT;
        } else if (random_number == 3) {
            random_ant.dir = DOWN;
        }

        // Move the random ant
        if (random_ant.dir == UP) {
            random_ant.row--;
        } else if (random_ant.dir == RIGHT) {
            random_ant.col++;
    } else if (random_ant.dir == LEFT) {
            random_ant.col--;
        } else if (random_ant.dir == DOWN) {
            random_ant.row++;
        }

        // Print the current state of the map
        print_map(map, rows, cols, langton_ant, random_ant);

        // Wait for some time
    sleep(wait_time);
    }

    // Free the memory used by the map
    for (int i = 0; i < rows; i++) {
            free(map[i]);
    }
    free(map);

    return 0;
}

What I have tried:

When I run my program, I want the ants to be able to move at any speed - be it less than one second or more - for the number of steps its given. When I run the program, it works well for any wait time that is one second or more. But when I try and run the program at a wait time of less than a second, the program instantly ends and prints a segmentation fault (core dumped) message.

Edit: I was able to figure out the previous issue I was having. My new question is; how to check for out-of-bounds access when updating the ants' position and direction? Because this is giving me segmentation fault error.

Posted 17-Apr-23 6:07am

DosNecro

Updated 17-Apr-23 9:56am

v4

Add a Solution

Comments

0x01AA 17-Apr-23 13:24pm

.

4 solutions

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Richard MacCutchan · Answer 1 · 2023-04-17T06:37:00

Solution 1

This is your third post of the same question, and you are still making the same mistake that I pointed out in the first one. You have the following code at the beginning:

C++

int waiting_time = atof(argv[1]); // get waiting time from command line argument

Then further down you have:

C++

int wait_time = 1; //default wait time between each step is 1 second
if (argc > 1) {
    wait_time = atof(argv[1]);
}

But ib both cases you declare the variables as int types, so calling atof makes no sense. And since the sleep function only accepts integer values there is no point in trying to capture the value as a float. So change the first line just after main to:

C++

int wait_time = atoi(argv[1]); // get wait_ime from command line argument

And remove the other lines where you try to capture it a second time.

Posted 17-Apr-23 6:37am

Richard MacCutchan

Comments

0x01AA 17-Apr-23 13:09pm

~~Looks like on linux sleep accepts float values: sleep() Function in C - GeeksforGeeks[^]~~

DosNecro 17-Apr-23 13:41pm

I tried your method, however, it didn't give me a fix. Instead, I used errno and usleep to help fix the issue, and it worked. Though I have to input the time in as milliseconds instead of seconds.

Richard MacCutchan 18-Apr-23 3:55am

Seconds multiplied by 1000 equals milliseconds. Howver, as you can see from sleep(3) - Linux manual page[^], the sleep function takes a value in seconds.

DosNecro 17-Apr-23 13:56pm

Any chance you know how to check for out-of-bounds access when updating the ants' position and direction? Cause this is giving me segmentation fault errors.

Richard MacCutchan 18-Apr-23 3:56am

Not without more information. Where does the error occur and what variable is causing it?

CPallini · Answer 2 · 2023-04-17T07:24:00

You might actually use usleep, however it cannot handle waiting times greater than one second (see the relative man page). An alternative could be nanosleep[^], try

C

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main(int argc, char *argv[])
{
    if (argc != 3)
    {
        printf("Error: Invalid number of arguments\n");
        return 1;
    }

    double waiting_time = atof(argv[1]); // get waiting time from command line argument
    int num_steps = atoi(argv[2]); // get number of steps from command line argument

    if (waiting_time < 0.005)
      waiting_time = 0.005;
    else if (waiting_time > 10.0)
      waiting_time = 10.0;

    struct timespec wt;

    wt.tv_sec = (time_t) waiting_time; // getting the integer part of the waiting time
    wt.tv_nsec = (long) ( (waiting_time - wt.tv_sec) * 1E9); // getting the fractional part of the wating time, converting it to nanoseconds

    for ( int step = 0; step < num_steps; ++step)
    {
      nanosleep(&wt, NULL);
    }
  return 0;
}

Note that sleeping for very small intervals is not accurate on (no-real-time) operative systems.

merano99 · Answer 3 · 2023-04-17T09:41:00

Quote:
My new question is; how to check for out-of-bounds access

I don't think it will help this time because as Richard said this is the third post with almost the same questions. As I told you here
https://www.codeproject.com/Answers/5359105/How-to-get-command-line-and-file-input-to-work-pro
some values are out of range. There are accesses with negative values and probably also too large values. How would it be if you think about whether you should always subtract something:

C

if (langton_ant.dir == UP) {
    langton_ant.row--;

k5054 · Answer 4 · 2023-04-17T09:56:00

Seems to work fine for me. What is in your input.txt, and what command line arguments are you using?
But maybe now is a good time to get acquainted with the debugger (gdb). Make sure you've compiled a debug version (gcc flag -g, -g3 or -ggdb. your session will go something like

gcc -Wall -Wextra -ggdb ants.c -o ants
gdb ants
r 2 10
.. program halts on SegFault...
bt
... gdb shows you where your program failed, and you can then inspect various values

You may need to take a look at gdb tutorial such as this one: gdb tutorial[^]

How to check for out-of-bounds to fix segmentation fault?

4 solutions

Solution 1

Solution 2

Solution 3

Solution 4

Add your solution here

Preview 0