Como implementar uma avaliação lenta de if ()

No momento, estou implementando um avaliador de expressão (expressões de linha única, como fórmulas) com base no seguinte:

• a expressão inserida é tokenizada para separar booleanos literais, números inteiros, decimais, seqüências de caracteres, funções, identificadores (variáveis)
• Eu implementei o algoritmo Shunting-yard (modificado levemente para lidar com funções com número variável de argumentos) para se livrar dos parênteses e ordenar aos operadores uma precedência decente em uma ordem pós-fixada
• meu pátio de derivação simplesmente produz uma fila (simulada) de tokens (por meio de uma matriz, minha linguagem do Powerbuilder Classic pode definir objetos, mas só possui matrizes dinâmicas como armazenamento nativo - lista não verdadeira, sem dicionário) que avalio sequencialmente com um máquina de pilha simples

Meu avaliador está funcionando bem, mas ainda estou com uma falta if()e estou pensando em como proceder.

Com minha avaliação pós-fixada e baseada em pilha do shunting yard, se eu adicionar if()como outra função partes verdadeiras e falsas, uma única if(true, msgbox("ok"), msgbox("not ok"))exibirá as duas mensagens enquanto eu gostaria de mostrar apenas uma. Isso ocorre porque quando preciso avaliar uma função, todos os seus argumentos já foram avaliados e colocados na pilha.

Você poderia me dar uma maneira de implementar de if()forma preguiçosa?

Pensei em processá-las como uma espécie de macro, mas, no início, ainda não tenho a avaliação da condição. Talvez eu precise usar outro tipo de estrutura que não seja uma fila para manter separadamente a condição e as expressões true / false? Por enquanto, a expressão é analisada antes da avaliação, mas também planejo armazenar a representação intermediária como um tipo de expressão pré-compilada para avaliação futura.

Edit : depois de algum pensamento sobre o problema, acho que poderia criar uma representação em árvore da minha expressão (um AST em vez de um fluxo de token linear), a partir do qual eu poderia facilmente ignorar um ou outro ramo do meu if().

Existem duas opções aqui.

1) Não implemente ifcomo uma função. Torne-o um recurso de linguagem com semântica especial. Fácil de fazer, mas menos "puro" se você quiser que tudo funcione.

2) Implemente a semântica "chamada pelo nome", que é muito mais complicada, mas permite que a mágica do compilador resolva o problema de avaliação preguiçosa, mantendo-a ifcomo uma função em vez de um elemento de linguagem. É assim:

ifé uma função que aceita dois parâmetros, ambos declarados como "por nome". Quando o compilador vê que está passando algo para um parâmetro de nome, ele altera o código a ser gerado. Em vez de avaliar a expressão e transmitir o valor, ele cria um fechamento que avalia a expressão e a passa. E ao invocar um parâmetro de nome dentro da função, o compilador gera código para avaliar o fechamento.

Em vez de a função ter a assinatura:

object if(bool, object, object)

Dê a assinatura:

object if(bool, object function(), object function())

Em seguida, sua iffunção chamará a função apropriada com base na condição, avaliando apenas uma delas.

É bem fácil, se você compilar tudo preguiçosamente. Você deve ter alguns meios para ver se um valor já está avaliado ou se precisa de mais avaliação.

Em seguida, você pode fazer o seguinte: Se for um literal ou variável (você possui esses ?, ou seja, nomes de funções?), Empurre-o na pilha. Se for uma aplicação de uma função, compile-a separadamente e empurre o ponto de entrada na pilha.

A execução de um programa é, então, meramente repetida até que o topo da pilha seja avaliado e não uma função. Se não for avaliado ou uma função, chame o código para o qual a parte superior da pilha aponta.