source: dev/trunk/ab5.0/abdev/BasicCompiler_Common/src/LexicalAnalyzer.cpp@ 542

Last change on this file since 542 was 542, checked in by dai_9181, 16 years ago

CollectTypeDefsメソッドをLexicalAnalyzerクラスに移動した。
File size: 16.9 KB
RevLine 
[506]1#include "stdafx.h"
2
3using namespace ActiveBasic::Compiler;
4
[531]5LexicalAnalyzer::SourceTemplate::SourceTemplate( const std::string &filePath )
6{
7 Jenga::Common::File file = Jenga::Common::File( GetApplicationBaseFullPath( filePath ) );
8 source = file.Read();
9}
10std::string LexicalAnalyzer::SourceTemplate::GetResult( const std::map<std::string,std::string> &values )
11{
12 std::string result = source;
13
14 std::map<std::string,std::string>::const_iterator it = values.begin();
15 while( it != values.end() )
16 {
17 while( true )
18 {
19 std::string::size_type index = result.find( it->first );
20 if( index == std::string::npos )
21 {
22 break;
23 }
24
25 result = result.substr( 0, index ) + it->second + result.substr( index + it->first.length() );
26 }
27 it++;
28 }
29
30 return result;
31}
32
33
[506]34bool LexicalAnalyzer::CollectNamespaces( const char *source, NamespaceScopesCollection &namespaceScopesCollection )
35{
36 int i, i2;
37 char temporary[1024];
38
39 bool isSuccessful = true;
40
41 // 名前空間管理
42 NamespaceScopes namespaceScopes;
43
44 for(i=0;;i++){
45 if(source[i]=='\0') break;
46
47 if( source[i] == 1 && source[i+1] == ESC_NAMESPACE ){
48 for(i+=2,i2=0;;i2++,i++){
49 if( IsCommandDelimitation( source[i] ) ){
50 temporary[i2]=0;
51 break;
52 }
53 temporary[i2]=source[i];
54 }
55 namespaceScopes.push_back( temporary );
56
57 if( !namespaceScopesCollection.IsExist( namespaceScopes ) ){
58 namespaceScopesCollection.push_back( namespaceScopes );
59 }
60
61 continue;
62 }
63 else if( source[i] == 1 && source[i+1] == ESC_ENDNAMESPACE ){
64 if( namespaceScopes.size() <= 0 ){
65 compiler.errorMessenger.Output( 12, "End Namespace", i );
66 isSuccessful = false;
67 }
68 else{
69 namespaceScopes.pop_back();
70 }
71
72 i += 2;
73 continue;
74 }
75 }
76
77 if( namespaceScopes.size() > 0 ){
78 compiler.errorMessenger.Output( 63, NULL, cp );
79 isSuccessful = false;
80 }
81
82 return isSuccessful;
83}
[508]84
85Symbol LexicalAnalyzer::FullNameToSymbol( const char *fullName )
86{
87 char areaName[VN_SIZE] = ""; //オブジェクト変数
88 char nestName[VN_SIZE] = ""; //入れ子メンバ
89 bool isNest = SplitMemberName( fullName, areaName, nestName );
90
91 return Symbol( NamespaceScopes( areaName ), nestName );
92}
93
94Symbol LexicalAnalyzer::FullNameToSymbol( const std::string &fullName )
95{
96 return FullNameToSymbol( fullName.c_str() );
97}
[511]98
99void LexicalAnalyzer::CollectClassesForNameOnly( const char *source, Classes &classes )
100{
101 int i, i2;
102 char temporary[VN_SIZE];
103
104 // 名前空間管理
105 NamespaceScopes &namespaceScopes = compiler.GetNamespaceSupporter().GetLivingNamespaceScopes();
106 namespaceScopes.clear();
107
108 // Importsされた名前空間の管理
109 NamespaceScopesCollection &importedNamespaces = compiler.GetNamespaceSupporter().GetImportedNamespaces();
110 importedNamespaces.clear();
111
112 for(i=0;;i++){
113 if(source[i]=='\0') break;
114
115 if( source[i] == 1 && source[i+1] == ESC_NAMESPACE ){
116 for(i+=2,i2=0;;i2++,i++){
117 if( IsCommandDelimitation( source[i] ) ){
118 temporary[i2]=0;
119 break;
120 }
121 temporary[i2]=source[i];
122 }
123 namespaceScopes.push_back( temporary );
124
125 continue;
126 }
127 else if( source[i] == 1 && source[i+1] == ESC_ENDNAMESPACE ){
128 if( namespaceScopes.size() <= 0 ){
129 compiler.errorMessenger.Output(12, "End Namespace", i );
130 }
131 else{
132 namespaceScopes.pop_back();
133 }
134
135 i += 2;
136 continue;
137 }
138 else if( source[i] == 1 && source[i+1] == ESC_IMPORTS ){
139 for(i+=2,i2=0;;i2++,i++){
140 if( IsCommandDelimitation( source[i] ) ){
141 temporary[i2]=0;
142 break;
143 }
144 temporary[i2]=source[i];
145 }
146 if( !compiler.GetNamespaceSupporter().ImportsNamespace( temporary ) )
147 {
148 compiler.errorMessenger.Output(64,temporary,i );
149 }
150
151 continue;
152 }
153 else if( source[i] == 1 && source[i+1] == ESC_CLEARNAMESPACEIMPORTED ){
154 importedNamespaces.clear();
155 continue;
156 }
157
158 if(source[i]==1&&(
159 source[i+1]==ESC_CLASS||
160 source[i+1]==ESC_TYPE||
161 source[i+1]==ESC_INTERFACE
162 ))
163 {
164 int nowLine = i;
165 i += 2;
166
167 Type blittableType;
168 if(memicmp(source+i,"Align(",6)==0){
169 //アラインメント修飾子
170 i+=6;
171 i=JumpStringInPare(source,i)+1;
172 }
173 else if( memicmp( source + i, "Blittable(", 10 ) == 0 ){
174 // Blittable修飾子
175 i+=10;
176 i+=GetStringInPare_RemovePare(temporary,source+i)+1;
177 compiler.StringToType( temporary, blittableType );
178 }
179
180 bool isEnum = false;
181 bool isDelegate = false;
182 if( source[i] == 1 && source[i+1] == ESC_ENUM ){
183 // 列挙型の場合
184 isEnum = true;
185
186 i += 2;
187 }
188 else if( source[i] == 1 && source[i+1] == ESC_DELEGATE )
189 {
190 // デリゲートの場合
191 isDelegate = true;
192
193 i += 2;
194 }
195
196 for(i2=0;;i++,i2++){
197 if(!IsVariableChar(source[i])){
198 temporary[i2]=0;
199 break;
200 }
201 temporary[i2]=source[i];
202 }
203
204 //クラスを追加
205 CClass *pClass = classes.Add(namespaceScopes, importedNamespaces, temporary,nowLine);
206 if( pClass ){
207 if( source[nowLine+1] == ESC_CLASS ){
208 if( isEnum )
209 {
210 pClass->SetClassType( CClass::Enum );
211 }
212 else if( isDelegate )
213 {
214 pClass->SetClassType( CClass::Delegate );
215 }
216 else{
217 pClass->SetClassType( CClass::Class );
218 }
219 }
220 else if( source[nowLine+1] == ESC_INTERFACE ){
221 pClass->SetClassType( CClass::Interface );
222 }
223 else{
224 pClass->SetClassType( CClass::Structure );
225 }
226 }
227
228 // Blittable型の場合
229 if( !blittableType.IsNull() ){
230 pClass->SetBlittableType( blittableType );
231
232 // Blittable型として登録
233 compiler.GetObjectModule().meta.GetBlittableTypes().push_back( BlittableType( blittableType, pClass ) );
234 }
235 }
236 }
237}
238
[542]239void LexicalAnalyzer::AddTypeDef( TypeDefCollection &typeDefs, const NamespaceScopes &namespaceScopes, const std::string &expression, int nowLine )
240{
241 int i;
242 char temporary[VN_SIZE];
243
244 for(i=0;;i++){
245 if(expression[i]=='='||expression[i]=='\0'){
246 temporary[i]=0;
247 break;
248 }
249 temporary[i]=expression[i];
250 }
251
252 if(expression[i]!='='){
253 compiler.errorMessenger.Output(10,"TypeDef",nowLine);
254 return;
255 }
256
257 const char *pTemp=expression.c_str()+i+1;
258
259 //識別文字のエラーチェック（新しい型）
260 i=0;
261 for(;;i++){
262 if(temporary[i]=='\0') break;
263 if( !( IsVariableChar( temporary[i], true) ) ){
264 compiler.errorMessenger.Output(10,"TypeDef",nowLine);
265 return;
266 }
267 }
268
269 //識別文字のエラーチェック（コピー元の型）
270 if(pTemp[0]=='*'&&pTemp[1]==1&&(pTemp[2]==ESC_FUNCTION||pTemp[2]==ESC_SUB)){
271 //関数ポインタ
272 if(pTemp[3]!='('){
273 compiler.errorMessenger.Output(10,"TypeDef",nowLine);
274 return;
275 }
276 }
277 else{
278 i=0;
279 while(pTemp[i]=='*') i++;
280 for(;;i++){
281 if(pTemp[i]=='\0') break;
282 if( !( IsVariableChar( pTemp[i], true) ) )
283 {
284 compiler.errorMessenger.Output(10,"TypeDef",nowLine);
285 return;
286 }
287 }
288 }
289
290 //識別子が重複している場合はエラーにする
291 if(lstrcmp(temporary,pTemp)==0){
292 compiler.errorMessenger.Output(1,NULL,nowLine);
293 return;
294 }
295
296
297
298 //////////////////////////
299 // TypeDef情報を追加
300 //////////////////////////
301
302 Type baseType;
303 if( !compiler.StringToType( pTemp, baseType ) )
304 {
305 compiler.errorMessenger.Output(3, pTemp, nowLine );
306 return;
307 }
308
309 typeDefs.push_back(
310 TypeDef(
311 namespaceScopes,
312 temporary,
313 pTemp,
314 baseType
315 )
316 );
317}
318void LexicalAnalyzer::CollectTypeDefs( const char *source, TypeDefCollection &typeDefs )
319{
320 // 名前空間管理
321 NamespaceScopes &namespaceScopes = compiler.GetNamespaceSupporter().GetLivingNamespaceScopes();
322 namespaceScopes.clear();
323
324 // Importsされた名前空間の管理
325 NamespaceScopesCollection &importedNamespaces = compiler.GetNamespaceSupporter().GetImportedNamespaces();
326 importedNamespaces.clear();
327
328 int i=-1, i2;
329 char temporary[VN_SIZE];
330 while(1){
331 extern char *basbuf;
332
333 i++;
334
335 if( basbuf[i] == 1 && basbuf[i+1] == ESC_NAMESPACE ){
336 for(i+=2,i2=0;;i2++,i++){
337 if( IsCommandDelimitation( basbuf[i] ) ){
338 temporary[i2]=0;
339 break;
340 }
341 temporary[i2]=basbuf[i];
342 }
343 namespaceScopes.push_back( temporary );
344
345 continue;
346 }
347 else if( basbuf[i] == 1 && basbuf[i+1] == ESC_ENDNAMESPACE ){
348 if( namespaceScopes.size() <= 0 ){
349 compiler.errorMessenger.Output(12, "End Namespace", i );
350 }
351 else{
352 namespaceScopes.pop_back();
353 }
354
355 i += 2;
356 continue;
357 }
358 else if( basbuf[i] == 1 && basbuf[i+1] == ESC_IMPORTS ){
359 for(i+=2,i2=0;;i2++,i++){
360 if( IsCommandDelimitation( basbuf[i] ) ){
361 temporary[i2]=0;
362 break;
363 }
364 temporary[i2]=basbuf[i];
365 }
366 if( !compiler.GetNamespaceSupporter().ImportsNamespace( temporary ) )
367 {
368 compiler.errorMessenger.Output(64,temporary,i );
369 }
370
371 continue;
372 }
373 else if( basbuf[i] == 1 && basbuf[i+1] == ESC_CLEARNAMESPACEIMPORTED ){
374 importedNamespaces.clear();
375 continue;
376 }
377
378 if( basbuf[i]==1 ){
379 char temporary[VN_SIZE];
380 if(basbuf[i+1]==ESC_TYPEDEF){
381 int i2 = 0;
382 for(i+=2;;i2++,i++){
383 if(basbuf[i]=='\n'){
384 temporary[i2]=0;
385 break;
386 }
387 temporary[i2]=basbuf[i];
388 if(basbuf[i]=='\0') break;
389 }
390 AddTypeDef( typeDefs, namespaceScopes, temporary, i );
391
392 continue;
393 }
394 else if( basbuf[i+1] == ESC_CONST && basbuf[i+2] == 1 && basbuf[i+3] == ESC_ENUM ){
395 int i2 = 0;
396 for(i+=4;;i2++,i++){
397 if(!IsVariableChar(basbuf[i])){
398 temporary[i2]=0;
399 break;
400 }
401 temporary[i2]=basbuf[i];
402 if(basbuf[i]=='\0') break;
403 }
404
405 Type baseType;
406 if( !compiler.StringToType( "Long", baseType ) )
407 {
408 throw;
409 }
410
411 typeDefs.push_back(
412 TypeDef(
413 namespaceScopes,
414 temporary,
415 "Long",
416 baseType
417 )
418 );
419 }
420 }
421
422 //次の行
423 for(;;i++){
424 if(IsCommandDelimitation(basbuf[i])) break;
425 }
426 if(basbuf[i]=='\0') break;
427 }
428}
429
[511]430UserProc* LexicalAnalyzer::ParseUserProc( const NamespaceScopes &namespaceScopes, const NamespaceScopesCollection &importedNamespaces, char *buffer,int nowLine,bool isVirtual,CClass *pobj_c, bool isStatic, char *interfaceName )
431{
432 int i2,i3;
433 char temporary[8192];
434
435 int i=1;
436
437 Procedure::Kind kind = Procedure::Sub;
438 bool isMacro = false;
439 if(buffer[i]==ESC_FUNCTION) kind = Procedure::Function;
440 if(buffer[i]==ESC_MACRO){
441 isMacro = true;
442 }
443
444 i++;
445
446 bool isCdecl = false;
447 bool isExport = false;
448 while(1){
449 if(buffer[i]==1&&buffer[i+1]==ESC_CDECL&& isCdecl == false ){
450 isCdecl = true;
451
452 i+=2;
453 }
454 else if(buffer[i]==1&&buffer[i+1]==ESC_EXPORT&& isExport == false ){
455 isExport = true;
456
457 i+=2;
458 }
459 else break;
460 }
461
462 i2=0;
463 if(buffer[i]==1&&buffer[i+1]==ESC_OPERATOR){
464 if(!pobj_c){
465 compiler.errorMessenger.Output(126,NULL,nowLine);
466 return 0;
467 }
468
469 //オペレータの場合
470 temporary[i2++]=buffer[i++];
471 temporary[i2++]=buffer[i++];
472
473 int iCalcId;
474 if(buffer[i]=='='&&buffer[i+1]=='='){
475 iCalcId=CALC_EQUAL;
476 i3=2;
477 }
478 else if(buffer[i]=='='){
479 iCalcId=CALC_SUBSITUATION;
480 i3=1;
481 }
482 else if(buffer[i]=='('){
483 iCalcId=CALC_AS;
484 i3=0;
485 }
486 else if(buffer[i]=='['&&buffer[i+1]==']'&&buffer[i+2]=='='){
487 iCalcId=CALC_ARRAY_SET;
488 i3=3;
489 }
490 else if(buffer[i]=='['&&buffer[i+1]==']'){
491 iCalcId=CALC_ARRAY_GET;
492 i3=2;
493 }
494 else{
495 iCalcId=GetCalcId(buffer+i,&i3);
496 i3++;
497 }
498 if(!iCalcId){
499 compiler.errorMessenger.Output(1,NULL,nowLine);
500 return 0;
501 }
502 temporary[i2++]=iCalcId;
503 temporary[i2]=0;
504
505 i+=i3;
506 }
507 else{
508 if(pobj_c){
509 //クラスメンバの場合、デストラクタには~が付くことを考慮
510 if(buffer[i]=='~'){
511 temporary[i2]='~';
512 i++;
513 i2++;
514 }
515 }
516
517 for(;;i++,i2++){
518 if(!IsVariableChar(buffer[i])){
519 temporary[i2]=0;
520 break;
521 }
522 temporary[i2]=buffer[i];
523 }
524
525 char parentName[VN_SIZE], memberName[VN_SIZE];
526 ReferenceKind refKind;
527 if( SplitMemberName( temporary, parentName, memberName, refKind ) )
528 {
529 if( pobj_c )
530 {
531 if( interfaceName )
532 {
533 lstrcpy( interfaceName, parentName );
534 }
535 else
536 {
537 compiler.errorMessenger.OutputFatalError();
538 return NULL;
539 }
540
541 char dummyMemberName[VN_SIZE];
542 if( SplitMemberName( memberName, parentName, dummyMemberName, refKind ) )
543 {
544 compiler.errorMessenger.Output(69,temporary,nowLine);
545 return NULL;
546 }
547 }
548 else
549 {
550 compiler.errorMessenger.Output(68,temporary,nowLine);
551 return NULL;
552 }
553
554 lstrcpy( temporary, memberName );
555 }
556 }
557
558 if( isMacro ){
559 //大文字に変換
560 CharUpper(temporary);
561 }
562
563 if(!pobj_c){
564 //クラスメンバ以外の場合のみ
565 //重複チェック
566
567 if(GetDeclareHash(temporary)){
568 compiler.errorMessenger.Output(15,temporary,nowLine);
569 return 0;
570 }
571 }
572
573 UserProc *pUserProc = new UserProc( namespaceScopes, importedNamespaces, temporary, kind, isMacro, isCdecl, isExport );
574 pUserProc->SetParentClass( pobj_c );
575
576 // 親インターフェイスをセット
577 if( interfaceName && interfaceName[0] )
578 {
579 ::Interface *pTargetInterface = NULL;
580 BOOST_FOREACH( ::Interface *pInterface, pobj_c->GetInterfaces() )
581 {
582 if( pInterface->GetClass().GetName() == interfaceName )
583 {
584 pTargetInterface = pInterface;
585 break;
586 }
587 }
588 pUserProc->SetInterface( pTargetInterface );
589 }
590
591 if(isExport){
592 pUserProc->Using();
593 }
594
595 // パラメータを解析
596 // ※第1パラメータにに指定するデータの例："( s As String ) As String"
597 pUserProc->SetParamsAndReturnType( buffer + i, nowLine, isStatic );
598
599 pUserProc->_paramStr = buffer + i;
600
601 return pUserProc;
602}
603
604void LexicalAnalyzer::CollectProcedures( const BasicSource &source, UserProcs &userProcs, DllProcs &dllProcs )
605{
606 extern HANDLE hHeap;
607 int i,i2,i3;
608 char temporary[8192];
609
610 // 名前空間管理
611 NamespaceScopes &namespaceScopes = compiler.GetNamespaceSupporter().GetLivingNamespaceScopes();
612 namespaceScopes.clear();
613
614 // Importsされた名前空間の管理
615 NamespaceScopesCollection &importedNamespaces = compiler.GetNamespaceSupporter().GetImportedNamespaces();
616 importedNamespaces.clear();
617
618 i=-1;
619 while(1){
620 i++;
621
622 if(source[i]==1&&(source[i+1]==ESC_CLASS||source[i+1]==ESC_INTERFACE)){
623 /* Class ～ End Class
624 Interface ～ End Interface
625 を飛び越す */
626 i3=GetEndXXXCommand(source[i+1]);
627 for(i+=2,i2=0;;i++,i2++){
628 if(source[i]=='\0') break;
629 if(source[i]==1&&source[i+1]==(char)i3){
630 i++;
631 break;
632 }
633 }
634 if(source[i]=='\0') break;
635 continue;
636 }
637
638 if( source[i] == 1 && source[i+1] == ESC_NAMESPACE ){
639 for(i+=2,i2=0;;i2++,i++){
640 if( IsCommandDelimitation( source[i] ) ){
641 temporary[i2]=0;
642 break;
643 }
644 temporary[i2]=source[i];
645 }
646 namespaceScopes.push_back( temporary );
647
648 continue;
649 }
650 else if( source[i] == 1 && source[i+1] == ESC_ENDNAMESPACE ){
651 if( namespaceScopes.size() <= 0 ){
652 compiler.errorMessenger.Output(12, "End Namespace", i );
653 }
654 else{
655 namespaceScopes.pop_back();
656 }
657
658 i += 2;
659 continue;
660 }
661 else if( source[i] == 1 && source[i+1] == ESC_IMPORTS ){
662 for(i+=2,i2=0;;i2++,i++){
663 if( IsCommandDelimitation( source[i] ) ){
664 temporary[i2]=0;
665 break;
666 }
667 temporary[i2]=source[i];
668 }
669 if( !compiler.GetNamespaceSupporter().ImportsNamespace( temporary ) )
670 {
671 compiler.errorMessenger.Output(64,temporary,cp );
672 }
673
674 continue;
675 }
676 else if( source[i] == 1 && source[i+1] == ESC_CLEARNAMESPACEIMPORTED ){
677 importedNamespaces.clear();
678 continue;
679 }
680
681 if(source[i]==1&&source[i+1]==ESC_DECLARE){
682 for(i+=2,i2=0;;i2++,i++){
683 if(source[i]=='\n'){
684 temporary[i2]=0;
685 break;
686 }
687 temporary[i2]=source[i];
688 if(source[i]=='\0') break;
689 }
690 dllProcs.Add(namespaceScopes,temporary,i);
691
692 continue;
693 }
694 if(source[i]==1&&(source[i+1]==ESC_SUB||source[i+1]==ESC_FUNCTION||source[i+1]==ESC_MACRO)){
695 char statementChar = source[i+1];
696
697 for(i2=0;;i2++,i++){
698 if(IsCommandDelimitation(source[i])){
699 temporary[i2]=0;
700 break;
701 }
702 temporary[i2]=source[i];
703 if(source[i]=='\0') break;
704 }
705
706 UserProc *pUserProc = ParseUserProc( namespaceScopes, importedNamespaces, temporary, i, false, NULL, false );
707 userProcs.Insert( pUserProc, i );
708
709 /* Sub ～ End Sub
710 Function ～ End Function
711 Macro ～ End Macro
712 を飛び越す */
713 char endStatementChar = GetEndXXXCommand( statementChar );
714 for(i2=0;;i++,i2++){
715 if( source[i] == '\0' ) break;
716 if( source[i] == 1 && source[i+1] == endStatementChar ){
717 i++;
718 break;
719 }
720 }
721 if(source[i]=='\0') break;
722 continue;
723 }
724
725 //次の行
726 for(;;i++){
727 if(IsCommandDelimitation(source[i])) break;
728 }
729 if(source[i]=='\0') break;
730 }
731
732 ////////////
733 // 特殊関数
734 ////////////
735 namespaceScopes.clear();
736 importedNamespaces.clear();
737
738 compiler.globalAreaProcName = "_System_GlobalArea_" + compiler.GetModuleName();
739 sprintf(temporary,"%c%c%s()",1,ESC_SUB,compiler.globalAreaProcName.c_str());
740 UserProc *pUserProc = ParseUserProc( namespaceScopes, importedNamespaces, temporary, 0, false, NULL, false );
741 userProcs.Insert( pUserProc, i );
742}
Note: See TracBrowser for help on using the repository browser.