HeeroYui-deprecated/eci
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

[DEV] update to the new licence MPL2 and new ETK and ...

Browse Source
This commit is contained in:
Edouard DUPIN 2017-10-25 22:19:39 +02:00
parent db109fe7a5
commit d36572e9c3
36 changed files with 471 additions and 554 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
README
View File

@ -1,11 +1,11 @@
ECI : Ewol C Interpreter
-----
Eci is a fork of PicoC...
ECI is a stipid interpreter of C language or C++, a good question ==> need rename the lib ...
Copyright
---------
BSD 3 clauses
MPL-2

8
eci/Class.cpp
View File

@ -1,11 +1,9 @@
/**
* @author Edouard DUPIN
*
* @copyright 2014, Edouard DUPIN, all right reserved
*
* @license APACHE-2 (see license file)
* @license MPL-2 (see license file)
*/
#include <eci/Class.h>
#include <eci/debug.h>
#include <eci/Class.hpp>
#include <eci/debug.hpp>

11
eci/Class.h → eci/Class.hpp
View File

@ -1,15 +1,12 @@
/**
* @author Edouard DUPIN
*
* @copyright 2014, Edouard DUPIN, all right reserved
*
* @license APACHE-2 (see license file)
* @license MPL-2 (see license file)
*/
#ifndef __ECI_CLASS_H__
#define __ECI_CLASS_H__
#pragma once
#include <etk/types.h>
#include <etk/types.hpp>
namespace eci {
class Class {
@ -18,5 +15,3 @@ namespace eci {
~Class() {};
};
}
#endif

26
eci/Enum.cpp
View File

@ -1,17 +1,15 @@
/**
* @author Edouard DUPIN
*
* @copyright 2014, Edouard DUPIN, all right reserved
*
* @license APACHE-2 (see license file)
* @license MPL-2 (see license file)
*/
#include <eci/Enum.h>
#include <eci/debug.h>
#include <eci/Enum.hpp>
#include <eci/debug.hpp>
void eci::Enum::addValue(const std::string& _name) {
void eci::Enum::addValue(const etk::String& _name) {
if (m_values.size() == 0) {
m_values.push_back(std::make_pair(_name, 0));
m_values.pushBack(etk::makePair(_name, 0));
return;
}
int32_t lastValue = 0;
@ -22,12 +20,12 @@ void eci::Enum::addValue(const std::string& _name) {
}
lastValue = m_values[iii].second;
}
m_values.push_back(std::make_pair(_name, lastValue+1));
m_values.pushBack(etk::makePair(_name, lastValue+1));
}
void eci::Enum::addValue(const std::string& _name, int32_t _value) {
void eci::Enum::addValue(const etk::String& _name, int32_t _value) {
if (m_values.size() == 0) {
m_values.push_back(std::make_pair(_name, _value));
m_values.pushBack(etk::makePair(_name, _value));
return;
}
for (size_t iii=0; iii<m_values.size(); ++iii) {
@ -36,10 +34,10 @@ void eci::Enum::addValue(const std::string& _name, int32_t _value) {
return;
}
}
m_values.push_back(std::make_pair(_name, _value));
m_values.pushBack(etk::makePair(_name, _value));
}
int32_t eci::Enum::getValue(const std::string& _name) const {
int32_t eci::Enum::getValue(const etk::String& _name) const {
for (size_t iii=0; iii<m_values.size(); ++iii) {
if (m_values[iii].first == _name) {
return m_values[iii].second;
@ -49,14 +47,14 @@ int32_t eci::Enum::getValue(const std::string& _name) const {
return 0;
}
const std::string& eci::Enum::getName(int32_t _value) const {
const etk::String& eci::Enum::getName(int32_t _value) const {
for (size_t iii=0; iii<m_values.size(); ++iii) {
if (m_values[iii].second == _value) {
return m_values[iii].first;
}
}
ECI_ERROR("Enum name does not exist ... : '" << _value << "'");
static const std::string errorValue = "---UnknowName---";
static const etk::String errorValue = "---UnknowName---";
return errorValue;
}

29
eci/Enum.h
View File

@ -1,29 +0,0 @@
/**
* @author Edouard DUPIN
*
* @copyright 2014, Edouard DUPIN, all right reserved
*
* @license APACHE-2 (see license file)
*/
#ifndef __ECI_ENUM_H__
#define __ECI_ENUM_H__
#include <etk/types.h>
namespace eci {
class Enum {
public:
Enum() {};
~Enum() {};
protected:
std::vector<std::pair<std::string, int32_t>> m_values;
public:
void addValue(const std::string& _name);
void addValue(const std::string& _name, int32_t _value);
int32_t getValue(const std::string& _name) const;
const std::string& getName(int32_t _value) const;
};
}
#endif

26
eci/Enum.hpp Normal file
View File

@ -0,0 +1,26 @@
/**
* @author Edouard DUPIN
* @copyright 2014, Edouard DUPIN, all right reserved
* @license MPL-2 (see license file)
*/
#pragma once
#include <etk/types.hpp>
#include <etk/Pair.hpp>
#include <etk/Vector.hpp>
namespace eci {
class Enum {
public:
Enum() {};
~Enum() {};
protected:
etk::Vector<etk::Pair<etk::String, int32_t>> m_values;
public:
void addValue(const etk::String& _name);
void addValue(const etk::String& _name, int32_t _value);
int32_t getValue(const etk::String& _name) const;
const etk::String& getName(int32_t _value) const;
};
}

38
eci/File.cpp
View File

@ -1,23 +1,21 @@
/**
* @author Edouard DUPIN
*
* @copyright 2014, Edouard DUPIN, all right reserved
*
* @license APACHE-2 (see license file)
* @license MPL-2 (see license file)
*/
#include <eci/File.h>
#include <eci/debug.h>
#include <etk/os/FSNode.h>
#include <eci/lang/ParserCpp.h>
#include <eci/lang/ParserJS.h>
#include <eci/File.hpp>
#include <eci/debug.hpp>
#include <etk/os/FSNode.hpp>
#include <eci/lang/ParserCpp.hpp>
#include <eci/lang/ParserJS.hpp>
static std::string getValue(const std::string& _file, const std::shared_ptr<eci::LexerNode>& _it) {
return std::string(_file, _it->getStartPos(), _it->getStopPos()-_it->getStartPos());
static etk::String getValue(const etk::String& _file, const ememory::SharedPtr<eci::LexerNode>& _it) {
return etk::String(_file, _it->getStartPos(), _it->getStopPos()-_it->getStartPos());
}
eci::Variable getVariableWithType(const std::string& _value) {
eci::Variable getVariableWithType(const etk::String& _value) {
eci::Variable ret;
if (_value == "void") {
@ -59,7 +57,7 @@ eci::Variable getVariableWithType(const std::string& _value) {
return ret;
}
eci::File::File(const std::string& _filename) {
eci::File::File(const etk::String& _filename) {
m_fileName = _filename;
m_fileData = etk::FSNodeReadAllData(m_fileName);
if ( etk::end_with(m_fileName, "cpp", false) == true
@ -72,13 +70,13 @@ eci::File::File(const std::string& _filename) {
tmpParser.parse(m_fileData);
// all we need all the time:
std::vector<eci::Variable> returnList;
std::vector<eci::Variable> argumentList;
std::string name;
std::string value;
std::shared_ptr<eci::Class> lastClass;
std::shared_ptr<eci::Function> lastFunction;
std::shared_ptr<eci::Variable> lastVariable;
etk::Vector<eci::Variable> returnList;
etk::Vector<eci::Variable> argumentList;
etk::String name;
etk::String value;
ememory::SharedPtr<eci::Class> lastClass;
ememory::SharedPtr<eci::Function> lastFunction;
ememory::SharedPtr<eci::Variable> lastVariable;
enum eci::visibility lastVisibility = eci::visibilityPublic;
for (auto &it : tmpParser.m_result.m_list) {
@ -115,7 +113,7 @@ eci::File::File(const std::string& _filename) {
case tokenCppType:
ECI_INFO("get type : " << value << "'" );
if (name == "") {
returnList.push_back(getVariableWithType(value));
returnList.pushBack(getVariableWithType(value));
} else {
ECI_ERROR(" get type : " << value << "' after name !!!" );
}

32
eci/File.h
View File

@ -1,32 +0,0 @@
/**
* @author Edouard DUPIN
*
* @copyright 2014, Edouard DUPIN, all right reserved
*
* @license APACHE-2 (see license file)
*/
#ifndef __ECI_FILE_H__
#define __ECI_FILE_H__
#include <etk/types.h>
#include <eci/Class.h>
#include <eci/Enum.h>
#include <eci/Variable.h>
#include <eci/Function.h>
namespace eci {
class File {
public:
File(const std::string& _filename);
~File() {};
protected:
std::string m_fileName; //!< Name of the file.
std::string m_fileData; //!< Data of the file.
std::vector<std::shared_ptr<eci::Function>> m_listFunction; // all function in the file
std::vector<std::shared_ptr<eci::Class>> m_listClass; // all class in the file
std::vector<std::shared_ptr<eci::Variable>> m_listVariable; // all variable in the file
};
}
#endif

28
eci/File.hpp Normal file
View File

@ -0,0 +1,28 @@
/**
* @author Edouard DUPIN
* @copyright 2014, Edouard DUPIN, all right reserved
* @license MPL-2 (see license file)
*/
#pragma once
#include <etk/types.hpp>
#include <eci/Class.hpp>
#include <eci/Enum.hpp>
#include <eci/Variable.hpp>
#include <eci/Function.hpp>
namespace eci {
class File {
public:
File(const etk::String& _filename);
~File() {};
protected:
etk::String m_fileName; //!< Name of the file.
etk::String m_fileData; //!< Data of the file.
etk::Vector<ememory::SharedPtr<eci::Function>> m_listFunction; // all function in the file
etk::Vector<ememory::SharedPtr<eci::Class>> m_listClass; // all class in the file
etk::Vector<ememory::SharedPtr<eci::Variable>> m_listVariable; // all variable in the file
};
}

12
eci/Function.cpp
View File

@ -1,13 +1,11 @@
/**
* @author Edouard DUPIN
*
* @copyright 2014, Edouard DUPIN, all right reserved
*
* @license APACHE-2 (see license file)
* @license MPL-2 (see license file)
*/
#include <eci/Function.h>
#include <eci/debug.h>
#include <eci/Function.hpp>
#include <eci/debug.hpp>
eci::Function::Function() :
@ -21,8 +19,8 @@ eci::Function::~Function() {
}
std::vector<std::shared_ptr<eci::Value>> eci::Function::call(const std::vector<std::shared_ptr<eci::Value>>& _input) {
return std::vector<std::shared_ptr<eci::Value>>();
etk::Vector<ememory::SharedPtr<eci::Value>> eci::Function::call(const etk::Vector<ememory::SharedPtr<eci::Value>>& _input) {
return etk::Vector<ememory::SharedPtr<eci::Value>>();
}

26
eci/Function.h → eci/Function.hpp
View File

@ -1,19 +1,16 @@
/**
* @author Edouard DUPIN
*
* @copyright 2014, Edouard DUPIN, all right reserved
*
* @license APACHE-2 (see license file)
* @license MPL-2 (see license file)
*/
#ifndef __ECI_FUNCTION_H__
#define __ECI_FUNCTION_H__
#pragma once
#include <etk/types.h>
#include <eci/visibility.h>
#include <eci/Variable.h>
#include <eci/Value.h>
#include <memory>
#include <etk/types.hpp>
#include <eci/visibility.hpp>
#include <eci/Variable.hpp>
#include <eci/Value.hpp>
#include <ememory/memory.hpp>
namespace eci {
class Function {
@ -21,14 +18,14 @@ namespace eci {
Function();
~Function();
protected:
std::string m_name; //!< Function Name.
etk::String m_name; //!< Function Name.
bool m_const; //!< The function is const.
bool m_static; //!< function is static.
enum eci::visibility m_visibility; //!< Visibility of the function
std::vector<eci::Variable> m_return; //!< return value.
std::vector<eci::Variable> m_arguments; //!< return value.
etk::Vector<eci::Variable> m_return; //!< return value.
etk::Vector<eci::Variable> m_arguments; //!< return value.
std::vector<std::shared_ptr<eci::Value>> call(const std::vector<std::shared_ptr<eci::Value>>& _input);
etk::Vector<ememory::SharedPtr<eci::Value>> call(const etk::Vector<ememory::SharedPtr<eci::Value>>& _input);
// 3 step:
// - first get Tockens (returns , names, const, parameters, codes
@ -37,4 +34,3 @@ namespace eci {
};
}
#endif

12
eci/Interpreter.cpp
View File

@ -1,13 +1,11 @@
/**
* @author Edouard DUPIN
*
* @copyright 2014, Edouard DUPIN, all right reserved
*
* @license APACHE-2 (see license file)
* @license MPL-2 (see license file)
*/
#include <eci/Interpreter.h>
#include <eci/debug.h>
#include <eci/Interpreter.hpp>
#include <eci/debug.hpp>
eci::Interpreter::Interpreter() {
@ -17,9 +15,9 @@ eci::Interpreter::~Interpreter() {
}
void eci::Interpreter::addFile(const std::string& _filename) {
void eci::Interpreter::addFile(const etk::String& _filename) {
// TODO : Check if file is not previously loaded ...
m_files.push_back(eci::File(_filename));
m_files.pushBack(eci::File(_filename));
}
void eci::Interpreter::main() {

45
eci/Interpreter.h → eci/Interpreter.hpp
View File

@ -1,17 +1,14 @@
/**
* @author Edouard DUPIN
*
* @copyright 2014, Edouard DUPIN, all right reserved
*
* @license APACHE-2 (see license file)
* @license MPL-2 (see license file)
*/
#ifndef __ECI_INTERPRETER_H__
#define __ECI_INTERPRETER_H__
#pragma once
#include <etk/types.h>
#include <eci/Library.h>
#include <eci/File.h>
#include <etk/types.hpp>
#include <eci/Library.hpp>
#include <eci/File.hpp>
namespace eci {
namespace interpreter {
@ -29,7 +26,7 @@ namespace eci {
typeOperator, //!< Call operator "xx" ex : "*" "++" "=" "=="
typeReserveId = 5000,
};
class Element : public std::enable_shared_from_this<Element> {
class Element : public ememory::EnableSharedFromThis<Element> {
protected:
int32_t m_tockenId;
public:
@ -45,7 +42,7 @@ namespace eci {
};
class Block : public Element {
protected:
std::vector<std::shared_ptr<Element>> m_actions;
etk::Vector<ememory::SharedPtr<Element>> m_actions;
public:
Block() :
Element(interpreter::typeBlock) {
@ -115,9 +112,9 @@ namespace eci {
};
class Condition : public Element {
protected:
std::shared_ptr<Element> m_condition;
std::shared_ptr<Block> m_block;
std::shared_ptr<Block> m_blockElse;
ememory::SharedPtr<Element> m_condition;
ememory::SharedPtr<Block> m_block;
ememory::SharedPtr<Block> m_blockElse;
public:
Condition() :
Element(interpreter::typeCondition) {
@ -128,10 +125,10 @@ namespace eci {
};
class For : public Element {
protected:
std::shared_ptr<Element> m_init;
std::shared_ptr<Element> m_condition;
std::shared_ptr<Element> m_increment;
std::shared_ptr<Block> m_block;
ememory::SharedPtr<Element> m_init;
ememory::SharedPtr<Element> m_condition;
ememory::SharedPtr<Element> m_increment;
ememory::SharedPtr<Block> m_block;
public:
For() :
Element(interpreter::typeFor) {
@ -143,8 +140,8 @@ namespace eci {
class While : public Element {
protected:
bool m_conditionAtStart;
std::shared_ptr<Element> m_condition;
std::shared_ptr<Element> m_action;
ememory::SharedPtr<Element> m_condition;
ememory::SharedPtr<Element> m_action;
public:
While() :
Element(interpreter::typeWhile) {
@ -154,7 +151,7 @@ namespace eci {
};
class Operator : public Element {
protected:
std::string m_operator;
etk::String m_operator;
public:
Operator() :
Element(interpreter::typeOperator) {
@ -169,12 +166,10 @@ namespace eci {
Interpreter();
~Interpreter();
protected:
std::vector<eci::Library> m_libraries; //!< list of all loaded libraries.
std::vector<eci::File> m_files; //!< List of all files in the current program.
etk::Vector<eci::Library> m_libraries; //!< list of all loaded libraries.
etk::Vector<eci::File> m_files; //!< List of all files in the current program.
public:
void addFile(const std::string& _filename);
void addFile(const etk::String& _filename);
void main();
};
}
#endif

119
eci/Lexer.cpp
View File

@ -1,14 +1,12 @@
/**
* @author Edouard DUPIN
*
* @copyright 2014, Edouard DUPIN, all right reserved
*
* @license APACHE-2 (see license file)
* @license MPL-2 (see license file)
*/
#include <memory>
#include <eci/Lexer.h>
#include <eci/debug.h>
#include <eci/Lexer.hpp>
#include <eci/debug.hpp>
eci::Lexer::Lexer() {
@ -18,44 +16,44 @@ eci::Lexer::~Lexer() {
}
void eci::Lexer::append(int32_t _tokenId, const std::string& _regularExpression) {
void eci::Lexer::append(int32_t _tokenId, const etk::String& _regularExpression) {
ECI_INFO("CPP lexer add : [" << _tokenId << "] '" << _regularExpression << "'");
try {
m_searchList.push_back(std::make_shared<eci::Lexer::TypeBase>(_tokenId, _regularExpression));
} catch (std::exception e){
m_searchList.pushBack(ememory::makeShared<eci::Lexer::TypeBase>(_tokenId, _regularExpression));
} catch (etk::Exception e){
ECI_ERROR(" create reg exp : '" << _regularExpression << "' : what:" << e.what());
}
}
void eci::Lexer::appendSection(int32_t _tokenId, int32_t _tockenStart, int32_t _tockenStop, const std::string& _type) {
void eci::Lexer::appendSection(int32_t _tokenId, int32_t _tockenStart, int32_t _tockenStop, const etk::String& _type) {
ECI_INFO("CPP lexer add section [" << _tokenId << "] : '" << _tockenStart << "' .. '" << _tockenStop << "'");
try {
m_searchList.push_back(std::make_shared<eci::Lexer::TypeSection>(_tokenId, _tockenStart, _tockenStop, _type));
} catch (std::exception e){
m_searchList.pushBack(ememory::makeShared<eci::Lexer::TypeSection>(_tokenId, _tockenStart, _tockenStop, _type));
} catch (etk::Exception e){
ECI_ERROR(" create reg exp : '" << _tockenStart << "' .. '" << _tockenStop << "' : what:" << e.what());
}
}
void eci::Lexer::appendSub(int32_t _tokenIdParrent, int32_t _tokenId, const std::string& _regularExpression) {
void eci::Lexer::appendSub(int32_t _tokenIdParrent, int32_t _tokenId, const etk::String& _regularExpression) {
ECI_INFO("CPP lexer add sub : [" << _tokenId << "] [" << _tokenIdParrent << "] '" << _regularExpression << "'");
try {
m_searchList.push_back(std::make_shared<eci::Lexer::TypeSubBase>(_tokenId, _tokenIdParrent, _regularExpression));
} catch (std::exception e){
m_searchList.pushBack(ememory::makeShared<eci::Lexer::TypeSubBase>(_tokenId, _tokenIdParrent, _regularExpression));
} catch (etk::Exception e){
ECI_ERROR(" create reg exp : '" << _regularExpression << "' : what:" << e.what());
}
}
void eci::Lexer::appendSubSection(int32_t _tokenIdParrent, int32_t _tokenId, int32_t _tockenStart, int32_t _tockenStop, const std::string& _type) {
void eci::Lexer::appendSubSection(int32_t _tokenIdParrent, int32_t _tokenId, int32_t _tockenStart, int32_t _tockenStop, const etk::String& _type) {
ECI_INFO("CPP lexer add section sub : [" << _tokenId << "] [" << _tokenIdParrent << "] '" << _tockenStart << "' .. '" << _tockenStop << "'");
try {
m_searchList.push_back(std::make_shared<eci::Lexer::TypeSubSection>(_tokenId, _tokenIdParrent, _tockenStart, _tockenStop, _type));
} catch (std::exception e){
m_searchList.pushBack(ememory::makeShared<eci::Lexer::TypeSubSection>(_tokenId, _tokenIdParrent, _tockenStart, _tockenStop, _type));
} catch (etk::Exception e){
ECI_ERROR(" create reg exp : '" << _tockenStart << "' .. '" << _tockenStop << "' : what:" << e.what());
}
}
eci::LexerResult eci::Lexer::interprete(const std::string& _data) {
eci::LexerResult eci::Lexer::interprete(const etk::String& _data) {
eci::LexerResult result(_data);
ECI_INFO("Parse : \n" << _data);
for (auto &it : m_searchList) {
@ -84,21 +82,27 @@ eci::LexerResult eci::Lexer::interprete(const std::string& _data) {
++itList;
continue;
}
std::vector<std::shared_ptr<eci::LexerNode>> res = it->parse(_data, start, (*itList)->getStartPos());
etk::Vector<ememory::SharedPtr<eci::LexerNode>> res = it->parse(_data, start, (*itList)->getStartPos());
// append it in the buffer:
if (res.size() > 0) {
int32_t currentPos = std::distance(result.m_list.begin(), itList) + res.size() ;
int32_t currentPos = etk::distance(result.m_list.begin(), itList) + res.size();
for (auto &it: res) {
result.m_list.insert(itList, it);
++itList;
}
/*
result.m_list.insert(itList, res.begin(), res.end());
itList = result.m_list.begin() + currentPos;
*/
}
start = (*itList)->getStopPos();
++itList;
}
// Do the last element :
if (start < _data.size()) {
std::vector<std::shared_ptr<eci::LexerNode>> res = it->parse(_data, start, _data.size());
etk::Vector<ememory::SharedPtr<eci::LexerNode>> res = it->parse(_data, start, _data.size());
for (auto &itRes : res) {
result.m_list.push_back(itRes);
result.m_list.pushBack(itRes);
}
}
}
@ -111,52 +115,59 @@ eci::LexerResult eci::Lexer::interprete(const std::string& _data) {
}
return result;
}
static std::regex_constants::match_flag_type createFlags(const std::string& _data, int32_t _start, int32_t _stop) {
std::regex_constants::match_flag_type flags = std::regex_constants::match_any;
/*
static etk::RegEx_constants::match_flag_type createFlags(const etk::String& _data, int32_t _start, int32_t _stop) {
etk::RegEx_constants::match_flag_type flags = etk::RegEx_constants::match_any;
//ECI_DEBUG("find data at : start=" << _start << " stop=" << _stop << " regex='" << m_regexValue << "'");
if ((int64_t)_stop <= (int64_t)_data.size()) {
char val = _data[_stop];
if ( val != '\n'
&& val != '\r') {
//after last char ==> not end of line ($ would not work))
flags |= std::regex_constants::match_not_eol;
flags |= etk::RegEx_constants::match_not_eol;
}
if (!( ('a' <= val && val <= 'z')
|| ('A' <= val && val <= 'Z')
|| ('0' <= val && val <= '9')
|| val == '_')) {
flags |= std::regex_constants::match_not_eow;
flags |= etk::RegEx_constants::match_not_eow;
}
}
if (_start>0) {
flags |= std::regex_constants::match_prev_avail;
flags |= etk::RegEx_constants::match_prev_avail;
}
return flags;
}
std::vector<std::shared_ptr<eci::LexerNode>> eci::Lexer::TypeBase::parse(const std::string& _data, int32_t _start, int32_t _stop) {
std::vector<std::shared_ptr<eci::LexerNode>> result;
*/
etk::Vector<ememory::SharedPtr<eci::LexerNode>> eci::Lexer::TypeBase::parse(const etk::String& _data, int32_t _start, int32_t _stop) {
etk::Vector<ememory::SharedPtr<eci::LexerNode>> result;
ECI_VERBOSE("parse : " << getValue());
while (true) {
std::smatch resultMatch;
std::regex_constants::match_flag_type flags = createFlags(_data, _start, _stop);
std::regex_search(_data.begin()+_start, _data.begin()+_stop, resultMatch, regex, flags);
if (resultMatch.size() > 0) {
int32_t start = std::distance(_data.begin(), resultMatch[0].first);
int32_t stop = std::distance(_data.begin(), resultMatch[0].second);
ECI_VERBOSE(" find data at : start=" << start << " stop=" << stop << " data='" <<std::string(_data, start, stop-start) << "'" );
_start = stop;
result.push_back(std::make_shared<eci::LexerNode>(m_tockenId, start, stop));
if (m_regex.parse(_data, _start, _stop) == true) {
result.pushBack(ememory::makeShared<eci::LexerNode>(m_tockenId, m_regex.start(), m_regex.stop()));
} else {
break;
}
/*
std::smatch resultMatch;
etk::RegEx_constants::match_flag_type flags = createFlags(_data, _start, _stop);
etk::RegEx_search(_data.begin()+_start, _data.begin()+_stop, resultMatch, regex, flags);
if (resultMatch.size() > 0) {
int32_t start = etk::distance(_data.begin(), resultMatch[0].first);
int32_t stop = etk::distance(_data.begin(), resultMatch[0].second);
ECI_VERBOSE(" find data at : start=" << start << " stop=" << stop << " data='" <<etk::String(_data, start, stop-start) << "'" );
_start = stop;
result.pushBack(ememory::makeShared<eci::LexerNode>(m_tockenId, start, stop));
} else {
break;
}
*/
}
return result;
}
void eci::Lexer::TypeSection::parseSectionCurrent(std::vector<std::shared_ptr<eci::LexerNode>>& _data) {
std::vector<size_t> posList;
void eci::Lexer::TypeSection::parseSectionCurrent(etk::Vector<ememory::SharedPtr<eci::LexerNode>>& _data) {
etk::Vector<size_t> posList;
for (size_t iii=0; iii<_data.size(); ++iii) {
if (_data[iii] == nullptr) {
ECI_TODO("remove null shared_ptr");
@ -164,7 +175,7 @@ void eci::Lexer::TypeSection::parseSectionCurrent(std::vector<std::shared_ptr<ec
}
if (_data[iii]->getTockenId() == tockenStart) {
ECI_VERBOSE("Detect start TOCKEN " << iii);
posList.push_back(iii);
posList.pushBack(iii);
}
if (_data[iii]->getTockenId() == tockenStop) {
if (posList.size() == 0) {
@ -173,44 +184,44 @@ void eci::Lexer::TypeSection::parseSectionCurrent(std::vector<std::shared_ptr<ec
}
size_t startId = posList.back();
ECI_VERBOSE("Detect stop TOCKEN " << startId << " => " << iii << " list size=" << posList.size());
posList.pop_back();
posList.popBack();
// agragate the subtoken :
int32_t startPos = _data[startId]->getStartPos();
int32_t stopPos = _data[iii]->getStopPos();
std::shared_ptr<eci::LexerNodeContainer> newContainer = std::make_shared<eci::LexerNodeContainer>(m_tockenId, startPos, stopPos, type);
ememory::SharedPtr<eci::LexerNodeContainer> newContainer = ememory::makeShared<eci::LexerNodeContainer>(m_tockenId, startPos, stopPos, type);
ECI_VERBOSE(" Agregate: " << startId << " -> " << iii);
newContainer->m_list.insert(newContainer->m_list.begin(), _data.begin()+startId+1, _data.begin()+iii);
newContainer->m_list.insert(0, &_data[startId+1], iii-(startId+1));
ECI_VERBOSE(" list size=" << newContainer->m_list.size() << " old=" << _data.size());
_data.erase(_data.begin()+startId, _data.begin()+iii+1);
_data.erase(startId, iii+1);
ECI_VERBOSE(" list size=" << newContainer->m_list.size() << " old=" << _data.size());
_data.insert(_data.begin()+startId, newContainer);
_data.insert(startId, newContainer);
ECI_VERBOSE(" list size=" << newContainer->m_list.size() << " old=" << _data.size());
iii = startId-1;
}
}
}
void eci::Lexer::TypeSection::parseSection(std::vector<std::shared_ptr<eci::LexerNode>>& _data) {
void eci::Lexer::TypeSection::parseSection(etk::Vector<ememory::SharedPtr<eci::LexerNode>>& _data) {
ECI_VERBOSE("parse section : " << getValue());
for (auto &it : _data) {
if (it == nullptr) {
continue;
}
if (it->isNodeContainer() == true) {
std::shared_ptr<eci::LexerNodeContainer> sec = std::dynamic_pointer_cast<eci::LexerNodeContainer>(it);
ememory::SharedPtr<eci::LexerNodeContainer> sec = ememory::dynamicPointerCast<eci::LexerNodeContainer>(it);
parseSection(sec->m_list);
}
}
parseSectionCurrent(_data);
}
std::vector<std::shared_ptr<eci::LexerNode>> eci::Lexer::TypeSubBase::parse(const std::string& _data, int32_t _start, int32_t _stop) {
std::vector<std::shared_ptr<eci::LexerNode>> result;
etk::Vector<ememory::SharedPtr<eci::LexerNode>> eci::Lexer::TypeSubBase::parse(const etk::String& _data, int32_t _start, int32_t _stop) {
etk::Vector<ememory::SharedPtr<eci::LexerNode>> result;
ECI_TODO("later 2");
return result;
}
std::vector<std::shared_ptr<eci::LexerNode>> eci::Lexer::TypeSubSection::parse(const std::string& _data, int32_t _start, int32_t _stop) {
std::vector<std::shared_ptr<eci::LexerNode>> result;
etk::Vector<ememory::SharedPtr<eci::LexerNode>> eci::Lexer::TypeSubSection::parse(const etk::String& _data, int32_t _start, int32_t _stop) {
etk::Vector<ememory::SharedPtr<eci::LexerNode>> result;
ECI_TODO("later 3");
return result;
}

91
eci/Lexer.h → eci/Lexer.hpp
View File

@ -1,20 +1,17 @@
/**
* @author Edouard DUPIN
*
* @copyright 2014, Edouard DUPIN, all right reserved
*
* @license APACHE-2 (see license file)
* @license MPL-2 (see license file)
*/
#ifndef __ECI_LEXER_H__
#define __ECI_LEXER_H__
#pragma once
#include <etk/types.h>
#include <etk/stdTools.h>
#include <regex>
#include <map>
#include <vector>
#include <eci/Interpreter.h>
#include <etk/types.hpp>
#include <etk/stdTools.hpp>
#include <etk/RegEx.hpp>
#include <etk/Map.hpp>
#include <etk/Vector.hpp>
#include <eci/Interpreter.hpp>
namespace eci {
@ -28,44 +25,44 @@ namespace eci {
}
virtual ~LexerNode() {};
int32_t m_startPos;
int32_t getStartPos() {
int32_t getStartPos() const {
return m_startPos;
}
int32_t m_stopPos;
int32_t getStopPos() {
int32_t getStopPos() const {
return m_stopPos;
}
virtual bool isNodeContainer() {
virtual bool isNodeContainer() const {
return false;
}
};
class LexerNodeContainer : public LexerNode {
private:
std::string m_type;
etk::String m_type;
public:
LexerNodeContainer(int32_t _tockenId=-1, int32_t _startPos=-1, int32_t _stopPos=-1, const std::string& _type="") :
LexerNodeContainer(int32_t _tockenId=-1, int32_t _startPos=-1, int32_t _stopPos=-1, const etk::String& _type="") :
LexerNode(_tockenId, _startPos, _stopPos) {
m_type = _type;
}
virtual ~LexerNodeContainer() {};
std::vector<std::shared_ptr<eci::LexerNode>> m_list;
virtual bool isNodeContainer() {
etk::Vector<ememory::SharedPtr<eci::LexerNode>> m_list;
virtual bool isNodeContainer() const {
return true;
}
const std::string& getType() const {
const etk::String& getType() const {
return m_type;
}
};
class LexerResult {
private:
std::string m_data;
etk::String m_data;
public:
LexerResult(const std::string& _data="") :
LexerResult(const etk::String& _data="") :
m_data(_data) {
}
~LexerResult() {};
std::vector<std::shared_ptr<eci::LexerNode>> m_list;
etk::Vector<ememory::SharedPtr<eci::LexerNode>> m_list;
};
class Lexer {
@ -78,7 +75,7 @@ namespace eci {
class Type {
protected:
int32_t m_tockenId;
std::string m_regexValue;
etk::String m_regexValue;
public:
Type(int32_t _tockenId) :
m_tockenId(_tockenId) {}
@ -89,14 +86,14 @@ namespace eci {
int32_t getTockenId() {
return m_tockenId;
}
virtual std::vector<std::shared_ptr<eci::LexerNode>> parse(const std::string& _data, int32_t _start, int32_t _stop) {
return std::vector<std::shared_ptr<eci::LexerNode>>();
virtual etk::Vector<ememory::SharedPtr<eci::LexerNode>> parse(const etk::String& _data, int32_t _start, int32_t _stop) {
return etk::Vector<ememory::SharedPtr<eci::LexerNode>>();
};
virtual void parseSection(std::vector<std::shared_ptr<eci::LexerNode>>& _data) {
virtual void parseSection(etk::Vector<ememory::SharedPtr<eci::LexerNode>>& _data) {
// nothing to do ...
};
std::string getValue() {
etk::String getValue() {
return m_regexValue;
};
virtual bool isSubParse() {
@ -108,28 +105,28 @@ namespace eci {
};
class TypeBase : public Type {
public:
std::regex regex;
TypeBase(int32_t _tockenId, const std::string& _regex="") :
etk::RegEx<etk::String> m_regex;
TypeBase(int32_t _tockenId, const etk::String& _regex="") :
Type(_tockenId),
regex(_regex, std::regex_constants::optimize | std::regex_constants::ECMAScript) {
m_regex(_regex) {
m_regexValue = _regex;
}
virtual int32_t getType() {
return TYPE_BASE;
}
std::vector<std::shared_ptr<eci::LexerNode>> parse(const std::string& _data, int32_t _start, int32_t _stop);
etk::Vector<ememory::SharedPtr<eci::LexerNode>> parse(const etk::String& _data, int32_t _start, int32_t _stop);
};
class TypeSection : public Type {
public:
int32_t tockenStart;
int32_t tockenStop;
std::string type;
TypeSection(int32_t _tockenId, int32_t _tockenStart=-1, int32_t _tockenStop=-1, const std::string& _type="") :
etk::String type;
TypeSection(int32_t _tockenId, int32_t _tockenStart=-1, int32_t _tockenStop=-1, const etk::String& _type="") :
Type(_tockenId),
tockenStart(_tockenStart),
tockenStop(_tockenStop),
type(_type) {
m_regexValue = "tok=" + etk::to_string(tockenStart) + " -> tok=" + etk::to_string(tockenStop);
m_regexValue = "tok=" + etk::toString(tockenStart) + " -> tok=" + etk::toString(tockenStop);
}
virtual int32_t getType() {
return TYPE_SECTION;
@ -137,19 +134,19 @@ namespace eci {
virtual bool isSection() {
return true;
}
void parseSectionCurrent(std::vector<std::shared_ptr<eci::LexerNode>>& _data);
void parseSection(std::vector<std::shared_ptr<eci::LexerNode>>& _data);
void parseSectionCurrent(etk::Vector<ememory::SharedPtr<eci::LexerNode>>& _data);
void parseSection(etk::Vector<ememory::SharedPtr<eci::LexerNode>>& _data);
};
class TypeSubBase : public TypeBase {
public:
int32_t parrent;
TypeSubBase(int32_t _tockenId, int32_t _tokenIdParrent=-1, const std::string& _regex="") :
TypeSubBase(int32_t _tockenId, int32_t _tokenIdParrent=-1, const etk::String& _regex="") :
TypeBase(_tockenId, _regex),
parrent(_tokenIdParrent) {}
virtual int32_t getType() {
return TYPE_SUB_BASE;
}
std::vector<std::shared_ptr<eci::LexerNode>> parse(const std::string& _data, int32_t _start, int32_t _stop);
etk::Vector<ememory::SharedPtr<eci::LexerNode>> parse(const etk::String& _data, int32_t _start, int32_t _stop);
bool isSubParse() {
return true;
}
@ -157,18 +154,18 @@ namespace eci {
class TypeSubSection : public TypeSection {
public:
int32_t parrent;
TypeSubSection(int32_t _tockenId, int32_t _tokenIdParrent=-1, int32_t _tockenStart=-1, int32_t _tockenStop=-1, const std::string& _type="") :
TypeSubSection(int32_t _tockenId, int32_t _tokenIdParrent=-1, int32_t _tockenStart=-1, int32_t _tockenStop=-1, const etk::String& _type="") :
TypeSection(_tockenId, _tockenStart, _tockenStop, _type),
parrent(_tokenIdParrent) {}
virtual int32_t getType() {
return TYPE_SUB_SECTION;
}
std::vector<std::shared_ptr<eci::LexerNode>> parse(const std::string& _data, int32_t _start, int32_t _stop);
etk::Vector<ememory::SharedPtr<eci::LexerNode>> parse(const etk::String& _data, int32_t _start, int32_t _stop);
bool isSubParse() {
return true;
}
};
std::vector<std::shared_ptr<eci::Lexer::Type>> m_searchList;
etk::Vector<ememory::SharedPtr<eci::Lexer::Type>> m_searchList;
public:
Lexer();
~Lexer();
@ -177,7 +174,7 @@ namespace eci {
* @param[in] _tokenId Tocken id value.
* @param[in] _regularExpression reconise regular expression.
*/
void append(int32_t _tokenId, const std::string& _regularExpression);
void append(int32_t _tokenId, const etk::String& _regularExpression);
/**
* @brief Append a Token recognition (section reconise start and stop with counting the number of start and stop).
* @param[in] _tokenId Tocken id value.
@ -185,14 +182,14 @@ namespace eci {
* @param[in] _tockenStop Tocken stop.
* @param[in] _type register type when we parse it ...
*/
void appendSection(int32_t _tokenId, int32_t _tockenStart, int32_t _tockenStop, const std::string& _type);
void appendSection(int32_t _tokenId, int32_t _tockenStart, int32_t _tockenStop, const etk::String& _type);
/**
* @brief Append a Token recognition (sub parsing).
* @param[in] _tokenIdParrent parrent Tocken id value.
* @param[in] _tokenId Tocken id value.
* @param[in] _regularExpression reconise regular expression.
*/
void appendSub(int32_t _tokenIdParrent, int32_t _tokenId, const std::string& _regularExpression);
void appendSub(int32_t _tokenIdParrent, int32_t _tokenId, const etk::String& _regularExpression);
/**
* @brief Append a Token recognition (sub parsing) (section reconise start and stop with counting the number of start and stop).
* @param[in] _tokenIdParrent parrent Tocken id value.
@ -201,10 +198,8 @@ namespace eci {
* @param[in] _tockenStop Tocken stop.
* @param[in] _type register type when we parse it ...
*/
void appendSubSection(int32_t _tokenIdParrent, int32_t _tokenId, int32_t _tockenStart, int32_t _tockenStop, const std::string& _type);
void appendSubSection(int32_t _tokenIdParrent, int32_t _tokenId, int32_t _tockenStart, int32_t _tockenStop, const etk::String& _type);
LexerResult interprete(const std::string& _data);
LexerResult interprete(const etk::String& _data);
};
}
#endif

8
eci/Library.cpp
View File

@ -1,11 +1,9 @@
/**
* @author Edouard DUPIN
*
* @copyright 2014, Edouard DUPIN, all right reserved
*
* @license APACHE-2 (see license file)
* @license MPL-2 (see license file)
*/
#include <eci/Library.h>
#include <eci/debug.h>
#include <eci/Library.hpp>
#include <eci/debug.hpp>

13
eci/Library.h → eci/Library.hpp
View File

@ -1,15 +1,13 @@
/**
* @author Edouard DUPIN
*
* @copyright 2014, Edouard DUPIN, all right reserved
*
* @license APACHE-2 (see license file)
* @license MPL-2 (see license file)
*/
#ifndef __ECI_LIBRARY_H__
#define __ECI_LIBRARY_H__
#pragma once
#include <etk/types.h>
#include <etk/types.hpp>
#include <etk/String.hpp>
namespace eci {
class Library {
@ -17,8 +15,7 @@ namespace eci {
Library() {};
~Library() {};
protected:
std::string m_name; //!< library name (just for debug)
etk::String m_name; //!< library name (just for debug)
};
}
#endif

9
eci/Type.cpp
View File

@ -1,11 +1,10 @@
/**
* @author Edouard DUPIN
*
* @copyright 2014, Edouard DUPIN, all right reserved
*
* @license APACHE-2 (see license file)
* @license MPL-2 (see license file)
*/
#include <eci/Type.h>
#include <eci/debug.h>
#include <eci/Type.hpp>
#include <eci/debug.hpp>

77
eci/Type.h
View File

@ -1,77 +0,0 @@
/**
* @author Edouard DUPIN
*
* @copyright 2014, Edouard DUPIN, all right reserved
*
* @license APACHE-2 (see license file)
*/
#ifndef __ECI_TYPE_H__
#define __ECI_TYPE_H__
#include <etk/types.h>
#include <map>
#include <memory>
#include <eci/debug.h>
namespace eci {
class Variable;
class Type : public std::enable_shared_from_this<eci::Type> {
protected:
std::string m_signature; // !!! <== specific au language ...
public:
Type() {};
virtual ~Type() {};
virtual std::shared_ptr<eci::Variable> callOperator(const std::shared_ptr<eci::Variable>& _this,
const std::string& _operatorName,
const std::shared_ptr<eci::Variable>& _obj) {
ECI_ERROR("call unknow operator : '" << _operatorName << "'");
return nullptr;
}
virtual std::vector<std::shared_ptr<eci::Variable>> callFunction(const std::shared_ptr<eci::Variable>& _this,
const std::string& _name,
const std::vector<std::shared_ptr<eci::Variable>>& _objList) {
ECI_ERROR("call unknow function : '" << _name << "' with _input.size()=" << _objList.size());
return std::vector<std::shared_ptr<eci::Variable>>();
};
virtual std::shared_ptr<eci::Variable> getVariable(std::shared_ptr<eci::Variable> _this,
const std::string& _name) {
ECI_ERROR("try get unknow Variable : '" << _name << "'");
return nullptr;
};
virtual std::shared_ptr<eci::Variable> create(const std::vector<std::shared_ptr<eci::Variable>>& _objList) {
return nullptr;
}
virtual void destroy(std::shared_ptr<eci::Variable>& _obj) {
if (_obj != nullptr) {
// TODO : mark as destroyed ...
}
}
virtual std::shared_ptr<eci::Variable> clone(const std::shared_ptr<eci::Variable>& _obj) {
return nullptr;
}
virtual std::shared_ptr<eci::Variable> cast(const std::shared_ptr<eci::Variable>& _obj, const eci::Type& _type) {
return nullptr;
}
};
class TypeNatif : public Type {
protected:
// name , opertor * / += / ++ ...
std::map<std::string, std::function<std::shared_ptr<eci::Variable>(const std::shared_ptr<eci::Variable>&)>> m_operatorList;
// name , function to call
std::map<std::string, std::function<std::vector<std::shared_ptr<eci::Variable>>(const std::vector<std::shared_ptr<eci::Variable>>&)>> m_functionList;
//
};
template<typename T> class TypeBase : public Type {
};
template<> class TypeBase<int32_t> {
};
}
#endif

73
eci/Type.hpp Normal file
View File

@ -0,0 +1,73 @@
/**
* @author Edouard DUPIN
* @copyright 2014, Edouard DUPIN, all right reserved
* @license MPL-2 (see license file)
*/
#pragma once
#include <etk/types.hpp>
#include <etk/Map.hpp>
#include <ememory/memory.hpp>
#include <eci/debug.hpp>
namespace eci {
class Variable;
class Type : public ememory::EnableSharedFromThis<eci::Type> {
protected:
etk::String m_signature; // !!! <== specific au language ...
public:
Type() {};
virtual ~Type() {};
virtual ememory::SharedPtr<eci::Variable> callOperator(const ememory::SharedPtr<eci::Variable>& _this,
const etk::String& _operatorName,
const ememory::SharedPtr<eci::Variable>& _obj) {
ECI_ERROR("call unknow operator : '" << _operatorName << "'");
return nullptr;
}
virtual etk::Vector<ememory::SharedPtr<eci::Variable>> callFunction(const ememory::SharedPtr<eci::Variable>& _this,
const etk::String& _name,
const etk::Vector<ememory::SharedPtr<eci::Variable>>& _objList) {
ECI_ERROR("call unknow function : '" << _name << "' with _input.size()=" << _objList.size());
return etk::Vector<ememory::SharedPtr<eci::Variable>>();
};
virtual ememory::SharedPtr<eci::Variable> getVariable(ememory::SharedPtr<eci::Variable> _this,
const etk::String& _name) {
ECI_ERROR("try get unknow Variable : '" << _name << "'");
return nullptr;
};
virtual ememory::SharedPtr<eci::Variable> create(const etk::Vector<ememory::SharedPtr<eci::Variable>>& _objList) {
return nullptr;
}
virtual void destroy(ememory::SharedPtr<eci::Variable>& _obj) {
if (_obj != nullptr) {
// TODO : mark as destroyed ...
}
}
virtual ememory::SharedPtr<eci::Variable> clone(const ememory::SharedPtr<eci::Variable>& _obj) {
return nullptr;
}
virtual ememory::SharedPtr<eci::Variable> cast(const ememory::SharedPtr<eci::Variable>& _obj, const eci::Type& _type) {
return nullptr;
}
};
class TypeNatif : public Type {
protected:
// name , opertor * / += / ++ ...
etk::Map<etk::String, etk::Function<ememory::SharedPtr<eci::Variable>(const ememory::SharedPtr<eci::Variable>&)>> m_operatorList;
// name , function to call
etk::Map<etk::String, etk::Function<etk::Vector<ememory::SharedPtr<eci::Variable>>(const etk::Vector<ememory::SharedPtr<eci::Variable>>&)>> m_functionList;
//
};
template<typename T> class TypeBase : public Type {
};
template<> class TypeBase<int32_t> {
};
}

26
eci/Value.h
View File

@ -1,26 +0,0 @@
/**
* @author Edouard DUPIN
*
* @copyright 2014, Edouard DUPIN, all right reserved
*
* @license APACHE-2 (see license file)
*/
#ifndef __ECI_VALUE_H__
#define __ECI_VALUE_H__
#include <etk/types.h>
#include <eci/Type.h>
#include <memory>
namespace eci {
class Value : public std::enable_shared_from_this<Value>{
public:
Value() {};
~Value() {};
protected:
};
}
#endif

22
eci/Value.hpp Normal file
View File

@ -0,0 +1,22 @@
/**
* @author Edouard DUPIN
* @copyright 2014, Edouard DUPIN, all right reserved
* @license MPL-2 (see license file)
*/
#pragma once
#include <etk/types.hpp>
#include <eci/Type.hpp>
#include <ememory/memory.hpp>
namespace eci {
class Value : public ememory::EnableSharedFromThis<Value>{
public:
Value() {};
~Value() {};
protected:
};
}

9
eci/Variable.cpp
View File

@ -1,13 +1,12 @@
/**
* @author Edouard DUPIN
*
* @copyright 2014, Edouard DUPIN, all right reserved
*
* @license APACHE-2 (see license file)
* @license MPL-2 (see license file)
*/
#include <eci/Variable.h>
#include <eci/debug.h>
#include <etk/types.hpp>
#include <eci/Variable.hpp>
#include <eci/debug.hpp>
eci::Variable::Variable() :
m_visibility(eci::visibilityPublic),

31
eci/Variable.h
View File

@ -1,31 +0,0 @@
/**
* @author Edouard DUPIN
*
* @copyright 2014, Edouard DUPIN, all right reserved
*
* @license APACHE-2 (see license file)
*/
#ifndef __ECI_VARIABLE_H__
#define __ECI_VARIABLE_H__
#include <etk/types.h>
#include <eci/visibility.h>
#include <eci/Type.h>
#include <memory>
namespace eci {
class Variable : public std::enable_shared_from_this<Variable> {
public:
Variable();
virtual ~Variable();
private:
enum eci::visibility m_visibility;
bool m_const;
std::string m_name;
std::shared_ptr<eci::Type> m_type;
};
}
#endif

26
eci/Variable.hpp Normal file
View File

@ -0,0 +1,26 @@
/**
* @author Edouard DUPIN
* @copyright 2014, Edouard DUPIN, all right reserved
* @license MPL-2 (see license file)
*/
#pragma once
#include <etk/types.hpp>
#include <eci/visibility.hpp>
#include <eci/Type.hpp>
#include <ememory/memory.hpp>
namespace eci {
class Variable : public ememory::EnableSharedFromThis<Variable> {
public:
Variable();
virtual ~Variable();
private:
enum eci::visibility m_visibility;
bool m_const;
etk::String m_name;
ememory::SharedPtr<eci::Type> m_type;
};
}

10
eci/debug.cpp
View File

@ -1,14 +1,12 @@
/**
* @author Edouard DUPIN
*
* @copyright 2011, Edouard DUPIN, all right reserved
*
* @license APACHE-2 (see license file)
* @copyright 2014, Edouard DUPIN, all right reserved
* @license MPL-2 (see license file)
*/
#include <eci/debug.h>
#include <eci/debug.hpp>
int32_t eci::getLogId() {
static int32_t g_val = etk::log::registerInstance("eci");
static int32_t g_val = elog::registerInstance("eci");
return g_val;
}

15
eci/debug.h → eci/debug.hpp
View File

@ -1,21 +1,19 @@
/**
* @author Edouard DUPIN
*
* @copyright 2011, Edouard DUPIN, all right reserved
*
* @license APACHE-2 (see license file)
* @copyright 2014, Edouard DUPIN, all right reserved
* @license MPL-2 (see license file)
*/
#ifndef __ECI_DEBUG_H__
#define __ECI_DEBUG_H__
#pragma once
#include <etk/log.h>
#include <elog/log.hpp>
namespace eci {
int32_t getLogId();
};
#define ECI_BASE(info,data) TK_LOG_BASE(eci::getLogId(),info,data)
#define ECI_BASE(info,data) ELOG_BASE(eci::getLogId(),info,data)
#define ECI_PRINT(data) ECI_BASE(-1, data)
#define ECI_CRITICAL(data) ECI_BASE(1, data)
#define ECI_ERROR(data) ECI_BASE(2, data)
#define ECI_WARNING(data) ECI_BASE(3, data)
@ -39,5 +37,4 @@ namespace eci {
} \
} while (0)
#endif

78
eci/eci.cpp
View File

@ -1,39 +1,38 @@
/**
* @author Edouard DUPIN
*
* @copyright 2014, Edouard DUPIN, all right reserved
*
* @license APACHE-2 (see license file)
* @license MPL-2 (see license file)
*/
#include <eci/eci.h>
#include <eci/debug.h>
#include <eci/lang/ParserCpp.h>
#include <etk/os/FSNode.h>
#include <eci/Interpreter.h>
#include <eci/eci.hpp>
#include <eci/debug.hpp>
#include <eci/lang/ParserCpp.hpp>
#include <etk/os/FSNode.hpp>
#include <eci/Interpreter.hpp>
#include <etk/etk.hpp>
void run_interactive() {
ECI_CRITICAL("TODO ... create interactive interface");
}
bool run_test(const std::string& _filename) {
eci::Interpreter::Interpreter virtualMachine;
bool run_test(const etk::String& _filename) {
eci::Interpreter virtualMachine;
virtualMachine.addFile(_filename);
virtualMachine.main();
return false;
}
void run_test(const std::vector<std::string>& _listFileToTest) {
void run_test(const etk::Vector<etk::String>& _listFileToTest) {
int32_t test_num = 1;
int32_t count = 0;
int32_t passed = 0;
for (auto &it : _listFileToTest) {
enum etk::typeNode type = etk::FSNode(it).getNodeType();
if (type == etk::FSN_FOLDER) {
if (type == etk::typeNode_folder) {
etk::FSNode node(it);
std::vector<std::string> list;
etk::Vector<etk::String> list;
node.folderGetRecursiveFiles(list, false);
for (auto &it2 : list) {
if (run_test(it2)) {
@ -42,7 +41,7 @@ void run_test(const std::vector<std::string>& _listFileToTest) {
count++;
test_num++;
}
} else if (type == etk::FSN_FILE) {
} else if (type == etk::typeNode_file) {
if (run_test(it)) {
passed++;
}
@ -54,47 +53,24 @@ void run_test(const std::vector<std::string>& _listFileToTest) {
}
int main(int argc, char** argv) {
int main(int _argc, const char** _argv) {
etk::init(_argc, _argv);
// the only one init for etk:
std::vector<std::string> listFileToTest;
for (int32_t iii=1; iii<argc ; ++iii) {
std::string data = argv[iii];
if (data == "-l0") {
etk::log::setLevel(etk::log::logLevelNone);
} else if (data == "-l1") {
etk::log::setLevel(etk::log::logLevelCritical);
} else if (data == "-l2") {
etk::log::setLevel(etk::log::logLevelError);
} else if (data == "-l3") {
etk::log::setLevel(etk::log::logLevelWarning);
} else if (data == "-l4") {
etk::log::setLevel(etk::log::logLevelInfo);
} else if (data == "-l5") {
etk::log::setLevel(etk::log::logLevelDebug);
} else if (data == "-l6") {
etk::log::setLevel(etk::log::logLevelVerbose);
} else if ( data == "-h"
|| data == "--help") {
etk::log::setLevel(etk::log::logLevelVerbose);
ECI_INFO("Help : ");
ECI_INFO(" ./xxx [options]");
ECI_INFO(" -l0: debug None");
ECI_INFO(" -l1: debug Critical");
ECI_INFO(" -l2: debug Error");
ECI_INFO(" -l3: debug Warning");
ECI_INFO(" -l4: debug Info");
ECI_INFO(" -l5: debug Debug");
ECI_INFO(" -l6: debug Verbose");
ECI_INFO(" -h/--help: this help");
etk::Vector<etk::String> listFileToTest;
for (int32_t iii=1; iii<_argc ; ++iii) {
etk::String data = _argv[iii];
if ( data == "-h"
|| data == "--help") {
ECI_PRINT("Help : ");
ECI_PRINT(" ./xxx [options]");
ECI_PRINT(" No option for now");
exit(0);
} else {
listFileToTest.push_back(data);
} else if ( data.startWith("--elog-") == false
&& data.startWith("--etk-") == false) {
listFileToTest.pushBack(data);
}
}
etk::setArgZero(argv[0]);
etk::initDefaultFolder("exml_test");
ECI_INFO("input elements : " << listFileToTest);
ECI_INFO("input elements: " << listFileToTest);
// Cocal parse :
if (listFileToTest.size() == 0) {
run_interactive();

12
eci/eci.h
View File

@ -1,12 +0,0 @@
/**
* @author Edouard DUPIN
*
* @copyright 2014, Edouard DUPIN, all right reserved
*
* @license APACHE-2 (see license file)
*/
#ifndef __ECI_H__
#define __ECI_H__
#endif

10
eci/eci.hpp Normal file
View File

@ -0,0 +1,10 @@
/**
* @author Edouard DUPIN
* @copyright 2014, Edouard DUPIN, all right reserved
* @license MPL-2 (see license file)
*/
#pragma once
#include <etk/types.hpp>

20
eci/lang/ParserCpp.cpp
View File

@ -1,13 +1,11 @@
/**
* @author Edouard DUPIN
*
* @copyright 2014, Edouard DUPIN, all right reserved
*
* @license APACHE-2 (see license file)
* @license MPL-2 (see license file)
*/
#include <eci/lang/ParserCpp.h>
#include <eci/debug.h>
#include <eci/lang/ParserCpp.hpp>
#include <eci/debug.hpp>
eci::ParserCpp::ParserCpp() {
@ -57,25 +55,25 @@ eci::ParserCpp::~ParserCpp() {
}
static void printNode(const std::string& _data, const std::vector<std::shared_ptr<eci::LexerNode>>& _nodes, int32_t _level=0) {
std::string offset;
static void printNode(const etk::String& _data, const etk::Vector<ememory::SharedPtr<eci::LexerNode>>& _nodes, int32_t _level=0) {
etk::String offset;
for (int32_t iii=0; iii<_level; ++iii) {
offset += " ";
}
for (auto &it : _nodes) {
if (it->isNodeContainer() == true) {
std::shared_ptr<eci::LexerNodeContainer> sec = std::dynamic_pointer_cast<eci::LexerNodeContainer>(it);
ememory::SharedPtr<eci::LexerNodeContainer> sec = ememory::dynamicPointerCast<eci::LexerNodeContainer>(it);
if (sec != nullptr) {
ECI_INFO(offset << " " << sec->getStartPos() << "->" << sec->getStopPos() << " container: " << sec->getType());
printNode(_data, sec->m_list, _level+1);
}
} else {
ECI_INFO(offset << it->getStartPos() << "->" << it->getStopPos() << " data='" <<std::string(_data, it->getStartPos(), it->getStopPos()-it->getStartPos()) << "'" );
ECI_INFO(offset << it->getStartPos() << "->" << it->getStopPos() << " data='" <<etk::String(_data, it->getStartPos(), it->getStopPos()-it->getStartPos()) << "'" );
}
}
}
bool eci::ParserCpp::parse(const std::string& _data) {
bool eci::ParserCpp::parse(const etk::String& _data) {
m_result = m_lexer.interprete(_data);
// TODO: Agregate type
@ -86,7 +84,7 @@ bool eci::ParserCpp::parse(const std::string& _data) {
printNode(_data, m_result.m_list);
/*
for (auto &it : m_result.m_list) {
ECI_INFO(" start=" << it->getStartPos() << " stop=" << it->getStopPos() << " data='" <<std::string(_data, it->getStartPos(), it->getStopPos()-it->getStartPos()) << "'" );
ECI_INFO(" start=" << it->getStartPos() << " stop=" << it->getStopPos() << " data='" <<etk::String(_data, it->getStartPos(), it->getStopPos()-it->getStartPos()) << "'" );
}
*/
return false;

16
eci/lang/ParserCpp.h → eci/lang/ParserCpp.hpp
View File

@ -1,16 +1,14 @@
/**
* @author Edouard DUPIN
*
* @copyright 2014, Edouard DUPIN, all right reserved
*
* @license APACHE-2 (see license file)
* @license MPL-2 (see license file)
*/
#ifndef __ECI_PARSER_CPP_H__
#define __ECI_PARSER_CPP_H__
#pragma once
#include <eci/Lexer.h>
#include <eci/Interpreter.h>
#include <etk/types.hpp>
#include <eci/Lexer.hpp>
#include <eci/Interpreter.hpp>
namespace eci {
@ -64,8 +62,6 @@ namespace eci {
public:
ParserCpp();
~ParserCpp();
bool parse(const std::string& _data);
bool parse(const etk::String& _data);
};
}
#endif

20
eci/lang/ParserJS.cpp
View File

@ -1,13 +1,11 @@
/**
* @author Edouard DUPIN
*
* @copyright 2014, Edouard DUPIN, all right reserved
*
* @license APACHE-2 (see license file)
* @license MPL-2 (see license file)
*/
#include <eci/lang/ParserJS.h>
#include <eci/debug.h>
#include <eci/lang/ParserJS.hpp>
#include <eci/debug.hpp>
eci::ParserJS::ParserJS() {
@ -39,25 +37,25 @@ eci::ParserJS::~ParserJS() {
}
static void printNode(const std::string& _data, const std::vector<std::shared_ptr<eci::LexerNode>>& _nodes, int32_t _level=0) {
std::string offset;
static void printNode(const etk::String& _data, const etk::Vector<ememory::SharedPtr<eci::LexerNode>>& _nodes, int32_t _level=0) {
etk::String offset;
for (int32_t iii=0; iii<_level; ++iii) {
offset += " ";
}
for (auto &it : _nodes) {
if (it->isNodeContainer() == true) {
std::shared_ptr<eci::LexerNodeContainer> sec = std::dynamic_pointer_cast<eci::LexerNodeContainer>(it);
ememory::SharedPtr<eci::LexerNodeContainer> sec = ememory::dynamicPointerCast<eci::LexerNodeContainer>(it);
if (sec != nullptr) {
ECI_INFO(offset << " " << sec->getStartPos() << "->" << sec->getStopPos() << " container: " << sec->getType());
printNode(_data, sec->m_list, _level+1);
}
} else {
ECI_INFO(offset << it->getStartPos() << "->" << it->getStopPos() << " data='" <<std::string(_data, it->getStartPos(), it->getStopPos()-it->getStartPos()) << "'" );
ECI_INFO(offset << it->getStartPos() << "->" << it->getStopPos() << " data='" <<etk::String(_data, it->getStartPos(), it->getStopPos()-it->getStartPos()) << "'" );
}
}
}
bool eci::ParserJS::parse(const std::string& _data) {
bool eci::ParserJS::parse(const etk::String& _data) {
m_result = m_lexer.interprete(_data);
// TODO: Agregate type
@ -68,7 +66,7 @@ bool eci::ParserJS::parse(const std::string& _data) {
printNode(_data, m_result.m_list);
/*
for (auto &it : m_result.m_list) {
ECI_INFO(" start=" << it->getStartPos() << " stop=" << it->getStopPos() << " data='" <<std::string(_data, it->getStartPos(), it->getStopPos()-it->getStartPos()) << "'" );
ECI_INFO(" start=" << it->getStartPos() << " stop=" << it->getStopPos() << " data='" <<etk::String(_data, it->getStartPos(), it->getStopPos()-it->getStartPos()) << "'" );
}
*/
return false;

16
eci/lang/ParserJS.h → eci/lang/ParserJS.hpp
View File

@ -1,16 +1,14 @@
/**
* @author Edouard DUPIN
*
* @copyright 2014, Edouard DUPIN, all right reserved
*
* @license APACHE-2 (see license file)
* @license MPL-2 (see license file)
*/
#ifndef __ECI_PARSER_JS_H__
#define __ECI_PARSER_JS_H__
#pragma once
#include <eci/Lexer.h>
#include <eci/Interpreter.h>
#include <etk/types.hpp>
#include <eci/Lexer.hpp>
#include <eci/Interpreter.hpp>
namespace eci {
@ -47,8 +45,6 @@ namespace eci {
public:
ParserJS();
~ParserJS();
bool parse(const std::string& _data);
bool parse(const etk::String& _data);
};
}
#endif

10
eci/visibility.h → eci/visibility.hpp
View File

@ -1,15 +1,12 @@
/**
* @author Edouard DUPIN
*
* @copyright 2014, Edouard DUPIN, all right reserved
*
* @license APACHE-2 (see license file)
* @license MPL-2 (see license file)
*/
#ifndef __ECI_VISIBILITY_H__
#define __ECI_VISIBILITY_H__
#pragma once
#include <etk/types.h>
#include <etk/types.hpp>
namespace eci {
enum visibility {
@ -20,4 +17,3 @@ namespace eci {
};
}
#endif

17
lutin_eci2.py
View File

@ -4,19 +4,28 @@ import lutin.tools as tools
import os
def get_type():
return "LIBRARY"
return "BINARY"
def get_name():
return "ECI"
def get_desc():
return "Ewol C Interpreter"
def get_licence():
return "APACHE-2"
return "MPL-2"
def get_compagny_type():
return "com"
return "org"
def get_compagny_name():
return "atria-soft"
return "Edouard DUPIN"
def get_maintainer():
return ["Mr DUPIN Edouard <yui.heero@gmail.com>"]
def get_version():
return [0,1,"dev"]
def configure(target, my_module):
my_module.add_extra_flags()