/*
 * File:        prefix.c
 * Author:      Luxing Huang
 * Date:        2013/11/24
 * Version:     1.0
 *
 * Purpose:     This programme will take in tokens from arguments or stdin to
 *              give back:
 *              1. postfix polish notation
 *              2. infix polish notation
 *              3. the result of the calculation (optional)
 *
 * Assumption:  User input will not exceed 256/2=128 chars.
 */
#include 
#include 
#include 
#include 
#include 
#include 

#define LIMIT 257

int pos;

typedef struct expression_tree_node
{
    struct expression_tree_node *leftnode;
    struct expression_tree_node *rightnode;
    union
    {
        int32_t left;
        char leftop[4];
    } left;

    union
    {
        int32_t right;
        char rightop[4];
    } right;

    union
    {
        char topop[4]; 
        int32_t top;
    } top;

    bool left_done;
    bool right_done;
} *node_T;

/*
 * Name:        convert
 * Purpose:     Convert from prefix expression to infix and postfix expression.
 * Arguments:   prefixin, postout, infixout, leaf1
 * Returns:     nothing
 * Modifies:    postout, infixout
 */
void
convert(char *prefixin, char *postout, char *infixout, node_T leaf1)
{
    int ret;
    node_T leaf2 = malloc(sizeof(struct expression_tree_node)); 
    char *tmp = calloc(LIMIT, sizeof(char));
    char *postoutl = calloc(LIMIT, sizeof(char));
    char *postoutr = calloc(LIMIT, sizeof(char));
    char *infixoutl = calloc(LIMIT, sizeof(char));
    char *infixoutr = calloc(LIMIT, sizeof(char));

    pos = 0;

    if (tmp == NULL || postoutl == NULL || postoutr == NULL || infixoutl == NULL
            || infixoutr == NULL)
    {
        fprintf(stderr, "Unable to calloc.\n");
        exit(-1);
    }


    /* Scanning in the top operator */
    if (leaf1->top.topop == 0)
    {
        ret = sscanf(prefixin, "%s", leaf1->top.topop);
        if (ret == 0)
        {
            fprintf(stderr, "Invalid expression.\n");
            exit(-1);
        }
        pos+= 2;
    }

    /* Scanning left tree */
    ret = sscanf(prefixin, "%d", &leaf1->left.left);
    if (ret == 0)
    {
        ret = sscanf(prefixin, "%s", leaf1->left.leftop);
        if (ret == EOF)
        {
            fprintf(stderr, "Insufficient arguments!\n");
            exit(-1);
        }
        pos += 2;
        strncpy(leaf2->top.topop, leaf1->left.leftop, sizeof(int32_t));
        leaf1->leftnode = leaf2;
        convert(prefixin + pos, postoutl, infixoutl, leaf2);
        pos += 2;
    }
    else if (ret == EOF)
    {
        fprintf(stderr, "Insufficient arguments!\n");
        exit(-1);
    }
    else
    {
        pos += 2;
        leaf1->left_done = true;
    }

    /* Scanning Right tree */
    ret = sscanf(prefixin + pos, "%d", &leaf1->right.right);
    if (ret == 0)
    {
        ret = sscanf(prefixin + pos, "%s", leaf1->right.rightop);
        if (ret == EOF)
        {
            fprintf(stderr, "Insufficient arguments!\n");
            exit(-1);
        }
        pos += 2;
        strncpy(leaf2->top.topop, leaf1->right.rightop, sizeof(int32_t));
        leaf1->rightnode = leaf2;
        convert(prefixin + pos, postoutr, infixoutr, leaf2);
        pos += 2;
    }
    else if (ret == EOF)
    {
        fprintf(stderr, "Insufficient arguments!\n");
        exit(-1);
    }
    else
    {
        leaf1->right_done = true;
        pos += 2;
    }

    /* Setting up Output */
    if (leaf1->left_done == true)
    {
        if (leaf1->right_done == true)
        {
            sprintf(tmp, "%d %d %s ", leaf1->left.left, leaf1->right.right,
                    leaf1->top.topop);
            strncpy(postout, tmp, LIMIT);
            sprintf(tmp, "(%d %s %d)", leaf1->left.left, leaf1->top.topop,
                    leaf1->right.right);
            strncpy(infixout, tmp, LIMIT);
        }
        else
        {
            sprintf(tmp, "%d %s %s", leaf1->left.left, postoutr,
                    leaf1->top.topop);
            strncpy(postout, tmp, LIMIT);
            sprintf(tmp, "(%d %s %s)", leaf1->left.left, leaf1->top.topop,
                    infixoutr);
            strncpy(infixout, tmp, LIMIT);
        }
    }
    else
    {
        if (leaf1->right_done == true)
        {
            sprintf(tmp, "%s %d %s", postoutl, leaf1->right.right,
                    leaf1->top.topop);
            strncpy(postout, tmp, LIMIT);
            sprintf(tmp, "(%s %s %d)", infixoutl, leaf1->top.topop, 
                    leaf1->right.right);
            strncpy(infixout, tmp, LIMIT);
        }
        else 
        {
            sprintf(tmp, "%s %s %s", postout, postout, leaf1->top.topop);
            strncpy(postout, tmp, LIMIT);
            sprintf(tmp, "(%s %s %s)", infixout, leaf1->top.topop, infixout);
            strncpy(infixout, tmp, LIMIT);
        }
    }
}

int
main(int argc, char *argv[])
{
    char *prefixin = calloc(LIMIT,  sizeof(char));
    char *postout = calloc(LIMIT,  sizeof(char));
    char *infout = calloc(LIMIT,  sizeof(char));
    char arguments[] = "echo '";
    char bc[] = "' | bc ";
    node_T start_of_tree;
    start_of_tree = malloc(sizeof(struct expression_tree_node));

    if (prefixin == NULL || postout == NULL || infout == NULL || 
        start_of_tree == NULL)
    {
        fprintf(stderr, "Unable to malloc.\n");
        return EXIT_FAILURE;
    }
    int i, ret, count;
    count = 2;

    if (argc == 1)
    {
        if (isatty(fileno(stdin)))
        {
            printf("Please enter your expression: ");
        }
        fgets(prefixin, LIMIT, stdin);
    }
    else
    {
        for (i = 1; i < argc; i++)
        {
            strcat(prefixin, argv[i]);
            strcat(prefixin, " ");
        }
    }

    ret = sscanf(prefixin, "%d", &start_of_tree->top.top);
    if (ret == 1)
    {
        printf("Postfix: %d\n", start_of_tree->top.top);
        printf("Infix:   (%d)\n", start_of_tree->top.top);
        printf("Result:  %d\n", start_of_tree->top.top);
        return EXIT_SUCCESS;
    }
    else
    {
        ret = sscanf(prefixin, "%s", start_of_tree->top.topop);
        if (ret == 0)
        {
            fprintf(stderr, "Invalid expression!\n");
            return EXIT_FAILURE;
        }
    }

    convert(prefixin + count, postout, infout, start_of_tree);

    printf("Postfix: %s\n", postout);
    printf("Infix:   %s\n", infout);
    printf("Result:  ");
    fflush(stdout);

    strcat(arguments, infout);
    strcat(arguments, bc);
    system(arguments);
    return EXIT_SUCCESS;
}

For thoses who don’t know what a5p1 means, it means Assignment 5, Problem 1.

Yesterday, my professor Jim added a new assignment for us to do. I am going to talk about the first in this article.

I am not a good coder and I just started learning C this term. Still, I am trying to solve the puzzle as best I can. I know it is not a good style to put everything under main(), but since it’s a simple and straightforward problem, please accept my messy style of coding.

You can view the question here. I started writing the first problem this morning and I think I have finished this problem at the noon. (Just before the time I was writing this article.)

If you get a 404 error, that means this term has finished, you can get the problem sets by emailing me.

Things need attention:

1. I need to justify what format the input/output is:

input:
N
Year(%d) Month(%s) Day(%d)
....

output:
Year(%d) Month(%d) Day(%s)

I happened to mixed the order up during programming, but it wasn’t a big deal.

2. It’s important to know that the Highwings calendar count from 0 in day section but Lowwings calendar count start from 1 in month section.

3. Those calendar systems have different days per year. Highwings has days per year and Lowwings has days per year, we can write a macro for further use.

#define TOTAL_DAYS_PERYR_HIGHWING (12 * 30 + 20)
#define TOTAL_DAYS_PERYR_LOWWING (20 * 12)

The structure is simple, parse every line until N is reached using a for loop. Using getchar and scanf to read the values from stdin, assign it to corresponding values. Professor has already talked about this in a3p1, we can extract his ideas and implement them into our code.

Why we don’t just parse the whole line all-together using

 scanf("%d %s %D\n", &h_yr, &h_m, &h_d)

You’ll never know what the user is going to type in, therefore the stdin might not be what you expected. This is for error checking which I’ll talk about it later.

When you have all the correct values assigned to correct variables, then how to convert it to Lowwings Calendar system?

What I did was to find the total days, it should be the only thing in common between these 2 systems of calendar, I call the variable unify_day.

Now things are getting clearer.

In this case,

1 charlie 17

charlie is the month in Year 1, but the month has not passed, so we only need to count the first 2 months into unify_day, then calculate the day/month/year in Lowwings system.

Finally you need to reset unify_day to 0 at the end of loop.

When you try to divide a number with 12, and if the remainder is 0, it doesn’t mean that it’s the start of next month, it’s the end of the previous month. So I have put zulu first in my string array.

*lowwing_day_names[] = {"zulu", "november", "oscar", "papa", "quebec",
        "romeo", "sierra", "tango", "uniform", "victor", "whiskey", "xray"};

The error detect part, which types of error have I considered?

(a). When N = 0.
(b). When N < next few lines. (When N > next few lines I just ignore the rest)
(c). Invalid data:
   i. When !isdigit(N)
   ii. !isdigit(h_day)
   iii. !isdigit(h_yr)
(d). spaces/tabs as seperator.

Programme ends whenever an error occurs.

/*
 * File:    lightplane.c
 * Author:  Luxing Huang
 * Version: 1.0
 *
 * Purpose:
 * When we have 2 different calendar systems, we need to translate the old one
 * to the new one. 
 *
 * Here we have an old system called Highwings: A year with 13 month, 30 days 
 * for the 1-12th month, and 20 days for the 13th month. We will have 30x12+20
 * = 380 days a year. Every month has its own name.
 *
 * And the second system is 240 days a year. We have 20 months with 12 days in
 * each month. Every day in each month has its own name. This system is called
 * Lowwings.
 *
 * The input format is:
 * N
 * Year(%d) Month(%s) Day(%d)
 *
 * The output format is:
 * Year(%d) Month(%d) Day(%s)
 */
#include 
#include 
#include 
#include 

#define CHAR_LENGTH 128
#define TOTAL_DAYS_PERYR_HIGHWING (12 * 30 + 20)
#define TOTAL_DAYS_PERYR_LOWWING (20 * 12)

int
main(int argc, char *argv[])
{
    /*
     * Structure:
     * 1. scan the input, preferrably using getchar then scanf
     * 2. Convert Highwing days to unify_day.
     * 3. Error detect:
     *  a. N < next a few lines. If > I just ignore the rest.
     *  b. Invalid data:
     *      (a) when it should be a number, it's a char.
     *      (b) after year we have more char rather than \n.
     * 4. Calculate the unify day to Lowwing system.
     */
    unsigned int i, unify_day = 0, highwing_year = 0, highwing_day = 0, 
                 lowwing_year = 0, lowwing_month = 0, lowwing_day = 0;
    int highwing_month = -1, entries = 0, c = 0;
    char highwing_month_name[CHAR_LENGTH] = "";
    char *highwing_compare[] = {"alpha", "bravo", "charlie", "delta", "echo", 
        "foxtrot", "golf", "hotel", "india", "juliet", "kilo", "lima", "mike"},
         *lowwing_day_names[] = {"zulu", "november", "oscar", "papa", "quebec", 
        "romeo", "sierra", "tango", "uniform", "victor", "whiskey", "xray"};
    
    /* Ignoring spaces if have any */
    scanf("%*[ \t]");

    /* check if is a digit */
    c = getchar();
    if (!isdigit(c))
    {
        fprintf(stderr, "You need to put a positive integer in the first " 
                "line!\n");
        return EXIT_FAILURE;
    }
    else
        ungetc(c, stdin);

    scanf("%d", &entries);
    if (entries <= 0)
    {
        fprintf(stdout, "Nothing to calculate!\n");
        return EXIT_SUCCESS;
    }
    else
    {
        /* 
         * Error detect for:
         * N more_char_here
         */
        scanf("%*[ \t]");
        c = getchar();
        if (c == EOF)
        {
            fprintf(stderr, "Where are your next lines?\n");
            return EXIT_FAILURE;
        }
        else if (c != '\n')
        {
            fprintf(stderr, "You should not input anything "
                            "behind %d!\n", entries);
            return EXIT_FAILURE;
        }

        /* We need to have a loop for entries time */
        for (i = 0; i < entries; i++)
        {
            /* We get year first, ignoring spaces */
            scanf("%*[ \t]");
            c = getchar();
            if (c == EOF)
            {
                fprintf(stderr, "Where's the %d(th) set of data?\n", i+1);
                return EXIT_FAILURE;
            }
            else if (!isdigit(c))
            {
                fprintf(stderr, "This is not a valid day!\n");
                return EXIT_FAILURE;
            }
            ungetc(c, stdin);
            scanf("%d", &highwing_year);

            /* Now the name (string) for highwing month */
            int m;
            c = getchar();
            if (c != ' ' && c != '\t')
                fprintf(stderr, "Your input format is wrong but we'll " 
                        "proceed anyway.\n");
            scanf("%*[ \t]");

            scanf("%s", highwing_month_name);
            for (m = 0; m <= 13; m++)
            {
                if (strcmp(highwing_month_name, highwing_compare[m]) == 0)
                {
                    /* Array of strings position start from 0 */
                    highwing_month = m;
                    break;
                }
            }
            if (highwing_month == -1)
            {
                fprintf(stderr, "Invalid month name.\n");
                return EXIT_FAILURE;
            }

            /* 
             * Let's now scan the day
             * First we need to make sure that the first character is a digit.
             */
            c = getchar();
            if (c != ' ' && c != '\t')
                fprintf(stderr, "Your input format is wrong but we'll "
                        "proceed anyway.\n");

            scanf("%*[ \t]");
            c = getchar();
            if (!isdigit(c))
            {
                fprintf(stderr, "Invalid input!\n");
                return EXIT_FAILURE;
            }
            else
                ungetc(c, stdin);

            scanf("%d", &highwing_day);

            if (highwing_day > 29)
            {
                fprintf(stderr, "You shouldn't input more than 30 days!\n");
                return EXIT_FAILURE;
            }
            highwing_day++;

            /* 
             * We need to make sure about the boundary values, 
             * In this case, the last day of mike is 20th
             */
            if (highwing_month == 12 && highwing_day > 20)
            {
                fprintf(stderr, "You cannot input 20 or more in day in " 
                        "Mike!\n");
                return EXIT_FAILURE;
            }

            /* ignoreing the spaces afterwards */
            scanf("%*[ \t]");

            /* Make sure that we have a nextline in the end */
            c = getchar();
            if (!(c == '\n'))
            {
                fprintf(stderr, "Nothing behind %d please!", highwing_day);
                return EXIT_FAILURE;
            }
            /* 
             * Once it is all done, we add the current inputs to unify_day.
             * Every Highwing month has 30 days except the last one.
             */
            unify_day = highwing_year * TOTAL_DAYS_PERYR_HIGHWING + highwing_month * 30
                        + highwing_day;

            /* 
             * From unify_day we need to calculate the year for Lowwing calendar
             */
            lowwing_year = unify_day / TOTAL_DAYS_PERYR_LOWWING;
            unify_day -= lowwing_year * TOTAL_DAYS_PERYR_LOWWING;

            /* We need to have lowwing_month at this point. */
            lowwing_month = unify_day / 12;
            unify_day -= lowwing_month * 12;

            if ((unify_day % 12) == 0)
                lowwing_month--;

            /* Now the day */
            lowwing_day = unify_day;

            printf("Highwings %d %s %d\t is\t Lowwings %d %d %s\n", 
                    highwing_year, highwing_month_name, highwing_day - 1,
                    lowwing_year, lowwing_month + 1, 
                    lowwing_day_names[lowwing_day]);
            
            /* Reset all the values which won't be re-assigned from stdin. */
            unify_day = 0;
        }
    }

    return EXIT_SUCCESS;
}