UCodeLang
1.0.0
Uma linguagem de programação de alto nível projetada para ser rápida para escrever, compilar e executar.
O UCode é uma linguagem de programação projetada para ser incorporada ao software existente, como mecanismos de jogo, sendo uma linguagem de baixo nível com recursos modernos e de alto nível.
principalmente
Completamente focado e especializado no desenvolvimento de jogos e nos mecanismos de jogo.
E mais.
Esse idioma foi feito porque a falta de idiomas de script adequados para um jogo de jogos que lhe permitiram controle de baixo nível sobre a memória e é fácil de analisar para reflexão.
por exemplo
$Vec2:
float x;
float y;
$Weapon;
$Player:
Vec2 pos;
Weapon[] Weapons;
Após a compilação, obteremos dados de montagem que podem ser usados para ver todas as classes, funções e campos. Portanto, pode ser usado no seu inspetor como os mecanismos de jogo mais populares.
O texto abaixo assume que você compilou uma CPU 64, a VM é agnóstica da CPU, exceto os tamanhos de ponteiro da CPU. Ele precisa ser compilado para 64 bits ou 32 bits, o que é trivial.
$Vec2: //class size 8
float x;//field offset 0
float y;//field offset 4
$Weapon;//size 0
$Player: //class size 32
Vec2 pos;//field offset 0
Vector<Weapon> Weapons;//field offset [8-12 depending if the compiler added padding]
$Vector<Weapon>: //class size 24
Weapon[&] _Data; //field offset 0
uintptr _Size; //field offset 8
uintptr _Capacity; //field offset 16
Queremos dados de montagem C#, mas com o controle de baixo nível C ++ sobre a memória e sem coletor de lixo C#.
Além disso, como estamos cometendo um novo idioma, podemos aprender erros de idiomas anteriores usando os tipos opcionais, os tipos de resultados e as variantes da enumeração e removendo exceções e muito mais.
Apesar de ser feito para os motores de jogo, o UCode não precisa de uma VM, ele pode ser usado por si só e pode ser compilado diretamente em C, Bibliotecas de plataforma WASM e nativas.
ou diretamente para o código da máquina nativo quando isso for feito.
Se o seu caso de uso precisar apenas de um idioma pequeno e não gastará a maior parte do tempo no idioma de script que você sholl usa Lua.
Se você precisar de digitação estática e NESS de baixo nível C ++, mas ok para fazer com que um coletor de lixo use mono c# ou terra.
Site
Playground
Documentação
Extensão do vscode
Começando para os usuários
Como adicionar ao seu projeto C ++
Execute o seguinte no seu terminal para instalar no Linux/MacOS.
curl -L https://github.com/LostbBlizzard/UCodeLang/releases/latest/download/install.sh | sh
Ou faça o download e execute o ucodelangsetup.exe na versão mais recente do Windows.
use ULang;//include standard Library.
|main[] -> int:
int a = 10;
int b = 20;
var c = a + b;
int[] List;
List.Push(c);
int&? LastItem = List.Back();
match LastItem:
Option(out myvalue):
if myvalue == 30:
Fmt::Print("myvalue does equal 30");
Null: panic("List size was 0");
Isso pode ser FUOUND em ucodeide/src/appObject/ecSexample.hpp e ucodeide/src/appObject/test.uc.
use API;//Imgui,Vec2,Time
use ECS;//Component,Entity
$Player[Component]:
float Speed = 1;
|Start[this&]:
entity().position2d() = [2,5];
|Update[this&] -> void:
var& pos = entity().position2d();//get rereference to entity position.
float deltatime = Time::DeltaTime();
if Imgui::KeyDown(ImKey::W):
pos.Y += Speed * deltatime;
if Imgui::KeyDown(ImKey::S):
pos.Y -= Speed * deltatime;
if Imgui::KeyDown(ImKey::A):
pos.X -= Speed * deltatime;
if Imgui::KeyDown(ImKey::D):
pos.X += Speed * deltatime;
# include < UCodeLang/UCodeLang.hpp >
int main ()
{
const char * MyUCode = " |main[] => 1; " ;
UCodeLang::Compiler myCompiler;
auto comilerRet = myCompiler. CompileText (MyUCode);
if (!comilerRet. IsError ())
{
// your ucode was Compiled
UCodeLang::RunTimeLangState State;
UCodeLang::RunTimeLib Lib;
Lib. Init (comilerRet. GetValue (). OutPut . value ()); // initialize RunTimeLib using our Compiled code.
State. AddLib (&Lib); // Add RunTimeLib
State. LinkLibs (); // Link libraries
UCodeLang::Interpreter interpreter;
interpreter. Init (&State);
interpreter. Call (StaticVariablesInitializeFunc); // initialize our Static Variables.
interpreter. Call (ThreadVariablesInitializeFunc); // initialize thread local/Interpreter local Variables.
int Value = interpreter. RCall < int >( " main " ); // Call main
std::cout << " Got Value " << Value;
interpreter. Call (ThreadVariablesUnLoadFunc); // Call Thread local Variables destructors.
interpreter. Call (StaticVariablesUnLoadFunc); // Call Static Variables destructors.
}
else
{
// your code some how failed to compile
}
}O UCodelang depende de Zycore e Zydis por razões de depuração e geração de código x86.
Ambos estão planejados para serem removidos.
Para construir o projeto, basta baixar arquivos ou executar.
git clone https://github.com/LostbBlizzard/UCodeLang.git
cd ./UCodeLang
Depois de obter os arquivos do projeto executados.
InstallTools.bat
./InstallTools.sh
O último passo é unido se você não precisar construir ucodeide.
Próxima execução.
./VS_2019.bat
./VS_2022.bat
./GNU_Make.sh
make
./GNU_Make.sh
make
./XCode.sh
A estrutura do projeto de arquivo está fora assim
/Dependências
/Uc
/Ucapp
/Ucodeapi
/Ucodelang
"O núcleo do UCode-Lang se você estiver usando isso como uma biblioteca, adicione isso ao seu diretório de incluir"
/Dependências
/Ucodeanalyzer
/Ucodelang
/UCODELANGUEGESEVER
/Ucodelanguageseverlib
/Ucodedocumentation
/Ucodeide
/Ucodewebsite
O projeto também tem o menor número possível de dependências, porque deve ser fácil adicionar a quaisquer Pojetos de C ++.
Use a guia Github Problem para bugs. Use as discussões do Github para falar sobre o idioma e os novos recursos e o design do idioma. também mantenha -o civil.
Também não tenha vergonha de criticar como as coisas são implementadas, sei que o código pode ser melhor em lugares.
A crítica construtiva é bem -vinda (não seja muito duro).
Faça perguntas sobre qualquer projeto, já que eu mal documentei nada.
A filial principal para lançamentos e o recurso é onde faço o desenvolvimento real.
A visão final do projeto tem back -end para
UCODEVM (INTERPRETER, JITINTERPRETER, NIVENTINTERPRETER)
C11
WebAssembly
Windows (executável nativo),
Linux (executável nativo),
MacOS (executável nativo),
X86
X86_64
Braço
ARM64
O idioma foi projetado e desenvolvido pela LostBlizzard no Github.
Que atualmente mantém o
O UCodeGameEngine (sendo trabalhado) a principal razão pela qual o idioma foi feito.
P: Ucodelang é muito semelhante ao C ++ e Rust, por que não usar ferrugem ou C ++?
R: C ++ é muito compilado de um idioma e é unanalisível após a compilação (sem hackear o compilador).
P: Por que está escrito em C ++.
R: A maioria dos mecanismos de jogo e, especificamente, meu mecanismo de jogo está escrito em C ++. O C ++ ainda é a melhor ferramenta para criar mecanismos de jogo.
P: Por que não usar o LLVM para o seu back -end.
R: O LLVM é muito grande de dependência e escrever me apoia, me dá uma boa desculpa para aprender sobre computadores (a razão pela qual estou fazendo um mecanismo de jogo). Além disso, basta produzir texto de montagem llvm llvm.
P: Por que espaço branco significativo?
A: Parecia interessante também parece melhor.
P: O que é o recurso Ucodelang Killer.
R: Ucodelang não é a próxima grande coisa, é apenas uma ferramenta feita para o meu caso de uso específico. É um C ++ refinado e otimizado de algumas maneiras.
P: O que o ucode significa?
R: A palavra ucode não significa nada e não tem histórico, apenas um nome que eu compensei para uma ideia de linguagem de programação.
P: Você gosta de C ++?
R: Gosto o suficiente para passar um ano fazendo um novo idioma usando -o, mas não o suficiente para fazer meus usuários para o meu mecanismo de jogo o usarem (desculpe irreal). Embora eu realmente goste de C ++, mas também estou ciente de suas falhas.
P: O que a seguir e quando será o idioma.
R: Quando o repositório é aberto (de preferência em 1/2/2023, o aniversário de um ano para fazer o projeto JIT) a maioria dos recursos seria feito e não planeja realmente adicionar mais, a menos que seja bom demais. Estarei por um ano extra para terminar as outras arquiteturas e back -ends e, de maneira estabitária.
P: Qual é a sua opinião sobre novas linguagens de programação.
R: Quanto mais o Merrier, especialmente para os idiomas de sistemas. Cada idioma experimenta quanto mais experimentamos, melhores idiomas, aprendendo com os erros daí.
