Segmentation fault with cout<<endl

[Neber]

For some reason when i put cout<<endl i'm getting segmentation faults in my Parser code. It's really weird some inputs of strings using cout is already faulting. However sometimes printf doesn't fault, but sometimes it will, it seems really unstable.

The court can basically be anywhere in the Parse(string) function, i have a cout at line 254 which faults.

Here is the code:

Parser.cpp

/* 
 * File:   Parser.cpp
 * Author: Daniel Rigby
 * 
 * Created on December 23, 2014, 10:23 AM
 */

#include "Parser.h"
#include <stdio.h>
#include <iostream>

using namespace std;

Parser::Parser()
{
    data = "";
    parseTree = 0;
    lineCount = 0;
}

Parser::Parser(string newData)
{
    data = newData;
    parseTree = 0;
    lineCount = 0;
}

Parser::~Parser()
{
    data = '\0';
    delete parseTree;
    delete lineCount;
}
void Parser::loadData(string newData)
{
    data = newData;
}
//Parses the local string data and returns as a Parse Tree
//Probably faster to do with linked list, for future implementations
//Also can create a functions or possibly new class to handle repeititve code
//for each check
ParseTree* Parser::parse()
{
    parseTree = new ParseTree();
    lineCount = new ParseTree();
    ParseNode* node, *newNode, *curCountNode, *countNode;
    int parseCount = 0;
    string* curString = new string("");
    //Count Number of lines, number of parse elements
    for(int i = 0; i < data.length(); i++)
    {
        char cur = data.at(i);
        //check for delimiter and start string again if found
        for(int j = 0; j < DELIMITERS_LENGTH; j++)
        {
            if(cur == DELIMITERS[j])
            {
                if(curString->length() > 0)
                    parseCount+= 2;
                else
                    parseCount++;
                *curString = "";
                continue;
            }     
        }
        //check for operator
        for(int j = 0; j < OPERATORS_LENGTH; j++)
        {
            if(cur == OPERATORS[j])
            {
                if(curString->length() > 0)
                    parseCount+= 2;
                else
                    parseCount++;
                *curString = "";
                continue;
            }     
        }
            //check for operator
        for(int j = 0; j < SYMBOLS_LENGTH; j++)
        {
            if(cur == SYMBOLS[j])
            {
                if(curString->length() > 0)
                    parseCount+= 2;
                else
                    parseCount++;
                *curString =  "";
                continue;
            }     
        }
        if(cur == ' ')
        {
            if(node->getSymbol() != '\"')
            {
                if(curString->length() > 0)
                    parseCount+= 2;
                else
                    parseCount++;
                *curString =  "";
                continue;
            }
        }
        //encounter new line just prevent code from appending the newline
        if(cur == '\n')
            continue;
        //continue appending characters to string as no checks were hit
        char appendString[1] = {cur};
        *curString += appendString;
        
    }
    
    //Parse string data into parse tree
    for(int i = 0, count = 1; i < data.length(); i++)
    {
        bool doContinue = false;
        char cur = data.at(i);
        //check for delimiter and start string again if found
        for(int j = 0; j < DELIMITERS_LENGTH; j++)
        {
            if(cur == DELIMITERS[j])
            {
                if(!curString->empty())
                {
                    countNode = new ParseNode(count);
                    newNode = new ParseNode(*curString);
                    parseTree->insertLeft(node, newNode);
                    this->lineCount->insertLeft(curCountNode, countNode);
                    node = newNode;
                    curCountNode = countNode;
                }
                
                countNode = new ParseNode(count);
                newNode = new ParseNode(cur);
                parseTree->insertLeft(node, newNode);
                this->lineCount->insertLeft(curCountNode, countNode);
                node = newNode;
                curCountNode = countNode;
                *curString = "";
                doContinue = true;
                printf("Inserting character: %c\n", cur);
                break;
            }     
        }
        if(doContinue)
        {
            doContinue = false;
            continue;
        }
        //check for operator
        for(int j = 0; j < OPERATORS_LENGTH; j++)
        {
            if(cur == OPERATORS[j])
            {
                if(!curString->empty())
                {
                    countNode = new ParseNode(count);
                    newNode = new ParseNode(*curString);
                    parseTree->insertLeft(node, newNode);
                    this->lineCount->insertLeft(curCountNode, countNode);
                    node = newNode;
                    curCountNode = countNode;
                }
                countNode = new ParseNode(count);
                newNode = new ParseNode(OPERATORS[j]);
                parseTree->insertLeft(node, newNode);
                this->lineCount->insertLeft(curCountNode, countNode);
                node = newNode;
                curCountNode = countNode;
                *curString = "";
                doContinue = true;
                break;
            }     
        }
        if(doContinue)
        {
            doContinue = false;
            continue;
        }
            //check for symbols
        for(int j = 0; j < SYMBOLS_LENGTH; j++)
        {
            if(cur == SYMBOLS[j])
            {
                
                if(!curString->empty())
                {
                    countNode = new ParseNode(count);
                    newNode = new ParseNode(*curString);
                    parseTree->insertLeft(node, newNode);
                    this->lineCount->insertLeft(curCountNode, countNode);
                    node = newNode;
                    curCountNode = countNode;
                }
                countNode = new ParseNode(count);
                newNode = new ParseNode(SYMBOLS[j]);
                parseTree->insertRight(node, newNode);
                this->lineCount->insertRight(curCountNode, countNode);
                node = newNode;
                curCountNode = countNode;
                *curString = "";
                doContinue = true;
                printf("Inserting character: %c\n", cur);
                break;
            }     
        }
        if(doContinue)
        {
            doContinue = false;
            continue;
        }
        if(cur == ' ')
        {
            if(node->getSymbol() == '\"')
            {
                if(curString->length() > 0)
                {
                    countNode = new ParseNode(count);
                    newNode = new ParseNode(*curString);
                    parseTree->insertLeft(node, newNode);
                    this->lineCount->insertLeft(curCountNode, countNode);
                    node = newNode;
                    curCountNode = countNode;
                }
                newNode = new ParseNode(' ');
                countNode = new ParseNode(count);
                parseTree->insertLeft(node, newNode);
                this->lineCount->insertLeft(curCountNode, countNode);
                node = newNode;
                curCountNode = countNode;
                *curString = "";
                doContinue = true;
                break;
            }
        }
        if(doContinue)
        {
            doContinue = false;
            continue;
        }
        //encounter new line just prevent code from appending the newline
        if(cur == '\n')
        {
            count++;
            continue;
        }
        //continue appending characters to string as no checks were hit
        char appendString[1] = {cur};
        printf("Current char: %s\n", appendString);
        *curString += appendString;
        cout<<appendString<<"\n";

    }
    cout<<"WHY SEGMENTATION FAULT"<<endl;
    return parseTree;
}
ParseTree* Parser::parse(string newData)
{
    ParseTree* parseTree = new ParseTree();
    
    return parseTree;
}

[HalfNOoB]

Hei Neber

Would you mind posting the original error message? :)

The most common Segmentation fault I get is when dereferencing a NULL pointer...

Segmentation fault is a specific kind of error caused by accessing memory that “does not belong to you.” It’s a helper mechanism that keeps you from corrupting the memory and introducing hard-to-debug memory bugs. Whenever you get a segfault you know you are doing something wrong with memory – accessing variable that has already been freed, writing to a read-only portion of the memory, etc.

[Neber]

The error message was: Segmentation Fault 11. That's all i can remember since now i've fixed the code but don't know what exactly fixed it except having clean code. Even though it's fixed i'd still like to know what caused the fault in the above code though.

I've now moved the repetitous code into a new ParseBlock class and this has cleaned up the code and removed the instability in the program so i can now cout and what not wherever i want in that code.

[MiiNiPaa]

        char appendString[1] = {cur};
        printf("Current char: %s\n", appendString);
        *curString += appendString;
        cout<<appendString<<"\n";

This alone is enought to trigger undefined behavior (which can lead to anything)
You have a c-string without terminating 0.
Both printf and cout statements will output values of consequitive memory cells until it hits 0.
If there is 0 before uninitialized memory, everything is fine. else you have a crash.

Also you have many leaks here.