pith/icache.c

   1 #if !defined(lint) && !defined(DOS)
   2 static char rcsid[] = "$Id: icache.c 874 2007-12-15 02:51:06Z hubert@u.washington.edu $";
   3 #endif
   4
   5 /*
   6  * ========================================================================
   7  * Copyright 2006-2007 University of Washington
   8  * Copyright 2013-2016 Eduardo Chappa
   9  *
  10  * Licensed under the Apache License, Version 2.0 (the "License");
  11  * you may not use this file except in compliance with the License.
  12  * You may obtain a copy of the License at
  13  *
  14  *     http://www.apache.org/licenses/LICENSE-2.0
  15  *
  16  * ========================================================================
  17  */
  18
  19 #include "../pith/headers.h"
  20 #include "../pith/icache.h"
  21 #include "../pith/mailindx.h"
  22 #include "../pith/flag.h"
  23 #include "../pith/msgno.h"
  24 #include "../pith/status.h"
  25 #include "../pith/pineelt.h"
  26
  27 /*
  28  * Internal prototypes
  29  */
  30
  31
  32 /*
  33  *           * * *  Index entry cache manager  * * *
  34  */
  35
  36
  37 /*
  38  * Erase a particular entry in the cache.
  39  */
  40 void
  41 clear_index_cache_ent(MAILSTREAM *stream, long int msgno, unsigned int flags)
  42 {
  43     long          rawno = -1L;
  44     PINELT_S    **peltp;
  45     MESSAGECACHE *mc;
  46
  47     if(stream){
  48         if(flags & IC_USE_RAW_MSGNO)
  49           rawno = msgno;
  50         else
  51           rawno = mn_m2raw(sp_msgmap(stream), msgno);
  52
  53         if(rawno > 0L && rawno <= stream->nmsgs){
  54             mc = mail_elt(stream, rawno);
  55             if(mc && mc->sparep){
  56                 peltp = (PINELT_S **) &mc->sparep;
  57                 if((*peltp)->ice){
  58                     /*
  59                      * This is intended to be a lightweight reset of
  60                      * just the widths and print_format strings. For example,
  61                      * the width of the screen changed and nothing else.
  62                      * We simply unset the widths_done bit and it
  63                      * is up to the drawer to free and recalculate the
  64                      * print_format strings and to reset the widths.
  65                      *
  66                      * The else case is a clear of the entire cache entry
  67                      * leaving behind only the empty structure.
  68                      */
  69                     if(flags & IC_CLEAR_WIDTHS_DONE){
  70                         (*peltp)->ice->widths_done = 0;
  71
  72                         /* also zero out hash value */
  73                         (*peltp)->ice->id = 0;
  74
  75                         if((*peltp)->ice->tice){
  76                             (*peltp)->ice->tice->widths_done = 0;
  77
  78                             /* also zero out hash value */
  79                             (*peltp)->ice->tice->id = 0;
  80                         }
  81                     }
  82                     else
  83                       clear_ice(&(*peltp)->ice);
  84                 }
  85             }
  86         }
  87     }
  88 }
  89
  90
  91 void
  92 clear_index_cache(MAILSTREAM *stream, unsigned int flags)
  93 {
  94     long rawno;
  95
  96     if(stream){
  97         set_need_format_setup(stream);
  98         for(rawno = 1L; rawno <= stream->nmsgs; rawno++)
  99           clear_index_cache_ent(stream, rawno, flags | IC_USE_RAW_MSGNO);
 100     }
 101 }
 102
 103
 104 void
 105 clear_index_cache_for_thread(MAILSTREAM *stream, PINETHRD_S *thrd, MSGNO_S *msgmap)
 106 {
 107     unsigned long msgno;
 108
 109     if(!thrd || !stream || thrd->rawno < 1L || thrd->rawno > stream->nmsgs)
 110       return;
 111
 112     msgno = mn_raw2m(msgmap, thrd->rawno);
 113
 114     clear_index_cache_ent(stream, msgno, 0);
 115
 116     if(thrd->next)
 117       clear_index_cache_for_thread(stream, fetch_thread(stream, thrd->next),
 118                                    msgmap);
 119
 120     if(thrd->branch)
 121       clear_index_cache_for_thread(stream, fetch_thread(stream, thrd->branch),
 122                                    msgmap);
 123 }
 124
 125
 126 void
 127 clear_icache_flags(MAILSTREAM *stream)
 128 {
 129     sp_set_icache_flags(stream, 0);
 130 }
 131
 132
 133 void
 134 set_need_format_setup(MAILSTREAM *stream)
 135 {
 136     sp_set_icache_flags(stream, sp_icache_flags(stream) | SP_NEED_FORMAT_SETUP);
 137 }
 138
 139
 140 int
 141 need_format_setup(MAILSTREAM *stream)
 142 {
 143     return(sp_icache_flags(stream) & SP_NEED_FORMAT_SETUP);
 144 }
 145
 146
 147 void
 148 set_format_includes_msgno(MAILSTREAM *stream)
 149 {
 150     sp_set_icache_flags(stream, sp_icache_flags(stream) | SP_FORMAT_INCLUDES_MSGNO);
 151 }
 152
 153
 154 int
 155 format_includes_msgno(MAILSTREAM *stream)
 156 {
 157     return(sp_icache_flags(stream) & SP_FORMAT_INCLUDES_MSGNO);
 158 }
 159
 160
 161 void
 162 set_format_includes_smartdate(MAILSTREAM *stream)
 163 {
 164     sp_set_icache_flags(stream, sp_icache_flags(stream) | SP_FORMAT_INCLUDES_SMARTDATE);
 165 }
 166
 167
 168 int
 169 format_includes_smartdate(MAILSTREAM *stream)
 170 {
 171     return(sp_icache_flags(stream) & SP_FORMAT_INCLUDES_SMARTDATE);
 172 }
 173
 174
 175 /*
 176  * Almost a free_ice, but we leave the memory there for the ICE_S.
 177  */
 178 void
 179 clear_ice(ICE_S **ice)
 180 {
 181     if(ice && *ice){
 182         free_ifield(&(*ice)->ifield);
 183
 184         if((*ice)->linecolor)
 185           free_color_pair(&(*ice)->linecolor);
 186
 187         if((*ice)->tice)
 188           clear_ice(&(*ice)->tice);
 189
 190         /* do these one at a time so we don't clear tice */
 191         (*ice)->color_lookup_done = 0;
 192         (*ice)->to_us = 0;
 193         (*ice)->cc_us = 0;
 194         (*ice)->plus = 0;
 195         (*ice)->id = 0;
 196     }
 197 }
 198
 199
 200 void
 201 free_ice(ICE_S **ice)
 202 {
 203     if(ice && *ice){
 204
 205         if((*ice)->tice)
 206           free_ice(&(*ice)->tice);
 207
 208         clear_ice(ice);
 209
 210         fs_give((void **) ice);
 211     }
 212 }
 213
 214
 215 void
 216 free_ifield(IFIELD_S **ifld)
 217 {
 218     if(ifld && *ifld){
 219         free_ifield(&(*ifld)->next);
 220         free_ielem(&(*ifld)->ielem);
 221         fs_give((void **) ifld);
 222     }
 223 }
 224
 225
 226 void
 227 free_ielem(IELEM_S **il)
 228 {
 229     if(il && *il){
 230         free_ielem(&(*il)->next);
 231         if((*il)->freeprintf && (*il)->print_format)
 232           fs_give((void **) &(*il)->print_format);
 233
 234         if((*il)->freecolor && (*il)->color)
 235           free_color_pair(&(*il)->color);
 236
 237         if((*il)->freedata && (*il)->data)
 238           fs_give((void **) &(*il)->data);
 239
 240         fs_give((void **) il);
 241     }
 242 }
 243
 244
 245 /*
 246  * Returns the index cache entry associated with this message.
 247  * If it doesn't already exist it is instantiated.
 248  */
 249 ICE_S *
 250 fetch_ice(MAILSTREAM *stream, long unsigned int rawno)
 251 {
 252     PINELT_S    **peltp;
 253     MESSAGECACHE *mc;
 254
 255     if(!stream || rawno < 1L || rawno > stream->nmsgs)
 256       return NULL;
 257
 258     if(!(mc = mail_elt(stream, rawno)))
 259       return NULL;
 260
 261     /*
 262      * any private elt data yet?
 263      */
 264     if(*(peltp = (PINELT_S **) &mc->sparep) == NULL){
 265         *peltp = (PINELT_S *) fs_get(sizeof(PINELT_S));
 266         memset(*peltp, 0, sizeof(PINELT_S));
 267     }
 268
 269     if((*peltp)->ice == NULL)
 270       (*peltp)->ice = new_ice();
 271
 272     if(need_format_setup(stream) && setup_header_widths)
 273       (*setup_header_widths)(stream);
 274
 275     return((*peltp)->ice);
 276 }
 277
 278
 279 ICE_S **
 280 fetch_ice_ptr(MAILSTREAM *stream, long unsigned int rawno)
 281 {
 282     PINELT_S    **peltp;
 283     MESSAGECACHE *mc;
 284
 285     if(!stream || rawno < 1L || rawno > stream->nmsgs)
 286       return NULL;
 287
 288     if(!(mc = mail_elt(stream, rawno)))
 289       return NULL;
 290
 291     /*
 292      * any private elt data yet?
 293      */
 294     if(*(peltp = (PINELT_S **) &mc->sparep) == NULL){
 295         *peltp = (PINELT_S *) fs_get(sizeof(PINELT_S));
 296         memset(*peltp, 0, sizeof(PINELT_S));
 297     }
 298
 299     return(&(*peltp)->ice);
 300 }
 301
 302
 303 ICE_S *
 304 copy_ice(ICE_S *src)
 305 {
 306     ICE_S *head = NULL;
 307
 308     if(src){
 309         head                    = new_ice();
 310
 311         head->color_lookup_done = src->color_lookup_done;
 312         head->widths_done       = src->widths_done;
 313         head->to_us             = src->to_us;
 314         head->cc_us             = src->cc_us;
 315         head->plus              = src->plus;
 316         head->id                = src->id;
 317
 318         if(src->linecolor)
 319           head->linecolor = new_color_pair(src->linecolor->fg, src->linecolor->bg);
 320
 321         if(src->ifield)
 322           head->ifield = copy_ifield(src->ifield);
 323
 324         if(src->tice)
 325           head->tice = copy_ice(src->tice);
 326     }
 327
 328     return(head);
 329 }
 330
 331
 332 IFIELD_S *
 333 copy_ifield(IFIELD_S *src)
 334 {
 335     IFIELD_S *head = NULL;
 336
 337     if(src){
 338         head          = new_ifield(NULL);
 339
 340         if(src->next)
 341           head->next = copy_ifield(src->next);
 342
 343         head->ctype   = src->ctype;
 344         head->width   = src->width;
 345         head->leftadj = src->leftadj;
 346
 347         if(src->ielem)
 348           head->ielem = copy_ielem(src->ielem);
 349     }
 350
 351     return(head);
 352 }
 353
 354
 355 IELEM_S *
 356 copy_ielem(IELEM_S *src)
 357 {
 358     IELEM_S *head = NULL;
 359
 360     if(src){
 361         head          = new_ielem(NULL);
 362
 363         if(src->next)
 364           head->next = copy_ielem(src->next);
 365
 366         head->type = src->type;
 367         head->wid  = src->wid;
 368
 369         if(src->color){
 370             head->color     = new_color_pair(src->color->fg, src->color->bg);
 371             head->freecolor = 1;
 372         }
 373
 374         if(src->data){
 375             head->data     = cpystr(src->data);
 376             head->datalen  = strlen(head->data);
 377             head->freedata = 1;
 378         }
 379
 380         if(src->print_format){
 381             head->print_format = cpystr(src->print_format);
 382             head->freeprintf   = strlen(head->print_format) + 1;
 383         }
 384     }
 385
 386     return(head);
 387 }
 388
 389
 390 ICE_S *
 391 new_ice(void)
 392 {
 393     ICE_S *ice;
 394
 395     ice = (ICE_S *) fs_get(sizeof(ICE_S));
 396     memset(ice, 0, sizeof(ICE_S));
 397     return(ice);
 398 }
 399
 400
 401 /*
 402  * Create new IFIELD_S, zero it out, and insert it at end.
 403  */
 404 IFIELD_S *
 405 new_ifield(IFIELD_S **ifieldp)
 406 {
 407     IFIELD_S *ifield, *ip;
 408
 409     ifield = (IFIELD_S *) fs_get(sizeof(*ifield));
 410     memset(ifield, 0, sizeof(*ifield));
 411
 412     if(ifieldp){
 413         ip = *ifieldp;
 414         if(ip){
 415             for(ip = (*ifieldp); ip && ip->next; ip = ip->next)
 416               ;
 417
 418             ip->next = ifield;
 419         }
 420         else
 421           *ifieldp = ifield;
 422     }
 423
 424     return(ifield);
 425 }
 426
 427
 428 /*
 429  * Create new IELEM_S, zero it out, and insert it at end.
 430  */
 431 IELEM_S *
 432 new_ielem(IELEM_S **ielemp)
 433 {
 434     IELEM_S *ielem, *ip;
 435
 436     ielem = (IELEM_S *) fs_get(sizeof(*ielem));
 437     memset(ielem, 0, sizeof(*ielem));
 438
 439     if(ielemp){
 440         ip = *ielemp;
 441         if(ip){
 442             for(ip = (*ielemp); ip && ip->next; ip = ip->next)
 443               ;
 444
 445             ip->next = ielem;
 446         }
 447         else
 448           *ielemp = ielem;
 449     }
 450
 451     return(ielem);
 452 }