Context Navigation

source: dev/trunk/ab5.0/abdev/BasicCompiler_Common/VariableOpe.cpp@ 537

Last change on this file since 537 was 537, checked in by dai_9181, 18 years ago
UserProcクラスによるコンパイル中関数管理用メソッドを除去（すべてCompilerクラス内で処理するようにした）。
File size: 26.5 KB

Rev	Line
[206]	1	#include "stdafx.h"
	2
[193]	3	#include <Compiler.h>
[248]	4	#include <LexicalScope.h>
[206]	5	#include <Variable.h>
[182]	6
[75]	7	#include "../BasicCompiler_Common/common.h"
	8
	9	#ifdef _AMD64_
[485]	10	#include "../compiler_x64/opcode.h"
[75]	11	#else
[484]	12	#include "../compiler_x86/opcode.h"
[75]	13	#endif
	14
[508]	15	using namespace ActiveBasic::Compiler;
	16
[75]	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:
[461]	119	if( compiler.IsUnicode() ) return DEF_WORD;
[75]	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{
[131]	158	lstrcpy(name,((CClass *)lpIndex)->GetName().c_str());
[75]	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{
[265]	168	if( compiler.GetObjectModule().meta.GetProcPointers()[lpIndex]->ReturnType().IsNull() )
[75]	169	lstrcpy(name,"*Sub");
	170	else lstrcpy(name,"*Function");
	171	}
	172	}
	173
	174	else{
	175	extern int cp;
[465]	176	compiler.errorMessenger.Output(1,NULL,cp);
[75]	177	return 0;
	178	}
	179	return 1;
	180	}
	181
	182	Type GetStringTypeInfo(){
[265]	183	Type type( DEF_OBJECT, *compiler.GetObjectModule().meta.GetClasses().GetStringClassPtr() );
[75]	184	return type;
	185	}
	186
[97]	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
[75]	196
[206]	197	void GetArrange(char variable,char variAnswer, Subscripts &subscripts ){
[182]	198	extern int cp;
[206]	199	int i,i2,i4;
[182]	200	double dbl;
	201	_int64 i64data;
	202	BOOL bBracket;
	203	char temporary[VN_SIZE];
[75]	204
[182]	205	for(i=0;;i++){
	206	if(variable[i]=='('\|\|variable[i]=='['){
	207	if(variable[i]=='[') bBracket=1;
	208	else bBracket=0;
[75]	209
[182]	210	variAnswer[i]=0;
[206]	211	for(i++,i2=0;;i++,i2++){
[182]	212	if(variable[i]==','){
	213	temporary[i2]=0;
[75]	214
[182]	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	}
[75]	223
[206]	224	if(i64data<0)
	225	{
[182]	226	//error
[206]	227	subscripts.push_back( 0 );
[182]	228	}
[206]	229	else
	230	{
	231	subscripts.push_back( (int)i64data );
	232	}
[182]	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){
[206]	252	subscripts.push_back( -2 );
[182]	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
[206]	267	subscripts.push_back( 0 );
[182]	268	}
[206]	269	else
	270	{
	271	subscripts.push_back( (int)i64data );
	272	}
[182]	273	break;
	274	}
	275	if(variable[i]=='\"'){
[465]	276	compiler.errorMessenger.Output(1,NULL,cp);
[182]	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	}
[75]	287	}
[182]	288	}
[75]	289
	290
[429]	291	BOOL GetVarFormatString( char buffer,char array,char array2,char NestMember,ReferenceKind &refType, PareOrBracket *pPareOrBracket ){
[75]	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	}
[403]	318
[429]	319	if( pPareOrBracket )
[403]	320	{
	321	// []なのか、()なのかを伝える
	322	if( cPare_Open == '[' )
	323	{
[429]	324	*pPareOrBracket = Bracket;
[403]	325	}
	326	else
	327	{
[429]	328	*pPareOrBracket = Pare;
[403]	329	}
	330	}
	331
[75]	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){
[465]	363	compiler.errorMessenger.Output(14,buffer,cp);
[75]	364	return 0;
	365	}
	366	}
	367	continue;
	368	}
	369	if(buffer[i]=='.'){
	370	lstrcpy(NestMember,buffer+i+1);
[206]	371	refType = RefDot;
[75]	372	buffer[i]=0;
	373	break;
	374	}
	375	if(buffer[i]==1&&buffer[i+1]==ESC_PSMEM){
	376	lstrcpy(NestMember,buffer+i+2);
[206]	377	refType = RefPointer;
[75]	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])){
[465]	414	compiler.errorMessenger.Output(1,NULL,nowLine);
[75]	415	return 0;
	416	}
	417	for(i2=1;;i2++){
	418	if(name[i2]=='\0') break;
	419	if(!IsVariableChar(name[i2])){
[465]	420	compiler.errorMessenger.Output(1,NULL,nowLine);
[75]	421	return 0;
	422	}
	423	}
	424	return 1;
	425	}
	426
[206]	427	int JumpSubScripts( const Subscripts &subscripts ){
[75]	428	//DIMで定義された並んだ配列の数だけアドレスを進める
[206]	429	int i, i2;
	430	for( i=0,i2=1; i<(int)subscripts.size(); i++ ){
	431	i2 *= subscripts[i] + 1;
[75]	432	}
	433	return i2;
	434	}
	435
	436
[290]	437	bool GetMemberType( const Type &classType, const char *lpszMember, Type &resultType, BOOL bPrivateAccess, bool isErrorEnabled)
	438	{
	439	const CClass &objClass = classType.GetClass();
	440
[75]	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]; //入れ子メンバ
[206]	448	ReferenceKind refType = RefNon;
[75]	449	lstrcpy(VarName,lpszMember);
	450	if(!GetVarFormatString(VarName,array,lpPtrOffset,NestMember,refType)) return false;
	451
[409]	452	const CMember *pMember = objClass.FindDynamicMember( VarName );
	453	if( !pMember ){
[465]	454	if(isErrorEnabled) compiler.errorMessenger.Output(103,VarName,cp);
[75]	455	return false;
	456	}
	457
	458	//アクセシビリティをチェック
[536]	459	if( compiler.IsCompilingClass() && &objClass == &compiler.GetCompilingClass() ){
[75]	460	//同一クラスオブジェクトの場合はプライベートアクセスを容認する
[140]	461	if( pMember->IsNoneAccess() ){
[465]	462	if(isErrorEnabled) compiler.errorMessenger.Output(107,VarName,cp);
[75]	463	return false;
	464	}
	465	}
	466	else{
[140]	467	if(( bPrivateAccess==0 && pMember->IsPrivate() )\|\|
	468	pMember->IsNoneAccess() ){
[465]	469	if(isErrorEnabled) compiler.errorMessenger.Output(107,VarName,cp);
[75]	470	return false;
	471	}
[140]	472	else if( bPrivateAccess==0 && pMember->IsProtected() ){
[465]	473	if(isErrorEnabled) compiler.errorMessenger.Output(108,VarName,cp);
[75]	474	return false;
	475	}
	476	}
	477
[140]	478	resultType = pMember->GetType();
[75]	479
[301]	480	// 型パラメータを解決
	481	ResolveFormalGenericTypeParameter( resultType, classType );
[290]	482
	483
[75]	484	//ポインタ変数の場合
	485	if( resultType.IsPointer() ){
[206]	486	if( pMember->GetSubscripts().size() == 0 ){
[75]	487	lstrcpy(lpPtrOffset,array);
	488	array[0]=0;
	489	}
	490	}
	491	else{
	492	if(lpPtrOffset[0]){
[465]	493	if(isErrorEnabled) compiler.errorMessenger.Output(16,lpszMember,cp);
[75]	494	return false;
	495	}
	496	}
	497
[334]	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
[206]	510	if( refType != RefNon ){
[75]	511	//入れ子構造の場合
	512
[290]	513	return GetMemberType( pMember->GetType(),
[75]	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	//エラー
[465]	526	if(isErrorEnabled) compiler.errorMessenger.Output(1,NULL,cp);
[75]	527	return false;
	528	}
	529	}
	530
	531	return true;
	532	}
	533	bool GetVarType( const char *nameBuffer, Type &resultType, bool isErrorEnabled){
[106]	534	char variable[VN_SIZE];
[75]	535
	536	if(nameBuffer[0]=='.'){
	537	GetWithName(variable);
	538	lstrcat(variable,nameBuffer);
	539	}
	540	else lstrcpy(variable,nameBuffer);
	541
[106]	542	// 名前空間を分離
	543	char namespaceStr[VN_SIZE]="", simpleName[VN_SIZE];
[265]	544	compiler.GetObjectModule().meta.GetNamespaces().SplitNamespace( variable, namespaceStr, simpleName );
[75]	545
[106]	546	// 先頭オブジェクトまたはクラス名と入れ子メンバに分割
[206]	547	ReferenceKind refType;
[106]	548	char member[VN_SIZE],array[VN_SIZE],lpPtrOffset[VN_SIZE];
	549	GetVarFormatString(simpleName,array,lpPtrOffset,member,refType);
[75]	550
[106]	551	// 名前空間を分離していた場合は結合
	552	char VarName[VN_SIZE];
	553	if( namespaceStr[0] ){
	554	sprintf( VarName, "%s.%s", namespaceStr, simpleName );
[75]	555	}
[106]	556	else{
	557	lstrcpy( VarName, simpleName );
	558	}
[75]	559
	560	const Variable *pVar = NULL;
	561
[537]	562	if( compiler.IsLocalAreaCompiling() ){
[75]	563	/////////////////
	564	// ローカル変数
	565	/////////////////
	566
[537]	567	pVar = compiler.GetCompilingUserProc().GetLocalVars().BackSearch( LexicalAnalyzer::FullNameToSymbol( VarName ) );
[75]	568	if( pVar ){
	569	goto ok;
	570	}
	571	}
	572
[536]	573	if( compiler.IsCompilingClass() ){
[75]	574	///////////////////////
	575	// クラスメンバの参照
	576	///////////////////////
	577
	578	if(lstrcmpi(variable,"This")==0){
	579	//Thisオブジェクト
[536]	580	resultType.SetType( DEF_OBJECT, &compiler.GetCompilingClass() );
[75]	581	return true;
	582	}
	583
[76]	584	if(memicmp(variable,"This.",5)==0){
[75]	585	//Thisオブジェクトのメンバを参照するとき
	586	SlideString(variable+5,-5);
	587	lstrcpy(VarName,variable);
	588	}
	589	else{
[409]	590	//クラス内の動的メンバを参照するとき（通常）
[75]	591
[536]	592	if( !compiler.GetCompilingClass().HasDynamicMember( VarName ) )
[409]	593	{
	594	goto NonClassMember;
[75]	595	}
	596	}
	597
[290]	598	return GetMemberType(
[536]	599	Type( DEF_OBJECT, compiler.GetCompilingClass() ),
[290]	600	variable,
	601	resultType,
	602	1,
	603	isErrorEnabled
	604	);
[75]	605	}
	606
	607	NonClassMember:
	608
	609	//////////////////////////
	610	// 静的ローカル変数
	611	// ※"Static.Object.Method.Variable"
	612	//////////////////////////
	613
	614	char temporary[VN_SIZE];
[537]	615	if( compiler.IsLocalAreaCompiling() ){
[75]	616	GetNowStaticVarFullName(VarName,temporary);
	617
[508]	618	pVar = compiler.GetObjectModule().meta.GetGlobalVars().Find( LexicalAnalyzer::FullNameToSymbol( temporary ) );
[75]	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	{
[206]	634	ReferenceKind refType;
[75]	635	GetVarFormatString(temporary,tempArray,lpPtrOffset,tempMember,refType);
	636	}
	637
[265]	638	int typeDefIndex = compiler.GetObjectModule().meta.GetTypeDefs().GetIndex( VarName );
[116]	639	if( typeDefIndex != -1 ){
	640	// TypeDef後の型名だったとき
[265]	641	lstrcpy( VarName, compiler.GetObjectModule().meta.GetTypeDefs()[typeDefIndex].GetBaseName().c_str() );
[116]	642	}
[114]	643
[75]	644	char temp2[VN_SIZE];
	645	sprintf(temp2,"%s.%s",VarName,temporary);
	646
[508]	647	pVar = compiler.GetObjectModule().meta.GetGlobalVars().Find( LexicalAnalyzer::FullNameToSymbol( temp2 ) );
[75]	648	if( pVar ){
	649	lstrcpy(member,tempMember);
	650	lstrcpy(array,tempArray);
	651	goto ok;
	652	}
	653	}
	654
[536]	655	if( compiler.IsCompilingClass() ){
[75]	656	//自身のクラスから静的メンバを参照する場合
	657	char temp2[VN_SIZE];
[536]	658	sprintf(temp2,"%s.%s",compiler.GetCompilingClass().GetName().c_str(),VarName);
[75]	659
[508]	660	pVar = compiler.GetObjectModule().meta.GetGlobalVars().Find( LexicalAnalyzer::FullNameToSymbol( temp2 ) );
[75]	661	if( pVar ){
	662	goto ok;
	663	}
	664	}
	665
	666
	667	////////////////////
	668	// グローバル変数
	669	////////////////////
	670
[508]	671	pVar = compiler.GetObjectModule().meta.GetGlobalVars().BackSearch( LexicalAnalyzer::FullNameToSymbol( VarName ) );
[75]	672	if( pVar ){
	673	goto ok;
	674	}
	675
	676	//変数として見つからなかったとき
[465]	677	if(isErrorEnabled) compiler.errorMessenger.Output(3,variable,cp);
[75]	678	return false;
	679
	680	ok:
	681
	682	//ポインタ変数の場合
[206]	683	if( pVar->GetType().IsPointer() ){
[75]	684	if( !pVar->IsArray() ){
	685	lstrcpy(lpPtrOffset,array);
	686	array[0]=0;
	687	}
	688	}
	689	else{
	690	if(lpPtrOffset[0]){
[465]	691	if(isErrorEnabled) compiler.errorMessenger.Output(16,variable,cp);
[75]	692	return false;
	693	}
	694	}
	695
[206]	696	resultType = pVar->GetType();
[75]	697
	698	if(member[0]){
	699	if( NATURAL_TYPE( resultType.GetBasicType() )==DEF_OBJECT
[290]	700	\|\| NATURAL_TYPE( resultType.GetBasicType() )==DEF_STRUCT)
	701	{
	702	return GetMemberType(resultType,member,resultType,0,isErrorEnabled);
[75]	703	}
	704	}
	705
[206]	706	if( array[0] == 0 && pVar->GetSubscripts().size() > 0 ){
[75]	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	//エラー
[465]	717	if(isErrorEnabled) compiler.errorMessenger.Output(1,NULL,cp);
[75]	718	return false;
	719	}
	720	}
	721
	722	return true;
	723	}
	724
[290]	725	bool GetVarOffsetReadOnly(const char NameBuffer,RELATIVE_VAR pRelativeVar,Type &resultType, Subscripts *pResultSubscripts )
	726	{
[75]	727	//読み取り専用で変数へアクセス
	728	return GetVarOffset(
	729	true, //エラー表示有効
	730	false, //書き込みアクセスは無し
	731	NameBuffer,
	732	pRelativeVar,
	733	resultType,
[206]	734	pResultSubscripts
	735	);
[75]	736	}
[290]	737	bool GetVarOffsetReadWrite(const char NameBuffer,RELATIVE_VAR pRelativeVar,Type &resultType, Subscripts *pResultSubscripts )
	738	{
[75]	739	//読み書き両用で変数へアクセス
	740	return GetVarOffset(
	741	true, //エラー表示有効
	742	true, //書き込みアクセス
	743	NameBuffer,
	744	pRelativeVar,
	745	resultType,
[206]	746	pResultSubscripts
	747	);
[75]	748	}
	749
	750
	751
	752	bool GetDimentionFormat( const char *buffer,
	753	char *VarName,
[206]	754	Subscripts &subscripts,
[75]	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	////////////////////////////////////
[79]	775	i++;
[75]	776
[79]	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];
[75]	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++){
[301]	821	if(buffer[i]=='('\|\|buffer[i]=='\0'){
[75]	822	temporary[i2]=0;
	823	break;
	824	}
	825	temporary[i2]=buffer[i];
	826	}
[78]	827	if(temporary[0]=='*'&&
	828	temporary[1]==1&&
	829	(temporary[2]==ESC_FUNCTION\|\|temporary[2]==ESC_SUB)){
	830	if(buffer[i]!='('){
[465]	831	compiler.errorMessenger.Output(10,temporary,cp);
[78]	832	return false;
	833	}
	834	i3=GetStringInPare(temporary+3,buffer+i);
	835	i+=i3;
	836	i2+=i3;
[75]	837
[78]	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;
[75]	845	}
[78]	846	temporary[i2]=buffer[i];
[75]	847	}
	848	}
[78]	849	}
[75]	850
[198]	851	if( !compiler.StringToType( temporary, type ) ){
[465]	852	compiler.errorMessenger.Output(3,temporary,cp);
[370]	853	return false;
[75]	854	}
	855
	856	if(buffer[i]=='('){
	857	//コンストラクタに渡すパラメータを取得
	858	i2=GetStringInPare(ConstractParameter,buffer+i);
	859	i+=i2;
	860	RemoveStringPare(ConstractParameter);
	861
	862	if( !type.IsObject() ){
[465]	863	compiler.errorMessenger.Output(112,variable,cp);
[75]	864	return false;
	865	}
	866	}
	867	}
	868	else{
	869	/////////////////
	870	// As指定なし
	871	/////////////////
	872
	873	if( InitBuf[0] == '\0' ){
	874	//As指定も、初期値指定もない場合
[182]	875	type.SetBasicType( Type::GetBasicTypeFromSimpleName(variable) );
[75]	876
	877	i2=lstrlen(variable)-1;
	878	if(i2>=0){
	879	if(!(variable[i2]=='#'\|\|variable[i2]=='!'\|\|variable[i2]=='%'\|\|variable[i2]=='$'))
[465]	880	compiler.errorMessenger.Output(-103,variable,cp);
[75]	881	}
	882	}
	883	else{
	884	//初期値の型を判別して自動的に型情報を付加する
	885	if( !NumOpe_GetType( InitBuf, GetStringTypeInfo(), type ) ){
	886	// エラーの場合
	887	return false;
	888	}
[79]	889
	890	if( IS_LITERAL( type.GetIndex() ) ){
	891	type.SetIndex( -1 );
	892	}
[75]	893	}
	894
	895	}
	896
	897	if( InitBuf[0] != '\0' && ConstractParameter[0] != '\0' ){
	898	//初期値とコンストラクタパラメータが同時に呼び出されているとき
[465]	899	compiler.errorMessenger.Output(132, NULL, cp);
[75]	900	}
	901
[206]	902	GetArrange(variable,VarName,subscripts);
[75]	903	return true;
	904	}
	905
	906	BOOL GetNowStaticVarFullName(char VarName,char FullName){
[537]	907	if( compiler.IsGlobalAreaCompiling() ){
[75]	908	// グローバル領域をコンパイル中のとき
	909	return 0;
	910	}
	911
[537]	912	const UserProc &proc = compiler.GetCompilingUserProc();
[75]	913
	914	//Static識別
	915	lstrcpy(FullName,"Static%");
	916
	917	//クラス名
[536]	918	if( compiler.IsCompilingClass() ){
	919	lstrcat(FullName,compiler.GetCompilingClass().GetName().c_str());
[75]	920	lstrcat(FullName,"%");
	921	}
	922
	923	//関数（またはメソッド）名
	924	lstrcat(FullName,proc.GetName().c_str());
	925	lstrcat(FullName,"%");
	926
	927	//ID
	928	char temp[255];
[206]	929	sprintf(temp,"%x",proc.GetId());
[75]	930	lstrcat(FullName,temp);
	931	lstrcat(FullName,"%");
	932
	933	//変数名
	934	lstrcat(FullName,VarName);
	935
	936	return 1;
	937	}
	938
	939
[206]	940	void AddGlobalVariable( const char name, const Subscripts &subscripts, const Type &type,const char InitBuf,const char *ConstractParameter,DWORD dwFlag){
[75]	941	/////////////////////////
	942	// グローバル変数を追加
	943	/////////////////////////
	944
[508]	945	if( compiler.GetObjectModule().meta.GetGlobalVars().DuplicateCheck( LexicalAnalyzer::FullNameToSymbol( name ) ) ){
[75]	946	//２重定義のエラー
[465]	947	compiler.errorMessenger.Output(15,name,cp);
[75]	948	return;
	949	}
	950
	951	bool isConst = ( dwFlag & DIMFLAG_CONST ) ? true:false;
	952
[275]	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	);
[75]	962
[206]	963	if( subscripts.size() > 0 ){
[75]	964	//配列あり
[206]	965	pVar->SetArray( subscripts );
[75]	966	}
	967
	968	//レキシカルスコープ
[248]	969	pVar->SetScopeLevel( compiler.codeGenerator.lexicalScopes.GetNowLevel() );
	970	pVar->SetScopeStartAddress( compiler.codeGenerator.lexicalScopes.GetStartAddress() );
[392]	971	pVar->isLiving = true;
[75]	972
	973	//エラー用
	974	pVar->source_code_address=cp;
	975
	976	// 変数を追加
