Context Navigation

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

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

ジェネリッククラスの型パラメータに値型が指定されたときに限り、テンプレート展開を行うようにした。

TODO: libファイルを跨ってテンプレート展開ができていないため、ソースコード管理部分に手を加える必要あり。

File size: 27.0 KB

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

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

Download in other formats: