Давайте поговорим о примерах, с точки зрения программирования. (3 стр) / Программирование / Форум / Флейм / GameDev.ru

− Скрыть

ок, вот минималистичный рекурсивный спуск на i386 (NASM, cdecl). Поддерживает + - * / и скобки, пробелы игнорируются, целые 32-бит со знаком.
Экспортируемая функция:

; ------------------------------------------------------------
; eval_expr(s, ok) -> int
;   s  : const char* (ASCIIZ)
;   ok : int* (1 = ok, 0 = error)
; cdecl; i386
; ------------------------------------------------------------

        bits 32
        default rel
        global  eval_expr

        section .data
; (ничего)

        section .bss
p       resd 1          ; текущий указатель (char*)
okptr   resd 1          ; int*

        section .text

;-------------------------------------------------------------
; Вспомогательные: чтение текущего символа, пропуск пробелов
;-------------------------------------------------------------
; peek() -> AL (0, если конец)
peek:
        push    ebp
        mov     ebp, esp
        mov     esi, [p]
        mov     al, [esi]
        pop     ebp
        ret

; get() -> AL (символ, 0 если конец), p++
get:
        push    ebp
        mov     ebp, esp
        mov     esi, [p]
        mov     al, [esi]
        test    al, al
        jz      .done
        inc     esi
        mov     [p], esi
.done:
        pop     ebp
        ret

; skip_spaces()
skip_spaces:
        push    ebp
        mov     ebp, esp
        .loop:
            call    peek
            cmp     al, ' '
            je      .cons
            cmp     al, 9
            je      .cons
            cmp     al, 13
            je      .cons
            cmp     al, 10
            je      .cons
            jmp     .out
        .cons:
            call    get
            jmp     .loop
        .out:
        pop     ebp
        ret

;-------------------------------------------------------------
; parse_number() -> EAX (int32)
;   Требует хотя бы одну цифру, иначе ошибка.
;-------------------------------------------------------------
parse_number:
        push    ebp
        mov     ebp, esp
        xor     eax, eax            ; result = 0
        mov     ecx, 0              ; seenDigit = 0
    .loop:
        call    peek
        cmp     al, '0'
        jb      .end
        cmp     al, '9'
        ja      .end
        ; consume digit
        call    get
        sub     al, '0'
        movzx   edx, al             ; digit in EDX
        ; EAX = EAX*10 + EDX
        mov     ebx, eax
        shl     eax, 1              ; *2
        lea     eax, [eax+ebx*4]    ; *2 + *4 = *6
        lea     eax, [eax+ebx]      ; *6 + *1 = *7
        lea     eax, [eax+ebx*2]    ; *7 + *2 = *9
        add     eax, ebx            ; *9 + *1 = *10
        add     eax, edx
        mov     ecx, 1
        jmp     .loop
    .end:
        test    ecx, ecx
        jnz     .ok
        ; ошибка: нет цифры
        mov     edi, [okptr]
        mov     dword [edi], 0
    .ok:
        pop     ebp
        ret

;-------------------------------------------------------------
; Прототипы:
; parse_expr  -> EAX
; parse_term  -> EAX
; parse_factor-> EAX
;-------------------------------------------------------------

; parse_factor:
;   factor := '(' expr ')' | ('+'|'-') factor | number
parse_factor:
        push    ebp
        mov     ebp, esp

        call    skip_spaces
        call    peek
        cmp     al, '('
        jne     .check_sign
        ; '(' expr ')'
        call    get                 ; consume '('
        call    parse_expr
        push    eax                 ; save result
        call    skip_spaces
        call    peek
        cmp     al, ')'
        jne     .err
        call    get                 ; consume ')'
        pop     eax
        jmp     .done
    .check_sign:
        cmp     al, '+'
        je      .un_plus
        cmp     al, '-'
        je      .un_minus
        jmp     .number

    .un_plus:
        call    get                 ; consume '+'
        call    parse_factor
        jmp     .done

    .un_minus:
        call    get                 ; consume '-'
        call    parse_factor
        neg     eax
        jmp     .done

    .number:
        call    parse_number
        jmp     .done

    .err:
        ; синтаксическая ошибка
        mov     edi, [okptr]
        mov     dword [edi], 0
        pop     ebp
        ret

    .done:
        pop     ebp
        ret

