Polish postfix pseudo

Constanta Caracter SUCCESS <- 0

Constanta Caracter NATURAL_NUMBER <- 'N'
Constanta Caracter LETTER <- 'L'


Polish_expr
        Sir expr
        Intreg value

Data
        Caracter type
        Intreg value


subprogram calculator(Sir string)

    /* The polish expr. */
    Polish_expr  result

    Stack  s

    Sir  token, expr

        /* Used for storing parsed token. */
    Data  input

    /* Statistic used for validation of *expr*
     * and error reporting.
     */
    Caracter  last_operation
        Intreg  err

        last_operation <- '\0'
        err <-0


        Intreg  index, j
        index <- 0

    /* While there's more of the string to process. */
    cat timp  string[index] AND !err


            /* Skip white space. */
            cat timp  string[index] AND strchr(" \t\n", string[index])
                    index++
            sf_cattimp


            /* Get token. */
            j <- 0

            cat timp  string[index] AND !strchr(" \t\n", string[index])
                token[j++] <- string[index++]
            sf_cattimp
            /* GOT token! */


            /* Get data from token. */
            input <- parse_token(token)


            /* If it's a natural number, push it on the stack. */
            daca  input.type = NATURAL_NUMBER
                push(st, input.value)


                /* Forming of expr. */
                strncat(expr, token, strlen(token))
                strncat(expr, " ", 1)
            sf_daca

            altfel daca  input.type = LETTER
                /* Operate */

                daca input.value = '+'
                    daca  SUCCESS != stackOperate(st, add, input.value) // add(Intreg a, b) returneaza a + b;
                        err++
                    sf_daca

                    last_operation <- input.value


                    /* Forming of expr. */
                    strncat(expr, token, strlen(token))
                    strncat(expr, " ", 1)


                altfel daca  input.value = '-'
                    daca  SUCCESS != stackOperate(st, substract, input.value) // substract(Intreg a, b) returneaza a - b;
                        err++
                    sf_daca

                    last_operation <- input.value


                    /* Forming of expr. */
                    strncat(expr, token, strlen(token))
                    strncat(expr, " ", 1)
                sf_altfeldaca


                altfel daca  input.value = '*'
                    daca  SUCCESS != stackOperate(st, multiply, input.value) // multiply(Intreg a, b) returneaza a * b;
                        err++
                    sf_daca

                    last_operation <- input.value


                    /* Forming of expr. */
                    strncat(expr, token, strlen(token))
                    strncat(expr, " ", 1)
                sf_altfeldaca



                altfel daca  input.value = '/'
                    daca  SUCCESS != stackOperate(st, divide, input.value) // divide(Intreg a, b)
                        err++                                              //     daca  a = 0
                    sf_daca                                                //        *afisare mesaj de eroare
                                                                           //        *iesire din program
                    last_operation <- input.value                          //     returneaza a / b


                    /* Forming of expr. */
                    strncat(expr, token, strlen(token))
                    strncat(expr, " ", 1)
                sf_altfeldaca


                altfel daca  input.value = '%'                           // mod(Intreg a, b)
                    daca  SUCCESS != stackOperate(st, mod, input.value)  //     daca  a = 0
                        err++                                            //        *afisare mesaj de eroadre
                    sf_daca                                              //        *iesire din program
                                                                         //     returneaza a % b
                    last_operation <- input.value


                    /* Forming of expr. */
                    strncat(expr, token, strlen(token))
                    strncat(expr, " ", 1)

                sf_altfeldaca

                altfel
                    Afiseaza [Error] Undefinded operator: token.

                    err++
                sf_altfel
                sf_daca
            sf_altfeldaca

            altfel daca  token[0]
                /* If token is !natural_number, !letter and !empty : bad input! */

                Afiseaza [Error] Bad input: token.
                err++
            sf_altfeldaca
            sf_daca
        sf_cattimp


    /* If there were operands, but no operation(s). */
    daca  !err AND !last_operation AND !isEmpty(st)
            Afiseaza [Error] Please provide an operation.
            err++
        sf_daca


    /* If too many operands were given. */
    daca  !err AND last_operation AND heightOf(st) > 1
            err_op_arity(last_operation)
            err++
        sf_daca


    /* If err OR if input was null, show USAGE message. */
        daca  err OR !last_operation
            Afiseaza Usage: a b [+-*/] | long a, b.

            return { NULL, 0 }
        sf_daca


    /* Remove trailing [space]. */
    expr[strlen(expr)] <- '\0'

    result.expr = expr
        result.value =  pop(st)

    return result
}


subprogram parse_token(Sir token)

    data d

    long long value <- 0
    char type <- '0'


    /* Convert token to long. */
        value <- strtol_(token) // strtol_ conversteste Sir in Intreg, verificand errori de input
                                // si ignorand spatii(si 0-uri) nesemnificative. Returneaza -1 in caz de eroare.

    daca value >= 0
        type <- NATURAL_NUMBER
    sf_daca

    /* We're dealing with non-numbers/negative numbers then. */
    altfel daca strlen(token) = 1 {
        type <- LETTER
        value <- token[0
    }

    /* Else not a number, nor a single letter. */

    d.value <- value
    d.type <- type

    return d

#sf_subprogram


subprogram stackOperate(Stack *s, Intreg operator, Caracter symbol) // Intreg operator este functie.

    daca heightOf(s) < 2
        err_op_arity(symbol)

        retureaza -1
    sf_daca

    Intreg termL, termR, result

    termR <- pop(s)
    termL <- pop(s)

    daca  (symbol = '/' OR symbol = '%') AND termR = 0
        afiseaza [Error] Ilegal operation; trying to symbol by 0: "termL termR symbol"

        returneaza DOMAIN_ERR
    sf_daca

    result <- operator(termL, termR)
    push(s, result)

    returneaza SUCCESS

#sf_subprogram


procedura err_op_arity(char op)

    afiseaza [Error] The "op" operator takes two operands: "a b op" | long a, b.

#sf_procedura