[275]	977	compiler.GetObjectModule().meta.GetGlobalVars().Add( pVar );
[75]	978
	979	if(InitBuf[0]){
	980	int result = 0;
[206]	981	if( !pVar->GetType().IsObject() ){
	982	result = SetInitGlobalData(pVar->GetOffsetAddress(),
	983	pVar->GetType(),
	984	pVar->GetSubscripts(),
[75]	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	//デストラクタの利用フラグをオンにする
[135]	1011	const CMethod *method = type.GetClass().GetDestructorMethod();
[75]	1012	if( method ){
[206]	1013	method->GetUserProc().Using();
[75]	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	//参照型
[465]	1027	compiler.errorMessenger.OutputFatalError();
[75]	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	//定数と２重定義されていないる場合は抜け出す
[265]	1047	if(compiler.GetObjectModule().meta.GetGlobalConsts().GetBasicType(VarName)){
[75]	1048	return;
	1049	}
	1050
	1051	//定数マクロとして定義されている場合は抜け出す
[265]	1052	if( compiler.GetObjectModule().meta.GetGlobalConstMacros().IsExist( VarName ) )
[206]	1053	{
[75]	1054	return;
	1055	}
	1056	}
	1057
[368]	1058
[75]	1059	//構文を解析
	1060	Type type;
	1061	char InitBuf[8192];
	1062	char ConstractParameter[VN_SIZE];
[206]	1063	Subscripts subscripts;
	1064	if(!GetDimentionFormat(Parameter, VarName,subscripts,type,InitBuf,ConstractParameter))
[75]	1065	return;
	1066
	1067
	1068	//定数と２重定義されていないかを調べる
[265]	1069	if(compiler.GetObjectModule().meta.GetGlobalConsts().GetBasicType(VarName)){
[465]	1070	compiler.errorMessenger.Output(15,VarName,cp);
[75]	1071	return;
	1072	}
	1073
	1074	//定数マクロとして定義されている場合
[265]	1075	if( compiler.GetObjectModule().meta.GetGlobalConstMacros().IsExist( VarName ) ){
[465]	1076	compiler.errorMessenger.Output(15,VarName,cp);
[75]	1077	return;
	1078	}
	1079
[128]	1080	if( type.IsObject() ){
	1081	if( type.GetClass().IsBlittableType() ){
	1082	// Blittable型のときは基本型として扱う
	1083	// ※ただし、コンパイル中のメソッドがBlittable型クラスに属していないこと
[537]	1084	if( compiler.IsLocalAreaCompiling()
	1085	&& compiler.GetCompilingUserProc().HasParentClass()
	1086	&& compiler.GetCompilingUserProc().GetParentClass().IsBlittableType() )
[128]	1087	{
	1088	// コンパイル中のメソッドがBlittable型クラスに属している
	1089	}
	1090	else{
	1091	type = type.GetClass().GetBlittableType();
	1092	}
	1093	}
	1094	}
	1095
[537]	1096	if(dwFlags&DIMFLAG_STATIC)
	1097	{
	1098	if( compiler.IsGlobalAreaCompiling() )
	1099	{
[465]	1100	compiler.errorMessenger.Output(60,NULL,cp);
[75]	1101	return;
	1102	}
	1103
	1104	/////////////////////
	1105	// Static変数
	1106	// ※"Static.Object.Method.Variable"
	1107	/////////////////////
	1108
	1109	char temporary[VN_SIZE];
	1110	GetNowStaticVarFullName(VarName,temporary);
	1111
[206]	1112	dim( temporary,subscripts,type,InitBuf,ConstractParameter,dwFlags );
[75]	1113
	1114	/*
	1115	Note: 静的変数のコンストラクタ呼び出しは
	1116	_System_InitStaticLocalVariables関数内で一括して行う
	1117	*/
	1118	}
	1119	else{
[206]	1120	dim( VarName,subscripts,type,InitBuf,ConstractParameter,dwFlags );
[75]	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	}
[301]	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	}
[75]	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	}
[308]	1169
	1170	void DebugVariable(void)
	1171	{
	1172	char temporary[255];
[508]	1173	if( compiler.GetObjectModule().meta.GetGlobalVars().Find( LexicalAnalyzer::FullNameToSymbol( "_DebugSys_dwThreadID" ) ) == NULL )
[308]	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	}

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

Download in other formats: