Context Navigation

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

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

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

Download in other formats: