Context Navigation

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

Last change on this file since 601 was 598, checked in by dai_9181, 17 years ago
SplitMemberNameの依存関係を排除。
File size: 26.9 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
[561]	452	const Member *pMember = objClass.FindDynamicMember( VarName );
[409]	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
[570]	567	pVar = compiler.GetCompilingUserProc().GetLocalVars().BackSearch(
	568	LexicalAnalyzer::FullNameToSymbol( VarName ),
	569	compiler.codeGenerator.lexicalScopes.GetNowLevel()
	570	);
[75]	571	if( pVar ){
	572	goto ok;
	573	}
	574	}
	575
[536]	576	if( compiler.IsCompilingClass() ){
[75]	577	///////////////////////
	578	// クラスメンバの参照
	579	///////////////////////
	580
	581	if(lstrcmpi(variable,"This")==0){
	582	//Thisオブジェクト
[536]	583	resultType.SetType( DEF_OBJECT, &compiler.GetCompilingClass() );
[75]	584	return true;
	585	}
	586
[76]	587	if(memicmp(variable,"This.",5)==0){
[75]	588	//Thisオブジェクトのメンバを参照するとき
	589	SlideString(variable+5,-5);
	590	lstrcpy(VarName,variable);
	591	}
	592	else{
[409]	593	//クラス内の動的メンバを参照するとき（通常）
[75]	594
[536]	595	if( !compiler.GetCompilingClass().HasDynamicMember( VarName ) )
[409]	596	{
	597	goto NonClassMember;
[75]	598	}
	599	}
	600
[290]	601	return GetMemberType(
[536]	602	Type( DEF_OBJECT, compiler.GetCompilingClass() ),
[290]	603	variable,
	604	resultType,
	605	1,
	606	isErrorEnabled
	607	);
[75]	608	}
	609
	610	NonClassMember:
	611
	612	//////////////////////////
	613	// 静的ローカル変数
	614	// ※"Static.Object.Method.Variable"
	615	//////////////////////////
	616
	617	char temporary[VN_SIZE];
[537]	618	if( compiler.IsLocalAreaCompiling() ){
[75]	619	GetNowStaticVarFullName(VarName,temporary);
	620
[508]	621	pVar = compiler.GetObjectModule().meta.GetGlobalVars().Find( LexicalAnalyzer::FullNameToSymbol( temporary ) );
[75]	622	if( pVar ){
	623	goto ok;
	624	}
	625	}
	626
	627
	628	//////////////////////////
	629	// クラスの静的メンバ
	630	//////////////////////////
	631
	632	if(member[0]){
	633	lstrcpy(temporary,member);
	634	char tempMember[VN_SIZE];
	635	char tempArray[VN_SIZE];
	636	{
[206]	637	ReferenceKind refType;
[75]	638	GetVarFormatString(temporary,tempArray,lpPtrOffset,tempMember,refType);
	639	}
	640
[598]	641	int typeDefIndex = compiler.GetObjectModule().meta.GetTypeDefs().GetIndex( LexicalAnalyzer::FullNameToSymbol( VarName ) );
[116]	642	if( typeDefIndex != -1 ){
	643	// TypeDef後の型名だったとき
[265]	644	lstrcpy( VarName, compiler.GetObjectModule().meta.GetTypeDefs()[typeDefIndex].GetBaseName().c_str() );
[116]	645	}
[114]	646
[75]	647	char temp2[VN_SIZE];
	648	sprintf(temp2,"%s.%s",VarName,temporary);
	649
[508]	650	pVar = compiler.GetObjectModule().meta.GetGlobalVars().Find( LexicalAnalyzer::FullNameToSymbol( temp2 ) );
[75]	651	if( pVar ){
	652	lstrcpy(member,tempMember);
	653	lstrcpy(array,tempArray);
	654	goto ok;
	655	}
	656	}
	657
[536]	658	if( compiler.IsCompilingClass() ){
[75]	659	//自身のクラスから静的メンバを参照する場合
	660	char temp2[VN_SIZE];
[536]	661	sprintf(temp2,"%s.%s",compiler.GetCompilingClass().GetName().c_str(),VarName);
[75]	662
[508]	663	pVar = compiler.GetObjectModule().meta.GetGlobalVars().Find( LexicalAnalyzer::FullNameToSymbol( temp2 ) );
[75]	664	if( pVar ){
	665	goto ok;
	666	}
	667	}
	668
	669
	670	////////////////////
	671	// グローバル変数
	672	////////////////////
	673
