v1.0.4-fix-pack

Novidades desde o Fix Pack 3

• Implementado RawInterrupt para interrupções compactas normalmente escritas em assembly, pois não guarda na pilha os dados para uso de código do HCBasic
• Correções gerais para cenários Multithread
• Implementado Try Catch compatível com Multithread (EM TESTES)

IMPORTANTE: Estou montando as bibliotecas no outro projeto HUSIX, por isso este projeto até a versão 1.1 deve ser atualizado apenas quando houver mudanças na linguagem, e não nas bibliotecas, assim que a biblioteca System e derivadas estiver mais madura no projeto HUSIX migrarei pro DOS(Deixei bem simples de ser feito) e implementarei neste projeto, pois o estado atual para a continuidade do System.Drawing, depende da implementação de alocação de memória e dezenas de melhorias inclusas no Framework do HUSIX, portanto para economizar tempo, estou implementando as bibliotecas lá e copiarei para cá (Adaptando as chamadas pro DOS) assim que estiver pronto o básico.

Para isto devo implementar:

System.Reflection - uma forma de carregar bibliotecas dinamicamente, o que ajudará a criar programas maiores de 64 KiB não precisando embutir todo o código em um único executável
System.Memory - Gerenciador de Alocação de memória

v1.0.3-fix-pack

Novidades desde o Fix Pack 2

• Corrigido as referencias externas, que em alguns cenários poderiam não ser geradas
• Otimizado a geração de código de chamadas a referencias externas

IMPORTANTE: Estou montando as bibliotecas no outro projeto HUSIX, por isso este projeto até a versão 1.1 deve ser atualizado apenas quando houver mudanças na linguagem, e não nas bibliotecas, assim que a biblioteca System e derivadas estiver mais madura no projeto HUSIX migrarei pro DOS(Deixei bem simples de ser feito) e implementarei neste projeto, pois o estado atual para a continuidade do System.Drawing, depende da implementação de alocação de memória e dezenas de melhorias inclusas no Framework do HUSIX, portanto para economizar tempo, estou implementando as bibliotecas lá e copiarei para cá (Adaptando as chamadas pro DOS) assim que estiver pronto o básico.

Para isto devo implementar:

System.Reflection - uma forma de carregar bibliotecas dinamicamente, o que ajudará a criar programas maiores de 64 KiB não precisando embutir todo o código em um único executável
System.Memory - Gerenciador de Alocação de memória

v1.0.2-fix-pack

Diversas melhorias desde o Fix Pack 1

Novidades:

• Implementado forma de Importar e Exportar dinamicamente bibliotecas (Falta implementar o Carregador na System do DOS)
• Melhorias no desempenho da System.Forms
• Otimizações
• Implementação de TextBox (Muito simples ainda)
• Melhoria na navegação entre controles usando TAB
• Implementado ElseIf

Dim a as UInt16
a = 1

If a == 0 Then
    Console.Write "a = 0"
ElseIf a == 1 Then
    Console.Write "a = 1"
ElseIf a == 2 Then
    Console.Write "a = 2"
ElseIf a >= 100 Then
    Console.Write "a >= 100"
Else
    Console.Write "2 > a < 100"
End

IMPORTANTE: Estou montando as bibliotecas no outro projeto HUSIX, por isso este projeto até a versão 1.1 deve ser atualizado apenas quando houver mudanças na linguagem, e não nas bibliotecas, assim que a biblioteca System e derivadas estiver mais madura no projeto HUSIX migrarei pro DOS(Deixei bem simples de ser feito) e implementarei neste projeto, pois o estado atual para a continuidade do System.Drawing, depende da implementação de alocação de memória e dezenas de melhorias inclusas no Framework do HUSIX, portanto para economizar tempo, estou implementando as bibliotecas lá e copiarei para cá (Adaptando as chamadas pro DOS) assim que estiver pronto o básico.

Para isto devo implementar:

• System.Reflection - uma forma de carregar bibliotecas dinamicamente, o que ajudará a criar programas maiores de 64 KiB não precisando embutir todo o código em um único executável
• System.Memory - Gerenciador de Alocação de memória

v1.0.2-beta-2

Mais uma alteração na linguagem disponível!!

Novidades:

• Implementado ElseIf

Dim a as UInt16
a = 1

If a == 0 Then
    Console.Write "a = 0"
ElseIf a == 1 Then
    Console.Write "a = 1"
ElseIf a == 2 Then
    Console.Write "a = 2"
ElseIf a >= 100 Then
    Console.Write "a >= 100"
Else
    Console.Write "2 > a < 100"
End

IMPORTANTE: Estou montando as bibliotecas no outro projeto HUSIX, por isso este projeto até a versão 1.1 deve ser atualizado apenas quando houver mudanças na linguagem, e não nas bibliotecas, assim que a biblioteca System e derivadas estiver mais madura no projeto HUSIX migrarei pro DOS(Deixei bem simples de ser feito) e implementarei neste projeto, pois o estado atual para a continuidade do System.Drawing, depende da implementação de alocação de memória e dezenas de melhorias inclusas no Framework do HUSIX, portanto para economizar tempo, estou implementando as bibliotecas lá e copiarei para cá (Adaptando as chamadas pro DOS) assim que estiver pronto o básico.

Para isto devo implementar:

• System.Reflection - uma forma de carregar bibliotecas dinamicamente, o que ajudará a criar programas maiores de 64 KiB não precisando embutir todo o código em um único executável
• System.Memory - Gerenciador de Alocação de memória

Futuro Próximo (Previsão até o final de Fevereiro)

Devo gerar três rotas para os programadores, que seriam duas versões do HCBasic Framework:

• Usando apenas recursos do DOS, o que limitaria a algo próximo que temos agora, com acesso a arquivos, e alguns recursos da API do MS-DOS

  • Teria acesso a Arquivos, Alocação de Memória, Console e Portas Serial/Paralela, porém sem recursos avançados, como System.Drawing/System.Forms/System.Threads/System.IO.Sockets, e sem carregamento de bibliotecas externas.

• Gerando uma aplicação do Sistema Operacional HUSIX, que permitiria rodar em um ambiente multitarefas e com ambiente gráfico, com vários recursos e APIs próximas do .Net

• Usando o HUSIX Framework encima do DOS, onde de forma transparente ele inicia o Kernel do HUSIX (Uma versão própria para este cenário) por cima do Kernel do DOS, o que abriria acesso a ambas as APIs, pois nesse caso o HUSIX rodaria em sintonia com o DOS como um Ambiente Operacional (Igual a ideia do Windows 1.0, onde o Windows quando embutido na aplicação, funcionava apenas como um Framework, e esta rodava exclusivamente sem o restante das aplicações do sistema operacional)

  Este cenário permite que uma aplicação rode em DOS porém com todos os recursos de uma aplicação do HUSIX

v1.0.2-beta-1

v1.0 - Fix Pack 2 - BETA 1

Esta versão apresenta algumas melhorias mas não pode ser considerada uma versão de produção.

Novidades:

• Implementação de TextBox (Muito simples ainda)
• Melhoria na navegação entre controles usando TAB

v1.0.1-fix-pack

Mais uma versão de produção do compilador, com leve correções de bugs e algumas melhorias.

O executável do compilador se chama hcbasic ou hcbasic.exe dependendo da plataforma.

Por ser distribuido em arquivo .zip, alguns descompactadores podem não definir corretamente a permissão do compilador, o script compilar.sh corrige isso automaticamente quando chamado.

Novidades:

• Corrigido os arquivos compilar.bat/compilar.sh que não usavam o NASM
• Adicionado um exemplo da biblioteca BETA System.Forms para ter uma ideia da evolução do projeto
• Para os usuários ficarem menos perdidos com a quantidade de arquivos distribuidos, foi adicionaro um README.MD informando como rodar
• Quando multiplos ponteiros eram usados em seguida o compilador poderia se perder qual estava ativo no momento

Exemplos inclusos:

• helloworld.hcb - Um exemplo simples de escrita no terminal
• gui.hcb - Exemplo da funcionalidade atual da biblioteca System.Forms (AINDA INCOMPLETA)

Bibliotecas

As bibliotecas usadas pelo compilador ficam no diretorio Plataformas, atualmente é suportado oficialmente pelo compilador apenas DOS 3.0 rodando em 8086 ou superior

v1.0.0-final

Primeira versão oficial do Compilador HCBasic.

A Linguagem HCBasic é uma variação moderna BASIC destinada para retrocomputação, que busca a união do baixo nível que o C/C++ permite, somado com a simplicidade de uma linguagem da família BASIC, inspirado principalmente na sua última interação da linhagem Microsoft, tendo sua estrutura e comandos originados no VisualBASIC.NET

OBS: A Documentação esta desatualizada, faltando alguns recursos novos do compilador e da biblioteca.

Requisitos mínimos dos executáveis gerados:

• IBM PC 5150 ou Compatíveis
• Intel 8088/8086 ou Compatíveis
• MS-DOS 3.0 ou Compatíveis
• 128 KiB de RAM

Novidades desde a última versão:

• Implementado Módulo Stream para facilitar chamada a rotinas da Stream

Dim s as Stream ' Declara uma variavel (Ponteiro) do tipo Stream
s = New         ' Aloca espaço (Temporário na Pilha que deve ser usado apenas dentro da rotina e nas suas sub rotinas chamadas) para a variavel do tipo Stream
Try
    File.Open s, "arquivo"     ' Abre um arquivo ou gera um erro do tipo AccessDeniedError ou NotFoundError
    Stream.Write s, "Teste"   ' Grava na stream um texto
    Stream.Close s     ' Fecha o arquivo
Catch Error
    Console.Write "Deu ruim" ' Caso um dos comandos dentro do try derem erro escreve uma mensagem
End

• Verifica automaticamente uso de variáveis locais não inicializadas, o que poderia gerar erros "misteriosos".

Dim teste as PtrByteArray
teste = 0 ' Tentativa de colocar 0 no destino do ponteiro antes de atribuir o seu destino, gerará um erro de compilação

• Implementado Manipulador de Interrupções com suporte a manipular todos os registradores disponíveis direto da linguagem HCBasic

Imports System

Module Program

Public Sub Main(args as String)
    Dim intPtr as PtrWordArray
    Dim handlerPtr as PtrByteArray
    handlerPtr = AddressOf(Interrupcao)    ' Le o endereço do manipulador de interrupção
    #intPtr = 0
    @intPtr = 0x99 * 4     ' Calcula o endereço na tabela de interrupções do processador intel
    asm "cli"     ' Impede interrupcoes enquanto grava na tabela de interrupcoes
    intPtr = @handlerPtr  ' Grava o Offset do Manipulador
    @intPtr++
    @intPtr++
    intPtr = #handlerPtr   ' Grava o Segment do Manipulador
    asm "sti"     ' Reativa as interrupções
    asm "int 0x99"    ' Chama as interrupções
End


' Não precisa declarar todos os argumentos, na verdade não precisa declarar nenhum se não usar, mas caso declare deve ser feito exatamente na sequencia abaixo, não podendo pular os argumentos que não utiliza e só declarar os que utiliza, por exemplo se usar apenas o AX, deve declarar ele e todos antes dele
' IMPORTANTE: Se alterar qualquer argumento, isso será passado para o respectivo registrador, tome cuidado, por exemplo alterando o SS ou SP para um valor aleatório, a pilha será perdida, e a execução com certeza ira gerar erros inesperados.
Sub Interrupcao(ss as UInt16, sp as UInt16, bp as UInt16, ax as UInt16, bx as UInt16, cx as UInt16, dx as UInt16, ds as UInt16, si as UInt16, es as UInt16, di as UInt16, ip as UInt16, cs as UInt16, flags as UInt16) Handles Interrupt
    Console.WriteLine "Interrupcao numero 0x99 chamada"
End

End

Requisitos mínimos

• Montador NASM
• Windows 7 SP1 com Suporte Extendido OU Superior
• macOS HighSierra ou Superior
• Linux x86-64 OU ARM64 OU ARM32 OU MUSL64

Nos pacotes de distribuição constam as bibliotecas necessárias do DotNET 7.0 para execução.

Biblioteca incluída:

• System: Biblioteca base com suporte a arquivos e strings

Bibliotecas em desenvolvimento (NÃO USAR)

• System.Drawing (BETA): Esta biblioteca está em desenvolvimento, encontrando parcialmente desenvolvida, suportando modos monocromáticos do CGA e VGA, sem suporte a desenho de elipses ainda, e fontes apenas maiúsculas sem acento.
  • Fonte Padrão embutida(ALFA): Contém apenas caracteres numéricos e letras maiúsculas, ainda não implementado acentuação
• System.Forms (ALFA): Esta no inicio de desenvolvimento, e ira mudar muito ainda, não usar

v0.9.10-pre-release

Para que fosse possível fazer a linguagem mais próxima da multitarefa, fiz algumas leves alterações no compilador, no código que verifica a pilha, agora sendo uma função curta da biblioteca ao invés de código gerado diretamente pelo compilador, o que também ajuda a diminuir um pouco o código gerado, agora estou me concentrando a fazer ajustes finos na System.hcb/System.OS.hcb para fechar a versão 1.0.

Novidades:

• Agora pode-se associar variaveis do tipo estrutura a outras diretamente assim copiando seus ponteiros/igualando, igual já era possível nos ponteiros tradicionais, evitando ter que copiar o ponteiro da estrutura para um ponteiro intermediario para assim copiar para outra estrutura.
• Criado a rotina StackCheck na System.OS que é chamada toda vez que se chama uma rotina para verificar se a pilha se mantém dentro do limite

O código do compilador em si não deve ser mais modificado para a versão final, otimizações e novos recursos da linguagem ficarão para a versão 1.1.0, então atualmente estou focando nas bibliotecas, que também não devem receber recursos grandiosos nessa versão limitando a apenas aplicativos de Console, com manipulação de Strings e Arquivos, em paralelo no projeto do sistema operacional HUSIX estou implementando todo o framework próximo ao .Net, como Lists, Threads, uma versão mais completa da Stream, e algo de Reflection para conseguir carregar bibliotecas em tempo de execução, porém como é um framework complexo e uma parte co-depende da outra, preciso terminar praticamente todas ao mesmo tempo para ser útil, e quando estiver pronto farei a migração dessas bibliotecas para o DOS podendo ser usadas diretamente por aplicativos simples.

Projeto do Sistema Operacional HUSIX

v0.9.9-pre-release

Finalmente o Compilador está maduro o suficiente para uso geral, sendo corrigido os ultimos bugs, para que tenha um roadmap mais consistente com versões de produção saindo com mais agilidade, estou colocando com objetivo para liberação da versão 1.0 fazer pequenas melhorias na Biblioteca System como uma melhor Console.ReadLine que hoje está meio limitada, além de que atualizar o manual para todos os novos recursos implementados da 0.9.6 em diante, que estão parcialmente contemplados.

Novidades

• Usando o estilo de eventos do VB.Net implementei um Interrupt Handler, facilitando para o programador trabalhar com interrupções sem ter que mexer diretamente em Assembly
• Correções dos ultimos bugs localizados durante a criação do sistema operacional HUSIX usando este compilador para criação

A API da System desta versão se torna fixa, não havendo mais alterações nos comandos já existentes, apenas expansões com mais bibliotecas e funções.

v0.9.8-pre-release

Terceira versão pre lançamento, com esta versão se corrige alguns bugs no compilador que atingiam cenários especificos de manipulação de ponteiros diretamente dentro de estruturas, além da prototipação da Biblioteca System.Drawing e System.Forms.

Novidades:

• Correção de bugs em ponteiros dentro de estruturas
• Prototipação da System.Drawing suportando VGA e CGA em modos monocromaticos.
• Prototipação da System.Forms suportando fontes personalizadas
• Correções da Realocação dinâmica que estava invertendo a posição dos dados de ponteiros estáticos.