CMPSC 122 Homework 3 tokenlist.cpp

// Token List Implementation file
//
// This tokenizer will scan a character string representing
// an expression, and will return a list of tokens.
// --- only integers and operators are supported (no names)

// The standard C library has some useful functions for us
#include <string.h>
#include <ctype.h>

// And to get the definition of a token:
#include "tokenlist.h"

// TokenList constructor
// converts a character string into a list of tokens
// Parameter:
//  expr    (input char pointer)    // string to examine
// Pre-condition:  str may not be a null pointer
//     and is assumed to actually point at a valid expression.
TokenList::TokenList( const char expr[])
{
    int pos = -1;                           // Iterator for loop
    int pos2;                               // Start of the next token
    int initiationBreak = 0;                // Breaks out of the initiation of the list: 1 means go to tail, 2 means break out of initiation
    int tokenType = 0;
    int newTokenType = 0;
    int number = 0;                             // Number token, used for calculating multidigit integers
    int exprlength = strlen(expr);

    ListElement *newElement;

    newElement = new ListElement;

    head = NULL;
    tail = NULL;

    newElement->next = NULL;

    // Initiation of List
    for (int i = 0; i < exprlength && initiationBreak < 2; i++) {
        switch (expr[i]) {
        case '(':
        case ')':
            newTokenType = 3;       // A 3 indicates parenthesis of some sort
        case '+':
        case '-':
        case '/':
        case '*':
        case '%':
            newTokenType = 1;       // A 1 indicates an operator
            break;
        case ' ':
            newTokenType = 4;       // A 4 indicates a space
            continue;
            break;
        default:                    // A 2 (digit) or a 0 (unknown token type)
            if (isdigit(expr[i])) {
                newTokenType = 2;   // A 2 indicates a digit
            }
        }
        if (newTokenType != tokenType) {    // If the previous token is different
            pos2 = i;                       // (operator -> integer)
            switch (tokenType) {
            case 3:                         // A parenthesis
            case 1:                         // An operator
                if (initiationBreak == 0) {
                    head = newElement;                          // Sets the head of the list
                    newElement->token = Token(expr[pos]);                   // Saves the operator (or parenthesis) token
                    initiationBreak = 1;                        // Proceed to tail creation
                }
                else {
                    newElement = new ListElement();             // Create a new instance of newElement
                    newElement->token = Token(expr[pos]);       // Saves the operator (or parenthesis) token
                    tail = newElement;                          // Sets the tail of the list
                    head->next = tail;                  // Link the head and tail
                    initiationBreak = 2;                        // Proceed to extension of list
                }
                break;
            case 2:                         // A digit
                number = atoi(&expr[pos]);
                if (initiationBreak == 0) {
                    newElement->token = Token(number);          // Saves the integer token
                    head = newElement;                          // Sets the head of the list
                    initiationBreak = 1;                        // Proceeed to tail creation
                    number = 0;                                 // Resets the value of number
                }
                else {
                    newElement = new ListElement();             // Create a new instance of newElement
                    newElement->token = Token(number);          // Saves the integer token
                    tail = newElement;                          // Sets the tail of the list
                    head->next = tail;                  // Link the head and tail
                    initiationBreak = 2;                        // Proceed to extension of list
                    number = 0;                                 // Resets the value of number
                }
                break;
            }
            pos = pos2;
            tokenType = newTokenType;       // Change in type of token
        }
    }

    // Propagation and Termination of List
    for (int i = pos; i < exprlength; i++) {
        switch (expr[i]) {
        case '(':
        case ')':
            newTokenType = 3;       // A 3 indicates parenthesis of some sort
        case '+':
        case '-':
        case '/':
        case '*':
        case '%':
            newTokenType = 1;       // A 1 indicates an operator
            break;
        case ' ':
            newTokenType = 4;       // A 4 indicates a space
            continue;
            break;
        default:
            if (isdigit(expr[i])) {
                newTokenType = 2;   // A 2 indicates a digit
            }
        }
        if (newTokenType != tokenType) {    // If the previous token is different
            pos2 = i;                       // (operator -> integer)
            switch (tokenType) {
            case 3:                         // A parenthesis
            case 1:                         // An operator
                newElement = new ListElement();             // Create a new instance of newElement
                newElement->token = Token(expr[pos]);           // Saves the operator (or parenthesis) token
                newElement->next = NULL;                    // Sets the end next pointer to NULL
                tail->next = newElement;                    // The tail now points to newElement (will become the second to last element in the list)
                tail = newElement;                          // Tail becomes newElement
                break;
            case 2:                         // A digit
                number = atoi(&expr[pos]);
                newElement = new ListElement();             // Create a new instance of newElement
                newElement->token = Token(number);          // Saves the integer token
                newElement->next = NULL;                    // Sets the end next pointer to NULL
                tail->next = newElement;                    // The tail now points to newElement (will become the second to last element in the list)
                tail = newElement;                          // Tail becomes newElement
                number = 0;
                break;
            }
            pos = pos2;
            tokenType = newTokenType;
        }
        else if (newTokenType == 1 && tokenType == 1) { // Accounts for two consecutive operators
            pos2 = i;
            newElement = new ListElement();             // Create a new instance of newElement
            newElement->token = Token(expr[pos]);           // Saves the operator (or parenthesis) token
            newElement->next = NULL;                    // Sets the end next pointer to NULL
            tail->next = newElement;                    // The tail now points to newElement (will become the second to last element in the list)
            tail = newElement;                          // Tail becomes newElement
            pos = pos2;
            tokenType = newTokenType;
        }
    }

    // Sets the last element of the list
    switch (tokenType) {
        case 3:
        case 1:                         // An operator
            newElement = new ListElement();             // Create a new instance of newElement
            newElement->token = Token(expr[pos]);           // Saves the operator (or parenthesis) token
            newElement->next = NULL;                    // Sets the end next pointer to NULL
            tail->next = newElement;                    // The tail now points to newElement (will become the second to last element in the list)
            tail = newElement;                          // Tail becomes newElement
            break;
        case 2:                         // A digit
            number = atoi(&expr[pos]);
            newElement = new ListElement();             // Create a new instance of newElement
            newElement->token = Token(number);          // Saves the integer token
            newElement->next = NULL;                    // Sets the end next pointer to NULL
            tail->next = newElement;                    // The tail now points to newElement (will become the second to last element in the list)
            tail = newElement;                          // Tail becomes newElement
            number = 0;
            break;
    }
}

//  output operation
//  Display all of the tokens in the list
ostream& operator<<( ostream &stream, TokenList &t )
{
    for (ListIterator iter = t.begin(); iter != t.end(); iter.advance())
    {
    stream << iter.token() << " ";
    }
    return stream;
}

//  Creates an iterator to refer to the beginning of the list
ListIterator TokenList::begin()
{
    return ListIterator( this, head );
}

//  Creates an iterator to refer after the end of the list
//  This list is simple:  it ends with NULL
ListIterator TokenList::end()
{
    return ListIterator( this, NULL );
}

//  Add a new element to the back of the list
//  Parameter:
//       t  (input Token)   the new item to add
void TokenList::push_back(Token t)
{



}

//  Add a new element to the front of the list
//  Parameter:
//       t  (input Token)   the new item to add
void TokenList::push_front(Token t)
{




}

//  Remove and return the element at the front of the list
Token TokenList::pop_front()
{


    return NULL;            // Temporary, ya dangus

}