1. Куча / Говнокод #25208

    +1

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    18. 18
    19. 19
    20. 20
    21. 21
    22. 22
    23. 23
    24. 24
    25. 25
    26. 26
    27. 27
    28. 28
    29. 29
    30. 30
    31. 31
    32. 32
    33. 33
    34. 34
    35. 35
    36. 36
    37. 37
    38. 38
    39. 39
    40. 40
    41. 41
    42. 42
    43. 43
    44. 44
    45. 45
    46. 46
    47. 47
    48. 48
    49. 49
    50. 50
    51. 51
    52. 52
    53. 53
    54. 54
    55. 55
    56. 56
    57. 57
    58. 58
    59. 59
    60. 60
    61. 61
    62. 62
    63. 63
    64. 64
    65. 65
    66. 66
    67. 67
    68. 68
    69. 69
    70. 70
    71. 71
    72. 72
    73. 73
    74. 74
    75. 75
    76. 76
    77. 77
    78. 78
    79. 79
    80. 80
    81. 81
    82. 82
    83. 83
    84. 84
    85. 85
    86. 86
    87. 87
    88. 88
    89. 89
    90. 90
    91. 91
    92. 92
    93. 93
    94. 94
    95. 95
    96. 96
    ;;; the toplevel operators of each equation in the system
;;; type : array[term]
(defmacro match-acz-state-methods (state__) `(svref ,state__ 0))

;;; functional terms
;;; type : array[term]
(defmacro match-acz-state-lhs-f (state__) `(svref ,state__ 1))

;;; variables on the LHS
;;; type : array[term]
(defmacro match-acz-state-lhs-v (state__) `(svref ,state__ 2))

;;; contants on the RHS
;;; type : array[term]
(defmacro match-acz-state-rhs-c (state__) `(svref ,state__ 3))

;;; functional terms on RHS
;;; type : array[term]
(defmacro match-acz-state-rhs-f (state__) `(svref ,state__ 4))

;;; notes repeated functional terms of LHS
;;; type : array[bool]
(defmacro match-acz-state-lhs-f-r (state__) `(svref ,state__ 5))

;;; notes repeated variables of LHS
;;; type : array[bool]
(defmacro match-acz-state-lhs-v-r (state__) `(svref ,state__ 6))

;;; notes repeated constants of RHS
;;; type : array[bool]
(defmacro match-acz-state-rhs-c-r (state__) `(svref ,state__ 7))

;;; notes repreated funcational terms of RHS
;;; type : array[bool]
(defmacro match-acz-state-rhs-f-r (state__) `(svref ,state__ 8))

;;; variables and funs acocunted for by RHS-c-sol
;;; type : fixnum
(defmacro match-acz-state-lhs-mask (state__)  `(svref ,state__ 9))

;;; funs accounted for by RHS-c-sol
;;; type : fixnum
(defmacro match-acz-state-lhs-f-mask (state__) `(svref ,state__ 10))

;;; bit vector of all repeated (> 0) terms on LHS
(defmacro match-acz-state-lhs-r-mask (state__)  `(svref ,state__ 11))

;;; solution matrix for constants
;;; type : array[fixnum]
(defmacro match-acz-state-rhs-c-sol (state__) `(svref ,state__ 12 ))

;;; max value of elements of RHS-C-sol
;;; type : fixnum
(defmacro match-acz-state-rhs-c-max (state__) `(svref ,state__ 13))

;;; solutions matrix; functional terms
;;; type : array[fixnum]
(defmacro match-acz-state-rhs-f-sol (state__) `(svref ,state__ 14))

;;; max value of elements of RHS-f-sol
;;; type : fixnum
(defmacro match-acz-state-rhs-f-max (state__) `(svref ,state__ 15))

;;; type : fixnum 11111 ... 1111
(defmacro match-acz-state-rhs-full-bits (state__) `(svref ,state__ 16))

;;; array of compatibility bitvectors; constants
;;; type : array[fixnum]
(defmacro match-acz-state-rhs-c-compat (state__) `(svref ,state__ 17))

;;; array of compatibility bitvectors; funcs
;;; type : array[fixnum]
(defmacro match-acz-state-rhs-f-compat (state__) `(svref ,state__ 18))

;;; number of constants on LHS after simplification
;;; type : fixnum
(defmacro match-acz-state-lhs-c-count (state__) `(svref ,state__ 19))

;;; number of functions on LHS after simplification
;;; type : fixnum
(defmacro match-acz-state-lhs-f-count (state__) `(svref ,state__ 20))

;;; number of variables on LHS after simplification
;;; type : fixnum
(defmacro match-acz-state-lhs-v-count (state__) `(svref ,state__ 21))

;;; number of constants on RHS after simplification
;;; type : fixnum
(defmacro match-acz-state-rhs-c-count (state__)  `(svref ,state__ 22))

;;; number of functions on RHS after simplification
;;; type : fixnum
(defmacro match-acz-state-rhs-f-count (state__) `(svref ,state__ 23))

;;; t iff all solutions have been reported.
(defmacro match-acz-state-no-more (state__) `(svref ,state__ 24))

    https://github.com/CafeOBJ/cafeobj/blob/master/chaos/e-match/match-acz.lisp

    ГОМОИКОНЫ копипаст лиспе
    CafeOBJ is a most advanced formal specification language which inherits many advanced features (e.g. flexible mix-fix syntax, powerful and clear typing system with ordered sorts, parameteric modules and views for instantiating the parameters, and module expressions, etc.) from OBJ (or more exactly OBJ3) algebraic specification language.

    CafeOBJ is a language for writing formal (i.e. mathematical) specifications of models for wide varieties of software and systems, and verifying properties of them. CafeOBJ implements equational logic by rewriting and can be used as a powerful interactive theorem proving system. Specifiers can write proof scores also in CafeOBJ and doing proofs by executing the proof scores.

    CafeOBJ has state-of-art rigorous logical semantics based on institutions. The CafeOBJ cube shows the structure of the various logics underlying the combination of the various paradigms implemented by the language. Proof scores in CafeOBJ are also based on institution based rigorous semantics, and can be constructed using a complete set of proof rules

    Запостил: j123123, 20 Декабря 2018

    Комментарии (46) RSS

    • ava j123123 20.12.2018 19:44 # +1 

      ;; and now stuff the state full of information, and return it.
               (setf (match-ACZ-state-methods state) sys-methods)
               (setf (match-ACZ-state-LHS-f state) lhs-f)
               (setf (match-ACZ-state-LHS-v state) lhs-v)
               (setf (match-ACZ-state-RHS-c state) rhs-c)
               (setf (match-ACZ-state-RHS-f state) rhs-f)
               (setf (match-ACZ-state-LHS-f-r state) lhs-f-r)
               (setf (match-ACZ-state-LHS-v-r state) lhs-v-r)
               (setf (match-ACZ-state-RHS-c-r state) rhs-c-r)
               (setf (match-ACZ-state-RHS-f-r state) rhs-f-r)
               ;; (setf (match-ACZ-state-LHS-mask state) 0)
               (setf (match-ACZ-state-LHS-f-mask state) 0)
               (setf (match-ACZ-state-LHS-r-mask state) lhs-r-mask)
               (setf (match-ACZ-state-RHS-c-sol state) rhs-c-sol)
               (setf (match-ACZ-state-RHS-c-max state) rhs-c-max)
               (setf (match-ACZ-state-RHS-f-sol state) rhs-f-sol)
               (setf (match-ACZ-state-RHS-f-max state) rhs-f-max)
               (setf (match-ACZ-state-RHS-full-bits state) rhs-full-bits)
               (setf (match-ACZ-state-RHS-c-compat state) rhs-c-compat)
               (setf (match-ACZ-state-RHS-f-compat state) rhs-f-compat)
               (setf (match-ACZ-state-LHS-c-count state) 0)
               (setf (match-ACZ-state-LHS-f-count state) lhs-f-count)
               (setf (match-ACZ-state-LHS-v-count state) lhs-v-count)
                                        ; off 1+ intentionally 
               (setf (match-ACZ-state-RHS-c-count state) rhs-c-count)
               (setf (match-ACZ-state-RHS-f-count state) rhs-f-count)
               (setf (match-ACZ-state-no-more state) nil)
               (setf (match-ACZ-state-acz-state-p state) 'acz-state)
               ;;
      Ответить

    • ava j123123 20.12.2018 20:06 # 0 

      https://www.preining.info/blog/2018/05/specification-and-verification-of-software-with-cafeobj-part-3-first-steps-with-cafeobj/

      Specification and Verification of Software with CafeOBJ – Part 3 – First steps with CafeOBJ

      > As a challenge the reader might try to give definitions of the factorial function and the Fibonacci function, the next blog will present solutions for it.

      %NAT> op fib : Nat -> Nat .

%NAT> eq fib(0) = 0 .

%NAT> eq fib(1) = 1 .

%NAT> eq fib(A:NzNat) = fib(p A) + fib(p p A) .

%NAT> red fib(10) .
-- reduce in %NAT : (fib(10)):Nat
(55):NzNat
(0.0000 sec for parse, 0.0020 sec for 529 rewrites + 760 matches)

%NAT>
      Ответить

      • ava j123123 20.12.2018 20:10 # 0 

        %NAT> op fact : Nat -> Nat .

%NAT> eq fact(0) = 1 . 

%NAT> eq fact(A:NzNat) = fact(p A) * A .

%NAT> red fact(10) .
-- reduce in %NAT : (fact(10)):Nat
(3628800):NzNat
(0.0000 sec for parse, 0.0000 sec for 30 rewrites + 49 matches)
        Ответить

    • ava crestoblyad 20.12.2018 20:47 # 0

      Делать нехуй?
      Ответить

      • ava j123123 20.12.2018 20:52 # 0

        Крестоблядям не понять
        Ответить

        • ava crestoblyad 20.12.2018 21:04 # 0

          Действительно, ебаться с закорючками то еще веселье. Кресты такая же хуйня.
          Ответить

    • ava yet_another_one_shit 20.12.2018 20:51 # +1

      (Какой ' (LISP ( )))
      Ответить

    • ava yet_another_one_shit 20.12.2018 20:55 # 0

      За S" Forth" я поэтому именно .
      Ответить

    • ava yet_another_one_shit 20.12.2018 20:59 # 0

      Когда языку нужны мокросы это говорит о говнистости языка , S" Forth'у" нинужны никакие мокросы , именно поэтому я за S" Си".
      Ответить

      • ava j123123 20.12.2018 21:07 # 0

        Хочу чтобы был такой язык, суть токова. Код парсился и был как двусвязный список из массивов байт, и в процессе интерпретация этот двусвязный список мог бы самопереписывать себя. Ну типа я напишу
        ( fuck = shit ) asdasd
asdfgh gdfg

        и с точки зрения языка это будет двусвязный список
        START <-> "(" <-> "fuck" <-> "=" <-> "shit" <-> ")" <-> "asdasd" <-> "asdfgh" <-> "gdfg" <-> END

        И чтоб можно было интерпретировать это, элементы в двусвязном списке менять как массивы байт, вставлять новые элементы в двусвязный список и потом интерпретировать свежевставленное на основе каких-то правил, которые могут быть заданы двусвязными списками и которые могут быть сгенерированы в процессе интерпретации двусвязных списков из этой всей питушни. Можно грабить корованы
        Ответить

        • ava zhigolo 20.12.2018 21:58 # 0

          "fuck = shit"

          А нам всё равно — что жопа, что говно.
          Ответить

        • ava 1024-- 20.12.2018 22:23 # 0

          Какая-то это слишком низкоуровневая питушня. Видна тяжёлая рука пердолинга с сишкой, коньпеляторами и ассемблером. Мне кажется, из такого языка выйдет только черепаха гомоиконный брейнфак.
          В программировании уже почти не обойтись без иерархии и циклических ссылок (то есть графов). Сюда надо хотя бы что-то вроде SAX-питушни.

          А вот простой синтаксис для перезаписи деревьев (вроде функций с паттерн матчингом) был бы полезен.
          Ответить

          • ava j123123 20.12.2018 22:48 # 0

            Ну, на основе линейного текста программы (которая прочитается как двусвязный список) можно на основе rewriting rules на этапе интерпретации сгенерить ориентированный граф, и потом уже с ним что-нибудь делать. Двусвязный список это будет просто частный случай этого ориентированного графа, который парсится из текстового файла в самом начале и с которого начинается построение дерева и дальнейшей манипуляции с ним.
            Ответить

            • ava j123123 20.12.2018 23:10 # +1

              Основная идея в том, что синтаксиса как такового у нас нет. Есть просто набор слов (точнее, массивов байт), разделенных пробелами. Если надо в самом слове пробел использовать, можно использовать скобки и сделать что-то вроде
              abc "test test" abc

              А если нужно сами скобки или еще какую-то фигню записать, можно это сделать эскейп-последовательностью
              abc "test \" test \\ test asdgh \" \xFF \x00 test" abc

              Если строка слишком длинная, можно делать так
              abc "very very very very \*"
"very long string" abc

              распознается как
              abc "very very very very very long string" abc

              И можно даже сделать подобие инклуда, типа
              abc "\PC:\somefile.txt" abc
              просто воткнет в один элемент двусвязного списка всё содержимое файла C:\somefile.txt
              Ответить

          • ava bormand 21.12.2018 07:51 # +1

            > синтаксис для перезаписи деревьев
            XSLT
            Ответить

    Добавить комментарий