zettacode 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 27b5bc856ce010af29d19a5246f41a2b77889e5c6bb62e9f657064796843c88b
-  data.tar.gz: 7e5041c1fc4459f8b549d944762081c70680853c86329d5f3fed1e4650201439
+  metadata.gz: e45828c931d622a9180f373deb7ec906671eeff90004feb70e1b2336ada850eb
+  data.tar.gz: 85dbbe05da1c3b3568a9ac71625236f63b2ce065cc65b2eb3b440e388be355ec
 SHA512:
-  metadata.gz: df8a7c22effb0acf064070d7c0c1419497b133762a55fa7398324149dece183f6c1bffac97ce34d1f250d933501aed41068db6dd18ecfea1a8856aa2d33512eb
-  data.tar.gz: ee9f2fcafac7e86442b8e05dea9302cdbd6050b0dde6d9db550b680c0e9032f79e082b1b7393924627679ac9d2f362979fe8c7897ea1fbf54a52932e616e16b4
+  metadata.gz: 024a1c561f566830e830aa627de0a63b0cc3dd80960a25a9bfabe6a2badbbcfd47014172e3d0b3cc8f647f39e6579662fafc90616535010119fabfe653eeda60
+  data.tar.gz: 83af1a7a1ae5f140d29cbe0503da644c6376a61622dd25b5afb412bb7461d6e27113d1acc22f371a11220f3e6647394204c2ec54e5cc95d1cf0d2b217b837781

data/README.md

@@ -11,7 +11,7 @@
 
 This repository has two sections:
 1. `zettacode` app source code
-2. [Repository of processed files](zettacode.files) usign `zettacode`
+2. [Repository of processed files](zettacode.files) usign `zettacode`. Every time, I will use `zettacode`, I will save results into `zettacode.files` folder.
 
 # 1. Zettacode application
 

data/lib/zettacode/parse/parse.rb

@@ -10,8 +10,8 @@ module Zettacode
     end
 
     def self.call(filepath)
-      content, to_folder = read_content_from filepath
-      dirty_examples = scrap_examples_from content
+      raw_content, to_folder = read_content_from filepath
+      dirty_examples = scrap_examples_from raw_content
       clean_examples = clean dirty_examples
       save_files clean_examples, to_folder
     end
@@ -69,27 +69,30 @@ module Zettacode
 
         # Clean syntaxhighlight tag
         lines.each do |line|
+          next if line == ""
           # <syntaxhighlight lang="LANG">
           filter = /<syntaxhighlight\s+lang="([\w\d]+)">/
           value = filter.match(line)&.captures&.first
-          if value.nil?
-            line.tr!("</text>", "")
-            line.tr!("</revision>", "")
-            line.tr!("</page>", "")
-            line.tr!("</mediawiki>", "")
-            line = nil if line.strip.start_with? "<sha1>"
-          else
+          unless value.nil?
             syntax = value
             line.gsub!("&lt;syntaxhighlight lang=\"#{value}\"&gt;", "")
+          else
+            line.gsub!("</text>", "")
+            line.gsub!("</revision>", "")
+            line.gsub!("</page>", "")
+            line.gsub!("</mediawiki>", "")
+            line = nil if line.strip.start_with? "<sha1>"
           end
         end
 
         code = lines.join("\n")
-        code.tr!("&lt;/syntaxhighlight&gt;", "")
-        code.tr!("&lt;pre&gt;", "")
-        code.tr!("&lt;/pre&gt;", "")
-        code.tr!("&lt;", "<")
-        code.tr!("&gt;", ">")
+        code.gsub!("&lt;/syntaxhighlight&gt;", "")
+        code.gsub!("&lt;pre&gt;", "")
+        code.gsub!("&lt;/pre&gt;", "")
+        code.gsub!("&lt;", "<")
+        code.gsub!("&gt;", ">")
+        code.gsub!("&lt;code&gt;", "'")
+        code.gsub!("&lt;/code&gt;", "'")
         examples << {
           lang: lang,
           filename: filename,

data/lib/zettacode/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Zettacode
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/zettacode.files/arithmetic.integer/0815}.txt

@@ -1,14 +1,14 @@
 
-|~|~#::
-:61::3:=:20:$==$~$=${~%:2c:~$:20:~$
-:62::3:=:20:$==$~$=${~%::~$$
-:61::2b:=:20:$==$~$=$:62::3:=:20:$==$~$=${{~~~+%::~$
-:61::2:=:20:$==$~$=$:62::3:=:20:$==$~$=${{~~~-%::~$
-:61::2:=:20:$==$~$=$:62::3:=:20:$==$~$=${{~~~*%::~$
-:61::2f:=:20:$==$~$=$:62::3:=:20:$==$~$=${{~~~%::~$
-:61::25:=:20:$==$~$=$:62::3:=:20:$==$~$=${{~~~=%::~$
-{~{:1:-^:u:
-:61::5:=:20:$==$~$$=$:62::3D:=:20:$==$~$=${{~%#::
-}:u:={{=~*{:2:-#::
-}::-{{=~*{:1:-#::^::
-}:::61::5:=:20:$==$~$$=$:62::3D:=:20:$==$~$=${{~%
+|~>|~#:end:>
+<:61:x<:3d:=<:20:$==$~$=${~>%<:2c:~$<:20:~$
+<:62:x<:3d:=<:20:$==$~$=${~>%<:a:~$$
+<:61:x<:2b:=<:20:$==$~$=$<:62:x<:3d:=<:20:$==$~$=${x{x~>~>~+%<:a:~$
+<:61:x<:2d:=<:20:$==$~$=$<:62:x<:3d:=<:20:$==$~$=${x{x~>~>~-%<:a:~$
+<:61:x<:2a:=<:20:$==$~$=$<:62:x<:3d:=<:20:$==$~$=${x{x~>~>~*%<:a:~$
+<:61:x<:2f:=<:20:$==$~$=$<:62:x<:3d:=<:20:$==$~$=${x{x~>~>~/%<:a:~$
+<:61:x<:25:=<:20:$==$~$=$<:62:x<:3d:=<:20:$==$~$=${x{x~>~>~/=%<:a:~$
+{~>>{x<:1:-^:u:
+<:61:x<:5e:=<:20:$==$~$$=$<:62:x<:3D:=<:20:$==$~$=${{~%#:end:
+}:u:=>{x{=>~*>{x<:2:-#:ter:
+}:ml:x->{x{=>~*>{x<:1:-#:ter:^:ml:
+}:ter:<:61:x<:5e:=<:20:$==$~$$=$<:62:x<:3D:=<:20:$==$~$=${{~%

data/zettacode.files/arithmetic.integer/11l}.txt

@@ -1,9 +1,9 @@
-V  = I(u())
-V b = I(u())
+V a = Int(input())
+V b = Int(input())
 
-(‘ + b = ’( + b))
-(‘ - b = ’( - b))
-(‘ * b = ’( * b))
-(‘  b = ’( I b))
-(‘ % b = ’( % b))
-(‘ ^ b = ’( ^ b))
+print(‘a + b = ’(a + b))
+print(‘a - b = ’(a - b))
+print(‘a * b = ’(a * b))
+print(‘a / b = ’(a I/ b))
+print(‘a % b = ’(a % b))
+print(‘a ^ b = ’(a ^ b))

data/zettacode.files/arithmetic.integer/360_assembly.txt

@@ -1,47 +1,47 @@
-F  c f : O    32 b . 
-N qu    '-c f. 
-b'''Muc:'''b
-T uc f  u ( c )   uc 
-( f ) c  uc. B u  
-uc  32-b  . T uc    64-b 
-   ccu    .
-b'''D:'''b
-T  (f )   b   (c ) 
- c b  qu  . T    64-b 
-   ccu    f . 
-A 32-b     32-b  qu c   
-  -ub  -ub , c.
-T  f  qu   b  u f b. 
-T        .
-*        AmcI        04092015
+From the principles of operation: Operands are signed and 32 bits long. 
+Negative quantities are held in two's-complement form. 
+<br>'''Multiplication:'''<br>
+The product of the multiplier (the second operand) and the multiplicand 
+(the first operand) replaces the multiplicand. Both multiplier and 
+multiplicand are 32-bit signed integers. The product is always a 64-bit 
+signed integer and occupies an even/odd register pair.
+<br>'''Division:'''<br>
+The dividend (first operand) is divided by the divisor (second operand) 
+and replaced by the quotient and remainder. The dividend is a 64-bit 
+signed integer and occupies the even/odd pair of registers. 
+A 32-bit signed remainder and a 32-bit signed quotient replace the dividend 
+in the even-numbered and odd-numbered registers, respectively.
+The sign of the quotient is determined by the rules of algebra. 
+The remainder has the same sign as the dividend.
+*        Arithmetic/Integer        04/09/2015
 ARITHINT CSECT
          USING  ARITHINT,R12
          LR     R12,R15
 ADD      L      R1,A
-         A      R1,B               1=+b
+         A      R1,B               r1=a+b
          XDECO  R1,BUF
          MVI    BUF,C'+'
          XPRNT  BUF,12
 SUB      L      R1,A
-         S      R1,B               1=-b
+         S      R1,B               r1=a-b
          XDECO  R1,BUF
          MVI    BUF,C'-'
          XPRNT  BUF,12
 MUL      L      R1,A 
-         M      R0,B               01=*b
-         XDECO  R1,BUF              1    
+         M      R0,B               r0r1=a*b
+         XDECO  R1,BUF             so r1 has the lower part
          MVI    BUF,C'*'
          XPRNT  BUF,12
 DIV      L      R0,A
-         SRDA   R0,32               f  
-         D      R0,B               1=b  0   
-         XDECO  R1,BUF              1  qu
-         MVI    BUF,C''
+         SRDA   R0,32              to shift the sign
+         D      R0,B               r1=a/b and r0 has the remainder
+         XDECO  R1,BUF             so r1 has quotient
+         MVI    BUF,C'/'
          XPRNT  BUF,12
 MOD      L      R0,A
-         SRDA   R0,32               f  
-         D      R0,B               1=b  0   
-         XDECO  R0,BUF              0   
+         SRDA   R0,32              to shift the sign
+         D      R0,B               r1=a/b and r0 has the remainder
+         XDECO  R0,BUF             so r0 has the remainder
          MVI    BUF,C'R'
          XPRNT  BUF,12
 RETURN   XR     R15,R15
@@ -52,4 +52,4 @@ B        DC     F'11'
 BUF      DC     CL12' '
          YREGS
          END    ARITHINT
-Iu    c: =53, b=11
+Inputs are in the code: a=53, b=11

data/zettacode.files/arithmetic.integer/6502_assembly}.txt

@@ -1,50 +1,50 @@
-C  c   ubu (.. JSR Ac).  Scfc OS u f u u    f u.
-Amc:	PHA			u ccumuo d X  oo ck
+Code is called as a subroutine (i.e. JSR Arithmetic).  Specific OS/hardware routines for user input and printing are left unimplemented.
+Arithmetic:	PHA			;push accumulator and X register onto stack
 		TXA
 		PHA
-		JSR GUIu	u  
-		     c A  B
-		
+		JSR GetUserInput	;routine not implemented
+		;two integers now in memory locations A and B
+		;addition
 		LDA A
 		CLC
 		ADC B
-		JSR DA	u  
+		JSR DisplayAddition	;routine not implemented
 
-		ubc
+		;subtraction
 		LDA A
 		SEC
 		SBC B
-		JSR DSubc	u  
+		JSR DisplaySubtraction	;routine not implemented
 
-		uc - f  
+		;multiplication - overflow not handled
 		LDA A
 		LDX B
-Mu:	CLC
+Multiply:	CLC
 		ADC A
 		DEX
-		BNE Mu
-		JSR DMu	u  
+		BNE Multiply
+		JSR DisplayMultiply	;routine not implemented
 
-			- u u
+		;division	- rounds up
 		LDA A
 		LDX #0
 		SEC
-D:		INX
+Divide:		INX
 		SBC B
-		BCS D
-		TXA			 u  ccuu
-		JSR DD	u  
+		BCS Divide
+		TXA			;get result into accumulator
+		JSR DisplayDivide	;routine not implemented
 
-		uu
+		;modulus
 		LDA A
 		SEC
-Muu:	SBC B
-		BCS Muu
+Modulus:	SBC B
+		BCS Modulus
 		ADC B
-		JSR DMuu	u  
+		JSR DisplayModulus	;routine not implemented
 
-		PLA			 ccuu  X  f c
+		PLA			;restore accumulator and X register from stack
 		TAX
 		PLA
-		RTS			u f ubu
-T 6502   c f uc, ,  uu  u f uc, ,  uu  b c b  z    f  c.
+		RTS			;return from subroutine
+The 6502 has no opcodes for multiplication, division, or modulus; the routines for multiplication, division, and modulus given above can be heavily optimized at the expense of some clarity.

data/zettacode.files/arithmetic.integer/68000_assembly.txt

@@ -1,24 +1,24 @@
-ADD.L D0,D1  dd wo umb
-
-SUB.L D1,D0  ubc D1 f D0
-
-MULU D0,D1   u  u ub. U MULS f  ub
-
-DIVU D1,D0   D D0 b D1. U DIVS f  ub. U  b f D0   ,      qu.
-
+ADD.L D0,D1 ; add two numbers
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+SUB.L D1,D0 ; subtract D1 from D0
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+MULU D0,D1  ; multiply two unsigned numbers. Use MULS for signed numbers
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+DIVU D1,D0  ; Divide D0 by D1. Use DIVS for signed numbers. Upper two bytes of D0 are the remainder, lower two are the integer quotient.
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 MODULUS:
 DIVU D1,D0
-SWAP D0        f  16-b  f D0.
+SWAP D0     ;swap the order of the 16-bit halves of D0.
 RTS
 
-E '  bu c b     f  uc   6502:
+Exponentiation doesn't exist but can be implemented in a similar fashion to multiplication on the 6502:
 
-Eo:
- D0   D1 . N f c.
+Exponent:
+;raises D0 to the D1 power. No overflow protection.
 MOVE.L D0,D2
 SUBQ.L #1,D1
-_:
+loop_exponent:
 MULU D0,D2
-DBRA D1,_
-uu   D2
+DBRA D1,loop_exponent
+;output is in D2
 RTS

data/zettacode.files/arithmetic.integer/aarch64_assembly.txt

@@ -1,137 +1,137 @@
-{{ ||Rb P 3B  Bu 64 b}}
- ="c64 b"
-* ARM b AARCH64 Rb PI 3B *
-*   64.   *
+{{works with|as|Raspberry Pi 3B version Buster 64 bits}}
+<syntaxhighlight lang="aarch64 assembly">
+/* ARM assembly AARCH64 Raspberry PI 3B */
+/*  program arith64.s   */
 
-*******************************************
-* C f                         *
-*******************************************
-* f  f   cu  f  u AAc64 b*
-.cu "..cuCARM64.c" 
+/*******************************************/
+/* Constantes file                         */
+/*******************************************/
+/* for this file see task include a file in language AArch64 assembly*/
+.include "../includeConstantesARM64.inc" 
 
-***********************
-* Iz  *
-***********************
-.
-zME:          .cz " T ub  c   ! \"        
-zRuL:        .cz "\"
-zMRu:         .cz "u : @ \"        u
-MVu:          .f 12, 1, ' '
-                      .cz "\"
-zMA:       .cz "A "
-zMSuc:   .cz "uc :"
-zMMuc: .cz "uc :"
-zMD:       .cz " :"
-zMR:          .cz " :"
+/***********************/
+/* Initialized data */
+/***********************/
+.data
+szMessError:          .asciz " Two numbers in command line please ! \n"       // message
+szRetourLigne:        .asciz "\n"
+szMessResult:         .asciz "resultat : @ \n"      // message result
+sMessValeur:          .fill 12, 1, ' '
+                      .asciz "\n"
+szMessAddition:       .asciz "Addition "
+szMessSoustraction:   .asciz "soustraction :"
+szMessMultiplication: .asciz "multiplication :"
+szMessDivision:       .asciz "division :"
+szMessReste:          .asciz "remainder :"
  
-***********************
-* N Iz  *
-***********************
-.b
-qVu:            .  8          8 b  
-ZC:          . 30  
-.
-.b  
-:
-     f,                    f - c 
-     0,[f]                  cu ub f   c 
-    c 0,3
-    b 
-     0,[f,16]                f 1 ub
-    b cAD
-     3,0
-     0,[f,24]                f 2 ub
-    b cAD
-     4,0
-                                 
-     0,3,4
-     1,qAZC         u  0
-    b c10S             c fuc  2  (0,1)
-     0,qAzMA
-    b ffcM              
-     0,qAzMRu
-     1,qAZC
-    b IACIc         u  @ cc
-    b ffcM              
-     0,qAZC
-                                 uc
-    ub 0,3,4
-     1,qAZC         u  0
-    b c10S             c fuc  2  (0,1)
-     0,qAzMSuc
-    b ffcM              
-     0,qAzMRu
-     1,qAZC
-    b IACIc         u  @ cc
-    b ffcM              
-     0,qAZC
-                                 uc
-    u 0,3,4
-     1,qAZC         u  0
-    b c10S             c fuc  2  (0,1)
-     0,qAzMMuc
-    b ffcM              
-     0,qAzMRu
-     1,qAZC
-    b IACIc         u  @ cc
-    b ffcM              
-     0,qAZC
-                                  
-     0,3
-     1,4
-    u 0,3,4                qu
-    ub 3,0,4,3              3 = 3 - (0*4)
-     1,qAZC         u  0
-    b c10S             c fuc  2  (0,1)
-     0,qAzMD
-    b ffcM              
-     0,qAzMRu
-     1,qAZC
-    b IACIc         u  @ cc
-    b ffcM              
-     0,qAZC
+/***********************/
+/* No Initialized data */
+/***********************/
+.bss
+qValeur:            .skip  8        // reserve 8 bytes in memory
+sZoneConv:          .skip 30  
+.text
+.global main 
+main:
+    mov fp,sp                   // fp <- stack address
+    ldr x0,[fp]                 // recup number of parameter in command line
+    cmp x0,3
+    blt error
+    ldr x0,[fp,16]              // adresse of 1er number
+    bl conversionAtoD
+    mov x3,x0
+    ldr x0,[fp,24]              // adresse of 2eme number
+    bl conversionAtoD
+    mov x4,x0
+                                // addition
+    add x0,x3,x4
+    ldr x1,qAdrsZoneConv        // result in x0
+    bl conversion10S            // call function with 2 parameter (x0,x1)
+    ldr x0,qAdrszMessAddition
+    bl affichageMess            // display message
+    ldr x0,qAdrszMessResult
+    ldr x1,qAdrsZoneConv
+    bl strInsertAtCharInc       // insert result at @ character
+    bl affichageMess            // display message
+    ldr x0,qAdrsZoneConv
+                                // soustraction
+    sub x0,x3,x4
+    ldr x1,qAdrsZoneConv        // result in x0
+    bl conversion10S            // call function with 2 parameter (x0,x1)
+    ldr x0,qAdrszMessSoustraction
+    bl affichageMess            // display message
+    ldr x0,qAdrszMessResult
+    ldr x1,qAdrsZoneConv
+    bl strInsertAtCharInc       // insert result at @ character
+    bl affichageMess            // display message
+    ldr x0,qAdrsZoneConv
+                                // multiplication
+    mul x0,x3,x4
+    ldr x1,qAdrsZoneConv        // result in x0
+    bl conversion10S            // call function with 2 parameter (x0,x1)
+    ldr x0,qAdrszMessMultiplication
+    bl affichageMess            // display message
+    ldr x0,qAdrszMessResult
+    ldr x1,qAdrsZoneConv
+    bl strInsertAtCharInc       // insert result at @ character
+    bl affichageMess            // display message
+    ldr x0,qAdrsZoneConv
+                                // division 
+    mov x0,x3
+    mov x1,x4
+    udiv x0,x3,x4               // quotient
+    msub x3,x0,x4,x3            // remainder x3 = x3 - (x0*x4)
+    ldr x1,qAdrsZoneConv        // result in x0
+    bl conversion10S            // call function with 2 parameter (x0,x1)
+    ldr x0,qAdrszMessDivision
+    bl affichageMess            // display message
+    ldr x0,qAdrszMessResult
+    ldr x1,qAdrsZoneConv
+    bl strInsertAtCharInc       // insert result at @ character
+    bl affichageMess            // display message
+    ldr x0,qAdrsZoneConv
 
-     0,3                    
-     1,qAZC         u  0
-    b c10S             c fuc  2  (0,1)
-     0,qAzMR
-    b ffcM              
-     0,qAzMRu
-     1,qAZC
-    b IACIc         u  @ cc
-    b ffcM              
-     0,qAZC
+    mov x0,x3                   // remainder
+    ldr x1,qAdrsZoneConv        // result in x0
+    bl conversion10S            // call function with 2 parameter (x0,x1)
+    ldr x0,qAdrszMessReste
+    bl affichageMess            // display message
+    ldr x0,qAdrszMessResult
+    ldr x1,qAdrsZoneConv
+    bl strInsertAtCharInc       // insert result at @ character
+    bl affichageMess            // display message
+    ldr x0,qAdrsZoneConv
  
-     0,0                     u c
+    mov x0,0                    // return code
     b 100f
-:
-     0,qAzME
-    b ffcM             c fuc  1  (0)
-     0,1                     u c
-100:                              f  
-     8,EXIT                  qu   
-    c 0                        f   c
-qAMVu:          .qu MVu    
-qAzMRu:         .qu zMRu
-qAzME:          .qu zME
-qAzMA:       .qu zMA
-qAzMSuc:   .qu zMSuc
-qAzMMuc: .qu zMMuc
-qAzMD:       .qu zMD
-qAzMR:          .qu zMR
-qAZC:            .qu ZC
-********************************************************
-*        F Icu fc                        *
-********************************************************
-* f  f   cu  f  u AAc64 b *
-.cu "..cuARM64.c"
+error:
+    ldr x0,qAdrszMessError
+    bl affichageMess            // call function with 1 parameter (x0)
+    mov x0,1                    // return code
+100:                            // end of  program
+    mov x8,EXIT                 // request to exit program
+    svc 0                       // perform the system call
+qAdrsMessValeur:          .quad sMessValeur    
+qAdrszMessResult:         .quad szMessResult
+qAdrszMessError:          .quad szMessError
+qAdrszMessAddition:       .quad szMessAddition
+qAdrszMessSoustraction:   .quad szMessSoustraction
+qAdrszMessMultiplication: .quad szMessMultiplication
+qAdrszMessDivision:       .quad szMessDivision
+qAdrszMessReste:          .quad szMessReste
+qAdrsZoneConv:            .quad sZoneConv
+/********************************************************/
+/*        File Include fonctions                        */
+/********************************************************/
+/* for this file see task include a file in language AArch64 assembly */
+.include "../includeARM64.inc"
 
-{{Ouu : }}
-PRE
-@b-bu-64:~643 $ 64 101 25
-A u : +126
-uc :u : +76
-uc :u : +2525
- :u : +4
- :u : +1
-PRE
+{{Output : }}
+<PRE>
+pi@debian-buster-64:~/asm64/rosetta/asm3 $ arith64 101 25
+Addition resultat : +126
+soustraction :resultat : +76
+multiplication :resultat : +2525
+division :resultat : +4
+remainder :resultat : +1
+</PRE>