← Back to branch summary

~ubuntu-branches/debian/squeeze/openttd/squeeze

« back to all changes in this revision

Viewing changes to src/3rdparty/squirrel/squirrel/sqclass.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Jordi Mallach, Matthijs Kooijman, Jordi Mallach
  • Date: 2009-04-15 18:22:10 UTC
  • mfrom: (1.1.6 upstream) (2.1.3 squeeze)
  • Revision ID: james.westby@ubuntu.com-20090415182210-22ktb8kdbp2tf3bm
[ Matthijs Kooijman ]
* New upstream release.
* Remove Debian specific desktop file, upstream provides one now. 
* Add debian/watch file.

[ Jordi Mallach ]
* Bump Standards-Version to 3.8.1, with no changes required.
* Move to debhelper compat 7. Bump Build-Depends accordingly.
* Use dh_prep.
* Add "set -e" to config script.
* Remove a few extra doc files that get installed by upstream Makefile.
* Add more complete copyright information.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/3rdparty/squirrel/squirrel/sqclass.cpp
 
1
/*
 
2
        see copyright notice in squirrel.h
 
3
*/
 
4
#include "sqpcheader.h"
 
5
#include "sqvm.h"
 
6
#include "sqtable.h"
 
7
#include "sqclass.h"
 
8
#include "sqclosure.h"
 
9
 
 
10
SQClass::SQClass(SQSharedState *ss,SQClass *base)
 
11
{
 
12
        _base = base;
 
13
        _typetag = 0;
 
14
        _hook = NULL;
 
15
        _udsize = 0;
 
16
        _metamethods.resize(MT_LAST); //size it to max size
 
17
        if(_base) {
 
18
                _defaultvalues.copy(base->_defaultvalues);
 
19
                _methods.copy(base->_methods);
 
20
                _metamethods.copy(base->_metamethods);
 
21
                __ObjAddRef(_base);
 
22
        }
 
23
        _members = base?base->_members->Clone() : SQTable::Create(ss,0);
 
24
        __ObjAddRef(_members);
 
25
        _locked = false;
 
26
        INIT_CHAIN();
 
27
        ADD_TO_CHAIN(&_sharedstate->_gc_chain, this);
 
28
}
 
29
 
 
30
void SQClass::Finalize() {
 
31
        _attributes = _null_;
 
32
        _defaultvalues.resize(0);
 
33
        _methods.resize(0);
 
34
        _metamethods.resize(0);
 
35
        __ObjRelease(_members);
 
36
        if(_base) {
 
37
                __ObjRelease(_base);
 
38
        }
 
39
}
 
40
 
 
41
SQClass::~SQClass()
 
42
{
 
43
        REMOVE_FROM_CHAIN(&_sharedstate->_gc_chain, this);
 
44
        Finalize();
 
45
}
 
46
 
 
47
bool SQClass::NewSlot(SQSharedState *ss,const SQObjectPtr &key,const SQObjectPtr &val,bool bstatic)
 
48
{
 
49
        SQObjectPtr temp;
 
50
        if(_locked)
 
51
                return false; //the class already has an instance so cannot be modified
 
52
        if(_members->Get(key,temp) && _isfield(temp)) //overrides the default value
 
53
        {
 
54
                _defaultvalues[_member_idx(temp)].val = val;
 
55
                return true;
 
56
        }
 
57
        if(type(val) == OT_CLOSURE || type(val) == OT_NATIVECLOSURE || bstatic) {
 
58
                SQInteger mmidx;
 
59
                if((type(val) == OT_CLOSURE || type(val) == OT_NATIVECLOSURE) &&
 
60
                        (mmidx = ss->GetMetaMethodIdxByName(key)) != -1) {
 
61
                        _metamethods[mmidx] = val;
 
62
                }
 
63
                else {
 
64
                        if(type(temp) == OT_NULL) {
 
65
                                SQClassMember m;
 
66
                                m.val = val;
 
67
                                _members->NewSlot(key,SQObjectPtr(_make_method_idx(_methods.size())));
 
68
                                _methods.push_back(m);
 
69
                        }
 
70
                        else {
 
71
                                _methods[_member_idx(temp)].val = val;
 
72
                        }
 
73
                }
 
74
                return true;
 
75
        }
 
76
        SQClassMember m;
 
77
        m.val = val;
 
78
        _members->NewSlot(key,SQObjectPtr(_make_field_idx(_defaultvalues.size())));
 
79
        _defaultvalues.push_back(m);
 
80
        return true;
 
81
}
 
82
 
 
83
SQInstance *SQClass::CreateInstance()
 
