Context Navigation

source: dev/trunk/abdev/BasicCompiler_Common/VariableOpe.cpp@ 308

Last change on this file since 308 was 308, checked in by dai_9181, 17 years ago
静的リンクライブラリにより、複数のグローバル領域が存在することになったのでそれぞれを関数ベースに分けた
File size: 25.7 KB

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

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

Download in other formats: