summary refs log tree commit diff stats
path: root/lib/pure/json.nim
Commit message (Expand)AuthorAgeFilesLines
...
* Improved assertion error messages on usage of JsonNode iterators on wrong kin...Ico Doornekamp2020-02-171-5/+5
* Fix vertical tab in JSON. (#13399)Khronos2020-02-171-1/+1
* Revert "printing float values will have one more digit. (#13276) [backport]" ...Timothee Cour2020-02-081-2/+2
* printing float values will have one more digit. (#13276) [backport]Arne Döring2020-02-071-2/+2
* fix json regression D20191212T144944 (#12902) [backport]Timothee Cour2019-12-151-0/+1
* Fixes #12832 (#12842) [backport]Neelesh Chandola2019-12-081-1/+1
* remove deprecated procs (#12535)Andreas Rumpf2019-11-051-16/+0
* fix several typos in documentation and comments (#12553)Nindaleth2019-10-301-1/+1
* Extent json.to testing to VM, add workrounds for VM bugs. (#12493)Arne Döring2019-10-281-50/+127
* Refactor json macro (#12391)Arne Döring2019-10-171-638/+263
* [backport] run nimpretty on parsersnarimiran2019-09-301-23/+28
* Fix spellings (#12277) [backport]Federico Ceratto2019-09-271-1/+1
* json: removed deprecatedGet pragmaAraq2019-09-211-10/+1
* fixes #12152 (#12165)Andreas Rumpf2019-09-111-0/+25
* fixes #12015 by also checking kind of `typeNode` (#12016)Vindaar2019-08-271-4/+13
* [refactoring] remove unused imports in the compiler and in some stdlib modulesAraq2019-07-181-2/+2
* styleCheck: make the compiler and large parts of the stdlib compatible with -...Araq2019-07-101-2/+2
* Added 'keys' iterator to JsonNode (#11597) [feature]Liam Sc2019-07-031-0/+6
* Render deprecated pragmas (#8886)LemonBoy2019-06-031-8/+8
* fixes #11057 (#11345)Andreas Rumpf2019-05-281-2/+1
* make json.to work with the more restricted case objectsAraq2019-05-271-14/+11
* fixes #1286; object case transitions are now soundAndreas Rumpf2019-05-271-42/+15
* fixes #10963, disallow implicit mixing of strings and ints/floats (#11292)Miran2019-05-211-4/+4
* json: add '\v' support, fixes #10541 (#10987)Miran2019-04-101-0/+1
* json.nim: tiny refactoringAraq2019-04-011-4/+1
* fixes json.nim regressionAndreas Rumpf2019-03-291-12/+5
* simplify json.% for tuples and objectsnarimiran2019-03-111-13/+7
* Tighten the conversion from tyRange to scalar types (#10495)LemonBoy2019-02-231-10/+48
* Implement `json.%` for tables and optionsOscar Nihlgård2019-02-131-1/+11
* fixup #10466 to use runnableExamples (#10510)Timothee Cour2019-01-311-17/+14
* Example for json.pretty (#10466)Mandeep Singh2019-01-301-3/+22
* Add logic to deserialize tyRange fields from json (#10469)LemonBoy2019-01-281-0/+24
* Use hexadecimal in json escaping (#10437) [backport]Christian Lyder Jacobsen2019-01-251-3/+3
* fix json bug `[]=` misplaced (#10397)Timothee Cour2019-01-211-5/+5
* json: support tuple (#10010)Timothee Cour2019-01-161-1/+16
* [json] document fact that key ordering is preserved (#10020)Timothee Cour2018-12-201-0/+7
* [docs/json]: expands existing examples + shows {} operator in action (#9157)Steve Kellock2018-10-021-28/+74
* Fix #9111; error when parsing to aliased type fieldmashingan2018-09-291-1/+15
* Add escapeJsonUnquoted for json escaped strings without quotes (#8785)hlaaf2018-08-271-4/+16
* even more strict isNil handling for strings/seqs in order to detect bugsAraq2018-08-221-1/+0
* make more tests greenAndreas Rumpf2018-08-131-1/+1
* fixes #8037, json.to support object with distinct types (#8086)andri lim2018-07-191-5/+30
* Testament should run tests with no action (#8232)genotrance2018-07-081-18/+17
* Allow `%` overloading in `%*` macro in json (again)hlaaf2018-06-061-4/+4
* fix #7881, control characters in json output (#7887)hlaaf2018-05-281-0/+3
* json.nim: delete should raise KeyError, not IndexError, minor cleanup of the ...Araq2018-05-201-4/+4
* move parsejson logic into its own standard lib moduleAraq2018-05-181-505/+12
* fixes #7817Araq2018-05-141-0/+3
* remove deprecated stuff from the stdlib; introduce better deprecation warningsAraq2018-05-051-11/+4
* Improve deprecation messages in json docs.Dominik Picheta2018-04-251-4/+4
mpletion of online contacts now rolls' href='/danisanti/profani-tty/commit/contact_list.c?id=f7584469bb8e546f547706083be6d7ccc19c59dc'>f7584469 ^
e6b076ce ^
cfc23078 ^










7a9d127a ^
78bd151c ^
2b743ea9 ^

7a9d127a ^
e6b076ce ^
7a9d127a ^
2b743ea9 ^
7a9d127a ^

78bd151c ^
dab37236 ^

7a9d127a ^

dab37236 ^
e568c588 ^


30d30133 ^
e568c588 ^


2b743ea9 ^

7a9d127a ^
91c157b1 ^
78bd151c ^
e568c588 ^
7a9d127a ^

78bd151c ^

2b743ea9 ^
7a9d127a ^


78bd151c ^
7a9d127a ^
78bd151c ^
78bd151c ^

dab37236 ^
78bd151c ^
dab37236 ^

7a9d127a ^
dab37236 ^
78bd151c ^
dab37236 ^

7a9d127a ^
dab37236 ^






30d30133 ^


7a9d127a ^
dab37236 ^
7a9d127a ^
dab37236 ^

78bd151c ^
7a9d127a ^
dab37236 ^
f23f768d ^
b1bf0540 ^
f23f768d ^
b1bf0540 ^

f23f768d ^
f7584469 ^
b1bf0540 ^



f7584469 ^
b1bf0540 ^

f7584469 ^
b1bf0540 ^





f7584469 ^
b1bf0540 ^



f7584469 ^
b1bf0540 ^
f7584469 ^

b1bf0540 ^

f7584469 ^
dab37236 ^












b1bf0540 ^

dab37236 ^
b1bf0540 ^




f23f768d ^
b1bf0540 ^





f23f768d ^

b1bf0540 ^
f23f768d ^
b1bf0540 ^

f23f768d ^

dab37236 ^
2b743ea9 ^
7a9d127a ^
dab37236 ^

2b743ea9 ^
7a9d127a ^




30d30133 ^

e6b076ce ^
30d30133 ^

e6b076ce ^


2b743ea9 ^



e6b076ce ^

2b743ea9 ^




e6b076ce ^
2b743ea9 ^
e6b076ce ^




dab37236 ^
e6b076ce ^


dab37236 ^
e6b076ce ^
dab37236 ^


2b743ea9 ^
dab37236 ^

e6b076ce ^

dab37236 ^
e6b076ce ^

30d30133 ^














1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327





















                                                                       
                  




                         

                                                    
 


                                                  
                                 
 

                                                                           
                                                        

                                                                

                                                                               


                                                          
 

                             
                                                


                     
                                                      
                                      

                              
 
                            
                             

                                
     

 











                                                  

                                




                              

 
                                                
 


                         

                                                    

                     
                                                      
                                                   



                                               
 




                                                                               
                                          










                              
 
 

                                                                       
 
 
                         
                                                               

                 
            

                                                    

                     
                                                           


                                                       
                                                                


                                                               

                                                                 
                         
             
 
                      

                              

         
                                                          


                              
 
                 
     

 
                                              
 

                                                
    
                                    
 

                
 






                                                                       


                                                     
 
                                                    
 

                    
 
 
                                     
 
                       
 

                            
                    
 



                                                                               
 

                                                         
 





                                                             
 



                                                         
 
                                         

                                

     
 












                                                                     

                 
                                                       




                                                                                 
 





                                                           

         
                          
     

                

 
                                                                           
                                                       
 

                                                                        
                                                    




                     

                                                                
 

                                                              


                                                                   



                                                                           

                                                                       




                                                                           
            
                           




               
                                                       


                        
                                
                            


                                  
                              

                               

                  
                   

 














                                                                            
/* 
 * contact_list.c
 *
 * Copyright (C) 2012 James Booth <boothj5@gmail.com>
 * 
 * This file is part of Profanity.
 *
 * Profanity is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Profanity is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Profanity.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "contact_list.h"

// internal contact list
static struct contact_node_t * _contact_list = NULL;

// state of current tab completion, currrent node 
static struct contact_node_t * _last_found = NULL;
// and current search pattern
static char * _search_str = NULL;

static char * _search_contact_list_from(struct contact_node_t * curr);
static struct contact_node_t * _make_contact_node(const char * const name, 
    const char * const show, const char * const status);
static struct contact_t * _new_contact(const char * const name, 
    const char * const show, const char * const status);
static void _destroy_contact(struct contact_t *contact);
static struct contact_node_t * _copy_contact_list(struct contact_node_t *node);
static void _insert_contact(struct contact_node_t *curr, 
    struct contact_node_t *prev, const char * const name, 
    const char * const show, const char * const status);

void contact_list_clear(void)
{
    struct contact_node_t *curr = _contact_list;
    
    if (curr) {
        while(curr) {
            struct contact_t *contact = curr->contact;
            _destroy_contact(contact);
            curr = curr->next;
        }

        free(_contact_list);
        _contact_list = NULL;
        
        reset_search_attempts();
    }
}

void destroy_list(struct contact_node_t *list)
{
    while(list) {
        struct contact_t *contact = list->contact;
        _destroy_contact(contact);
        list = list->next;
    }

    free(list);
    list = NULL;
}

void reset_search_attempts(void)
{
    _last_found = NULL;
    if (_search_str != NULL) {
        free(_search_str);
        _search_str = NULL;
    }
}

int contact_list_remove(const char * const name)
{
    if (!_contact_list) {
        return 0;
    } else {
        struct contact_node_t *curr = _contact_list;
        struct contact_node_t *prev = NULL;
        
        while(curr) {
            struct contact_t *contact = curr->contact;
            if (strcmp(contact->name, name) == 0) {
                if (prev)
                    prev->next = curr->next;
                else
                    _contact_list = curr->next;

                // reset last found if it points at the node to be removed
                if (_last_found != NULL)
                    if (strcmp(_last_found->contact->name, contact->name) == 0)
                        _last_found = NULL;

                _destroy_contact(contact);
                free(curr);

                return 1;
            }

            prev = curr;
            curr = curr->next;
        }

        return 0;
    }
}

int contact_list_add(const char * const name, const char * const show, 
    const char * const status)
{

    if (!_contact_list) {
        _contact_list = _make_contact_node(name, show, status);
        
        return 1;
    } else {
        struct contact_node_t *curr = _contact_list;
        struct contact_node_t *prev = NULL;

        while(curr) {
            struct contact_t *curr_contact = curr->contact;

            // insert    
            if (strcmp(curr_contact->name, name) > 0) {
                _insert_contact(curr, prev, name, show, status);
                return 0;
            // update
            } else if (strcmp(curr_contact->name, name) == 0) {
                _destroy_contact(curr->contact);
                curr->contact = _new_contact(name, show, status);
                return 0;
            }

            // move on
            prev = curr;
            curr = curr->next;
        }

        curr = _make_contact_node(name, show, status);    
        
        if (prev)
            prev->next = curr;

        return 1;
    }
}

struct contact_node_t * get_contact_list(void)
{
    struct contact_node_t *copy = NULL;
    struct contact_node_t *curr = _contact_list;
    
    copy = _copy_contact_list(curr);

    return copy;
}

struct contact_node_t * _copy_contact_list(struct contact_node_t *node)
{
    if (node == NULL) {
        return NULL;
    } else {
        struct contact_t *curr_contact = node->contact;
        struct contact_node_t *copy = 
            _make_contact_node(curr_contact->name, 
                               curr_contact->show, 
                               curr_contact->status);

        copy->next = _copy_contact_list(node->next);

        return copy;
    }
}

char * find_contact(char *search_str)
{
    char *found = NULL;

    // no contacts to search
    if (!_contact_list)
        return NULL;

    // first search attempt
    if (_last_found == NULL) {
        _search_str = (char *) malloc((strlen(search_str) + 1) * sizeof(char));
        strcpy(_search_str, search_str);

        found = _search_contact_list_from(_contact_list);
        return found;

    // subsequent search attempt
    } else {
        // search from here+1 to end 
        found = _search_contact_list_from(_last_found->next);
        if (found != NULL)
            return found;

        // search from beginning
        found = _search_contact_list_from(_contact_list);
        if (found != NULL)
            return found;

        // we found nothing, reset search
        reset_search_attempts();
        return NULL;
    }
}

int get_size(struct contact_node_t *list)
{
    int size = 0;

    while(list) {
        size++;
        list = list->next;
    }

    return size;
}

static char * _search_contact_list_from(struct contact_node_t * curr)
{
    while(curr) {
        struct contact_t *curr_contact = curr->contact;
        
        // match found
        if (strncmp(curr_contact->name, _search_str, strlen(_search_str)) == 0) {
            char *result = 
                (char *) malloc((strlen(curr_contact->name) + 1) * sizeof(char));

            // set pointer to last found
            _last_found = curr;
            
            // return the contact, must be free'd by caller
            strcpy(result, curr_contact->name);
            return result;
        }

        curr = curr->next;
    }

    return NULL;
}

static struct contact_node_t * _make_contact_node(const char * const name, 
    const char * const show, const char * const status)
{
    struct contact_node_t *new = 
        (struct contact_node_t *) malloc(sizeof(struct contact_node_t));
    new->contact = _new_contact(name, show, status);
    new->next = NULL;

    return new;
}

static struct contact_t * _new_contact(const char * const name, 
    const char * const show, const char * const status)
{
    struct contact_t *new = 
        (struct contact_t *) malloc(sizeof(struct contact_t));
    new->name = (char *) malloc((strlen(name) + 1) * sizeof(char));
    strcpy(new->name, name);
    
    if (show == NULL || (strcmp(show, "") == 0)) {
        new->show = (char *) malloc((strlen("online") + 1) * sizeof(char));
        strcpy(new->show, "online");
    } else {
        new->show = (char *) malloc((strlen(show) + 1) * sizeof(char));
        strcpy(new->show, show);
    }

    if (status != NULL) {
        new->status = (char *) malloc((strlen(status) + 1) * sizeof(char));
        strcpy(new->status, status);
    } else {
        new->status = NULL;
    }

    return new;
}

static void _destroy_contact(struct contact_t *contact)
{
    free(contact->name);

    if (contact->show != NULL) {
        free(contact->show);
        contact->show = NULL;
    }
    if (contact->status != NULL) {
        free(contact->status);
        contact->status = NULL;
    }

    free(contact);
    contact = NULL;
}

static void _insert_contact(struct contact_node_t *curr, 
    struct contact_node_t *prev, const char * const name,
    const char * const show, const char * const status)
{
    if (prev) {
        struct contact_node_t *new = _make_contact_node(name, show, status);
        new->next = curr;
        prev->next = new;
    } else {
        struct contact_node_t *new = _make_contact_node(name, show, status);
        new->next = _contact_list;
        _contact_list = new;
    }
}