Commit: 70230ce6af7d452211f3f5497d7e76899a1025ef - nullptr (git)

自作言語nullptrのインタープリターです。

Commit MetaInfo

• Revision: 70230ce6af7d452211f3f5497d7e76899a1025ef (tree)
• Time: 2015-08-12 14:09:04
• Author: Diverge <diverge.vosystems@gmai...>
• Commiter: Diverge

Log Message

Module Loader created
begin to create Interpreter

Change Summary

• modified: nullptr.sdf
• modified: nullptr/Interpreter.h
• add: nullptr/Module.cpp
• modified: nullptr/Module.h
• delete: nullptr/ModuleLoader.cpp
• add: nullptr/Preprocessor.cpp
• modified: nullptr/Preprocessor.h
• modified: nullptr/nullptr.cpp
• modified: nullptr/nullptr.h
• modified: nullptr/nullptr.vcxproj
• modified: nullptr/nullptr.vcxproj.filters

Incremental Difference

Binary files a/nullptr.sdf and b/nullptr.sdf differ

--- a/nullptr/Interpreter.h
+++ b/nullptr/Interpreter.h
@@ -15,7 +15,7 @@ namespace VOSystemsNullptr
 {
 	namespace Core
 	{
-		class Interpreter
+		class Interpreter : System::StringModule
 		{
 		private:
 			std::vector<BasicTypes::IntManager> m_int;//Int変数リスト
@@ -35,10 +35,7 @@ namespace VOSystemsNullptr
 			
 			std::string m_stdout,m_stdin,m_stderr;//標準入出力系の名前
 
-			std::vector<std::string> Split(const std::string &str, const std::string &delim);//文字列分割
-			std::string Replace(std::string src, std::string before, std::string after);//文字列置き換え
-			bool Find(const std::string& str, const std::string& find);//文字列検索
-
+			
 			void Screen(std::string line);//ベーシックモジュール->標準出力
 			void Keyboard(std::string line);//ベーシックモジュール->標準入力
 			void EScreen(std::string line);//ベーシックモジュール標準エラー出力

--- /dev/null
+++ b/nullptr/Module.cpp
@@ -0,0 +1,109 @@
+/*
+nullptr interpreter
+(C) 2015 VOSystems.
+*/
+
+#include"nullptr.h"
+#include"Interpreter.h"
+#include"Module.h"
+#include<regex>
+#include<thread>
+#include<future>
+
+using namespace std;
+using namespace VOSystemsNullptr::Core;
+
+inline VOSystemsNullptr::System::ModuleFunction SearchDLL(VOSystemsNullptr::System::Module module, string name);
+
+bool Module::Connect(std::string name)
+{
+	m_mf=DllSearch(name);
+	string dllname=m_mf.dllname;
+
+	if(m_CurrentConnectModuleName==dllname){
+		return true;
+	}else if(!m_CurrentConnectModuleName.empty()){
+		DisConnect();
+	}
+
+	m_module=LoadLibrary((dllname+".dll").c_str());
+	if(m_module==NULL){
+		m_CurrentConnectModuleName="";
+		return false;
+	}else{
+		m_CurrentConnectModuleName=dllname;
+		
+		return true;
+	}
+}
+
+bool Module::Run(std::string name, BasicTypes::Int* paramInt, BasicTypes::String* paramString)
+{
+	if(!Connect(name))return false;
+	
+	switch(m_mf.mode){
+	case System::NotFound:
+	case System::ReturnBool:
+	default:
+		return false;
+		break;
+	case System::ReturnInt:
+		Core::IntFunc ifunc=(Core::IntFunc)GetProcAddress(m_module,"runRI");
+		m_int=(*ifunc)(name,paramInt,paramString);
+		
+		break;
+	case System::ReturnString:
+		Core::StrFunc sfunc=(Core::StrFunc)GetProcAddress(m_module,"runRS");
+		m_str=(*sfunc)(name,paramInt,paramString);
+		break;
+	}
+	return true;
+}
+
+bool Module::DisConnect(void)
+{
+	if(m_module==NULL)return true;
+
+	if(FreeLibrary(m_module)){
+		m_module=NULL;
+		return true;
+	}else{
+		return false;
+	}
+}
+
+VOSystemsNullptr::System::ModuleFunction Module::DllSearch(std::string name)
+{
+	this->m_modules.size();
+	vector<thread> th(this->m_modules.size());
+	vector<future<System::ModuleFunction>> fu(this->m_modules.size());
+
+	for(size_t C=0; C<this->m_modules.size(); C++){
+		System::Module mod=m_modules[C];
+		fu[C]=async([mod,name](string){SearchDLL(mod,name);});//th[C]=thread([mod,name](){SearchDLL(mod,name);});
+	}
+
+	vector<System::ModuleFunction> result(this->m_modules.size());
+	for(size_t C=0; C<this->m_modules.size(); C++){
+		result[C]=fu[C].get();
+		if(!result[C].mode==System::NotFound){
+			return result[C];
+		}
+	}
+
+	VOSystemsNullptr::System::ModuleFunction mf;
+	mf.mode=VOSystemsNullptr::System::NotFound;
+	return mf;
+}
+
+inline VOSystemsNullptr::System::ModuleFunction SearchDLL(VOSystemsNullptr::System::Module module, string name)
+{
+	for(size_t C=0; C<module.size(); C++){
+		if(module[C].name==name){
+			return module[C];
+		}
+	}
+	VOSystemsNullptr::System::ModuleFunction mf;
+	mf.mode=VOSystemsNullptr::System::NotFound;
+	return mf;
+}
\ No newline at end of file

--- a/nullptr/Module.h
+++ b/nullptr/Module.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include<string>
+#include<Windows.h>
 
 #include"nullptr.h"
 #include"Preprocessor.h"
@@ -10,17 +11,32 @@ namespace VOSystemsNullptr
 {
 	namespace Core
 	{
+		typedef BasicTypes::String (*StrFunc)(std::string, BasicTypes::Int*,BasicTypes::String*);
+		typedef BasicTypes::Int (*IntFunc)(std::string, BasicTypes::Int*,BasicTypes::String*);
+
 		class Module
 		{
 		private:
 			std::vector<System::Module> m_modules;
-			System::Module m_CurrentConnectModule;
+			std::string m_CurrentConnectModuleName;
+			HMODULE m_module;
+			System::ModuleFunction m_mf;
+			BasicTypes::Int m_int;
+			BasicTypes::String m_str;
 
+			VOSystemsNullptr::System::ModuleFunction DllSearch(std::string name);
 		public:
-			bool Load(std::string name);
 			bool Connect(std::string name);
-			bool Run(std::string name, BasicTypes::Int* paramInt, BasicTypes::String paramString);
-			bool DisConnect(std::string name);
+			bool Run(std::string name, BasicTypes::Int* paramInt, BasicTypes::String* paramString);
+			bool DisConnect(void);
+			template<typename _Ty> _Ty GetResult(void)
+			{
+				if(typeid(_Ty)==typeid(BasicTypes::Int)){
+					return m_int;
+				}else if(typeid(_Ty)==typeid(BasicTypes::String)){
+					return m_str;
+				}
+			}
 		};
 	}
 }
\ No newline at end of file

--- a/nullptr/ModuleLoader.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
-nullptr interpreter
-(C) 2015 VOSystems.
-*/
-
-#include"nullptr.h"
-#include"Interpreter.h"
-#include"Module.h"
-#include<regex>
-
-using namespace std;
-using namespace VOSystemsNullptr::Core;
-
-bool Module::Load(std::string name)
-{
-	string src=m_src;
-	string work=m_workline;
-	
-	System::Module module;
-	module.name=name;
-	string ident[3]={"Int","String","bool"};
-	m_src=name+".nullptrmodule";
-	do{
-		LineLoad();
-		if(regex_match(m_workline,regex(".+ .+(.+)"))){
-			System::ModuleFunction mf;
-			string::iterator namestart,nameend;
-
-			m_workline=Replace(m_workline," ","");
-
-			if(regex_match(m_workline,regex("bool .+(.+)"))){
-				mf.mode=System::ReturnBool;
-				namestart=m_workline.begin()+5;
-
-			}else if(regex_match(m_workline,regex("Int .+(.+)"))){
-				mf.mode=System::ReturnInt;
-				namestart=m_workline.begin()+4;
-
-			}else if(regex_match(m_workline,regex("String .+(.+)"))){
-				mf.mode=System::ReturnString;
-				namestart=m_workline.begin()+7;
-
-			}
-			nameend=m_workline.begin()+m_workline.find_first_of('(');
-			mf.name=string(namestart,nameend);
-
-			size_t offset=0;
-			unsigned char count[3]={0};
-			for(size_t C=0; C<3; C++){
-				do{
-					offset=m_workline.find(ident[C],offset+1);
-					count[C]++;
-				}while(offset==string::npos);
-			}
-			mf.ArguInt=count[0];
-			mf.ArguString=count[1];
-			mf.ArguBool=count[2];
-			
-			module.modules.push_back(mf);
-		}
-	}while(!m_workline.empty());
-	m_modules.push_back(module);
-
-	m_src=src;
-	m_workline=work;
-}
-
-bool Module::Connect(std::string name)
-{
-	
-}
-
-bool Module::Run(std::string name, BasicTypes::Int* paramInt, BasicTypes::String paramString)
-{
-
-}
-
-bool Module::DisConnect(std::string name)
-{
-
-}

--- /dev/null
+++ b/nullptr/Preprocessor.cpp
@@ -0,0 +1,176 @@
+/*
+
+*/
+
+#include<direct.h>
+#include<fstream>
+
+#include"Preprocessor.h"
+
+using namespace VOSystemsNullptr::Core;
+using namespace std;
+
+Preprocessor::Preprocessor(string source) :fope(source,"\n") {}
+
+void Preprocessor::Extract(void)
+{
+	_mkdir("NullptrTmp");
+	ofstream fout("./NullptrTmp/Extracted.nullptr");
+	string line;
+	do{
+		line=fope();
+
+		if (Find(line, "#include")) {
+			string str(line.begin()+line.find_first_of('\"')+1, line.begin()+line.find_last_of('\"'));
+
+			ifstream ufile(str);
+
+			if(!ufile)goto ErrorNext;
+
+			ufile.seekg(0,ios_base::end);
+			size_t len=ufile.tellg();
+			ufile.seekg(0,ios_base::beg);
+
+			char* ch=new char[len];
+
+			ufile.read(ch,len);
+
+			fout<<ch<<endl;
+
+			delete ch;
+
+		}else if (regex_match(line, regex("#pragma comment(lib,\".+\""))) {
+			string str(line.begin()+line.find_first_of('\"')+1, line.begin()+line.find_last_of('\"'));
+
+			ifstream ufile(str+".nullptrmodule");
+			if(!ufile)goto ErrorNext;
+			ufile.close();
+
+			m_modulefiles.push_back(str+".nullptrmodule");
+		}else{
+			fout<<line<<";"<<endl;
+		}
+	ErrorNext:;
+	}while(!line.empty());
+
+	fope = "./NullptrTmp/Extracted.nullptr";
+}
+
+void Preprocessor::Trim(void)
+{
+	ofstream fout("./NullptrTmp/Prerocessed.nullptr");
+	string line;
+	bool lcomment=false;
+	do{
+		line=fope();
+		
+		if(Find(line,"//")){
+			bool first=false;
+
+			for(size_t C=0; C<line.size(); C++){
+				if(line[C]=='/' && !first){
+					first=true;
+
+				}else if(line[C]=='/'){
+					break;
+
+				}else if(first && line[C]!='/'){
+					fout<<"/"<<line[C];
+					first=false;
+
+				}else{
+					fout<<line[C];
+
+				}
+			}
+		}else if(Find(line,"/*")){
+			bool first=false;
+
+			for(size_t C=0; C<line.size(); C++){
+				if(line[C]=='/' && !first){
+					first=true;
+
+				}else if(line[C]=='*'){
+					break;
+
+				}else if(first && line[C]!='*'){
+					fout<<"/"<<line[C];
+					first=false;
+
+				}else{
+					fout<<line[C];
+
+				}
+			}
+
+			lcomment=true;
+
+		}else if(Find(line,"*/")){
+			for(size_t C=0; C<line.size()-1; C++){
+				if(line[C]=='*' && line[C]=='/'){
+					fout<<string(line.begin()+C,line.end());
+					break;
+				}
+			}
+			lcomment=false;
+
+		}else{
+			if(!lcomment){
+				fout<<line;
+			}
+		}
+	}while(!line.empty());
+}
+
+void Preprocessor::Load(System::Module& module)
+{
+	regex func_regex(R"(.+ .+(Int \d+\s*,\s*String \d+\s*,\s*bool \d+\s*);*)");
+	regex bool_regex(R"(bool .+(Int \d+\s*,\s*String \d+\s*,\s*bool \d+\s*);*)");
+	regex int_regex(R"(Int .+(Int \d+\s*,\s*String \d+\s*,\s*bool \d+\s*);*)");
+	regex str_regex(R"(String .+(Int \d+\s*,\s*String \d+\s*,\s*bool \d+\s*);*)");
+
+	string line;
+	
+	for(size_t C=0; C<m_modulefiles.size(); C++){
+		System::FileOperator fop(m_modulefiles[C],";");
+		do{
+			line=fop();
+			if(regex_match(line,func_regex)){
+				System::ModuleFunction mf;
+				mf.dllname=m_modulefiles[C];
+				string::iterator start;
+				
+				if(regex_match(line,bool_regex)){
+					mf.mode=System::ReturnBool;
+					start=line.begin()+5;
+
+				}else if(regex_match(line,bool_regex)){
+					mf.mode=System::ReturnInt;
+					start=line.begin()+4;
+
+				}else if(regex_match(line,bool_regex)){
+					mf.mode=System::ReturnString;
+					start=line.begin()+7;
+
+				}else{
+					mf.mode=System::NotFound;
+					start=line.begin()+4;
+
+				}
+				char name[32]={0};
+				for(size_t C=0; *start!='(' || C<32; start++ ,C++)name[C]=*start;
+				mf.name=name;
+				
+				size_t whrint=line.find_last_of("Int")+4;
+				size_t whrstr=line.find_last_of("String")+7;
+				size_t whrbool=line.find_last_of("bool")+5;
+
+				mf.ArguBool=stoul(string(line.begin()+whrbool, line.begin()+line.find_last_of(")")));
+				mf.ArguInt=stoul(string(line.begin()+whrint, line.begin()+whrstr-7));
+				mf.ArguString=stoul(string(line.begin()+whrstr, line.begin()+whrbool-4));
+				
+				module.push_back(mf);
+			}
+		}while(!line.empty());
+	}
+}
\ No newline at end of file

--- a/nullptr/Preprocessor.h
+++ b/nullptr/Preprocessor.h
@@ -7,12 +7,17 @@ namespace VOSystemsNullptr
 {
 	namespace Core
 	{
-		class Preprocessor
+		class Preprocessor : System::StringModule
 		{
 		private:
-
+			std::string m_src;
+			System::FileOperator fope;
+			std::vector<std::string> m_modulefiles;
 		public:
-
+			Preprocessor(std::string source);
+			void Extract(void);
+			void Trim(void);
+			void Load(System::Module& module);
 		};
 	}
 }
\ No newline at end of file

--- a/nullptr/nullptr.cpp
+++ b/nullptr/nullptr.cpp
@@ -15,7 +15,7 @@
 using namespace VOSystemsNullptr;
 using namespace std;
 
-vector<string> Nullptr::Split(const string &str, const string &delim)
+vector<string> System::StringModule::Split(const string &str, const string &delim)
 {
 	vector<string> res;
 	size_t current = 0, found, delimlen = delim.size();
@@ -27,7 +27,7 @@ vector<string> Nullptr::Split(const string &str, const string &delim)
 	return res;
 }
 
-std::string Nullptr::Replace(std::string src, std::string before, std::string after)
+std::string System::StringModule::Replace(std::string src, std::string before, std::string after)
 {
 	std::string::size_type  Pos(src.find(before));
 
@@ -39,7 +39,7 @@ std::string Nullptr::Replace(std::string src, std::string before, std::string af
 	return src;
 }
 
-bool Nullptr::Find(const string& str, const string& find)
+bool System::StringModule::Find(const string& str, const string& find)
 {
 	return(str.find(find) != string::npos);
 }
@@ -56,73 +56,7 @@ Nullptr::~Nullptr(void)
 	_rmdir("NullptrTmp");
 }
 
-void Nullptr::Extract(void)
-{
-	_mkdir("NullptrTmp");
-	ofstream fout("./NullptrTmp/Extracted.nullptr");
-
-	do{
-		LineLoad();
-
-		if (Find(m_workline, "using file")) {
-			string str(m_workline.begin()+m_workline.find_first_of('\"')+1, m_workline.begin()+m_workline.find_last_of('\"'));
-			
-			ifstream ufile(str);
-
-			if(!ufile)goto ErrorNext;
-
-			ufile.seekg(0,ios_base::end);
-			size_t len=ufile.tellg();
-			ufile.seekg(0,ios_base::beg);
-
-			char* ch=new char[len];
-
-			ufile.read(ch,len);
-
-			fout<<ch<<endl;
-
-			delete ch;
 
-		}else if (Find(m_workline, "using module")) {
-			string str(m_workline.begin()+m_workline.find_first_of('\"')+1, m_workline.begin()+m_workline.find_last_of('\"'));
-
-			ifstream ufile(str+".nullptrmodule");
-
-			if(!ufile)goto ErrorNext;
-			
-			string id;
-			do{
-				ufile>>id;
-				id=Replace(id,"\n","");
-				id=Replace(id,"\r","");
-				id=Replace(id,"\t","");
-				id=Replace(id," ","");
-				id=Replace(id,";","");
-				vector<string> ids=Split(id,"->");
-				if(id.size()>1){
-					if(ids[0]=="stdin"){
-						m_stdin=ids[1];
-					}else if(ids[0]=="stdout"){
-						m_stdout=ids[1];
-					}else if(ids[0]=="stderr"){
-						m_stderr=ids[1];
-					}
-				}
-			}while(!ufile.eof());
-
-		}else{
-			fout<<m_workline<<";"<<endl;
-		}
-ErrorNext:;
-	}while(!m_workline.empty());
-
-	m_src = "./NullptrTmp/Extracted.nullptr";
-}
-
-void Nullptr::Trim(void)
-{
-
-}
 
 void Nullptr::Work(void)
 {

--- a/nullptr/nullptr.h
+++ b/nullptr/nullptr.h
@@ -10,12 +10,18 @@
 #include<regex>
 #include<fstream>
 
+#include"Interpreter.h"
+#include"Module.h"
+#include"Preprocessor.h"
+
 namespace VOSystemsNullptr
 {
 	class Nullptr
 	{
 	private:
-
+		Core::Interpreter m_int;
+		Core::Module m_module;
+		Core::Preprocessor m_pre;
 	public:
 
 	};
@@ -91,25 +97,34 @@ namespace VOSystemsNullptr
 		};
 
 		struct ModuleFunction{
-			std::string name;
+			std::string name,dllname;
 			unsigned char mode;
 			unsigned char ArguInt,ArguBool,ArguString;
 		};
 
-		typedef struct _Module{
-			std::string name;
-			std::vector<struct ModuleFunction> modules;
-		}Module;
+		typedef std::vector<struct ModuleFunction> Module;
 
-		class FileComponent
+		class FileOperator
 		{
 		private:
-			size_t m_p_loaded;
-		protected:
+			size_t m_eip;
 			std::string m_src;
+			std::string m_separator;
+
 		public:
-			virtual std::string Load(void);
+			FileOperator(std::string source, std::string separator) :m_src(source), m_separator(separator), m_eip(0) {};
 
+			std::string operator()(void);
+			std::string operator()(size_t startpoint);
+			std::string operator=(std::string source);
+		};
+
+		class StringModule
+		{
+		public:
+			std::vector<std::string> Split(const std::string &str, const std::string &delim);//文字列分割
+			std::string Replace(std::string src, std::string before, std::string after);//文字列置き換え
+			bool Find(const std::string& str, const std::string& find);//文字列検索
 		};
 	}
 #define loop(count)	for(size_t LoopCounter=0; LoopCounter<count; LoopCounter++)

--- a/nullptr/nullptr.vcxproj
+++ b/nullptr/nullptr.vcxproj
@@ -128,9 +128,10 @@
     <ClCompile Include="ControlManager.cpp" />
     <ClCompile Include="int.cpp" />
     <ClCompile Include="ManageVar.cpp" />
-    <ClCompile Include="ModuleLoader.cpp" />
+    <ClCompile Include="Module.cpp" />
     <ClCompile Include="nullptr.cpp" />
     <ClCompile Include="open.cpp" />
+    <ClCompile Include="Preprocessor.cpp" />
   </ItemGroup>
   <ItemGroup>
     <None Include="iostream.nullptrmodule" />

--- a/nullptr/nullptr.vcxproj.filters
+++ b/nullptr/nullptr.vcxproj.filters
@@ -47,7 +47,10 @@
     <ClCompile Include="ControlManager.cpp">
       <Filter>ソース ファイル</Filter>
     </ClCompile>
-    <ClCompile Include="ModuleLoader.cpp">
+    <ClCompile Include="Preprocessor.cpp">
+      <Filter>ソース ファイル</Filter>
+    </ClCompile>
+    <ClCompile Include="Module.cpp">
       <Filter>ソース ファイル</Filter>
     </ClCompile>
   </ItemGroup>