Words.c

Go to the documentation of this file.

// word cluster
//
//  top        bottom     type
// vertex      vertex    vertex
//      o=========o========o
//
//
//
// a top vertex of the word layer
//
//               all
//         previous and next
// next      one-letter      one-word
// word ^       words      ^  phrase
//      |         V        |
//      o=========o========o
//      ^                  ^
//      |                  |
//   previous             word
//     word               type
//
//
//
//  the low border of the word layer
//
//               all
//         previous and next
//            one-letter
//              words
//                V
//      o=========o========o
//      ^                  ^
//      |                  |
//   binary               word
//    code                type
//
 
#include <stdlib.h>
#include "errors.h"
#include "Graph.h"
#include "Binary.h"
#include "Utf8.h"
 
#include <stdio.h>
 
#define WORD_CLUSTER_LENGTH 3
#define BUFFER_LENGTH 256 // No large alphabets, no large dictionaries, because otherwise either no sense or no time. It's the natural constraint on the mind. Many cultures and many people and many contextual meanings of one word are nessecary. Degradation follows too much of unavoidable unification.
 
struct Words {
    struct Binary *binary;  
    struct Utf8 *utf8;      
    struct Graph *graph;    
    unsigned int wordType;  
};
 
struct Words* Words_construct(unsigned int wordType, struct Binary *binary, struct Utf8 *utf8, struct Graph *graph, int *error)
{
    struct Words *this = malloc(sizeof(struct Words));
 
    if (0 == this) {
        *error = ERROR_NO_MEMORY;
        return 0;
    }
 
    this->binary = binary;
    this->utf8 = utf8;
    this->graph = graph;
    this->wordType = wordType;
 
    return this;
}
 
struct Words* Words_destruct(struct Words *this)
{
    if (0 != this) {
        Binary_destruct(this->binary);
        Utf8_destruct(this->utf8);
        free(this);
    }
 
    return 0;
}
 
unsigned int Words_writeWord(struct Words *this, unsigned int length, unsigned int *characters, int *error)
{
    unsigned int bottoms[BUFFER_LENGTH];
    unsigned int wordCluster[WORD_CLUSTER_LENGTH];
    unsigned int typeVertex = 0;
 
    if (length > BUFFER_LENGTH) {
        *error = ERROR_WORD_TOO_LONG;
        return 0;
    }
 
    // connect binary codes to single-letter words
 
    for (unsigned int offset = length; offset > 0; offset--) {
 
        unsigned int index = offset - 1;
 
        unsigned int characterCode = Binary_writeCode(this->binary, characters[index], error);
 
        if (*error) {
            return 0;
        }
 
        unsigned int wordClusterStart = Graph_readLastTarget(this->graph, characterCode, error);
 
        if (*error) {
            return 0;
        }
 
 
        if (0 == wordClusterStart) {
 
            Graph_addCluster(this->graph, WORD_CLUSTER_LENGTH, wordCluster, error);
 
            if (*error) {
                return 0;
            }
 
            Graph_addEdge(this->graph, characterCode, wordCluster[0], error);
 
            if (*error) {
                return 0;
            }
 
            Graph_addEdge(this->graph, this->wordType, wordCluster[2], error);
 
            if (*error) {
                return 0;
            }
 
        } else {
 
            Graph_readCluster(this->graph, wordClusterStart, WORD_CLUSTER_LENGTH, wordCluster, error);
 
            if (*error) {
                return 0;
            }
        }
 
        bottoms[index] = wordCluster[1];
    }
 
    // build the word pyramid
 
    if (1 == length) {
        typeVertex = wordCluster[2];
    }
 
    unsigned int targets[BUFFER_LENGTH];
    unsigned int sources[BUFFER_LENGTH];
 
    for (unsigned int last = length - 1; last > 0; last--) {
 
        for (unsigned int current = 1; current <= last; current++) {
            
            unsigned int previous = current - 1;
 
            unsigned int targetCount = Graph_countTargets(this->graph, bottoms[previous], error);
 
            if (*error) {
                return 0;
            }
 
            if (targetCount > BUFFER_LENGTH) {
                *error = ERROR_WORD_TOO_RICH;
                return 0;
            }
 
            unsigned int sourceCount = Graph_countSources(this->graph, bottoms[current], error);
 
            if (*error) {
                return 0;
            }
 
            if (sourceCount > BUFFER_LENGTH) {
                *error = ERROR_WORD_TOO_RICH;
                return 0;
            }
 
            Graph_readTargets(this->graph, bottoms[previous], BUFFER_LENGTH, targets, error);
 
            if (*error) {
                return 0;
            }
 
            Graph_readSources(this->graph, bottoms[current], BUFFER_LENGTH, sources, error);
 
            if (*error) {
                return 0;
            }
 
            unsigned int common = 0;
 
            for (unsigned int targetIndex = 0; targetIndex < targetCount; targetIndex++) { // TODO: perhapse, check intersection after ordering
                for (unsigned int sourceIndex = 0; sourceIndex < sourceCount; sourceIndex++) {
                    if (targets[targetIndex] == sources[sourceIndex]) {
                        common = targets[targetIndex];
                        break;
                    }
                }
            }
 
            if (0 == common) {
 
                Graph_addCluster(this->graph, WORD_CLUSTER_LENGTH, wordCluster, error);
 
                if (*error) {
                    return 0;
                }
 
                Graph_addEdge(this->graph, this->wordType, wordCluster[2], error);
 
                if (*error) {
                    return 0;
                }
 
                Graph_addEdge(this->graph, bottoms[previous], wordCluster[0], error);
 
                if (*error) {
                    return 0;
                }
 
                Graph_addEdge(this->graph, wordCluster[0], bottoms[current], error);
 
                if (*error) {
                    return 0;
                }
 
            } else {
 
                Graph_readCluster(this->graph, common, WORD_CLUSTER_LENGTH, wordCluster, error);
 
                if (*error) {
                    return 0;
                }
 
            }
 
            bottoms[previous] = wordCluster[1];
            typeVertex = wordCluster[2];
        }
    }
 
    return typeVertex;
}
 
void Words_readWord(struct Words *this, unsigned int word, unsigned int length, unsigned int *characters, int *error)
{
    if (0 == length) {
        *error = ERROR_WORD_BUFFER_TOO_SMALL;
        return;
    }
 
    // traverse the word pyramid
 
    unsigned int wordCluster[WORD_CLUSTER_LENGTH];
 
    Graph_readCluster(this->graph, word, WORD_CLUSTER_LENGTH, wordCluster, error); // reversed
 
    if (*error) {
        return;
    }
 
    unsigned int tops[BUFFER_LENGTH];
 
    tops[0] = wordCluster[1];
 
    unsigned int last = 0;
    int atBinaryBorder = 0;
 
    while (! atBinaryBorder) {
 
        unsigned int index = last;
 
        while (index >= 0) {
 
            unsigned int lastTarget = Graph_readLastTarget(this->graph, tops[index], error);
 
            if (*error) {
                return;
            }
 
            if (0 == lastTarget) {
                atBinaryBorder = 1;
                break;
            }
 
            Graph_readCluster(this->graph, lastTarget, WORD_CLUSTER_LENGTH, wordCluster, error);
 
            if (*error) {
                return;
            }
 
            tops[index + 1] = wordCluster[2];
 
            if (0 == index) {
 
                unsigned int lastSource = Graph_readLastSource(this->graph, tops[index], error);
 
                if (*error) {
                    return;
                }
 
                Graph_readCluster(this->graph, lastSource, WORD_CLUSTER_LENGTH, wordCluster, error);
 
                if (*error) {
                    return;
                }
 
                tops[index] = wordCluster[2];
            }
 
            if (index == 0) {
                break;
            } else {
                index--;
            }
        };
 
        if (! atBinaryBorder) {
 
            last++;
 
            if (last == length) {
                *error = ERROR_WORD_BUFFER_TOO_SMALL;
                return;
            }
        }
    }
 
    // read codes
 
    for (unsigned int index = 0; index <= last; index++) {
 
        unsigned int lastSource = Graph_readLastSource(this->graph, tops[index], error);
 
        if (*error) {
            return;
        }
 
        unsigned int code = Binary_readCode(this->binary, lastSource, error);
 
        if (*error) {
            return;
        }
 
        characters[index] = code;
    }
}