Context Navigation

source: dev/BasicCompiler_Common/VariableOpe.cpp@ 78

Last change on this file since 78 was 78, checked in by dai_9181, 17 years ago
CTypeDef → TypeDef Houseクラスを追加。オーバーロードレベルの種類を追加（レベル1に挿入）
File size: 28.7 KB

Line
1	#include "../BasicCompiler_Common/common.h"
2
3	#ifdef _AMD64_
4	#include "../BasicCompiler64/opcode.h"
5	#else
6	#include "../BasicCompiler32/opcode.h"
7	#endif
8
9	BOOL IsVariableTopChar(char c){
10	if((c>='A'&&c<='Z')\|\|(c>='a'&&c<='z')\|\|c=='_') return 1;
11	return 0;
12	}
13	BOOL IsVariableChar(char c){
14	if((c>='A'&&c<='Z')\|\|(c>='a'&&c<='z')\|\|(c>='0'&&c<='9')\|\|
15	c=='%'\|\|c=='!'\|\|c=='#'\|\|c=='$'\|\|
16	c=='_'\|\|c=='.') return 1;
17	return 0;
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( isUnicode ) return DEF_WORD;
122	return DEF_BYTE;
123	}
124	return type;
125	}
126	int GetTypeSize(int type,LONG_PTR lpIndex){
127	if(type==DEF_LONG){
128	if(lpIndex==LITERAL_NULL\|\|lpIndex==LITERAL_M128_0\|\|lpIndex==LITERAL_0_255)
129	return sizeof(BYTE);
130	else if(lpIndex==LITERAL_M32768_0\|\|lpIndex==LITERAL_0_65535)
131	return sizeof(WORD);
132
133	return sizeof(DWORD);
134	}
135
136	//整数型
137	if(type==DEF_INT64\|\|type==DEF_QWORD)
138	return sizeof(_int64);
139	else if(type==DEF_LONG\|\|type==DEF_DWORD)
140	return sizeof(DWORD);
141	else if(type==DEF_INTEGER\|\|type==DEF_WORD)
142	return sizeof(WORD);
143	else if(type==DEF_SBYTE\|\|type==DEF_BYTE \|\| type == DEF_BOOLEAN)
144	return sizeof(BYTE);
145
146	//実数型
147	else if(type==DEF_DOUBLE) return sizeof(double);
148	else if(type==DEF_SINGLE) return sizeof(float);
149
150	//文字型
151	else if( type == DEF_CHAR ){
152	if( isUnicode ) return sizeof( WORD );
153	return sizeof( BYTE );
154	}
155
156	//ポインタ型
157	else if(IsPtrType(type)) return PTR_SIZE;
158
159	else if( type == DEF_STRUCT ){
160	if(lpIndex == 0 \|\| lpIndex == -1){
161	SetError(300,NULL,cp);
162	return 0;
163	}
164
165	const CClass pobj_c=(CClass )lpIndex;
166
167	return pobj_c->GetSize();
168	}
169
170	else if(type==DEF_OBJECT){
171	return PTR_SIZE;
172	}
173	else{
174	SetError(300,NULL,cp);
175	}
176	return 0;
177	}
178	int GetPtrType(int type){
179	return MAKE_PTR_TYPE(NATURAL_TYPE(type),PTR_LEVEL(type)+1);
180	}
181	int GetTypeFixed(const char TypeName,LONG_PTR lpNum){
182	int type;
183
184	if(lpNum) *lpNum=-1;
185
186	if(TypeName[0]=='*'){
187	if(TypeName[1]==1&&(TypeName[2]==ESC_FUNCTION\|\|TypeName[2]==ESC_SUB)){
188	//関数ポインタ（*Function）
189	return DEF_PTR_PROC;
190	}
191
192	type=GetTypeFixed(TypeName+1,lpNum);
193	if(type==-1) return -1;
194
195	return GetPtrType(type);
196	}
197
198	//整数型
199	if(lstrcmpi(TypeName,"SByte")==0) return DEF_SBYTE;
200	else if(lstrcmpi(TypeName,"Byte")==0) return DEF_BYTE;
201	else if(lstrcmpi(TypeName,"Integer")==0) return DEF_INTEGER;
202	else if(lstrcmpi(TypeName,"WORD")==0) return DEF_WORD;
203	else if(lstrcmpi(TypeName,"Long")==0) return DEF_LONG;
204	else if(lstrcmpi(TypeName,"DWORD")==0) return DEF_DWORD;
205	else if(lstrcmpi(TypeName,"Int64")==0) return DEF_INT64;
206	else if(lstrcmpi(TypeName,"QWORD")==0) return DEF_QWORD;
207
208	//実数型
209	else if(lstrcmpi(TypeName,"Single")==0) return DEF_SINGLE;
210	else if(lstrcmpi(TypeName,"Double")==0) return DEF_DOUBLE;
211
212	//文字型
213	//else if( lstrcmpi( TypeName, "Char" ) == 0 ) return DEF_CHAR;
214
215	//bool型
216	else if( lstrcmpi( TypeName, "Boolean" ) == 0 ) return DEF_BOOLEAN;
217
218	//ポインタ型
219	//※VoidPtr型以外のポインタ型はTypeDef宣言により定義される
220	else if(lstrcmpi(TypeName,"VoidPtr")==0) return DEF_PTR_VOID;
221
222	//その他
223	else if(lstrcmpi(TypeName,"Any")==0) return DEF_ANY;
224
225
226	////////////////////
227	// TypeDefされた型
228	////////////////////
229	int i;
230	i=House::typeDefs.GetIndex(TypeName);
231	if(i!=-1){
232	*lpNum = House::typeDefs[i].GetBaseType().GetIndex();
233	return House::typeDefs[i].GetBaseType().GetBasicType();
234	}
235
236	if(!lpNum) return -1;
237
238	//クラス
239	CClass *pobj_c;
240	pobj_c=pobj_DBClass->check(TypeName);
241	if(pobj_c){
242	*lpNum=(LONG_PTR)pobj_c;
243
244	if( pobj_c->IsStructure() ){
245	return DEF_STRUCT;
246	}
247	else{
248	return DEF_OBJECT;
249	}
250	}
251
252	return -1;
253	}
254	/*
255	TODO: 消す(TypeDef関連の変更)
256	void GetOriginalTypeName_Old(char *buffer){
257	// TypeDefされた型に対して、オリジナルの型の名前に変更する
258
259	if(buffer[0]=='*'){
260	if(buffer[1]==1&&(buffer[2]==ESC_FUNCTION\|\|buffer[2]==ESC_SUB)) return;
261
262	GetOriginalTypeName_Old(buffer+1);
263	return;
264	}
265
266	int i;
267	i=House::typeDefs.GetIndex(buffer);
268	if(i!=-1){
269	lstrcpy(buffer,House::typeDefs[i].GetBaseName().c_str());
270	GetOriginalTypeName_Old(buffer);
271	}
272	}*/
273	BOOL GetTypeName(int type,LONG_PTR lpIndex,char *name){
274	if(PTR_LEVEL(type)){
275	//ポインタ型
276	name[0]='*';
277	return GetTypeName(MAKE_PTR_TYPE(NATURAL_TYPE(type),PTR_LEVEL(type)-1),lpIndex,name+1);
278	}
279
280	//整数型
281	if(type==DEF_SBYTE) lstrcpy(name,"SByte");
282	else if(type==DEF_BYTE) lstrcpy(name,"Byte");
283	else if(type==DEF_INTEGER) lstrcpy(name,"Integer");
284	else if(type==DEF_WORD) lstrcpy(name,"Word");
285	else if(type==DEF_LONG) lstrcpy(name,"Long");
286	else if(type==DEF_DWORD) lstrcpy(name,"DWord");
287	else if(type==DEF_INT64) lstrcpy(name,"Int64");
288	else if(type==DEF_QWORD) lstrcpy(name,"QWord");
289
290	//実数型
291	else if(type==DEF_SINGLE) lstrcpy(name,"Single");
292	else if(type==DEF_DOUBLE) lstrcpy(name,"Double");
293
294	//文字型
295	//else if(type==DEF_CHAR) lstrcpy(name,"Char");
296
297	//bool型
298	else if(type==DEF_BOOLEAN) lstrcpy(name,"Boolean");
299
300	//オブジェクト
301	else if(type==DEF_OBJECT \|\| type==DEF_STRUCT){
302	if(lpIndex==0) lstrcpy(name,"non");
303	else{
304	lstrcpy(name,((CClass *)lpIndex)->name);
305	}
306	}
307
308	//ポインタ型
309	else if(type==DEF_PTR_VOID) lstrcpy(name,"VoidPtr");
310
311	else if(type==DEF_PTR_PROC){
312	if(lpIndex==-1) lstrcpy(name,"VoidPtr");
313	else{
314	if( House::procPointers[lpIndex]->ReturnType().IsNull() )
315	lstrcpy(name,"*Sub");
316	else lstrcpy(name,"*Function");
317	}
318	}
319
320	else{
321	extern int cp;
322	SetError(1,NULL,cp);
323	return 0;
324	}
325	return 1;
326	}
327
328	Type GetStringTypeInfo(){
329	extern CClass *pobj_StringClass;
330	Type type( DEF_OBJECT, *pobj_StringClass );
331	return type;
332	}
333
334	bool FormatUseProcReturnObject( const char term, char procName, char parameter, CClass::RefType &refType, char member ){
335	int p1 = 0, p2 = 0;
336
337	for( int i=0; term[i]!='\0' ; i++ ){
338
339	if( term[i] == '[' ){
340	i = JumpStringInBracket( term, i + 1 );
341	if( term[i] == '\0' ) break;
342	continue;
343	}
344	if( term[i] == '(' ){
345	int temp_p = i;
346	i = JumpStringInPare( term, i + 1 ) + 1;
347	if( term[i] == '\0' ) break;
348	if( term[i] == '.'
349	\|\| term[i] == 1 && term[i] == ESC_PSMEM ){
350	p1 = temp_p;
351	p2 = i;
352	}
353	continue;
354	}
355	}
356	if( !p1 ) return false;
357
358	//メソッド名
359	memcpy( procName, term, p1 );
360	procName[p1] = 0;
361
362	//パラメータ
363	memcpy( parameter, term + p1 + 1, p2 - p1 - 2 );
364	parameter[ p2 - p1 - 2 ] = 0;
365
366	//参照タイプ
367	if( term[p2] == '.' ){
368	refType = CClass::Dot;
369	}
370	else{
371	refType = CClass::Pointer;
372	p2++;
373	}
374
375	//メンバ
376	lstrcpy( member, term + p2 + 1 );
377
378	return true;
379	}
380
381	BOOL GetVarFormatString(char buffer,char array,char array2,char NestMember,CClass::RefType &refType){
382	extern int cp;
383	int i,i2,i3;
384	char cPare_Open,cPare_Close;
385
386	array[0]=0;
387	array2[0]=0;
388	NestMember[0]=0;
389	for(i=0;;i++){
390	if(buffer[i]=='\"'){
391	for(i++;;i++){
392	if(IsDBCSLeadByte(buffer[i])){
393	i++;
394	continue;
395	}
396	if(buffer[i]=='\"') break;
397	}
398	}
399	if(buffer[i]=='['\|\|buffer[i]=='('){
400	if(buffer[i]=='['){
401	cPare_Open='[';
402	cPare_Close=']';
403	}
404	else{
405	cPare_Open='(';
406	cPare_Close=')';
407	}
408	buffer[i]=0;
409	for(i++,i2=0;;i++,i2++){
410	if(buffer[i]==cPare_Open){
411	if(cPare_Open=='[') i3=GetStringInBracket(array+i2,buffer+i);
412	else i3=GetStringInPare(array+i2,buffer+i);
413	i+=i3-1;
414	i2+=i3-1;
415	continue;
416	}
417	if(buffer[i]==cPare_Close){
418	array[i2]=0;
419	break;
420	}
421	array[i2]=buffer[i];
422	}
423	if(buffer[i+1]==cPare_Open){
424	for(i+=2,i2=0;;i++,i2++){
425	if(buffer[i]==cPare_Open){
426	if(cPare_Open=='[') i3=GetStringInBracket(array2+i2,buffer+i);
427	else i3=GetStringInPare(array2+i2,buffer+i);
428	i+=i3-1;
429	i2+=i3-1;
430	continue;
431	}
432	if(buffer[i]==cPare_Close){
433	array2[i2]=0;
434	break;
435	}
436	array2[i2]=buffer[i];
437	}
438	if(buffer[i+1]==cPare_Open){
439	SetError(14,buffer,cp);
440	return 0;
441	}
442	}
443	continue;
444	}
445	if(buffer[i]=='.'){
446	lstrcpy(NestMember,buffer+i+1);
447	refType = CClass::Dot;
448	buffer[i]=0;
449	break;
450	}
451	if(buffer[i]==1&&buffer[i+1]==ESC_PSMEM){
452	lstrcpy(NestMember,buffer+i+2);
453	refType = CClass::Pointer;
454	buffer[i]=0;
455	break;
456	}
457	if(buffer[i]=='\0') break;
458	}
459	return 1;
460	}
461
462	void GetArrayElement( const char buffer,char variable,char *array_element){
463	array_element[0]=0;
464
465	if(buffer[lstrlen(buffer)-1]!=']'){
466	lstrcpy(variable,buffer);
467	return;
468	}
469
470	int i,i2;
471	for(i=0;;i++){
472	if(buffer[i]=='\0') break;
473	if(buffer[i]=='['){
474	i2=GetStringInBracket(array_element,buffer+i);
475	i+=i2-1;
476	continue;
477	}
478	}
479
480	lstrcpy(variable,buffer);
481	variable[lstrlen(variable)-lstrlen(array_element)]=0;
482
483	RemoveStringBracket(array_element);
484	}
485
486	BOOL CheckVarNameError(char *name,int nowLine){
487	int i2;
488
489	if(!IsVariableTopChar(name[0])){
490	SetError(1,NULL,nowLine);
491	return 0;
492	}
493	for(i2=1;;i2++){
494	if(name[i2]=='\0') break;
495	if(!IsVariableChar(name[i2])){
496	SetError(1,NULL,nowLine);
497	return 0;
498	}
499	}
500	return 1;
501	}
502
503	int JumpSubScripts(const int *ss){
504	//DIMで定義された並んだ配列の数だけアドレスを進める
505	int i,i2;
506	for(i=0,i2=1;i<255;i++){
507	if(ss[i]==-1) break;
508	i2*=ss[i]+1;
509	}
510	return i2;
511	}
512	void GetArrange(char variable,char variAnswer,int *SubScripts){
513	extern int cp;
514	int i,i2,i3,i4;
515	double dbl;
516	_int64 i64data;
517	BOOL bBracket;
518	char temporary[VN_SIZE];
519
520	for(i=0;;i++){
521	if(variable[i]=='('\|\|variable[i]=='['){
522	if(variable[i]=='[') bBracket=1;
523	else bBracket=0;
524
525	variAnswer[i]=0;
526	for(i++,i2=0,i3=0;;i++,i2++){
527	if(variable[i]==','){
528	temporary[i2]=0;
529
530	Type resultType;
531	if( !StaticCalculation(true, temporary,0,&i64data,resultType) ){
532	return;
533	}
534	if(resultType.IsReal()){
535	memcpy(&dbl,&i64data,sizeof(double));
536	i64data=(_int64)dbl;
537	}
538
539	if(i64data<0){
540	//error
541	SubScripts[i3]=0;
542	}
543	else SubScripts[i3]=(int)i64data;
544	i3++;
545	i2=-1;
546	continue;
547	}
548	if(variable[i]=='('){
549	i4=GetStringInPare(temporary+i2,variable+i);
550	i2+=i4-1;
551	i+=i4-1;
552	continue;
553	}
554	if(variable[i]=='['){
555	i4=GetStringInBracket(temporary+i2,variable+i);
556	i2+=i4-1;
557	i+=i4-1;
558	continue;
559	}
560	if(variable[i]==')'&&bBracket==0\|\|
561	variable[i]==']'&&bBracket){
562	temporary[i2]=0;
563	if(i2==0){
564	SubScripts[i3]=-2;
565	break;
566	}
567
568	Type resultType;
569	if( !StaticCalculation(true, temporary,0,&i64data,resultType) ){
570	return;
571	}
572	if(resultType.IsReal()){
573	memcpy(&dbl,&i64data,sizeof(double));
574	i64data=(_int64)dbl;
575	}
576
577	if(i64data<0){
578	//error
579	SubScripts[i3]=0;
580	}
581	else SubScripts[i3]=(int)i64data;
582	SubScripts[i3+1]=-1;
583	break;
584	}
585	if(variable[i]=='\"'){
586	SetError(1,NULL,cp);
587	return;
588	}
589	temporary[i2]=variable[i];
590	}
591	break;
592	}
593	variAnswer[i]=variable[i];
594	if(variable[i]=='\0'){
595	SubScripts[0]=-1;
596	break;
597	}
598	}
599	}
600
601	int GetTypeFromSimpleName(char *variable){
602	extern char DefIntVari[26],DefSngVari[26],DefStrVari[26],divNum,dsvNum,dStrvNum;
603	int i;
604	char name[VN_SIZE];
605
606	//構造体メンバの場合を考慮
607	for(i=lstrlen(variable);i>0;i--){
608	if(variable[i]=='.'){
609	i++;
610	break;
611	}
612	}
613
614	for(;;i++){
615	if(variable[i]=='('\|\|variable[i]=='\0'){
616	name[i]=0;
617	break;
618	}
619	name[i]=variable[i];
620	}
621	//変数名から選択
622	i--;
623	if(name[i]=='#') return DEF_DOUBLE;
624	if(name[i]=='!') return DEF_SINGLE;
625	if(name[i]=='%') return DEF_INTEGER;
626	return DEF_DOUBLE;
627	}
628
629
630	bool GetMemberType( const CClass &objClass, const char *lpszMember, Type &resultType, BOOL bPrivateAccess, bool isErrorEnabled){
631	extern int cp;
632	int i;
633
634	//クラス、配列の構成要素を解析する
635	char VarName[VN_SIZE]; //変数名
636	char array[VN_SIZE]; //第1次配列
637	char lpPtrOffset[VN_SIZE]; //第2次配列
638	char NestMember[VN_SIZE]; //入れ子メンバ
639	CClass::RefType refType = CClass::Non;
640	lstrcpy(VarName,lpszMember);
641	if(!GetVarFormatString(VarName,array,lpPtrOffset,NestMember,refType)) return false;
642
643	for(i=0;i<objClass.iMemberNum;i++){
644	if(lstrcmp(objClass.ppobj_Member[i]->name,VarName)==0) break;
645	}
646	if(i==objClass.iMemberNum){
647	if(isErrorEnabled) SetError(103,VarName,cp);
648	return false;
649	}
650
651	//アクセシビリティをチェック
652	if( &objClass == pobj_CompilingClass ){
653	//同一クラスオブジェクトの場合はプライベートアクセスを容認する
654	if(objClass.ppobj_Member[i]->dwAccess==ACCESS_NON){
655	if(isErrorEnabled) SetError(107,VarName,cp);
656	return false;
657	}
658	}
659	else{
660	if((bPrivateAccess==0&&objClass.ppobj_Member[i]->dwAccess==ACCESS_PRIVATE)\|\|
661	objClass.ppobj_Member[i]->dwAccess==ACCESS_NON){
662	if(isErrorEnabled) SetError(107,VarName,cp);
663	return false;
664	}
665	else if(bPrivateAccess==0&&objClass.ppobj_Member[i]->dwAccess==ACCESS_PROTECTED){
666	if(isErrorEnabled) SetError(108,VarName,cp);
667	return false;
668	}
669	}
670
671	resultType = *objClass.ppobj_Member[i];
672
673	//ポインタ変数の場合
674	if( resultType.IsPointer() ){
675	if(objClass.ppobj_Member[i]->SubScripts[0]==-1){
676	lstrcpy(lpPtrOffset,array);
677	array[0]=0;
678	}
679	}
680	else{
681	if(lpPtrOffset[0]){
682	if(isErrorEnabled) SetError(16,lpszMember,cp);
683	return false;
684	}
685	}
686
687	if( refType != CClass::Non ){
688	//入れ子構造の場合
689
690	return GetMemberType( objClass.ppobj_Member[i]->GetClass(),
691	NestMember,
692	resultType,
693	0,
694	isErrorEnabled);
695	}
696
697	if(array[0]==0&&objClass.ppobj_Member[i]->SubScripts[0]!=-1){
698	resultType.SetBasicType( resultType.GetBasicType() \| FLAG_PTR );
699	return true;
700	}
701
702	if(lpPtrOffset[0]){
703	if( resultType.PtrLevel() ){
704	resultType.PtrLevelDown();
705	}
706	else{
707	//エラー
708	if(isErrorEnabled) SetError(1,NULL,cp);
709	return false;
710	}
711	}
712
713	return true;
714	}
715	bool GetVarType( const char *nameBuffer, Type &resultType, bool isErrorEnabled){
716	int i;
717	char variable[VN_SIZE],member[VN_SIZE],VarName[VN_SIZE],array[VN_SIZE],lpPtrOffset[VN_SIZE];
718
719	if(nameBuffer[0]=='.'){
720	GetWithName(variable);
721	lstrcat(variable,nameBuffer);
722	}
723	else lstrcpy(variable,nameBuffer);
724
725
726	CClass::RefType refType;
727	if( FormatUseProcReturnObject( variable, VarName, array, refType, member ) ){
728	// 戻り値オブジェクトのメンバを直接参照しているとき
729	//例: func().member
730
731	void *pProc;
732	int idProc=GetProc(VarName,(void **)&pProc);
733
734	if(idProc){
735	Type type;
736	if( !CallProc( idProc, pProc, VarName, array,type, false) ){
737	return false;
738	}
739
740	return GetMemberType( type.GetClass() ,member,resultType,1,isErrorEnabled);
741	}
742	}
743
744
745
746	lstrcpy(VarName,variable);
747	GetVarFormatString(VarName,array,lpPtrOffset,member,refType);
748
749	const Variable *pVar = NULL;
750	const int *pSubScripts;
751
752	if( UserProc::IsLocalAreaCompiling() ){
753	/////////////////
754	// ローカル変数
755	/////////////////
756
757	pVar = UserProc::CompilingUserProc().localVars.BackSearch( VarName );
758	if( pVar ){
759	goto ok;
760	}
761	}
762
763	if(pobj_CompilingClass){
764	///////////////////////
765	// クラスメンバの参照
766	///////////////////////
767
768	if(lstrcmpi(variable,"This")==0){
769	//Thisオブジェクト
770	resultType.SetType( DEF_OBJECT, pobj_CompilingClass );
771	return true;
772	}
773
774	if(memicmp(variable,"This.",5)==0){
775	//Thisオブジェクトのメンバを参照するとき
776	SlideString(variable+5,-5);
777	lstrcpy(VarName,variable);
778	}
779	else{
780	//クラス内メンバを参照するとき（通常）
781
782	for(i=0;i<pobj_CompilingClass->iMemberNum;i++){
783	if(lstrcmp(VarName,pobj_CompilingClass->ppobj_Member[i]->name)==0) break;
784	}
785	if(i==pobj_CompilingClass->iMemberNum) goto NonClassMember;
786	}
787
788	return GetMemberType(*pobj_CompilingClass,variable,resultType,1,isErrorEnabled);
789	}
790
791	NonClassMember:
792
793	//////////////////////////
794	// 静的ローカル変数
795	// ※"Static.Object.Method.Variable"
796	//////////////////////////
797
798	char temporary[VN_SIZE];
799	if( UserProc::IsLocalAreaCompiling() ){
800	GetNowStaticVarFullName(VarName,temporary);
801
802	pVar = globalVars.Find( temporary );
803	if( pVar ){
804	goto ok;
805	}
806	}
807
808
809	//////////////////////////
810	// クラスの静的メンバ
811	//////////////////////////
812
813	if(member[0]){
814	lstrcpy(temporary,member);
815	char tempMember[VN_SIZE];
816	char tempArray[VN_SIZE];
817	{
818	CClass::RefType refType;
819	GetVarFormatString(temporary,tempArray,lpPtrOffset,tempMember,refType);
820	}
821
822	char temp2[VN_SIZE];
823	sprintf(temp2,"%s.%s",VarName,temporary);
824
825	pVar = globalVars.Find( temp2 );
826	if( pVar ){
827	lstrcpy(member,tempMember);
828	lstrcpy(array,tempArray);
829	goto ok;
830	}
831	}
832
833	if(pobj_CompilingClass){
834	//自身のクラスから静的メンバを参照する場合
835	char temp2[VN_SIZE];
836	sprintf(temp2,"%s.%s",pobj_CompilingClass->name,VarName);
837
838	pVar = globalVars.Find( temp2 );
839	if( pVar ){
840	goto ok;
841	}
842	}
843
844
845	////////////////////
846	// グローバル変数
847	////////////////////
848
849	pVar = globalVars.BackSearch( VarName );
850	if( pVar ){
851	goto ok;
852	}
853
854	//変数として見つからなかったとき
855	if(isErrorEnabled) SetError(3,variable,cp);
856	return false;
857
858	ok:
859
860	//ポインタ変数の場合
861	if( pVar->IsPointer() ){
862	if( !pVar->IsArray() ){
863	lstrcpy(lpPtrOffset,array);
864	array[0]=0;
865	}
866	}
867	else{
868	if(lpPtrOffset[0]){
869	if(isErrorEnabled) SetError(16,variable,cp);
870	return false;
871	}
872	}
873
874	resultType = (*pVar);
875	pSubScripts=pVar->GetSubScriptsPtr();
876
877
878	if(member[0]){
879	if( NATURAL_TYPE( resultType.GetBasicType() )==DEF_OBJECT
880	\|\| NATURAL_TYPE( resultType.GetBasicType() )==DEF_STRUCT){
881	return GetMemberType(resultType.GetClass(),member,resultType,0,isErrorEnabled);
882	}
883	}
884
885	if(array[0]==0&&pSubScripts[0]!=-1){
886	//配列の先頭ポインタを示す場合
887	resultType.SetBasicType( resultType.GetBasicType() \| FLAG_PTR );
888	}
889
890	if(lpPtrOffset[0]){
891	if( resultType.PtrLevel() ){
892	resultType.PtrLevelDown();
893	}
894	else{
895	//エラー
896	if(isErrorEnabled) SetError(1,NULL,cp);
897	return false;
898	}
899	}
900
901	return true;
902	}
903
904	bool GetVarOffsetReadOnly(const char NameBuffer,RELATIVE_VAR pRelativeVar,Type &resultType,int *pss ){
905	//読み取り専用で変数へアクセス
906	return GetVarOffset(
907	true, //エラー表示有効
908	false, //書き込みアクセスは無し
909	NameBuffer,
910	pRelativeVar,
911	resultType,
912	pss);
913	}
914	bool GetVarOffsetReadWrite(const char NameBuffer,RELATIVE_VAR pRelativeVar,Type &resultType,int *pss ){
915	//読み書き両用で変数へアクセス
916	return GetVarOffset(
917	true, //エラー表示有効
918	true, //書き込みアクセス
919	NameBuffer,
920	pRelativeVar,
921	resultType,
922	pss);
923	}
924
925
926
927	bool GetDimentionFormat( const char *buffer,
928	char *VarName,
929	int *SubScripts,
930	Type &type,
931	char *InitBuf,
932	char *ConstractParameter ){
933	int i,i2,i3,IsStr;
934	char variable[VN_SIZE],temporary[8192];
935
936	for(i=0;;i++){
937	if((buffer[i]==1&&buffer[i+1]==ESC_AS)\|\|
938	buffer[i]=='='\|\|
939	buffer[i]=='\0'){
940	variable[i]=0;
941	break;
942	}
943	variable[i]=buffer[i];
944	}
945
946	if(buffer[i]=='='){
947	////////////////////////////////////
948	// 初期化データが指定されいるとき
949	////////////////////////////////////
950
951	for(i++,i2=0,IsStr=0;;i++,i2++){
952	if(buffer[i]=='\"') IsStr^=1;
953	if(buffer[i]=='('&&IsStr==0){
954	i3=GetStringInPare(InitBuf+i2,buffer+i);
955	i+=i3-1;
956	i2+=i3-1;
957	continue;
958	}
959	if(buffer[i]=='['&&IsStr==0){
960	i3=GetStringInBracket(InitBuf+i2,buffer+i);
961	i+=i3-1;
962	i2+=i3-1;
963	continue;
964	}
965	if((buffer[i]==1&&buffer[i+1]==ESC_AS)\|\|
966	(buffer[i]==','&&IsStr==0)\|\|
967	buffer[i]=='\0'){
968	InitBuf[i2]=0;
969	break;
970	}
971	InitBuf[i2]=buffer[i];
972	}
973	}
974	else{
975	//初期化データなし
976	InitBuf[0]=0;
977	}
978
979	ConstractParameter[0]=0;
980	if(buffer[i]==1&&buffer[i+1]==ESC_AS){
981	/////////////////////////////
982	// "As ～" による型指定あり
983	/////////////////////////////
984
985	for(i+=2,i2=0;;i++,i2++){
986	if(buffer[i]==','\|\|buffer[i]=='('\|\|buffer[i]=='\0'){
987	temporary[i2]=0;
988	break;
989	}
990	temporary[i2]=buffer[i];
991	}
992	if(temporary[0]=='*'&&
993	temporary[1]==1&&
994	(temporary[2]==ESC_FUNCTION\|\|temporary[2]==ESC_SUB)){
995	if(buffer[i]!='('){
996	SetError(10,temporary,cp);
997	return false;
998	}
999	i3=GetStringInPare(temporary+3,buffer+i);
1000	i+=i3;
1001	i2+=i3;
1002
1003	if(temporary[2]==ESC_FUNCTION&&buffer[i]==1&&buffer[i+1]==ESC_AS){
1004	temporary[i2++]=buffer[i++];
1005	temporary[i2++]=buffer[i++];
1006	for(;;i++,i2++){
1007	if(!IsVariableChar(buffer[i])){
1008	temporary[i2]=0;
1009	break;
1010	}
1011	temporary[i2]=buffer[i];
1012	}
1013	}
1014	}
1015
1016	if( !Type::StringToType( temporary, type ) ){
1017	SetError(3,temporary,cp);
1018	type.SetBasicType( DEF_LONG );
1019	}
1020
1021	if(buffer[i]=='('){
1022	//コンストラクタに渡すパラメータを取得
1023	i2=GetStringInPare(ConstractParameter,buffer+i);
1024	i+=i2;
1025	RemoveStringPare(ConstractParameter);
1026
1027	if( !type.IsObject() ){
1028	SetError(112,variable,cp);
1029	return false;
1030	}
1031	}
1032	}
1033	else{
1034	/////////////////
1035	// As指定なし
1036	/////////////////
1037
1038	if( InitBuf[0] == '\0' ){
1039	//As指定も、初期値指定もない場合
1040	type.SetBasicType( GetTypeFromSimpleName(variable) );
1041
1042	i2=lstrlen(variable)-1;
1043	if(i2>=0){
1044	if(!(variable[i2]=='#'\|\|variable[i2]=='!'\|\|variable[i2]=='%'\|\|variable[i2]=='$'))
1045	SetError(-103,variable,cp);
1046	}
1047	}
1048	else{
1049	//初期値の型を判別して自動的に型情報を付加する
1050	if( !NumOpe_GetType( InitBuf, GetStringTypeInfo(), type ) ){
1051	// エラーの場合
1052	return false;
1053	}
1054	}
1055
1056	}
1057
1058	if( InitBuf[0] != '\0' && ConstractParameter[0] != '\0' ){
1059	//初期値とコンストラクタパラメータが同時に呼び出されているとき
1060	SetError(132, NULL, cp);
1061	}
1062
1063	GetArrange(variable,VarName,SubScripts);
1064	return true;
1065	}
1066
1067	BOOL GetNowStaticVarFullName(char VarName,char FullName){
1068	if( UserProc::IsGlobalAreaCompiling() ){
1069	// グローバル領域をコンパイル中のとき
1070	return 0;
1071	}
1072
1073	UserProc &proc = UserProc::CompilingUserProc();
1074
1075	//Static識別
1076	lstrcpy(FullName,"Static%");
1077
1078	//クラス名
1079	if(pobj_CompilingClass){
1080	lstrcat(FullName,pobj_CompilingClass->name);
1081	lstrcat(FullName,"%");
1082	}
1083
1084	//関数（またはメソッド）名
1085	lstrcat(FullName,proc.GetName().c_str());
1086	lstrcat(FullName,"%");
1087
1088	//ID
1089	char temp[255];
1090	sprintf(temp,"%x",proc.id);
1091	lstrcat(FullName,temp);
1092	lstrcat(FullName,"%");
1093
1094	//変数名
1095	lstrcat(FullName,VarName);
1096
1097	return 1;
1098	}
1099
1100
1101	void AddGlobalVariable(bool isRef, const char name,int SubScripts, const Type &type,char InitBuf,char ConstractParameter,DWORD dwFlag){
1102	/////////////////////////
1103	// グローバル変数を追加
1104	/////////////////////////
1105	extern int AllInitGlobalVarSize;
1106	extern int AllGlobalVarSize;
1107
1108	if( globalVars.DuplicateCheck( name ) ){
1109	//２重定義のエラー
1110	SetError(15,name,cp);
1111	return;
1112	}
1113
1114	bool isConst = ( dwFlag & DIMFLAG_CONST ) ? true:false;
1115
1116	Variable *pVar = new Variable( name, type, isConst, isRef );
1117
1118	if( SubScripts[0] != -1 ){
1119	//配列あり
1120	pVar->SetArray( SubScripts );
1121	}
1122
1123	//コンストラクタ用パラメータ
1124	pVar->paramStrForConstructor = ConstractParameter;
1125
1126	//レキシカルスコープ
1127	pVar->ScopeLevel=obj_LexScopes.GetNowLevel();
1128	pVar->ScopeStartAddress=obj_LexScopes.GetStartAddress();
1129	pVar->bLiving=TRUE;
1130
1131	//エラー用
1132	pVar->source_code_address=cp;
1133
1134	// 変数を追加
1135	globalVars.push_back( pVar );
1136
1137	//アラインメントを考慮
1138	int alignment = 0;
1139	if( pVar->IsStruct() ){
1140	alignment = pVar->GetClass().iAlign;
1141	}
1142
1143	if(InitBuf[0]\|\|dwFlag==DIMFLAG_INITDEBUGVAR){
1144	//初期バッファがあるとき
1145
1146	if( alignment ){
1147	if( AllInitGlobalVarSize % alignment ){
1148	AllInitGlobalVarSize += alignment - (AllInitGlobalVarSize % alignment);
1149	}
1150	}
1151
1152	pVar->offset=AllInitGlobalVarSize;
1153	AllInitGlobalVarSize += pVar->GetMemorySize();
1154	}
1155	else{
1156	//初期バッファがないとき
1157
1158	if( alignment ){
1159	if( AllGlobalVarSize % alignment ){
1160	AllGlobalVarSize += alignment - (AllGlobalVarSize % alignment);
1161	}
1162	}
1163
1164	pVar->offset=AllGlobalVarSize \| 0x80000000;
1165	AllGlobalVarSize += pVar->GetMemorySize();
1166	}
1167
1168	if(InitBuf[0]){
1169	int result = 0;
1170	if( !pVar->IsObject() ){
1171	//初期バッファにデータをセット
1172	extern BYTE *initGlobalBuf;
1173	initGlobalBuf=(BYTE *)HeapReAlloc(hHeap,
1174	HEAP_ZERO_MEMORY,
1175	initGlobalBuf,
1176	AllInitGlobalVarSize);
1177
1178	result = SetInitGlobalData(pVar->offset,
1179	*pVar,
1180	pVar->GetSubScriptsPtr(),
1181	InitBuf);
1182	}
1183
1184	if(!result){
1185	//動的な式だった場合は代入演算を行う
1186
1187	//初期代入時のみ、書き込みアクセスを許可する
1188	if( isConst ){
1189	pVar->ConstOff();
1190	}
1191
1192	//代入
1193	char temporary[8192];
1194	sprintf(temporary,"%s=%s",name,InitBuf);
1195	OpcodeCalc(temporary);
1196
1197	//アクセス制限を元に戻す
1198	if( isConst ){
1199	pVar->ConstOn();
1200	}
1201	}
1202	}
1203
1204
1205	if( type.IsObject() ){
1206	//デストラクタの利用フラグをオンにする
1207	CMethod *method = type.GetClass().GetDestructorMethod();
1208	if( method ){
1209	method->pUserProc->Using();
1210	}
1211	}
1212	}
1213
1214	void dim(char *Parameter,DWORD dwFlags){
1215	extern HANDLE hHeap;
1216	int i2;
1217	char VarName[VN_SIZE];
1218
1219	//参照型かどうか
1220	bool isRef = false;
1221
1222	i2 = 0;
1223
1224	if( Parameter[i2] == 1 && Parameter[i2+1] == ESC_BYREF ){
1225	//参照型
1226	isRef = true;
1227	Parameter += 2;
1228	}
1229
1230	if(dwFlags & DIMFLAG_CONST){
1231
1232	//////////////////////////////////
1233	// 定数変数の場合を考慮
1234	//////////////////////////////////
1235	for(;;i2++){
1236	if(Parameter[i2] == '=' \|\|
1237	Parameter[i2] == 1 && Parameter[i2] == ESC_AS \|\|
1238	Parameter[i2] =='('){
1239	VarName[i2] = 0;
1240	break;
1241	}
1242	VarName[i2] = Parameter[i2];
1243	}
1244
1245	//定数と２重定義されていないる場合は抜け出す
1246	if(CDBConst::obj.GetType(VarName)){
1247	return;
1248	}
1249
1250	//定数マクロとして定義されている場合は抜け出す
1251	if(GetConstHash(VarName)){
1252	return;
1253	}
1254	}
1255
1256
1257	//構文を解析
1258	int SubScripts[MAX_ARRAYDIM];
1259	Type type;
1260	char InitBuf[8192];
1261	char ConstractParameter[VN_SIZE];
1262	if(!GetDimentionFormat(Parameter, VarName,SubScripts,type,InitBuf,ConstractParameter))
1263	return;
1264
1265
1266	//定数と２重定義されていないかを調べる
1267	if(CDBConst::obj.GetType(VarName)){
1268	SetError(15,VarName,cp);
1269	return;
1270	}
1271
1272	//定数マクロとして定義されている場合
1273	if(GetConstHash(VarName)){
1274	SetError(15,VarName,cp);
1275	return;
1276	}
1277
1278	if(dwFlags&DIMFLAG_STATIC){
1279	if( UserProc::IsGlobalAreaCompiling() ){
1280	SetError(60,NULL,cp);
1281	return;
1282	}
1283
1284	/////////////////////
1285	// Static変数
1286	// ※"Static.Object.Method.Variable"
1287	/////////////////////
1288
1289	char temporary[VN_SIZE];
1290	GetNowStaticVarFullName(VarName,temporary);
1291
1292	dim( isRef,temporary,SubScripts,type,InitBuf,ConstractParameter,dwFlags );
1293
1294	/*
1295	Note: 静的変数のコンストラクタ呼び出しは
1296	_System_InitStaticLocalVariables関数内で一括して行う
1297	*/
1298	}
1299	else{
1300	dim( isRef,VarName,SubScripts,type,InitBuf,ConstractParameter,dwFlags );
1301	}
1302	}
1303	void OpcodeDim(char *Parameter,DWORD dwFlags){
1304	int i,i2,i3,IsStr=0;
1305	char temporary[8192];
1306
1307	for(i=0,i2=0;;i++,i2++){
1308	if(Parameter[i]=='\"') IsStr^=1;
1309	if(Parameter[i]=='('&&IsStr==0){
1310	i3=GetStringInPare(temporary+i2,Parameter+i);
1311	i+=i3-1;
1312	i2+=i3-1;
1313	continue;
1314	}
1315	if(Parameter[i]=='['&&IsStr==0){
1316	i3=GetStringInBracket(temporary+i2,Parameter+i);
1317	i+=i3-1;
1318	i2+=i3-1;
1319	continue;
1320	}
1321	if((Parameter[i]==','&&IsStr==0)\|\|
1322	Parameter[i]=='\0'){
1323	temporary[i2]=0;
1324
1325	dim(temporary,dwFlags);
1326
1327	if(Parameter[i]=='\0') break;
1328	i2=-1;
1329	continue;
1330	}
1331	temporary[i2]=Parameter[i];
1332	}
1333	}

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

Download in other formats: