source/blender/blenloader/intern/undofile.c

   1 /*
   2  * ***** BEGIN GPL LICENSE BLOCK *****
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software Foundation,
  16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  17  *
  18  * The Original Code is Copyright (C) 2004 Blender Foundation
  19  * All rights reserved.
  20  *
  21  * The Original Code is: all of this file.
  22  *
  23  * Contributor(s): none yet.
  24  *
  25  * ***** END GPL LICENSE BLOCK *****
  26  * .blend file reading entry point
  27  */
  28
  29 /** \file blender/blenloader/intern/undofile.c
  30  *  \ingroup blenloader
  31  */
  32
  33 #include <stdlib.h>
  34 #include <string.h>
  35 #include <stdio.h>
  36 #include <math.h>
  37
  38 #include "MEM_guardedalloc.h"
  39
  40 #include "DNA_listBase.h"
  41
  42 #include "BLI_blenlib.h"
  43
  44 #include "BLO_undofile.h"
  45
  46 /* **************** support for memory-write, for undo buffers *************** */
  47
  48 /* not memfile itself */
  49 void BLO_memfile_free(MemFile *memfile)
  50 {
  51         MemFileChunk *chunk;
  52
  53         while ((chunk = BLI_pophead(&memfile->chunks))) {
  54                 if (chunk->ident == 0)
  55                         MEM_freeN(chunk->buf);
  56                 MEM_freeN(chunk);
  57         }
  58         memfile->size = 0;
  59 }
  60
  61 /* to keep list of memfiles consistent, 'first' is always first in list */
  62 /* result is that 'first' is being freed */
  63 void BLO_memfile_merge(MemFile *first, MemFile *second)
  64 {
  65         MemFileChunk *fc, *sc;
  66
  67         fc = first->chunks.first;
  68         sc = second->chunks.first;
  69         while (fc || sc) {
  70                 if (fc && sc) {
  71                         if (sc->ident) {
  72                                 sc->ident = 0;
  73                                 fc->ident = 1;
  74                         }
  75                 }
  76                 if (fc) fc = fc->next;
  77                 if (sc) sc = sc->next;
  78         }
  79
  80         BLO_memfile_free(first);
  81 }
  82
  83 void memfile_chunk_add(MemFile *compare, MemFile *current, const char *buf, unsigned int size)
  84 {
  85         static MemFileChunk *compchunk = NULL;
  86         MemFileChunk *curchunk;
  87
  88         /* this function inits when compare != NULL or when current == NULL  */
  89         if (compare) {
  90                 compchunk = compare->chunks.first;
  91                 return;
  92         }
  93         if (current == NULL) {
  94                 compchunk = NULL;
  95                 return;
  96         }
  97
  98         curchunk = MEM_mallocN(sizeof(MemFileChunk), "MemFileChunk");
  99         curchunk->size = size;
 100         curchunk->buf = NULL;
 101         curchunk->ident = 0;
 102         BLI_addtail(&current->chunks, curchunk);
 103
 104         /* we compare compchunk with buf */
 105         if (compchunk) {
 106                 if (compchunk->size == curchunk->size) {
 107                         if (memcmp(compchunk->buf, buf, size) == 0) {
 108                                 curchunk->buf = compchunk->buf;
 109                                 curchunk->ident = 1;
 110                         }
 111                 }
 112                 compchunk = compchunk->next;
 113         }
 114
 115         /* not equal... */
 116         if (curchunk->buf == NULL) {
 117                 curchunk->buf = MEM_mallocN(size, "Chunk buffer");
 118                 memcpy(curchunk->buf, buf, size);
 119                 current->size += size;
 120         }
 121 }
 122