[570]	674	pVar = compiler.GetObjectModule().meta.GetGlobalVars().BackSearch(
	675	LexicalAnalyzer::FullNameToSymbol( VarName ),
	676	compiler.codeGenerator.lexicalScopes.GetNowLevel()
	677	);
[75]	678	if( pVar ){
	679	goto ok;
	680	}
	681
	682	//変数として見つからなかったとき
[465]	683	if(isErrorEnabled) compiler.errorMessenger.Output(3,variable,cp);
[75]	684	return false;
	685
	686	ok:
	687
	688	//ポインタ変数の場合
[206]	689	if( pVar->GetType().IsPointer() ){
[75]	690	if( !pVar->IsArray() ){
	691	lstrcpy(lpPtrOffset,array);
	692	array[0]=0;
	693	}
	694	}
	695	else{
	696	if(lpPtrOffset[0]){
[465]	697	if(isErrorEnabled) compiler.errorMessenger.Output(16,variable,cp);
[75]	698	return false;
	699	}
	700	}
	701
[206]	702	resultType = pVar->GetType();
[75]	703
	704	if(member[0]){
	705	if( NATURAL_TYPE( resultType.GetBasicType() )==DEF_OBJECT
[290]	706	\|\| NATURAL_TYPE( resultType.GetBasicType() )==DEF_STRUCT)
	707	{
	708	return GetMemberType(resultType,member,resultType,0,isErrorEnabled);
[75]	709	}
	710	}
	711
[206]	712	if( array[0] == 0 && pVar->GetSubscripts().size() > 0 ){
[75]	713	//配列の先頭ポインタを示す場合
	714	resultType.SetBasicType( resultType.GetBasicType() \| FLAG_PTR );
	715	}
	716
	717	if(lpPtrOffset[0]){
	718	if( resultType.PtrLevel() ){
	719	resultType.PtrLevelDown();
	720	}
	721	else{
	722	//エラー
[465]	723	if(isErrorEnabled) compiler.errorMessenger.Output(1,NULL,cp);
[75]	724	return false;
	725	}
	726	}
	727
	728	return true;
	729	}
	730
[290]	731	bool GetVarOffsetReadOnly(const char NameBuffer,RELATIVE_VAR pRelativeVar,Type &resultType, Subscripts *pResultSubscripts )
	732	{
[75]	733	//読み取り専用で変数へアクセス
	734	return GetVarOffset(
	735	true, //エラー表示有効
	736	false, //書き込みアクセスは無し
	737	NameBuffer,
	738	pRelativeVar,
	739	resultType,
[206]	740	pResultSubscripts
	741	);
[75]	742	}
[290]	743	bool GetVarOffsetReadWrite(const char NameBuffer,RELATIVE_VAR pRelativeVar,Type &resultType, Subscripts *pResultSubscripts )
	744	{
[75]	745	//読み書き両用で変数へアクセス
	746	return GetVarOffset(
	747	true, //エラー表示有効
	748	true, //書き込みアクセス
	749	NameBuffer,
	750	pRelativeVar,
	751	resultType,
[206]	752	pResultSubscripts
	753	);
[75]	754	}
	755
	756
	757
	758	bool GetDimentionFormat( const char *buffer,
	759	char *VarName,
[206]	760	Subscripts &subscripts,
[75]	761	Type &type,
	762	char *InitBuf,
	763	char *ConstractParameter ){
	764	int i,i2,i3,IsStr;
	765	char variable[VN_SIZE],temporary[8192];
	766
	767	for(i=0;;i++){
	768	if((buffer[i]==1&&buffer[i+1]==ESC_AS)\|\|
	769	buffer[i]=='='\|\|
	770	buffer[i]=='\0'){
	771	variable[i]=0;
	772	break;
	773	}
	774	variable[i]=buffer[i];
	775	}
	776
	777	if(buffer[i]=='='){
	778	////////////////////////////////////
	779	// 初期化データが指定されいるとき
	780	////////////////////////////////////
[79]	781	i++;
[75]	782
[79]	783	if( buffer[i]=='[' ){
	784	// 構造初期データの場合
	785
	786	i3=GetStringInBracket(InitBuf,buffer+i);
	787	i+=i3;
	788	}
	789	else{
	790	// 代入初期データの場合
	791
	792	for(i2=0,IsStr=0;;i++,i2++){
	793	if(buffer[i]=='\"') IsStr^=1;
	794	if(buffer[i]=='('&&IsStr==0){
	795	i3=GetStringInPare(InitBuf+i2,buffer+i);
	796	i+=i3-1;
	797	i2+=i3-1;
	798	continue;
	799	}
	800	if(buffer[i]=='['&&IsStr==0){
	801	i3=GetStringInBracket(InitBuf+i2,buffer+i);
	802	i+=i3-1;
	803	i2+=i3-1;
	804	continue;
	805	}
	806	if((buffer[i]==','&&IsStr==0)\|\|
	807	buffer[i]=='\0'){
	808	InitBuf[i2]=0;
	809	break;
	810	}
	811	InitBuf[i2]=buffer[i];
[75]	812	}
	813	}
	814	}
	815	else{
	816	//初期化データなし
	817	InitBuf[0]=0;
	818	}
	819
	820	ConstractParameter[0]=0;
	821	if(buffer[i]==1&&buffer[i+1]==ESC_AS){
	822	/////////////////////////////
	823	// "As ～" による型指定あり
	824	/////////////////////////////
	825
	826	for(i+=2,i2=0;;i++,i2++){
[301]	827	if(buffer[i]=='('\|\|buffer[i]=='\0'){
[75]	828	temporary[i2]=0;
	829	break;
	830	}
	831	temporary[i2]=buffer[i];
	832	}
[78]	833	if(temporary[0]=='*'&&
	834	temporary[1]==1&&
	835	(temporary[2]==ESC_FUNCTION\|\|temporary[2]==ESC_SUB)){
	836	if(buffer[i]!='('){
[465]	837	compiler.errorMessenger.Output(10,temporary,cp);
[78]	838	return false;
	839	}
	840	i3=GetStringInPare(temporary+3,buffer+i);
	841	i+=i3;
	842	i2+=i3;
[75]	843
[78]	844	if(temporary[2]==ESC_FUNCTION&&buffer[i]==1&&buffer[i+1]==ESC_AS){
	845	temporary[i2++]=buffer[i++];
	846	temporary[i2++]=buffer[i++];
	847	for(;;i++,i2++){
	848	if(!IsVariableChar(buffer[i])){
	849	temporary[i2]=0;
	850	break;
[75]	851	}
[78]	852	temporary[i2]=buffer[i];
[75]	853	}
	854	}
[78]	855	}
[75]	856
[198]	857	if( !compiler.StringToType( temporary, type ) ){
[465]	858	compiler.errorMessenger.Output(3,temporary,cp);
[370]	859	return false;
[75]	860	}
	861
	862	if(buffer[i]=='('){
	863	//コンストラクタに渡すパラメータを取得
	864	i2=GetStringInPare(ConstractParameter,buffer+i);
	865	i+=i2;
	866	RemoveStringPare(ConstractParameter);
	867
	868	if( !type.IsObject() ){
[465]	869	compiler.errorMessenger.Output(112,variable,cp);
[75]	870	return false;
	871	}
	872	}
	873	}
	874	else{
	875	/////////////////
	876	// As指定なし
	877	/////////////////
	878
	879	if( InitBuf[0] == '\0' ){
	880	//As指定も、初期値指定もない場合
[182]	881	type.SetBasicType( Type::GetBasicTypeFromSimpleName(variable) );
[75]	882
	883	i2=lstrlen(variable)-1;
	884	if(i2>=0){
	885	if(!(variable[i2]=='#'\|\|variable[i2]=='!'\|\|variable[i2]=='%'\|\|variable[i2]=='$'))
[465]	886	compiler.errorMessenger.Output(-103,variable,cp);
[75]	887	}
	888	}
	889	else{
	890	//初期値の型を判別して自動的に型情報を付加する
	891	if( !NumOpe_GetType( InitBuf, GetStringTypeInfo(), type ) ){
	892	// エラーの場合
	893	return false;
	894	}
[79]	895
	896	if( IS_LITERAL( type.GetIndex() ) ){
	897	type.SetIndex( -1 );
	898	}
[75]	899	}
	900
	901	}
	902
	903	if( InitBuf[0] != '\0' && ConstractParameter[0] != '\0' ){
	904	//初期値とコンストラクタパラメータが同時に呼び出されているとき
[465]	905	compiler.errorMessenger.Output(132, NULL, cp);
[75]	906	}
	907
[206]	908	GetArrange(variable,VarName,subscripts);
[75]	909	return true;
	910	}
	911
	912	BOOL GetNowStaticVarFullName(char VarName,char FullName){
[537]	913	if( compiler.IsGlobalAreaCompiling() ){
[75]	914	// グローバル領域をコンパイル中のとき
	915	return 0;
	916	}
	917
[537]	918	const UserProc &proc = compiler.GetCompilingUserProc();
[75]	919
	920	//Static識別
	921	lstrcpy(FullName,"Static%");
	922
	923	//クラス名
[536]	924	if( compiler.IsCompilingClass() ){
	925	lstrcat(FullName,compiler.GetCompilingClass().GetName().c_str());
[75]	926	lstrcat(FullName,"%");
	927	}
	928
	929	//関数（またはメソッド）名
	930	lstrcat(FullName,proc.GetName().c_str());
	931	lstrcat(FullName,"%");
	932
	933	//ID
	934	char temp[255];
[206]	935	sprintf(temp,"%x",proc.GetId());
[75]	936	lstrcat(FullName,temp);
	937	lstrcat(FullName,"%");
	938
	939	//変数名
	940	lstrcat(FullName,VarName);
	941
	942	return 1;
	943	}
	944
	945
[206]	946	void AddGlobalVariable( const char name, const Subscripts &subscripts, const Type &type,const char InitBuf,const char *ConstractParameter,DWORD dwFlag){
[75]	947	/////////////////////////
	948	// グローバル変数を追加
	949	/////////////////////////
	950
[570]	951	if( compiler.GetObjectModule().meta.GetGlobalVars().DuplicateCheck( LexicalAnalyzer::FullNameToSymbol( name ), compiler.codeGenerator.lexicalScopes.GetNowLevel() ) ){
[75]	952	//２重定義のエラー
[465]	953	compiler.errorMessenger.Output(15,name,cp);
[75]	954	return;
	955	}
	956
	957	bool isConst = ( dwFlag & DIMFLAG_CONST ) ? true:false;
	958
[275]	959	Variable *pVar = new Variable(
	960	compiler.GetNamespaceSupporter().GetLivingNamespaceScopes(),
	961	name,
	962	type,
	963	isConst,
	964	false,
	965	ConstractParameter,
	966	( InitBuf[0] != 0 \|\| dwFlag == DIMFLAG_INITDEBUGVAR )
	967	);
[75]	968
[206]	969	if( subscripts.size() > 0 ){
[75]	970	//配列あり
[206]	971	pVar->SetArray( subscripts );
[75]	972	}
	973
	974	//レキシカルスコープ
[248]	975	pVar->SetScopeLevel( compiler.codeGenerator.lexicalScopes.GetNowLevel() );
	976	pVar->SetScopeStartAddress( compiler.codeGenerator.lexicalScopes.GetStartAddress() );
[392]	977	pVar->isLiving = true;
[75]	978
	979	//エラー用
	980	pVar->source_code_address=cp;
	981
	982	// 変数を追加
[275]	983	compiler.GetObjectModule().meta.GetGlobalVars().Add( pVar );
[75]	984
	985	if(InitBuf[0]){
	986	int result = 0;
[206]	987	if( !pVar->GetType().IsObject() ){
	988	result = SetInitGlobalData(pVar->GetOffsetAddress(),
	989	pVar->GetType(),
	990	pVar->GetSubscripts(),
[75]	991	InitBuf);
	992	}
	993
	994	if(!result){
	995	//動的な式だった場合は代入演算を行う
	996
	997	//初期代入時のみ、書き込みアクセスを許可する
	998	if( isConst ){
	999	pVar->ConstOff();
	1000	}
	1001
	1002	//代入
	1003	char temporary[8192];
	1004	sprintf(temporary,"%s=%s",name,InitBuf);
	1005	OpcodeCalc(temporary);
	1006
	1007	//アクセス制限を元に戻す
	1008	if( isConst ){
	1009	pVar->ConstOn();
	1010	}
	1011	}
	1012	}
	1013
	1014
	1015	if( type.IsObject() ){
	1016	//デストラクタの利用フラグをオンにする
[135]	1017	const CMethod *method = type.GetClass().GetDestructorMethod();
[75]	1018	if( method ){
[206]	1019	method->GetUserProc().Using();
[75]	1020	}
	1021	}
	1022	}
	1023
	1024	void dim(char *Parameter,DWORD dwFlags){
	1025	extern HANDLE hHeap;
	1026	int i2;
	1027	char VarName[VN_SIZE];
	1028
	1029	i2 = 0;
	1030
	1031	if( Parameter[i2] == 1 && Parameter[i2+1] == ESC_BYREF ){
	1032	//参照型
[465]	1033	compiler.errorMessenger.OutputFatalError();
[75]	1034	Parameter += 2;
	1035	}
	1036
	1037	if(dwFlags & DIMFLAG_CONST){
	1038
	1039	//////////////////////////////////
	1040	// 定数変数の場合を考慮
	1041	//////////////////////////////////
	1042	for(;;i2++){
	1043	if(Parameter[i2] == '=' \|\|
	1044	Parameter[i2] == 1 && Parameter[i2] == ESC_AS \|\|
	1045	Parameter[i2] =='('){
	1046	VarName[i2] = 0;
	1047	break;
	1048	}
	1049	VarName[i2] = Parameter[i2];
	1050	}
	1051
	1052	//定数と２重定義されていないる場合は抜け出す
[579]	1053	if(compiler.GetObjectModule().meta.GetGlobalConsts().GetBasicType( ActiveBasic::Compiler::LexicalAnalyzer::FullNameToSymbol( VarName ) )){
[75]	1054	return;
	1055	}
	1056
	1057	//定数マクロとして定義されている場合は抜け出す
[564]	1058	if( compiler.GetObjectModule().meta.GetGlobalConstMacros().IsExistDuplicationKeyName( VarName ) )
[206]	1059	{
[75]	1060	return;
	1061	}
	1062	}
	1063
[368]	1064
[75]	1065	//構文を解析
	1066	Type type;
	1067	char InitBuf[8192];
	1068	char ConstractParameter[VN_SIZE];
[206]	1069	Subscripts subscripts;
	1070	if(!GetDimentionFormat(Parameter, VarName,subscripts,type,InitBuf,ConstractParameter))
[75]	1071	return;
	1072
	1073
	1074	//定数と２重定義されていないかを調べる
[579]	1075	if(compiler.GetObjectModule().meta.GetGlobalConsts().GetBasicType( ActiveBasic::Compiler::LexicalAnalyzer::FullNameToSymbol( VarName ) )){
[465]	1076	compiler.errorMessenger.Output(15,VarName,cp);
[75]	1077	return;
	1078	}
	1079
	1080	//定数マクロとして定義されている場合
[564]	1081	if( compiler.GetObjectModule().meta.GetGlobalConstMacros().IsExistDuplicationKeyName( VarName ) ){
[465]	1082	compiler.errorMessenger.Output(15,VarName,cp);
[75]	1083	return;
	1084	}
	1085
[128]	1086	if( type.IsObject() ){
	1087	if( type.GetClass().IsBlittableType() ){
	1088	// Blittable型のときは基本型として扱う
	1089	// ※ただし、コンパイル中のメソッドがBlittable型クラスに属していないこと
[537]	1090	if( compiler.IsLocalAreaCompiling()
	1091	&& compiler.GetCompilingUserProc().HasParentClass()
	1092	&& compiler.GetCompilingUserProc().GetParentClass().IsBlittableType() )
[128]	1093	{
	1094	// コンパイル中のメソッドがBlittable型クラスに属している
	1095	}
	1096	else{
	1097	type = type.GetClass().GetBlittableType();
	1098	}
	1099	}
	1100	}
	1101
[537]	1102	if(dwFlags&DIMFLAG_STATIC)
	1103	{
	1104	if( compiler.IsGlobalAreaCompiling() )
	1105	{
[465]	1106	compiler.errorMessenger.Output(60,NULL,cp);
[75]	1107	return;
	1108	}
	1109
	1110	/////////////////////
	1111	// Static変数
	1112	// ※"Static.Object.Method.Variable"
	1113	/////////////////////
	1114
	1115	char temporary[VN_SIZE];
	1116	GetNowStaticVarFullName(VarName,temporary);
	1117
[206]	1118	dim( temporary,subscripts,type,InitBuf,ConstractParameter,dwFlags );
[75]	1119
	1120	/*
	1121	Note: 静的変数のコンストラクタ呼び出しは
	1122	_System_InitStaticLocalVariables関数内で一括して行う
	1123	*/
	1124	}
	1125	else{
[206]	1126	dim( VarName,subscripts,type,InitBuf,ConstractParameter,dwFlags );
[75]	1127	}
	1128	}
	1129	void OpcodeDim(char *Parameter,DWORD dwFlags){
	1130	int i,i2,i3,IsStr=0;
	1131	char temporary[8192];
	1132
	1133	for(i=0,i2=0;;i++,i2++){
	1134	if(Parameter[i]=='\"') IsStr^=1;
	1135	if(Parameter[i]=='('&&IsStr==0){
	1136	i3=GetStringInPare(temporary+i2,Parameter+i);
	1137	i+=i3-1;
	1138	i2+=i3-1;
	1139	continue;
	1140	}
	1141	if(Parameter[i]=='['&&IsStr==0){
	1142	i3=GetStringInBracket(temporary+i2,Parameter+i);
	1143	i+=i3-1;
	1144	i2+=i3-1;
	1145	continue;
	1146	}
[301]	1147	if( Parameter[i] == '<' && IsStr == 0 )
	1148	{
	1149	if( IsGenericTypeSourcePart( Parameter + i ) )
	1150	{
	1151	// ジェネリクス構文
	1152	i3=GetStringInGenericBracket(temporary+i2,Parameter+i);
	1153	i+=i3-1;
	1154	i2+=i3-1;
	1155	continue;
	1156	}
	1157	else
	1158	{
	1159	// 一般構文
	1160	}
	1161	}
[75]	1162	if((Parameter[i]==','&&IsStr==0)\|\|
	1163	Parameter[i]=='\0'){
	1164	temporary[i2]=0;
	1165
	1166	dim(temporary,dwFlags);
	1167
	1168	if(Parameter[i]=='\0') break;
	1169	i2=-1;
	1170	continue;
	1171	}
	1172	temporary[i2]=Parameter[i];
	1173	}
	1174	}
