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
  34 #include <stdlib.h>
  35 #include <string.h>
  36 #include <stdio.h>
  37 #include <math.h>
  38
  39 #include "MEM_guardedalloc.h"
  40
  41 #include "DNA_listBase.h"
  42
  43
  44 #include "BLO_undofile.h"
  45
  46 #include "BLI_blenlib.h"
  47 #include "BLI_linklist.h"
  48
  49
  50
  51 /* **************** support for memory-write, for undo buffers *************** */
  52
  53 /* not memfile itself */
  54 void BLO_free_memfile(MemFile *memfile)
  55 {
  56         MemFileChunk *chunk;
  57
  58         while ( (chunk = (memfile->chunks.first) ) ) {
  59                 if (chunk->ident == 0) MEM_freeN(chunk->buf);
  60                 BLI_remlink(&memfile->chunks, chunk);
  61                 MEM_freeN(chunk);
  62         }
  63         memfile->size = 0;
  64 }
  65
  66 /* to keep list of memfiles consistent, 'first' is always first in list */
  67 /* result is that 'first' is being freed */
  68 void BLO_merge_memfile(MemFile *first, MemFile *second)
  69 {
  70         MemFileChunk *fc, *sc;
  71
  72         fc = first->chunks.first;
  73         sc = second->chunks.first;
  74         while (fc || sc) {
  75                 if (fc && sc) {
  76                         if (sc->ident) {
  77                                 sc->ident = 0;
  78                                 fc->ident = 1;
  79                         }
  80                 }
  81                 if (fc) fc = fc->next;
  82                 if (sc) sc = sc->next;
  83         }
  84
  85         BLO_free_memfile(first);
  86 }
  87
  88 static int my_memcmp(const int *mem1, const int *mem2, const int len)
  89 {
  90         register int a = len;
  91         register const int *mema = mem1;
  92         register const int *memb = mem2;
  93
  94         while (a--) {
  95                 if (*mema != *memb) return 1;
  96                 mema++;
  97                 memb++;
  98         }
  99         return 0;
 100 }
 101
 102 void add_memfilechunk(MemFile *compare, MemFile *current, const char *buf, unsigned int size)
 103 {
 104         static MemFileChunk *compchunk = NULL;
 105         MemFileChunk *curchunk;
 106
 107         /* this function inits when compare != NULL or when current == NULL  */
 108         if (compare) {
 109                 compchunk = compare->chunks.first;
 110                 return;
 111         }
 112         if (current == NULL) {
 113                 compchunk = NULL;
 114                 return;
 115         }
 116
 117         curchunk = MEM_mallocN(sizeof(MemFileChunk), "MemFileChunk");
 118         curchunk->size = size;
 119         curchunk->buf = NULL;
 120         curchunk->ident = 0;
 121         BLI_addtail(&current->chunks, curchunk);
 122
 123         /* we compare compchunk with buf */
 124         if (compchunk) {
 125                 if (compchunk->size == curchunk->size) {
 126                         if (my_memcmp((int *)compchunk->buf, (const int *)buf, size / 4) == 0) {
 127                                 curchunk->buf = compchunk->buf;
 128                                 curchunk->ident = 1;
 129                         }
 130                 }
 131                 compchunk = compchunk->next;
 132         }
 133
 134         /* not equal... */
 135         if (curchunk->buf == NULL) {
 136                 curchunk->buf = MEM_mallocN(size, "Chunk buffer");
 137                 memcpy(curchunk->buf, buf, size);
 138                 current->size += size;
 139         }
 140 }
 141