4coder/4coder_search.cpp

#ifndef FCODER_SEARCH
#define FCODER_SEARCH

enum Search_Range_Type{
    SearchRange_FrontToBack,
    SearchRange_BackToFront,
    SearchRange_Wave,
};

struct Search_Range{
    int type;
    int buffer;
    int start;
    int size;
    int mid_start;
    int mid_size;
};

struct Search_Set{
    Search_Range *ranges;
    int count;
    int max;
};

struct Search_Iter{
    String word;
    int pos;
    int back_pos;
    int i;
    int range_initialized;
};

struct Search_Match{
    Buffer_Summary buffer;
    int start;
    int end;
    int found_match;
};

// TODO(allen): HOW DO I WANT TO GET MEMORY CUSTOM SIDE??
#define GET_MEMORY(a) (void*)(0)
#define REGET_MEMORY(a,b) (void*)(0)
#define REGET_NOCOPY_MEMORY(a,b) (void*)(0)
#define FREE_MEMORY(a) (void)(a)

static void
search_iter_init(Application_Links *app, Search_Iter *iter, int size){
    int str_max = size*2;
    if (iter->word.str == 0){
        iter->word.str = (char*)GET_MEMORY(str_max);
        iter->word.memory_size = str_max;
    }
    else if (iter->word.memory_size < size){
        iter->word.str = (char*)REGET_MEMORY(iter->word.str, str_max);
        iter->word.memory_size = str_max;
    }
    
    iter->i = 0;
    iter->pos = 0;
}

static void
search_set_init(Application_Links *app, Search_Set *set, int range_count){
    int max = range_count*2;
    
    if (set->ranges == 0){
        set->ranges = (Search_Range*)GET_MEMORY(sizeof(Search_Range)*max);
        set->max = max;
    }
    else if (set->max < range_count){
        set->ranges = (Search_Range*)REGET_MEMORY(set->ranges, sizeof(Search_Range)*max);
        set->max = max;
    }
    
    set->count = range_count;
}

static void
search_hits_table_alloc(Application_Links *app, Table *hits, int table_size){
    void *mem = 0;
    int mem_size = table_required_mem_size(table_size, sizeof(Offset_String));
    if (hits->hash_array == 0){
        mem = GET_MEMORY(mem_sze);
    }
    else{
        mem = REGET_NOCOPY_MEMORY(hits->hash_array, mem_sze);
    }
    table_init_memory(hits, mem, table_size, sizeof(Offset_String));
}

static void
search_hits_init(Application_Links *app, Table *hits, String_Space *str, int table_size, int str_size){
    if (hits->hash_array == 0){
        search_hits_table_alloc(app, hits, table_size);
    }
    else{
        int mem_size = table_required_mem_size(table_size, sizeof(Offset_String));
        void *mem = REGET_NOCOPY_MEMORY(mem, mem_size);
        table_init_memory(hits, mem, table_size, sizeof(Offset_String));
    }
    
    if (str->space == 0){
        str->space = (char*)GET_MEMORY(str_size);
        str->max = str_size;
    }
    else if (str->max < str_size){
        str->space = (char*)REGET_NOCOPY_MEMORY(str->space, str_size);
        str->max = str_size;
    }
    
    str->pos = str->new_pos = 0;
    table_clear(hits);
}

static int
search_hit_add(Application_Links *app, Table *hits, String_Space *space, char *str, int len){
    int result = false;
    
    assert(len != 0);
    
    Offset_String ostring = strspace_append(space, str, len);
    if (ostring.size == 0){
        int new_size = space->max*2;
        if (new_size < space->max + len){
            new_size = space->max + len;
        }
        space->space = (char*)REGET_MEMORY(space->space, new_size);
        ostring = strspace_append(space, str, len);
    }
    
    assert(ostring.size != 0);
    
    if (table_at_capacity(hits)){
        Table new_hits = {0};
        search_hits_table_alloc(app, &new_hits, hits->max*2);
        table_clear(&new_hits);
        table_rehash(hits, &new_hits, space->space, tbl_offset_string_hash, tbl_offset_string_compare);
        FREE_MEMORY(hits->hash_array);
        *hits = new_hits;
    }
    
    if (!table_add(hits, &ostring, space->space, tbl_offset_string_hash, tbl_offset_string_compare)){
        result = true;
        strspace_keep_prev(space);
    }
    else{
        strspace_discard_prev(space);
    }
    
    return(result);
}

static int
buffer_seek_alpha_numeric_end(Application_Links *app, Buffer_Summary *buffer, int pos){
    char space[1024];
    Stream_Chunk chunk = {0};
    if (init_stream_chunk(&chunk, app, buffer, pos, space, sizeof(space))){
        int still_looping = true;
        do{
            for (; pos < chunk.end; ++pos){
                char at_pos = chunk.data[pos];
                if (!char_is_alpha_numeric(at_pos)) goto double_break;
            }
            still_looping = forward_stream_chunk(&chunk);
        }while(still_looping);
    }
    double_break:;
    return(pos);
}

static void
search_iter_next_range(Search_Iter *it){
    ++it->i;
    it->pos = 0;
    it->back_pos = 0;
    it->range_initialized = 0;
}

enum{
    FindResult_None,
    FindResult_FoundMatch,
    FindResult_PastEnd
};

static int
search_front_to_back_step(Application_Links *app,
                          Search_Range *range,
                          String word,
                          int *pos,
                          Search_Match *result_ptr){
    int found_match = FindResult_None;
    
    Search_Match result = *result_ptr;
    
    int end_pos = range->start + range->size;
    if (*pos + word.size < end_pos){
        int start_pos = *pos;
        if (start_pos < range->start){
            start_pos = range->start;
        }
        
        result.buffer = app->get_buffer(app, range->buffer, AccessAll);
        buffer_seek_string_forward(app, &result.buffer,
                                   start_pos, end_pos,
                                   word.str, word.size,
                                   &result.start);
        
        if (result.start < end_pos){
            *pos = result.start + 1;
            char prev = ' ';
            if (result.start > 0){
                prev = buffer_get_char(app, &result.buffer, result.start - 1);
            }
            if (!char_is_alpha_numeric(prev)){
                result.end =
                    buffer_seek_alpha_numeric_end(
                    app, &result.buffer, result.start);
                
                if (result.end < end_pos){
                    result.found_match = true;
                    *pos = result.end;
                    found_match = FindResult_FoundMatch;
                }
            }
        }
        else{
            found_match = FindResult_PastEnd;
        }
    }
    else{
        found_match = FindResult_PastEnd;
    }
    
    *result_ptr = result;
    
    return(found_match);
}

static int
search_back_to_front_step(Application_Links *app,
                          Search_Range *range,
                          String word,
                          int *pos,
                          Search_Match *result_ptr){
    int found_match = FindResult_None;
    
    Search_Match result = *result_ptr;
    
    int end_pos = range->start + range->size;
    if (*pos > range->start){
        int start_pos = *pos;
        
        result.buffer = app->get_buffer(app, range->buffer, AccessAll);
        buffer_seek_string_backward(app, &result.buffer,
                                    start_pos, range->start,
                                    word.str, word.size,
                                    &result.start);
        
        if (result.start >= range->start){
            *pos = result.start - 1;
            char prev = ' ';
            if (result.start > 0){
                prev = buffer_get_char(app, &result.buffer, result.start - 1);
            }
            if (!char_is_alpha_numeric(prev)){
                result.end =
                    buffer_seek_alpha_numeric_end(
                    app, &result.buffer, result.start);
                
                if (result.end < end_pos){
                    result.found_match = true;
                    *pos = result.start - word.size;
                    found_match = FindResult_FoundMatch;
                }
            }
        }
        else{
            found_match = FindResult_PastEnd;
        }
    }
    else{
        found_match = FindResult_PastEnd;
    }
    
    *result_ptr = result;
    
    return(found_match);
}

static Search_Match
search_next_match(Application_Links *app, Search_Set *set, Search_Iter *it_ptr){
    Search_Match result = {0};
    Search_Iter iter = *it_ptr;
    
    char *spare = (char*)GET_MEMORY(iter.word.size);
    
    int count = set->count;
    for (; iter.i < count;){
        Search_Range *range = set->ranges + iter.i;
        
        int find_result = FindResult_None;
        
        if (!iter.range_initialized){
            iter.range_initialized = true;
            switch (range->type){
                case SearchRange_BackToFront:
                {
                    iter.back_pos = range->start+range->size-1;
                }break;
                
                case SearchRange_Wave:
                {
                    iter.back_pos = range->mid_start-1;
                    iter.pos = range->mid_start + range->mid_size;
                }break;
            }
        }
        
        switch (range->type){
            case SearchRange_FrontToBack:
            {
                find_result =
                    search_front_to_back_step(app, range,
                                              iter.word,
                                              &iter.pos,
                                              &result);
            }break;
            
            case SearchRange_BackToFront:
            {
                find_result =
                    search_back_to_front_step(app, range,
                                              iter.word,
                                              &iter.back_pos,
                                              &result);
            }break;
            
            case SearchRange_Wave:
            {
                Search_Match forward_match = {0};
                int forward_result =
                    search_front_to_back_step(app, range,
                                              iter.word,
                                              &iter.pos,
                                              &forward_match);
                
                Search_Match backward_match = {0};
                int backward_result =
                    search_back_to_front_step(app, range,
                                              iter.word,
                                              &iter.back_pos,
                                              &backward_match);
                
                if (forward_result == FindResult_FoundMatch){
                    if (backward_result == FindResult_FoundMatch){
                        find_result = FindResult_FoundMatch;
                        
                        int forward_start = range->mid_start + range->mid_size;
                        int forward_distance = (forward_match.start - forward_start);
                        int backward_distance = (forward_match.end - range->mid_start);
                        
                        if (backward_distance < forward_distance){
                            --iter.pos;
                            result = forward_match;
                        }
                        else{
                            ++iter.back_pos;
                            result = backward_match;
                        }
                    }
                    else{
                        find_result = FindResult_FoundMatch;
                        result = forward_match;
                    }
                }
                else{
                    if (backward_result == FindResult_FoundMatch){
                        find_result = FindResult_FoundMatch;
                        result = backward_match;
                        --iter.pos;
                    }
                    else{
                        find_result = FindResult_PastEnd;
                    }
                }
            }break;
        }
        
        if (find_result == FindResult_FoundMatch){
            goto double_break;
        }
        else if (find_result == FindResult_PastEnd){
            search_iter_next_range(&iter);
        }
    }
    double_break:;
    
    FREE_MEMORY(spare);
    
    *it_ptr = iter;
    
    return(result);
} 

#endif