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

Last change on this file since 266 was 266, checked in by dai_9181, 17 years ago

BasicSourceのシリアライズがうまくいっていない

File size: 11.8 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 {
216 return true;
217 }
218 return false;
219 }
220
221 bool IsMacro() const
222 {
223 return isMacro;
224 }
225
226 int GetSecondParmNum() const
227 {
228 return secondParmNum;
229 }
230 const Parameters &RealParams() const
231 {
232 return realParams;
233 }
234 int GetRealSecondParmNum() const
235 {
236 return realSecondParmNum;
237 }
238
239 void ExportOff(){
240 isExport = false;
241 }
242 bool IsExport() const
243 {
244 return isExport;
245 }
246 void ThisIsSystemProc() const
247 {
248 isSystem = true;
249 }
250 bool IsSystem() const
251 {
252 return isSystem;
253 }
254 void ThisIsAutoGenerationProc() const
255 {
256 isAutoGeneration = true;
257 }
258 bool IsAutoGeneration() const
259 {
260 return isAutoGeneration;
261 }
262 void CompleteCompile() const
263 {
264 isCompiled = true;
265 }
266 void KillCompileStatus() const
267 {
268 isCompiled = false;
269 }
270 bool IsCompiled() const
271 {
272 return isCompiled;
273 }
274 bool IsDestructor() const
275 {
276 return ( GetName()[0] == '~' );
277 }
278
279 // バイナリコード位置とサイズ
280 DWORD GetBeginOpAddress() const
281 {
282 return beginOpAddress;
283 }
284 void SetBeginOpAddress( DWORD beginOpAddress ) const
285 {
286 this->beginOpAddress = beginOpAddress;
287 }
288 DWORD GetEndOpAddress() const
289 {
290 return endOpAddress;
291 }
292 void SetEndOpAddress( DWORD endOpAddress ) const
293 {
294 this->endOpAddress = endOpAddress;
295 }
296 int GetCodeSize() const
297 {
298 return endOpAddress - beginOpAddress;
299 }
300
301 virtual const NamespaceScopes &GetNamespaceScopes() const;
302 const NamespaceScopesCollection &GetImportedNamespaces() const;
303
304 Variables &GetLocalVars() const
305 {
306 return localVars;
307 }
308
309 int GetId() const
310 {
311 return id;
312 }
313
314 const NativeCode &GetNativeCode() const
315 {
316 return nativeCode;
317 }
318 NativeCode &GetNativeCode()
319 {
320 return nativeCode;
321 }
322
323 std::string GetFullName() const;
324
325 bool IsVirtual() const;
326
327 void SetParentClass( const CClass *pParentClass ){
328 this->pParentClass = pParentClass;
329 }
330 const CClass *GetParentClassPtr() const
331 {
332 return pParentClass;
333 }
334 const CClass &GetParentClass() const
335 {
336 return *pParentClass;
337 }
338 bool HasParentClass() const
339 {
340 return ( pParentClass != NULL );
341 }
342 bool IsGlobalProcedure() const
343 {
344 return ( pParentClass == NULL );
345 }
346 void SetMethod( CMethod *pMethod ){
347 this->pMethod = pMethod;
348 }
349
350 bool SetParamsAndReturnType( const char *sourceOfParams, int nowLine, bool isStatic );
351
352
353
354 /////////////////////////////////////////////////////////////////
355 // コンパイル中の関数を管理
356 /////////////////////////////////////////////////////////////////
357private:
358 static const UserProc *pCompilingUserProc;
359public:
360 static void CompileStartForGlobalArea(){
361 pCompilingUserProc = NULL;
362 }
363 static void CompileStartForUserProc( const UserProc *pUserProc ){
364 pCompilingUserProc = pUserProc;
365 }
366 static bool IsGlobalAreaCompiling(){
367 return ( pCompilingUserProc == NULL );
368 }
369 static bool IsLocalAreaCompiling(){
370 return ( pCompilingUserProc != NULL );
371 }
372 static const UserProc &CompilingUserProc(){
373 return *pCompilingUserProc;
374 }
375
376
377
378 mutable long _beginOpAddressOld;
379 mutable long _endOpAddressOld;
380};
381
382class UserProcs : public Jenga::Common::Hashmap<UserProc>
383{
384 std::vector<std::string> macroNames;
385
386 // XMLシリアライズ用
387private:
388 friend class boost::serialization::access;
389 template<class Archive> void serialize(Archive& ar, const unsigned int version)
390 {
391 trace_for_serialize( "serializing - UserProcs" );
392
393 ar & boost::serialization::make_nvp("Hashmap_UserProcImpl",
394 boost::serialization::base_object<Jenga::Common::Hashmap<UserProc>>(*this));
395 ar & BOOST_SERIALIZATION_NVP( macroNames );
396 }
397
398
399public:
400 UserProcs()
401 {
402 }
403 ~UserProcs()
404 {
405 }
406
407 bool Insert( UserProc *pUserProc, int nowLine );
408
409 UserProc *Add( const NamespaceScopes &namespaceScopes, const NamespaceScopesCollection &importedNamespaces, char *buffer,int nowLine,bool isVirtual,CClass *pobj_c, bool isStatic);
410
411 void EnumGlobalProcs( const char *simpleName, const char *localName, std::vector<const UserProc *> &subs );
412};
413
414class DllProc : public Procedure, public Jenga::Common::ObjectInHashmap<DllProc>
415{
416 string dllFileName;
417 string alias;
418 int lookupAddress;
419
420 // XMLシリアライズ用
421private:
422 friend class boost::serialization::access;
423 template<class Archive> void serialize(Archive& ar, const unsigned int version)
424 {
425 trace_for_serialize( "serializing - DllProc" );
426
427 ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP( Procedure );
428 ar & BOOST_SERIALIZATION_NVP( dllFileName );
429 ar & BOOST_SERIALIZATION_NVP( alias );
430 ar & BOOST_SERIALIZATION_NVP( lookupAddress );
431 }
432
433public:
434 // ハッシュリスト用
435 DllProc *pNextData;
436
437 DllProc( const NamespaceScopes &namespaceScopes, const string &name, Kind kind, bool isCdecl, const string &dllFileName, const string &alias )
438 : Procedure( namespaceScopes, name, kind, isCdecl )
439 , dllFileName( dllFileName )
440 , alias( alias )
441 , lookupAddress( 0 )
442 , pNextData( NULL )
443 {
444 }
445 DllProc()
446 {
447 }
448 ~DllProc()
449 {
450 }
451
452 virtual const std::string &GetKeyName() const
453 {
454 return GetName();
455 }
456
457 virtual bool IsDuplication( const DllProc *pDllProc ) const
458 {
459 if( pDllProc->IsEqualSymbol( *this )
460 && this->Params().Equals( pDllProc->Params() ) )
461 {
462 return true;
463 }
464 return false;
465 }
466
467 const string &GetDllFileName() const
468 {
469 return dllFileName;
470 }
471 const string &GetAlias() const
472 {
473 return alias;
474 }
475
476 void SetLookupAddress( int lookupAddress ){
477 this->lookupAddress = lookupAddress;
478 }
479 int GetLookupAddress() const
480 {
481 return lookupAddress;
482 }
483
484 bool SetParamsAndReturnType( const char *sourceOfParams, int nowLine );
485};
486class DllProcs : public Jenga::Common::Hashmap<DllProc>
487{
488 // XMLシリアライズ用
489private:
490 friend class boost::serialization::access;
491 template<class Archive> void serialize(Archive& ar, const unsigned int version)
492 {
493 trace_for_serialize( "serializing - DllProcs" );
494
495 ar & boost::serialization::make_nvp("Hashmap_DllProc",
496 boost::serialization::base_object<Jenga::Common::Hashmap<DllProc>>(*this));
497 }
498
499public:
500 void Add(const NamespaceScopes &namespaceScopes, char *buffer,int nowLine);
501};
502
503void CollectProcedures( const BasicSource &source, UserProcs &userProcs, DllProcs &dllProcs );
504
505class ProcPointer : public Procedure
506{
507 // XMLシリアライズ用
508private:
509 friend class boost::serialization::access;
510 template<class Archive> void serialize(Archive& ar, const unsigned int version)
511 {
512 trace_for_serialize( "serializing - ProcPointer" );
513
514 ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP( Procedure );
515 }
516
517public:
518 ProcPointer( Kind kind )
519 : Procedure( NamespaceScopes(), std::string(), kind, false )
520 {
521 }
522 ProcPointer()
523 {
524 }
525 ~ProcPointer(){}
526
527 virtual bool SetParamsAndReturnType( const char *sourceOfParams, int nowLine );
528};
529
530class ProcPointers : public vector<ProcPointer *>
531{
532 // XMLシリアライズ用
533private:
534 friend class boost::serialization::access;
535 template<class Archive> void serialize(Archive& ar, const unsigned int version)
536 {
537 trace_for_serialize( "serializing - ProcPointers" );
538
539 ar & boost::serialization::make_nvp("vector_ProcPointer",
540 boost::serialization::base_object<vector<ProcPointer *>>(*this));
541 }
542
543public:
544 ProcPointers()
545 {
546 }
547 ~ProcPointers()
548 {
549 Clear();
550 }
551
552 virtual int Add( const string &typeExpression );
553 virtual void Clear();
554};
Note: See TracBrowser for help on using the repository browser.