Skip to content

Commit dbd9442

Browse files
josesimoesjosesimoes
committed
Fix code style
***NO_CI***
1 parent b11a465 commit dbd9442

File tree

1 file changed

+69
-58
lines changed

1 file changed

+69
-58
lines changed

‎src/CLR/Core/CLR_RT_HeapBlock_Lock.cpp‎

Lines changed: 69 additions & 58 deletions
Original file line numberDiff line numberDiff line change
@@ -7,18 +7,22 @@
77

88
////////////////////////////////////////////////////////////////////////////////////////////////////
99

10-
HRESULT CLR_RT_HeapBlock_Lock::CreateInstance( CLR_RT_HeapBlock_Lock*& lock, CLR_RT_Thread* th, CLR_RT_HeapBlock& resource )
10+
HRESULT CLR_RT_HeapBlock_Lock::CreateInstance(
11+
CLR_RT_HeapBlock_Lock *&lock,
12+
CLR_RT_Thread *th,
13+
CLR_RT_HeapBlock &resource)
1114
{
1215
NATIVE_PROFILE_CLR_CORE();
1316
NANOCLR_HEADER();
1417

15-
lock = EVENTCACHE_EXTRACT_NODE(g_CLR_RT_EventCache,CLR_RT_HeapBlock_Lock,DATATYPE_LOCK_HEAD); CHECK_ALLOCATION(lock);
18+
lock = EVENTCACHE_EXTRACT_NODE(g_CLR_RT_EventCache, CLR_RT_HeapBlock_Lock, DATATYPE_LOCK_HEAD);
19+
CHECK_ALLOCATION(lock);
1620

1721
lock->m_owningThread = th; // CLR_RT_Thread* m_owningThread;
1822
//
19-
lock->m_resource.Assign( resource ); // CLR_RT_HeapBlock m_resource;
23+
lock->m_resource.Assign(resource); // CLR_RT_HeapBlock m_resource;
2024
//
21-
lock->m_owners .DblLinkedList_Initialize(); // CLR_RT_DblLinkedList m_owners;
25+
lock->m_owners.DblLinkedList_Initialize(); // CLR_RT_DblLinkedList m_owners;
2226
lock->m_requests.DblLinkedList_Initialize(); // CLR_RT_DblLinkedList m_requests;
2327

2428
#if defined(NANOCLR_APPDOMAINS)
@@ -27,44 +31,44 @@ HRESULT CLR_RT_HeapBlock_Lock::CreateInstance( CLR_RT_HeapBlock_Lock*& lock, CLR
2731

2832
//--//
2933

30-
if(resource.DataType() == DATATYPE_OBJECT)
34+
if (resource.DataType() == DATATYPE_OBJECT)
3135
{
32-
CLR_RT_HeapBlock* ptr = resource.Dereference();
36+
CLR_RT_HeapBlock *ptr = resource.Dereference();
3337

34-
if(ptr)
38+
if (ptr)
3539
{
36-
switch(ptr->DataType())
40+
switch (ptr->DataType())
3741
{
3842
case DATATYPE_VALUETYPE:
39-
case DATATYPE_CLASS :
40-
ptr->SetObjectLock( lock );
43+
case DATATYPE_CLASS:
44+
ptr->SetObjectLock(lock);
4145
break;
42-
46+
4347
default:
4448
// the remaining data types aren't to be handled
4549
break;
4650
}
4751
}
4852
}
4953

50-
th->m_locks.LinkAtBack( lock );
54+
th->m_locks.LinkAtBack(lock);
5155

5256
NANOCLR_NOCLEANUP();
5357
}
5458

55-
void CLR_RT_HeapBlock_Lock::DestroyOwner( CLR_RT_SubThread* sth )
59+
void CLR_RT_HeapBlock_Lock::DestroyOwner(CLR_RT_SubThread *sth)
5660
{
5761
NATIVE_PROFILE_CLR_CORE();
58-
NANOCLR_FOREACH_NODE(CLR_RT_HeapBlock_Lock::Owner,owner,m_owners)
62+
NANOCLR_FOREACH_NODE(CLR_RT_HeapBlock_Lock::Owner, owner, m_owners)
5963
{
60-
if(owner->m_owningSubThread == sth)
64+
if (owner->m_owningSubThread == sth)
6165
{
62-
g_CLR_RT_EventCache.Append_Node( owner );
66+
g_CLR_RT_EventCache.Append_Node(owner);
6367
}
6468
}
6569
NANOCLR_FOREACH_NODE_END();
6670

67-
if(m_owners.IsEmpty())
71+
if (m_owners.IsEmpty())
6872
{
6973
ChangeOwner();
7074
}
@@ -75,39 +79,41 @@ void CLR_RT_HeapBlock_Lock::ChangeOwner()
7579
NATIVE_PROFILE_CLR_CORE();
7680
m_owners.DblLinkedList_PushToCache();
7781

78-
while(true)
82+
while (true)
7983
{
80-
CLR_RT_HeapBlock_LockRequest* req = (CLR_RT_HeapBlock_LockRequest*)m_requests.ExtractFirstNode(); if(!req) break;
84+
CLR_RT_HeapBlock_LockRequest *req = (CLR_RT_HeapBlock_LockRequest *)m_requests.ExtractFirstNode();
85+
if (!req)
86+
break;
8187

82-
CLR_RT_SubThread* sth = req->m_subthreadWaiting;
83-
CLR_RT_Thread* th = sth->m_owningThread;
88+
CLR_RT_SubThread *sth = req->m_subthreadWaiting;
89+
CLR_RT_Thread *th = sth->m_owningThread;
8490

85-
g_CLR_RT_EventCache.Append_Node( req );
91+
g_CLR_RT_EventCache.Append_Node(req);
8692

87-
sth->ChangeLockRequestCount( -1 );
93+
sth->ChangeLockRequestCount(-1);
8894

89-
th->m_locks.LinkAtBack( this );
95+
th->m_locks.LinkAtBack(this);
9096

9197
m_owningThread = th;
9298

93-
CLR_RT_HeapBlock_Lock::IncrementOwnership( this, sth, TIMEOUT_INFINITE, false );
99+
CLR_RT_HeapBlock_Lock::IncrementOwnership(this, sth, TIMEOUT_INFINITE, false);
94100

95101
//
96102
// If the new owner was waiting on something, update the flags.
97103
//
98104
{
99-
CLR_RT_StackFrame* stack = th->CurrentFrame();
105+
CLR_RT_StackFrame *stack = th->CurrentFrame();
100106

101-
if(stack->m_flags & CLR_RT_StackFrame::c_PendingSynchronizeGlobally)
107+
if (stack->m_flags & CLR_RT_StackFrame::c_PendingSynchronizeGlobally)
102108
{
103109
stack->m_flags &= ~CLR_RT_StackFrame::c_PendingSynchronizeGlobally;
104-
stack->m_flags |= CLR_RT_StackFrame::c_SynchronizedGlobally;
110+
stack->m_flags |= CLR_RT_StackFrame::c_SynchronizedGlobally;
105111
}
106112

107-
if(stack->m_flags & CLR_RT_StackFrame::c_PendingSynchronize)
113+
if (stack->m_flags & CLR_RT_StackFrame::c_PendingSynchronize)
108114
{
109115
stack->m_flags &= ~CLR_RT_StackFrame::c_PendingSynchronize;
110-
stack->m_flags |= CLR_RT_StackFrame::c_Synchronized;
116+
stack->m_flags |= CLR_RT_StackFrame::c_Synchronized;
111117
}
112118
}
113119

@@ -117,42 +123,46 @@ void CLR_RT_HeapBlock_Lock::ChangeOwner()
117123
//
118124
// None is listening for this object, unlock it.
119125
//
120-
if(m_resource.DataType() == DATATYPE_OBJECT)
126+
if (m_resource.DataType() == DATATYPE_OBJECT)
121127
{
122-
CLR_RT_HeapBlock* ptr = m_resource.Dereference();
128+
CLR_RT_HeapBlock *ptr = m_resource.Dereference();
123129

124-
if(ptr)
130+
if (ptr)
125131
{
126-
switch(ptr->DataType())
132+
switch (ptr->DataType())
127133
{
128134
case DATATYPE_VALUETYPE:
129-
case DATATYPE_CLASS :
130-
ptr->SetObjectLock( NULL );
135+
case DATATYPE_CLASS:
136+
ptr->SetObjectLock(NULL);
131137
break;
132-
138+
133139
default:
134140
// the remaining data types aren't to be handled
135-
break;
141+
break;
136142
}
137143
}
138144
}
139145

140-
g_CLR_RT_EventCache.Append_Node( this );
146+
g_CLR_RT_EventCache.Append_Node(this);
141147
}
142148

143-
HRESULT CLR_RT_HeapBlock_Lock::IncrementOwnership( CLR_RT_HeapBlock_Lock* lock, CLR_RT_SubThread* sth, const CLR_INT64& timeExpire, bool fForce )
149+
HRESULT CLR_RT_HeapBlock_Lock::IncrementOwnership(
150+
CLR_RT_HeapBlock_Lock *lock,
151+
CLR_RT_SubThread *sth,
152+
const CLR_INT64 &timeExpire,
153+
bool fForce)
144154
{
145155
NATIVE_PROFILE_CLR_CORE();
146156
NANOCLR_HEADER();
147157

148-
CLR_RT_Thread* th = sth ->m_owningThread;
149-
CLR_RT_Thread* thOwner = lock->m_owningThread;
158+
CLR_RT_Thread *th = sth->m_owningThread;
159+
CLR_RT_Thread *thOwner = lock->m_owningThread;
150160

151-
if(thOwner == th)
161+
if (thOwner == th)
152162
{
153-
NANOCLR_FOREACH_NODE(CLR_RT_HeapBlock_Lock::Owner,owner,lock->m_owners)
163+
NANOCLR_FOREACH_NODE(CLR_RT_HeapBlock_Lock::Owner, owner, lock->m_owners)
154164
{
155-
if(owner->m_owningSubThread == sth)
165+
if (owner->m_owningSubThread == sth)
156166
{
157167
owner->m_recursion++;
158168
NANOCLR_SET_AND_LEAVE(S_OK);
@@ -161,45 +171,47 @@ HRESULT CLR_RT_HeapBlock_Lock::IncrementOwnership( CLR_RT_HeapBlock_Lock* lock,
161171
NANOCLR_FOREACH_NODE_END();
162172

163173
{
164-
CLR_RT_HeapBlock_Lock::Owner* owner = EVENTCACHE_EXTRACT_NODE(g_CLR_RT_EventCache,Owner,DATATYPE_LOCK_OWNER_HEAD); CHECK_ALLOCATION(owner);
174+
CLR_RT_HeapBlock_Lock::Owner *owner =
175+
EVENTCACHE_EXTRACT_NODE(g_CLR_RT_EventCache, Owner, DATATYPE_LOCK_OWNER_HEAD);
176+
CHECK_ALLOCATION(owner);
165177

166178
owner->m_owningSubThread = sth;
167-
owner->m_recursion = 1;
179+
owner->m_recursion = 1;
168180

169-
lock->m_owners.LinkAtFront( owner );
181+
lock->m_owners.LinkAtFront(owner);
170182
NANOCLR_SET_AND_LEAVE(S_OK);
171183
}
172184
}
173185

174186
//
175187
// Create a request and stop the calling thread.
176188
//
177-
NANOCLR_SET_AND_LEAVE(CLR_RT_HeapBlock_LockRequest::CreateInstance( lock, sth, timeExpire, fForce ));
189+
NANOCLR_SET_AND_LEAVE(CLR_RT_HeapBlock_LockRequest::CreateInstance(lock, sth, timeExpire, fForce));
178190

179191
NANOCLR_NOCLEANUP();
180192
}
181193

182-
HRESULT CLR_RT_HeapBlock_Lock::DecrementOwnership( CLR_RT_HeapBlock_Lock* lock, CLR_RT_SubThread* sth )
194+
HRESULT CLR_RT_HeapBlock_Lock::DecrementOwnership(CLR_RT_HeapBlock_Lock *lock, CLR_RT_SubThread *sth)
183195
{
184196
NATIVE_PROFILE_CLR_CORE();
185197
NANOCLR_HEADER();
186198

187-
CLR_RT_Thread* th = sth->m_owningThread;
199+
CLR_RT_Thread *th = sth->m_owningThread;
188200

189-
if(lock && lock->m_owningThread == th)
201+
if (lock && lock->m_owningThread == th)
190202
{
191-
NANOCLR_FOREACH_NODE(CLR_RT_HeapBlock_Lock::Owner,owner,lock->m_owners)
203+
NANOCLR_FOREACH_NODE(CLR_RT_HeapBlock_Lock::Owner, owner, lock->m_owners)
192204
{
193-
if(owner->m_owningSubThread == sth)
205+
if (owner->m_owningSubThread == sth)
194206
{
195-
if(--owner->m_recursion == 0)
207+
if (--owner->m_recursion == 0)
196208
{
197-
g_CLR_RT_EventCache.Append_Node( owner );
209+
g_CLR_RT_EventCache.Append_Node(owner);
198210
}
199211

200212
//--//
201213

202-
if(lock->m_owners.IsEmpty())
214+
if (lock->m_owners.IsEmpty())
203215
{
204216
lock->ChangeOwner();
205217
}
@@ -225,4 +237,3 @@ void CLR_RT_HeapBlock_Lock::Relocate_Owner()
225237
{
226238
NATIVE_PROFILE_CLR_CORE();
227239
}
228-

0 commit comments

Comments
 (0)