source: dev/trunk/abdev/BasicCompiler_Common/include/Procedure.h@ 340

Last change on this file since 340 was 336, checked in by dai_9181, 18 years ago

静的メソッドのデリゲートに対応
File size: 11.9 KB
Line 
1#pragma once
2
3#include <Hashmap.h>
4#include <option.h>
5#include <Program.h>
6#include <Class.h>
7#include <Method.h>
8#include <Procedure.h>
9#include <Parameter.h>
10#include <Variable.h>
11#include <CodeGenerator.h>
12#include <Source.h>
13
14class CClass;
15class CMethod;
16
17class Procedure : public Symbol
18{
19public:
20 // 種類
21 enum Kind{
22 Sub,
23 Function,
24 };
25
26private:
27 Kind kind;
28
29 bool isCdecl;
30 mutable bool isUsing;
31
32protected:
33
34 // パラメータ
35 Parameters params;
36
37 // 戻り値の型
38 Type returnType;
39
40 // ソースコードの位置
41 int codePos;
42
43 // XMLシリアライズ用
44private:
45 friend class boost::serialization::access;
46 template<class Archive> void serialize(Archive& ar, const unsigned int version)
47 {
48 trace_for_serialize( "serializing - Procedure" );
49
50 ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP( Symbol );
51 ar & BOOST_SERIALIZATION_NVP( kind );
52 ar & BOOST_SERIALIZATION_NVP( isCdecl );
53 ar & BOOST_SERIALIZATION_NVP( isUsing );
54 ar & BOOST_SERIALIZATION_NVP( params );
55 ar & BOOST_SERIALIZATION_NVP( returnType );
56 ar & BOOST_SERIALIZATION_NVP( codePos );
57 }
58
59public:
60 Procedure( const NamespaceScopes &namespaceScopes, const string &name, Kind kind, bool isCdecl )
61 : Symbol( namespaceScopes, name )
62 , kind( kind )
63 , isCdecl( isCdecl )
64 , isUsing( false )
65 , codePos( -1 )
66 {
67 }
68 Procedure()
69 {
70 }
71 ~Procedure(){
72 BOOST_FOREACH( Parameter *pParam, params ){
73 delete pParam;
74 }
75 }
76
77 bool IsSub() const
78 {
79 return ( kind == Sub );
80 }
81 bool IsFunction() const
82 {
83 return ( kind == Function );
84 }
85
86 bool IsCdecl() const
87 {
88 return isCdecl;
89 }
90 void Using() const
91 {
92 isUsing = true;
93 }
94 bool IsUsing() const
95 {
96 return isUsing;
97 }
98
99 int GetCodePos() const
100 {
101 return codePos;
102 }
103
104 const Parameters &Params() const
105 {
106 return params;
107 }
108 const Type &ReturnType() const
109 {
110 return returnType;
111 }
112};
113
114class UserProc : public Procedure, public Jenga::Common::ObjectInHashmap<UserProc>
115{
116public:
117 string _paramStr;
118
119private:
120 NamespaceScopesCollection importedNamespaces;
121
122 // 親クラスと対応するメソッド
123 const CClass *pParentClass;
124 CMethod *pMethod;
125
126 bool isMacro;
127
128 // パラメータの追加情報
129 int secondParmNum;
130 Parameters realParams;
131 int realSecondParmNum;
132
133 // 各種フラグ
134 bool isExport;
135 mutable bool isSystem;
136 mutable bool isAutoGeneration;
137 mutable bool isCompiled;
138
139 mutable DWORD beginOpAddress;
140 mutable DWORD endOpAddress;
141
142 // ローカル変数
143 mutable Variables localVars;
144
145 // 識別ID
146 int id;
147
148 // ネイティブコード
149 NativeCode nativeCode;
150
151 // XMLシリアライズ用
152private:
153 friend class boost::serialization::access;
154 template<class Archive> void serialize(Archive& ar, const unsigned int version)
155 {
156 trace_for_serialize( "serializing - UserProc" );
157
158 ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP( Procedure );
159 ar & BOOST_SERIALIZATION_NVP( _paramStr );
160 ar & BOOST_SERIALIZATION_NVP( importedNamespaces );
161 ar & boost::serialization::make_nvp("pParentClass", const_cast<CClass *&>(pParentClass) );
162 ar & BOOST_SERIALIZATION_NVP( pMethod );
163 ar & BOOST_SERIALIZATION_NVP( isMacro );
164 ar & BOOST_SERIALIZATION_NVP( secondParmNum );
165 ar & BOOST_SERIALIZATION_NVP( realParams );
166 ar & BOOST_SERIALIZATION_NVP( realSecondParmNum );
167 ar & BOOST_SERIALIZATION_NVP( isExport );
168 ar & BOOST_SERIALIZATION_NVP( isSystem );
169 ar & BOOST_SERIALIZATION_NVP( isAutoGeneration );
170 ar & BOOST_SERIALIZATION_NVP( isCompiled );
171 ar & BOOST_SERIALIZATION_NVP( beginOpAddress );
172 ar & BOOST_SERIALIZATION_NVP( endOpAddress );
173 ar & BOOST_SERIALIZATION_NVP( localVars );
174 ar & BOOST_SERIALIZATION_NVP( id );
175 ar & BOOST_SERIALIZATION_NVP( nativeCode );
176 }
177
178public:
179
180 UserProc( const NamespaceScopes &namespaceScopes, const NamespaceScopesCollection &importedNamespaces, const string &name, Kind kind, bool isMacro, bool isCdecl, bool isExport, int id )
181 : Procedure( namespaceScopes, name, kind, isCdecl )
182 , importedNamespaces( importedNamespaces )
183 , pParentClass( NULL )
184 , pMethod( NULL )
185 , isMacro( isMacro )
186 , isExport( isExport )
187 , isSystem( false )
188 , isAutoGeneration( false )
189 , isCompiled( false )
190 , beginOpAddress( 0 )
191 , endOpAddress( 0 )
192 , id( id )
193 {
194 }
195 UserProc()
196 {
197 }
198 ~UserProc()
199 {
200 BOOST_FOREACH( Parameter *pParam, realParams ){
201 delete pParam;
202 }
203 }
204
205 virtual const std::string &GetKeyName() const
206 {
207 return GetName();
208 }
209
210 virtual bool IsDuplication( const UserProc *pUserProc ) const
211 {
212 if( this->GetParentClassPtr() == pUserProc->GetParentClassPtr() // 親クラスが等しい
213 && pUserProc->IsEqualSymbol( *this ) // 名前空間及び名前が等しい
214 && this->Params().Equals( pUserProc->Params() ) // パラメータが等しい
215 && this->returnType.Equals( pUserProc->returnType ) ) // 戻り値が等しい
216 {
217 return true;
218 }
219 return false;
220 }
221
222 bool IsMacro() const
223 {
224 return isMacro;
225 }
226
227 int GetSecondParmNum() const
228 {
229 return secondParmNum;
230 }
231 const Parameters &RealParams() const
232 {
233 return realParams;
234 }
235 int GetRealSecondParmNum() const
236 {
237 return realSecondParmNum;
238 }
239
240 void ExportOff(){
241 isExport = false;
242 }
243 bool IsExport() const
244 {
245 return isExport;
246 }
247 void ThisIsSystemProc() const
248 {
249 isSystem = true;
250 }
251 bool IsSystem() const
252 {
253 return isSystem;
254 }
255 void ThisIsAutoGenerationProc() const
256 {
257 isAutoGeneration = true;
258 }
259 bool IsAutoGeneration() const
260 {
261 return isAutoGeneration;
262 }
263 void CompleteCompile() const
264 {
265 isCompiled = true;
266 }
267 void KillCompileStatus() const
268 {
269 isCompiled = false;
270 }
271 bool IsCompiled() const
272 {
273 return isCompiled;
274 }
275 bool IsDestructor() const
276 {
277 return ( GetName()[0] == '~' );
278 }
279
280 // バイナリコード位置とサイズ
281 DWORD GetBeginOpAddress() const
282 {
283 return beginOpAddress;
284 }
285 void SetBeginOpAddress( DWORD beginOpAddress ) const
286 {
287 this->beginOpAddress = beginOpAddress;
288 }
289 DWORD GetEndOpAddress() const
290 {
291 return endOpAddress;
292 }
293 void SetEndOpAddress( DWORD endOpAddress ) const
294 {
295 this->endOpAddress = endOpAddress;
296 }
297 int GetCodeSize() const
298 {
299 return endOpAddress - beginOpAddress;
300 }
301
302 virtual const NamespaceScopes &GetNamespaceScopes() const;
303 const NamespaceScopesCollection &GetImportedNamespaces() const;
304
305 Variables &GetLocalVars() const
306 {
307 return localVars;
308 }
309
310 int GetId() const
311 {
312 return id;
313 }
314
315 const NativeCode &GetNativeCode() const
316 {
317 return nativeCode;
318 }
319 NativeCode &GetNativeCode()
320 {
321 return nativeCode;
322 }
323
324 std::string GetFullName() const;
325
326 bool IsVirtual() const;
327
328 void SetParentClass( const CClass *pParentClass ){
329 this->pParentClass = pParentClass;
330 }
331 const CClass *GetParentClassPtr() const
332 {
333 return pParentClass;
334 }
335 const CClass &GetParentClass() const
336 {
337 return *pParentClass;
338 }
339 bool HasParentClass() const
340 {
341 return ( pParentClass != NULL );
342 }
343 bool IsGlobalProcedure() const
344 {
345 return ( pParentClass == NULL );
346 }
347 void SetMethod( CMethod *pMethod ){
348 this->pMethod = pMethod;
349 }
350 const CMethod &GetMethod() const;
351
352 bool SetParamsAndReturnType( const char *sourceOfParams, int nowLine, bool isStatic );
353
354
355
356 /////////////////////////////////////////////////////////////////
357 // コンパイル中の関数を管理
358 /////////////////////////////////////////////////////////////////
359private:
360 static const UserProc *pCompilingUserProc;
361public:
362 static void CompileStartForGlobalArea(){
363 pCompilingUserProc = NULL;
364 }
365 static void CompileStartForUserProc( const UserProc *pUserProc ){
366 pCompilingUserProc = pUserProc;
367 }
368 static bool IsGlobalAreaCompiling(){
369 return ( pCompilingUserProc == NULL );
370 }
371 static bool IsLocalAreaCompiling(){
372 return ( pCompilingUserProc != NULL );
373 }
374 static const UserProc &CompilingUserProc(){
375 return *pCompilingUserProc;
376 }
377};
378
379class UserProcs : public Jenga::Common::Hashmap<UserProc>
380{
381 std::vector<std::string> macroNames;
382
383 // XMLシリアライズ用
384private:
385 friend class boost::serialization::access;
386 template<class Archive> void serialize(Archive& ar, const unsigned int version)
387 {
388 trace_for_serialize( "serializing - UserProcs" );
389
390 ar & boost::serialization::make_nvp("Hashmap_UserProcImpl",
391 boost::serialization::base_object<Jenga::Common::Hashmap<UserProc>>(*this));
392 ar & BOOST_SERIALIZATION_NVP( macroNames );
393 }
394
395
396public:
397 UserProcs()
398 {
399 }
400 ~UserProcs()
401 {
402 }
403
404 bool Insert( UserProc *pUserProc, int nowLine );
405
406 UserProc *Add( const NamespaceScopes &namespaceScopes, const NamespaceScopesCollection &importedNamespaces, char *buffer,int nowLine,bool isVirtual,CClass *pobj_c, bool isStatic);
407
408 void EnumGlobalProcs( const char *simpleName, const char *localName, std::vector<const UserProc *> &subs );
409};
410
411class DllProc : public Procedure, public Jenga::Common::ObjectInHashmap<DllProc>
412{
413 string dllFileName;
414 string alias;
415 int lookupAddress;
416
417 // XMLシリアライズ用
418private:
419 friend class boost::serialization::access;
420 template<class Archive> void serialize(Archive& ar, const unsigned int version)
421 {
422 trace_for_serialize( "serializing - DllProc" );
423
424 ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP( Procedure );
425 ar & BOOST_SERIALIZATION_NVP( dllFileName );
426 ar & BOOST_SERIALIZATION_NVP( alias );
427 ar & BOOST_SERIALIZATION_NVP( lookupAddress );
428 }
429
430public:
431 DllProc( const NamespaceScopes &namespaceScopes, const string &name, Kind kind, bool isCdecl, const string &dllFileName, const string &alias )
432 : Procedure( namespaceScopes, name, kind, isCdecl )
433 , dllFileName( dllFileName )
434 , alias( alias )
435 , lookupAddress( 0 )
436 {
437 }
438 DllProc()
439 {
440 }
441 ~DllProc()
442 {
443 }
444
445 virtual const std::string &GetKeyName() const
446 {
447 return GetName();
448 }
449
450 virtual bool IsDuplication( const DllProc *pDllProc ) const
451 {
452 if( pDllProc->IsEqualSymbol( *this )
453 && this->Params().Equals( pDllProc->Params() ) )
454 {
455 return true;
456 }
457 return false;
458 }
459
460 const string &GetDllFileName() const
461 {
462 return dllFileName;
463 }
464 const string &GetAlias() const
465 {
466 return alias;
467 }
468
469 void SetLookupAddress( int lookupAddress ){
470 this->lookupAddress = lookupAddress;
471 }
472 int GetLookupAddress() const
473 {
474 return lookupAddress;
475 }
476
477 bool SetParamsAndReturnType( const char *sourceOfParams, int nowLine );
478};
479class DllProcs : public Jenga::Common::Hashmap<DllProc>
480{
481 // XMLシリアライズ用
482private:
483 friend class boost::serialization::access;
484 template<class Archive> void serialize(Archive& ar, const unsigned int version)
485 {
486 trace_for_serialize( "serializing - DllProcs" );
487
488 ar & boost::serialization::make_nvp("Hashmap_DllProc",
489 boost::serialization::base_object<Jenga::Common::Hashmap<DllProc>>(*this));
490 }
491
492public:
493 void Add(const NamespaceScopes &namespaceScopes, char *buffer,int nowLine);
494};
495
496void CollectProcedures( const BasicSource &source, UserProcs &userProcs, DllProcs &dllProcs );
497
498class ProcPointer : public Procedure
499{
500 // XMLシリアライズ用
501private:
502 friend class boost::serialization::access;
503 template<class Archive> void serialize(Archive& ar, const unsigned int version)
504 {
505 trace_for_serialize( "serializing - ProcPointer" );
506
507 ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP( Procedure );
508 }
509
510public:
511 ProcPointer( Kind kind )
512 : Procedure( NamespaceScopes(), std::string(), kind, false )
513 {
514 }
515 ProcPointer()
516 {
517 }
518 ~ProcPointer(){}
519
520 virtual bool SetParamsAndReturnType( const char *sourceOfParams, int nowLine );
521};
522
523class ProcPointers : public vector<ProcPointer *>
524{
525 // XMLシリアライズ用
526private:
527 friend class boost::serialization::access;
528 template<class Archive> void serialize(Archive& ar, const unsigned int version)
529 {
530 trace_for_serialize( "serializing - ProcPointers" );
531
532 ar & boost::serialization::make_nvp("vector_ProcPointer",
533 boost::serialization::base_object<vector<ProcPointer *>>(*this));
534 }
535
536public:
537 ProcPointers()
538 {
539 }
540 ~ProcPointers()
541 {
542 Clear();
543 }
544
545 int Add( const string &typeExpression );
546 void Clear();
547 void PullOutAll()
548 {
549 clear();
550 }
551};
Note: See TracBrowser for help on using the repository browser.