Context Navigation

source: dev/trunk/ab5.0/abdev/BasicCompiler_Common/VariableOpe.cpp@ 601

Last change on this file since 601 was 598, checked in by dai_9181, 17 years ago
SplitMemberNameの依存関係を排除。
File size: 26.9 KB

Line
1	#include "stdafx.h"
2
3	#include <Compiler.h>
4	#include <LexicalScope.h>
5	#include <Variable.h>
6
7	#include "../BasicCompiler_Common/common.h"
8
9	#ifdef _AMD64_
10	#include "../compiler_x64/opcode.h"
11	#else
12	#include "../compiler_x86/opcode.h"
13	#endif
14
15	using namespace ActiveBasic::Compiler;
16
17	BOOL IsPtrType(int type){
18	if(type==-1) return 0;
19
20	if(PTR_LEVEL(type)\|\|type==DEF_PTR_VOID\|\|type==DEF_PTR_PROC\|\|
21	(type&FLAG_PTR) ) return 1;
22
23	return 0;
24	}
25	BOOL IsSignedType(int type){
26	switch(type){
27	case DEF_SBYTE:
28	case DEF_INTEGER:
29	case DEF_LONG:
30	case DEF_INT64:
31	case DEF_SINGLE:
32	case DEF_DOUBLE:
33	case DEF_CHAR:
34	return 1;
35	default:
36	break;
37	}
38	return 0;
39	}
40	BOOL IsNaturalWholeNumberType(int type){
41	switch(type){
42	case DEF_SBYTE:
43	case DEF_BYTE:
44	case DEF_INTEGER:
45	case DEF_WORD:
46	case DEF_LONG:
47	case DEF_DWORD:
48	case DEF_INT64:
49	case DEF_QWORD:
50	case DEF_CHAR:
51	return 1;
52	default:
53	break;
54	}
55	return 0;
56	}
57	BOOL IsWholeNumberType(int type){
58	return (
59	IsNaturalWholeNumberType(type)
60	\|\| IsPtrType(type)
61	\|\| type == DEF_BOOLEAN
62	);
63	}
64	BOOL IsRealNumberType(int type){
65	switch(type){
66	case DEF_DOUBLE:
67	case DEF_SINGLE:
68	return 1;
69	default:
70	break;
71	}
72	return 0;
73	}
74	BOOL Is64Type(int type){
75	switch(type){
76	case DEF_INT64:
77	case DEF_QWORD:
78	return 1;
79	default:
80	break;
81	}
82	#ifdef _AMD64_
83	return IsPtrType(type);
84	#else
85	return 0;
86	#endif
87	}
88	int GetSignedType(int type){
89	switch(type){
90	case DEF_BYTE:
91	return DEF_SBYTE;
92	case DEF_WORD:
93	return DEF_INTEGER;
94	case DEF_DWORD:
95	return DEF_LONG;
96	case DEF_QWORD:
97	return DEF_INT64;
98	default:
99	break;
100	}
101	#ifdef _AMD64_
102	if(IsPtrType(type)) return DEF_INT64;
103	#else
104	if(IsPtrType(type)) return DEF_LONG;
105	#endif
106	return type;
107	}
108	int GetUnsignedType(int type){
109	switch(type){
110	case DEF_SBYTE:
111	return DEF_BYTE;
112	case DEF_INTEGER:
113	return DEF_WORD;
114	case DEF_LONG:
115	return DEF_DWORD;
116	case DEF_INT64:
117	return DEF_QWORD;
118	case DEF_CHAR:
119	if( compiler.IsUnicode() ) return DEF_WORD;
120	return DEF_BYTE;
121	}
122	return type;
123	}
124	int GetPtrType(int type){
125	return MAKE_PTR_TYPE(NATURAL_TYPE(type),PTR_LEVEL(type)+1);
126	}
127	BOOL GetTypeName(int type,LONG_PTR lpIndex,char *name){
128	if(PTR_LEVEL(type)){
129	//ポインタ型
130	name[0]='*';
131	return GetTypeName(MAKE_PTR_TYPE(NATURAL_TYPE(type),PTR_LEVEL(type)-1),lpIndex,name+1);
132	}
133
134	//整数型
135	if(type==DEF_SBYTE) lstrcpy(name,"SByte");
136	else if(type==DEF_BYTE) lstrcpy(name,"Byte");
137	else if(type==DEF_INTEGER) lstrcpy(name,"Integer");
138	else if(type==DEF_WORD) lstrcpy(name,"Word");
139	else if(type==DEF_LONG) lstrcpy(name,"Long");
140	else if(type==DEF_DWORD) lstrcpy(name,"DWord");
141	else if(type==DEF_INT64) lstrcpy(name,"Int64");
142	else if(type==DEF_QWORD) lstrcpy(name,"QWord");
143
144	//実数型
145	else if(type==DEF_SINGLE) lstrcpy(name,"Single");
146	else if(type==DEF_DOUBLE) lstrcpy(name,"Double");
147
148	//文字型
149	//else if(type==DEF_CHAR) lstrcpy(name,"Char");
150
151	//bool型
152	else if(type==DEF_BOOLEAN) lstrcpy(name,"Boolean");
153
154	//オブジェクト
155	else if(type==DEF_OBJECT \|\| type==DEF_STRUCT){
156	if(lpIndex==0) lstrcpy(name,"non");
157	else{
158	lstrcpy(name,((CClass *)lpIndex)->GetName().c_str());
159	}
160	}
161
162	//ポインタ型
163	else if(type==DEF_PTR_VOID) lstrcpy(name,"VoidPtr");
164
165	else if(type==DEF_PTR_PROC){
166	if(lpIndex==-1) lstrcpy(name,"VoidPtr");
167	else{
168	if( compiler.GetObjectModule().meta.GetProcPointers()[lpIndex]->ReturnType().IsNull() )
169	lstrcpy(name,"*Sub");
170	else lstrcpy(name,"*Function");
171	}
172	}
173
174	else{
175	extern int cp;
176	compiler.errorMessenger.Output(1,NULL,cp);
177	return 0;
178	}
179	return 1;
180	}
181
182	Type GetStringTypeInfo(){
183	Type type( DEF_OBJECT, *compiler.GetObjectModule().meta.GetClasses().GetStringClassPtr() );
184	return type;
185	}
186
187	void GetWithName(char *buffer){
188	extern WITHINFO WithInfo;
189	int i;
190
191	buffer[0]=0;
192	for(i=0;i<WithInfo.num;i++)
193	lstrcat(buffer,WithInfo.ppName[i]);
194	}
195
196
197	void GetArrange(char variable,char variAnswer, Subscripts &subscripts ){
198	extern int cp;
199	int i,i2,i4;
200	double dbl;
201	_int64 i64data;
202	BOOL bBracket;
203	char temporary[VN_SIZE];
204
205	for(i=0;;i++){
206	if(variable[i]=='('\|\|variable[i]=='['){
207	if(variable[i]=='[') bBracket=1;
208	else bBracket=0;
209
210	variAnswer[i]=0;
211	for(i++,i2=0;;i++,i2++){
212	if(variable[i]==','){
213	temporary[i2]=0;
214
215	Type resultType;
216	if( !StaticCalculation(true, temporary,0,&i64data,resultType) ){
217	return;
218	}
219	if(resultType.IsReal()){
220	memcpy(&dbl,&i64data,sizeof(double));
221	i64data=(_int64)dbl;
222	}
223
224	if(i64data<0)
225	{
226	//error
227	subscripts.push_back( 0 );
228	}
229	else
230	{
231	subscripts.push_back( (int)i64data );
232	}
233	i2=-1;
234	continue;
235	}
236	if(variable[i]=='('){
237	i4=GetStringInPare(temporary+i2,variable+i);
238	i2+=i4-1;
239	i+=i4-1;
240	continue;
241	}
242	if(variable[i]=='['){
243	i4=GetStringInBracket(temporary+i2,variable+i);
244	i2+=i4-1;
245	i+=i4-1;
246	continue;
247	}
248	if(variable[i]==')'&&bBracket==0\|\|
249	variable[i]==']'&&bBracket){
250	temporary[i2]=0;
251	if(i2==0){
252	subscripts.push_back( -2 );
253	break;
254	}
255
256	Type resultType;
257	if( !StaticCalculation(true, temporary,0,&i64data,resultType) ){
258	return;
259	}
260	if(resultType.IsReal()){
261	memcpy(&dbl,&i64data,sizeof(double));
262	i64data=(_int64)dbl;
263	}
264
265	if(i64data<0){
266	//error
267	subscripts.push_back( 0 );
268	}
269	else
270	{
271	subscripts.push_back( (int)i64data );
272	}
273	break;
274	}
275	if(variable[i]=='\"'){
276	compiler.errorMessenger.Output(1,NULL,cp);
277	return;
278	}
279	temporary[i2]=variable[i];
280	}
281	break;
282	}
283	variAnswer[i]=variable[i];
284	if(variable[i]=='\0'){
285	break;
286	}
287	}
288	}
289
290
291	BOOL GetVarFormatString( char buffer,char array,char array2,char NestMember,ReferenceKind &refType, PareOrBracket *pPareOrBracket ){
292	extern int cp;
293	int i,i2,i3;
294	char cPare_Open,cPare_Close;
295
296	array[0]=0;
297	array2[0]=0;
298	NestMember[0]=0;
299	for(i=0;;i++){
300	if(buffer[i]=='\"'){
301	for(i++;;i++){
302	if(IsDBCSLeadByte(buffer[i])){
303	i++;
304	continue;
305	}
306	if(buffer[i]=='\"') break;
307	}
308	}
309	if(buffer[i]=='['\|\|buffer[i]=='('){
310	if(buffer[i]=='['){
311	cPare_Open='[';
312	cPare_Close=']';
313	}
314	else{
315	cPare_Open='(';
316	cPare_Close=')';
317	}
318
319	if( pPareOrBracket )
320	{
321	// []なのか、()なのかを伝える
322	if( cPare_Open == '[' )
323	{
324	*pPareOrBracket = Bracket;
325	}
326	else
327	{
328	*pPareOrBracket = Pare;
329	}
330	}
331
332	buffer[i]=0;
333	for(i++,i2=0;;i++,i2++){
334	if(buffer[i]==cPare_Open){
335	if(cPare_Open=='[') i3=GetStringInBracket(array+i2,buffer+i);
336	else i3=GetStringInPare(array+i2,buffer+i);
337	i+=i3-1;
338	i2+=i3-1;
339	continue;
340	}
341	if(buffer[i]==cPare_Close){
342	array[i2]=0;
343	break;
344	}
345	array[i2]=buffer[i];
346	}
347	if(buffer[i+1]==cPare_Open){
348	for(i+=2,i2=0;;i++,i2++){
349	if(buffer[i]==cPare_Open){
350	if(cPare_Open=='[') i3=GetStringInBracket(array2+i2,buffer+i);
351	else i3=GetStringInPare(array2+i2,buffer+i);
352	i+=i3-1;
353	i2+=i3-1;
354	continue;
355	}
356	if(buffer[i]==cPare_Close){
357	array2[i2]=0;
358	break;
359	}
360	array2[i2]=buffer[i];
361	}
362	if(buffer[i+1]==cPare_Open){
363	compiler.errorMessenger.Output(14,buffer,cp);
364	return 0;
365	}
366	}
367	continue;
368	}
369	if(buffer[i]=='.'){
370	lstrcpy(NestMember,buffer+i+1);
371	refType = RefDot;
372	buffer[i]=0;
373	break;
374	}
375	if(buffer[i]==1&&buffer[i+1]==ESC_PSMEM){
376	lstrcpy(NestMember,buffer+i+2);
377	refType = RefPointer;
378	buffer[i]=0;
379	break;
380	}
381	if(buffer[i]=='\0') break;
382	}
383	return 1;
384	}
385
386	void GetArrayElement( const char buffer,char variable,char *array_element){
387	array_element[0]=0;
388
389	if(buffer[lstrlen(buffer)-1]!=']'){
390	lstrcpy(variable,buffer);
391	return;
392	}
393
394	int i,i2;
395	for(i=0;;i++){
396	if(buffer[i]=='\0') break;
397	if(buffer[i]=='['){
398	i2=GetStringInBracket(array_element,buffer+i);
399	i+=i2-1;
400	continue;
401	}
402	}
403
404	lstrcpy(variable,buffer);
405	variable[lstrlen(variable)-lstrlen(array_element)]=0;
406
407	RemoveStringBracket(array_element);
408	}
409
410	BOOL CheckVarNameError(char *name,int nowLine){
411	int i2;
412
413	if(!IsVariableTopChar(name[0])){
414	compiler.errorMessenger.Output(1,NULL,nowLine);
415	return 0;
416	}
417	for(i2=1;;i2++){
418	if(name[i2]=='\0') break;
419	if(!IsVariableChar(name[i2])){
420	compiler.errorMessenger.Output(1,NULL,nowLine);
421	return 0;
422	}
423	}
424	return 1;
425	}
426
427	int JumpSubScripts( const Subscripts &subscripts ){
428	//DIMで定義された並んだ配列の数だけアドレスを進める
429	int i, i2;
430	for( i=0,i2=1; i<(int)subscripts.size(); i++ ){
431	i2 *= subscripts[i] + 1;
432	}
433	return i2;
434	}
435
436
437	bool GetMemberType( const Type &classType, const char *lpszMember, Type &resultType, BOOL bPrivateAccess, bool isErrorEnabled)
438	{
439	const CClass &objClass = classType.GetClass();
440
441	extern int cp;
442
443	//クラス、配列の構成要素を解析する
444	char VarName[VN_SIZE]; //変数名
445	char array[VN_SIZE]; //第1次配列
446	char lpPtrOffset[VN_SIZE]; //第2次配列
447	char NestMember[VN_SIZE]; //入れ子メンバ
448	ReferenceKind refType = RefNon;
449	lstrcpy(VarName,lpszMember);
450	if(!GetVarFormatString(VarName,array,lpPtrOffset,NestMember,refType)) return false;
451
452	const Member *pMember = objClass.FindDynamicMember( VarName );
453	if( !pMember ){
454	if(isErrorEnabled) compiler.errorMessenger.Output(103,VarName,cp);
455	return false;
456	}
457
458	//アクセシビリティをチェック
459	if( compiler.IsCompilingClass() && &objClass == &compiler.GetCompilingClass() ){
460	//同一クラスオブジェクトの場合はプライベートアクセスを容認する
461	if( pMember->IsNoneAccess() ){
462	if(isErrorEnabled) compiler.errorMessenger.Output(107,VarName,cp);
463	return false;
464	}
465	}
466	else{
467	if(( bPrivateAccess==0 && pMember->IsPrivate() )\|\|
468	pMember->IsNoneAccess() ){
469	if(isErrorEnabled) compiler.errorMessenger.Output(107,VarName,cp);
470	return false;
471	}
472	else if( bPrivateAccess==0 && pMember->IsProtected() ){
473	if(isErrorEnabled) compiler.errorMessenger.Output(108,VarName,cp);
474	return false;
475	}
476	}
477
478	resultType = pMember->GetType();
479
480	// 型パラメータを解決
481	ResolveFormalGenericTypeParameter( resultType, classType );
482
483
484	//ポインタ変数の場合
485	if( resultType.IsPointer() ){
486	if( pMember->GetSubscripts().size() == 0 ){
487	lstrcpy(lpPtrOffset,array);
488	array[0]=0;
489	}
490	}
491	else{
492	if(lpPtrOffset[0]){
493	if(isErrorEnabled) compiler.errorMessenger.Output(16,lpszMember,cp);
494	return false;
495	}
496	}
497
498	if(array[0]){
499	//配列オフセット
500	if( pMember->GetSubscripts().size() <= 0 )
501	{
502	// 配列ではないメンバに配列指定をした
503	return false;
504	}
505	}
506	else if( pMember->GetSubscripts().size() > 0 ){
507	resultType.SetBasicType( resultType.GetBasicType() \| FLAG_PTR );
508	}
509
510	if( refType != RefNon ){
511	//入れ子構造の場合
512
513	return GetMemberType( pMember->GetType(),
514	NestMember,
515	resultType,
516	0,
517	isErrorEnabled);
518	}
519
520	if(lpPtrOffset[0]){
521	if( resultType.PtrLevel() ){
522	resultType.PtrLevelDown();
523	}
524	else{
525	//エラー
526	if(isErrorEnabled) compiler.errorMessenger.Output(1,NULL,cp);
527	return false;
528	}
529	}
530
531	return true;
532	}
533	bool GetVarType( const char *nameBuffer, Type &resultType, bool isErrorEnabled){
534	char variable[VN_SIZE];
535
536	if(nameBuffer[0]=='.'){
537	GetWithName(variable);
538	lstrcat(variable,nameBuffer);
539	}
540	else lstrcpy(variable,nameBuffer);
541
542	// 名前空間を分離
543	char namespaceStr[VN_SIZE]="", simpleName[VN_SIZE];
544	compiler.GetObjectModule().meta.GetNamespaces().SplitNamespace( variable, namespaceStr, simpleName );
545
546	// 先頭オブジェクトまたはクラス名と入れ子メンバに分割
547	ReferenceKind refType;
548	char member[VN_SIZE],array[VN_SIZE],lpPtrOffset[VN_SIZE];
549	GetVarFormatString(simpleName,array,lpPtrOffset,member,refType);
550
551	// 名前空間を分離していた場合は結合
552	char VarName[VN_SIZE];
553	if( namespaceStr[0] ){
554	sprintf( VarName, "%s.%s", namespaceStr, simpleName );
555	}
556	else{
557	lstrcpy( VarName, simpleName );
558	}
559
560	const Variable *pVar = NULL;
561
562	if( compiler.IsLocalAreaCompiling() ){
563	/////////////////
564	// ローカル変数
565	/////////////////
566
567	pVar = compiler.GetCompilingUserProc().GetLocalVars().BackSearch(
568	LexicalAnalyzer::FullNameToSymbol( VarName ),
569	compiler.codeGenerator.lexicalScopes.GetNowLevel()
570	);
571	if( pVar ){
572	goto ok;
573	}
574	}
575
576	if( compiler.IsCompilingClass() ){
577	///////////////////////
578	// クラスメンバの参照
579	///////////////////////
580
581	if(lstrcmpi(variable,"This")==0){
582	//Thisオブジェクト
583	resultType.SetType( DEF_OBJECT, &compiler.GetCompilingClass() );
584	return true;
585	}
586
587	if(memicmp(variable,"This.",5)==0){
588	//Thisオブジェクトのメンバを参照するとき
589	SlideString(variable+5,-5);
590	lstrcpy(VarName,variable);
591	}
592	else{
593	//クラス内の動的メンバを参照するとき（通常）
594
595	if( !compiler.GetCompilingClass().HasDynamicMember( VarName ) )
596	{
597	goto NonClassMember;
598	}
599	}
600
601	return GetMemberType(
602	Type( DEF_OBJECT, compiler.GetCompilingClass() ),
603	variable,
604	resultType,
605	1,
606	isErrorEnabled
607	);
608	}
609
610	NonClassMember:
611
612	//////////////////////////
613	// 静的ローカル変数
614	// ※"Static.Object.Method.Variable"
615	//////////////////////////
616
617	char temporary[VN_SIZE];
618	if( compiler.IsLocalAreaCompiling() ){
619	GetNowStaticVarFullName(VarName,temporary);
620
621	pVar = compiler.GetObjectModule().meta.GetGlobalVars().Find( LexicalAnalyzer::FullNameToSymbol( temporary ) );
622	if( pVar ){
623	goto ok;
624	}
625	}
626
627
628	//////////////////////////
629	// クラスの静的メンバ
630	//////////////////////////
631
632	if(member[0]){
633	lstrcpy(temporary,member);
634	char tempMember[VN_SIZE];
635	char tempArray[VN_SIZE];
636	{
637	ReferenceKind refType;
638	GetVarFormatString(temporary,tempArray,lpPtrOffset,tempMember,refType);
639	}
640
641	int typeDefIndex = compiler.GetObjectModule().meta.GetTypeDefs().GetIndex( LexicalAnalyzer::FullNameToSymbol( VarName ) );
642	if( typeDefIndex != -1 ){
643	// TypeDef後の型名だったとき
644	lstrcpy( VarName, compiler.GetObjectModule().meta.GetTypeDefs()[typeDefIndex].GetBaseName().c_str() );
645	}
646
647	char temp2[VN_SIZE];
648	sprintf(temp2,"%s.%s",VarName,temporary);
649
650	pVar = compiler.GetObjectModule().meta.GetGlobalVars().Find( LexicalAnalyzer::FullNameToSymbol( temp2 ) );
651	if( pVar ){
652	lstrcpy(member,tempMember);
653	lstrcpy(array,tempArray);
654	goto ok;
655	}
656	}
657
658	if( compiler.IsCompilingClass() ){
659	//自身のクラスから静的メンバを参照する場合
660	char temp2[VN_SIZE];
661	sprintf(temp2,"%s.%s",compiler.GetCompilingClass().GetName().c_str(),VarName);
662
663	pVar = compiler.GetObjectModule().meta.GetGlobalVars().Find( LexicalAnalyzer::FullNameToSymbol( temp2 ) );
664	if( pVar ){
665	goto ok;
666	}
667	}
668
669
670	////////////////////
671	// グローバル変数
672	////////////////////
673
674	pVar = compiler.GetObjectModule().meta.GetGlobalVars().BackSearch(
675	LexicalAnalyzer::FullNameToSymbol( VarName ),
676	compiler.codeGenerator.lexicalScopes.GetNowLevel()
677	);
678	if( pVar ){
679	goto ok;
680	}
681
682	//変数として見つからなかったとき
683	if(isErrorEnabled) compiler.errorMessenger.Output(3,variable,cp);
684	return false;
685
686	ok:
687
688	//ポインタ変数の場合
689	if( pVar->GetType().IsPointer() ){
690	if( !pVar->IsArray() ){
691	lstrcpy(lpPtrOffset,array);
692	array[0]=0;
693	}
694	}
695	else{
696	if(lpPtrOffset[0]){
697	if(isErrorEnabled) compiler.errorMessenger.Output(16,variable,cp);
698	return false;
699	}
700	}
701
702	resultType = pVar->GetType();
703
704	if(member[0]){
705	if( NATURAL_TYPE( resultType.GetBasicType() )==DEF_OBJECT
706	\|\| NATURAL_TYPE( resultType.GetBasicType() )==DEF_STRUCT)
707	{
708	return GetMemberType(resultType,member,resultType,0,isErrorEnabled);
709	}
710	}
711
712	if( array[0] == 0 && pVar->GetSubscripts().size() > 0 ){
713	//配列の先頭ポインタを示す場合
714	resultType.SetBasicType( resultType.GetBasicType() \| FLAG_PTR );
715	}
716
717	if(lpPtrOffset[0]){
718	if( resultType.PtrLevel() ){
719	resultType.PtrLevelDown();
720	}
721	else{
722	//エラー
723	if(isErrorEnabled) compiler.errorMessenger.Output(1,NULL,cp);
724	return false;
725	}
726	}
727
728	return true;
729	}
730
731	bool GetVarOffsetReadOnly(const char NameBuffer,RELATIVE_VAR pRelativeVar,Type &resultType, Subscripts *pResultSubscripts )
732	{
733	//読み取り専用で変数へアクセス
734	return GetVarOffset(
735	true, //エラー表示有効
736	false, //書き込みアクセスは無し
737	NameBuffer,
738	pRelativeVar,
739	resultType,
740	pResultSubscripts
741	);
742	}
743	bool GetVarOffsetReadWrite(const char NameBuffer,RELATIVE_VAR pRelativeVar,Type &resultType, Subscripts *pResultSubscripts )
744	{
745	//読み書き両用で変数へアクセス
746	return GetVarOffset(
747	true, //エラー表示有効
748	true, //書き込みアクセス
749	NameBuffer,
750	pRelativeVar,
751	resultType,
752	pResultSubscripts
753	);
754	}
755
756
757
758	bool GetDimentionFormat( const char *buffer,
759	char *VarName,
760	Subscripts &subscripts,
761	Type &type,
762	char *InitBuf,
763	char *ConstractParameter ){
764	int i,i2,i3,IsStr;
765	char variable[VN_SIZE],temporary[8192];
766
767	for(i=0;;i++){
768	if((buffer[i]==1&&buffer[i+1]==ESC_AS)\|\|
769	buffer[i]=='='\|\|
770	buffer[i]=='\0'){
771	variable[i]=0;
772	break;
773	}
774	variable[i]=buffer[i];
775	}
776
777	if(buffer[i]=='='){
778	////////////////////////////////////
779	// 初期化データが指定されいるとき
780	////////////////////////////////////
781	i++;
782
783	if( buffer[i]=='[' ){
784	// 構造初期データの場合
785
786	i3=GetStringInBracket(InitBuf,buffer+i);
787	i+=i3;
788	}
789	else{
790	// 代入初期データの場合
791
792	for(i2=0,IsStr=0;;i++,i2++){
793	if(buffer[i]=='\"') IsStr^=1;
794	if(buffer[i]=='('&&IsStr==0){
795	i3=GetStringInPare(InitBuf+i2,buffer+i);
796	i+=i3-1;
797	i2+=i3-1;
798	continue;
799	}
800	if(buffer[i]=='['&&IsStr==0){
801	i3=GetStringInBracket(InitBuf+i2,buffer+i);
802	i+=i3-1;
803	i2+=i3-1;
804	continue;
805	}
806	if((buffer[i]==','&&IsStr==0)\|\|
807	buffer[i]=='\0'){
808	InitBuf[i2]=0;
809	break;
810	}
811	InitBuf[i2]=buffer[i];
812	}
813	}
814	}
815	else{
816	//初期化データなし
817	InitBuf[0]=0;
818	}
819
820	ConstractParameter[0]=0;
821	if(buffer[i]==1&&buffer[i+1]==ESC_AS){
822	/////////////////////////////
823	// "As ～" による型指定あり
824	/////////////////////////////
825
826	for(i+=2,i2=0;;i++,i2++){
827	if(buffer[i]=='('\|\|buffer[i]=='\0'){
828	temporary[i2]=0;
829	break;
830	}
831	temporary[i2]=buffer[i];
832	}
833	if(temporary[0]=='*'&&
834	temporary[1]==1&&
835	(temporary[2]==ESC_FUNCTION\|\|temporary[2]==ESC_SUB)){
836	if(buffer[i]!='('){
837	compiler.errorMessenger.Output(10,temporary,cp);
838	return false;
839	}
840	i3=GetStringInPare(temporary+3,buffer+i);
841	i+=i3;
842	i2+=i3;
843
844	if(temporary[2]==ESC_FUNCTION&&buffer[i]==1&&buffer[i+1]==ESC_AS){
845	temporary[i2++]=buffer[i++];
846	temporary[i2++]=buffer[i++];
847	for(;;i++,i2++){
848	if(!IsVariableChar(buffer[i])){
849	temporary[i2]=0;
850	break;
851	}
852	temporary[i2]=buffer[i];
853	}
854	}
855	}
856
857	if( !compiler.StringToType( temporary, type ) ){
858	compiler.errorMessenger.Output(3,temporary,cp);
859	return false;
860	}
861
862	if(buffer[i]=='('){
863	//コンストラクタに渡すパラメータを取得
864	i2=GetStringInPare(ConstractParameter,buffer+i);
865	i+=i2;
866	RemoveStringPare(ConstractParameter);
867
868	if( !type.IsObject() ){
869	compiler.errorMessenger.Output(112,variable,cp);
870	return false;
871	}
872	}
873	}
874	else{
875	/////////////////
876	// As指定なし
877	/////////////////
878
879	if( InitBuf[0] == '\0' ){
880	//As指定も、初期値指定もない場合
881	type.SetBasicType( Type::GetBasicTypeFromSimpleName(variable) );
882
883	i2=lstrlen(variable)-1;
884	if(i2>=0){
885	if(!(variable[i2]=='#'\|\|variable[i2]=='!'\|\|variable[i2]=='%'\|\|variable[i2]=='$'))
886	compiler.errorMessenger.Output(-103,variable,cp);
887	}
888	}
889	else{
890	//初期値の型を判別して自動的に型情報を付加する
891	if( !NumOpe_GetType( InitBuf, GetStringTypeInfo(), type ) ){
892	// エラーの場合
893	return false;
894	}
895
896	if( IS_LITERAL( type.GetIndex() ) ){
897	type.SetIndex( -1 );
898	}
899	}
900
901	}
902
903	if( InitBuf[0] != '\0' && ConstractParameter[0] != '\0' ){
904	//初期値とコンストラクタパラメータが同時に呼び出されているとき
905	compiler.errorMessenger.Output(132, NULL, cp);
906	}
907
908	GetArrange(variable,VarName,subscripts);
909	return true;
910	}
911
912	BOOL GetNowStaticVarFullName(char VarName,char FullName){
913	if( compiler.IsGlobalAreaCompiling() ){
914	// グローバル領域をコンパイル中のとき
915	return 0;
916	}
917
918	const UserProc &proc = compiler.GetCompilingUserProc();
919
920	//Static識別
921	lstrcpy(FullName,"Static%");
922
923	//クラス名
924	if( compiler.IsCompilingClass() ){
925	lstrcat(FullName,compiler.GetCompilingClass().GetName().c_str());
926	lstrcat(FullName,"%");
927	}
928
929	//関数（またはメソッド）名
930	lstrcat(FullName,proc.GetName().c_str());
931	lstrcat(FullName,"%");
932
933	//ID
934	char temp[255];
935	sprintf(temp,"%x",proc.GetId());
936	lstrcat(FullName,temp);
937	lstrcat(FullName,"%");
938
939	//変数名
940	lstrcat(FullName,VarName);
941
942	return 1;
943	}
944
945
946	void AddGlobalVariable( const char name, const Subscripts &subscripts, const Type &type,const char InitBuf,const char *ConstractParameter,DWORD dwFlag){
947	/////////////////////////
948	// グローバル変数を追加
949	/////////////////////////
950
951	if( compiler.GetObjectModule().meta.GetGlobalVars().DuplicateCheck( LexicalAnalyzer::FullNameToSymbol( name ), compiler.codeGenerator.lexicalScopes.GetNowLevel() ) ){
952	//２重定義のエラー
953	compiler.errorMessenger.Output(15,name,cp);
954	return;
955	}
956
957	bool isConst = ( dwFlag & DIMFLAG_CONST ) ? true:false;
958
959	Variable *pVar = new Variable(
960	compiler.GetNamespaceSupporter().GetLivingNamespaceScopes(),
961	name,
962	type,
963	isConst,
964	false,
965	ConstractParameter,
966	( InitBuf[0] != 0 \|\| dwFlag == DIMFLAG_INITDEBUGVAR )
967	);
968
969	if( subscripts.size() > 0 ){
970	//配列あり
971	pVar->SetArray( subscripts );
972	}
973
974	//レキシカルスコープ
975	pVar->SetScopeLevel( compiler.codeGenerator.lexicalScopes.GetNowLevel() );
976	pVar->SetScopeStartAddress( compiler.codeGenerator.lexicalScopes.GetStartAddress() );
977	pVar->isLiving = true;
978
979	//エラー用
980	pVar->source_code_address=cp;
981
982	// 変数を追加
983	compiler.GetObjectModule().meta.GetGlobalVars().Add( pVar );
984
985	if(InitBuf[0]){
986	int result = 0;
987	if( !pVar->GetType().IsObject() ){
988	result = SetInitGlobalData(pVar->GetOffsetAddress(),
989	pVar->GetType(),
990	pVar->GetSubscripts(),
991	InitBuf);
992	}
993
994	if(!result){
995	//動的な式だった場合は代入演算を行う
996
997	//初期代入時のみ、書き込みアクセスを許可する
998	if( isConst ){
999	pVar->ConstOff();
1000	}
1001
1002	//代入
1003	char temporary[8192];
1004	sprintf(temporary,"%s=%s",name,InitBuf);
1005	OpcodeCalc(temporary);
1006
1007	//アクセス制限を元に戻す
1008	if( isConst ){
1009	pVar->ConstOn();
1010	}
1011	}
1012	}
1013
1014
1015	if( type.IsObject() ){
1016	//デストラクタの利用フラグをオンにする
1017	const CMethod *method = type.GetClass().GetDestructorMethod();
1018	if( method ){
1019	method->GetUserProc().Using();
1020	}
1021	}
1022	}
1023
1024	void dim(char *Parameter,DWORD dwFlags){
1025	extern HANDLE hHeap;
1026	int i2;
1027	char VarName[VN_SIZE];
1028
1029	i2 = 0;
1030
1031	if( Parameter[i2] == 1 && Parameter[i2+1] == ESC_BYREF ){
1032	//参照型
1033	compiler.errorMessenger.OutputFatalError();
1034	Parameter += 2;
1035	}
1036
1037	if(dwFlags & DIMFLAG_CONST){
1038
1039	//////////////////////////////////
1040	// 定数変数の場合を考慮
1041	//////////////////////////////////
1042	for(;;i2++){
1043	if(Parameter[i2] == '=' \|\|
1044	Parameter[i2] == 1 && Parameter[i2] == ESC_AS \|\|
1045	Parameter[i2] =='('){
1046	VarName[i2] = 0;
1047	break;
1048	}
1049	VarName[i2] = Parameter[i2];
1050	}
1051
1052	//定数と２重定義されていないる場合は抜け出す
1053	if(compiler.GetObjectModule().meta.GetGlobalConsts().GetBasicType( ActiveBasic::Compiler::LexicalAnalyzer::FullNameToSymbol( VarName ) )){
1054	return;
1055	}
1056
1057	//定数マクロとして定義されている場合は抜け出す
1058	if( compiler.GetObjectModule().meta.GetGlobalConstMacros().IsExistDuplicationKeyName( VarName ) )
1059	{
1060	return;
1061	}
1062	}
1063
1064
1065	//構文を解析
1066	Type type;
1067	char InitBuf[8192];
1068	char ConstractParameter[VN_SIZE];
1069	Subscripts subscripts;
1070	if(!GetDimentionFormat(Parameter, VarName,subscripts,type,InitBuf,ConstractParameter))
1071	return;
1072
1073
1074	//定数と２重定義されていないかを調べる
1075	if(compiler.GetObjectModule().meta.GetGlobalConsts().GetBasicType( ActiveBasic::Compiler::LexicalAnalyzer::FullNameToSymbol( VarName ) )){
1076	compiler.errorMessenger.Output(15,VarName,cp);
1077	return;
1078	}
1079
1080	//定数マクロとして定義されている場合
1081	if( compiler.GetObjectModule().meta.GetGlobalConstMacros().IsExistDuplicationKeyName( VarName ) ){
1082	compiler.errorMessenger.Output(15,VarName,cp);
1083	return;
1084	}
1085
1086	if( type.IsObject() ){
1087	if( type.GetClass().IsBlittableType() ){
1088	// Blittable型のときは基本型として扱う
1089	// ※ただし、コンパイル中のメソッドがBlittable型クラスに属していないこと
1090	if( compiler.IsLocalAreaCompiling()
1091	&& compiler.GetCompilingUserProc().HasParentClass()
1092	&& compiler.GetCompilingUserProc().GetParentClass().IsBlittableType() )
1093	{
1094	// コンパイル中のメソッドがBlittable型クラスに属している
1095	}
1096	else{
1097	type = type.GetClass().GetBlittableType();
1098	}
1099	}
1100	}
1101
1102	if(dwFlags&DIMFLAG_STATIC)
1103	{
1104	if( compiler.IsGlobalAreaCompiling() )
1105	{
1106	compiler.errorMessenger.Output(60,NULL,cp);
1107	return;
1108	}
1109
1110	/////////////////////
1111	// Static変数
1112	// ※"Static.Object.Method.Variable"
1113	/////////////////////
1114
1115	char temporary[VN_SIZE];
1116	GetNowStaticVarFullName(VarName,temporary);
1117
1118	dim( temporary,subscripts,type,InitBuf,ConstractParameter,dwFlags );
1119
1120	/*
1121	Note: 静的変数のコンストラクタ呼び出しは
1122	_System_InitStaticLocalVariables関数内で一括して行う
1123	*/
1124	}
1125	else{
1126	dim( VarName,subscripts,type,InitBuf,ConstractParameter,dwFlags );
1127	}
1128	}
1129	void OpcodeDim(char *Parameter,DWORD dwFlags){
1130	int i,i2,i3,IsStr=0;
1131	char temporary[8192];
1132
1133	for(i=0,i2=0;;i++,i2++){
1134	if(Parameter[i]=='\"') IsStr^=1;
1135	if(Parameter[i]=='('&&IsStr==0){
1136	i3=GetStringInPare(temporary+i2,Parameter+i);
1137	i+=i3-1;
1138	i2+=i3-1;
1139	continue;
1140	}
1141	if(Parameter[i]=='['&&IsStr==0){
1142	i3=GetStringInBracket(temporary+i2,Parameter+i);
1143	i+=i3-1;
1144	i2+=i3-1;
1145	continue;
1146	}
1147	if( Parameter[i] == '<' && IsStr == 0 )
1148	{
1149	if( IsGenericTypeSourcePart( Parameter + i ) )
1150	{
1151	// ジェネリクス構文
1152	i3=GetStringInGenericBracket(temporary+i2,Parameter+i);
1153	i+=i3-1;
1154	i2+=i3-1;
1155	continue;
1156	}
1157	else
1158	{
1159	// 一般構文
1160	}
1161	}
1162	if((Parameter[i]==','&&IsStr==0)\|\|
1163	Parameter[i]=='\0'){
1164	temporary[i2]=0;
1165
1166	dim(temporary,dwFlags);
1167
1168	if(Parameter[i]=='\0') break;
1169	i2=-1;
1170	continue;
1171	}
1172	temporary[i2]=Parameter[i];
1173	}
1174	}
1175
1176	void DebugVariable(void)
1177	{
1178	char temporary[255];
1179	if( compiler.GetObjectModule().meta.GetGlobalVars().Find( LexicalAnalyzer::FullNameToSymbol( "_DebugSys_dwThreadID" ) ) == NULL )
1180	{
1181	// 未定義の場合は定義する
1182	sprintf(temporary,"_DebugSys_dwThreadID[255]%c%cDWord",1,ESC_AS);
1183	OpcodeDim(temporary,DIMFLAG_INITDEBUGVAR);
1184	sprintf(temporary,"_DebugSys_ProcNum[255]%c%cDWord",1,ESC_AS);
1185	OpcodeDim(temporary,DIMFLAG_INITDEBUGVAR);
1186	sprintf(temporary,"_DebugSys_lplpObp[255]%c%c*ULONG_PTR",1,ESC_AS);
1187	OpcodeDim(temporary,DIMFLAG_INITDEBUGVAR);
1188	sprintf(temporary,"_DebugSys_lplpSpBase[255]%c%c*ULONG_PTR",1,ESC_AS);
1189	OpcodeDim(temporary,DIMFLAG_INITDEBUGVAR);
1190	}
1191	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: