C++ Custom JVM

merka1rugg · 15 Май 2025

Я это делал за 5 минут.

Custom JVM:

#include <iostream>
#include <stack>
#include <map>
#include <vector>
#include <string>
#include <stdexcept>

class ClassObject {
private:
    std::string name;
    std::map<std::string, std::vector<int>> methods;
public:
    ClassObject(const std::string& name) : name(name) {}
    void addMethod(const std::string& methodName, const std::vector<int>& bytecode) {
        methods[methodName] = bytecode;
    }
    std::vector<int> getMethod(const std::string& methodName) {
        return methods[methodName];
    }
};

class SimpleJVM {
private:
    std::stack<int> stack;
    std::map<std::string, ClassObject*> classLoader;
public:
    SimpleJVM() {}
    ~SimpleJVM() {
        for (auto& entry : classLoader) {
            delete entry.second;
        }
    }
    ClassObject* loadClass(const std::string& className) {
        if (classLoader.find(className) != classLoader.end()) {
            return classLoader[className];
        }
        ClassObject* cls = new ClassObject(className);
        cls->addMethod("main", {0x10, 0x01, 0x15, 0x00});
        classLoader[className] = cls;
        return cls;
    }
    void execute(const std::string& className) {
        ClassObject* cls = loadClass(className);
        std::vector<int> method = cls->getMethod("main");
        for (int instr : method) {
            switch(instr) {
                case 0x10:
                    stack.push(42);
                    break;
                case 0x01:
                    std::cout << stack.top() << std::endl;
                    stack.pop();
                    break;
                case 0x15:
                    stack.push(100);
                    break;
                case 0x00:
                    return;
                default:
                    throw std::runtime_error("Unknown instruction");
            }
        }
    }
};

int main() {
    SimpleJVM jvm;
    jvm.execute("MyClass");
}

Код:

TheXSVV · 15 Май 2025

ахахах ебать это что

Angelwingsov · 15 Май 2025

Я тебя понял

Albertrunner · 15 Май 2025

merka1rugg написал(а):

Я это делал за 5 минут.

Custom JVM:

#include <iostream>
#include <stack>
#include <map>
#include <vector>
#include <string>
#include <stdexcept>

class ClassObject {
private:
    std::string name;
    std::map<std::string, std::vector<int>> methods;
public:
    ClassObject(const std::string& name) : name(name) {}
    void addMethod(const std::string& methodName, const std::vector<int>& bytecode) {
        methods[methodName] = bytecode;
    }
    std::vector<int> getMethod(const std::string& methodName) {
        return methods[methodName];
    }
};

class SimpleJVM {
private:
    std::stack<int> stack;
    std::map<std::string, ClassObject*> classLoader;
public:
    SimpleJVM() {}
    ~SimpleJVM() {
        for (auto& entry : classLoader) {
            delete entry.second;
        }
    }
    ClassObject* loadClass(const std::string& className) {
        if (classLoader.find(className) != classLoader.end()) {
            return classLoader[className];
        }
        ClassObject* cls = new ClassObject(className);
        cls->addMethod("main", {0x10, 0x01, 0x15, 0x00});
        classLoader[className] = cls;
        return cls;
    }
    void execute(const std::string& className) {
        ClassObject* cls = loadClass(className);
        std::vector<int> method = cls->getMethod("main");
        for (int instr : method) {
            switch(instr) {
                case 0x10:
                    stack.push(42);
                    break;
                case 0x01:
                    std::cout << stack.top() << std::endl;
                    stack.pop();
                    break;
                case 0x15:
                    stack.push(100);
                    break;
                case 0x00:
                    return;
                default:
                    throw std::runtime_error("Unknown instruction");
            }
        }
    }
};

int main() {
    SimpleJVM jvm;
    jvm.execute("MyClass");
}

Код:

за 5 мин пойдет но кучу траблов с таким кодом

upd: я как понимаю ты просто скопировал из этой темы https://yougame.biz/threads/339212/

merka1rugg · 15 Май 2025

Albertrunner написал(а):
за 5 мин пойдет но кучу траблов с таким кодом

upd: я как понимаю ты просто скопировал из этой темы https://yougame.biz/threads/339212/

Да, было дело но он забыл последний байт добавить 0x15

user_sterford · 15 Май 2025

merka1rugg написал(а):

Я это делал за 5 минут.

Custom JVM:

#include <iostream>
#include <stack>
#include <map>
#include <vector>
#include <string>
#include <stdexcept>

class ClassObject {
private:
    std::string name;
    std::map<std::string, std::vector<int>> methods;
public:
    ClassObject(const std::string& name) : name(name) {}
    void addMethod(const std::string& methodName, const std::vector<int>& bytecode) {
        methods[methodName] = bytecode;
    }
    std::vector<int> getMethod(const std::string& methodName) {
        return methods[methodName];
    }
};

class SimpleJVM {
private:
    std::stack<int> stack;
    std::map<std::string, ClassObject*> classLoader;
public:
    SimpleJVM() {}
    ~SimpleJVM() {
        for (auto& entry : classLoader) {
            delete entry.second;
        }
    }
    ClassObject* loadClass(const std::string& className) {
        if (classLoader.find(className) != classLoader.end()) {
            return classLoader[className];
        }
        ClassObject* cls = new ClassObject(className);
        cls->addMethod("main", {0x10, 0x01, 0x15, 0x00});
        classLoader[className] = cls;
        return cls;
    }
    void execute(const std::string& className) {
        ClassObject* cls = loadClass(className);
        std::vector<int> method = cls->getMethod("main");
        for (int instr : method) {
            switch(instr) {
                case 0x10:
                    stack.push(42);
                    break;
                case 0x01:
                    std::cout << stack.top() << std::endl;
                    stack.pop();
                    break;
                case 0x15:
                    stack.push(100);
                    break;
                case 0x00:
                    return;
                default:
                    throw std::runtime_error("Unknown instruction");
            }
        }
    }
};

int main() {
    SimpleJVM jvm;
    jvm.execute("MyClass");
}

Код:

мерка, что это блять такое

merka1rugg · 15 Май 2025

user_sterford написал(а):
мерка, что это блять такое

Я че ебу я так и не понял magicvalue как делается

TheXSVV · 15 Май 2025

merka1rugg написал(а):

Я это делал за 5 минут.

Custom JVM:

#include <iostream>
#include <stack>
#include <map>
#include <vector>
#include <string>
#include <stdexcept>

class ClassObject {
private:
    std::string name;
    std::map<std::string, std::vector<int>> methods;
public:
    ClassObject(const std::string& name) : name(name) {}
    void addMethod(const std::string& methodName, const std::vector<int>& bytecode) {
        methods[methodName] = bytecode;
    }
    std::vector<int> getMethod(const std::string& methodName) {
        return methods[methodName];
    }
};

class SimpleJVM {
private:
    std::stack<int> stack;
    std::map<std::string, ClassObject*> classLoader;
public:
    SimpleJVM() {}
    ~SimpleJVM() {
        for (auto& entry : classLoader) {
            delete entry.second;
        }
    }
    ClassObject* loadClass(const std::string& className) {
        if (classLoader.find(className) != classLoader.end()) {
            return classLoader[className];
        }
        ClassObject* cls = new ClassObject(className);
        cls->addMethod("main", {0x10, 0x01, 0x15, 0x00});
        classLoader[className] = cls;
        return cls;
    }
    void execute(const std::string& className) {
        ClassObject* cls = loadClass(className);
        std::vector<int> method = cls->getMethod("main");
        for (int instr : method) {
            switch(instr) {
                case 0x10:
                    stack.push(42);
                    break;
                case 0x01:
                    std::cout << stack.top() << std::endl;
                    stack.pop();
                    break;
                case 0x15:
                    stack.push(100);
                    break;
                case 0x00:
                    return;
                default:
                    throw std::runtime_error("Unknown instruction");
            }
        }
    }
};

int main() {
    SimpleJVM jvm;
    jvm.execute("MyClass");
}

Код:

может просто CustomVM а не JVM?

Bocxol · 16 Май 2025

Хуйня какая-то

battleye · 17 Май 2025

merka1rugg написал(а):
~snip~

ТС объебался солями и задал ChatGPT сделать ему JVM, но вместо этого ChatGPT сделал ему обычную ВМ))

merka1rugg · 17 Май 2025

zero-cocain написал(а):
ТС объебался солями и задал ChatGPT сделать ему JVM, но вместо этого ChatGPT сделал ему обычную ВМ))

;)

r3z · 17 Май 2025

merka1rugg написал(а):

Я это делал за 5 минут.

Custom JVM:

#include <iostream>
#include <stack>
#include <map>
#include <vector>
#include <string>
#include <stdexcept>

class ClassObject {
private:
    std::string name;
    std::map<std::string, std::vector<int>> methods;
public:
    ClassObject(const std::string& name) : name(name) {}
    void addMethod(const std::string& methodName, const std::vector<int>& bytecode) {
        methods[methodName] = bytecode;
    }
    std::vector<int> getMethod(const std::string& methodName) {
        return methods[methodName];
    }
};

class SimpleJVM {
private:
    std::stack<int> stack;
    std::map<std::string, ClassObject*> classLoader;
public:
    SimpleJVM() {}
    ~SimpleJVM() {
        for (auto& entry : classLoader) {
            delete entry.second;
        }
    }
    ClassObject* loadClass(const std::string& className) {
        if (classLoader.find(className) != classLoader.end()) {
            return classLoader[className];
        }
        ClassObject* cls = new ClassObject(className);
        cls->addMethod("main", {0x10, 0x01, 0x15, 0x00});
        classLoader[className] = cls;
        return cls;
    }
    void execute(const std::string& className) {
        ClassObject* cls = loadClass(className);
        std::vector<int> method = cls->getMethod("main");
        for (int instr : method) {
            switch(instr) {
                case 0x10:
                    stack.push(42);
                    break;
                case 0x01:
                    std::cout << stack.top() << std::endl;
                    stack.pop();
                    break;
                case 0x15:
                    stack.push(100);
                    break;
                case 0x00:
                    return;
                default:
                    throw std::runtime_error("Unknown instruction");
            }
        }
    }
};

int main() {
    SimpleJVM jvm;
    jvm.execute("MyClass");
}

Код:

это чуть чуть не жвм

user_sterford · 17 Май 2025

r3z написал(а):
это чуть чуть не жвм

я мерке написал что жвм делается на исходниках OpenJDK, он такой "чего?"

r3z · 17 Май 2025

user_sterford написал(а):
я мерке написал что жвм делается на исходниках OpenJDK, он такой "чего?"

ХЪЗПВАЗВПАЫХВЗ

merka1rugg · 17 Май 2025

user_sterford написал(а):
я мерке написал что жвм делается на исходниках OpenJDK, он такой "чего?"

когда я тебе на сайт поставил аватарку клоуна ты такой "как?"

C++ Custom JVM

Похожие темы