Structuring_The_Document

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#define MAX_CHARACTERS 1005
#define MAX_PARAGRAPHS 5

struct word {
    char* data;
};

struct sentence {
    struct word* data;
    int word_count;//denotes number of words in a sentence
};

struct paragraph {
    struct sentence* data  ;
    int sentence_count;//denotes number of sentences in a paragraph
};

struct document {
    struct paragraph* data;
    int paragraph_count;//denotes number of paragraphs in a document
};
typedef struct
{
    struct word curr_word;
    struct sentence curr_sentence;
    struct paragraph curr_para;
    struct document curr_doc;
} CompountStructType;


void end_word(CompountStructType *p)
{
    struct word* curr_word = &p->curr_word;
    struct sentence* curr_sentence = &p->curr_sentence;

    // Add the current word to the sentence, making space for it - if there is a word
    if (curr_word->data)
    {
        curr_sentence->data = realloc(curr_sentence->data, (1 + curr_sentence->word_count) * sizeof(struct word));
        curr_sentence->data[curr_sentence->word_count] = *curr_word;
        curr_sentence->word_count++;

        // Clear down current word
        curr_word->data = NULL;
    }
}

void end_sentence(CompountStructType* p)
{
    struct sentence* curr_sentence = &p->curr_sentence;
    struct paragraph* curr_para = &p->curr_para;

    // Add the current sentence to the paragraph, making space for it - if there is a sentence
    if (curr_sentence->data)
    {
        curr_para->data = realloc(curr_para->data, (1 + curr_para->sentence_count) * sizeof(struct sentence));
        curr_para->data[curr_para->sentence_count] = *curr_sentence;
        curr_para->sentence_count++;

        // Clear down current sentence
        curr_sentence->data = NULL;
        curr_sentence->word_count = 0;
    }
}

void end_paragraph(CompountStructType *p)
{
    struct paragraph* curr_para = &p->curr_para;
    struct document* curr_doc = &p->curr_doc;

    // Add the current paragraph to the document, making space for it - if there is a paragraph
    if (curr_para->data)
    {
        curr_doc->data = realloc(curr_doc->data, (1 + curr_doc->paragraph_count) * sizeof(struct paragraph));
        curr_doc->data[curr_doc->paragraph_count] = *curr_para;
        curr_doc->paragraph_count++;

        // Clear down current paragraph
        curr_para->data = NULL;
        curr_para->sentence_count = 0;
    }
}


struct document get_document(char* text) {

    CompountStructType data = { 0 };

    while (*text != '\0')
    {
        switch (*text)
        {
        case '\n':
            // End of word, sentence and paragraph
            *text = '\0';   // Close off current word
            end_word(&data);
            end_sentence(&data);
            end_paragraph(&data);
            break;

        case '.':
            // End of word and end of sentence.  
            *text = '\0';   // Close off current word
            end_word(&data);
            end_sentence(&data);
            break;

        case ' ':
            // End of word
            *text = '\0';   // Close off current word
            end_word(&data);
            break;

        default:
            if (!data.curr_word.data)
            {
                // Start current word here since we have text which is not a special character
                data.curr_word.data = text;
            }
            break;
        }
        text++;
    }

    // Finish up any word, sentence and paragraph which was pending
    end_word(&data);
    end_sentence(&data);
    end_paragraph(&data);

    return data.curr_doc;   // return byval
}

struct word kth_word_in_mth_sentence_of_nth_paragraph(struct document Doc, int k, int m, int n) {
    return Doc.data[n-1].data[m-1].data[k-1];
}

struct sentence kth_sentence_in_mth_paragraph(struct document Doc, int k, int m) {
    return Doc.data[m-1].data[k-1];
}

struct paragraph kth_paragraph(struct document Doc, int k) {

    return Doc.data[k-1];
}