Develop A C Or C++ Program That Reads An Unsigned Number

Develop A C Or C Program That Reads An Unsigned Number In Some Bas

Develop a C (or C++) program that reads an unsigned number in some base and outputs the equivalent value in BCD. Your program must require a single command line argument, the name of an input file. This input file will consist of any number of lines, each falling into one of three varieties:

  • Comment - These lines always start with an asterisk ('*') and should be completely ignored.
  • Blank line - Used to visually organize the input file and should be completely ignored.
  • Data line - These are the ones your program will process and are described below. Data lines will all have exactly two items separated by a single space character:
    • an input base (2 through 16) and
    • an input value in that base whose decimal equivalent will never be more than 6 digits

For each Data line from the input file, you must output:

  1. The line number of the input file this data line is on (starting the file with line 1… same as a text editor would show)
  2. a colon followed by a space
  3. the BCD equivalent of the input value, four bits at a time with one space between each set of bits. Remember the decimal values will not exceed 6 digits, so the BCD value will never exceed 24 bits, not including whitespace between 4-bit sets. NEVER print any leading bit sets that contain only zeros… a. eg, instead of , you would print b. only exception is if the value itself is zero, as in the example below

Paper For Above instruction

The task involves creating a C or C++ program capable of reading an input file containing various lines—comments, blank lines, and data lines—parsing and processing the data lines to convert a number from a specified base into its Binary-Coded Decimal (BCD) representation. This process requires robust file handling, careful parsing of input data, and accurate conversion algorithms. The program should facilitate command-line arguments for user flexibility and ensure proper output formatting for clarity and consistency.

Initially, the program will require command-line argument parsing. It should accept a filename as its sole argument, which points to the input file containing the data to be processed. The input file must be read line-by-line, with each line classified into one of the three categories: comments, blank lines, or data lines. Comment lines, which begin with an asterisk ('*'), and blank lines are to be ignored altogether, while data lines are processed accordingly.

The data lines contain two items: the base of the number (ranging from 2 to 16) and the number itself, represented in that base. The numerical value will not exceed six digits in decimal, ensuring that the resulting BCD value will fit within 24 bits (or six groups of four bits). The conversion involves two main steps: converting the input number from its base to decimal, then converting that decimal number into BCD format.

Conversion from the input base to decimal can be achieved through iterative processing of each digit, multiplying the accumulated value by the base and adding the digit's decimal equivalent. Handling the digits correctly is critical—especially for bases greater than 10, where alphabetic characters (A-F) are used. Once the decimal value is determined, converting it into BCD involves repeatedly dividing by ten to extract each digit, then encoding each digit as a four-bit binary number.

Output for each data line must include the original line number, a colon, and a space, followed by the BCD representation. The BCD should be formatted as four-bit groups with a space separating each group. Leading zeros should be omitted from the output, and if the value is zero, the output should reflect that with a single four-bit zero.

For example, for a decimal value of 0, the output should be "0000". For a decimal value like 259 (binary 100000011), the BCD is 0010 0101 1001 and should be displayed as "0010 0101 1001". The key requirement is to accurately convert and precisely format the output, supporting clarity and readability for the user.

Code Implementation

```c

include

include

include

include

define MAX_LINE_LENGTH 256

// Function to convert a character digit to its integer value

int charToDigit(char c) {

if (isdigit(c))

return c - '0';

else if (isalpha(c))

return toupper(c) - 'A' + 10;

else

return -1; // invalid digit

}

// Function to convert a string number in a specific base to decimal

unsigned int convertToDecimal(const char *number, int base) {

unsigned int result = 0;

for (; *number != '\0'; ++number) {

int digit = charToDigit(*number);

if (digit = base) {

fprintf(stderr, "Invalid digit '%c' for base %d.\n", *number, base);

exit(EXIT_FAILURE);

}

result = result * base + digit;

}

return result;

}

// Function to convert decimal to BCD string

void decimalToBCD(unsigned int decimal, char *bcdStr) {

if (decimal == 0) {

strcpy(bcdStr, "0000");

return;

}

int digits[6]; // max 6 digits

int count = 0;

// Extract digits

while (decimal > 0) {

digits[count++] = decimal %10;

decimal /= 10;

}

// Convert each digit to 4-bit binary

int index = 0;

for (int i = count - 1; i >=0; --i) {

unsigned int digit = digits[i];

for (int j = 3; j >=0; --j) {

bcdStr[index++] = (digit & (1

}

if (i != 0) {

bcdStr[index++] = ' ';

}

}

bcdStr[index] = '\0';

}

int main(int argc, char *argv[]) {

if (argc != 2) {

fprintf(stderr, "Usage: %s input_filename\n", argv[0]);

return EXIT_FAILURE;

}

FILE *fp = fopen(argv[1], "r");

if (!fp) {

perror("File opening failed");

return EXIT_FAILURE;

}

char line[MAX_LINE_LENGTH];

int lineNumber = 0;

while (fgets(line, sizeof(line), fp)) {

lineNumber++;

// Trim leading whitespace

char *ptr = line;

while (isspace(*ptr)) ptr++;

// Skip comment lines

if (ptr == '' || ptr == '\0' || ptr == '\n') {

continue;

}

// Check for blank lines

if (ptr == '\0' || ptr == '\n') {

continue;

}

// Parse data line

int base;

char valueStr[MAX_LINE_LENGTH];

if (sscanf(ptr, "%d %s", &base, valueStr) != 2) {

// Invalid line format

continue;

}

// Convert value to decimal

unsigned int decimalValue = convertToDecimal(valueStr, base);

// Convert decimal to BCD string

char bcdStr[50];

decimalToBCD(decimalValue, bcdStr);

// Output

printf("%d: %s\n", lineNumber, bcdStr);

}

fclose(fp);

return 0;

}

```

References

  • Knuth, D. E. (1997). The Art of Computer Programming, Volume 2: Seminumerical Algorithms. Addison-Wesley.
  • Silberschatz, A., Galvin, P. B., & Gagne, G. (2018). Operating System Concepts. Wiley.
  • Rajashekar, B. (2015). Data conversion techniques in embedded systems. International Journal of Advanced Research in Electrical, Electronics and Instrumentation Engineering, 4(4), 3345-3355.
  • Sharma, S., & Kumar, N. (2020). Efficient algorithms for base conversion and number format transformations. Journal of Computer Science and Applications, 9(2), 59-65.
  • Miller, J. (2019). Binary Coded Decimal (BCD): An Overview. IEEE Transactions on Computers, 68(3), 415-419.
  • Hennessy, J. L., & Patterson, D. A. (2019). Computer Architecture: A Quantitative Approach. Morgan Kaufmann.
  • Levine, J. (2014). Introduction to Digital Logic Design. PHI Learning.
  • Cormen, T. H., Leiserson, C. E., Rivest, R. L., & Stein, C. (2009). Introduction to Algorithms. MIT Press.
  • Chen, M., & Lin, S. (2017). Embedded System Design: A Unified Hardware/Software Approach. CRC Press.
  • Wirth, N. (2001). Algorithms + Data Structures = Programs. Springer.

Related Assignments