source: dev/BasicCompiler_Common/ParamImpl.cpp@ 73

Last change on this file since 73 was 73, checked in by dai_9181, 17 years ago

Parameterクラスを適用。32bit側は動くようになったので、64bitのほうを調整する。
File size: 7.6 KB
Line 
1#include "common.h"
2
3#ifdef _AMD64_
4#include "../BasicCompiler64/opcode.h"
5#else
6#include "../BasicCompiler32/opcode.h"
7#endif
8
9ParamImpl::ParamImpl(const char *buffer){
10 ///////////////////////////
11 // パラメータ文字列を整理
12 ///////////////////////////
13
14 extern HANDLE hHeap;
15 int i,i2,i3;
16 char temporary[VN_SIZE];
17
18 i=0;
19 ParmsNum=0;
20 while(1){
21 if(buffer[i]=='\0') break;
22
23 for(i2=0;;i2++,i++){
24 if(buffer[i]=='\"'){
25 temporary[i2]=buffer[i];
26 for(i++,i2++;;i++,i2++){
27 temporary[i2]=buffer[i];
28 if(buffer[i]=='\"') break;
29 }
30 continue;
31 }
32
33 if(buffer[i]=='('){
34 i3=GetStringInPare(temporary+i2,buffer+i);
35 i2+=i3-1;
36 i+=i3-1;
37 continue;
38 }
39 if(buffer[i]=='['){
40 i3=GetStringInBracket(temporary+i2,buffer+i);
41 i2+=i3-1;
42 i+=i3-1;
43 continue;
44 }
45
46 if(buffer[i]==','||buffer[i]=='\0'){
47 temporary[i2]=0;
48 break;
49 }
50 temporary[i2]=buffer[i];
51 }
52
53 Parms[ParmsNum]=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
54 lstrcpy(Parms[ParmsNum],temporary);
55 ParmsNum++;
56
57 if(buffer[i]==',') i++;
58 }
59
60 ReturnTypeInfo.type=DEF_NON;
61 ReturnTypeInfo.u.lpIndex=-1;
62}
63ParamImpl::ParamImpl(const PARAMETER_INFO *pParamInfo,const int ParmNum){
64 int i;
65 for(i=0;i<ParmNum;i++){
66 Parms[i]=0;
67 types[i].type=pParamInfo[i].type;
68 types[i].u.lpIndex=pParamInfo[i].u.index;
69 }
70 this->ParmsNum=ParmNum;
71
72 ReturnTypeInfo.type=DEF_NON;
73 ReturnTypeInfo.u.lpIndex=-1;
74}
75ParamImpl::ParamImpl(const Parameters &params){
76 int count = 0;
77 foreach( Parameter *pParam, params ){
78 types[count].type = pParam->GetBasicType();
79 types[count].u.lpIndex = pParam->GetIndex();
80 count++;
81 }
82 this->ParmsNum=params.size();
83
84 ReturnTypeInfo.type=DEF_NON;
85 ReturnTypeInfo.u.lpIndex=-1;
86}
87ParamImpl::~ParamImpl(){
88 int i2;
89
90 //パラメータ文字列を解放
91 for(i2=0;i2<ParmsNum;i2++){
92 if(Parms[i2]==(char *)-1) continue;
93
94 if(Parms[i2]) HeapDefaultFree(Parms[i2]);
95 }
96}
97
98void ParamImpl::SetReturnType(TYPEINFO *pTypeInfo){
99 ReturnTypeInfo=*pTypeInfo;
100}
101
102BOOL ParamImpl::_overload_check( Parameters &params,TYPEINFO *pReturnTypeInfo,int overload_level){
103 //パラメータを識別してオーバーロードを解決
104
105 //パラメータの個数が不一致の場合
106 int max = (int)params.size();
107 if(max!=ParmsNum) return 0;
108
109 Type argType;
110 for(int i=0;i<max;i++){
111 Parameter &param = *params[i];
112
113 if(Parms[i]){
114 Type nullParam( DEF_NON );
115
116 NumOpe_GetType(Parms[i],
117 (overload_level==OVERLOAD_LEVEL0)? nullParam : param,
118 argType);
119 }
120 else{
121 argType.SetType( types[i].type, types[i].u.lpIndex );
122 }
123
124 if(argType.GetBasicType()!=param.GetBasicType()){
125 if(overload_level==OVERLOAD_LEVEL1 || overload_level == OVERLOAD_LEVEL0){
126 return 0;
127 }
128 else if(overload_level==OVERLOAD_LEVEL2){
129 if(!(
130 IsWholeNumberType(argType.GetBasicType())&&IsWholeNumberType(param.GetBasicType())||
131 IsRealNumberType(argType.GetBasicType())&&IsRealNumberType(param.GetBasicType())
132 )) return 0;
133 }
134 else if(overload_level==OVERLOAD_LEVEL3){
135 if(argType.GetBasicType()==DEF_OBJECT||param.GetBasicType()==DEF_OBJECT) return 0;
136 }
137 }
138 else{
139 if(NATURAL_TYPE(argType.GetBasicType())==DEF_OBJECT || NATURAL_TYPE(argType.GetBasicType())==DEF_STRUCT){
140 if(argType.GetIndex()!=param.GetIndex()) return 0;
141 }
142 }
143 }
144
145 if(pReturnTypeInfo){
146 //戻り値も比較対象にする
147 if(ReturnTypeInfo.type==pReturnTypeInfo->type){
148 if(NATURAL_TYPE(ReturnTypeInfo.type)==DEF_OBJECT
149 || NATURAL_TYPE(ReturnTypeInfo.type)==DEF_STRUCT ){
150 if(ReturnTypeInfo.u.lpIndex != pReturnTypeInfo->u.lpIndex) return 0;
151 }
152 }
153 else return 0;
154 }
155
156 return 1;
157}
158
159SubInfo *ParamImpl::OverloadSolutionWithReturnType( const char *name, std::vector<SubInfo *> &subs ){
160 int sw=0;
161 SubInfo *psi;
162 psi=0;
163
164 for( int level=OVERLOAD_MIN_LEVEL; level<=OVERLOAD_MAX_LEVEL; level++ ){
165 foreach( SubInfo *temp_psi, subs ){
166
167 TYPEINFO ReturnTypeInfo;
168 ReturnTypeInfo.type=temp_psi->ReturnType;
169 ReturnTypeInfo.u.lpIndex=temp_psi->u.ReturnIndex;
170
171 //エラーチェック
172 if(_overload_check(temp_psi->params,&ReturnTypeInfo,level)){
173 if(sw){
174 SetError(52,name,cp);
175 return 0;
176 }
177 sw=1;
178
179 psi = temp_psi;
180 break;
181 }
182 }
183
184 if( sw ) break;
185 }
186
187 if(!sw){
188 SetError(52,name,cp);
189 return 0;
190 }
191
192 return psi;
193}
194SubInfo *ParamImpl::OverloadSolution( const char *name, std::vector<SubInfo *> &subs ){
195 int sw=0;
196 SubInfo *psi;
197 psi=0;
198
199 for( int level=OVERLOAD_MIN_LEVEL; level<=OVERLOAD_MAX_LEVEL; level++ ){
200
201 foreach( SubInfo *temp_psi, subs ){
202
203 //エラーチェック
204 if(_overload_check(temp_psi->params,NULL,level)){
205 if(sw){
206 return OverloadSolutionWithReturnType(name,subs);
207 }
208 sw=1;
209
210 psi = temp_psi;
211 }
212 }
213
214 if( sw ) break;
215 }
216
217 if(!sw){
218 SubInfo *temp_psi;
219 foreach( temp_psi, subs ){
220
221 //エラーチェック
222 if(temp_psi->params.size()==this->ParmsNum){
223 if(sw){
224 sw=0;
225 break;
226 }
227 sw=1;
228
229 psi=temp_psi;
230 }
231 }
232 }
233
234 if(!sw){
235 SetError(52,name,cp);
236 return 0;
237 }
238
239 return psi;
240}
241
242BOOL ParamImpl::ErrorCheck(const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum){
243 if(ParmsNum>pi_num){
244 if(ppi[pi_num-1].type!=DEF_ELLIPSE){
245 //パラメータが多すぎるとき
246 SetError(10,FuncName,cp);
247 return 0;
248 }
249 }
250 else if(ParmsNum<pi_num){
251 if(ParmsNum<SecondParmNum){
252 if(ppi[ParmsNum].type==DEF_ELLIPSE){
253 return 1;
254 }
255
256 //パラメータが少なすぎるとき
257 SetError(10,FuncName,cp);
258 return 0;
259 }
260
261 //省略パラメータに "0" を指定する
262 for(;ParmsNum < pi_num;ParmsNum++){
263 extern HANDLE hHeap;
264 char temporary[64];
265 if(ppi[ParmsNum].bByVal) lstrcpy(temporary,"0");
266 else sprintf(temporary,"%c%c0",1,ESC_BYVAL);
267 Parms[ParmsNum]=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
268 lstrcpy(Parms[ParmsNum],temporary);
269 }
270 }
271
272 return 1;
273}
274bool ParamImpl::ErrorCheck( const char *procName, const Parameters &params, int SecondParmNum ){
275 if(ParmsNum>(int)params.size()){
276 if(params[params.size()-1]->GetBasicType()!=DEF_ELLIPSE){
277 //パラメータが多すぎるとき
278 SetError(10,procName,cp);
279 return false;
280 }
281 }
282 else if(ParmsNum<(int)params.size()){
283 if(ParmsNum<SecondParmNum){
284 if(params[ParmsNum]->GetBasicType()==DEF_ELLIPSE){
285 return true;
286 }
287
288 //パラメータが少なすぎるとき
289 SetError(10,procName,cp);
290 return false;
291 }
292
293 //省略パラメータに "0" を指定する
294 for(;ParmsNum < (int)params.size();ParmsNum++){
295 extern HANDLE hHeap;
296 char temporary[64];
297 if(params[ParmsNum]->IsRef() == false) lstrcpy(temporary,"0");
298 else sprintf(temporary,"%c%c0",1,ESC_BYVAL);
299 Parms[ParmsNum]=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
300 lstrcpy(Parms[ParmsNum],temporary);
301 }
302 }
303
304 return true;
305}
306
307void ParamImpl::MacroParameterSupport(PARAMETER_INFO *ppi){
308 for(int i=0;i<ParmsNum;i++){
309 if(Parms[i][0]=='\0'){
310 extern HANDLE hHeap;
311 char temporary[64];
312 if(ppi[i].bByVal) lstrcpy(temporary,"0");
313 else sprintf(temporary,"%c%c0",1,ESC_BYVAL);
314 HeapDefaultFree(Parms[i]);
315 Parms[i]=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
316 lstrcpy(Parms[i],temporary);
317 }
318 }
319}
320void ParamImpl::MacroParameterSupport( const Parameters &params ){
321 for(int i=0;i<ParmsNum;i++){
322 if(Parms[i][0]=='\0'){
323 extern HANDLE hHeap;
324 char temporary[64];
325 if( params[i]->IsRef() == false ) lstrcpy(temporary,"0");
326 else sprintf(temporary,"%c%c0",1,ESC_BYVAL);
327 HeapDefaultFree(Parms[i]);
328 Parms[i]=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
329 lstrcpy(Parms[i],temporary);
330 }
331 }
332}
Note: See TracBrowser for help on using the repository browser.