Fix build error on Windows 32 bit.
[blender-staging.git] / 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