C 程序执行与 shell 不同

Question

I am trying to read this input as characters into memory in c in a 2 dimensional array.

00P015
00P116
030000
06P0ZZ
030005
06P1ZZ
04P0ZZ
26P1ZZ
3412ZZ
030010
06P0ZZ
99ZZZZ
030010
06P1ZZ
99ZZZZ
ZZ0000
ZZ0010

My code is

#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>


int pr;
int value;
/*These are variables representing the VM itself*/

char IR[6] ;
short int PC = 0 ;

int P0 ;                                                                //these are the pointer registers
int P1 ;
int P2 ;
int P3 ;

int R0 ; //GP regs
int R1 ;
int R2 ;
int R3 ;

int ACC ;
char PSW[2];
char memory [100][6]  ;                                                 //this is the program memory for first program
short int opcode ;                                                      //nice to know what we are doing
int program_line = 0 ;


int fp ;
int i ;
int q = -1;                                                                  //Used to iterate through memory to execute program
int TrueFalse;                                                          //True / False value for check statements, 1 implies true, 0 implies false
int halt = 0;
int address;


char input_line [7] ;

main(int argc, char *argv[])
{                                                                       //Read file into VM
    fp = open("C:\\Users\\Whiskey Golf\\ClionProjects\\untitled\\program.txt", O_RDONLY) ;
    printf("Open is %d\n", fp) ;                                        //always check the return value.

    if (fp < 0)                                                         //error in read
    {printf("Could not open file\n");
        exit(0) ;
    }
                                                                        //read in the first line of the program
    int charRead = read (fp, input_line, 8 ) ;                          //returns number of characters read`
    printf("\n*******************************\n");
    printf("* Reading Program Into Memory *\n");
    printf("*******************************\n");
    while (1)
    { if (charRead <= 0)                                                //indicates end of file or error
            break ;                                                     //breaks out of infinite loop

        for (i = 0; i < 6 ; i++)                                        //If we get here must have correctly read in a line of program code.
            memory[program_line][i] = input_line[i] ;                   //copy from input line into program memory

        printf("Program Line %d: ", program_line) ;                     //printing out program line for debugging purposes
        for(i = 0; i <  6; i++)
            printf("%c", memory[program_line][i]) ;
        printf("\n") ;

        opcode = (memory[program_line][0] -48) *10 ;                    //Get opcode, print out opcode to console
        opcode += (memory[program_line][1] -48) ;

        printf("Opcode is %d\n", opcode) ;

        charRead = read (fp, input_line, 8) ;                           //read in next line of code

        if(input_line[0] == 'Z')                                        //if the firat character is a 'Z' then you are reading data.
            break ;                                                     //No more program code so break out of loop

        program_line++ ;                                                //now at a new line in the prog
        printf("%n");
    }

The issue I am having is that when I run the program in the IDE I wrote it in, Clion, my output is correct, I get

Program Line 0: 00P015
Opcode is 0
Program Line 1: 00P116
Opcode is 0
Program Line 2: 030000
Opcode is 3
Program Line 3: 06P0ZZ
Opcode is 6

But when I run the code via a shell via gcc compilation then ./a.out execution, the output I get is

Program Line 0: 00P015
Opcode is 0
Program Line 1: 16
Opcode is -528
Program Line 2: 00
Opcode is -528
Program Line 3: ZZ
Opcode is-528

I have been trying to debug this issue for a while now, and I can not get it to work correctly when I do it through the shell, which is the way I need to do it. Any help would be greatly appreciated.

Answer 1

You are reading 8 bytes which takes the end of line character '\\n' and tries to store it in a 7 bytes array.

read (fp, input_line, 8)

this leads to undefined behavrio, and it should be

read(fp, input_line, 7)

And then you could just discard the next byte like

char discard; 
read(fp, &discard, 1);

I suppose you was reading 8 bytes to consume the end of line character, so you could have increased the array size to 8 and ignore the last character or simply read it and discard it.

EDIT : Looking closely at the data and your code, I found out that I don't understand what you try to do, you must read just 7 characters, that will include the trailing '\\n' , the following code will work if and only if there is always a new line '\\n' after each line, otherwise it will skip the last line, you should think of the obvious solution yourself. Also, see this comment , if you write the program with a text editor on MS Windows, you will have trouble. To solve that you can just use fopen() instead of low level I/O.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>

int
main(void)
{
    int file;
    ssize_t length;
    char buffer[7];
    file = open("program.txt", O_RDONLY);
    if (file == -1)
        return -1;
    while ((length = read(file, buffer, sizeof(buffer))) == 0)
    {
        int opcode;
        /* You will need to overwrite the '\n' for the printf() to work 
         * but you can skip this if you don't want to print the command
         */
        buffer[length - 1] = '\0'; 
        opcode = 10 * (buffer[0] - '0') + buffer[1] - '0';
        fprintf(stderr, "Command: `%s'\n\topcode: %d\n", buffer, opcode);
    }
    close(file);
    return 0;
}

Answer 2

char input_line [7] ;

int charRead = read (fp, input_line, 8 ) ;

Reads 8 bytes into a 7 byte array, which is bad. It just wrote over some memory after the array, but since the array is 7 bytes and most data is aligned on 4 or 8 byte values, you probably get away with it by not reading data over anything important.

But!!! Here is your data:

00P015<EOL>
00P116<EOL>
030000<EOL>
06P0ZZ<EOL>
030005<EOL>
...

On a Unix-based system where the end of line is one byte, reading 8 bytes will read

00P015<EOL>0

And the next eight bytes will read

0P116<EOL>03

etcetera... So here is your data on drugs:

00P015<EOL>0
0P116<EOL>03
0000<EOL>06P
0ZZ<EOL>0300
05<EOL>...

See what happens? Not what you need or want.

How this could work in the IDE, smurfed if I know, unless the input file is actually a windows text file (two byte end of line mark), but it's playing with fire. I'm going to stick with C and pitch fscanf as an alternative to read. I also stripped out all of the stuff not essential to this example.

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


int main(int argc, char *argv[])
{
    (void) argc; // I'm being pedantic. As pointed out below in the comments, this
                 // is not needed. Main needs no arguments. I just like them.
    (void) argv;
    //Read file into VM
// moved all variables into function
    char memory [100][6] ; //This is likely program death if you read more than 100 
                           // lines from the file. There are no guards to prevent this 
                           // in the original code.
    int opcode ;
    int program_line = 0 ;


    FILE* fp ; //using a C FILE handle rather than a posix handle for maximum portability

    char input_line [8] ;// death if a line is poorly formatted and has extra characters, 
                         // but in this case, the whole program falls apart.                            
                         // Went with 8 in case the input file was formatted for Windows.

    fp = fopen("asd.txt", "r") ; // using c standard library file open
    if (fp == NULL)
    {
        printf("Could not open file\n");
        return 0 ;
    }
    int itemsRead = fscanf(fp, "%s\n", input_line) ;
    //fscanf is a much more tractable reader. This will read one string of characters 
    // up to the end of line. It will easily and happily run past the end of input_line 
    // if the line is poorly formatted
    // handles a variety of EOL types. and returns the number of the requested 
    // items read. In this case, one item.
    printf("\n*******************************\n");
    printf("* Reading Program Into Memory *\n");
    printf("*******************************\n");
    while (itemsRead == 1 && input_line[0] != 'Z' && program_line < 100) 
    { // much better place for the exit conditions. Also added test to prevent 
      // overrunning memory
        for (int i = 0; i < 6 ; i++)
        {
            memory[program_line][i] = input_line[i] ;
        } // this can also be performed with memcpy
        printf("Program Line %d: ", program_line) ;
        for(int i = 0; i <  6; i++)
        {
            printf("%c", memory[program_line][i]) ;
        } // if we were using properly terminated c-style strings, and we are not, 
          // this loop and the following printf("\n") could be replaced with  
          // printf("%s\n", memory[program_line]). As it is putc would be a more 
          // efficient option
        printf("\n") ;

        opcode = (memory[program_line][0] -'0') *10 ;  // '0' much easier to read than 48
        opcode += memory[program_line][1] -'0' ;

        printf("Opcode is %d\n", opcode) ;

        charRead = fscanf(fp, "%s\n", input_line) ;

        program_line++ ;
        printf("\n"); // fixed typo
    }
}

And in C++, this sucker is trivial

#include <iostream>
#include <fstream>
#include <vector>

int main(int argc, char *argv[])
{
    (void) argc; // I'm still being pedantic.
    (void) argv;
    //Read file into VM

    std::vector<std::string> memory;
    int opcode;

    std::ifstream in("asd.txt");
    std::cout << "\n*******************************\n"
              << "* Reading Program Into Memory *\n"
              << "*******************************\n";
    std::string input_line;
    while (std::getline(in, input_line) && input_line[0] != 'Z')
    {
        memory.push_back(input_line);
        std::cout << input_line << std::endl;
        opcode = (input_line[0] - '0') * 10 + input_line[1] - '0';

        std::cout << "Opcode is " << opcode << std::endl << std::endl;
    }
}

A note on being pedantic. There is this wonderful compiler option called -pedantic It instructs the compiler to do some fairly anally retentive error checking. Add it , -Wall , and -Wextra to your command line. Together they will spot a lot of mistakes. And some stuff that isn't mistakes, but you can't win them all.