Context Navigation

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

Last change on this file since 743 was 721, checked in by イグトランス (egtra), 16 years ago
#192への対処
File size: 27.6 KB

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

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

Download in other formats: