Issue with simple bool function

[jollygnome123]

Hey, I'm sure that given enough time I'll simply find the very stupid mistake I've made, but I was wondering if anyone could tell me where I'm screwing up on this and maybe a duct-tape fix? (Haha)

main.cpp

#include<iostream>
#include<fstream>
#include<string>
#include<vector>
#include<cmath>
#include<cstdlib>
#include "lexer.h"

using namespace std;

//How to make a vector matrix:
// vector<vector<type>> name

string trim(string x)
{
    x = x.substr(1, (x.size()-1));
    return x;
}

bool hasParentheses(string x)
{
    if((x.at(0) == '(') && (x.at(x.size()-1) == ')'))
        return true;
    else
        return false;
}

void display(vector<Token> x)
{
    for(int i = 0; i < x.size(); i++)
        cout << x[i].value << "\t";
}

void display(vector< vector<Token> > x)
{
    for(int i = 0; i < x.size(); i++)
    {
        for(int j = 0; j < x[i].size(); j++)
        {
            cout << x[i][j].value << "\t";
        }
        cout << endl;
    }
}

int main()
{
    //Variables
    Token tok;
    Lexer lex;
    string input;

    // "display" variables
    string file;
    string sortedBy;
    char* offnen;
    fstream doc;
    int numColumns;
    vector<string> categories;
    Token tok2;
    vector< vector<Token> > docMatrix;
    vector<Token> columns;
    vector< vector<Token> > temptrix;
    //Needs to be a vector or it can't be pushed onto the vector matrix
    vector<Token> * line;

    ////////////////////////////////////////////////////////////
    //              MAIN MENU
    ////////////////////////////////////////////////////////////
    while(true)
    {
        cout << ">";
        getline(cin, input);

        lex.set_input(input);
        tok = lex.next_token();

        if(tok.value == "display")
        {
            file = lex.next_token().value;
            cout << file << endl;
            if(lex.next_token().value != "sortedby")
                goto bad;
            sortedBy = lex.next_token().value;
            cout << sortedBy << endl;
            offnen = (char*) file.c_str();
            doc.open(offnen);
            while(!doc.eof())
            {
                getline(doc, input);
                lex.set_input(input);


                //Potential for error IF:
                //There is anything else with parentheses
                while(lex.has_more_token())
                {
                    //Error here
                    while(true)
                    {
                        tok = lex.next_token();
                        tok2 = lex.next_token();
                        if(hasParentheses(tok2.value) == true) // <-- Error here!
                        //{
                            //columns.push_back(tok);
                            //numColumns++;
                        //}
                        //else
                            break;
                    }

                    lex.next_token();
                    //docMatrix.push_back(columns);

                    /*
                    while(lex.has_more_token())
                    {
                        //tok = lex.next_token();
                        line = new vector<Token>;
                        for(int i = 0; i < numColumns; i++)
                        {
                            tok = lex.next_token();
                            line->push_back(tok);
                        }
                        docMatrix.push_back((*line));
                    }
                    */
                }
            }

            display(docMatrix);
        }
        else if(tok.value == "nljoin")
        {

        }
        else if(tok.value == "smjoin")
        {

        }
        else if(tok.value == "exit")
        {
            break;
        }
        else
        {
            bad:
            cout << "Incorrect input" << endl;
        }
    }

    return 0;
}


//Code for potential reuse
/*
                        //traverses from row 1 to end
                        for(int i = 1; i < docMatrix.size(); i++)
                        {
                            if(docMatrix[i].size() < columns)
                            {
                                docMatrix[i].push_back(tok);
                                break;
                            }
                        }
                        //Now do it again, but this time for tok2
                        for(int i = 1; i < docMatrix.size(); i++)
                        {
                            if(docMatrix[i].size() < columns)
                            {
                                docMatrix[i].push_back(tok2);
                                break;
                            }
                        }
*/

/*

            //Now vector matrix should be filled with tokens
            //so let's display it

            for(int i = 0; i < docMatrix.size(); i++)
            {
                for(int j = 0; j < docMatrix[i].size(); j++)
                    cout << docMatrix[i][j].value << "\t";
                cout << endl;
            }

            doc.close();
*/

And here's the lexer class:

/**
 * *****************************************************************************
 * file name : Lexer.cpp
 * author    : Hung Q. Ngo
 * description: implementation of Lexer interface
 * *****************************************************************************
 */
#include "Lexer.h"
#include <iostream>
using namespace std;

/**
 * -----------------------------------------------------------------------------
 *  scan and return the next token
 *  cur_pos then points to one position right past the token
 *  the token type is set to ERRTOK on error, at that point the global state
 *  variable err will be set to true
 * -----------------------------------------------------------------------------
 */
Token Lexer::next_token() {
    Token ret;
    size_t last;

    if (in_err) {
        ret.type = ERRTOK;
        ret.value = "";
        return ret;
    }

    // if not in error state, the default token is the ENDTOK
    ret.type = ENDTOK;
    ret.value = "";

    if (has_more_token()) {
        last = cur_pos; // input_str[last] is a non-space char
        if (input_str[cur_pos] == '"') {
            cur_pos++;
            while (cur_pos < input_str.length() && input_str[cur_pos] != '"')
                cur_pos++;
            if (cur_pos < input_str.length()) {
                ret.type = STRING;
                ret.value = input_str.substr(last+1, cur_pos-last-1);
                cur_pos++; // move past the closing "
            } else {
                in_err = true;
                ret.type = ERRTOK;
                ret.value = "";
            }
        } else {
            while (cur_pos < input_str.length() &&
                   separators.find(input_str[cur_pos]) == string::npos &&
                   input_str[cur_pos] != '"') {
                cur_pos++;
            }
            ret.type  = IDENT;
            ret.value = input_str.substr(last, cur_pos-last);
        }
    }
    return ret;
}

/**
 * -----------------------------------------------------------------------------
 *  set a new input string, restart
 * -----------------------------------------------------------------------------
 */
void Lexer::set_input(string str) {
    input_str = str;
    restart();
}

/**
 * -----------------------------------------------------------------------------
 * -----------------------------------------------------------------------------
 */
bool Lexer::has_more_token() {
    while (cur_pos < input_str.length() && 
           separators.find(input_str[cur_pos]) != string::npos) {
        cur_pos++;
    }
    return (cur_pos < input_str.length());
}

/**
 * -----------------------------------------------------------------------------
 *  restart from the beginning, reset error states
 * -----------------------------------------------------------------------------
 */
void Lexer::restart() {
    cur_pos = 0;
    in_err = false;
}

The Lexer is provided by my instructor, so I don't intend to edit that. I just can't seem to figure out what I'm doing wrong.

[therockon7throw]

Hi

Could you specify and make clear where you have a problem and what does not work ?

by the way you may simplify your bool hasParentheses(string x) as

bool hasParentheses(const string& x){

	return x[0] == '(' && x[ x.size() - 1 ] == ')';
}

[jollygnome123]

Haha, well I edited my hasParentheses function anyway so that's all working now, but why the const and the string&? I almost never use those, so what's the advantage?