First commit

src/bcrossc.cpp

@@ -0,0 +1,19 @@
+#include "bcrossc.hpp"
+#include <iostream>
+#include <fstream>
+using namespace Tesses::Framework;
+using namespace Tesses::CrossLang;
+
+int main(int argc, char** argv)
+{
+    TF_Init();
+    std::ifstream strm("../sourceCode.btcross",std::ios_base::binary);
+    std::vector<LexToken> tokens;
+   
+    Lex("sourceCode.btcross",strm, tokens);
+    BCParser parser(tokens);
+    auto node = parser.ParseRoot();
+    auto json = node->ToJsonObject();
+    std::cout << Tesses::Framework::Serialization::Json::Json::Encode(json) << std::endl;
+    
+}

src/bcrossc.hpp

@@ -0,0 +1,296 @@
+#include <CrossLang.hpp>
+
+
+namespace Tesses::CrossLang {
+    using TF_JToken = Tesses::Framework::Serialization::Json::JToken;
+    class BNode {
+        public:
+            virtual bool IsExpression() = 0;
+            virtual ~BNode() = default;
+            virtual TF_JToken ToJsonObject() = 0;
+    };
+    
+    using BSyntaxNode = std::shared_ptr<BNode>;
+    
+    struct BType {
+        std::vector<std::string> nameParts;
+        std::vector<BType> generics;  
+        bool nullable=false;      
+        std::string Stringify();    
+    };
+    class BUndefined : public BNode {
+        public:
+            bool IsExpression();
+            TF_JToken ToJsonObject();
+    };
+    class BNull : public BNode {
+        public:
+            bool IsExpression();
+            TF_JToken ToJsonObject();
+    };
+    class BString : public BNode {
+        public:
+            BString(std::string text);
+            bool IsExpression();
+            TF_JToken ToJsonObject();
+            std::string text;
+    };
+    class BChar : public BNode {
+        public:
+            BChar(char value);
+            bool IsExpression();
+            TF_JToken ToJsonObject();
+            char value;
+    };
+    class BBoolean : public BNode {
+        public:
+            BBoolean(bool text);
+            bool IsExpression();
+            TF_JToken ToJsonObject();
+            bool value;
+    };
+    class BLong : public BNode {
+        public:
+            BLong(int64_t text);
+            bool IsExpression();
+            TF_JToken ToJsonObject();
+            int64_t value;
+    };
+    class BDouble : public BNode {
+        public:
+            BDouble(double text);
+            bool IsExpression();
+            TF_JToken ToJsonObject();
+            double value;
+    };
+
+    class BUnaryExpression : public BNode {
+        public:
+            BUnaryExpression(std::string_view type, BSyntaxNode val);
+            bool IsExpression();
+            TF_JToken ToJsonObject();
+            std::string_view type;
+            BSyntaxNode value;
+    };
+    class BBinaryExpression : public BNode {
+        public:
+            BBinaryExpression(std::string_view type, BSyntaxNode left, BSyntaxNode right);
+            bool IsExpression();
+            TF_JToken ToJsonObject();
+            std::string_view type;
+            BSyntaxNode left;
+            BSyntaxNode right;
+    };
+    class BTernaryExpression : public BNode {
+        public:
+            BTernaryExpression(BSyntaxNode cond, BSyntaxNode yes, BSyntaxNode no);
+            bool IsExpression();
+            TF_JToken ToJsonObject();
+            BSyntaxNode cond;
+            BSyntaxNode yes;
+            BSyntaxNode no;
+    };
+    class BIfStatement : public BNode {
+        public:
+            BIfStatement(BSyntaxNode cond, BSyntaxNode yes, BSyntaxNode no);
+            bool IsExpression();
+            TF_JToken ToJsonObject();
+            BSyntaxNode cond;
+            BSyntaxNode yes;
+            BSyntaxNode no;
+    };
+    class BEachStatement : public BNode {
+        public:
+            BEachStatement(BSyntaxNode var, BSyntaxNode list, BSyntaxNode body);
+            bool IsExpression();
+            TF_JToken ToJsonObject();
+            BSyntaxNode var;
+            BSyntaxNode list;
+            BSyntaxNode body;
+    };
+
+    class BExternVariableNode : public BNode {
+        public: 
+            BExternVariableNode(std::string documentation,std::string name, BType type);
+            bool IsExpression();
+            TF_JToken ToJsonObject();
+            std::string documentation;
+            std::string name;
+            BType type;
+    };
+    class BExternFuncNode : public BNode {
+        public:
+            BExternFuncNode(std::string documentation,BType returnType, BType name, BSyntaxNode args);
+            bool IsExpression();
+            TF_JToken ToJsonObject();
+            std::string documentation;
+            BType returnType;
+            BType name;
+            BSyntaxNode args;
+    };
+
+    class BNamespaceNode : public BNode {
+        public:
+            BNamespaceNode(BType name, BSyntaxNode body);
+            bool IsExpression();
+            TF_JToken ToJsonObject();
+            BType name;
+            BSyntaxNode body;
+    };
+    class BUsingType : public BNode {
+        public:
+            BUsingType(BType name, BType type);
+            bool IsExpression();
+            TF_JToken ToJsonObject();
+            BType name;
+            BType type;
+    };
+    class BUsingNamespace : public BNode {
+        public:
+            BUsingNamespace(BType name);
+            bool IsExpression();
+            TF_JToken ToJsonObject();
+            BType name;
+    };
+
+    class BVariableDeclarationNode : public BNode {
+        public:
+            BVariableDeclarationNode(std::string documetnation,std::string name, BType type, BSyntaxNode value);
+            std::string documentation;
+            std::string name;
+            BType type;
+            BSyntaxNode value;
+            bool IsExpression();
+            TF_JToken ToJsonObject();
+    };
+    
+    class BArgumentNode : public BNode {
+        public:
+            BArgumentNode(std::string name, BType type);
+            std::string name;
+            BType type;
+            bool IsExpression();
+            TF_JToken ToJsonObject();
+    };
+    class BGetVariableExpression : public BNode {
+        public:
+            BGetVariableExpression(std::string name);
+            std::string name;
+            bool IsExpression();
+            TF_JToken ToJsonObject();
+    };
+
+    class BScopeNode : public BNode {
+        bool isExpression;
+        bool isRoot;
+        public:
+            BScopeNode(bool isRoot=false,bool isExpression=false);
+            bool IsRoot();
+            bool IsExpression();
+            std::vector<BSyntaxNode> childern;
+            TF_JToken ToJsonObject();
+    };
+
+    
+    class BFunctionNode  : public BNode {
+        public:
+            BFunctionNode(std::string documentation,BType returnType, BType name, BSyntaxNode args, BSyntaxNode body);
+            bool IsExpression();
+            TF_JToken ToJsonObject();
+            std::string documentation;
+            BType returnType;
+            BType name;
+            BSyntaxNode args;
+            BSyntaxNode body;
+    };
+
+    class BClosureExpression : public BNode {
+        public:
+            BClosureExpression(BType returnType, BSyntaxNode args, BSyntaxNode body);
+            bool IsExpression();
+            TF_JToken ToJsonObject();
+            BType returnType;
+            BSyntaxNode args;
+            BSyntaxNode body;
+    };
+
+    class BFunctionCallExpression : public BNode {
+        public:
+            BFunctionCallExpression(BSyntaxNode fun, BSyntaxNode args, std::vector<BType> generics);
+            bool IsExpression();
+            TF_JToken ToJsonObject();
+            BSyntaxNode fun;
+            BSyntaxNode args;
+            std::vector<BType> generics;
+    };
+
+
+    class BDelegateNode  : public BNode {
+        public:
+            BDelegateNode(std::string documentation,BType returnType, BType name, BSyntaxNode args);
+            bool IsExpression();
+            TF_JToken ToJsonObject();
+            std::string documentation;
+            BType returnType;
+            BType name;
+            BSyntaxNode args;
+    };
+    class BInterfaceNode : public BNode {
+        public:
+            BInterfaceNode(std::string documentation, BType name);
+            bool IsExpression();
+            TF_JToken ToJsonObject();
+            std::string documentation;
+            BType name; 
+            std::vector<BType> inherits;
+            std::vector<BFunctionNode> funs;
+    };
+
+    class BReturnNode : public BNode {
+        public:
+            BReturnNode(BSyntaxNode retVal);
+            BSyntaxNode retVal;
+            bool IsExpression();
+            TF_JToken ToJsonObject();
+    };
+
+    class BCParser {
+        size_t i = 0;
+        std::vector<LexToken> tokens;
+        BSyntaxNode ParseNode(bool isRoot=false);
+        LexToken tkn;
+        void EnsureSymbol(std::string txt);
+        bool IsIdentifier(std::string txt,bool pop=true);
+        bool IsAnyIdentifier(std::initializer_list<std::string> idents, bool pop=true);
+        bool IsSymbol(std::string txt,bool pop=true);
+        bool IsAnySymbol(std::initializer_list<std::string> idents, bool pop=true);
+        std::string ReadIdentifier();
+        BType ReadType();
+        bool IsGeneric();
+        void ReadGenerics(std::vector<BType>& generics);
+        BSyntaxNode ParseParenElement();
+        BSyntaxNode ParseParen();
+        BSyntaxNode ParseAssignment();
+        BSyntaxNode ParseSum();
+        BSyntaxNode ParseNullCoalescing();
+        BSyntaxNode ParseTernary();
+        BSyntaxNode ParseShift();
+        BSyntaxNode ParseRel();
+        BSyntaxNode ParseEq();
+        BSyntaxNode ParseBAnd();
+        BSyntaxNode ParseExpression();
+        BSyntaxNode ParseXOr();
+        BSyntaxNode ParseBOr();
+        BSyntaxNode ParseLAnd();
+        BSyntaxNode ParseLOr();
+        BSyntaxNode ParseFactor();
+        BSyntaxNode ParseUnary();
+        BSyntaxNode ParseValue();
+
+        public:
+            BCParser(const std::vector<LexToken>& tokens);
+            BSyntaxNode ParseRoot();
+    };
+
+    
+}

src/node.cpp

@@ -0,0 +1,513 @@
+#include "bcrossc.hpp"
+using namespace Tesses::Framework::Serialization::Json;
+namespace Tesses::CrossLang {
+    BScopeNode::BScopeNode(bool isRoot,bool isExpression) : isRoot(isRoot), isExpression(isExpression)
+    {
+
+    }
+    bool BScopeNode::IsRoot()
+    {
+        return isRoot;
+    }
+    bool BScopeNode::IsExpression()
+    {
+        return isExpression;
+    }
+    TF_JToken BScopeNode::ToJsonObject()
+    {
+        JObject o;
+        o.SetValue("Type", "ScopeNode");
+        o.SetValue("IsRoot", isRoot);
+        o.SetValue("IsExpression", isExpression);
+
+        JArray a;
+        for(auto& item : this->childern)
+        {
+            a.Add(item->ToJsonObject());
+        }
+        o.SetValue("Childern",a);
+        return o;
+    }
+
+
+    bool BNull::IsExpression()
+    {
+        return true;
+    }
+
+    TF_JToken BNull::ToJsonObject()
+    {
+        return nullptr;
+    }
+    BVariableDeclarationNode::BVariableDeclarationNode(std::string documentation,std::string name, BType type, BSyntaxNode value)
+        : documentation(documentation), name(name), type(type), value(value)
+    {
+
+    }
+    bool BVariableDeclarationNode::IsExpression()
+    {
+        return false;
+    }
+    TF_JToken BVariableDeclarationNode::ToJsonObject()
+    {
+        JObject o;
+        o.SetValue("Type", "VariableDeclarationNode");
+        o.SetValue("TypeString", this->type.Stringify());
+        o.SetValue("Name", this->name);
+        o.SetValue("Documentation",this->documentation);
+        if(this->value)
+            o.SetValue("Value", this->value->ToJsonObject());
+        return o;
+    }
+
+    BBinaryExpression::BBinaryExpression(std::string_view type, BSyntaxNode left, BSyntaxNode right) : type(type), left(left), right(right)
+    {
+
+    }
+    bool BBinaryExpression::IsExpression()
+    {
+        return true;
+    }
+    TF_JToken BBinaryExpression::ToJsonObject()
+    {
+        JObject o;
+        o.SetValue("Type",(std::string)this->type);
+        if(this->left)
+        o.SetValue("Left", this->left->ToJsonObject());
+
+        if(this->right)
+        o.SetValue("Right", this->right->ToJsonObject());
+
+        return o;
+    }
+
+    BUnaryExpression::BUnaryExpression(std::string_view type, BSyntaxNode value) : type(type), value(value)
+    {
+
+    }
+
+    bool BUnaryExpression::IsExpression()
+    {
+        return true;
+    }
+    TF_JToken BUnaryExpression::ToJsonObject()
+    {
+        JObject o;
+        o.SetValue("Type",(std::string)this->type);
+        if(this->value)
+        o.SetValue("Value", this->value->ToJsonObject());
+
+        
+        return o;
+    }
+
+    BTernaryExpression::BTernaryExpression(BSyntaxNode cond, BSyntaxNode yes, BSyntaxNode no): cond(cond), yes(yes), no(no)
+    {
+
+    }
+    bool BTernaryExpression::IsExpression()
+    {
+        return true;
+    }
+    TF_JToken BTernaryExpression::ToJsonObject()
+    {
+        JObject o;
+        o.SetValue("Type","TernaryExpression");
+        if(this->cond)
+        o.SetValue("Condition", this->cond->ToJsonObject());
+
+        if(this->yes)
+        o.SetValue("True", this->yes->ToJsonObject());
+
+
+        if(this->no)
+        o.SetValue("False", this->no->ToJsonObject());
+        
+        return o;
+    }
+
+    BIfStatement::BIfStatement(BSyntaxNode cond, BSyntaxNode yes, BSyntaxNode no): cond(cond), yes(yes), no(no)
+    {
+
+    }
+    bool BIfStatement::IsExpression()
+    {
+        return false;
+    }
+    TF_JToken BIfStatement::ToJsonObject()
+    {
+        JObject o;
+        o.SetValue("Type","IfStatement");
+        if(this->cond)
+        o.SetValue("Condition", this->cond->ToJsonObject());
+
+        if(this->yes)
+        o.SetValue("True", this->yes->ToJsonObject());
+
+
+        if(this->no)
+        o.SetValue("False", this->no->ToJsonObject());
+        
+        return o;
+    }
+
+    BString::BString(std::string text) : text(text)
+    {}
+    bool BString::IsExpression()
+    {
+        return true;
+    }
+    TF_JToken BString::ToJsonObject()
+    {
+        return text;
+    }
+
+
+
+
+    BChar::BChar(char value) : value(value)
+    {}
+    bool BChar::IsExpression()
+    {
+        return true;
+    }
+    TF_JToken BChar::ToJsonObject()
+    {
+        JObject o;
+        o.SetValue("Type","Char");
+        o.SetValue("Value", std::string{value});
+        return o;
+    }
+
+    BLong::BLong(int64_t value) : value(value)
+    {}
+    bool BLong::IsExpression()
+    {
+        return true;
+    }
+    TF_JToken BLong::ToJsonObject()
+    {
+        return value;
+    }
+    BDouble::BDouble(double value) : value(value)
+    {}
+    bool BDouble::IsExpression()
+    {
+        return true;
+    }
+    TF_JToken BDouble::ToJsonObject()
+    {
+        return value;
+    }
+    BBoolean::BBoolean(bool value) : value(value)
+    {}
+    bool BBoolean::IsExpression()
+    {
+        return true;
+    }
+    TF_JToken BBoolean::ToJsonObject()
+    {
+        return value;
+    }
+
+    BArgumentNode::BArgumentNode(std::string name, BType type): name(name), type(type)
+    {}
+    bool BArgumentNode::IsExpression()
+    {
+        return false;
+    }
+    TF_JToken BArgumentNode::ToJsonObject()
+    {
+        JObject o;
+        o.SetValue("Type","ArgumentNode");
+        o.SetValue("Name",this->name);
+        o.SetValue("TypeString",this->type.Stringify());
+        return o;
+    }
+
+    BGetVariableExpression::BGetVariableExpression(std::string name) : name(name)
+    {
+
+    }
+    bool BGetVariableExpression::IsExpression()
+    {
+        return true;
+    }
+    TF_JToken BGetVariableExpression::ToJsonObject()
+    {
+        JObject o;
+        o.SetValue("Type","GetVariableExpression");
+        o.SetValue("Name",this->name);       
+        return o;
+    }
+
+    bool BUndefined::IsExpression()
+    {
+        return true;
+    }
+    TF_JToken BUndefined::ToJsonObject()
+    {
+        JObject o;
+        o.SetValue("Type","Undefined");
+        return o;
+    }
+
+    BFunctionNode::BFunctionNode(std::string documentation,BType returnType, BType name, BSyntaxNode args, BSyntaxNode body): documentation(documentation), returnType(returnType), name(name), args(args), body(body)
+    {
+
+    }
+    bool BFunctionNode::IsExpression()
+    {
+        return false;
+    }
+    TF_JToken BFunctionNode::ToJsonObject()
+    {
+        JObject o;
+        o.SetValue("Type","FunctionNode");
+        o.SetValue("ReturnType", this->returnType.Stringify());
+        o.SetValue("Name", this->name.Stringify());
+        o.SetValue("Documentation",this->documentation);
+        if(this->args)
+        o.SetValue("Arguments", this->args->ToJsonObject());
+        if(this->body)
+        o.SetValue("Body",this->body->ToJsonObject());
+        return o;
+    }
+
+    BClosureExpression::BClosureExpression(BType returnType, BSyntaxNode args, BSyntaxNode body): returnType(returnType), args(args), body(body)
+    {
+
+    }
+    bool BClosureExpression::IsExpression()
+    {
+        return true;
+    }
+    TF_JToken BClosureExpression::ToJsonObject()
+    {
+        JObject o;
+        o.SetValue("Type","ClosureExpression");
+        o.SetValue("ReturnType", this->returnType.Stringify());
+        
+        if(this->args)
+        o.SetValue("Arguments", this->args->ToJsonObject());
+        if(this->body)
+        o.SetValue("Body",this->body->ToJsonObject());
+        return o;
+    }
+    BDelegateNode::BDelegateNode(std::string documentation,BType returnType, BType name, BSyntaxNode args): documentation(documentation),returnType(returnType), name(name), args(args)
+    {
+
+    }
+    bool BDelegateNode::IsExpression()
+    {
+        return false;
+    }
+    TF_JToken BDelegateNode::ToJsonObject()
+    {
+        JObject o;
+        o.SetValue("Type","DelegateNode");
+        o.SetValue("ReturnType", this->returnType.Stringify());
+        o.SetValue("Name", this->name.Stringify());
+        if(this->args)
+        o.SetValue("Arguments", this->args->ToJsonObject());
+        o.SetValue("Documentation",this->documentation);
+        
+        return o;
+    }
+   
+    BReturnNode::BReturnNode(BSyntaxNode retVal): retVal(retVal)
+    {
+
+    }
+    bool BReturnNode::IsExpression()
+    {
+        return false;
+    }
+    TF_JToken BReturnNode::ToJsonObject()
+    {
+        JObject o;
+        o.SetValue("Type","ReturnNode");
+        if(this->retVal)
+        o.SetValue("Value",this->retVal->ToJsonObject());
+        return o;
+    }
+
+    BFunctionCallExpression::BFunctionCallExpression(BSyntaxNode fun, BSyntaxNode args, std::vector<BType> generics)
+        :fun(fun), args(args), generics(generics)
+    {
+
+    }
+    bool BFunctionCallExpression::IsExpression()
+    {
+        return true;
+    }
+    TF_JToken BFunctionCallExpression::ToJsonObject()
+    {
+        JObject o;
+        o.SetValue("Type","FunctionCallExpression");
+        if(this->args)
+            o.SetValue("Arguments",this->args->ToJsonObject());
+        if(this->fun)
+            o.SetValue("Function", this->fun->ToJsonObject());
+        if(!this->generics.empty())
+        {
+            JArray a;
+            for(auto& item : this->generics)
+            {
+                a.Add(item.Stringify());
+            }
+            o.SetValue("Generics",a);
+        }
+        return o;
+    }
+
+    BEachStatement::BEachStatement(BSyntaxNode var, BSyntaxNode list, BSyntaxNode body)
+        :var(var), list(list), body(body)
+    {
+
+    }
+    bool BEachStatement::IsExpression()
+    {
+        return false;
+    }
+    TF_JToken BEachStatement::ToJsonObject()
+    {
+        JObject o;
+        o.SetValue("Type","EachStatement");
+        if(this->var)
+        o.SetValue("Variable", this->var->ToJsonObject());
+        if(this->list)
+        o.SetValue("List",this->list->ToJsonObject());
+        if(this->body)
+        o.SetValue("Body", this->body->ToJsonObject());
+        return o;
+    }
+
+    BExternFuncNode::BExternFuncNode(std::string documentation,BType returnType, BType name, BSyntaxNode args): documentation(documentation),
+        returnType(returnType), name(name), args(args)
+    {
+
+    }
+    bool BExternFuncNode::IsExpression()
+    {
+        return false;
+    }
+
+    TF_JToken BExternFuncNode::ToJsonObject()
+    {
+        JObject o;
+        o.SetValue("Type","ExternFuncNode");
+        if(this->args)
+        o.SetValue("Arguments",this->args->ToJsonObject());
+        o.SetValue("Name",this->name.Stringify());
+        o.SetValue("ReturnType",this->returnType.Stringify());
+        o.SetValue("Documentation",this->documentation);
+        return o;
+    }
+
+
+    BExternVariableNode::BExternVariableNode(std::string documentation,std::string name, BType type) : documentation(documentation), name(name), type(type)
+    {
+        
+    }
+    bool BExternVariableNode::IsExpression()
+    {
+        return false;
+    }
+    TF_JToken BExternVariableNode::ToJsonObject()
+    {
+        JObject o;
+        o.SetValue("Type","ExternVariableNode");
+        o.SetValue("Name",this->name);
+        o.SetValue("Documentation",this->documentation);
+        o.SetValue("TypeString", this->type.Stringify());
+        return o;
+    }
+
+    BNamespaceNode::BNamespaceNode(BType name, BSyntaxNode body):
+        name(name), body(body)
+    {
+
+    }
+
+    bool BNamespaceNode::IsExpression()
+    {
+        return false;
+    }
+
+    TF_JToken BNamespaceNode::ToJsonObject()
+    {
+        JObject o;
+        o.SetValue("Type","NamespaceNode");
+        o.SetValue("Name",this->name.Stringify());
+        if(this->body)
+        o.SetValue("Body",this->body->ToJsonObject());
+
+        return o;
+    }
+
+    BUsingType::BUsingType(BType name, BType type):
+        name(name), type(type)
+    {
+
+    }
+    bool BUsingType::IsExpression()
+    {
+        return false;
+    }
+    TF_JToken BUsingType::ToJsonObject()
+    {
+        JObject o;
+        o.SetValue("Type","UsingType");
+        o.SetValue("Name",this->name.Stringify());
+        o.SetValue("TypeString",this->type.Stringify());
+        return o;
+    }
+
+    BUsingNamespace::BUsingNamespace(BType name): name(name)
+    {
+
+    }
+    bool BUsingNamespace::IsExpression()
+    {
+        return false;
+    }
+
+    TF_JToken BUsingNamespace::ToJsonObject()
+    {
+        JObject o;
+        o.SetValue("Type", "UsingNamespace");
+        o.SetValue("Name",this->name.Stringify());
+        return o;
+    }
+
+    BInterfaceNode::BInterfaceNode(std::string documentation, BType name):
+        documentation(documentation), name(name)
+    {
+
+    }
+    bool BInterfaceNode::IsExpression()
+    {
+        return false;
+    }
+    TF_JToken BInterfaceNode::ToJsonObject()
+    {
+        JObject o;
+        o.SetValue("Type","InterfaceNode");
+        o.SetValue("Documentation",this->documentation);
+        o.SetValue("Name",this->name.Stringify());
+        JArray a;
+        for(auto& item : this->inherits)
+        {
+            a.Add(item.Stringify());
+        }
+        o.SetValue("Inherits", a);
+        a.Clear();
+        for(auto& item : this->funs)
+        {
+            a.Add(item.ToJsonObject());
+        }
+        o.SetValue("Functions",a);
+        return o;
+    }
+}