main.cpp.save-failed

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <string>
using namespace std;

class Node
{
public:
    string value;
    Node *child;
    Node *parent;

private:

};

Node packageNode;
Node importNode;

string x;
string result;
int counter;
string leaf;

int parsePackage();
int parseImport();
int parseFunc();
int parseBody();
int parseConst();
int parseVar();

int parseVar()
{
    int varCounter = 1+parseBody();
    while(iswspace(x[varCounter]) || x[varCounter] == '{' || x[varCounter] == '}')
    {
        varCounter++;
    }

    if(isalnum(x[varCounter]))
    {
        int q = varCounter;
        string varName;
        cout << "I am printing from inside 'parseVar()'"<< endl;
        for(int i = q; !iswspace(x[i]) && x[i] != '}'; i++)
        {
            varName = varName + x[i];
            counter = i;
        }
        cout << "var--> " << varName << endl;
        leaf = "var";
        return counter;
    }
    else
    {
        cout << "Error: invalid syntax"<< endl;
    }
    return 0;

}

int parseConst()
{
    int constCounter = 1+parseBody();
    while(iswspace(x[constCounter]) || x[constCounter] == '{' || x[constCounter] == '}')
    {
        constCounter++;
    }

    if(isalnum(x[constCounter]) && x.substr(constCounter, 5) == "const")
    {
        int n = constCounter;
        string constName;
        cout << "I am printing from inside 'parseConst()'"<< endl;
        for(int i = n; !iswspace(x[i]) && x[i] != '}'; i++)
        {
            constName = constName + x[i];
            counter = i;
        }
        cout << "const--> " << constName << endl;
        leaf = "const";
        return counter;
    }
    else
    {
        parseVar();
        cout << "Error: invalid syntax"<< endl;
    }
    return 0;
}

int parseBody()
{
    int bodyCounter = 1 + parseFunc();
    while(iswspace(x[bodyCounter]) || x[bodyCounter] == '{' || x[bodyCounter] == '}')
    {
        bodyCounter++;
    }
    cout << bodyCounter << endl;

    if(x.substr(bodyCounter, 5) == "const" && leaf != "const")
    {
        return bodyCounter+4;
    }
    else if(x.substr(bodyCounter, 3) == "var" && leaf != "var")
    {
        return bodyCounter+2;
    }
    else
    {
        cout << "Error: invalid syntax" << endl;

    }
    return 99;

}

int parseFunc()
{
    int funcCounter = 1 + parseImport();
    while(iswspace(x[funcCounter]))
    {
        funcCounter++;
    }
    cout << funcCounter << endl;

    if(x.substr(funcCounter, 4) == "func")
    {
        funcCounter = funcCounter + 4;
        while(iswspace(x[funcCounter]))
        {
            funcCounter++;
        }
        int j = funcCounter;
        string funcName;
        cout << "I am printing from inside 'parseFunc()'"<< endl;
        for(int i = j; !iswspace(x[i]); i++)
        {
            funcName = funcName + x[i];
            counter = i;
        }
        cout << "func--> " << funcName << endl;
        return counter;
    }
    else
    {
        cout << "Error: invalid syntax"<< endl;
    }
    return 0;
}

int parseImport()
{
    int importCounter = 1 + parsePackage();
    while(iswspace(x[importCounter]))
    {
        importCounter++;
    }
    cout << importCounter << endl;

    if(x.substr(importCounter, 6) == "import")
    {
        importCounter = importCounter + 6;
        while(iswspace(x[importCounter]))
        {
            importCounter++;
        }
        int k = importCounter;
        string importName;
        cout << "I am printing from inside 'parseImport()'"<< endl;
        for(int i = k; !iswspace(x[i]) && x[i] != '('; i++)
        {
            importName = importName + x[i];
            counter = i;
        }
        cout << "import--> " << importName << endl;
        return counter;
    }
    else
    {
        cout << "Error: invalid syntax"<< endl;
    }
    return 0;
}

int parsePackage()
{
    if(x.substr(0,7) == "package") //find subset of string, compare to target string (i.e. 'package')
    {
        int packageCounter = 7;
        cout << "I am printing from inside 'parsePackage()'"<< endl;
        while(iswspace(x[packageCounter]))
        {
            packageCounter++;
        }

        for(int i = packageCounter; !iswspace(x[i]); i++)
        {
            result = result + x[i];
            counter = i;
        }
        cout << "package--> " << result << endl;
        packageNode.value = result;
        packageNode.child = &importNode;
        return counter;
    }
    else
    {
        cout << "Error: invalid syntax"<< endl;
    }
    return 0;
}

int main()
{
    //x = "package main\n";
    x = "package main\nimport \"fmt\"\nfunc main()\n{\nvar Pi = 50\n}";
    //x = "package main\nimport \"fmt\"\nfunc main()\n{\n\tprintln(\"helloworld\")\n}";
    //x = "package main\nfunc main()\n{\n\tprintln(\"helloworld\")\n}";
    int result = parseVar();
    cout << "\n\n\npackageNode's value-->" << packageNode.value << endl;
    cout << "\n\n\npackageNode's child-->" << importNode.child << endl;
    return 0;
}

/*TODO*/
//the possibility of more than one import
//parse variable types?
//allow for whitespace before package?
//parseVar and ParseConst as normal, like other functions, return as though skiping over the function

//parse whitespace, don't just +1 the counter!

//build generic node class, have nodes for each part e.g. packageNode, importNode etc., then create node in each respective function, thus tree?