← Back to branch summary

~ubuntu-branches/ubuntu/vivid/emscripten/vivid

« back to all changes in this revision

Viewing changes to tests/box2d/Box2D/Common/b2StackAllocator.cpp

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2013-05-02 13:11:51 UTC
  • Revision ID: package-import@ubuntu.com-20130502131151-q8dvteqr1ef2x7xz
Tags: upstream-1.4.1~20130504~adb56cb
Import upstream version 1.4.1~20130504~adb56cb

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/box2d/Box2D/Common/b2StackAllocator.cpp
 
1
/*
 
2
* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
 
3
*
 
4
* This software is provided 'as-is', without any express or implied
 
5
* warranty.  In no event will the authors be held liable for any damages
 
6
* arising from the use of this software.
 
7
* Permission is granted to anyone to use this software for any purpose,
 
8
* including commercial applications, and to alter it and redistribute it
 
9
* freely, subject to the following restrictions:
 
10
* 1. The origin of this software must not be misrepresented; you must not
 
11
* claim that you wrote the original software. If you use this software
 
12
* in a product, an acknowledgment in the product documentation would be
 
13
* appreciated but is not required.
 
14
* 2. Altered source versions must be plainly marked as such, and must not be
 
15
* misrepresented as being the original software.
 
16
* 3. This notice may not be removed or altered from any source distribution.
 
17
*/
 
18
 
 
19
#include <Box2D/Common/b2StackAllocator.h>
 
20
#include <Box2D/Common/b2Math.h>
 
21
 
 
22
b2StackAllocator::b2StackAllocator()
 
23
{
 
24
        m_index = 0;
 
25
        m_allocation = 0;
 
26
        m_maxAllocation = 0;
 
27
        m_entryCount = 0;
 
28
}
 
29
 
 
30
b2StackAllocator::~b2StackAllocator()
 
31
{
 
32
        b2Assert(m_index == 0);
 
33
        b2Assert(m_entryCount == 0);
 
34
}
 
35
 
 
36
void* b2StackAllocator::Allocate(int32 size)
 
37
{
 
38
        b2Assert(m_entryCount < b2_maxStackEntries);
 
39
 
 
40
        b2StackEntry* entry = m_entries + m_entryCount;
 
41
        entry->size = size;
 
42
        if (m_index + size > b2_stackSize)
 
43
        {
 
44
                entry->data = (char*)b2Alloc(size);
 
45
                entry->usedMalloc = true;
 
46
        }
 
47
        else
 
48
        {
 
49
                entry->data = m_data + m_index;
 
50
                entry->usedMalloc = false;
 
51
                m_index += size;
 
52
        }
 
53
 
 
54
        m_allocation += size;
 
55
        m_maxAllocation = b2Max(m_maxAllocation, m_allocation);
 
56
        ++m_entryCount;
 
57
 
 
58
        return entry->data;
 
59
}
 
60
 
 
61
void b2StackAllocator::Free(void* p)
 
62
{
 
63
        b2Assert(m_entryCount > 0);
 
64
        b2StackEntry* entry = m_entries + m_entryCount - 1;
 
65
        b2Assert(p == entry->data);
 
66
        if (entry->usedMalloc)
 
67
        {
 
68
                b2Free(p);
 
69
        }
 
70
        else
 
71
        {
 
72
                m_index -= entry->size;
 
73
        }
 
74
        m_allocation -= entry->size;
 
75
        --m_entryCount;
 
76
 
 
77
        p = NULL;
 
78
}
 
79
 
 
80
int32 b2StackAllocator::GetMaxAllocation() const
 
81
{
 
82
        return m_maxAllocation;
 
83
}