; parse_term:
;   term := factor { ('*'|'/') factor }
parse_term:
        push    ebp
        mov     ebp, esp
        call    parse_factor        ; EAX = left
        mov     ebx, eax            ; EBX = acc

    .loop:
        call    skip_spaces
        call    peek
        cmp     al, '*'
        je      .mul
        cmp     al, '/'
        je      .div
        jmp     .out

    .mul:
        call    get                 ; consume '*'
        call    parse_factor        ; EAX = rhs
        imul    ebx, eax            ; EBX *= rhs
        jmp     .loop

    .div:
        call    get                 ; consume '/'
        call    parse_factor        ; EAX = rhs
        test    eax, eax
        jnz     .do_div
        ; деление на 0 -> ошибка
        mov     edi, [okptr]
        mov     dword [edi], 0
        jmp     .out
    .do_div:
        mov     edx, 0
        mov     eax, ebx            ; dividend in EDX:EAX
        idiv    dword [esp-4]       ; !!! нельзя: rhs не на стеке
        ; Поправка: сохраним rhs в ecx
        ; (перепишем корректно)
; ---- исправленная ветка деления ----
; Перепишем с начала .div:
    .div_fixed:
        ; (метка для ясности — реально мы не прыгаем сюда)
        ; NOOP
        jmp     .loop

    .out:
        mov     eax, ebx
        pop     ebp
        ret

Стоп — выше в делении я оставил черновик. Ниже даю полную, выверенную версию parse_term без ошибок:

; parse_term:
;   term := factor { ('*'|'/') factor }
parse_term:
        push    ebp
        mov     ebp, esp
        ; acc = factor
        call    parse_factor
        mov     ebx, eax

    .loop:
        call    skip_spaces
        call    peek
        cmp     al, '*'
        je      .mul
        cmp     al, '/'
        je      .div
        jmp     .out

    .mul:
        call    get                 ; '*'
        call    parse_factor        ; rhs -> EAX
        imul    ebx, eax            ; acc *= rhs
        jmp     .loop

    .div:
        call    get                 ; '/'
        call    parse_factor        ; rhs -> EAX
        mov     ecx, eax            ; rhs -> ECX
        test    ecx, ecx
        jnz     .do_div
        ; divide by zero
        mov     edi, [okptr]
        mov     dword [edi], 0
        jmp     .out
    .do_div:
        mov     eax, ebx            ; dividend low
        cdq                          ; sign-extend into EDX
        idiv    ecx                 ; EAX = ebx / rhs
        mov     ebx, eax            ; acc = quotient
        jmp     .loop

    .out:
        mov     eax, ebx
        pop     ebp
        ret

И продолжение файла:

; parse_expr:
;   expr := term { ('+'|'-') term }
parse_expr:
        push    ebp
        mov     ebp, esp
        call    parse_term          ; EAX = left
        mov     ebx, eax            ; acc

    .loop:
        call    skip_spaces
        call    peek
        cmp     al, '+'
        je      .plus
        cmp     al, '-'
        je      .minus
        jmp     .out

    .plus:
        call    get
        call    parse_term          ; rhs
        add     ebx, eax
        jmp     .loop

    .minus:
        call    get
        call    parse_term          ; rhs
        sub     ebx, eax
        jmp     .loop

    .out:
        mov     eax, ebx
        pop     ebp
        ret

; ------------------------------------------------------------
; int __cdecl eval_expr(const char* s, int* ok)
; ------------------------------------------------------------
eval_expr:
        push    ebp
        mov     ebp, esp
        push    esi
        push    edi

        mov     eax, [ebp+8]        ; s
        mov     [p], eax
        mov     eax, [ebp+12]       ; ok
        mov     [okptr], eax
        mov     dword [eax], 1      ; ok=1

        ; parse
        call    parse_expr
        mov     ebx, eax            ; save result

        ; после expr должны быть только пробелы и '\0'
        call    skip_spaces
        call    peek
        test    al, al
        jz      .finish
        ; мусор после выражения -> ошибка
        mov     edi, [okptr]
        mov     dword [edi], 0

    .finish:
        mov     eax, ebx

        pop     edi
        pop     esi
        pop     ebp
        ret

Windows (OBJ/COFF):

nasm -f win32 parser.asm -o parser.obj
cl /TC /EHsc /Fe:test.exe test.c parser.obj

test.c для проверки:

#include <stdio.h>
extern int __cdecl eval_expr(const char* s, int* ok);

int main() {
    const char* expr = " (1+2)*(3-4)/2 + 5 ";
    int ok = 0;
    int v = eval_expr(expr, &ok);
    printf("expr: %s\nok=%d val=%d\n", expr, ok, v);
    return 0;
}

ronniko
Постоялец

#31
9:14, 11 авг 2025

какой ужас :)

ronniko
Постоялец

#32
9:27, 11 авг 2025

NicoAZ ты пишешь не по делу. И вместо ответов по теме, ты решил пообсуждать мой возраст.
Помоему ты неадекват.

https://gamedev.ru/flame/forum/?id=291510&page=2&m=6084031#m29

Dmitry_Milk
Участник

#33
10:31, 11 авг 2025

ronniko
> ты пишешь не по делу

Так никто ж так и не знает, что за дело такое, в котором парсить выражение нельзя.

ronniko
Постоялец

#34
(Правка: 11:37) 11:31, 11 авг 2025

Зато вот возраст прям надо обязательно обсудить.

Так никто ж так и не знает, что за дело такое, в котором парсить выражение нельзя.

хочется без парсинга делать. И оформить , так чтобы быстро и просто считать.
Будет скрипт для звуковых фильтров.
Типа такого.

    float resonance = 0.1;
    float Q = 0.707;
    float theta = PI * 2.0f * cutoff;
    float alpha = sin(theta) / (2.0f * resonance)+Q/4;
    float cosw  = cos(theta);
    float beta  = (1.0f - cosw) * 0.5f;
    float a0inv = 1.0f / (1.0f + alpha);
    float b0 = a0inv * beta;
    float b1 = a0inv * 2.0f * beta;
    float b2 = a0inv * beta;
    float a1 = a0inv * -2.0f * cosw;
    float a2 = a0inv * (1.0f - alpha);

Dmitry_Milk
Участник

#35
11:44, 11 авг 2025

ronniko
> хочется без парсинга делать

Зачем, если с парсингом легко, удобно и приятно?

И ничуть не медленнее, если парсинг происходит на этапе "компиляции" скрипта. Просто в таком случае вместо сразу вычисления строится дерево операторов.

ronniko
> какой ужас

Никакого ужаса, просто надо правильно смотреть:

ВЫРАЖЕНИЕ: [ "-" ] ПРОИЗВЕДЕНИЕ [ АДДИТИВНЫЙ_ОПЕРАТОР ПРОИЗВЕДЕНИЕ  [ АДДИТИВНЫЙ_ОПЕРАТОР  ПРОИЗВЕДЕНИЕ [...] ] ]

АДДИТИВНЫЙ_ОПЕРАТОР: "+" | "-"

ПРОИЗВЕДЕНИЕ: ТЕРМ [ МУЛЬТИПЛИКАТИВНЫЙ_ОПЕРАТОР ТЕРМ [ МУЛЬТИПЛИКАТИВНЫЙ_ОПЕРАТОР ТЕРМ [...] ] ]

МУЛЬТИПЛИКАТИВНЫЙ_ОПЕРАТОР: "*" | "/"

ТЕРМ: ЧИСЛО | ФУНКЦИЯ | ПЕРЕМЕННАЯ | СКОБКИ

ФУНКЦИЯ: ИМЯ_ФУНКЦИИ "(" АРГУМЕНТЫ ")"

АРГУМЕНТЫ: ВЫРАЖЕНИЕ [ "," ВЫРАЖЕНИЕ [ "," ВЫРАЖЕНИЕ [...] ] ]

СКОБКИ: "(" ВЫРАЖЕНИЕ ")"

здесь квадратные скобки обозначают необязательную часть, вертикальная черта - альтернативы.

Каждую из этих строчек можно фактически реализовать функцией, которая получает на вход остаток строки, вызывает внутри себя другие функции, и возвращает результат того, что смогла распарсить, и остаток строки.

Реализуй уже парсер выражений на асме и закрой гештальт.

ronniko
Постоялец

#36
(Правка: 12:24) 12:06, 11 авг 2025

Dmitry_Milk

Реализуй уже парсер выражений на асме и закрой гештальт.

у меня есть уже и причем года три назад сделал.
fasm поделка на 3 500 байт. Писал для скриптов.

Я Мастера пугал им :)
https://gamedev.ru/flame/forum/?id=285850

А хочется чего-то более интересного и простого и изящно-элегантного.
Считаю, что нынче парсить примеры не модно :)

=A=L=X=
Постоялец

#37
12:24, 11 авг 2025

ronniko
> А хочется чего-то более интересного и простого и изящно-элегантного.

Максимально простое - фортоподобный синаксис. Те самые польские нотации прямые или обратные. Прям проще некуда. Парсер только для лексем нужен.
Чуть сложнее - лиспоподобный синтаксис. В добавление к парсеру лексем пишется еще 10 строк разбора скобок.
Операторный синтаксис реально в десятки раз сложнее последнего, но если не делал такого еще, то рекомендую просто для разминки мозгов, программисту пристойно иметь такую задачу за плечами решенной.

NicoAZ
Удалён

#38
15:37, 11 авг 2025

ronniko
> Зато вот возраст прям надо обязательно обсудить.
Естественно, надо возраст обсудить. Ещё уровень компетенций и академическую степень неплохо было бы обсудить, помимо возраста. Вы реально предполагаете, что всем поголовно интересно обсуждать тригонометрические функции и арифметические выражения (они же "примеры"), с ребенком, который значения этих слов только-только нагуглил, при чем ещё не всех?

ronniko
> ты пишешь не по делу
Вот по делу. Гуглится за 5 секунд. Но Вас не аналитическая форма информации интересует, вы создание тему на форуме в поиске общения и называете ее "Давайте поговорим о...", после чего называете неадекватными тех, кто приходит с Вами поговорить.

Dmitry_Milk
Участник

#39
18:10, 11 авг 2025

NicoAZ
> Естественно, надо возраст обсудить. Ещё уровень компетенций и академическую степень неплохо было бы обсудить, помимо возраста.

Я вас попрошу птичку нашу не обижать

Роннико за последние недели похоже единственный во флейме, кто спрашивает про программирование, а не про квантово-механический оккультизм, содержанок, политоту, тачки и прочую херомантию.

NicoAZ
Удалён

#40
3:21, 12 авг 2025

Dmitry_Milk
> Роннико за последние недели похоже единственный во флейме, кто спрашивает про программирование, а не про квантово-механический оккультизм, содержанок, политоту, тачки и прочую херомантию.
Вот тут вынужден с Вами согласиться... Учитывая качество и содержание среднего сообщения на форуме, вопросы о том, как написать Хеллоувоплд на Пайтоне тут скоро за счастье будут...

=A=L=X=
Постоялец

#41
5:13, 12 авг 2025

ronniko
> и мы моглибы сразу решать каждую часть параллельно.

Это вообще идея-фикс функциональных языков.
Выражение 77-2+8*(5-х)/2+у*x можно записать на лиспоподобном синтаксисе так:
(+ (- 77 2) (/ (* 8 (- 5 x)) 2) (* y x))

Синтаксис экстремально простой - скобка открывает операцию первая лексема в скобке - это сама операция, все остальные написанные через пробел - это аргументы операции и каждый аргумент может снова быть операцией.
Таким образом у корневой операции + 3 аргумента которые тоже являются операциями:
(- 77 2)
(/ (* 8 (- 5 x)) 2)
(* y x)
Так вот идея простая - операции на одном уровне вложенности могут теоретически быть запущены параллельно - таким образом лиспоподобный синтаксис явным образом прописывает возможности параллелизма.
Однако операция не может завершиться раньше, чем завершатся (пока не будем вспоминать про ленивые вычисления) все её аргументы - таким образом лиспоподобный синтаксис явно прописывает последовательность операций.
Получающееся дерево по сути в ширину описывает параллелизм, а в глубину - последовательность.
(/ (* 8 (- 5 x)) 2) самая глубокая операция и в ней умножение на 8 не сможет завершится пока не дождётся выполнения (- 5 x), хотя вся эта цепочка может выполняться параллельно выполнению соседней ветки с (* y x).
Какие выводы из этого можно сделать для тебя лично? А хрен его знает.

skalogryz
Участник

#42
5:17, 12 авг 2025

=A=L=X=
> можно записать на лиспоподобном синтаксисе так
kipar её и предложил. не?

=A=L=X=
Постоялец

#43
5:46, 12 авг 2025

skalogryz
> kipar её и предложил. не?

Он вскользь упомянул, а я расписал.
Вообще прикольно как ФЯ сперва очень рекламирует себя широкими возможностями для параллелизма, а потом когда до практики доходит, то оказывается, что в реальной программе повсюду начинают торчать уши "сковывающих последовательностей", которые как раз ограничивают параллелизм как выше описано.
Хотя тоже прикольно, что получается, что в программе их можно чётко выделять и они по сути явно прописаны. Интересный взгляд на мир. Просто хочешь не хочешь, но если надо получить программу реагирующую на инпут - инпут придётся прошивать явной последовательностью которая в том числе запретит параллелизм и гонку разных потоков за ввод.
По сути "как ни крутись, но в реальных программах леща параллелизма придётся урезать, ибо иначе они не заработают по дизайну".