[308]	1175
	1176	void DebugVariable(void)
	1177	{
	1178	char temporary[255];
[508]	1179	if( compiler.GetObjectModule().meta.GetGlobalVars().Find( LexicalAnalyzer::FullNameToSymbol( "_DebugSys_dwThreadID" ) ) == NULL )
[308]	1180	{
	1181	// 未定義の場合は定義する
	1182	sprintf(temporary,"_DebugSys_dwThreadID[255]%c%cDWord",1,ESC_AS);
	1183	OpcodeDim(temporary,DIMFLAG_INITDEBUGVAR);
	1184	sprintf(temporary,"_DebugSys_ProcNum[255]%c%cDWord",1,ESC_AS);
	1185	OpcodeDim(temporary,DIMFLAG_INITDEBUGVAR);
	1186	sprintf(temporary,"_DebugSys_lplpObp[255]%c%c*ULONG_PTR",1,ESC_AS);
	1187	OpcodeDim(temporary,DIMFLAG_INITDEBUGVAR);
	1188	sprintf(temporary,"_DebugSys_lplpSpBase[255]%c%c*ULONG_PTR",1,ESC_AS);
	1189	OpcodeDim(temporary,DIMFLAG_INITDEBUGVAR);
	1190	}
	1191	}

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

Download in other formats: