Context Navigation

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

Last change on this file since 625 was 603, checked in by dai_9181, 16 years ago
ObjectModuleに関連するクラス一式をab_commonプロジェクトに移動した。
File size: 26.8 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	int typeDefIndex = compiler.GetObjectModule().meta.GetTypeDefs().GetIndex( LexicalAnalyzer::FullNameToSymbol( VarName ) );
636	if( typeDefIndex != -1 ){
637	// TypeDef後の型名だったとき
638	lstrcpy( VarName, compiler.GetObjectModule().meta.GetTypeDefs()[typeDefIndex].GetBaseName().c_str() );
639	}
640
641	char temp2[VN_SIZE];
642	sprintf(temp2,"%s.%s",VarName,temporary);
643
644	pVar = compiler.GetObjectModule().meta.GetGlobalVars().Find( LexicalAnalyzer::FullNameToSymbol( temp2 ) );
645	if( pVar ){
646	lstrcpy(member,tempMember);
647	lstrcpy(array,tempArray);
648	goto ok;
649	}
650	}
651
652	if( compiler.IsCompilingClass() ){
653	//自身のクラスから静的メンバを参照する場合
654	char temp2[VN_SIZE];
655	sprintf(temp2,"%s.%s",compiler.GetCompilingClass().GetName().c_str(),VarName);
656
657	pVar = compiler.GetObjectModule().meta.GetGlobalVars().Find( LexicalAnalyzer::FullNameToSymbol( temp2 ) );
658	if( pVar ){
659	goto ok;
660	}
661	}
662
663
664	////////////////////
665	// グローバル変数
666	////////////////////
667
668	pVar = compiler.GetObjectModule().meta.GetGlobalVars().BackSearch(
669	LexicalAnalyzer::FullNameToSymbol( VarName ),
670	compiler.codeGenerator.lexicalScopes.GetNowLevel()
671	);
672	if( pVar ){
673	goto ok;
674	}
675
676	//変数として見つからなかったとき
677	if(isErrorEnabled) compiler.errorMessenger.Output(3,variable,cp);
678	return false;
679
680	ok:
681
682	//ポインタ変数の場合
683	if( pVar->GetType().IsPointer() ){
684	if( !pVar->IsArray() ){
685	lstrcpy(lpPtrOffset,array);
686	array[0]=0;
687	}
688	}
689	else{
690	if(lpPtrOffset[0]){
691	if(isErrorEnabled) compiler.errorMessenger.Output(16,variable,cp);
692	return false;
693	}
694	}
695
696	resultType = pVar->GetType();
697
698	if(member[0]){
699	if( NATURAL_TYPE( resultType.GetBasicType() )==DEF_OBJECT
700	\|\| NATURAL_TYPE( resultType.GetBasicType() )==DEF_STRUCT)
701	{
702	return GetMemberType(resultType,member,resultType,0,isErrorEnabled);
703	}
704	}
705
706	if( array[0] == 0 && pVar->GetSubscripts().size() > 0 ){
707	//配列の先頭ポインタを示す場合
708	resultType.SetBasicType( resultType.GetBasicType() \| FLAG_PTR );
709	}
710
711	if(lpPtrOffset[0]){
712	if( resultType.PtrLevel() ){
713	resultType.PtrLevelDown();
714	}
715	else{
716	//エラー
717	if(isErrorEnabled) compiler.errorMessenger.Output(1,NULL,cp);
718	return false;
719	}
720	}
721
722	return true;
723	}
724
725	bool GetVarOffsetReadOnly(const char NameBuffer,RELATIVE_VAR pRelativeVar,Type &resultType, Subscripts *pResultSubscripts )
726	{
727	//読み取り専用で変数へアクセス
728	return GetVarOffset(
729	true, //エラー表示有効
730	false, //書き込みアクセスは無し
731	NameBuffer,
732	pRelativeVar,
733	resultType,
734	pResultSubscripts
735	);
736	}
737	bool GetVarOffsetReadWrite(const char NameBuffer,RELATIVE_VAR pRelativeVar,Type &resultType, Subscripts *pResultSubscripts )
738	{
739	//読み書き両用で変数へアクセス
740	return GetVarOffset(
741	true, //エラー表示有効
742	true, //書き込みアクセス
743	NameBuffer,
744	pRelativeVar,
745	resultType,
746	pResultSubscripts
747	);
748	}
749
750
751
752	bool GetDimentionFormat( const char *buffer,
753	char *VarName,
754	Subscripts &subscripts,
755	Type &type,
756	char *InitBuf,
757	char *ConstractParameter ){
758	int i,i2,i3,IsStr;
759	char variable[VN_SIZE],temporary[8192];
760
761	for(i=0;;i++){
762	if((buffer[i]==1&&buffer[i+1]==ESC_AS)\|\|
763	buffer[i]=='='\|\|
764	buffer[i]=='\0'){
765	variable[i]=0;
766	break;
767	}
768	variable[i]=buffer[i];
769	}
770
771	if(buffer[i]=='='){
772	////////////////////////////////////
773	// 初期化データが指定されいるとき
774	////////////////////////////////////
775	i++;
776
777	if( buffer[i]=='[' ){
778	// 構造初期データの場合
779
780	i3=GetStringInBracket(InitBuf,buffer+i);
781	i+=i3;
782	}
783	else{
784	// 代入初期データの場合
785
786	for(i2=0,IsStr=0;;i++,i2++){
787	if(buffer[i]=='\"') IsStr^=1;
788	if(buffer[i]=='('&&IsStr==0){
789	i3=GetStringInPare(InitBuf+i2,buffer+i);
790	i+=i3-1;
791	i2+=i3-1;
792	continue;
793	}
794	if(buffer[i]=='['&&IsStr==0){
795	i3=GetStringInBracket(InitBuf+i2,buffer+i);
796	i+=i3-1;
797	i2+=i3-1;
798	continue;
799	}
800	if((buffer[i]==','&&IsStr==0)\|\|
801	buffer[i]=='\0'){
802	InitBuf[i2]=0;
803	break;
804	}
805	InitBuf[i2]=buffer[i];
806	}
807	}
808	}
809	else{
810	//初期化データなし
811	InitBuf[0]=0;
812	}
813
814	ConstractParameter[0]=0;
815	if(buffer[i]==1&&buffer[i+1]==ESC_AS){
816	/////////////////////////////
817	// "As ～" による型指定あり
818	/////////////////////////////
819
820	for(i+=2,i2=0;;i++,i2++){
821	if(buffer[i]=='('\|\|buffer[i]=='\0'){
822	temporary[i2]=0;
823	break;
824	}
825	temporary[i2]=buffer[i];
826	}
827	if(temporary[0]=='*'&&
828	temporary[1]==1&&
829	(temporary[2]==ESC_FUNCTION\|\|temporary[2]==ESC_SUB)){
830	if(buffer[i]!='('){
831	compiler.errorMessenger.Output(10,temporary,cp);
832	return false;
833	}
834	i3=GetStringInPare(temporary+3,buffer+i);
835	i+=i3;
836	i2+=i3;
837
838	if(temporary[2]==ESC_FUNCTION&&buffer[i]==1&&buffer[i+1]==ESC_AS){
839	temporary[i2++]=buffer[i++];
840	temporary[i2++]=buffer[i++];
841	for(;;i++,i2++){
842	if(!IsVariableChar(buffer[i])){
843	temporary[i2]=0;
844	break;
845	}
846	temporary[i2]=buffer[i];
847	}
848	}
849	}
850
851	if( !compiler.StringToType( temporary, type ) ){
852	compiler.errorMessenger.Output(3,temporary,cp);
853	return false;
854	}
855
856	if(buffer[i]=='('){
857	//コンストラクタに渡すパラメータを取得
858	i2=GetStringInPare(ConstractParameter,buffer+i);
859	i+=i2;
860	RemoveStringPare(ConstractParameter);
861
862	if( !type.IsObject() ){
863	compiler.errorMessenger.Output(112,variable,cp);
864	return false;
865	}
866	}
867	}
868	else{
869	/////////////////
870	// As指定なし
871	/////////////////
872
873	if( InitBuf[0] == '\0' ){
874	//As指定も、初期値指定もない場合
875	type.SetBasicType( Type::GetBasicTypeFromSimpleName(variable) );
876
877	i2=lstrlen(variable)-1;
878	if(i2>=0){
879	if(!(variable[i2]=='#'\|\|variable[i2]=='!'\|\|variable[i2]=='%'\|\|variable[i2]=='$'))
880	compiler.errorMessenger.Output(-103,variable,cp);
881	}
882	}
883	else{
884	//初期値の型を判別して自動的に型情報を付加する
885	if( !NumOpe_GetType( InitBuf, GetStringTypeInfo(), type ) ){
886	// エラーの場合
887	return false;
888	}
889
890	if( IS_LITERAL( type.GetIndex() ) ){
891	type.SetIndex( -1 );
892	}
893	}
894
895	}
896
897	if( InitBuf[0] != '\0' && ConstractParameter[0] != '\0' ){
898	//初期値とコンストラクタパラメータが同時に呼び出されているとき
899	compiler.errorMessenger.Output(132, NULL, cp);
900	}
901
902	GetArrange(variable,VarName,subscripts);
903	return true;
904	}
905
906	BOOL GetNowStaticVarFullName(char VarName,char FullName){
907	if( compiler.IsGlobalAreaCompiling() ){
908	// グローバル領域をコンパイル中のとき
909	return 0;
910	}
911
912	const UserProc &proc = compiler.GetCompilingUserProc();
913
914	//Static識別
915	lstrcpy(FullName,"Static%");
916
917	//クラス名
918	if( compiler.IsCompilingClass() ){
919	lstrcat(FullName,compiler.GetCompilingClass().GetName().c_str());
920	lstrcat(FullName,"%");
921	}
922
923	//関数（またはメソッド）名
924	lstrcat(FullName,proc.GetName().c_str());
925	lstrcat(FullName,"%");
926
927	//ID
928	char temp[255];
929	sprintf(temp,"%x",proc.GetId());
930	lstrcat(FullName,temp);
931	lstrcat(FullName,"%");
932
933	//変数名
934	lstrcat(FullName,VarName);
935
936	return 1;
937	}
938
939
940	void AddGlobalVariable( const char name, const Subscripts &subscripts, const Type &type,const char InitBuf,const char *ConstractParameter,DWORD dwFlag){
941	/////////////////////////
942	// グローバル変数を追加
943	/////////////////////////
944
945	if( compiler.GetObjectModule().meta.GetGlobalVars().DuplicateCheck( LexicalAnalyzer::FullNameToSymbol( name ), compiler.codeGenerator.lexicalScopes.GetNowLevel() ) ){
946	//２重定義のエラー
947	compiler.errorMessenger.Output(15,name,cp);
948	return;
949	}
950
951	bool isConst = ( dwFlag & DIMFLAG_CONST ) ? true:false;
952
953	Variable *pVar = new Variable(
954	compiler.GetNamespaceSupporter().GetLivingNamespaceScopes(),
955	name,
956	type,
957	isConst,
958	false,
959	ConstractParameter,
960	( InitBuf[0] != 0 \|\| dwFlag == DIMFLAG_INITDEBUGVAR )
961	);
962
963	if( subscripts.size() > 0 ){
964	//配列あり
965	pVar->SetArray( subscripts );
966	}
967
968	//レキシカルスコープ
969	pVar->SetScopeLevel( compiler.codeGenerator.lexicalScopes.GetNowLevel() );
970	pVar->SetScopeStartAddress( compiler.codeGenerator.lexicalScopes.GetStartAddress() );
971	pVar->isLiving = true;
972
973	//エラー用
974	pVar->source_code_address=cp;
975
976	// 変数を追加
977	compiler.GetObjectModule().meta.GetGlobalVars().Add( pVar );
978
979	if(InitBuf[0]){
980	int result = 0;
981	if( !pVar->GetType().IsObject() ){
982	result = SetInitGlobalData(pVar->GetOffsetAddress(),
983	pVar->GetType(),
984	pVar->GetSubscripts(),
985	InitBuf);
986	}
987
988	if(!result){
989	//動的な式だった場合は代入演算を行う
990
991	//初期代入時のみ、書き込みアクセスを許可する
992	if( isConst ){
993	pVar->ConstOff();
994	}
995
996	//代入
997	char temporary[8192];
998	sprintf(temporary,"%s=%s",name,InitBuf);
999	OpcodeCalc(temporary);
1000
1001	//アクセス制限を元に戻す
1002	if( isConst ){
1003	pVar->ConstOn();
1004	}
1005	}
1006	}
1007
1008
1009	if( type.IsObject() ){
1010	//デストラクタの利用フラグをオンにする
1011	const CMethod *method = type.GetClass().GetDestructorMethod();
1012	if( method ){
1013	method->GetUserProc().Using();
1014	}
1015	}
1016	}
1017
1018	void dim(char *Parameter,DWORD dwFlags){
1019	extern HANDLE hHeap;
1020	int i2;
1021	char VarName[VN_SIZE];
1022
1023	i2 = 0;
1024
1025	if( Parameter[i2] == 1 && Parameter[i2+1] == ESC_BYREF ){
1026	//参照型
1027	compiler.errorMessenger.OutputFatalError();
1028	Parameter += 2;
1029	}
1030
1031	if(dwFlags & DIMFLAG_CONST){
1032
1033	//////////////////////////////////
1034	// 定数変数の場合を考慮
1035	//////////////////////////////////
1036	for(;;i2++){
1037	if(Parameter[i2] == '=' \|\|
1038	Parameter[i2] == 1 && Parameter[i2] == ESC_AS \|\|
1039	Parameter[i2] =='('){
1040	VarName[i2] = 0;
1041	break;
1042	}
1043	VarName[i2] = Parameter[i2];
1044	}
1045
1046	//定数と２重定義されていないる場合は抜け出す
1047	if(compiler.GetObjectModule().meta.GetGlobalConsts().GetBasicType( ActiveBasic::Compiler::LexicalAnalyzer::FullNameToSymbol( VarName ) )){
1048	return;
1049	}
1050
1051	//定数マクロとして定義されている場合は抜け出す
1052	if( compiler.GetObjectModule().meta.GetGlobalConstMacros().IsExistDuplicationKeyName( VarName ) )
1053	{
1054	return;
1055	}
1056	}
1057
1058
1059	//構文を解析
1060	Type type;
1061	char InitBuf[8192];
1062	char ConstractParameter[VN_SIZE];
1063	Subscripts subscripts;
1064	if(!GetDimentionFormat(Parameter, VarName,subscripts,type,InitBuf,ConstractParameter))
1065	return;
1066
1067
1068	//定数と２重定義されていないかを調べる
1069	if(compiler.GetObjectModule().meta.GetGlobalConsts().GetBasicType( ActiveBasic::Compiler::LexicalAnalyzer::FullNameToSymbol( VarName ) )){
1070	compiler.errorMessenger.Output(15,VarName,cp);
1071	return;
1072	}
1073
1074	//定数マクロとして定義されている場合
1075	if( compiler.GetObjectModule().meta.GetGlobalConstMacros().IsExistDuplicationKeyName( VarName ) ){
1076	compiler.errorMessenger.Output(15,VarName,cp);
1077	return;
1078	}
1079
1080	if( type.IsObject() ){
1081	if( type.GetClass().IsBlittableType() ){
1082	// Blittable型のときは基本型として扱う
1083	// ※ただし、コンパイル中のメソッドがBlittable型クラスに属していないこと
1084	if( compiler.IsLocalAreaCompiling()
1085	&& compiler.GetCompilingUserProc().HasParentClass()
1086	&& compiler.GetCompilingUserProc().GetParentClass().IsBlittableType() )
1087	{
1088	// コンパイル中のメソッドがBlittable型クラスに属している
1089	}
1090	else{
1091	type = type.GetClass().GetBlittableType();
1092	}
1093	}
1094	}
1095
1096	if(dwFlags&DIMFLAG_STATIC)
1097	{
1098	if( compiler.IsGlobalAreaCompiling() )
1099	{
1100	compiler.errorMessenger.Output(60,NULL,cp);
1101	return;
1102	}
1103
1104	/////////////////////
1105	// Static変数
1106	// ※"Static.Object.Method.Variable"
1107	/////////////////////
1108
1109	char temporary[VN_SIZE];
1110	GetNowStaticVarFullName(VarName,temporary);
1111
1112	dim( temporary,subscripts,type,InitBuf,ConstractParameter,dwFlags );
1113
1114	/*
1115	Note: 静的変数のコンストラクタ呼び出しは
1116	_System_InitStaticLocalVariables関数内で一括して行う
1117	*/
1118	}
1119	else{
1120	dim( VarName,subscripts,type,InitBuf,ConstractParameter,dwFlags );
1121	}
1122	}
1123	void OpcodeDim(char *Parameter,DWORD dwFlags){
1124	int i,i2,i3,IsStr=0;
1125	char temporary[8192];
1126
1127	for(i=0,i2=0;;i++,i2++){
1128	if(Parameter[i]=='\"') IsStr^=1;
1129	if(Parameter[i]=='('&&IsStr==0){
1130	i3=GetStringInPare(temporary+i2,Parameter+i);
1131	i+=i3-1;
1132	i2+=i3-1;
1133	continue;
1134	}
1135	if(Parameter[i]=='['&&IsStr==0){
1136	i3=GetStringInBracket(temporary+i2,Parameter+i);
1137	i+=i3-1;
1138	i2+=i3-1;
1139	continue;
1140	}
1141	if( Parameter[i] == '<' && IsStr == 0 )
1142	{
1143	if( IsGenericTypeSourcePart( Parameter + i ) )
1144	{
1145	// ジェネリクス構文
1146	i3=GetStringInGenericBracket(temporary+i2,Parameter+i);
1147	i+=i3-1;
1148	i2+=i3-1;
1149	continue;
1150	}
1151	else
1152	{
1153	// 一般構文
1154	}
1155	}
1156	if((Parameter[i]==','&&IsStr==0)\|\|
1157	Parameter[i]=='\0'){
1158	temporary[i2]=0;
1159
1160	dim(temporary,dwFlags);
1161
1162	if(Parameter[i]=='\0') break;
1163	i2=-1;
1164	continue;
1165	}
1166	temporary[i2]=Parameter[i];
1167	}
1168	}
1169
1170	void DebugVariable(void)
1171	{
1172	char temporary[255];
1173	if( compiler.GetObjectModule().meta.GetGlobalVars().Find( LexicalAnalyzer::FullNameToSymbol( "_DebugSys_dwThreadID" ) ) == NULL )
1174	{
1175	// 未定義の場合は定義する
1176	sprintf(temporary,"_DebugSys_dwThreadID[255]%c%cDWord",1,ESC_AS);
1177	OpcodeDim(temporary,DIMFLAG_INITDEBUGVAR);
1178	sprintf(temporary,"_DebugSys_ProcNum[255]%c%cDWord",1,ESC_AS);
1179	OpcodeDim(temporary,DIMFLAG_INITDEBUGVAR);
1180	sprintf(temporary,"_DebugSys_lplpObp[255]%c%c*ULONG_PTR",1,ESC_AS);
1181	OpcodeDim(temporary,DIMFLAG_INITDEBUGVAR);
1182	sprintf(temporary,"_DebugSys_lplpSpBase[255]%c%c*ULONG_PTR",1,ESC_AS);
1183	OpcodeDim(temporary,DIMFLAG_INITDEBUGVAR);
1184	}
1185	}

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

Download in other formats: