Context Navigation

source: dev/trunk/ab5.0/abdev/BasicCompiler_Common/NumOpe_GetType.cpp@ 536

Last change on this file since 536 was 536, checked in by dai_9181, 16 years ago
Compiler::pCompilingClassメンバをprivateにし、setter/getterにあたるメソッドを用意した。
File size: 24.9 KB

Line
1	#include "stdafx.h"
2
3	#include <Compiler.h>
4
5	#include "common.h"
6
7
8	int MakeWholeType(int size,int bSigned){
9	switch(size){
10	case 1:
11	if(bSigned) return DEF_SBYTE;
12	else return DEF_BYTE;
13	break;
14	case 2:
15	if(bSigned) return DEF_INTEGER;
16	else return DEF_WORD;
17	break;
18	case 4:
19	if(bSigned) return DEF_LONG;
20	else return DEF_DWORD;
21	break;
22	case 8:
23	if(bSigned) return DEF_INT64;
24	else return DEF_QWORD;
25	break;
26	}
27	return 0;
28	}
29
30	int AutoBigCast(int BaseType,int CalcType){
31	int type;
32	type=CalcType;
33
34	if(BaseType==0\|\|BaseType==-1){
35	//ベースタイプが未定のとき
36	return type;
37	}
38
39	if(!IsWholeNumberType(type)){
40	//整数型ではないときは暗黙の変換は必要なし
41	return type;
42	}
43
44	if(BaseType==DEF_OBJECT\|\|BaseType==DEF_STRUCT){
45	//ベースタイプがオブジェクトのときは暗黙の変換は必要なし
46	return type;
47	}
48
49	int BaseTypeSize;
50	BaseTypeSize=Type(BaseType,-1).GetSize();
51
52	if(IsRealNumberType(BaseType)){
53	if(Type(CalcType,-1).GetSize()<4)
54	type=MakeWholeType(4,IsSignedType(CalcType));
55	}
56	else if(BaseTypeSize>Type(CalcType,-1).GetSize()){
57	//要求される型のほうがサイズが大きいとき
58	type=MakeWholeType(BaseTypeSize,IsSignedType(CalcType));
59	}
60
61	if(!type){
62	extern int cp;
63	compiler.errorMessenger.Output(300,NULL,cp);
64	}
65
66	return type;
67	}
68
69	BOOL CheckCalcType(int idCalc,int *type,int sp){
70	//演算子の右辺、左辺の型をチェック
71	extern int cp;
72
73	//演算子名を取得
74	char temporary[255];
75	GetCalcName(idCalc,temporary);
76
77	switch(idCalc){
78
79	/////////////////////////////////////
80	// 実数に対する論理演算はエラー
81	/////////////////////////////////////
82
83	case CALC_XOR:
84	case CALC_OR:
85	case CALC_AND:
86	if(IsRealNumberType(type[sp-2])\|\|IsRealNumberType(type[sp-1])){
87	//いずれかの項が実数のとき
88	compiler.errorMessenger.Output(45,temporary,cp);
89	return 0;
90	}
91
92	//As以外の演算子に型名が指定されていないかをチェック
93	if((type[sp-2]&FLAG_CAST)\|\|(type[sp-1]&FLAG_CAST)){
94	compiler.errorMessenger.Output(48,temporary,cp);
95	return 0;
96	}
97	break;
98
99	case CALC_NOT:
100	if(IsRealNumberType(type[sp-1])){
101	//実数のとき
102	compiler.errorMessenger.Output(45,temporary,cp);
103	return 0;
104	}
105
106	//As以外の演算子に型名が指定されていないかをチェック
107	if(type[sp-1]&FLAG_CAST){
108	compiler.errorMessenger.Output(48,temporary,cp);
109	return 0;
110	}
111	break;
112
113
114
115	/////////////////////////////////////
116	// 比較演算はチェック項目なし
117	/////////////////////////////////////
118
119	case CALC_PE:
120	case CALC_QE:
121	case CALC_NOTEQUAL:
122	case CALC_EQUAL:
123	case CALC_P:
124	case CALC_Q:
125	//As以外の演算子に型名が指定されていないかをチェック
126	if((type[sp-2]&FLAG_CAST)\|\|(type[sp-1]&FLAG_CAST)){
127	compiler.errorMessenger.Output(48,temporary,cp);
128	return 0;
129	}
130	break;
131
132
133
134	/////////////////////////////////////
135	// 算術演算をチェック
136	/////////////////////////////////////
137
138	case CALC_ADDITION:
139	case CALC_SUBTRACTION:
140	case CALC_PRODUCT:
141	case CALC_QUOTIENT:
142	case CALC_POWER:
143	//As以外の演算子に型名が指定されていないかをチェック
144	if((type[sp-2]&FLAG_CAST)\|\|(type[sp-1]&FLAG_CAST)){
145	compiler.errorMessenger.Output(48,temporary,cp);
146	return 0;
147	}
148	break;
149
150	case CALC_SHL:
151	case CALC_SHR:
152	case CALC_MOD:
153	case CALC_INTQUOTIENT:
154	if(IsRealNumberType(type[sp-2])\|\|IsRealNumberType(type[sp-1])){
155	//いずれかの項が実数のとき
156	compiler.errorMessenger.Output(45,temporary,cp);
157	return 0;
158	}
159
160	//As以外の演算子に型名が指定されていないかをチェック
161	if((type[sp-2]&FLAG_CAST)\|\|(type[sp-1]&FLAG_CAST)){
162	compiler.errorMessenger.Output(48,temporary,cp);
163	return 0;
164	}
165	break;
166
167	case CALC_AS:
168	if((type[sp-1]&FLAG_CAST)==0){
169	//型名が指定されていないときはエラー
170	compiler.errorMessenger.Output(47,NULL,cp);
171	return 0;
172	}
173	break;
174
175	case CALC_BYVAL:
176	if(type[sp-1]&FLAG_CAST){
177	//型名が指定されていないときはエラー
178	compiler.errorMessenger.Output(47,NULL,cp);
179	return 0;
180	}
181	break;
182
183	case CALC_MINUSMARK:
184	//As以外の演算子に型名が指定されていないかをチェック
185	if(type[sp-1]&FLAG_CAST){
186	compiler.errorMessenger.Output(48,temporary,cp);
187	return 0;
188	}
189	break;
190	}
191	return 1;
192	}
193
194	int GetReturnType_OperatorProc(int idCalc,const Type &baseType,int type_stack,LONG_PTR index_stack,int &sp){
195	Type leftType( type_stack[sp-2], index_stack[sp-2] );
196	Type rightType( type_stack[sp-1] & (~FLAG_CAST), index_stack[sp-1] );
197
198	//オーバーロードされたオペレータ関数を呼び出す
199	const CClass *pobj_c = &leftType.GetClass();
200
201	std::vector<const UserProc *> subs;
202	pobj_c->GetDynamicMethods().Enum( idCalc, subs );
203	if( subs.size() == 0 ){
204	return 0;
205	}
206
207
208	//項の数
209	BOOL bTwoTerm=1;
210	if(idCalc==CALC_AS) bTwoTerm=0;
211
212
213
214	/////////////////////////////////////////////
215	// オーバーロード解決用のパラメータを設定
216	/////////////////////////////////////////////
217
218
219	//_System_LocalThis
220	Parameters params;
221
222	if(bTwoTerm){
223	params.push_back( new Parameter( "", rightType ) );
224	}
225
226
227	//オーバーロードを解決
228	char temporary[255];
229	if(idCalc==CALC_EQUAL) lstrcpy(temporary,"==");
230	else GetCalcName(idCalc,temporary);
231	const UserProc *pUserProc = OverloadSolution( temporary, subs, params, baseType, leftType );
232
233	if(bTwoTerm){
234	delete params[0];
235	}
236
237	if(!pUserProc){
238	return 0;
239	}
240	else{
241	//オーバーロードされていないが、パラメータ個数が一致しないとき
242	if(params.size()!=pUserProc->Params().size()){
243	return 0;
244	}
245	}
246
247	sp--;
248	type_stack[sp-1]=pUserProc->ReturnType().GetBasicType();
249	index_stack[sp-1]=pUserProc->ReturnType().GetIndex();
250
251	return 1;
252	}
253
254	bool Operator_New_GetType(const char *Parameter,const Type &baseType, Type &resultType ){
255	char TypeName[VN_SIZE],objectSizeStr[VN_SIZE];
256	int i,i2;
257
258	i=0;
259
260	if(Parameter[0]=='['){
261	i=GetStringInBracket(objectSizeStr,Parameter);
262
263	SlideString(objectSizeStr+1,-1);
264	objectSizeStr[i-2]=0;
265	}
266	else objectSizeStr[0]=0;
267
268	for(i2=0;;i++,i2++){
269	if(Parameter[i]=='(' \|\| Parameter[i]=='['){
270	TypeName[i2]=0;
271	break;
272	}
273	TypeName[i2]=Parameter[i];
274	if(Parameter[i]=='\0'){
275	break;
276	}
277	}
278
279	if( !compiler.StringToType( TypeName, resultType ) )
280	{
281	compiler.errorMessenger.Output(3,TypeName,cp);
282	return false;
283	}
284
285	if( !resultType.IsObject() )
286	{
287	compiler.errorMessenger.Output(121,NULL,cp);
288	return false;
289	}
290
291	if( baseType.IsObject() ){
292	resultType.SetBasicType( DEF_OBJECT );
293	}
294	else{
295	resultType.SetBasicType( DEF_PTR_OBJECT );
296	}
297	return true;
298	}
299
300	bool GetMemberTermType( const Type &leftType, const Type &baseType, Type &resultType, const char termFull, const char termLeft, const char member, bool pIsVariable )
301	{
302	////////////////////////////////
303	// インデクサ（getアクセサ）
304	////////////////////////////////
305
306	char VarName[VN_SIZE],ArrayElements[VN_SIZE];
307	GetArrayElement(member,VarName,ArrayElements);
308	if(ArrayElements[0]){
309	Type classType;
310	if( VarName[0] == '\0' )
311	{
312	classType = leftType;
313
314	if( classType.IsObject() )
315	{
316	// 既にuseRegにオブジェクトポインタが格納されており、それに対するインデクサを呼び出す場合
317	// ※「プロパティ値として返ってきたオブジェクトインスタンスのインデクサを呼び出す」場合にここにくる
318	}
319	}
320	else
321	{
322	GetMemberType( leftType, VarName, classType, 0, false );
323	}
324
325	if( classType.IsObject() )
326	{
327	if( !GetReturnTypeOfIndexerGetterProc( classType, resultType ) ){
328	compiler.errorMessenger.Output(1,NULL,cp);
329	return false;
330	}
331
332	return true;
333	}
334	}
335
336
337	///////////////////////////////////////////////////////////////////
338	// メンバを検索
339	///////////////////////////////////////////////////////////////////
340	if( GetMemberType( leftType, member, resultType, 0, false ) ){
341	// メンバが見つかったとき
342
343	if( pIsVariable )
344	{
345	*pIsVariable = true;
346	}
347
348	return true;
349	}
350
351
352	///////////////////////////////////////////////////////////////////
353	// 動的メソッドを検索
354	///////////////////////////////////////////////////////////////////
355	char methodName[VN_SIZE] ,lpPtrOffset[VN_SIZE], dummy[1];
356	char parameter[VN_SIZE];
357	ReferenceKind refType;
358	PareOrBracket pareOrBracket = None;
359	lstrcpy( methodName, member );
360	GetVarFormatString( methodName, parameter, lpPtrOffset, dummy, refType, &pareOrBracket );
361
362	std::vector<const UserProc *> userProcs;
363	leftType.GetClass().EnumDynamicMethodsOrInterfaceMethods( methodName, userProcs );
364	if(userProcs.size()){
365	//オーバーロードを解決
366	const UserProc *pUserProc = OverloadSolutionWithStrParam(termFull,userProcs,parameter,termLeft);
367
368	if( pUserProc )
369	{
370	if(
371	pUserProc->Params().size() == 0 // 仮引数の個数は0
372	&& parameter[0] // 実引数は1つ以上
373	&& pUserProc->ReturnType().IsObject() // 戻り値がクラス型の場合
374	&& pareOrBracket == Bracket ) // 実引数は[]で囲まれている
375	{
376	// プロパティ値として返ってきたオブジェクトインスタンスのインデクサを呼び出す
377
378	// まずはプロパティ値を取得
379	bool dummyIsVariable;
380	GetMemberTermType( leftType, baseType, resultType, termFull, termLeft, methodName, &dummyIsVariable );
381
382	// 戻り値のオブジェクトインスタンスのインデクサを呼び出す
383	char temporary[VN_SIZE], temp2[VN_SIZE];
384	sprintf( temporary, "[%s]", parameter );
385	sprintf( temp2, "%s.%s", termLeft, methodName );
386	Type classType = resultType;
387	return GetMemberTermType( classType, baseType, resultType, termFull, temp2, temporary, pIsVariable );
388	}
389
390	resultType = pUserProc->ReturnType();
391
392	// 型パラメータを解決
393	ResolveFormalGenericTypeParameter( resultType, leftType, pUserProc );
394
395	return true;
396	}
397	}
398
399	return false;
400	}
401
402	bool GetTermType( const char term, const Type &baseType, Type &resultType, bool &isLiteral, bool pIsClassName, bool *pIsVariable )
403	{
404	char parameter[VN_SIZE];
405
406	// Withを解決
407	char termFull[VN_SIZE];
408	if(term[0]=='.'){
409	GetWithName(termFull);
410	lstrcat(termFull,term);
411	}
412	else lstrcpy(termFull,term);
413
414	char termLeft[VN_SIZE];
415	lstrcpy(termLeft,termFull);
416
417	// パース
418	char member[VN_SIZE];
419	ReferenceKind refType;
420	if( SplitMemberName( termFull, termLeft, member, refType ) ){
421	///////////////////////////////////////////////////////////////////
422	// オブジェクトとメンバに分解できるとき
423	// termLeft.member
424	///////////////////////////////////////////////////////////////////
425
426	isLiteral = false;
427
428	// オブジェクト側の型を取得
429	bool isClassName = false;
430	Type leftType;
431	if( GetTermType( termLeft, Type(), leftType, isLiteral, &isClassName ) ){
432	if( isClassName == false && compiler.GetObjectModule().meta.GetBlittableTypes().IsExist( leftType ) ){
433	// 左側のオブジェクト部分がBlittable型のとき
434
435	char temporary[VN_SIZE];
436	lstrcpy( temporary, termLeft );
437	sprintf( termLeft, "%s(%s)",
438	compiler.GetObjectModule().meta.GetBlittableTypes().Find( leftType ).GetCreateStaticMethodFullName().c_str(),
439	temporary );
440
441	if( !GetTermType( termLeft, Type(), leftType, isLiteral, &isClassName ) ){
442	goto globalArea;
443	}
444	}
445	}
446	else{
447	goto globalArea;
448	}
449
450	if( isClassName ){
451	// 静的メンバ/メソッドの場合
452	goto globalArea;
453	}
454
455	if( !leftType.HasMember() ){
456	// メンバを持たない型の場合
457	return false;
458	}
459
460	return GetMemberTermType( leftType, baseType, resultType, termFull, termLeft, member, pIsVariable );
461	}
462
463
464	//////////////////////////////////////////////
465	// クラス名かどうかをチェック（静的メンバ用）
466	//////////////////////////////////////////////
467
468	if( pIsClassName ){
469	if( compiler.GetObjectModule().meta.GetClasses().Find( termFull ) ){
470	*pIsClassName = true;
471	return true;
472	}
473	}
474
475
476	/////////////////////////////////////////////////////////////////
477	// グローバル属性
478	/////////////////////////////////////////////////////////////////
479	globalArea:
480
481
482	if(lstrcmpi(termFull,"This")==0)
483	{
484	if( !compiler.IsCompilingClass() )
485	{
486	return false;
487	}
488
489	//Thisオブジェクト
490	resultType.SetType( DEF_OBJECT, &compiler.GetCompilingClass() );
491	isLiteral = false;
492	return true;
493	}
494
495
496	//////////////////////////////////////
497	// 関数（DLL、ユーザー定義、組み込み）
498	//////////////////////////////////////
499	char procName[VN_SIZE];
500	char temporary[8192];
501
502	int i2=GetCallProcName(termFull,procName);
503	if(termFull[i2]=='('){
504	int i4=GetStringInPare_RemovePare(parameter,termFull+i2+1);
505
506	void *pProc;
507	int idProc=GetProc(procName,(void **)&pProc);
508
509	if(idProc){
510	//閉じカッコ")"に続く文字がNULLでないとき
511	if(termFull[i2+1+i4+1]!='\0'){
512	compiler.errorMessenger.Output(42,NULL,cp);
513	}
514
515
516	////////////////
517	// 呼び出し
518	////////////////
519
520	if( !CallProc(idProc,pProc,procName,parameter, baseType, resultType, false ) ){
521	return false;
522	}
523	if( resultType.IsNull() ){
524	//戻り値が存在しないとき
525	return false;
526	}
527
528	isLiteral = false;
529
530	return true;
531	}
532	else
533	{
534	ConstMacro *pConstMacro = compiler.GetObjectModule().meta.GetGlobalConstMacros().Find( procName );
535	if( pConstMacro )
536	{
537	if( pConstMacro->GetCalcBuffer( parameter, temporary ) )
538	{
539	/////////////////////////
540	// マクロ関数
541	/////////////////////////
542
543	//閉じカッコ")"に続く文字がNULLでないときはエラーにする
544	if(termFull[i2+1+i4+1]!='\0') compiler.errorMessenger.Output(42,NULL,cp);
545
546	//マクロ関数の場合
547	if( !NumOpe_GetType(temporary,Type(),resultType) ){
548	return false;
549	}
550
551	if( !IS_LITERAL( resultType.GetIndex() ) ){
552	//リテラル値ではなかったとき
553	isLiteral = false;
554	}
555
556	return true;
557	}
558	}
559	}
560	}
561
562
563	////////////////////////////////
564	// インデクサ（getアクセサ）
565	////////////////////////////////
566
567	char VarName[VN_SIZE],ArrayElements[VN_SIZE];
568	GetArrayElement(termFull,VarName,ArrayElements);
569	if(ArrayElements[0]){
570	Type classType;
571	GetVarType(VarName,classType,false);
572	if( classType.IsObject() ){
573	if( !GetReturnTypeOfIndexerGetterProc( classType, resultType ) ){
574	compiler.errorMessenger.Output(1,NULL,cp);
575	return false;
576	}
577
578	isLiteral = false;
579
580	return true;
581	}
582	}
583
584
585	////////////////////////////////
586	// 変数
587	////////////////////////////////
588
589	if( GetVarType( termFull, resultType, false ) ){
590	if( resultType.GetBasicType() & FLAG_PTR ){
591	//配列ポインタ
592	resultType.SetBasicType( GetPtrType( resultType.GetBasicType()^FLAG_PTR ) );
593	}
594
595	isLiteral = false;
596
597	if( pIsVariable )
598	{
599	// 変数である
600	*pIsVariable = true;
601	}
602
603	return true;
604	}
605
606
607	/////////////////////////////////
608	// プロパティ用のメソッド
609	/////////////////////////////////
610
611	//配列要素を排除
612	GetArrayElement(termFull,VarName,ArrayElements);
613
614	if(GetSubHash(VarName,0)){
615	GetReturnTypeOfPropertyMethod(termFull,NULL,resultType);
616
617	isLiteral = false;
618
619	return true;
620	}
621
622
623	return false;
624	}
625
626	bool GetTermType( const char *term, Type &resultType )
627	{
628	bool isLiteral;
629	return GetTermType( term, Type(), resultType, isLiteral );
630	}
631
632	bool GetTermTypeOnlyVariable( const char *term, Type &resultType )
633	{
634	bool isLiteral, isVariable = false;
635	bool result = GetTermType( term, Type(), resultType, isLiteral, NULL, &isVariable );
636	return ( result && isVariable );
637	}
638
639	bool NumOpe_GetType( const char expression, const Type &baseType, Type &resultType, bool pIsLiteralCalculation ){
640	extern int cp;
641	int i,i3;
642
643	//リテラル値のみの計算かどうかを判別するためのフラグ
644	bool dummyBool;
645	if( pIsLiteralCalculation == NULL )
646	{
647	pIsLiteralCalculation = &dummyBool;
648	}
649	*pIsLiteralCalculation = true;
650
651	if(expression[0]=='\0'){
652	compiler.errorMessenger.Output(1,NULL,cp);
653	return false;
654	}
655
656	if(expression[0]==1&& ( expression[1]==ESC_NEW \|\| expression[1] == ESC_SYSTEM_STATIC_NEW ) ){
657	//New演算子（オブジェクト生成）
658	*pIsLiteralCalculation = false;
659	return Operator_New_GetType(expression+2,baseType, resultType );
660	}
661
662	if( expression[0] == '[' ){
663	if( !baseType.IsPointer() ){
664	return false;
665	}
666
667	resultType = baseType;
668	return true;
669	}
670
671
672	/////////////////////////////////
673	// 式要素を逆ポーランド式で取得
674	/////////////////////////////////
675
676	char *values[255];
677	long calc[255];
678	long stack[255];
679	int pnum;
680	if(!GetNumOpeElements(expression,&pnum,values,calc,stack)){
681	for(i=0;i<pnum;i++){
682	if(values[i]) HeapDefaultFree(values[i]);
683	}
684	return false;
685	}
686
687
688
689	////////////////////////////////
690	// 演算部分のコード生成を開始
691	////////////////////////////////
692
693	BOOL bError;
694	bError=0;
695
696	int sp;
697	int type_stack[255];
698	LONG_PTR index_stack[255];
699	bool isNothing_stack[255];
700	_int64 i64data;
701	int idCalc;
702	for(i=0,sp=0;i<pnum;i++){
703	idCalc=calc[i]%100;
704
705	if(idCalc){
706	if(type_stack[sp-2]==DEF_OBJECT){
707	if( idCalc == CALC_AS
708	&& type_stack[sp-1] == ( DEF_OBJECT \| FLAG_CAST )
709	&& index_stack[sp-1] == index_stack[sp-2]
710	\|\| isNothing_stack[sp-2] ){
711	// 同一の型、またはNothingに対するAsはAs演算子を呼び出さない
712	}
713	else if( idCalc == CALC_AS
714	&& type_stack[sp-1] == ( DEF_OBJECT \| FLAG_CAST )
715	&& ( ((CClass )index_stack[sp-1])->IsEqualsOrSubClass( (CClass )index_stack[sp-2] ) \|\| ((CClass )index_stack[sp-2])->IsEqualsOrSubClass( (CClass )index_stack[sp-1] )
716	)){
717	// ダウンキャストを許可する
718	}
719	else if( idCalc == CALC_AS ){
720	// NumOpe_GetTypeではすべてのキャストを許可する
721	}
722	else{
723	//オーバーロードされたオペレータを呼び出す
724	if(!GetReturnType_OperatorProc(idCalc,baseType,type_stack,index_stack,sp)){
725	goto error;
726	}
727
728	continue;
729	}
730	}
731
732	if(!CheckCalcType(idCalc,type_stack,sp)) goto error;
733	}
734
735	switch(idCalc){
736	//数値
737	case 0:
738	index_stack[sp]=-1;
739	isNothing_stack[sp] = false;
740
741	char *term;
742	term = values[i];
743
744	if( calc[i+1]%100 == CALC_AS ){
745	// As演算子の右辺値
746	//型名
747	if( compiler.StringToType( term, resultType ) ){
748
749	if( resultType.IsObject() ){
750	if( resultType.GetClass().IsBlittableType() ){
751	// Blittable型のときは基本型として扱う
752	// ※ただし、コンパイル中のメソッドがBlittable型クラスに属していないこと
753	if( UserProc::IsLocalAreaCompiling()
754	&& UserProc::CompilingUserProc().HasParentClass()
755	&& UserProc::CompilingUserProc().GetParentClass().IsBlittableType() )
756	{
757	// コンパイル中のメソッドがBlittable型クラスに属している
758	}
759	else{
760	resultType = resultType.GetClass().GetBlittableType();
761	}
762	}
763	}
764
765	resultType.SetBasicType( resultType.GetBasicType() \| FLAG_CAST );
766	}
767	else{
768	compiler.errorMessenger.Output(3, term, cp );
769	goto error;
770	}
771
772	type_stack[sp] = resultType.GetBasicType();
773	index_stack[sp] = resultType.GetIndex();
774	sp++;
775
776	break;
777	}
778
779	if(term[0]=='\"'){
780	StrLiteral:
781
782	if( !baseType.IsPointer() ){
783	//要求タイプがオブジェクト、または未定のとき
784	type_stack[sp]=DEF_OBJECT;
785	index_stack[sp]=(LONG_PTR)compiler.GetObjectModule().meta.GetClasses().GetStringClassPtr();
786	*pIsLiteralCalculation = false;
787
788	sp++;
789	break;
790	}
791
792	type_stack[sp]=typeOfPtrChar;
793	*pIsLiteralCalculation = false;
794	}
795	else if((term[0]=='e'\|\|term[0]=='E')&&
796	(term[1]=='x'\|\|term[1]=='X')&&
797	term[2]=='\"'){
798	//拡張版リテラル文字列（エスケープシーケンス可能）
799	goto StrLiteral;
800	}
801	else if(IsVariableTopChar(term[0])\|\|
802	term[0]=='*'\|\|
803	(term[0]=='.'&&IsVariableTopChar(term[1])))
804	{
805	//////////////////
806	// 何らかの識別子
807
808	bool isLiteral = true;
809	if( GetTermType( term, baseType, resultType, isLiteral ) ){
810	type_stack[sp] = resultType.GetBasicType();
811	index_stack[sp] = resultType.GetIndex();
812
813	if( !isLiteral ){
814	*pIsLiteralCalculation = false;
815	}
816
817	sp++;
818	break;
819	}
820
821
822	// Nothing
823	if( lstrcmp( term, "Nothing" ) == 0 ){
824	isNothing_stack[sp] = true;
825
826	type_stack[sp] = DEF_OBJECT;
827	if( baseType.IsObject() ){
828	index_stack[sp] = baseType.GetIndex();
829	}
830	else{
831	index_stack[sp] = (LONG_PTR)compiler.GetObjectModule().meta.GetClasses().GetObjectClassPtr();
832	}
833	*pIsLiteralCalculation = false;
834	sp++;
835	break;
836	}
837
838
839	//////////////
840	// 定数の場合
841	//////////////
842
843	i3 = compiler.GetObjectModule().meta.GetGlobalConsts().GetBasicType(term);
844	if(i3){
845	if( compiler.GetObjectModule().meta.GetGlobalConsts().IsStringPtr( term ) ){
846	//リテラル文字列
847	goto StrLiteral;
848	}
849
850	type_stack[sp]=i3;
851	if(IsRealNumberType(i3)){
852	//実数
853	goto Literal;
854	}
855	else if(IsWholeNumberType(i3)){
856	//整数
857	goto Literal;
858	}
859	else if(Is64Type(i3)){
860	//64ビット整数値
861	goto Literal;
862	}
863	else{
864	compiler.errorMessenger.Output(1,NULL,0);
865	goto error;
866	}
867	}
868
869
870	/////////////////////////////////
871	// プロパティ用のメソッド
872	/////////////////////////////////
873
874	//配列要素を排除
875	char VarName[VN_SIZE],ArrayElements[VN_SIZE];
876	GetArrayElement(term,VarName,ArrayElements);
877
878	if(GetSubHash(VarName,0)){
879	compiler.errorMessenger.OutputFatalError();
880	Type tempType;
881	GetReturnTypeOfPropertyMethod(term,NULL,tempType);
882
883	//大きな型への暗黙の変換
884	type_stack[sp]=tempType.GetBasicType();
885
886	index_stack[sp]=tempType.GetIndex();
887	*pIsLiteralCalculation = false;
888
889	sp++;
890	break;
891	}
892
893
894
895	//該当する識別子が見当たらないときはエラー扱いにする
896	bError=1;
897	compiler.errorMessenger.Output(3,term,cp);
898	type_stack[sp]=DEF_DOUBLE;
899	}
900	else{
901	//リテラル値
902	int base_type = 0;
903	if( !baseType.IsNull() ) base_type = baseType.GetBasicType();
904	type_stack[sp]=GetLiteralValue(term,&i64data,base_type);
905	Literal:
906	if((long)i64data==0&&index_stack[sp]==-1) index_stack[sp]=LITERAL_NULL;
907	}
908
909	sp++;
910	break;
911
912	//論理演算子
913	case CALC_XOR:
914	case CALC_OR:
915	case CALC_AND:
916	sp--;
917	type_stack[sp-1]=NeutralizationType(type_stack[sp-1],index_stack[sp-1],type_stack[sp],index_stack[sp]);
918	break;
919	case CALC_NOT:
920	//values[sp-1]=Not values[sp-1]
921	//NOT演算子
922	break;
923
924	//比較演算子
925	case CALC_PE: //values[sp-2] <= values[sp-1]
926	case CALC_QE: //values[sp-2] >= values[sp-1]
927	case CALC_P: //values[sp-2] < values[sp-1]
928	case CALC_Q: //values[sp-2] > values[sp-1]
929	case CALC_NOTEQUAL: //values[sp-2] <> values[sp-1]
930	case CALC_EQUAL: //values[sp-2] = values[sp-1]
931	sp--;
932	type_stack[sp-1]=DEF_LONG;
933	break;
934
935	//ビットシフト
936	case CALC_SHL: //values[sp-2] << values[sp-1]
937	case CALC_SHR: //values[sp-2] >> values[sp-1]
938	sp--;
939	break;
940
941	//算術演算
942	case CALC_ADDITION:
943	case CALC_SUBTRACTION:
944	case CALC_PRODUCT:
945	sp--;
946	type_stack[sp-1]=NeutralizationType(type_stack[sp-1],index_stack[sp-1],type_stack[sp],index_stack[sp]);
947	break;
948	case CALC_MOD:
949	//values[sp-2]%=values[sp-1]
950	//剰余演算
951	sp--;
952	type_stack[sp-1]=NeutralizationType(type_stack[sp-1],index_stack[sp-1],type_stack[sp],index_stack[sp]);
953	break;
954	case CALC_QUOTIENT:
955	//values[sp-2]/=values[sp-1];
956	//除算
957	sp--;
958	type_stack[sp-1]=NeutralizationType(type_stack[sp-1],index_stack[sp-1],type_stack[sp],index_stack[sp]);
959	break;
960	case CALC_INTQUOTIENT:
961	//values[sp-2]/=values[sp-1]
962	//整数除算
963	sp--;
964	type_stack[sp-1]=NeutralizationType(type_stack[sp-1],index_stack[sp-1],type_stack[sp],index_stack[sp]);
965	break;
966	case CALC_MINUSMARK:
967	//values[sp-1]=-values[sp-1]
968	//符号反転
969	break;
970	case CALC_POWER:
971	//べき乗演算（浮動小数点演算のみ）
972	sp--;
973	//未完成
974	break;
975	case CALC_AS:
976	//キャスト
977	type_stack[sp-2]=type_stack[sp-1]&(~FLAG_CAST);
978	index_stack[sp-2]=index_stack[sp-1];
979
980	sp--;
981	break;
982
983	case CALC_BYVAL:
984	//ポインタ型→参照型
985	if( PTR_LEVEL( type_stack[sp-1] ) <= 0 ){
986	//ポインタ型ではないとき
987	compiler.errorMessenger.Output( 3, NULL, cp );
988	goto error;
989	}
990
991	type_stack[sp-1] = PTR_LEVEL_DOWN( type_stack[sp-1] );
992	break;
993	}
994	}
995
996	if(bError) goto error;
997
998	if(sp!=1){
999	compiler.errorMessenger.Output(1,NULL,cp);
1000	goto error;
1001	}
1002
1003	if( *pIsLiteralCalculation ){
1004	//右辺値が数値の定数式の場合
1005	int base_type = 0;
1006	if( !baseType.IsNull() ) base_type = baseType.GetBasicType();
1007	Type tempType;
1008	StaticCalculation(true, expression,base_type,&i64data,tempType);
1009
1010	type_stack[0]=tempType.GetBasicType();
1011	index_stack[0]=tempType.GetIndex();
1012	}
1013	else{
1014	//右辺値が数値の定数式ではないとき
1015	if(IS_LITERAL(index_stack[0])) index_stack[0]=-1;
1016	}
1017
1018	resultType.SetType( type_stack[0], index_stack[0] );
1019
1020	bool isSuccessful = true;
1021	goto finish;
1022
1023
1024	//////////////////
1025	// エラー処理
1026	//////////////////
1027
1028	error:
1029	isSuccessful = false;
1030	goto finish;
1031
1032
1033	finish:
1034	for(i=0;i<pnum;i++){
1035	if(values[i]) HeapDefaultFree(values[i]);
1036	}
1037	return isSuccessful;
1038	}

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

Download in other formats: