Este é o meu projeto maluco que eu criei após anos sonhando até que as ferramentas de inteligência artificial mostraram a sua utilidade como ferramentas de programação, mas cujo desenvolvimento depende do programador humano e das suas decisões, dado que os erros de design por vezes tem que ser resolvidos pelo intelecto humano.
Este fork do Wine permite usar o código base para correr aplicativos do histórico OS/2 da IBM, cuja história envolve a Microsoft e a IBM na década de 1980, até o famoso divórcio que os separou. Em termos de organização de código verifica-se que a API do Windows NT é literalmente igual (basta mudarem os nomes das funções!) ao OS/2. Quanto Cutler desenvolveu o Windows NT 3.1, o projeto começou como NT OS/2, pois a API de utilizador era derivado do Presentation Manager (o servidor gráfico do OS/2), mas o Kernel foi derivado do MICA, e não dá IBM que era derivado do IBM-DOS e do AIX para criar um sistema operativo de modo protegido. Ainda assim, o nome do kernel do OS/2 foi os2krnl e o NT foi ntoskrnl (a ironia!)
Mas o grande obstáculo para criar o OS/2 sobre o Wine vem logo do passado de 16-bits, porque a IBM queria que o 286 fosse o processador mínimo para o OS/2, enquanto a Microsoft exigia o 386, mas em 1985 ambos tinham razão. O OS/2 eventualmente passaria para o 386 e seguintes numa base de 32-bits, mas com componentes de 16-bit durante o tempo de vida da plataforma (que ficou em estado comatoso em 2000, mas com um uso crítico em sistemas empresariais e industriais que duram até hoje!).
Se no Windows 3.1, os programas eram estritamente lineares, e o modo de emulação básico era o suficiente para os programas de 16-bits correrem no Wine, usando execução direta e manipulação do LDT (os porteiros da memória do processador), no OS/2 1.0 era para esquecer. Os programas de 16-bits eram multithreading e multitasking nativos desde a primeira hora, o que simplesmente faria o sistema Linux fechar os programas por insistirem em usar o obsoleto sistema de memória em segmentos (de até 64 kb) com um mecanismo de ponteiros base com offset (A conversão 16:16 para 32), juntamente com a troca de contexto em programas multithreading que arrebenta com um mecanismo testado com programas do DOS e Windows 3.1, e não OS/2. Embora o multithreading fosse raro na era 16-bits, a Multitasking era mais comum, superando o Windows 3.0 da altura que usa multitarefa cooperativa (cedência voluntária) com a preemptiva (o sistema operativo tomava a dianteira).
Neste campo a única solução realista para o OS/2 1.3 ( a era 16-bits) foi criar um emulador do 286 por interpretação de opcodes (que serviu de ensaio para o uso de IA ser testado), que rapidamente passou para o 287 (o co-procesador matemático), e acabou por emular por software a tabela de descritores (LDT) que o 286 tem direito a 8192, embora 16 sejam historicamente reservados para o sistema operativo (e para o DOS Coffin, o infame modo de emulação do DOS que no 286 só corria um único programa, sem isolamento real e apenas 640 kb!), outros são reservados para as callgates (os ponteiros das funções da API do OS/2), restando uns quantos para os blocos de memória. Assim, um 286 podia alocar 512 MB de RAM virtual, mas evidentemente que havia o limite físico de 16 MB, e os diferentes programas a ocupar espaço. Por outro lado, também foi preciso emular a tabela de excepção do processador (IDT), porque a comunicação entre o 286 e 287 era feita sem a supervisão do Kernel, levando a regressar ao uso de assembly para gerir as interrupções! E nem vale a pena falar dos truques manhosos para emular as instruções de vírgula flutuante usando o 286 com interrupções a rodos, modificação do código e outros horrores que levaram a optar por emular o 287, pois o emulador foi feito para gerir o Ring 3, e não o Ring 0.
Na verdade, o papel do emulador é assim que chama os opcodes de chamada pela callgates, este acaba por consultar a LDT virtual e passar para o endereço virtual do ordinal da função e chamar o código da função do OS/2 implementada sobre o código do Wine. Pretende-se no futuro o suporte de programas de 32-bits, que dispensam o uso do emulador, porque a execução nativa do código é possível num formato de memória moderno (plano ). Aliás, sem o emulador de 16-bits o programa teria sido morto quando fizesse uma interrupção (que em Linux é absolutamente proibido), ou uma chamada de sub-rotina mal preparada que pedia a manipulação do LDT (que é restrita em Linux!)
No presente momento, só executa algum código, porque estou na fase de caça aos bugs que os programas do Arquivo do Hobbes me deram forma de testar. Também o uso do Open Watcom para DOS permite compilar pequenos programas para o OS/2 de 16-bits e 32-bits, usando o DosBox.
Ironicamente o runtime C (a parte de arranque do programa antes de chamar o Main) da Microsoft ainda fez chamada no DosGetVersion, DosGetMachineState, Dos16qhandtype e DosSetVec até ser acabar num General Protection Fault criado pelo INT 13 (decimal) que foi causado pela violação de um endereço de memória inexistente! E o erro foi gerido pelo próprio emulador, como deveria ocorrer!
A seu tempo terá o Presentation Manager e as componentes multimédia, que terá a longa base do Wine, do qual muitas funções serão literalmente de uma linha (ou dez para gerir os casos mais bicudos!).
Embora não seja exequível uma compatibilidade a 100% do antigo software OS/2, pelo menos uma parte o será.
Relativamente ao que está planeado, como o Wine OS/2 senta sobre o Wine, os programas Windows e MS-DOS são geridos pela base do Wine (O OS/2 2.0 e seguintes usavam máquinas virtuais do DOS e Windows 3.1, acabando por ser optimizado no Win-OS/2 no Warp), e assim o tandem que existia no OS/2 já tem uma base intrínseca de graça.
Outra diferença, que imita o antigo subsistema do OS/2 no Windows NT antigo, e a configuração ficar no registo do Wine, em vez dos ficheiros binários OS2.INI e OS2SYS.INI que era o pai do registo do Windows! E devido às raízes históricas, existia um ficheiro de texto designado config.sys lido no arranque. Também fica no Registo do Wine. Embora o config.sys real podia ter 100 linhas ou mais, no Wine OS/2 somente alguns comandos são suportados, outros são opcionais e o resto ignorado mesmo que crie no editor de registo.
Além disso, ainda fiz um desvio para implementar o REXX, que era a linguagem de programação de scripts entranhada no OS/2 de 16-bits e de 32-bits. Mesmo as IA pediam para usar um projeto Open+source do que criar um do nada. O escolhido foi o Regina REXX por ser o mais fiel ao dialecto usado ao longo de toda a história do OS/2. Embora exista uma versão avançada orientada a objectos no Warp 4.x esta era experimental, opcional e incompatível com a norma antiga. Só que foi lançado na altura em que o suporte comercial do OS/2 foi cortado a favor do Linux...
Sem o REXX mais de 60% (ou até mais) do software de 32-bits do OS/2 sequer corria! A compilação criada foi feita com base monolítica e num executável Windows, ficando a ligação com as DLL do OS/2 numa fase posterior.
O projeto utiliza um programa âncora (wineos2) em Windows nativo (como são os programas do Wine internos) que contém o emulador de 16-bits, carrega as DLL híbridos (são programas PE normais como os DLLs do Wine) e lança os programas OS/2 de 16-bits e 32-bits e os DLLs de sub-rotinas e futuramente DLL de 16-bits de sub-rotinas por programas de 32-bits (algo inacreditável mais comum no OS/2), ou servir de apoio ao REXX para carregar o trio REXX.dll, REXXAPI.dll, RXSYSTEM.dll pois os scripts eram no OS/2 um processo similar ao Bash scripts, e no Wine OS/2 lançados pelo REXX.exe.
Resumindo, a parte mais complicada são os alicerces que são a coisa mais estranha da computação, mas o resto é pura tradução de API quase trivial, como se o Windows reencontrava com o antigo irmão gémeo.