Context Navigation

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

Last change on this file since 412 was 409, checked in by dai_9181, 17 years ago
クラス継承を行う際、dynamicMembersの中身をコピーする方式をやめ、基底クラスのものを参照するように修正した。
File size: 25.8 KB

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

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

Download in other formats: