crosslang/src/compiler/ast.cpp

#include "CrossLang.hpp"
#if defined(CROSSLANG_ENABLE_JSON)
#include <jansson.h>
#endif
namespace Tesses::CrossLang
{
AdvancedSyntaxNode AdvancedSyntaxNode::Create(std::string_view nodeName,bool isExpression, std::vector<SyntaxNode> nodes)
{
    AdvancedSyntaxNode asn;
    asn.nodeName = std::string(nodeName);
    asn.isExpression = isExpression;
    asn.nodes = nodes;
    return asn;
}

#if defined(CROSSLANG_ENABLE_JSON)
static SyntaxNode Deserialize2(json_t* json)
{
    if(json_is_null(json)) return nullptr;
    if(json_is_true(json)) return true;
    if(json_is_false(json)) return false;
    if(json_is_integer(json)) return (int64_t)json_integer_value(json);
    if(json_is_real(json)) return json_real_value(json);
    if(json_is_string(json)) return std::string(json_string_value(json),json_string_length(json));
    if(json_is_object(json))
    {
        json_t* typ = json_object_get(json, "type");
        if(json_is_string(typ))
        {
            std::string type(json_string_value(typ),json_string_length(typ));
            if(type == CharExpression)
            {
                json_t* chrData = json_object_get(json,"value");
                if(json_is_integer(chrData))
                {
                    return (char)(uint8_t)json_integer_value(chrData);
                }
            }
            if(type == UndefinedExpression)
            {
                return Undefined();
            }
            json_t* isExpr = json_object_get(json,"isExpression");
            bool isExprB = json_is_true(isExpr);
             AdvancedSyntaxNode asn;
            asn.nodeName = type;
            asn.isExpression = isExprB;
            json_t* args = json_object_get(json, "args");
            if(json_is_array(args))
            {
                size_t index;
                json_t* value;
                
                json_array_foreach(args, index, value)
                {
                    asn.nodes.push_back(Deserialize2(value));
                }
            }
            return asn;
        }
    }
    return nullptr;
}
#endif


SyntaxNode Deserialize(std::string astData)
{
    #if defined(CROSSLANG_ENABLE_JSON)
    json_t* json = json_loadb(astData.c_str(),astData.size(), 0, NULL);

    auto r = Deserialize2(json);
    json_decref(json);

    return r;
    #endif

    return nullptr;
}
#if defined(CROSSLANG_ENABLE_JSON)
static json_t* Serialize2(SyntaxNode node)
{
    if(std::holds_alternative<std::nullptr_t>(node))
        return json_null();
    if(std::holds_alternative<int64_t>(node))
    {
        return json_integer(std::get<int64_t>(node));
    }
    if(std::holds_alternative<double>(node))
    {
        return json_real(std::get<double>(node));
    }
    if(std::holds_alternative<bool>(node))
    {
        return json_boolean(std::get<bool>(node));
    }
    if(std::holds_alternative<std::string>(node))
    {
        std::string str = std::get<std::string>(node);
        return json_stringn(str.c_str(),str.size());
    }
    if(std::holds_alternative<char>(node))
    {
        char c = std::get<char>(node);
        json_t* json = json_object();
        json_object_set_new(json,"type",json_string(CharExpression.begin()));
        json_object_set_new(json, "value", json_integer((uint8_t)c));
        return json;
    }
    if(std::holds_alternative<Undefined>(node))
    {
        json_t* json = json_object();
        json_object_set_new(json,"type",json_string(UndefinedExpression.begin()));
        return json;
    }


    if(std::holds_alternative<AdvancedSyntaxNode>(node))
    {
        auto asn = std::get<AdvancedSyntaxNode>(node);
        json_t* j = json_object();
        json_object_set_new(j, "type", json_string(asn.nodeName.c_str()));
        json_object_set_new(j, "isExpression",json_boolean(asn.isExpression));
        json_t* arr=json_array();
        for(auto item : asn.nodes)
        {
            json_array_append_new(arr,Serialize2(item));
        }
        json_object_set_new(j, "args", arr);
        return j;
    }
    
    return json_null();
}
#endif

std::string Serialize(SyntaxNode node)
{

#if defined(CROSSLANG_ENABLE_JSON)
json_t* json = Serialize2(node);
char* txt = json_dumps(json,0);
std::string str(txt);
free(json);
json_decref(json);
return str;
#endif
return "";
}

}