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