84
{
 
85
        if(!_locked) Lock();
 
86
        return SQInstance::Create(_opt_ss(this),this);
 
87
}
 
88
 
 
89
SQInteger SQClass::Next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval)
 
90
{
 
91
        SQObjectPtr oval;
 
92
        SQInteger idx = _members->Next(false,refpos,outkey,oval);
 
93
        if(idx != -1) {
 
94
                if(_ismethod(oval)) {
 
95
                        outval = _methods[_member_idx(oval)].val;
 
96
                }
 
97
                else {
 
98
                        SQObjectPtr &o = _defaultvalues[_member_idx(oval)].val;
 
99
                        outval = _realval(o);
 
100
                }
 
101
        }
 
102
        return idx;
 
103
}
 
104
 
 
105
bool SQClass::SetAttributes(const SQObjectPtr &key,const SQObjectPtr &val)
 
106
{
 
107
        SQObjectPtr idx;
 
108
        if(_members->Get(key,idx)) {
 
109
                if(_isfield(idx))
 
110
                        _defaultvalues[_member_idx(idx)].attrs = val;
 
111
                else
 
112
                        _methods[_member_idx(idx)].attrs = val;
 
113
                return true;
 
114
        }
 
115
        return false;
 
116
}
 
117
 
 
118
bool SQClass::GetAttributes(const SQObjectPtr &key,SQObjectPtr &outval)
 
119
{
 
120
        SQObjectPtr idx;
 
121
        if(_members->Get(key,idx)) {
 
122
                outval = (_isfield(idx)?_defaultvalues[_member_idx(idx)].attrs:_methods[_member_idx(idx)].attrs);
 
123
                return true;
 
124
        }
 
125
        return false;
 
126
}
 
127
 
 
128
///////////////////////////////////////////////////////////////////////
 
129
void SQInstance::Init(SQSharedState *ss)
 
130
{
 
131
        _userpointer = NULL;
 
132
        _hook = NULL;
 
133
        __ObjAddRef(_class);
 
134
        _delegate = _class->_members;
 
135
        INIT_CHAIN();
 
136
        ADD_TO_CHAIN(&_sharedstate->_gc_chain, this);
 
137
}
 
138
 
 
139
SQInstance::SQInstance(SQSharedState *ss, SQClass *c, SQInteger memsize)
 
140
{
 
141
        _memsize = memsize;
 
142
        _class = c;
 
143
        SQUnsignedInteger nvalues = _class->_defaultvalues.size();
 
144
        for(SQUnsignedInteger n = 0; n < nvalues; n++) {
 
145
                new (&_values[n]) SQObjectPtr(_class->_defaultvalues[n].val);
 
146
        }
 
147
        Init(ss);
 
148
}
 
149
 
 
150
SQInstance::SQInstance(SQSharedState *ss, SQInstance *i, SQInteger memsize)
 
151
{
 
152
        _memsize = memsize;
 
153
        _class = i->_class;
 
154
        SQUnsignedInteger nvalues = _class->_defaultvalues.size();
 
155
        for(SQUnsignedInteger n = 0; n < nvalues; n++) {
 
156
                new (&_values[n]) SQObjectPtr(i->_values[n]);
 
157
        }
 
158
        Init(ss);
 
159
}
 
160
 
 
161
void SQInstance::Finalize()
 
162
{
 
163
        SQUnsignedInteger nvalues = _class->_defaultvalues.size();
 
164
        __ObjRelease(_class);
 
165
        for(SQUnsignedInteger i = 0; i < nvalues; i++) {
 
166
                _values[i] = _null_;
 
167
        }
 
168
}
 
169
 
 
170
SQInstance::~SQInstance()
 
171
{
 
172
        REMOVE_FROM_CHAIN(&_sharedstate->_gc_chain, this);
 
173
        if(_class){ Finalize(); } //if _class is null it was already finalized by the GC
 
174
}
 
175
 
 
176
bool SQInstance::GetMetaMethod(SQVM *v,SQMetaMethod mm,SQObjectPtr &res)
 
177
{
 
178
        if(type(_class->_metamethods[mm]) != OT_NULL) {
 
179
                res = _class->_metamethods[mm];
 
180
                return true;
 
181
        }
 
182
        return false;
 
183
}
 
184
 
 
185
bool SQInstance::InstanceOf(SQClass *trg)
 
186
{
 
187
        SQClass *parent = _class;
 
188
        while(parent != NULL) {
 
189
                if(parent == trg)
 
190
                        return true;
 
191
                parent = parent->_base;
 
192
        }
 
193
        return false;
 
194
}