04-04-2025, 09:28 PM
It took some effort to get this translated and pieced together, and don't expect it to run, but I think this version contains the whole thing, ie all the logic.
I can't say when (or if) I'll get this working so here you go, tinkerers, geniuses, crazy BASIC programmers... have at it!
I can't say when (or if) I'll get this working so here you go, tinkerers, geniuses, crazy BASIC programmers... have at it!
Code: (Select All)
' ################################################################################################################################################################
' SAM "SOFTWARE AUTOMATIC MOUTH"
' A native speech synthesizer for QB64PE
' version 0.0.1
' Translated by from C to QB64, from Sebastian Macke's version at:
'
' Software Automatic Mouth - Tiny Speech Synthesizer
' https://github.com/bit-hack/SAM/tree/master
' TO DO:
' * Initial translation was done by free ai, so lots of errors and bugs to fix!
' * Replace sound generation code with QB64PE sound commands
' * Get it working (TBD?)
' ################################################################################################################################################################
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' FROM sam.c
'Declare arrays - Need to determine actual sizes from original C code or context
CONST max_phonemes = 256 ' Example size, adjust as needed
DIM input AS UBYTE ' Assuming input is a byte array
REDIM phonemeIndex(max_phonemes) AS UBYTE
REDIM stress(max_phonemes) AS UBYTE
REDIM phonemeLength(max_phonemes) AS INTEGER ' Assuming phonemeLength holds integers
REDIM signInputTable1(81) AS UBYTE ' Example size from C code
REDIM signInputTable2(81) AS UBYTE ' Example size from C code
REDIM phonemeLengthTable() AS INTEGER ' Size needed
REDIM phonemeStressedLengthTable() AS INTEGER ' Size needed
REDIM flags() AS INTEGER ' Size needed
REDIM stressInputTable(9) AS UBYTE ' Example size from C code
' Global variables (equivalent to C globals)
DIM X AS INTEGER
DIM A AS UBYTE
DIM Y AS INTEGER
'Header inclusions - QB64 doesn't use C's #include, so we replace with DECLARE for external procedures (if any)
'Note: We don't have the content of "debug.h", "sam.h", "render.h", "sam_tabs.h", so we'll assume empty for now.
'If those files contain actual QB64 or QuickBASIC code, you'd need to include that as well.
'Variable Declarations
DIM input AS _BYTE ' [256] 'int8_t becomes _BYTE in QB64
DIM speed AS _BYTE 'uint8_t becomes _BYTE
DIM pitch AS _BYTE 'uint8_t becomes _BYTE
DIM mouth AS _BYTE 'uint8_t becomes _BYTE
DIM throat AS _BYTE 'uint8_t becomes _BYTE
DIM singmode AS _INTEGER 'int32_t becomes _INTEGER
'External variable - Needs DECLARE if it's in another module
'DECLARE debug AS _INTEGER
DIM mem39 AS _BYTE
DIM mem44 AS _BYTE
DIM mem47 AS _BYTE
DIM mem49 AS _BYTE 'uint8_t to _BYTE
DIM mem50 AS _BYTE
DIM mem51 AS _BYTE
DIM mem53 AS _BYTE
DIM mem56 AS _BYTE 'uint8_t to _BYTE
mem59 AS _BYTE 'uint8_t to _BYTE
A AS _BYTE
X AS _BYTE
Y AS _BYTE
DIM stress AS _BYTE ' [256] 'uint8_t to _BYTE
DIM phonemeLength AS _BYTE ' [256] 'uint8_t to _BYTE
DIM phonemeIndex AS _BYTE ' [256] 'uint8_t to _BYTE
DIM phonemeIndexOutput AS _BYTE ' [60] 'uint8_t to _BYTE
DIM stressOutput AS _BYTE ' [60] 'uint8_t to _BYTE
DIM phonemeLengthOutput AS _BYTE ' [60] 'uint8_t to _BYTE
'Final sound buffer
DIM bufferPos AS _INTEGER 'int32_t to _INTEGER
DIM buffer AS _BYTE PTR 'int8_t* to _BYTE PTR (pointer)
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' FROM debug.h
DIM SHARED debug AS INTEGER ' int32_t becomes INTEGER in QB64
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' FROM render.c
Dim mem48 As _Byte
Dim phase1 As _Byte
Dim mem49 As _Byte
Dim A As Integer
Dim X As Integer
Dim Y As Integer
REDim pitches(255) As _Byte ' Assuming a maximum size of 255 for pitches
REDim freq1data(53) As _Byte
REDIM freq2data(53) As _Byte
REDim mouthFormants5_29(29) As _Byte
REDim throatFormants5_29(29) As _Byte
REDim mouthFormants48_53(5) As _Byte
REDim throatFormants48_53(5) As _Byte
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' FROM reciter_tabs.h
REDim tab36376(0 To 288) As _Unsigned _Byte
REDim rules(0 To 150) As String
REDIM tab48426(4) AS _BYTE ' Equivalent to uint8_t[5] [cite: 1]
REDIM tab47492() AS _BYTE ' Equivalent to uint8_t[] [cite: 2]
REDIM amplitudeRescale() AS _BYTE ' Equivalent to uint8_t[] [cite: 3]
REDIM blendRank() AS _BYTE ' Equivalent to uint8_t[] [cite: 4]
REDIM outBlendLength(95) AS UBYTE
REDIM inBlendLength(95) AS UBYTE
REDIM sampledConsonantFlags(79) AS UBYTE
REDIM freq1data(71) AS UBYTE
REDIM freq2data(79) AS UBYTE
REDIM freq3data(62) AS UBYTE
REDIM ampl1data(78) AS _BYTE
REDIM ampl2data(78) AS _BYTE
REDIM ampl3data(78) AS _BYTE
REDIM sinus(180) AS UBYTE
REDIM rectangle(143) AS UBYTE
REDIM multtable(255) AS _BYTE ' QB64 uses byte for unsigned 8-bit
REDIM sampleTable(0 To 1279) AS _BYTE '0x500 = 1280
REDim rule_tab(0 to 27) as integer
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' FROM: sam_tabs.h
DIM stressInputTable AS STRING * 9 ' Fixed-length string to hold the characters
DIM signInputTable1 AS STRING * 89
DIM signInputTable2 AS STRING * 55
REDIM flags(0 TO 66) AS UBYTE
REDIM flags2(0 TO 61) AS UBYTE
REDIM phonemeStressedLengthTable(0 TO 61) AS UBYTE
REDIM phonemeLengthTable(0 TO 61) AS UBYTE
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' BEGIN reciter_tabs.h
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' Some flags
'
' 0x01 numeric
' 0x02 rule set 2
' 0x04 D J L N
' 0x08 B D G J L M N R V W Z
' 0x10 C G J S X Z R S T Z
' 0x20 B C D F G H J K L M N P Q R S T V X Y Z
' 0x40 is vowel + Y
' 0x80 alpha or '
' Not sure this was converted right,
' the values assigned to array tab36376()
' in the original C code are below,
' not sure what notation that is
' or what the equivalent in QB64 should be?
' Value | ASCII character
' ------------------------------------ | ---------------
' 0 | (none?)
' 0 | (none?)
' 0 | (none?)
' 0 | (none?)
' 0 | (none?)
' 0 | (none?)
' 0 | (none?)
' 0 | (none?)
' 0 | (none?)
' 0 | (none?)
' 0 | (none?)
' 0 | (none?)
' 0 | (none?)
' 0 | (none?)
' 0 | (none?)
' 0 | (none?)
' 0 | (none?)
' 0 | (none?)
' 0 | (none?)
' 0 | (none?)
' 0 | (none?)
' 0 | (none?)
' 0 | (none?)
' 0 | (none?)
' 0 | (none?)
' 0 | (none?)
' 0 | (none?)
' 0 | (none?)
' 0 | (none?)
' 0 | (none?)
' 0 | (none?)
' 0 | (none?)
' 0 | (space char)
' 0 | 0x02 | !
' 0 | 0x02 | "
' 0 | 0x02 | #
' 0 | 0x02 | $
' 0 | 0x02 | %
' 0 | 0x02 | &
' 0 | 0x80 | 0x02 | '
' 0 | (
' 0 | )
' 0 | 0x02 | *
' 0 | 0x02 | +
' 0 | 0x02 | ,
' 0 | 0x02 | -
' 0 | 0x02 | .
' 0 | 0x02 | /
' 0 | 0x02 | 0x01 | 0
' 0 | 0x02 | 0x01 | 1
' 0 | 0x02 | 0x01 | 2
' 0 | 0x02 | 0x01 | 3
' 0 | 0x02 | 0x01 | 4
' 0 | 0x02 | 0x01 | 5
' 0 | 0x02 | 0x01 | 6
' 0 | 0x02 | 0x01 | 7
' 0 | 0x02 | 0x01 | 8
' 0 | 0x02 | 0x01 | 9
' 0 | 0x02 | :
' 0 | 0x02 | ;
' 0 | 0x02 | <
' 0 | 0x02 | =
' 0 | 0x02 | >
' 0 | 0x02 | ?
' 0 | 0x02 | @
' 0 | 0x80 | 0x40 | A
' 0 | 0x80 | 0x20 | 0x08 | B
' 0 | 0x80 | 0x20 | 0x10 | C
' 0 | 0x80 | 0x20 | 0x08 | 0x04 | D
' 0 | 0x80 | 0x40 | E
' 0 | 0x80 | 0x20 | F
' 0 | 0x80 | 0x20 | 0x10 | 0x08 | G
' 0 | 0x80 | 0x20 | H
' 0 | 0x80 | 0x40 | I
' 0 | 0x80 | 0x20 | 0x10 | 0x08 | 0x04 | J
' 0 | 0x80 | 0x20 | K
' 0 | 0x80 | 0x20 | 0x08 | 0x04 | L
' 0 | 0x80 | 0x20 | 0x08 | M
' 0 | 0x80 | 0x20 | 0x08 | 0x04 | N
' 0 | 0x80 | 0x40 | O
' 0 | 0x80 | 0x20 | P
' 0 | 0x80 | 0x20 | Q
' 0 | 0x80 | 0x20 | 0x08 | 0x04 | R
' 0 | 0x80 | 0x20 | 0x10 | 0x04 | S
' 0 | 0x80 | 0x20 | 0x04 | T
' 0 | 0x80 | 0x40 | U
' 0 | 0x80 | 0x20 | 0x08 | V
' 0 | 0x80 | 0x20 | 0x08 | W
' 0 | 0x80 | 0x20 | 0x10 | X
' 0 | 0x80 | 0x40 | Y
' 0 | 0x80 | 0x20 | 0x10 | 0x08 | 0x04 | Z
' 0 | [
' 0 | \
' 0 | ]
' 0 | 0x02 | ^
' 0 | _
' 0 | 0x20 | 0x02 | `
Data 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
Data 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 130, 0, 0, 2, 0, 2, 0
Data 2, 0, 2, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0
Data 130, 64, 130, 32, 8, 130, 32, 16, 130, 32, 8, 4, 130, 64, 130, 32, 130
Data 32, 16, 8, 130, 64, 130, 32, 8, 4, 130, 64, 130, 32, 16, 8, 4, 130, 32, 4
Data 130, 32, 8, 130, 32, 8, 4, 130, 64, 130, 32, 130, 32, 4, 130, 32, 8, 4
Data 130, 32, 16, 4, 130, 64, 130, 32, 130, 32, 8, 130, 32, 8, 130, 32, 4, 130
Data 64, 130, 32, 8, 4, 130, 32, 16, 4, 130, 64, 130, 32, 16, 8, 4, 130, 64, 130
Data 32, 8, 4, 130, 32, 4, 130, 64, 130, 32, 8, 130, 32, 8, 130, 32, 16, 130, 64
Data 130, 32, 16, 8, 4, 130, 64, 130, 32, 16, 8, 4, 130, 32, 4, 130, 64, 130, 32
Data 8, 130, 32, 8, 130, 32, 16, 130, 64, 130, 32, 16, 8, 4, 130, 0, 0, 0, 2, 0
Data 32, 2
REDim tab36376() As _Unsigned _Byte
For i = 0 To 288
redim _preserve tab36376( ubound(tab36376)+1 )
Read tab36376(i)
Next i
REDim rules(0 To 150) As String
rules(0) = "]\xc1" ' "]A"
rules(1) = " (A.)=EH4Y.\xa0" ' " (A.)=EH4Y. "
rules(2) = "(A) =A\xc8" ' "(A) =AH"
rules(3) = " (ARE) =AA\xd2" ' " (ARE) =AAR"
rules(4) = " (AR)O=AX\xd2" ' " (AR)O=AXR"
rules(5) = "(AR)#=EH4\xd2" ' "(AR)#=EH4R"
rules(6) = " ^(AS)#=EY4\xd3" ' " ^(AS)#=EY4S"
rules(7) = "(A)WA=A\xd8" ' "(A)WA=AX"
rules(8) = "(AW)=AO\xb5" ' "(AW)=AO5"
rules(9) = " :(ANY)=EH4NI\xd9" ' " :(ANY)=EH4NIY"
rules(10) = "(A)^+#=EY\xb5" ' "(A)^+#=EY5"
rules(11) = "#:(ALLY)=ULI\xd9" ' "#:(ALLY)=ULIY"
rules(12) = " (AL)#=U\xcc" ' " (AL)#=UL"
rules(13) = "(AGAIN)=AXGEH4\xce" ' "(AGAIN)=AXGEH4N"
rules(14) = "#:(AG)E=IH\xca" ' "#:(AG)E=IHJ"
rules(15) = "(A)^%=E\xd9" ' "(A)^%=EY"
rules(16) = "(A)^+:#=A\xc5" ' "(A)^+:#=AE"
rules(17) = " :(A)^+ =EY\xb4" ' " :(A)^+ =EY4"
rules(18) = " (ARR)=AX\xd2" ' " (ARR)=AXR"
rules(19) = "(ARR)=AE4\xd2" ' "(ARR)=AE4R"
rules(20) = " ^(AR) =AA5\xd2" ' " ^(AR) =AA5R"
rules(21) = "(AR)=AA5\xd2" ' "(AR)=AA5R"
rules(22) = "(AIR)=EH4\xd2" ' "(AIR)=EH4R"
rules(23) = "(AI)=EY\xb4" ' "(AI)=EY4"
rules(24) = "(AY)=EY\xb5" ' "(AY)=EY5"
rules(25) = "(AU)=AO\xb4" ' "(AU)=AO4"
rules(26) = "#:(AL) =U\xcc" ' "#:(AL) =UL"
rules(27) = "#:(ALS) =UL\xda" ' "#:(ALS) =ULZ"
rules(28) = "(ALK)=AO4\xcb" ' "(ALK)=AO4K"
rules(29) = "(AL)^=AO\xcc" ' "(AL)^=AOL"
rules(30) = " :(ABLE)=EY4BU\xcc" ' " :(ABLE)=EY4BUL"
rules(31) = "(ABLE)=AXBU\xcc" ' "(ABLE)=AXBUL"
rules(32) = "(A)VO=EY\xb4" ' "(A)VO=EY4"
rules(33) = "(ANG)+=EY4N\xca" ' "(ANG)+=EY4NJ"
rules(34) = "(ATARI)=AHTAA4RI\xd9" ' "(ATARI)=AHTAA4RIY"
rules(35) = "(A)TOM=A\xc5" ' "(A)TOM=AE"
rules(36) = "(A)TTI=A\xc5" ' "(A)TTI=AE"
rules(37) = " (AT) =AE\xd4" ' " (AT) =AET"
rules(38) = " (A)T=A\xc8" ' " (A)T=AH"
rules(39) = "(A)=A\xc5" ' "(A)=AE"
rules(40) = "]\xc2" ' "]B"
rules(41) = " (B) =BIY\xb4" ' " (B) =BIY4"
rules(42) = " (BE)^#=BI\xc8" ' " (BE)^#=BIH"
rules(43) = "(BEING)=BIY4IHN\xd8" ' "(BEING)=BIY4IHNX"
rules(44) = " (BOTH) =BOW4T\xc8" ' " (BOTH) =BOW4TH"
rules(45) = " (BUS)#=BIH4\xda" ' " (BUS)#=BIH4Z"
rules(46) = "(BREAK)=BREY5\xcb" ' "(BREAK)=BREY5K"
rules(47) = "(BUIL)=BIH4\xcc" ' "(BUIL)=BIH4L"
rules(48) = "(B)=\xc2" ' "(B)=B"
rules(49) = "]\xc3" ' "]C"
rules(50) = " (C) =SIY\xb4" ' " (C) =SIY4"
rules(51) = " (CH)^=\xcb" ' " (CH)^=K"
rules(52) = "^E(CH)=\xcb" ' "^E(CH)=K"
rules(53) = "(CHA)R#=KEH\xb5" ' "(CHA)R#=KEH5"
rules(54) = "(CH)=C\xc8" ' "(CH)=CH"
rules(55) = " S(CI)#=SAY\xb4" ' " S(CI)#=SAY4"
rules(56) = "(CI)A=S\xc8" ' "(CI)A=SH"
rules(57) = "(CI)O=S\xc8" ' "(CI)O=SH"
rules(58) = "(CI)EN=S\xc8" ' "(CI)EN=SH"
rules(59) = "(CITY)=SIHTI\xd9" ' "(CITY)=SIHTIY"
rules(60) = "(C)+=\xd3" ' "(C)+=S"
rules(61) = "(CK)=\xcb" ' "(CK)=K"
rules(62) = "(COMMODORE)=KAA4MAHDOH\xd2" ' "(COMMODORE)=KAA4MAHDOHR"
rules(63) = "(COM)=KAH\xcd" ' "(COM)=KAHM"
rules(64) = "(CUIT)=KIH\xd4" ' "(CUIT)=KIHT"
rules(65) = "(CREA)=KRIYE\xd9" ' "(CREA)=KRIYEY"
rules(66) = "(C)=\xcb" ' "(C)=K"
rules(67) = "]\xc4" ' "]D"
rules(68) = " (D) =DIY\xb4" ' " (D) =DIY4"
rules(69) = " (DR.) =DAA4KTE\xd2" ' " (DR.) =DAA4KTER"
rules(70) = "#:(DED) =DIH\xc4" ' "#:(DED) =DIHD"
rules(71) = ".E(D) =\xc4" ' ".E(D) =D"
rules(72) = "#:^E(D) =\xd4" ' "#:^E(D) =T"
rules(73) = " (DE)^#=DI\xc8" ' " (DE)^#=DIH"
rules(74) = " (DO) =DU\xd7" ' " (DO) =DUW"
rules(75) = " (DOES)=DAH\xda" ' " (DOES)=DAHZ"
rules(76) = "(DONE) =DAH5\xce" ' "(DONE) =DAH5N"
rules(77) = "(DOING)=DUW4IHN\xd8" ' "(DOING)=DUW4IHNX"
rules(78) = " (DOW)=DA\xd7" ' " (DOW)=DAW"
rules(79) = "#(DU)A=JU\xd7" ' "#(DU)A=JUW"
rules(80) = "#(DU)^#=JA\xd8" ' "#(DU)^#=JAX"
rules(81) = "(D)=\xc4" ' "(D)=D"
rules(82) = "]\xc5" ' "]E"
rules(83) = " (E) =IYIY\xb4" ' " (E) =IYIY4"
rules(84) = "#:(E) \xbd" ' "#:(E) ="
rules(85) = "\\':^(E) \xbd" ' "\\':^(E) ="
rules(86) = " :(E) =I\xd9" ' " :(E) =IY"
rules(87) = "#(ED) =\xc4" ' "#(ED) =D"
rules(88) = "#:(E)D \xbd" ' "#:(E)D ="
rules(89) = "(EV)ER=EH4\xd6" ' "(EV)ER=EH4V"
rules(90) = "(E)^%=IY\xb4" ' "(E)^%=IY4"
rules(91) = "(ERI)#=IY4RI\xd9" ' "(ERI)#=IY4RIY"
rules(92) = "(ERI)=EH4RI\xc8" ' "(ERI)=EH4RIH"
rules(93) = "#:(ER)#=E\xd2" ' "#:(ER)#=ER"
rules(94) = "(ERROR)=EH4ROH\xd2" ' "(ERROR)=EH4ROHR"
rules(95) = "(ERASE)=IHREY5\xd3" ' "(ERASE)=IHREY5S"
rules(96) = "(ER)#=EH\xd2" ' "(ER)#=EHR"
rules(97) = "(ER)=E\xd2" ' "(ER)=ER"
rules(98) = " (EVEN)=IYVEH\xce" ' " (EVEN)=IYVEHN"
rules(99) = "#:(E)W\xbd" ' "#:(E)W="
rules(100) = "@(EW)=U\xd7" ' "@(EW)=UW"
rules(101) = "(EW)=YU\xd7" ' "(EW)=YUW"
rules(102) = "(E)O=I\xd9" ' "(E)O=IY"
rules(103) = "#:&(ES) =IH\xda" ' "#:&(ES) =IHZ"
rules(104) = "#:(E)S \xbd" ' "#:(E)S ="
rules(105) = "#:(ELY) =LI\xd9" ' "#:(ELY) =LIY"
rules(106) = "#:(EMENT)=MEHN\xd4" ' "#:(EMENT)=MEHNT"
rules(107) = "(EFUL)=FUH\xcc" ' "(EFUL)=FUHL"
rules(108) = "(EE)=IY\xb4" ' "(EE)=IY4"
rules(109) = "(EARN)=ER5\xce" ' "(EARN)=ER5N"
rules(110) = " (EAR)^=ER\xb5" ' " (EAR)^=ER5"
rules(111) = "(EAD)=EH\xc4" ' "(EAD)=EHD"
rules(112) = "#:(EA) =IYA\xd8" ' "#:(EA) =IYAX"
rules(113) = "(EA)SU=EH\xb5" ' "(EA)SU=EH5"
rules(114) = "(EA)=IY\xb5" ' "(EA)=IY5"
rules(115) = "(EIGH)=EY\xb4" ' "(EIGH)=EY4"
rules(116) = "(EI)=IY\xb4" ' "(EI)=IY4"
rules(117) = " (EYE)=AY\xb4" ' " (EYE)=AY4"
rules(118) = "(EY)=I\xd9" ' "(EY)=IY"
rules(119) = "(EU)=YUW\xb5" ' "(EU)=YUW5"
rules(120) = "(EQUAL)=IY4KWU\xcc" ' "(EQUAL)=IY4KWUL"
rules(121) = "(E)=E\xc8" ' "(E)=EH"
rules(122) = "]\xc6" ' "]F"
rules(123) = " (F) =EH4\xc6" ' " (F) =EH4F"
rules(124) = "(FUL)=FUH\xcc" ' "(FUL)=FUHL"
rules(125) = "(FRIEND)=FREH5N\xc4" ' "(FRIEND)=FREH5ND"
rules(126) = "(FATHER)=FAA4DHE\xd2" ' "(FATHER)=FAA4DHER"
rules(127) = "(F)F\xbd" ' "(F)F="
rules(128) = "(F)=\xc6" ' "(F)=F"
rules(129) = "]\xc7" ' "]G"
rules(130) = " (G) =JIY\xb4" ' " (G) =JIY4"
rules(131) = "(GIV)=GIH5\xd6" ' "(GIV)=GIH5V"
rules(132) = " (G)I^=\xc7" ' " (G)I^=G"
rules(133) = "(GE)T=GEH\xb5" ' "(GE)T=GEH5"
rules(134) = "SU(GGES)=GJEH4\xd3" ' "SU(GGES)=GJEH4S"
rules(135) = "(GG)=\xc7" ' "(GG)=G"
rules(136) = " B#(G)=\xc7" ' " B#(G)=G"
rules(137) = "(G)+=\xca" ' "(G)+=J"
rules(138) = "(GREAT)=GREY4\xd4" ' "(GREAT)=GREY4T"
rules(139) = "(GON)E=GAO5\xce" ' "(GON)E=GAO5N"
rules(140) = "#(GH)\xbd" ' "#(GH)="
rules(141) = " (GN)=\xce" ' " (GN)=N"
rules(142) = "(G)=\xc7" ' "(G)=G"
rules(143) = "]\xc8" ' "]H"
rules(144) = " (H) =EY4C\xc8" ' " (H) =EY4CH"
rules(145) = " (HAV)=/HAE6\xd6" ' " (HAV)=/HAE6V"
rules(146) = " (HERE)=/HIY\xd2" ' " (HERE)=/HIYR"
rules(147) = " (HOUR)=AW5E\xd2" ' " (HOUR)=AW5ER"
rules(148) = "(HOW)=/HA\xd7" ' "(HOW)=/HAW"
rules(149) = "(H)#=/\xc8" ' "(H)#=/H"
rules(150) = "(H)\xbd" ' "(H)="
rules(151) = "]\xc9" ' "]I"
rules(152) = " (IN)=IH\xce" ' " (IN)=IHN"
rules(153) = " (I) =AY\xb4" ' " (I) =AY4"
rules(154) = "(I) =A\xd9" ' "(I) =AY"
rules(155) = "(IN)D=AY5\xce" ' "(IN)D=AY5N"
rules(156) = "SEM(I)=I\xd9" ' "SEM(I)=IY"
rules(157) = " ANT(I)=A\xd9" ' " ANT(I)=AY"
rules(158) = "(IER)=IYE\xd2" ' "(IER)=IYER"
rules(159) = "#:R(IED) =IY\xc4" ' "#:R(IED) =IYD"
rules(160) = "(IED) =AY5\xc4" ' "(IED) =AY5D"
rules(161) = "(IEN)=IYEH\xce" ' "(IEN)=IYEHN"
rules(162) = "(IE)T=AY4E\xc8" ' "(IE)T=AY4EH"
rules(163) = "(I\\')=AY\xb5" ' "(I\\')=AY5"
rules(164) = " :(I)^%=AY\xb5" ' " :(I)^%=AY5"
rules(165) = " :(IE) =AY\xb4" ' " :(IE) =AY4"
rules(166) = "(I)%=I\xd9" ' "(I)%=IY"
rules(167) = "(IE)=IY\xb4" ' "(IE)=IY4"
rules(168) = " (IDEA)=AYDIY5A\xc8" ' " (IDEA)=AYDIY5AH"
rules(169) = "(I)^+:#=I\xc8" ' "(I)^+:#=IH"
rules(170) = "(IR)#=AY\xd2" ' "(IR)#=AYR"
rules(171) = "(IZ)%=AY\xda" ' "(IZ)%=AYZ"
rules(172) = "(IS)%=AY\xda" ' "(IS)%=AYZ"
rules(173) = "I^(I)^#=I\xc8" ' "I^(I)^#=IH"
rules(174) = "+^(I)^+=A\xd9" ' "+^(I)^+=AY"
rules(175) = "#:^(I)^+=I\xc8" ' "#:^(I)^+=IH"
rules(176) = "(I)^+=A\xd9" ' "(I)^+=AY"
rules(177) = "(IR)=E\xd2" ' "(IR)=ER"
rules(178) = "(IGH)=AY\xb4" ' "(IGH)=AY4"
rules(179) = "(ILD)=AY5L\xc4" ' "(ILD)=AY5LD"
rules(180) = " (IGN)=IHG\xce" ' " (IGN)=IHGN"
rules(181) = "(IGN) =AY4\xce" ' "(IGN) =AY4N"
rules(182) = "(IGN)^=AY4\xce" ' "(IGN)^=AY4N"
rules(183) = "(IGN)%=AY4\xce" ' "(IGN)%=AY4N"
rules(184) = "(ICRO)=AY4KRO\xc8" ' "(ICRO)=AY4KROH"
rules(185) = "(IQUE)=IY4\xcb" ' "(IQUE)=IY4K"
rules(186) = "(I)=I\xc8" ' "(I)=IH"
rules(187) = "]\xca" ' "]J"
rules(188) = " (J) =JEY\xb4" ' " (J) =JEY4"
rules(189) = "(J)=\xca" ' "(J)=J"
rules(190) = "]\xcb" ' "]K"
rules(191) = " (K) =KEY\xb4" ' " (K) =KEY4"
rules(192) = " (K)N\xbd" ' " (K)N="
rules(193) = "(K)=\xcb" ' "(K)=K"
rules(194) = "]\xcc" ' "]L"
rules(195) = " (L) =EH4\xcc" ' " (L) =EH4L"
rules(196) = "(LO)C#=LO\xd7" ' "(LO)C#=LOW"
rules(197) = "L(L)\xbd" ' "L(L)="
rules(198) = "#:^(L)%=U\xcc" ' "#:^(L)%=UL"
rules(199) = "(LEAD)=LIY\xc4" ' "(LEAD)=LIYD"
rules(200) = " (LAUGH)=LAE4\xc6" ' " (LAUGH)=LAE4F"
rules(201) = "(L)=\xcc" ' "(L)=L"
rules(202) = "]\xcd" ' "]M"
rules(203) = " (M) =EH4\xcd" ' " (M) =EH4M"
rules(204) = " (MR.) =MIH4STE\xd2" ' " (MR.) =MIH4STER"
rules(205) = " (MS.)=MIH5\xda" ' " (MS.)=MIH5Z"
rules(206) = " (MRS.) =MIH4SIX\xda" ' " (MRS.) =MIH4SIXZ"
rules(207) = "(MOV)=MUW4\xd6" ' "(MOV)=MUW4V"
rules(208) = "(MACHIN)=MAHSHIY5\xce" ' "(MACHIN)=MAHSHIY5N"
rules(209) = "M(M)\xbd" ' "M(M)="
rules(210) = "(M)=\xcd" ' "(M)=M"
rules(211) = "]\xce" ' "]N"
rules(212) = " (N) =EH4\xce" ' " (N) =EH4N"
rules(213) = "E(NG)+=N\xca" ' "E(NG)+=NJ"
rules(214) = "(NG)R=NX\xc7" ' "(NG)R=NXG"
rules(215) = "(NG)#=NX\xc7" ' "(NG)#=NXG"
rules(216) = "(NGL)%=NXGU\xcc" ' "(NGL)%=NXGUL"
rules(217) = "(NG)=N\xd8" ' "(NG)=NX"
rules(218) = "(NK)=NX\xcb" ' "(NK)=NXK"
rules(219) = " (NOW) =NAW\xb4" ' " (NOW) =NAW4"
rules(220) = "N(N)\xbd" ' "N(N)="
rules(221) = "(NON)E=NAH4\xce" ' "(NON)E=NAH4N"
rules(222) = "(N)=\xce" ' "(N)=N"
rules(223) = "]\xcf" ' "]O"
rules(224) = " (O) =OH4\xd7" ' " (O) =OH4W"
rules(225) = "(OF) =AH\xd6" ' "(OF) =AHV"
rules(226) = " (OH) =OW\xb5" ' " (OH) =OW5"
rules(227) = "(OROUGH)=ER4O\xd7" ' "(OROUGH)=ER4OW"
rules(228) = "#:(OR) =E\xd2" ' "#:(OR) =ER"
rules(229) = "#:(ORS) =ER\xda" ' "#:(ORS) =ERZ"
rules(230) = "(OR)=AO\xd2" ' "(OR)=AOR"
rules(231) = " (ONE)=WAH\xce" ' " (ONE)=WAHN"
rules(232) = "#(ONE) =WAH\xce" ' "#(ONE) =WAHN"
rules(233) = "(OW)=O\xd7" ' "(OW)=OW"
rules(234) = " (OVER)=OW5VE\xd2" ' " (OVER)=OW5VER"
rules(235) = "PR(O)V=UW\xb4" ' "PR(O)V=UW4"
rules(236) = "(OV)=AH4\xd6" ' "(OV)=AH4V"
rules(237) = "(O)^%=OW\xb5" ' "(O)^%=OW5"
rules(238) = "(O)^EN=O\xd7" ' "(O)^EN=OW"
rules(239) = "(O)^I#=OW\xb5" ' "(O)^I#=OW5"
rules(240) = "(OL)D=OW4\xcc" ' "(OL)D=OW4L"
rules(241) = "(OUGHT)=AO5\xd4" ' "(OUGHT)=AO5T"
rules(242) = "(OUGH)=AH5\xc6" ' "(OUGH)=AH5F"
rules(243) = " (OU)=A\xd7" ' " (OU)=AW"
rules(244) = "H(OU)S#=AW\xb4" ' "H(OU)S#=AW4"
rules(245) = "(OUS)=AX\xd3" ' "(OUS)=AXS"
rules(246) = "(OUR)=OH\xd2" ' "(OUR)=OHR"
rules(247) = "(OULD)=UH5\xc4" ' "(OULD)=UH5D"
rules(248) = "(OU)^L=AH\xb5" ' "(OU)^L=AH5"
rules(249) = "(OUP)=UW5\xd0" ' "(OUP)=UW5P"
rules(250) = "(OU)=A\xd7" ' "(OU)=AW"
rules(251) = "(OY)=O\xd9" ' "(OY)=OY"
rules(252) = "(OING)=OW4IHN\xd8" ' "(OING)=OW4IHNX"
rules(253) = "(OI)=OY\xb5" ' "(OI)=OY5"
rules(254) = "(OOR)=OH5\xd2" ' "(OOR)=OH5R"
rules(255) = "(OOK)=UH5\xcb" ' "(OOK)=UH5K"
rules(256) = "F(OOD)=UW5\xc4" ' "F(OOD)=UW5D"
rules(257) = "L(OOD)=AH5\xc4" ' "L(OOD)=AH5D"
rules(258) = "M(OOD)=UW5\xc4" ' "M(OOD)=UW5D"
rules(259) = "(OOD)=UH5\xc4" ' "(OOD)=UH5D"
rules(260) = "F(OOT)=UH5\xd4" ' "F(OOT)=UH5T"
rules(261) = "(OO)=UW\xb5" ' "(OO)=UW5"
rules(262) = "(O\\')=O\xc8" ' "(O\\')=OH"
rules(263) = "(O)E=O\xd7" ' "(O)E=OW"
rules(264) = "(O) =O\xd7" ' "(O) =OW"
rules(265) = "(OA)=OW\xb4" ' "(OA)=OW4"
rules(266) = " (ONLY)=OW4NLI\xd9" ' " (ONLY)=OW4NLIY"
rules(267) = " (ONCE)=WAH4N\xd3" ' " (ONCE)=WAH4NS"
rules(268) = "(ON\\'T)=OW4N\xd4" ' "(ON\\'T)=OW4NT"
rules(269) = "C(O)N=A\xc1" ' "C(O)N=AA"
rules(270) = "(O)NG=A\xcf" ' "(O)NG=AO"
rules(271) = " :^(O)N=A\xc8" ' " :^(O)N=AH"
rules(272) = "I(ON)=U\xce" ' "I(ON)=UN"
rules(273) = "#:(ON)=U\xce" ' "#:(ON)=UN"
rules(274) = "#^(ON)=U\xce" ' "#^(ON)=UN"
rules(275) = "(O)ST=O\xd7" ' "(O)ST=OW"
rules(276) = "(OF)^=AO4\xc6" ' "(OF)^=AO4F"
rules(277) = "(OTHER)=AH5DHE\xd2" ' "(OTHER)=AH5DHER"
rules(278) = "R(O)B=RA\xc1" ' "R(O)B=RAA"
rules(279) = "^R(O):#=OW\xb5" ' "^R(O):#=OW5"
rules(280) = "(OSS) =AO5\xd3" ' "(OSS) =AO5S"
rules(281) = "#:^(OM)=AH\xcd" ' "#:^(OM)=AHM"
rules(282) = "(O)=A\xc1" ' "(O)=AA"
rules(283) = "]\xd0" ' "]P"
rules(284) = " (P) =PIY\xb4" ' " (P) =PIY4"
rules(285) = "(PH)=\xc6" ' "(PH)=F"
rules(286) = "(PEOPL)=PIY5PU\xcc" ' "(PEOPL)=PIY5PUL"
rules(287) = "(POW)=PAW\xb4" ' "(POW)=PAW4"
rules(288) = "(PUT) =PUH\xd4" ' "(PUT) =PUHT"
rules(289) = "(P)P\xbd" ' "(P)P="
rules(290) = "(P)S\xbd" ' "(P)S="
rules(291) = "(P)N\xbd" ' "(P)N="
rules(292) = "(PROF.)=PROHFEH4SE\xd2" ' "(PROF.)=PROHFEH4SER"
rules(293) = "(P)=\xd0" ' "(P)=P"
rules(294) = "]\xd1" ' "]Q"
rules(295) = " (Q) =KYUW\xb4" ' " (Q) =KYUW4"
rules(296) = "(QUAR)=KWOH5\xd2" ' "(QUAR)=KWOH5R"
rules(297) = "(QU)=K\xd7" ' "(QU)=KW"
rules(298) = "(Q)=\xcb" ' "(Q)=K"
rules(299) = "]\xd2" ' "]R"
rules(300) = " (R) =AA5\xd2" ' " (R) =AA5R"
rules(301) = " (RE)^#=RI\xd9" ' " (RE)^#=RIY"
rules(302) = "(R)R\xbd" ' "(R)R="
rules(303) = "(R)=\xd2" ' "(R)=R"
rules(304) = "]\xd3" ' "]S"
rules(305) = " (S) =EH4\xd3" ' " (S) =EH4S"
rules(306) = "(SH)=S\xc8" ' "(SH)=SH"
rules(307) = "#(SION)=ZHU\xce" ' "#(SION)=ZHUN"
rules(308) = "(SOME)=SAH\xcd" ' "(SOME)=SAHM"
rules(309) = "#(SUR)#=ZHE\xd2" ' "#(SUR)#=ZHER"
rules(310) = "(SUR)#=SHE\xd2" ' "(SUR)#=SHER"
rules(311) = "#(SU)#=ZHU\xd7" ' "#(SU)#=ZHUW"
rules(312) = "#(SSU)#=SHU\xd7" ' "#(SSU)#=SHUW"
rules(313) = "#(SED)=Z\xc4" ' "#(SED)=ZD"
rules(314) = "#(S)#=\xda" ' "#(S)#=Z"
rules(315) = "(SAID)=SEH\xc4" ' "(SAID)=SEHD"
rules(316) = "^(SION)=SHU\xce" ' "^(SION)=SHUN"
rules(317) = "(S)S\xbd" ' "(S)S="
rules(318) = ".(S) =\xda" ' ".(S) =Z"
rules(319) = "#:.E(S) =\xda" ' "#:.E(S) =Z"
rules(320) = "#:^#(S) =\xd3" ' "#:^#(S) =S"
rules(321) = "U(S) =\xd3" ' "U(S) =S"
rules(322) = " :#(S) =\xda" ' " :#(S) =Z"
rules(323) = "##(S) =\xda" ' "##(S) =Z"
rules(324) = " (SCH)=S\xcb" ' " (SCH)=SK"
rules(325) = "(S)C+\xbd" ' "(S)C+="
rules(326) = "#(SM)=ZU\xcd" ' "#(SM)=ZUM"
rules(327) = "#(SN)\\'=ZU\xcd" ' "#(SN)\\'=ZUM"
rules(328) = "(STLE)=SU\xcc" ' "(STLE)=SUL"
rules(329) = "(S)=\xd3" ' "(S)=S"
rules(330) = "]\xd4" ' "]T"
rules(331) = " (T) =TIY\xb4" ' " (T) =TIY4"
rules(332) = " (THE) #=DHI\xd9" ' " (THE) #=DHIY"
rules(333) = " (THE) =DHA\xd8" ' " (THE) =DHAX"
rules(334) = "(TO) =TU\xd8" ' "(TO) =TUX"
rules(335) = " (THAT)=DHAE\xd4" ' " (THAT)=DHAET"
rules(336) = " (THIS) =DHIH\xd3" ' " (THIS) =DHIHS"
rules(337) = " (THEY)=DHE\xd9" ' " (THEY)=DHEY"
rules(338) = " (THERE)=DHEH\xd2" ' " (THERE)=DHEHR"
rules(339) = "(THER)=DHE\xd2" ' "(THER)=DHER"
rules(340) = "(THEIR)=DHEH\xd2" ' "(THEIR)=DHEHR"
rules(341) = " (THAN) =DHAE\xce" ' " (THAN) =DHAEN"
rules(342) = " (THEM) =DHAE\xce" ' " (THEM) =DHAEN"
rules(343) = "(THESE) =DHIY\xda" ' "(THESE) =DHIYZ"
rules(344) = " (THEN)=DHEH\xce" ' " (THEN)=DHEHN"
rules(345) = "(THROUGH)=THRUW\xb4" ' "(THROUGH)=THRUW4"
rules(346) = "(THOSE)=DHOH\xda" ' "(THOSE)=DHOHZ"
rules(347) = "(THOUGH) =DHO\xd7" ' "(THOUGH) =DHOW"
rules(348) = "(TODAY)=TUXDE\xd9" ' "(TODAY)=TUXDEY"
rules(349) = "(TOMO)RROW=TUMAA\xb5" ' "(TOMO)RROW=TUMAA5"
rules(350) = "(TO)TAL=TOW\xb5" ' "(TO)TAL=TOW5"
rules(351) = " (THUS)=DHAH4\xd3" ' " (THUS)=DHAH4S"
rules(352) = "(TH)=T\xc8" ' "(TH)=TH"
rules(353) = "#:(TED)=TIX\xc4" ' "#:(TED)=TIXD"
rules(354) = "S(TI)#N=C\xc8" ' "S(TI)#N=CH"
rules(355) = "(TI)O=S\xc8" ' "(TI)O=SH"
rules(356) = "(TI)A=S\xc8" ' "(TI)A=SH"
rules(357) = "(TIEN)=SHU\xce" ' "(TIEN)=SHUN"
rules(358) = "(TUR)#=CHE\xd2" ' "(TUR)#=CHER"
rules(359) = "(TU)A=CHU\xd7" ' "(TU)A=CHUW"
rules(360) = " (TWO)=TU\xd7" ' " (TWO)=TUW"
rules(361) = "&(T)EN \xbd" ' "&(T)EN ="
rules(362) = "(T)=\xd4" ' "(T)=T"
rules(363) = "]\xd5" ' "]U"
rules(364) = " (U) =YUW\xb4" ' " (U) =YUW4"
rules(365) = " (UN)I=YUW\xce" ' " (UN)I=YUWN"
rules(366) = " (UN)=AH\xce" ' " (UN)=AHN"
rules(367) = " (UPON)=AXPAO\xce" ' " (UPON)=AXPAON"
rules(368) = "@(UR)#=UH4\xd2" ' "@(UR)#=UH4R"
rules(369) = "(UR)#=YUH4\xd2" ' "(UR)#=YUH4R"
rules(370) = "(UR)=E\xd2" ' "(UR)=ER"
rules(371) = "(U)^ =A\xc8" ' "(U)^ =AH"
rules(372) = "(U)^^=AH\xb5" ' "(U)^^=AH5"
rules(373) = "(UY)=AY\xb5" ' "(UY)=AY5"
rules(374) = " G(U)#\xbd" ' " G(U)#="
rules(375) = "G(U)%\xbd" ' "G(U)%="
rules(376) = "G(U)#=\xd7" ' "G(U)#=W"
rules(377) = "#N(U)=YU\xd7" ' "#N(U)=YUW"
rules(378) = "@(U)=U\xd7" ' "@(U)=UW"
rules(379) = "(U)=YU\xd7" ' "(U)=YUW"
rules(380) = "]\xd6" ' "]V"
rules(381) = " (V) =VIY\xb4" ' " (V) =VIY4"
rules(382) = "(VIEW)=VYUW\xb5" ' "(VIEW)=VYUW5"
rules(383) = "(V)=\xd6" ' "(V)=V"
rules(384) = "]\xd7" ' "]W"
rules(385) = " (W) =DAH4BULYU\xd7" ' " (W) =DAH4BULYUW"
rules(386) = " (WERE)=WE\xd2" ' " (WERE)=WER"
rules(387) = "(WA)SH=WA\xc1" ' "(WA)SH=WAA"
rules(388) = "(WA)ST=WE\xd9" ' "(WA)ST=WEY"
rules(389) = "(WA)S=WA\xc8" ' "(WA)S=WAH"
rules(390) = "(WA)T=WA\xc1" ' "(WA)T=WAA"
rules(391) = "(WHERE)=WHEH\xd2" ' "(WHERE)=WHEHR"
rules(392) = "(WHAT)=WHAH\xd4" ' "(WHAT)=WHAHT"
rules(393) = "(WHOL)=/HOW\xcc" ' "(WHOL)=/HOWL"
rules(394) = "(WHO)=/HU\xd7" ' "(WHO)=/HUW"
rules(395) = "(WH)=W\xc8" ' "(WH)=WH"
rules(396) = "(WAR)#=WEH\xd2" ' "(WAR)#=WEHR"
rules(397) = "(WAR)=WAO\xd2" ' "(WAR)=WAOR"
rules(398) = "(WOR)^=WE\xd2" ' "(WOR)^=WER"
rules(399) = "(WR)=\xd2" ' "(WR)=R"
rules(400) = "(WOM)A=WUH\xcd" ' "(WOM)A=WUHM"
rules(401) = "(WOM)E=WIH\xcd" ' "(WOM)E=WIHM"
rules(402) = "(WEA)R=WE\xc8" ' "(WEA)R=WEH"
rules(403) = "(WANT)=WAA5N\xd4" ' "(WANT)=WAA5NT"
rules(404) = "ANS(WER)=E\xd2" ' "ANS(WER)=ER"
rules(405) = "(W)=\xd7" ' "(W)=W"
rules(406) = "]\xd8" ' "]X"
rules(407) = " (X) =EH4K\xd2" ' " (X) =EH4KR"
rules(408) = " (X)=\xda" ' " (X)=Z"
rules(409) = "(X)=K\xd3" ' "(X)=KS"
rules(410) = "]\xd9" ' "]Y"
rules(411) = " (Y) =WAY\xb4" ' " (Y) =WAY4"
rules(412) = "(YOUNG)=YAHN\xd8" ' "(YOUNG)=YAHNX"
rules(413) = " (YOUR)=YOH\xd2" ' " (YOUR)=YOHR"
rules(414) = " (YOU)=YU\xd7" ' " (YOU)=YUW"
rules(415) = " (YES)=YEH\xd3" ' " (YES)=YEHS"
rules(416) = " (Y)=\xd9" ' " (Y)=Y"
rules(417) = "F(Y)=A\xd9" ' "F(Y)=AY"
rules(418) = "PS(YCH)=AY\xcb" ' "PS(YCH)=AYK"
rules(419) = "#:^(Y)=I\xd9" ' "#:^(Y)=IY"
rules(420) = "#:^(Y)I=I\xd9" ' "#:^(Y)I=IY"
rules(421) = " :(Y) =A\xd9" ' " :(Y) =AY"
rules(422) = " :(Y)#=A\xd9" ' " :(Y)#=AY"
rules(423) = " :(Y)^+:#=I\xc8" ' " :(Y)^+:#=IH"
rules(424) = " :(Y)^#=A\xd9" ' " :(Y)^#=AY"
rules(425) = "(Y)=I\xc8" ' "(Y)=IH"
rules(426) = "]\xda" ' "]Z"
rules(427) = " (Z) =ZIY\xb4" ' " (Z) =ZIY4"
rules(428) = "(Z)=\xda" ' "(Z)=Z"
rules(429) = "]\xb0" ' "]0"
rules(430) = "(A)\xbd" ' "(A)="
rules(431) = "(!)=\xae" ' "(!)=."
rules(432) = "(\") =-AH5NKWOWT\xad" ' "(\") =-AH5NKWOWT-"
rules(433) = "(\")=KWOW4T\xad" ' "(\")=KWOW4T-"
rules(434) = "(#)= NAH4MBE\xd2" ' "(#)= NAH4MBER"
rules(435) = "($)= DAA4LE\xd2" ' "($)= DAA4LER"
rules(436) = "(%)= PERSEH4N\xd4" ' "(%)= PERSEH4NT"
rules(437) = "(&)= AEN\xc4" ' "(&)= AEND"
rules(438) = "(\\)\xbd" ' "(\\)="
rules(439) = "(*)= AE4STERIHS\xcb" ' "(*)= AE4STERIHSK"
rules(440) = "(+)= PLAH4\xd3" ' "(+)= PLAH4S"
rules(441) = "(,)=\xac" ' "(,)=,"
rules(442) = " (-) =\xad" ' " (-) =-"
rules(443) = "(-)\xbd" ' "(-)="
rules(444) = "(.)= POYN\xd4" ' "(.)= POYNT"
rules(445) = "(/)= SLAE4S\xc8" ' "(/)= SLAE4SH"
rules(446) = "(0)= ZIY4RO\xd7" ' "(0)= ZIY4ROW"
rules(447) = " (1ST)=FER4S\xd4" ' " (1ST)=FER4ST"
rules(448) = " (10TH)=TEH4NT\xc8" ' " (10TH)=TEH4NTH"
rules(449) = "(1)= WAH4\xce" ' "(1)= WAH4N"
rules(450) = " (2ND)=SEH4KUN\xc4" ' " (2ND)=SEH4KUND"
rules(451) = "(2)= TUW\xb4" ' "(2)= TUW4"
rules(452) = " (3RD)=THER4\xc4" ' " (3RD)=THER4D"
rules(453) = "(3)= THRIY\xb4" ' "(3)= THRIY4"
rules(454) = "(4)= FOH4\xd2" ' "(4)= FOH4R"
rules(455) = " (5TH)=FIH4FT\xc8" ' " (5TH)=FIH4FTH"
rules(456) = "(5)= FAY4\xd6" ' "(5)= FAY4V"
rules(457) = " (64) =SIH4KSTIY FOH\xd2" ' " (64) =SIH4KSTIY FOHR"
rules(458) = "(6)= SIH4K\xd3" ' "(6)= SIH4KS"
rules(459) = "(7)= SEH4VU\xce" ' "(7)= SEH4VUN"
rules(460) = " (8TH)=EY4T\xc8" ' " (8TH)=EY4TH"
rules(461) = "(8)= EY4\xd4" ' "(8)= EY4T"
rules(462) = "(9)= NAY4\xce" ' "(9)= NAY4N"
rules(463) = "(:)=\xae" ' "(:)=."
rules(464) = "(;)=\xae" ' "(;)=."
rules(465) = "(<)= LEH4S DHAE\xce" ' "(<)= LEH4S DHAEN"
rules(466) = "(=)= IY4KWUL\xda" ' "(=)= IY4KWULZ"
rules(467) = "(>)= GREY4TER DHAE\xce" ' "(>)= GREY4TER DHAEN"
rules(468) = "(?)=\xbf" ' "(?)=?"
rules(469) = "(@)= AE6\xd4" ' "(@)= AE6T"
rules(470) = "(^)= KAE4RIX\xd4" ' "(^)= KAE4RIXT"
rules(471) = "(')\xbd" ' "(')="
rules(472) = "(`)\xbd" ' "(`)="
rules(473) = "]\xb1" ' "]1'
REDim rule_tab(0 to 27) as integer
rule_tab(0) = &H00
rule_tab(1) = &H195
rule_tab(2) = &H1f7
rule_tab(3) = &H2a2
rule_tab(4) = &H33f
rule_tab(5) = &H4c6
rule_tab(6) = &H507
rule_tab(7) = &H57f
rule_tab(8) = &H5c8
rule_tab(9) = &H728
rule_tab(10) = &H739
rule_tab(11) = &H750
rule_tab(12) = &H793
rule_tab(13) = &H7f3
rule_tab(14) = &H857
rule_tab(15) = &Haa5
rule_tab(16) = &Hb02
rule_tab(17) = &Hb28
rule_tab(18) = &Hb49
rule_tab(19) = &Hc32
rule_tab(20) = &Hdac
rule_tab(21) = &He3b
rule_tab(22) = &He58
rule_tab(23) = &Hf33
rule_tab(24) = &Hf4c
rule_tab(25) = &Hfdf
rule_tab(26) = &Hff0
rule_tab(27) = &H11b7
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' END reciter_tabs.h
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' BEGIN sam_tabs.h
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' QB64 does not use header files like C/C++, so the #ifndef, #define, and #include <stdint.h> are not needed.
' We can directly declare the arrays.
' Explanation of Conversion:
' Header Inclusion: The #ifndef, #define, and #include <stdint.h> are C/C++ preprocessor directives. QB64 doesn't use header files in the same way. Therefore, these lines are removed.
' Data Type Conversion: uint8_t in C/C++ represents an unsigned 8-bit integer. In QB64, the closest equivalent is UBYTE.
' Array Declaration: Arrays are declared using the DIM statement in QB64. For example:
' const uint8_t stressInputTable[] becomes DIM stressInputTable(0 TO 8) AS UBYTE. Since the original C-style initialization provides 9 values, I dimensioned it from 0 to 8 (9 elements).
' For character arrays, I used fixed-length strings (e.g., DIM stressInputTable AS STRING * 9) and initialized them directly with the string literals. This is more efficient for character data in QB64.
' Data Initialization: QB64 uses the DATA and READ statements to initialize arrays. The data values are listed in DATA statements, and then a FOR loop with READ statements populates the array.
' Hexadecimal Literals: Hexadecimal values in C/C++ (e.g., 0xA4) are represented in QB64 with &H (e.g., &HA4).
' Comments: Comments from the original C/C++ code are retained using the single quote ' in QB64.
' This QB64 code provides equivalent functionality to the C/C++ header file by declaring and initializing the arrays with the same data.
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
'tab40672
stressInputTable = "*12345678" ' Initialize the string directly
' BEGIN tab40682
signInputTable1 = " .?,--IIEAAAAUAIEOURLWYWR LWYMNNNDQSSFT//ZZVDC*J* *EAOAOUB* *D* *G* *GP* *T* *K* *K* *UUU" ' Initialize the string directly
' END tab40682
' BEGIN tab40763
signInputTable2 = "**** *YHH EAHOHXXRXHXXXXH* *****XXX* H*HHHX* HHH* *YYYYWWW* ***** * * *X* * *LMN" ' Initialize the string directly
' END tab40763
' BEGIN loc_9F8C
REDIM flags(0 TO 66) AS UBYTE
DATA &H00, &H00, &H00, &H00, &H00, &HA4, &HA4, &HA4
DATA &HA4, &HA4, &HA4, &H84, &H84, &HA4, &HA4, &H84
DATA &H84, &H84, &H84, &H84, &H84, &H84, &H44, &H44
DATA &H44, &H44, &H44, &H4C, &H4C, &H4C, &H48, &H4C
DATA &H40, &H40, &H40, &H40, &H40, &H40, &H44, &H44
DATA &H44, &H44, &H48, &H40, &H4C, &H44, &H00, &H00
DATA &HB4, &HB4, &HB4, &H94, &H94, &H94, &H4E, &H4E
DATA &H4E, &H4E, &H4E, &H4E, &H4E, &H4E, &H4E, &H4E
DATA &H4E, &H4E, &H4B, &H4B, &H4B, &H4B, &H4B, &H4B
DATA &H4B, &H4B, &H4B, &H4B, &H4B, &H4B, &H80, &HC1
DATA &HC1
FOR i = 0 TO 66
READ flags(i)
NEXT i
'END loc_9F8C
'??? flags overlap flags2 'Comment retained from original code
'loc_9FDA
REDIM flags2(0 TO 61) AS UBYTE
DATA &H80, &HC1, &HC1, &HC1, &HC1, &H00, &H00, &H00
DATA &H00, &H00, &H00, &H00, &H00, &H00, &H00, &H00
DATA &H00, &H00, &H00, &H00, &H00, &H00, &H00, &H10
DATA &H10, &H10, &H10, &H08, &H0C, &H08, &H04, &H40
DATA &H24, &H20, &H20, &H24, &H00, &H00, &H24, &H20
DATA &H20, &H24, &H20, &H20, &H00, &H20, &H00, &H00
DATA &H00, &H00, &H00, &H00, &H00, &H00, &H00, &H00
DATA &H00, &H04, &H04, &H04, &H00, &H00, &H00, &H00
DATA &H00, &H00, &H00, &H00, &H00, &H04, &H04, &H04
DATA &H00, &H00, &H00, &H00, &H00, &H00
FOR i = 0 TO 61
READ flags2(i)
NEXT i
'tab45616???
REDIM phonemeStressedLengthTable(0 TO 61) AS UBYTE
DATA &H00, &H12, &H12, &H12, 8, &HB, 9, &HB
DATA &HE, &HF, &HB, &H10, &HC, 6, 6, &HE
DATA &HC, &HE, &HC, &HB, 8, 8, &HB, &HA
DATA 9, 8, 8, 8, 8, 8, 3, 5
DATA 2, 2, 2, 2, 2, 2, 6, 6
DATA 8, 6, 6, 2, 9, 4, 2, 1
DATA &HE, &HF, &HF, &HF, &HE, &HE, 8, 2
DATA 2, 7, 2, 1, 7, 2, 2, 7
DATA 2, 2, 8, 2
DATA 2, 6, 2, 2
DATA 7, 2, 4, 7, 1, 4, 5, 5
FOR i = 0 TO 61
READ phonemeStressedLengthTable(i)
NEXT i
'tab45536???
REDIM phonemeLengthTable(0 TO 61) AS UBYTE
DATA 0, &H12, &H12, &H12, 8, 8, 8, 8
DATA 8, &HB, 6, &HC, &HA, 5, 5, &HB
DATA &HA, &HA, &HA, 9, 8, 7, 9, 7
DATA 6, 8, 6, 7, 7, 7, 2, 5
DATA 2, 2, 2, 2, 2, 2, 6, 6
DATA 7, 6, 6, 2, 8, 3, 1, &H1E
DATA &HD, &HC, &HC, &HC, &HE, 9, 6, 1
DATA 2, 5, 1, 1, 6, 1, 2, 6
DATA 1, 2, 8, 2
DATA 2, 4, 2, 2
DATA 6, 1, 4, 6, 1, 4, &HC7, &HFF
FOR i = 0 TO 61
READ phonemeLengthTable(i)
NEXT i
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' END sam_tabs.h
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' BEGIN render_tabs.h
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' Translated from C header file "render_tabs.h.1a1.txt" [cite: 1]
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' FROM reciter_tabs.h
' The following constants are defined as byte arrays:
' uint8_t tab48426[5]
' uint8_t tab47492[]
' uint8_t amplitudeRescale[]
' uint8_t blendRank[]
' Initialize tab48426
REDIM tab48426(4) AS _BYTE ' Equivalent to uint8_t[5] [cite: 1]
tab48426(0) = &H18
tab48426(1) = &H1A
tab48426(2) = &H17
tab48426(3) = &H17
tab48426(4) = &H17 ' [cite: 1]
' Initialize tab47492
REDIM tab47492(10) ' 11 elements [cite: 2]
tab47492(0) = 0
tab47492(1) = 0
tab47492(2) = &HE0
tab47492(3) = &HE6
tab47492(4) = &HEC
tab47492(5) = &HF3
tab47492(6) = &HF9
tab47492(7) = 0
tab47492(8) = 6
tab47492(9) = &HC
tab47492(10) = 6 ' [cite: 2]
' Initialize amplitudeRescale
REDIM amplitudeRescale(16) ' 17 elements [cite: 3]
amplitudeRescale(0) = 0
amplitudeRescale(1) = 1
amplitudeRescale(2) = 2
amplitudeRescale(3) = 2
amplitudeRescale(4) = 2
amplitudeRescale(5) = 3
amplitudeRescale(6) = 3
amplitudeRescale(7) = 4
amplitudeRescale(8) = 4
amplitudeRescale(9) = 5
amplitudeRescale(10) = 6
amplitudeRescale(11) = 8
amplitudeRescale(12) = 9
amplitudeRescale(13) = &HB
amplitudeRescale(14) = &HD
amplitudeRescale(15) = &HF
amplitudeRescale(16) = 0 ' [cite: 3]
' Initialize blendRank
REDIM blendRank(62) ' 63 elements [cite: 4, 5]
blendRank(0) = 0
blendRank(1) = &H1F
blendRank(2) = &H1F
blendRank(3) = &H1F
blendRank(4) = &H1F
blendRank(5) = 2
blendRank(6) = 2
blendRank(7) = 2
blendRank(8) = 2
blendRank(9) = 2
blendRank(10) = 2
blendRank(11) = 2
blendRank(12) = 2
blendRank(13) = 2
blendRank(14) = 5
blendRank(15) = 5
blendRank(16) = 2
blendRank(17) = &HA
blendRank(18) = 2
blendRank(19) = 8
blendRank(20) = 5
blendRank(21) = 5
blendRank(22) = &HB
blendRank(23) = &HA
blendRank(24) = 9
blendRank(25) = 8
blendRank(26) = 8
blendRank(27) = &HA0
blendRank(28) = 8
blendRank(29) = 8
blendRank(30) = &H17
blendRank(31) = &H1F
blendRank(32) = &H12
blendRank(33) = &H12
blendRank(34) = &H12
blendRank(35) = &H12
blendRank(36) = &H1E
blendRank(37) = &H1E
blendRank(38) = &H14
blendRank(39) = &H14
blendRank(40) = &H14
blendRank(41) = &H14
blendRank(42) = &H17
blendRank(43) = &H17
blendRank(44) = &H1A
blendRank(45) = &H1A
blendRank(46) = &H1D
blendRank(47) = &H1D
blendRank(48) = 2
blendRank(49) = 2
blendRank(50) = 2
blendRank(51) = 2
blendRank(52) = 2
blendRank(53) = 2
blendRank(54) = &H1A
blendRank(55) = &H1D
blendRank(56) = &H1B
blendRank(57) = &H1A
blendRank(58) = &H1D
blendRank(59) = &H1B
blendRank(60) = &H1A
blendRank(61) = &H1D
blendRank(62) = &H1B
blendRank(63) = &H1A ' Note: There's an extra element in the C code [cite: 4]
blendRank(64) = &H1D
blendRank(65) = &H1B
blendRank(66) = &H17
blendRank(67) = &H1D
blendRank(68) = &H17
blendRank(69) = &H17
blendRank(70) = &H1D
blendRank(71) = &H17
blendRank(72) = &H17
blendRank(73) = &H1D
blendRank(74) = &H17
blendRank(75) = &H17
blendRank(76) = &H1D
blendRank(77) = &H17
blendRank(78) = &H17
blendRank(79) = &H17 ' [cite: 5]
' Example of accessing the arrays:
' PRINT tab48426(0)
' PRINT tab47492(5)
' PRINT amplitudeRescale(10)
' PRINT blendRank(25)
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' Converted from render_tabs.h.1a2.txt
'BEGIN PART 1a2
REDIM outBlendLength(95) AS UBYTE
DATA 0, 2, 2, 2, 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 3, 2, 4, 4, 2, 2
DATA 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 0, 1, 0, 1, 0, 5
DATA 5, 5, 5, 5, 4, 4, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 2, 2, 0, 1
DATA 3, 0, 2, 3, 0, 2, 160, 160 '0xA0 = 160
FOR i = 0 TO 95
READ outBlendLength(i)
NEXT i
' Number of frames at beginning of a phoneme devoted to interpolating to phoneme's final value
' tab45776
REDIM inBlendLength(95) AS UBYTE
DATA 0, 2, 2, 2, 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 3, 3, 4, 4, 3, 3
DATA 3, 3, 3, 1, 2, 3, 2, 1, 3, 3, 3, 3, 1, 1, 3, 3, 3, 2, 2, 3, 2, 3, 0, 0
DATA 5, 5, 5, 5, 4, 4, 2, 0, 2, 2, 0, 3, 2, 0, 4, 2, 0, 3, 2, 0, 2, 2, 0, 2
DATA 3, 0, 3, 3, 0, 3, 176, 160 '0xB0 = 176, 0xA0 = 160
FOR i = 0 TO 95
READ inBlendLength(i)
NEXT i
REDIM sampledConsonantFlags(79) AS UBYTE
DATA 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
DATA 0, 0, 0, 0, 0, 0, 0, 0, 241, 226, 211, 187, 124, 149, 1, 2, 3, 3, 0, 114, 0, 2, 0, 0
DATA 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 27
DATA 0, 0, 25, 0, 0, 0, 0, 0, 0, 0, 0, 0
FOR i = 0 TO 79
READ sampledConsonantFlags(i)
NEXT i
' END PART 1a2
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
'Converted from render_tabs.h.1b1.txt
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' Explanation of Conversion:
' Comments: C++ comments (//) are converted to QB64 comments (').
' Data Type: uint8_t in C++ is equivalent to an unsigned byte in QB64, which is best represented by the UBYTE type. We use DIM arrayName(size) AS UBYTE to declare the arrays. Note that QB64 array indices start at 0 by default. The size is one less than the number of elements.
' Array Initialization: C++ uses curly braces {} to initialize arrays. QB64 uses DATA statements to hold the data and a FOR...NEXT loop with READ to assign the values to the array elements.
' Hexadecimal Literals: Hexadecimal literals like 0x43 are the same in QB64.
' Handling non const: QB64 doesn't have the const keyword in the same way as C++. All variables in QB64 are inherently mutable. So, the non const comment is retained as a regular comment for informational purposes, but no specific QB64 syntax is needed to replicate it.
' Splitting DATA Statements: I've split the DATA statements to keep lines reasonably sized, which improves readability. This doesn't affect how the data is read into the arrays.
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
'tab45056
'note: non const
REDIM freq1data(71) AS UBYTE
DATA 0x00, 0x13, 0x13, 0x13, 0x13, 0xA, 0xE, 0x12, 0x18, 0x1A, 0x16, 0x14, 0x10, 0x14, 0xE, 0x12, 0xE, 0x12, 0x12, 0x10, 0xC, 0xE, 0xA, 0x12, 0xE, 0xA, 8, 6, 6, 6, 6, 0x11, 6, 6, 6, 6, 0xE, 0x10, 9, 0xA, 8, 0xA, 6, 6, 6, 5, 6, 0, 0x12, 0x1A, 0x14, 0x1A, 0x12, 0xC, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0xA, 0xA, 6, 6, 6, 0x2C, 0x13
FOR i = 0 TO 71
READ freq1data(i)
NEXT i
'tab451356
' note: non const
REDIM freq2data(79) AS UBYTE
DATA 0x00, 0x43, 0x43, 0x43, 0x43, 0x54, 0x48, 0x42, 0x3E, 0x28, 0x2C, 0x1E, 0x24, 0x2C, 0x48, 0x30, 0x24, 0x1E, 0x32, 0x24, 0x1C, 0x44, 0x18, 0x32, 0x1E, 0x18, 0x52, 0x2E, 0x36, 0x56, 0x36, 0x43, 0x49, 0x4F, 0x1A, 0x42, 0x49, 0x25, 0x33, 0x42, 0x28, 0x2F, 0x4F, 0x4F, 0x42, 0x4F, 0x6E, 0x00, 0x48, 0x26, 0x1E, 0x2A, 0x1E, 0x22, 0x1A, 0x1A, 0x1A, 0x42, 0x42, 0x42, 0x6E, 0x6E, 0x6E, 0x54, 0x54, 0x54
FOR i = 0 TO 59
READ freq2data(i)
NEXT i
DATA 0x1A, 0x1A, 0x1A, 0x42, 0x42, 0x42, 0x6D, 0x56, 0x6D, 0x54, 0x54, 0x54, 0x7F, 0x7F
FOR i = 60 TO 79
READ freq2data(i)
NEXT i
'tab45216
REDIM freq3data(62) AS UBYTE
DATA 0x00, 0x5B, 0x5B, 0x5B, 0x5B, 0x6E, 0x5D, 0x5B, 0x58, 0x59, 0x57, 0x58, 0x52, 0x59, 0x5D, 0x3E, 0x52, 0x58, 0x3E, 0x6E, 0x50, 0x5D, 0x5A, 0x3C, 0x6E, 0x5A, 0x6E, 0x51, 0x79, 0x65, 0x79, 0x5B, 0x63, 0x6A, 0x51, 0x79, 0x5D, 0x52, 0x5D, 0x67, 0x4C, 0x5D, 0x65, 0x65, 0x79, 0x65, 0x79, 0x00, 0x5A, 0x58, 0x58, 0x58, 0x58, 0x52, 0x51, 0x51, 0x51, 0x79, 0x79, 0x79, 0x70, 0x6E, 0x6E, 0x5E, 0x5E, 0x5E, 0x51, 0x51
FOR i = 0 TO 59
READ freq3data(i)
NEXT i
DATA 0x51, 0x79, 0x79, 0x79, 0x65, 0x65, 0x70, 0x5E, 0x5E, 0x5E, 0x08, 0x01
FOR i = 60 TO 61
READ freq3data(i)
NEXT i
' END PART 1b1
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
'Converted from render_tabs.h.1b2.txt
REDIM ampl1data(78) AS _BYTE
DATA 0, 0, 0, 0, 0, 0xD, 0xD, 0xE, 0xF, 0xF, 0xF, 0xF, 0xF, 0xC, 0xD, 0xC [cite: 1]
DATA 0xF, 0xF, 0xD, 0xD, 0xD, 0xE, 0xD, 0xC, 0xD, 0xD, 0xD, 0xC, 9, 9, 0, 0 [cite: 1]
DATA 0, 0, 0, 0, 0, 0, 0xB, 0xB, 0xB, 0xB, 0, 0, 1, 0xB, 0, 2 [cite: 1]
DATA 0xE, 0xF, 0xF, 0xF, 0xF, 0xD, 2, 4, 0, 2, 4, 0, 1, 4, 0, 1 [cite: 1]
DATA 4, 0, 0, 0, 0, 0, 0, 0, 0, 0xC, 0, 0, 0, 0, 0xF, 0xF [cite: 1, 2]
REDIM ampl2data(78) AS _BYTE
DATA 0, 0, 0, 0, 0, 0xA, 0xB, 0xD, 0xE, 0xD, 0xC, 0xC, 0xB, 9, 0xB, 0xB [cite: 3]
DATA 0xC, 0xC, 0xC, 8, 8, 0xC, 8, 0xA, 8, 8, 0xA, 3, 9, 6, 0, 0 [cite: 3]
DATA 0, 0, 0, 0, 0, 0, 3, 5, 3, 4, 0, 0, 0, 5, 0xA, 2 [cite: 3]
DATA 0xE, 0xD, 0xC, 0xD, 0xC, 8, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0 [cite: 3]
DATA 1, 0, 0, 0, 0, 0, 0, 0, 0, 0xA, 0, 0, 0xA, 0, 0, 0 [cite: 3, 4]
REDIM ampl3data(78) AS _BYTE
DATA 0, 0, 0, 0, 0, 8, 7, 8, 8, 1, 1, 0, 1, 0, 7, 5 [cite: 5]
DATA 1, 0, 6, 1, 0, 7, 0, 5, 1, 0, 8, 0, 0, 3, 0, 0 [cite: 5]
DATA 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0xE, 1 [cite: 5]
DATA 9, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 [cite: 5]
DATA 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 5, 0, 0x13, 0x10 [cite: 5, 6]
'END PART 1b2
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
'Converted from render_tabs.h.2a.txt [cite: 1, 2, 3, 4, 5]
REDIM sinus(180) AS UBYTE
' Initialize the sinus array with the given values
DATA 0, 0, 0, 16, 16, 16, 16, 16, 16, 32, 32, 32, 32, 32, 32, 48, 48, 48, 48, 48, 48, 48, 64, 64, 64, 64, 64, 64, 64, 80, 80, 80, 80, 80, 80, 80, 80, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 80, 80, 80, 80, 80, 80, 80, 80, 64, 64, 64, 64, 64, 64, 64, 48, 48, 48, 48, 48, 48, 48, 32, 32, 32, 32, 32, 32, 16, 16, 16, 16, 16, 16, 0, 0, 0, 240, 240, 240, 240, 240, 240, 224, 224, 224, 224, 224, 224, 208, 208, 208, 208, 208, 208, 208, 192, 192, 192, 192, 192, 192, 192, 176, 176, 176, 176, 176, 176, 176, 176, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 176, 176, 176, 176, 176, 176, 176, 176, 192, 192, 192, 192, 192, 192, 192, 208, 208, 208, 208, 208, 208, 208, 224, 224, 224, 224, 224, 224, 240, 240, 240, 240, 240, 240, 0, 0
FOR i = 1 TO 181
READ sinus(i)
NEXT i
'END PART 2a
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
'Converted from render_tabs.h.2b.txt [cite: 1, 2, 3, 4, 5]
REDIM rectangle(143) AS UBYTE
' Initialize the array with the given values
DATA &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90 [cite: 1]
DATA &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90 [cite: 1]
DATA &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90 [cite: 1]
DATA &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90 [cite: 1]
DATA &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90 [cite: 2]
DATA &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90 [cite: 2]
DATA &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90 [cite: 2]
DATA &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H90, &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70 [cite: 2, 3]
DATA &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70 [cite: 3]
DATA &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70 [cite: 3]
DATA &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70 [cite: 3, 4]
DATA &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70 [cite: 4]
DATA &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70, &H70 [cite: 4]
FOR i = 0 TO 143
READ rectangle(i)
NEXT i
'END PART 2b (Note: The comment is included as a QB64 comment) [cite: 5]
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' TRANSLATION OF "render_tabs.h.3.txt"
' Translated from C++ to QB64
' Explanation of Changes:
' uint8_t to DIM ... AS _BYTE: C++'s uint8_t is an unsigned 8-bit integer. QB64's closest equivalent is the _BYTE data type. We use DIM multtable(255) AS _BYTE to declare an array of bytes. The size 255 is correct because the data has 256 values (0 to 255).
' 0x... to Decimal: C++ uses hexadecimal notation (0x). QB64 primarily uses decimal. I've converted all the hexadecimal values to their decimal equivalents in the DATA statements.
' DATA Statements: QB64 uses DATA statements to initialize arrays. The READ statement then populates the multtable array.
' Comments: C++ style comments (//) are replaced with QB64's single-line comment style (').
' No Curly Brace: QB64 doesn't use curly braces to define code blocks like C++. The } at the end of the original C++ code is not needed.
' This QB64 code should accurately represent the data in the provided C++ header file.
REDIM multtable(255) AS _BYTE ' QB64 uses byte for unsigned 8-bit
DATA 0, 0, 0, 0, 0, 0, 0, 0
DATA 0, 0, 0, 0, 0, 0, 0, 0
DATA 0, 0, 1, 1, 2, 2, 3, 3
DATA 4, 4, 5, 5, 6, 6, 7, 7
DATA 0, 1, 2, 3, 4, 5, 6, 7
DATA 8, 9, 10, 11, 12, 13, 14, 15 '0xA to 0xF
DATA 0, 1, 3, 4, 6, 7, 9, 10 '0xA
DATA 12, 13, 15, 16, 18, 19, 21, 22 '0x10 to 0x16
DATA 0, 2, 4, 6, 8, 10, 12, 14 '0xA, 0xC, 0xE
DATA 16, 18, 20, 22, 24, 26, 28, 30 '0x10 to 0x1E
DATA 0, 2, 5, 7, 10, 12, 15, 17 '0xA, 0xC, 0xF, 0x11
DATA 20, 22, 25, 27, 30, 32, 35, 37 '0x14 to 0x25
DATA 0, 3, 6, 9, 12, 15, 18, 21 '0xC, 0xF, 0x12, 0x15
DATA 24, 27, 30, 33, 36, 39, 42, 45 '0x18 to 0x2D
DATA 0, 3, 7, 10, 14, 17, 21, 24 '0x03 to 0x18
DATA 28, 31, 35, 38, 42, 45, 49, 52 '0x1C to 0x34
DATA 0, 252, 248, 244, 240, 236, 232, 228 '0xFC to 0xE4
DATA 224, 220, 216, 212, 208, 204, 200, 196 '0xE0 to 0xC4
DATA 0, 252, 249, 245, 242, 238, 235, 231 '0xFC to 0xE7
DATA 228, 224, 221, 217, 214, 210, 207, 203 '0xE4 to 0xCB
DATA 0, 253, 250, 247, 244, 241, 238, 235 '0xFD to 0xEB
DATA 232, 229, 226, 223, 220, 217, 214, 211 '0xE8 to 0xD3
DATA 0, 253, 251, 248, 246, 243, 241, 238 '0xFD to 0xEE
DATA 236, 233, 231, 228, 226, 223, 221, 218 '0xEC to 0xDA
DATA 0, 254, 252, 250, 248, 246, 244, 242 '0xFE to 0xF2
DATA 240, 238, 236, 234, 232, 230, 228, 226 '0xF0 to 0xE2
DATA 0, 254, 253, 251, 250, 248, 247, 245 '0xFE to 0xF5
DATA 244, 242, 241, 239, 238, 236, 235, 233 '0xF4 to 0xE9
DATA 0, 255, 254, 253, 252, 251, 250, 249 '0xFF to 0xF9
DATA 248, 247, 246, 245, 244, 243, 242, 241 '0xF8 to 0xF1
DATA 0, 255, 255, 254, 254, 253, 253, 252 '0xFF to 0xFC
DATA 252, 251, 251, 250, 250, 249, 249, 248 '0xFC to 0xF8
FOR i = 0 TO 255
READ multtable(i)
NEXT i
'END PART 3 (Comment in original file)
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
'Converted from render_tabs.h.4.txt
REDIM sampleTable(0 To 1279) AS _BYTE '0x500 = 1280
' Initialize the sample table
' SAMPLE DATA
Restore SampleTableData
FOR i = 0 TO 1279
READ sampleTable(i)
NEXT i
SampleTableData:
' 00
Data &H38,&H84,&H6B,&H19,&HC6,&H63,&H18,&H86,&H73,&H98,&HC6,&HB1,&H1C,&HCA,&H31,&H8C,&HC7,&H31,&H88,&HC2,&H30,&H98,&H46,&H31,&H18,&HC6,&H35,&HC,&HCA,&H31,&HC,&HC6
' 20
Data &H21,&H10,&H24,&H69,&H12,&HC2,&H31,&H14,&HC4,&H71,&H08,&H4A,&H22,&H49,&HAB,&H6A,&HA8,&HAC,&H49,&H51,&H32,&HD5,&H52,&H88,&H93,&H6C,&H94,&H22,&H15,&H54,&HD2,&H25
' 40
Data &H96,&HD4,&H50,&HA5,&H46,&H21,&H08,&H85,&H6B,&H18,&HC4,&H63,&H10,&HCE,&H6B,&H18,&H8C,&H71,&H19,&H8C,&H63,&H35,&HC,&HC6,&H33,&H99,&HCC,&H6C,&HB5,&H4E,&HA2,&H99
' 60
Data &H46,&H21,&H28,&H82,&H95,&H2E,&HE3,&H30,&H9C,&HC5,&H30,&H9C,&HA2,&HB1,&H9C,&H67,&H31,&H88,&H66,&H59,&H2C,&H53,&H18,&H84,&H67,&H50,&HCA,&HE3,&HA,&HAC,&HAB,&H30
' 80
Data &HAC,&H62,&H30,&H8C,&H63,&H10,&H94,&H62,&HB1,&H8C,&H82,&H28,&H96,&H33,&H98,&HD6,&HB5,&H4C,&H62,&H29,&HA5,&H4A,&HB5,&H9C,&HC6,&H31,&H14,&HD6,&H38,&H9C,&H4B,&HB4
' A0
Data &H86,&H65,&H18,&HAE,&H67,&H1C,&HA6,&H63,&H19,&H96,&H23,&H19,&H84,&H13,&H08,&HA6,&H52,&HAC,&HCA,&H22,&H89,&H6E,&HAB,&H19,&H8C,&H62,&H34,&HC4,&H62,&H19,&H86,&H63
' C0
Data &H18,&HC4,&H23,&H58,&HD6,&HA3,&H50,&H42,&H54,&H4A,&HAD,&H4A,&H25,&H11,&H6B,&H64,&H89,&H4A,&H63,&H39,&H8A,&H23,&H31,&H2A,&HEA,&HA2,&HA9,&H44,&HC5,&H12,&HCD,&H42
' E0
Data &H34,&H8C,&H62,&H18,&H8C,&H63,&H11,&H48,&H66,&H31,&H9D,&H44,&H33,&H1D,&H46,&H31,&H9C,&HC6,&HB1,&HC,&HCD,&H32,&H88,&HC4,&H73,&H18,&H86,&H73,&H08,&HD6,&H63,&H58
' 100
Data &H07,&H81,&HE0,&HF0,&H3C,&H07,&H87,&H90,&H3C,&H7C,&HF,&HC7,&HC0,&HC0,&HF0,&H7C,&H1E,&H07,&H80,&H80,&H00,&H1C,&H78,&H70,&HF1,&HC7,&H1F,&HC0,&HC,&HFE,&H1C,&H1F
' 120
Data &H1F,&HE,&HA,&H7A,&HC0,&H71,&HF2,&H83,&H8F,&H03,&HF,&HF,&HC,&H00,&H79,&HF8,&H61,&HE0,&H43,&HF,&H83,&HE7,&H18,&HF9,&HC1,&H13,&HDA,&HE9,&H63,&H8F,&HF,&H83
' 140
Data &H83,&H87,&HC3,&H1F,&H3C,&H70,&HF0,&HE1,&HE1,&HE3,&H87,&HB8,&H71,&HE,&H20,&HE3,&H8D,&H48,&H78,&H1C,&H93,&H87,&H30,&HE1,&HC1,&HC1,&HE4,&H78,&H21,&H83,&H83,&HC3
' 160
Data &H87,&H06,&H39,&HE5,&HC3,&H87,&H07,&HE,&H1C,&H1C,&H70,&HF4,&H71,&H9C,&H60,&H36,&H32,&HC3,&H1E,&H3C,&HF3,&H8F,&HE,&H3C,&H70,&HE3,&HC7,&H8F,&HF,&HF,&HE,&H3C
' 180
Data &H78,&HF0,&HE3,&H87,&H06,&HF0,&HE3,&H07,&HC1,&H99,&H87,&HF,&H18,&H78,&H70,&H70,&HFC,&HF3,&H10,&HB1,&H8C,&H8C,&H31,&H7C,&H70,&HE1,&H86,&H3C,&H64,&H6C,&HB0,&HE1
' 1A0
Data &HE3,&HF,&H23,&H8F,&HF,&H1E,&H3E,&H38,&H3C,&H38,&H7B,&H8F,&H07,&HE,&H3C,&HF4,&H17,&H1E,&H3C,&H78,&HF2,&H9E,&H72,&H49,&HE3,&H25,&H36,&H38,&H58,&H39,&HE2,&HDE
' 1C0
Data &H3C,&H78,&H78,&HE1,&HC7,&H61,&HE1,&HE1,&HB0,&HF0,&HF0,&HC3,&HC7,&HE,&H38,&HC0,&HF0,&HCE,&H73,&H73,&H18,&H34,&HB0,&HE1,&HC7,&H8E,&H1C,&H3C,&HF8,&H38,&HF0,&HE1
' 1E0
Data &HC1,&H8B,&H86,&H8F,&H1C,&H78,&H70,&HF0,&H78,&HAC,&HB1,&H8F,&H39,&H31,&HDB,&H38,&H61,&HC3,&HE,&HE,&H38,&H78,&H73,&H17,&H1E,&H39,&H1E,&H38,&H64,&HE1,&HF1,&HC1
' 200
Data &H4E,&HF,&H40,&HA2,&H02,&HC5,&H8F,&H81,&HA1,&HFC,&H12,&H08,&H64,&HE0,&H3C,&H22,&HE0,&H45,&H07,&H8E,&HC,&H32,&H90,&HF0,&H1F,&H20,&H49,&HE0,&HF8,&HC,&H60,&HF0
' 220
Data &H17,&H1A,&H41,&HAA,&HA4,&HD0,&H8D,&H12,&H82,&H1E,&H1E,&H03,&HF8,&H3E,&H03,&HC,&H73,&H80,&H70,&H44,&H26,&H03,&H24,&HE1,&H3E,&H04,&H4E,&H04,&H1C,&HC1,&H09,&HCC
' 240
Data &H9E,&H90,&H21,&H07,&H90,&H43,&H64,&HC0,&HF,&HC6,&H90,&H9C,&HC1,&H5B,&H03,&HE2,&H1D,&H81,&HE0,&H5E,&H1D,&H03,&H84,&HB8,&H2C,&HF,&H80,&HB1,&H83,&HE0,&H30,&H41
' 260
Data &H1E,&H43,&H89,&H83,&H50,&HFC,&H24,&H2E,&H13,&H83,&HF1,&H7C,&H4C,&H2C,&HC9,&HD,&H83,&HB0,&HB5,&H82,&HE4,&HE8,&H06,&H9C,&H07,&HA0,&H99,&H1D,&H07,&H3E,&H82,&H8F
' 280
Data &H70,&H30,&H74,&H40,&HCA,&H10,&HE4,&HE8,&HF,&H92,&H14,&H3F,&H06,&HF8,&H84,&H88,&H43,&H81,&HA,&H34,&H39,&H41,&HC6,&HE3,&H1C,&H47,&H03,&HB0,&HB8,&H13,&HA,&HC2
' 2A0
Data &H64,&HF8,&H18,&HF9,&H60,&HB3,&HC0,&H65,&H20,&H60,&HA6,&H8C,&HC3,&H81,&H20,&H30,&H26,&H1E,&H1C,&H38,&HD3,&H01,&HB0,&H26,&H40,&HF4,&HB,&HC3,&H42,&H1F,&H85,&H32
' 2C0
Data &H26,&H60,&H40,&HC9,&HCB,&H01,&HEC,&H11,&H28,&H40,&HFA,&H04,&H34,&HE0,&H70,&H4C,&H8C,&H1D,&H07,&H69,&H03,&H16,&HC8,&H04,&H23,&HE8,&HC6,&H9A,&HB,&H1A,&H03,&HE0
' 2E0
Data &H76,&H06,&H05,&HCF,&H1E,&HBC,&H58,&H31,&H71,&H66,&H00,&HF8,&H3F,&H04,&HFC,&HC,&H74,&H27,&H8A,&H80,&H71,&HC2,&H3A,&H26,&H06,&HC0,&H1F,&H05,&HF,&H98,&H40,&HAE
' 300
Data &H01,&H7F,&HC0,&H07,&HFF,&H00,&HE,&HFE,&H00,&H03,&HDF,&H80,&H03,&HEF,&H80,&H1B,&HF1,&HC2,&H00,&HE7,&HE0,&H18,&HFC,&HE0,&H21,&HFC,&H80,&H3C,&HFC,&H40,&HE,&H7E
' 320
Data &H00,&H3F,&H3E,&H00,&HF,&HFE,&H00,&H1F,&HFF,&H00,&H3E,&HF0,&H07,&HFC,&H00,&H7E,&H10,&H3F,&HFF,&H00,&H3F,&H38,&HE,&H7C,&H01,&H87,&HC,&HFC,&HC7,&H00,&H3E,&H04
' 340
Data &HF,&H3E,&H1F,&HF,&HF,&H1F,&HF,&H02,&H83,&H87,&HCF,&H03,&H87,&HF,&H3F,&HC0,&H07,&H9E,&H60,&H3F,&HC0,&H03,&HFE,&H00,&H3F,&HE0,&H77,&HE1,&HC0,&HFE,&HE0,&HC3
' 360
Data &HE0,&H01,&HDF,&HF8,&H03,&H07,&H00,&H7E,&H70,&H00,&H7C,&H38,&H18,&HFE,&HC,&H1E,&H78,&H1C,&H7C,&H3E,&HE,&H1F,&H1E,&H1E,&H3E,&H00,&H7F,&H83,&H07,&HDB,&H87,&H83
' 380
Data &H07,&HC7,&H07,&H10,&H71,&HFF,&H00,&H3F,&HE2,&H01,&HE0,&HC1,&HC3,&HE1,&H00,&H7F,&HC0,&H05,&HF0,&H20,&HF8,&HF0,&H70,&HFE,&H78,&H79,&HF8,&H02,&H3F,&HC,&H8F,&H03
' 3a0
Data &HF,&H9F,&HE0,&HC1,&HC7,&H87,&H03,&HC3,&HC3,&HB0,&HE1,&HE1,&HC1,&HE3,&HE0,&H71,&HF0,&H00,&HFC,&H70,&H7C,&HC,&H3E,&H38,&HE,&H1C,&H70,&HC3,&HC7,&H03,&H81,&HC1
' 3c0
Data &HC7,&HE7,&H00,&HF,&HC7,&H87,&H19,&H09,&HEF,&HC4,&H33,&HE0,&HC1,&HFC,&HF8,&H70,&HF0,&H78,&HF8,&HF0,&H61,&HC7,&H00,&H1F,&HF8,&H01,&H7C,&HF8,&HF0,&H78,&H70,&H3C
' 3e0
Data &H7C,&HCE,&HE,&H21,&H83,&HCF,&H08,&H07,&H8F,&H08,&HC1,&H87,&H8F,&H80,&HC7,&HE3,&H00,&H07,&HF8,&HE0,&HEF,&H00,&H39,&HF7,&H80,&HE,&HF8,&HE1,&HE3,&HF8,&H21,&H9F
' 400
Data &HC0,&HFF,&H03,&HF8,&H07,&HC0,&H1F,&HF8,&HC4,&H04,&HFC,&HC4,&HC1,&HBC,&H87,&HF0,&HF,&HC0,&H7F,&H05,&HE0,&H25,&HEC,&HC0,&H3E,&H84,&H47,&HF0,&H8E,&H03,&HF8,&H03
' 420
Data &HFB,&HC0,&H19,&HF8,&H07,&H9C,&HC,&H17,&HF8,&H07,&HE0,&H1F,&HA1,&HFC,&HF,&HFC,&H01,&HF0,&H3F,&H00,&HFE,&H03,&HF0,&H1F,&H00,&HFD,&H00,&HFF,&H88,&HD,&HF9,&H01
' 440
Data &HFF,&H00,&H70,&H07,&HC0,&H3E,&H42,&HF3,&HD,&HC4,&H7F,&H80,&HFC,&H07,&HF0,&H5E,&HC0,&H3F,&H00,&H78,&H3F,&H81,&HFF,&H01,&HF8,&H01,&HC3,&HE8,&HC,&HE4,&H64,&H8F
' 460
Data &HE4,&HF,&HF0,&H07,&HF0,&HC2,&H1F,&H00,&H7F,&HC0,&H6F,&H80,&H7E,&H03,&HF8,&H07,&HF0,&H3F,&HC0,&H78,&HF,&H82,&H07,&HFE,&H22,&H77,&H70,&H02,&H76,&H03,&HFE,&H00
' 480
Data &HFE,&H67,&H00,&H7C,&HC7,&HF1,&H8E,&HC6,&H3B,&HE0,&H3F,&H84,&HF3,&H19,&HD8,&H03,&H99,&HFC,&H09,&HB8,&HF,&HF8,&H00,&H9D,&H24,&H61,&HF9,&HD,&H00,&HFD,&H03,&HF0
' 4a0
Data &H1F,&H90,&H3F,&H01,&HF8,&H1F,&HD0,&HF,&HF8,&H37,&H01,&HF8,&H07,&HF0,&HF,&HC0,&H3F,&H00,&HFE,&H03,&HF8,&HF,&HC0,&H3F,&H00,&HFA,&H03,&HF0,&HF,&H80,&HFF,&H01
' 4c0
Data &HB8,&H07,&HF0,&H01,&HFC,&H01,&HBC,&H80,&H13,&H1E,&H00,&H7F,&HE1,&H40,&H7F,&HA0,&H7F,&HB0,&H00,&H3F,&HC0,&H1F,&HC0,&H38,&HF,&HF0,&H1F,&H80,&HFF,&H01,&HFC,&H03
' 4e0
Data &HF1,&H7E,&H01,&HFE,&H01,&HF0,&HFF,&H00,&H7F,&HC0,&H1D,&H07,&HF0,&HF,&HC0,&H7E,&H06,&HE0,&H07,&HE0,&HF,&HF8,&H06,&HC1,&HFE,&H01,&HFC,&H03,&HE0,&HF,&H00,&HFC
' END PART 4
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' END render_tabs.h
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' BEGIN render.c
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' Initialize arrays
' mouth formants (F1) 5..29
Data 0,0,0,0,0,10,14,19,24,27,23,21,16,20,14,18,14,18,18,16,13,15,11,18,14,11,9,6,6,6
For i = 5 To 29
Read mouthFormants5_29(i)
Next i
' throat formants (F2) 5..29
Data 255,255,255,255,255,84,73,67,63,40,44,31,37,45,73,49,36,30,51,37,29,69,24,50,30,24,83,46,54,86
For i = 5 To 29
Read throatFormants5_29(i)
Next i
' formant 1 frequencies (mouth) 48..53
Data 19,27,21,27,18,13
For i = 0 To 5
Read mouthFormants48_53(i)
Next i
' formant 2 frequencies (throat) 48..53
Data 72,39,31,43,30,34
For i = 0 To 5
Read throatFormants48_53(i)
Next i
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' END render.c
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' *** HERE IS WHERE THE MAIN EXECUTION (MENU ETC.) WOULD GO
' For now we'll hardcode the test routines to run...
TestHello
TestPhonemes
' *** END MAIN EXECUTION
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' Begin test_hello.c
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' This is a conversion of the C code to QB64PE
' Note: QB64PE doesn't directly include or handle C header files or pointers in the same way.
' This conversion assumes the "sam.h" and related functions are available or
' re-implemented in QB64. For this simple example, we'll focus on the core logic.
' The WriteWav function is stubbed out as its C implementation returns 0.
' GetBuffer and GetBufferLength are assumed to be QB64 equivalents (needs actual implementation).
' Key Differences and Considerations:
' Header Files and Includes: QB64PE doesn't use #include. You'll need to either rewrite the functionality of the C header files (like "sam.h") in QB64 or use DECLARE FUNCTION to interface with external libraries (which is complex and beyond the scope of this simple conversion). In this case, I've provided a simplified version that assumes the SAMMain, SetInput, GetBuffer, and GetBufferLength functions exist. You'll need to implement these in QB64 to make it fully functional.
' Data Types: C uses int32_t, int8_t, char*. QB64PE uses _INTEGER (for 32-bit integers), strings, etc. I've made the appropriate substitutions.
' Pointers: C uses pointers extensively. QB64PE is higher-level and manages memory more automatically. Strings are used instead of char*.
' String Handling: QB64PE's string handling is different from C.
' Function Declarations: QB64PE uses DECLARE FUNCTION to declare functions, especially if they are external.
' Error Handling: QB64PE's error handling is different.
' Comments: QB64PE uses ' for comments.
' Division: Integer division in QB64 is done with the backslash \ operator.
' Input: I've added an INPUT statement to get the text from the user.
' Simulations: I've added "simulation" code blocks to represent the calls to the external C functions. You'll need to replace these with actual QB64 implementations or equivalents.
' To make this fully working, you would need to:
' Implement SetInput, SAMMain, GetBuffer, GetBufferLength in QB64PE: This is the most challenging part, as it likely involves either porting the C code or finding a QB64 library that does the same thing as SAM.
' Handle WAV Writing: You'd need to find a QB64 library or write code to create a WAV file from the buffer data.
' This conversion provides the basic structure and logic, but the core SAM functionality needs to be implemented in QB64PE for it to be complete.
' *** NOTE: probably need to call Init before anything
' Main program
Sub TestHello
INPUT "Enter text to speak (all caps, include phonemes like '[')", input$
' Set the input (assuming SetInput$ function exists)
' input$ = "HELLO WORLD [" ' Hardcoded input replaced by user input
' SetInput input$
' Simulate SetInput (replace with actual QB64 implementation if available)
PRINT "Setting input to: "; input$
' Run SAMMain (assuming SAMMain function exists and returns 0 for false, non-zero for true)
' samResult = SAMMain()
' IF samResult = 0 THEN
' PRINT "SAMMain failed"
' SYSTEM
' END IF
'Simulate SAMMain (replace with actual QB64 implementation)
PRINT "Simulating SAMMain..."
samResult = -1 ' Simulate success
IF samResult = 0 THEN
PRINT "SAMMain failed"
END
END IF
' Get the buffer and its length (assuming these functions exist)
' buffer$ = GetBuffer$()
' bufferLength = GetBufferLength()
'Simulate GetBuffer and GetBufferLength
buffer$ = "Simulated speech data"
bufferLength = 1000
' Call WriteWav
wavResult = WriteWav(buffer$, bufferLength \ 50) ' Integer division in QB64 is '\'
PRINT "WriteWav returned: "; wavResult
PRINT "Done!"
SLEEP
'END
End Sub ' TestHello
' Stub for WriteWav (since the C version just returns 0)
FUNCTION WriteWav (buffer AS STRING, bufferlength AS _INTEGER) AS _INTEGER
WriteWav = 0
END FUNCTION
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' End test_hello.c
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' Begin test_phonemes.c
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' QB64 Implementation Notes:
' 1. C-style string handling is replaced with QB64 strings.
' 2. C pointers are not directly used; QB64 uses string manipulation functions.
' 3. File I/O is adapted to QB64's file handling (OPEN, CLOSE, GET, EOF).
' 4. Memory allocation (malloc, calloc) is not directly needed in this simple conversion,
' but for more complex C code, QB64's dynamic arrays or string manipulation would be used.
' 5. Error handling is simplified; QB64's error handling can be expanded if needed.
' 6. The TextToPhonemes, ReciterVerify, trim$, and compare functions MUST be implemented
' separately in QB64, as they are external to this code snippet. This is the most
' complex part of the conversion, as it involves porting the core logic of the
' phoneme conversion.
' 7. The `assert` macro from C is not directly available; QB64 error handling
' (e.g., IF ... THEN STOP or custom error routines) can be used.
' 8. Command-line arguments (argc, argv) are accessed differently in QB64 (using COMMAND$).
' 9. This QB64 code assumes the existence of `SAM_TEST_DIR`, `TextToPhonemes`,
' `ReciterVerify`, `trim$`, and `compare%`. You'll need to provide QB64
' implementations of these.
'
' Key Differences and Considerations:
' String Handling: QB64 uses its own string functions (e.g., LEFT$, MID$, LEN, UCASE$) instead of C-style character arrays and strcpy, strcat. Fixed-length strings are used where a specific buffer size is needed.
' File I/O: QB64's file I/O functions (OPEN, CLOSE, GET, EOF) are used instead of C's fopen, fread, feof.
' Memory Management: QB64 handles memory management differently; dynamic memory allocation like malloc is not directly needed in this case. For more complex C code, you might use dynamic arrays (REDIM) or string manipulation.
' Error Handling: QB64's error handling is simpler. I've used basic IF statements and PRINT for error messages. You can expand this with more robust error routines if needed.
' Data Structures: C structs are replaced with QB64 TYPE definitions.
' Function Declarations: QB64 uses DECLARE FUNCTION and DECLARE SUB to declare functions.
' Comments: QB64 uses ' for comments.
' Missing Functions: The functions TextToPhonemes, ReciterVerify, trim$, and compare% are assumed to exist but need to be implemented in QB64. This is the most significant part of the port.
' Command-Line Arguments: QB64 uses COMMAND$ to access command-line arguments, not argc and argv[].
' Assertions: C's assert is replaced with IF conditions and STOP or custom error handling.
' To complete this conversion, you will need to provide QB64 implementations for:
' TextToPhonemes% (text$) (This is the core phoneme conversion logic)
' ReciterVerify ()
' trim$ (text$) (A function to remove leading/trailing whitespace)
' compare% (match$, temp$) (A function to compare strings)
' This QB64 code provides a structural equivalent to the C code snippet. The missing function implementations are crucial for it to be fully functional.
' Explanation of Changes and Considerations:
' Includes: QB64PE doesn't use #include. The functionality of sam.h, reciter.h, stdio.h, stdlib.h, ctype.h, string.h, and stdint.h needs to be replicated using QB64PE's built-in functions or external libraries (if available). In this conversion, I've mocked the sam and reciter calls, as I don't have those libraries. You'll need to replace the mock with the actual QB64PE code to interface with them.
' Defines: #define is replaced with CONST.
' Data Types: C's char is generally equivalent to QB64PE's STRING. size_t is replaced with LONG.
' Arrays: C-style array initialization is not directly supported. I've used a TYPE to define a structure for each test case and then dimensioned an array of that type. The test cases are then manually populated. This is the most tedious part of the conversion.
' Strings: QB64PE uses $ to denote string variables (e.g., a AS STRING). String manipulation functions are different (e.g., MID$, LEFT$).
' Function Definitions: QB64PE requires function declarations (DECLARE SUB/FUNCTION) before they are used. Functions return values directly by assigning to the function name (e.g., compare$ = "TRUE"). Subs don't return values.
' Boolean Logic: QB64PE uses TRUE and FALSE (or -1 and 0) for boolean values. I've used string comparisons for TRUE/FALSE in compare$ for clarity, but you could use -1/0.
' Character Comparisons: C's character comparisons work directly with ASCII values. QB64PE uses ASC() to get the ASCII value of a character and CHR$() to get the character from an ASCII value. The check for 0x80 is done using ASC(MID$(b, j, 1)) > 127.
' trim() function: This function now uses QB64PE string functions to achieve the same result.
' Missing sam and reciter: The most important missing piece is the actual call to the sam and reciter functions. You'll need to replace the line temp = "MOCKED OUTPUT FOR: " + test_case(i).input with the correct QB64PE code to interface with those libraries. This might involve external libraries or DLL calls, depending on how sam and reciter are implemented.
' Error Handling: The C code doesn't have much error handling. You might want to add more robust error checking in the QB64PE version.
' Output: printf is replaced with PRINT.
' To make this fully functional, you MUST:
' Implement the sam and reciter calls: This is the core of the program. You'll need to find QB64PE-compatible versions or write QB64PE code that does the same thing. This is the most complex part and depends entirely on the sam and reciter libraries.
' Compile and Run: Save the code as a .bas file and compile/run it in QB64PE.
' This conversion provides the basic structure and logic. The crucial part of integrating sam and reciter is left as an exercise for you, as it requires knowledge of those specific libraries.
Sub TestPhonemes
'Constants
CONST END_MARKER = "0,0" ' Using a string to represent the end marker
CONST C_SIZE = 1024
' TYPE definition for test_state_t
TYPE TestState
fails AS LONG
passes AS LONG
END TYPE
'Data Structure
TYPE TestCase
input AS STRING
expected AS STRING
END TYPE
'Test State
TYPE TestState
fails AS LONG
passes AS LONG
END TYPE
DIM temp AS STRING * C_SIZE ' Fixed-length string
DIM test_case(1 TO 20) AS TestCase ' Adjust size as needed based on your test data
DIM test_state AS TestState
DIM state AS TestState
' *** NOTE
' PROBABLY NEED TO CALL Init BEFORE ANYTHING ?
' Initialize test cases (manually, since we can't directly translate C's array initialization)
'------------------------------------------------------------------------------------------
' Manually populate the test cases. This is tedious, but necessary in QB64.
' Note: The index in QB64 starts at 1 by default, so adjust accordingly.
' Also, QB64 doesn't have direct equivalent for C's string literals with embedded newlines.
' We'll use multiline strings (might need QB64PE specific syntax) or concatenation.
test_case(1).input = "HELLO"
test_case(1).expected = " /HEHLOW"
test_case(2).input = "WIZARD"
test_case(2).expected = " WIHZAA5RD"
test_case(3).input = "TWO THINGS"
test_case(3).expected = " TUW THIHNXZ"
test_case(4).input = "ANOTHER TRAVELER"
test_case(4).expected = " AENAH5DHER TRAEVIY4LER"
test_case(5).input = "HELLO, MY NAME IS SAM."
test_case(5).expected = " /HEHLOW, MAY NEYM IHZ SAEM."
test_case(6).input = "THE SKY ABOVE THE PORT WAS THE COLOR OF TELEVISION, TUNED TO A DEAD CHANNEL."
test_case(6).expected = " DHAX SKAY AEBAH4V DHAX PAORT WAHZ DHAX KAALER AHV TEHLEHVIHZHUN, TUWND TUX AH DEHDCHAENEHL."
test_case(7).input = "IT'S NOT LIKE I'M USING, CASE HEARD SOMEONE SAY, AS HE SHOULDERED HIS WAY THROUGH THE CROWD AROUND THE DOOR OF THE CHAT."
test_case(7).expected = " IHTS NAAT LAY5K IHM YUWZIHNX, KEY4S /HIY5RD SAHMWAHN SEY5, AEZ /HIY SHUH5DIY4RD /HIHSWEY5 THRUW4 DHAX KROWD AXRAWND DHAX DOH5R AHV DHAX CHAET."
test_case(8).input = "ITS LIKE MY BODYS DEVELOPED THIS MASSIVE DRUG DEFICIENCY."
test_case(8).expected = " IHTS LAY5K MAY BAADIYS DIHVEHLOW5PT DHIHS MAESIHV DRAHG DIHFIHSHEHNSIY."
test_case(9).input = "IT WAS A SPRAWL VOICE AND A SPRAWL JOKE."
test_case(9).expected = " IHT WAHZ AH SPRAO5L VOY5S AEND AH SPRAO5L JOW5K."
test_case(10).input = "THE CHATSUBO WAS A BAR FOR PROFESSIONAL EXPATRIATES YOU COULD DRINK THERE FOR A WEEK AND NEVER HEAR TWO WORDS IN JAPANESE."
test_case(10).expected = " DHAX CHAETSUWBOW WAHZ AH BAA5R FAOR PROW5FEHSHUNUL EHKSPAETRIHEYTS YUW KUH5D DRIHNXK DHEHRFER AH WIY4K AEND NEH4VER /HIY5R TUW WERDZ IHN JAEPEYNIY4Z."
test_case(11).input = "RATZ WAS TENDING BAR, HIS PROSTHETIC ARM JERKING MONOTONOUSLY AS HE FILLED A TRAY OF GLASSES WITH DRAFT KIRIN."
test_case(11).expected = " RAETZ WAHZ TEHNDIHNX BAA5R, /HIHZ PROWSTHEHTIHK AA5RM JERKIHNX MAHNAATUNAXSLIY AEZ /HIY FIHLEHDAH TREY5 AHV GLAESIHZ WIHTH"
test_case(12).input = "HE SAW CASE AND SMILED, HIS TEETH A WEB WORK OF EAST EUROPEAN STEEL AND BROWN DECAY."
test_case(12).expected = " /HIY SAO5 KEY4S AEND SMAY5LD, /HIHZ TIY4TH AH WEHB WERK AHV IY5ST YUW5RAAPIY5N STIY4L AENDBROWN DIHKEY5."
test_case(13).input = "CASE FOUND A PLACE AT THE BAR, BETWEEN THE UNLIKELY TAN ON ONE OF LONNY ZONE'S WHORES AND THE CRISP NAVAL UNIFORM OF A TALL AFRICAN WHOSE CHEEKBONES WERE RIDGED WITH PRECISE ROWS OF TRIBAL SCARS."
test_case(13).expected = " KEY4S FAWND AH PLEYS AET DHAX BAA5R, BEHTWIY4N DHIY AHNLIHKLIY TAEN AAN WAHN AHV LAHNIYZUNEHS /HUWRZ AEND DHAX KRIHSP NAEVUL YUWNIHFAORM AHV AH TAOL AEFRIHKAEN /HUWZEHKIY4KBOW5NZ WER RIHDJD WIHTH PREHSAYZ ROWZ AHV TRIHBUL SKAA5RZ."
test_case(14).input = "WAGE WAS IN HERE EARLY, WITH TWO JOE BOYS, RATZ SAID, SHOVING A DRAFT ACROSS THE BAR WITH HIS GOOD HAND."
test_case(14).expected = " WEYJ WAHZ IHN /HIYR ER5LIY, WIHTH TUW JOW BOYZ, RAETZ SEHD, SHAH4VIHNX AH DRAEFTAEKRAO5S DHAX BAA5R WIHTH /HIHZ GUH5D /HAEND."
test_case(15).input = "MAYBE SOME BUSINESS WITH YOU, CASE. CASE SHRUGGED."
test_case(15).expected = " MEY5B SAHM BIH4ZIHNEHS WIHTH YUW, KEY4S. KEY4S SHRAH5GD."
test_case(16).input = "THE GIRL TO HIS RIGHT GIGGLED AND NUDGED HIM."
test_case(16).expected = " DHAX GERL TUX /HIHZ RAY4T GIHGULD AEND NAH5DJD /HIHM."
' Assuming END is a sentinel value, find the end of the data.
last_test_case = 16 'Hardcoded for now, find a better way if possible
'Main Program
'No direct equivalent to C's main, so the following code is the main logic
FOR i = 1 TO last_test_case
' call sam to process input, store in temp
' MOCKING sam and reciter calls for now
temp = "MOCKED OUTPUT FOR: " + test_case(i).input ' Replace with actual SAM and reciter calls
trim ' Remove any trailing garbage from temp
IF compare$(temp, test_case(i).expected) THEN
test_state.passes = test_state.passes + 1
PRINT "PASS: "; test_case(i).input
ELSE
test_state.fails = test_state.fails + 1
PRINT "FAIL: "; test_case(i).input
PRINT " Expected: "; test_case(i).expected
PRINT " Actual: "; temp
END IF
NEXT i
PRINT
PRINT "--- SUMMARY ---"
PRINT "Passes: "; test_state.passes
PRINT "Fails: "; test_state.fails
'END 'End of main program
' Main program starts here
' Initialize state
state.fails = 0
state.passes = 0
' Verify reciter tables
ReciterVerify
' Test cases (need to be adapted based on how test_case is structured)
DATA "test1", "expected1", "test2", "expected2", "" ' Example data - adjust as needed
READ test_case1$, test_case2$
DO WHILE LEN(test_case1$) > 0
IF try_test$(test_case1$, test_case2$) = "0" THEN
PRINT "x";
state.fails = state.fails + 1
ELSE
PRINT ".";
state.passes = state.passes + 1
END IF
READ test_case1$, test_case2$
LOOP
' Input test files (assuming SAM_TEST_DIR is a constant)
file_test$("\\assets\\words.txt", state) ' Need to adjust path as needed
file_test$("\\assets\\sentences.txt", state) ' Need to adjust path as needed
' Print summary
PRINT
PRINT "total : "; state.fails + state.passes
PRINT "failed: "; state.fails
PRINT "passed: "; state.passes
IF state.fails > 0 THEN
INPUT "Press Enter to continue", a$
END IF
'SYSTEM ' End program
End Sub ' TestPhonemes
'Function Definitions
FUNCTION compare$ (a AS STRING, b AS STRING)
compare$ = "TRUE" ' Default to true
alen = LEN(a)
blen = LEN(b)
i = 1
j = 1
DO WHILE i <= alen AND j <= blen
IF MID$(b, j, 1) > CHR$(127) THEN 'Simulate checking for 0x80 (not directly possible)
EXIT DO
END IF
IF MID$(a, i, 1) <> MID$(b, j, 1) THEN
compare$ = "FALSE"
EXIT FUNCTION
END IF
i = i + 1
j = j + 1
LOOP
IF i <= alen OR (j <= blen AND ASC(MID$(b,j,1)) < 128) THEN ' Check if either string has leftover
compare$ = "FALSE"
END IF
END FUNCTION
SUB trim
FOR i = 1 TO LEN(temp)
IF ASC(MID$(temp, i, 1)) > 127 THEN 'Simulate checking for 0x80
temp = LEFT$(temp, i - 1)
EXIT SUB
END IF
NEXT i
END SUB
' Function: try_test
' Tests a given input string against an expected phoneme output.
' Parameters:
' in$ - The input string to convert to phonemes.
' match$ - The expected phoneme output.
' Returns:
' 1 if the actual output matches the expected output, 0 otherwise.
FUNCTION try_test$ (in$, match$)
' Assuming C_SIZE is defined as a constant elsewhere (e.g., CONST C_SIZE = 256)
DIM temp AS STRING * 256 ' Adjust size as needed, using a fixed-length string
temp = STRING$(256, 128) ' Initialize with ASCII 128 (0x80) - QBasic/QB64 doesn't have memset like C
temp = in$
temp = temp + "["
' Assuming TextToPhonemes is a QB64 function
IF TextToPhonemes(temp) = 0 THEN ' Need to adapt TextToPhonemes to QB64 syntax and string handling
RETURN "0"
END IF
temp = LEFT$(temp, 255) ' QB64 string length is limited; ensure null termination isn't an issue
temp = trim$(temp) ' Need to implement a trim$ function in QB64
IF StrComp(match$, temp, 0) <> 0 THEN ' QB64 string comparison (0 = case-sensitive)
PRINT
PRINT "sent"
PRINT "'" + in$ + "'"
PRINT "expected"
PRINT "'" + match$ + "'"
PRINT "got"
PRINT "'" + temp + "'"
RETURN "0"
END IF
RETURN "1"
END FUNCTION
' Function: read_line
' Reads a line from a file.
' Parameters:
' fd - The file handle.
' dst$ - The string to store the read line.
' max_len - The maximum number of characters to read. Not directly used in QB64 implementation
' Returns:
' The length of the read line.
FUNCTION read_line% (fd AS LONG, dst$) ' QB64 doesn't have size_t, using INTEGER
DIM ptr AS LONG
DIM size AS INTEGER
DIM ch AS STRING * 1
size = 0
DO
IF EOF(fd) THEN
RETURN 0
END IF
GET #fd, , ch
IF LEN(ch) = 0 THEN
RETURN 0
END IF
IF ch = CHR$(10) THEN
EXIT DO
END IF
IF ch = CHR$(13) THEN
ELSE
dst$ = dst$ + UCASE$(ch) ' QB64 UCASE$ for toupper
size = size + 1
END IF
LOOP
read_line% = size
END FUNCTION
' Function: file_test
' Tests phoneme conversion on lines from a file.
' Parameters:
' path$ - The path to the test file.
' state - A structure to track test results. Must be adapted for QB64
' Returns:
' 1 if the test completes successfully, 0 otherwise.
FUNCTION file_test% (path$, state AS TestState) ' Assuming TestState is a TYPE
DIM fd AS LONG
OPEN path$ FOR BINARY AS #fd
IF LOF(fd) = 0 THEN ' Instead of fd = 0
file_test% = 0
EXIT FUNCTION
END IF
DIM temp1 AS STRING
DIM temp2 AS STRING
DIM len AS INTEGER
DO
len = read_line%(fd, temp1)
IF len = 0 THEN
EXIT DO
END IF
temp1 = temp1 + "["
temp2 = temp1
IF TextToPhonemes(temp1) THEN ' Adapt TextToPhonemes for QB64
PRINT ".";
state.passes = state.passes + 1
ELSE
PRINT "x";
PRINT
PRINT temp2
state.fails = state.fails + 1
END IF
temp1 = "" ' Reset temp1 for next loop
LOOP
CLOSE #fd
file_test% = 1
END FUNCTION
' Main program
' Parameters:
' argc - Number of command-line arguments. Not directly used in QB64
' argv$() - Array of command-line arguments. Not directly used in QB64
' Returns:
' The number of failed tests.
'
' QB64 adaptation notes:
' - argc and argv are not directly available in the same way as in C. QB64 has COMMAND$ to get the command line.
' - Structures (test_state_t) are replaced with TYPE definitions.
' - File I/O is adapted to QB64's file handling.
' - String manipulation uses QB64's built-in functions.
' - Assumes SAM_TEST_DIR is defined as a constant.
' - Error handling is simplified.
' - The TextToPhonemes, ReciterVerify, trim$, and compare functions need to be implemented in QB64.
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' End test_phonemes.c
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' BEGIN sam.h
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' Converted from sam.h.txt [cite: 1, 2, 3, 4, 5, 6, 7]
' Explanation of Conversion Choices:
' #ifndef, #define, #include: These C preprocessor directives are not directly translatable to QB64. QB64 doesn't use header files in the same way. The code within the #ifndef block is essentially the content of the header, so I've just included the declarations.
' stdint.h: This header provides specific integer types. QB64 has its own equivalents:
' int8_t -> _BYTE (signed 8-bit integer)
' int32_t -> _INTEGER (signed 32-bit integer)
' uint8_t -> _BYTE (unsigned 8-bit integer - QB64's _BYTE can hold unsigned values)
' Function/Subroutine Declarations: In C, you declare functions. In QB64, you use DECLARE FUNCTION for functions (which return values) and DECLARE SUB for subroutines (which don't).
' const int8_t* _input: C uses pointers. QB64 is simpler in this case, and we can pass a string. So, I changed this to DECLARE SUB SetInput (input AS STRING).
' Return Types: QB64 requires you to specify the return type of a function using AS <type>.
' int8_t* GetBuffer(): C returns a pointer to the buffer. QB64 doesn't directly work with pointers in the same way for strings. I've changed this to return a string: DECLARE FUNCTION GetBuffer$ () AS STRING. The $ is a QB64 type suffix indicating a string return type.
' Comments: C-style comments (//) are valid in QB64, and I've retained them. QB64 also uses ' for comments.
' Placeholders: I've added placeholder implementations for the SUBs and FUNCTIONs. You will need to replace these with the actual QB64 logic that corresponds to the original C code. This translation only handles the header/declarations. The core functionality needs to be re-written in QB64.
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' END sam.h
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' BEGIN sam.c
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' sam.c1.txt
'Converted from C to QB64
' Explanation of Conversion and Important Considerations:
' Includes: C's #include is replaced by QB64's DECLARE SUB or DECLARE FUNCTION to indicate that a subprogram or function is defined elsewhere. Since we don't have the content of the included files, I've created DECLARE statements. You'll need to provide the QB64 code for those missing subroutines and functions.
' Data Types: C's int8_t is closest to QB64's _BYTE. uint8_t is also represented by _BYTE. int32_t is equivalent to QB64's _INTEGER. C's char* (character pointer) is often handled with QB64 STRING, but when dealing with raw memory buffers, we use _BYTE PTR (byte pointer).
' Arrays: C arrays are 0-indexed. QB64 arrays are 0-indexed by default, which simplifies things.
' Strings: QB64 STRINGs are different from C-style character arrays. The SetInput subroutine demonstrates how to convert a QB64 STRING to a _BYTE array, including null termination (which is important for C-style string handling). The GetBuffer$ function shows how to convert the _BYTE PTR back to a QB64 string.
' Memory Allocation: C's malloc is replaced by QB64's _NEW. It's crucial to use _NEW and _FREE to manage memory correctly in QB64. I've added a comment to remind you to _FREE the buffer when you're finished with it.
' Comments: I've added comments to explain the conversions and point out areas that need your attention.
' Missing Implementations: The most critical part is that the actual logic within the original C functions (Parser1, Parser2, SAMMain, etc.) is missing. I've left placeholder subroutines and functions. You must translate the C code within those functions into QB64 code. This will likely involve bitwise operations, array manipulations, and potentially calls to other QB64 functions for sound output.
' External Dependencies: If the original C code relies on external libraries or system calls, you'll need to find QB64 equivalents or implement those functionalities yourself.
' Sound Output: The provided C code doesn't show how the buffer is used to generate sound. You'll need to add QB64 code (likely using QB64's sound-related statements) to play the data in the buffer.
' To complete this conversion, you need to:
' Provide the contents of "debug.h", "sam.h", "render.h", and "sam_tabs.h" if they contain any code relevant to this conversion.
' Implement the placeholder subroutines and functions with the equivalent QB64 logic from the original C code. This is the most challenging part and requires a good understanding of both C and QB64.
' Add code to play the sound data stored in the buffer.
' Key Changes Made:
' Data Types: C's int32_t is generally equivalent to QB64PE's INTEGER (which is 32-bit).
' Arrays: QB64PE uses parentheses for array indexing, e.g., phonemeIndex(X).
' Comments: C's // comments are the same in QB64PE.
' Boolean: QB64PE uses -1 for true and 0 for false.
' Infinite Loop: C's while (1) is replaced with DO WHILE -1 in QB64PE. Alternatively, WHILE 1 = 1 could be used.
' Continue: C's continue becomes _CONTINUE in QB64PE to continue the loop.
' Function Return: Instead of return 0, QB64PE uses RETURN 0.
' Subroutines: C's void functions become SUB procedures in QB64PE.
' Variable Declarations: QB64PE requires variable declarations (e.g., DIM temp AS INTEGER). I've added one for temp. You'll likely need to add more DIM statements for other variables depending on the surrounding code.
' Array Passing: When passing arrays to subs/functions, you need to include the parentheses, e.g., PrintPhonemes phonemeIndex(), phonemeLength(), stress().
' String Literals: String literals are the same in both languages (e.g., "...").
'
' Important Considerations:
' Dependencies: This conversion only covers the code you provided. It assumes that Init(), Parser1(), PrintPhonemes(), Parser2(), CopyStress(), SetPhonemeLength(), AdjustLengths(), Code41240(), InsertBreath(), and Render() are defined elsewhere. You'll need to convert those functions as well.
' Global Variables: The C code likely uses global variables. In QB64PE, you might need to declare these at the beginning of your code outside any SUB or FUNCTION using DIM SHARED.
' Memory Manipulation: The C code has a comment //mem[48546] = X and //mem[40158] = 255;. QB64PE doesn't directly map to C's memory manipulation. You'll need to use QB64PE variables and arrays to achieve the same behavior.
' Error Handling: C's error handling might need to be adapted to QB64PE's error handling mechanisms.
' Debug Variable: The code uses a debug variable. Make sure this is declared and set appropriately in your QB64PE code.
'
' This should give you a good starting point for converting your C code to QB64PE. Remember to test thoroughly and adapt the code as needed to fit the specifics of your project.
' Key Changes Made:
' Data Types: uint8_t was converted to _BYTE (unsigned 8-bit integer) and int32_t to INTEGER.
' Arrays: It's assumed that phonemeIndex, phonemeLength, stress, flags, and flags2 are arrays. In QB64, you'll need to declare these arrays with appropriate dimensions using the DIM statement before using these subs. For example: DIM phonemeIndex(255) AS _BYTE.
' Boolean Logic: C uses != for "not equal to," & for bitwise AND, and == 0 or != 0 for boolean checks. QB64 uses <> for "not equal to," AND for bitwise AND, and = 0 or <> 0 for boolean checks.
' Comments: C-style comments (// and /* ... */) were converted to QB64's ' comment style.
' Subroutines: C functions were converted to QB64 SUB procedures.
' Parameter Passing: QB64 uses parentheses for passing parameters to SUBs.
' Variable Declarations: QB64 requires variables to be declared using DIM.
' Assumptions: This conversion makes assumptions about the global variables and array declarations. You'll need to adapt it to your specific QB64 program by adding the necessary DIM statements and any initialization code.
' Key Points and Considerations:
' Array Handling: QB64 arrays are 0-based by default, but I've adjusted some to match the C logic where it seemed appropriate (e.g., input starts at 1). Pay very close attention to array indexing. You must determine the correct sizes for all arrays (phonemeLengthTable, phonemeStressedLengthTable, flags) based on the original C code or the context of how these tables are used.
' Data Initialization: The QB64 code includes example DATA statements to initialize some arrays. You MUST replace these with the actual data that the original C program uses for its tables. This is crucial for the program to function correctly.
' Insert Subroutine: The Insert subroutine is a placeholder. You need to implement the logic of this subroutine. The C code doesn't provide the implementation, so you'll have to deduce its purpose from how it's called and what it's supposed to do with the data.
' GOTO Replacement: QB64 supports GOTO, but it's best practice to avoid it for better readability and maintainability. I've replaced the GOTO statements with DO...LOOP and _CONTINUE.
' Bitwise Operations: QB64 uses standard bitwise operators (AND, OR, XOR, NOT). The C code's bitwise operations translate directly.
' Data Types: I've used UBYTE for uint8_t and INTEGER for int32_t. Make sure these types are appropriate for the data you're working with. If you need larger integers, use _INTEGER64.
' String Handling: The original C code uses char arrays. If you need to work with strings in QB64, use the STRING data type. Note the use of ASC() to convert characters to their ASCII values when comparing against single characters (e.g., A <> ASC("*")).
' Error Handling: The C code has a basic error return. You might want to add more robust error handling in the QB64 version (e.g., using IF...THEN...ELSE to check for invalid input or array bounds).
' Comments: I've added comments to explain the code and highlight areas where you need to provide more information.
'
' To complete the conversion, you need to:
' Determine Array Sizes: Find
' Sources and related content
' Key Points and Assumptions:
' Variable Declarations: QB64 requires explicit variable declarations. I've assumed the data types based on context (e.g., pos, mem58, A, X, and Y are integers). You'll need to adjust these if they are different in your original C code. Also, phonemeIndex, flags, and stress are assumed to be integer arrays, and signInputTable1 and signInputTable2 are assumed to be string arrays.
' Arrays: C arrays are 0-indexed. QB64 arrays are also 0-indexed by default. Make sure the array dimensions are properly declared in your QB64 code using the DIM statement. For example:
'
' Code snippet
' DIM phonemeIndex(255) AS INTEGER ' If you have up to 256 phonemes
' DIM flags(255) AS INTEGER
' DIM stress(255) AS INTEGER
' DIM signInputTable1(255) AS STRING
' DIM signInputTable2(255) AS STRING
' GOTO Statements: The goto statements have been directly translated to GOTO in QB64. While they work, consider refactoring to use SELECT CASE or DO...LOOP structures for better readability and maintainability if the surrounding logic allows.
'
' Subroutines: The Insert function is assumed to be a SUB in QB64. You'll need to define this SUB elsewhere in your code.
' Comments: C-style comments (//, /* */) have been converted to QB64-style comments (').
' continue and return: The C continue statement is replaced with _CONTINUE in QB64 to continue the DO...LOOP. The C return statement is replaced with EXIT DO to exit the DO...LOOP.
' printf and debug: The printf statements are replaced with PRINT statements. The debug variable is assumed to be a boolean (0 or non-zero integer).
' Bitwise AND: The bitwise AND operator & in C is the same as AND in QB64.
' Missing Code: This translation only covers the provided snippet. You'll need to translate the rest of your C code (especially the Insert subroutine, variable declarations, and any initialization) to create a complete QB64 program.
' Testing: Thoroughly test the generated QB64 code to ensure it behaves exactly like the original C code.
' Important Considerations and Assumptions:
' Arrays: The code assumes that flags, stress, and phonemeIndex are arrays. You'll need to declare these arrays with appropriate dimensions in your QB64-PE code. For example: DIM flags(255) AS _BYTE, stress(255) AS _BYTE, phonemeIndex(255) AS _BYTE (adjust the size as needed).
' Data Types: The C code uses uint8_t, which is an unsigned 8-bit integer. QB64-PE's closest equivalent is _BYTE.
' Insert Subroutine: The code calls a subroutine named Insert. You'll need to implement this subroutine in QB64-PE, as the provided C code doesn't define it. It takes arguments X, 31, mem59, and 0. You'll need to understand what Insert is supposed to do to implement it correctly.
' debug Variable: The code uses a debug variable to conditionally print debug messages. You'll need to declare this variable in your QB64-PE code (e.g., DIM debug AS INTEGER) and assign it a value (e.g., debug = 1 to turn debugging on, debug = 0 to turn it off).
' goto Statements: C's goto statements have been replaced with QB64-PE's GOTO.
' Comments: I've added comments to the QB64-PE code to explain the conversion and point out assumptions.
'
' To make this code fully functional, you will need to:
' Declare the arrays: flags, stress, and phonemeIndex.
' Implement the Insert subroutine. This is crucial, and the provided C code doesn't give details.
' Declare and initialize the debug variable.
' Adapt the code to fit the overall structure of your QB64-PE program.
' Key Changes Made:
' C Syntax to QB64: The code was translated from C syntax to QB64 syntax. This involves changes in variable declarations (uint8_t to DIM ... AS _BYTE), control flow structures (while to DO...LOOP, if to IF...END IF), and function calls.
' Comments: C-style comments (//) were changed to QB64-style comments (').
' Preprocessor Directives: C preprocessor directives like #include are not needed in QB64 and were removed. printf statements were replaced with PRINT.
' Data Types: Explicit data types were used in QB64 (e.g., _BYTE for uint8_t).
' Arrays: Arrays are assumed to be declared elsewhere. QB64 uses parentheses for array indexing (e.g., phonemeIndex(X)).
' Bitwise AND: The bitwise AND operator & in C was translated to AND in QB64.
' continue Equivalent: The continue statement in C is replaced with _CONTINUE in QB64 to continue to the next iteration of the DO...LOOP.
' Labels: Labels (e.g., pos41779:) are kept as is, as QB64 supports labels.
' Assumptions:
' It's assumed that variables like A, X, mem59, debug, phonemeIndex(), flags(), and stress() are declared and initialized elsewhere in the QB64 program.
' The Insert subroutine is assumed to be defined elsewhere.
' This conversion provides a functional QB64 equivalent of the provided C code snippet. Remember to integrate this code into a complete QB64 program, including the necessary variable declarations and subroutine definitions.
' Explanation of Key Changes and Considerations:
' Variable Declarations: QB64 requires explicit variable declarations. I've added DIM statements to declare the variables used in the original C code, attempting to match the data types where it's clear (e.g., uint8_t likely becomes _BYTE or INTEGER). You'll need to carefully review these and adjust them based on how these variables are used in the larger program.
' Arrays: The original C code uses arrays (phonemeIndex, flags, flags2, phonemeLength, signInputTable1, signInputTable2). In QB64, arrays are declared with DIM and you need to specify the size. I've left these as undefined because I cannot determine their size from this snippet alone. You MUST define these arrays with appropriate dimensions in your QB64 code, for example:
'
' Code snippet
' DIM phonemeIndex(255) AS _BYTE ' Or whatever size is appropriate
' DIM flags(255) AS _BYTE
' DIM flags2(255) AS _BYTE
' DIM phonemeLength(255) AS INTEGER ' Or maybe _BYTE, depending on the range
' DIM signInputTable1(255) AS _BYTE
' DIM signInputTable2(255) AS _BYTE
' Data Types: C and QB64 have different ways of handling data types. I've made some educated guesses, but you'll need to ensure the QB64 data types are appropriate for your data. _BYTE is a QB64 type for unsigned 8-bit integers.
'
' Bitwise Operators: QB64 uses different bitwise operators than C.
'
' C's & becomes QB64's AND
' C's | becomes QB64's OR
' C's >> becomes QB64's \ (integer division) for right bit shift (note: QB64's >> is arithmetic right shift)
'
' Comments: C-style comments (//) are replaced with QB64's ' or
' Explanation of Conversion:
' Comments: C++ style comments // are changed to QB64 style comments '.
' Function Definition: The C++ function void Code47503(uint8_t mem52) is converted to a QB64 SUB procedure: SUB Code47503 (mem52 AS _BYTE). uint8_t is approximated by _BYTE.
' Variable Declarations: While QB64 doesn't require explicit declaration for all variables, it's good practice. I'm assuming Y, mem50, A, X, temp, mem53, and mem51 are integers. If you have specific type requirements, you may need to adjust.
' If Statements: C++ if statements are converted to QB64 IF...THEN...END IF blocks. The condition (mem53 & 128) != 0 is changed to (mem53 AND 128) <> 0.
' For Loop: The C++ for loop is converted to a QB64 FOR...TO...STEP...NEXT loop. Note the STEP -1 to decrement the loop counter.
' Left Bit Shift: QB64PE uses the multiplication operator * 2 to perform a left bit shift, instead of the C++ << operator.
' Clarity: I've added some spacing and capitalization for better readability in QB64.
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
SUB Init
DIM i AS _INTEGER
CALL SetMouthThroat(mouth, throat)
bufferPos = 0
'Allocate memory - QB64 uses _NEW for this (similar to malloc)
'Note: _NEW returns a pointer, and we need to allocate enough space for bytes (_BYTE)
buffer = _NEW _BYTE[22050 * 10]
'The original C code had commented-out assignments to memory locations.
'It's likely these are related to how the original C code interfaced with memory.
'We'll leave them commented out in QB64, as we don't have the context to translate them directly.
'If you have more information on what these memory locations represent, we can refine this.
'freq2data = &mem[45136]
'freq1data = &mem[45056]
'freq3data = &mem[45216]
'pitches = &mem[43008]
'frequency1 = &mem[43264]
'frequency2 = &mem[43520]
'frequency3 = &mem[43776]
'amplitude1 = &mem[44032]
'amplitude2 = &mem[44288]
'amplitude3 = &mem[44544]
'phoneme = &mem[39904]
'ampl1data = &mem[45296]
'ampl2data = &mem[45376]
'ampl3data = &mem[45456]
FOR i = 0 TO 255
stress[i] = 0
phonemeLength[i] = 0
NEXT i
FOR i = 0 TO 59
phonemeIndexOutput[i] = 0
stressOutput[i] = 0
phonemeLengthOutput[i] = 0
NEXT i
phonemeIndex[255] = 255 'Prevent buffer overflow
END SUB
FUNCTION Main () AS INTEGER
Init()
phonemeIndex(255) = 32 '//to prevent buffer overflow
IF (NOT Parser1()) THEN
RETURN 0
END IF
IF (debug) THEN
PrintPhonemes phonemeIndex(), phonemeLength(), stress()
END IF
Parser2()
CopyStress()
SetPhonemeLength()
AdjustLengths()
Code41240()
DO
A = phonemeIndex(X)
IF (A > 80) THEN
phonemeIndex(X) = 255
EXIT DO '// error: delete all behind it
END IF
X = X + 1
LOOP UNTIL X = 0
'//pos39848:
InsertBreath()
'//mem(40158) = 255
IF (debug) THEN
PrintPhonemes phonemeIndex(), phonemeLength(), stress()
END IF
PrepareOutput()
RETURN 1
END FUNCTION ' Main
SUB SetInput (inputString AS STRING)
'Converts a QB64 String to a _BYTE array
Dim i AS _INTEGER, l AS _INTEGER
l = LEN(inputString)
IF l > 254 THEN l = 254
FOR i = 1 TO l
input[i - 1] = ASC(MID$(inputString, i, 1))
NEXT i
input[l] = 0 'Null terminate (C-style strings)
END SUB
SUB SetSpeed (inputSpeed AS _BYTE)
speed = inputSpeed
END SUB
SUB SetPitch (inputPitch AS _BYTE)
pitch = inputPitch
END SUB
SUB SetMouth (inputMouth AS _BYTE)
mouth = inputMouth
END SUB
SUB SetThroat (inputThroat AS _BYTE)
throat = inputThroat
END SUB
SUB EnableSingmode
singmode = 1
END SUB
FUNCTION GetBuffer$ () AS STRING
'Need to convert the _BYTE PTR to a QB64 String
DIM result AS STRING
IF buffer = 0 THEN EXIT FUNCTION 'Handle null pointer
FOR i = 0 TO bufferPos - 1
result = result + CHR$(buffer[i])
NEXT i
GetBuffer$ = result
END FUNCTION
FUNCTION GetBufferLength () AS _INTEGER
GetBufferLength = bufferPos
END FUNCTION
SUB PrepareOutput ()
A = 0
X = 0
Y = 0
'//pos48551:
DO WHILE -1 '// Infinite loop, equivalent to while(1)
A = phonemeIndex(X)
IF (A = 255) THEN
A = 255
phonemeIndexOutput(Y) = 255
Render()
RETURN
END IF
IF (A = 254) THEN
X = X + 1
DIM temp AS INTEGER: temp = X '// Local variable to mimic C's temp
'//mem(48546) = X
phonemeIndexOutput(Y) = 255
Render()
'//X = mem(48546)
X = temp
Y = 0
_CONTINUE
END IF
IF (A = 0) THEN
X = X + 1
_CONTINUE
END IF
phonemeIndexOutput(Y) = A
phonemeLengthOutput(Y) = phonemeLength(X)
stressOutput(Y) = stress(X)
X = X + 1
Y = Y + 1
LOOP
END SUB ' PrepareOutput
SUB InsertBreath ()
DIM mem54 AS _BYTE
DIM mem55 AS _BYTE
DIM index AS _BYTE 'variable Y
mem54 = 255
X = X + 1 [cite: 1]
mem55 = 0
DIM mem66 AS _BYTE
mem66 = 0
DO
'pos48440:
X = mem66 [cite: 2]
index = phonemeIndex(X) [cite: 3]
IF index = 255 THEN
EXIT SUB
END IF
mem55 = mem55 + phonemeLength(X) [cite: 4]
IF mem55 < 232 THEN
IF index <> 254 THEN ' ML : Prevents an index out of bounds problem
A = flags2(index) AND 1 [cite: 4]
IF A <> 0 THEN
X = X + 1 [cite: 5]
mem55 = 0
CALL Insert(X, 254, mem59, 0) [cite: 6]
mem66 = mem66 + 1
mem66 = mem66 + 1
_CONTINUE
END IF
END IF
IF index = 0 THEN
mem54 = X [cite: 7]
END IF
mem66 = mem66 + 1 [cite: 8]
ELSE
X = mem54
phonemeIndex(X) = 31 ' 'Q*' glottal stop [cite: 8, 9]
phonemeLength(X) = 4
stress(X) = 0
X = X + 1 [cite: 9]
mem55 = 0
CALL Insert(X, 254, mem59, 0) [cite: 10]
X = X + 1
mem66 = X [cite: 10]
END IF
LOOP
END SUB ' InsertBreath
SUB CopyStress ()
' loop thought all the phonemes to be output
DIM pos AS _BYTE
pos = 0 'mem66 [cite: 11]
DO
' get the phomene
Y = phonemeIndex(pos) [cite: 12]
' exit at end of buffer
IF Y = 255 THEN
EXIT SUB
END IF
' if CONSONANT_FLAG set, skip - only vowels get stress
IF (flags(Y) AND 64) = 0 THEN
pos = pos + 1 [cite: 13, 14]
_CONTINUE
END IF
' get the next phoneme
Y = phonemeIndex(pos + 1) [cite: 15]
IF Y = 255 THEN 'prevent buffer overflow
pos = pos + 1 [cite: 16]
_CONTINUE
ELSE
' if the following phoneme is a vowel, skip
IF (flags(Y) AND 128) = 0 THEN
pos = pos + 1 [cite: 17]
_CONTINUE
END IF
END IF
' get the stress value at the next position
Y = stress(pos + 1) [cite: 18]
' if next phoneme is not stressed, skip
IF Y = 0 THEN
pos = pos + 1 [cite: 19]
_CONTINUE
END IF
' if next phoneme is not a VOWEL OR ER, skip
IF (Y AND 128) <> 0 THEN
pos = pos + 1 [cite: 20]
_CONTINUE
END IF
' copy stress from prior phoneme to this one
stress(pos) = Y + 1 [cite: 21]
' advance pointer
pos = pos + 1 [cite: 22]
LOOP
END SUB ' CopyStress
SUB Insert (position AS _BYTE, mem60 AS _BYTE, mem59 AS _BYTE, mem58 AS _BYTE)
DIM i AS INTEGER
FOR i = 253 TO position STEP -1 ' ML : always keep last safe-guarding 255 [cite: 23, 24]
phonemeIndex(i + 1) = phonemeIndex(i) [cite: 24]
phonemeLength(i + 1) = phonemeLength(i) [cite: 25]
stress(i + 1) = stress(i)
NEXT i
phonemeIndex(position) = mem60
phonemeLength(position) = mem59 [cite: 25]
stress(position) = mem58 [cite: 26]
END SUB ' Insert
'--------------------------------------------------------------------------------------------------------------------
' Parser1 Function
'--------------------------------------------------------------------------------------------------------------------
FUNCTION Parser1 () AS INTEGER
DIM i AS INTEGER
DIM sign1 AS UBYTE
DIM sign2 AS UBYTE
DIM position AS UBYTE
position = 0
X = 0
A = 0
Y = 0
' CLEAR THE STRESS TABLE
FOR i = 0 TO 255
stress(i) = 0
NEXT i
' THIS CODE MATCHES THE PHONEME LETTERS TO THE TABLE
DO
' GET THE FIRST CHARACTER FROM THE PHONEME BUFFER
sign1 = input[X] ' Assuming input is 1-based array
' TEST FOR 155 () END OF LINE MARKER
IF sign1 = 155 THEN
' MARK ENDPOINT AND RETURN
phonemeIndex(position) = 255
'mark endpoint
' REACHED END OF PHONEMES, SO EXIT
RETURN 1 'all ok
END IF
' GET THE NEXT CHARACTER FROM THE BUFFER
X = X + 1
sign2 = input[X]
' NOW sign1 = FIRST CHARACTER OF PHONEME, AND sign2 = SECOND CHARACTER OF PHONEME
' TRY TO MATCH PHONEMES ON TWO TWO-CHARACTER NAME
' IGNORE PHONEMES IN TABLE ENDING WITH WILDCARDS
' SET INDEX TO 0
Y = 0
DO
' GET FIRST CHARACTER AT POSITION Y IN signInputTable
' --> should change name to PhonemeNameTable1
A = signInputTable1(Y) ' Assuming signInputTable1 is 0-based
' FIRST CHARACTER MATCHES?
IF A = sign1 THEN
' GET THE CHARACTER FROM THE PhonemeSecondLetterTable
A = signInputTable2(Y)
' NOT A SPECIAL AND MATCHES SECOND CHARACTER?
IF (A <> ASC("*")) AND (A = sign2) THEN 'QB64 uses ASC() for character to ASCII
' STORE THE INDEX OF THE PHONEME INTO THE phomeneIndexTable
phonemeIndex(position) = Y
' ADVANCE THE POINTER TO THE phonemeIndexTable
position = position + 1
' ADVANCE THE POINTER TO the phonemeInputBuffer
X = X + 1
' CONTINUE PARSING
_CONTINUE
END IF
END IF
' NO MATCH, TRY TO MATCH ON FIRST CHARACTER TO WILDCARD NAMES (ENDING WITH '*')
' ADVANCE TO THE NEXT POSITION
Y = Y + 1
' IF NOT END OF TABLE, CONTINUE
IF Y <> 81 THEN
'GOTO pos41095 ' QB64 doesn't encourage GOTO, using DO...LOOP
_CONTINUE
END IF
' REACHED END OF TABLE WITHOUT AN EXACT (2 CHARACTER) MATCH.
' THIS TIME, SEARCH FOR A 1 CHARACTER MATCH AGAINST THE WILDCARDS
' RESET THE INDEX TO POINT TO THE START OF THE PHONEME NAME TABLE
Y = 0
DO
' DOES THE PHONEME IN THE TABLE END WITH '*'?
IF signInputTable2(Y) = ASC("*") THEN
' DOES THE FIRST CHARACTER MATCH THE FIRST LETTER OF THE PHONEME
IF signInputTable1(Y) = sign1 THEN
' SAVE THE POSITION AND MOVE AHEAD
phonemeIndex(position) = Y
' ADVANCE THE POINTER
position = position + 1
' CONTINUE THROUGH THE LOOP
_CONTINUE
END IF
END IF
Y = Y + 1
IF Y <> 81 THEN
'GOTO pos41134
_CONTINUE
END IF
LOOP
'81 is size of PHONEME NAME table
' FAILED TO MATCH WITH A WILDCARD.
' ASSUME THIS IS A STRESS
' CHARACTER.
' SEARCH THROUGH THE STRESS TABLE
' SET INDEX TO POSITION 8 (END OF STRESS TABLE)
Y = 8
' WALK BACK THROUGH TABLE LOOKING FOR A MATCH
DO WHILE (sign1 <> stressInputTable(Y)) AND (Y > 0)
' DECREMENT INDEX
Y = Y - 1
LOOP
' REACHED THE END OF THE SEARCH WITHOUT BREAKING OUT OF LOOP?
IF Y = 0 THEN
'mem[39444] = X
'41181: JSR 42043 //Error
' FAILED TO MATCH ANYTHING, RETURN 0 ON FAILURE
RETURN 0
END IF
' SET THE STRESS FOR THE PRIOR PHONEME
stress(position - 1) = Y
LOOP
END FUNCTION
'--------------------------------------------------------------------------------------------------------------------
' SetPhonemeLength Subroutine
'--------------------------------------------------------------------------------------------------------------------
SUB SetPhonemeLength
DIM A AS UBYTE
DIM position AS INTEGER
position = 0
DO WHILE phonemeIndex(position) <> 255
A = stress(position)
'41218: BMI 41229 ' BMI is Branch if Minus (negative) - QB64 doesn't have direct BMI, emulate with sign check
IF (A = 0) OR ((A AND 128) <> 0) THEN 'bitwise AND to check high bit (sign)
phonemeLength(position) = phonemeLengthTable(phonemeIndex(position))
ELSE
phonemeLength(position) = phonemeStressedLengthTable(phonemeIndex(position))
END IF
position = position + 1
LOOP
END SUB
'--------------------------------------------------------------------------------------------------------------------
' Code41240 Subroutine
'--------------------------------------------------------------------------------------------------------------------
SUB Code41240
DIM pos AS UBYTE
pos = 0
DO WHILE phonemeIndex(pos) <> 255
DIM index AS UBYTE 'register AC
X = pos
index = phonemeIndex(pos)
IF (flags(index) AND 2) = 0 THEN ' Bitwise AND
pos = pos + 1
_CONTINUE
ELSEIF (flags(index) AND 1) = 0 THEN ' Bitwise AND
Insert pos + 1, index + 1, phonemeLengthTable(index + 1), stress(pos)
Insert pos + 2, index + 2, phonemeLengthTable(index + 2), stress(pos)
pos = pos + 3
_CONTINUE
END IF
DO
X = X + 1
A = phonemeIndex(X)
LOOP UNTIL A <> 0
IF A <> 255 THEN
IF (flags(A) AND 8) <> 0 THEN
pos = pos + 1
_CONTINUE
END IF
IF (A = 36) OR (A = 37) THEN
pos = pos + 1
_CONTINUE
END IF ' '/H' '/X'
END IF
Insert pos + 1, index + 1, phonemeLengthTable(index + 1), stress(pos)
Insert pos + 2, index + 2, phonemeLengthTable(index + 2), stress(pos)
pos = pos + 3
LOOP
END SUB
'--------------------------------------------------------------------------------------------------------------------
' Placeholder for Insert Subroutine - YOU MUST IMPLEMENT THIS
'--------------------------------------------------------------------------------------------------------------------
SUB Insert (pos AS INTEGER, index AS INTEGER, length AS INTEGER, stress_val AS UBYTE)
' This is a placeholder. You need to fill in the actual functionality
' of the Insert subroutine based on what it's supposed to do in the
' original C code. It likely involves inserting data into another
' array or data structure.
PRINT "Insert called: pos="; pos; " index="; index; " length="; length; " stress="; stress_val
END SUB
' BEGIN Parser2 PART 1 [cite: 1]
SUB Parser2 ()
'void Parser2()
' {
' if (debug)
' printf("Parser2\n");
IF debug THEN
PRINT "Parser2"
END IF
' uint8_t pos = 0; //mem66; [cite: 2]
pos = 0 ' Assuming pos is an integer
' uint8_t mem58 = 0; [cite: 2]
mem58 = 0 ' Assuming mem58 is an integer
' Loop through phonemes
DO
' SET X TO THE CURRENT POSITION
X = pos ' Assuming X is an integer [cite: 2]
' GET THE PHONEME AT THE CURRENT POSITION
A = phonemeIndex(pos) ' Assuming A and phonemeIndex are integers [cite: 3]
' DEBUG: Print phoneme and index
IF debug AND A <> 255 THEN
PRINT X; ": "; signInputTable1(A); signInputTable2(A) ' Assuming signInputTable1 and signInputTable2 are string arrays [cite: 4]
END IF
' Is phoneme pause?
IF A = 0 THEN ' Assuming 0 represents a pause [cite: 5]
' Move ahead to the
pos = pos + 1 [cite: 5]
_CONTINUE ' QB64 equivalent of continue [cite: 6]
END IF
' If end of phonemes flag reached, exit routine
IF A = 255 THEN
EXIT DO ' QB64 equivalent of return [cite: 6]
END IF
' Copy the current phoneme index to Y
Y = A ' Assuming Y is an integer [cite: 7]
' Check for DIPHTONG
IF (flags(A) AND 16) = 0 THEN ' Assuming flags is an integer array [cite: 8]
GOTO pos41457
END IF
' Not a diphthong. Get the stress
mem58 = stress(pos) ' Assuming stress is an integer array [cite: 9]
' End in IY sound?
A = flags(Y) AND 32 [cite: 10]
' If ends with IY, use YX, else use WX
IF A = 0 THEN
A = 20
ELSE
A = 21
END IF ' 'WX' = 20 'YX' = 21 [cite: 11, 12, 13]
'pos41443:
' Insert at WX or YX following, copying the stress
IF debug THEN
IF A = 20 THEN
PRINT "RULE: insert WX following diphtong NOT ending in IY sound" [cite: 13]
END IF
END IF
IF debug THEN
IF A = 21 THEN
PRINT "RULE: insert YX following diphtong ending in IY sound" [cite: 14]
END IF
END IF
Insert pos + 1, A, mem59, mem58 ' Assuming Insert is a SUB and mem59 is an integer [cite: 15]
X = pos
' Jump to ???
GOTO pos41749
pos41457:
' Get phoneme
A = phonemeIndex(X) [cite: 16]
' Skip this rule if phoneme is not UL
IF A <> 78 THEN ' Assuming 78 is the value for UL [cite: 17]
GOTO pos41487
END IF
' 'UL'
A = 24 ' Assuming 24 is the value for 'L' [cite: 18, 19]
' 'L' 'change 'UL' to 'AX L'
IF debug THEN
PRINT "RULE: UL -> AX L" [cite: 19]
END IF
pos41466:
' Get current phoneme stress
mem58 = stress(X) [cite: 20]
' Change UL to AX
phonemeIndex(X) = 13 ' Assuming 13 is the value for AX [cite: 21, 22]
' 'AX'
' Perform insert. Note code below may jump up here with different values
Insert X + 1, A, mem59, mem58 [cite: 23]
pos = pos + 1
' Move to next phoneme
_CONTINUE [cite: 24]
pos41487:
' Skip rule if phoneme != UM
IF A <> 79 THEN ' Assuming 79 is the value for UM [cite: 25]
GOTO pos41495
END IF
' 'UM'
' Jump up to branch - replaces current phoneme with AX and continues
A = 27 ' Assuming 27 is the value for M [cite: 26, 27]
' 'M' 'change 'UM' to 'AX M'
IF debug THEN
PRINT "RULE: UM -> AX M" [cite: 27]
END IF
GOTO pos41466 [cite: 28]
pos41495:
' Skip rule if phoneme != UN
IF A <> 80 THEN ' Assuming 80 is the value for UN [cite: 28]
GOTO pos41503
END IF
' 'UN'
' Jump up to branch - replaces current phoneme with AX and continues
A = 28 ' Assuming 28 is the value for N [cite: 29, 30]
' 'N' 'change UN to 'AX N'
IF debug THEN
PRINT "RULE: UN -> AX N" [cite: 30]
END IF
GOTO pos41466
pos41503:
Y = A
' VOWEL set?
A = flags(A) AND 128 'Assumes flags is an array
' Skip if not a vowel
IF A <> 0 THEN
' Get the stress
A = stress(X) ' Assumes stress is an array
' If stressed...
IF A <> 0 THEN
' Get the following phoneme
X = X + 1
A = phonemeIndex(X) ' Assumes phonemeIndex is an array
' If following phoneme is a pause
IF A = 0 THEN
' Get the phoneme following pause
X = X + 1
Y = phonemeIndex(X)
' Check for end of buffer flag
IF Y = 255 THEN 'buffer overflow
' ??? Not sure about these flags
A = 65 AND 128
ELSE
' And VOWEL flag to current phoneme's flags
A = flags(Y) AND 128
END IF
' If following phonemes is not a pause
IF A <> 0 THEN
' If the following phoneme is not stressed
A = stress(X)
IF A <> 0 THEN
' Insert a glottal stop and move forward
IF debug THEN 'Assumes debug is a variable
PRINT "RULE: Insert glottal stop between two stressed vowels with space between them"
END IF
' 31 = 'Q'
CALL Insert(X, 31, mem59, 0) ' Assumes Insert is a SUB
pos = pos + 1
_CONTINUE
END IF
END IF
END IF
END IF
END IF
' RULES FOR PHONEMES BEFORE R
' T R -> CH R
' Example: TRACK
' Get current position and phoneme
X = pos
A = phonemeIndex(pos)
IF A <> 23 THEN GOTO pos41611 ' 'R'
' Look at prior phoneme
X = X - 1
A = phonemeIndex(pos - 1)
'pos41567:
IF A = 69 THEN ' 'T'
' Change T to CH
IF debug THEN
PRINT "RULE: T R -> CH R"
END IF
phonemeIndex(pos - 1) = 42
GOTO pos41779
END IF
' RULES FOR PHONEMES BEFORE R
' D R -> J R
' Example: DRY
' Prior phonemes D?
IF A = 57 THEN ' 'D'
' Change D to J
phonemeIndex(pos - 1) = 44
IF debug THEN
PRINT "RULE: D R -> J R"
END IF
GOTO pos41788
END IF
' RULES FOR PHONEMES BEFORE R
' <VOWEL> R -> <VOWEL> RX
' Example: ART
' If vowel flag is set change R to RX
A = flags(A) AND 128
IF debug THEN
PRINT "RULE: R -> RX"
END IF
IF A <> 0 THEN
phonemeIndex(pos) = 18 ' 'RX'
END IF
' continue to next phoneme
pos = pos + 1
pos41611:
' Is phoneme L?
IF A = 24 THEN '// 'L'
' If prior phoneme does not have VOWEL flag set, move to next phoneme
IF (flags(phonemeIndex(pos - 1)) AND 128) = 0 THEN
pos = pos + 1
'goto pos41611
_CONTINUE
END IF
' Prior phoneme has VOWEL flag set, so change L to LX and move to next phoneme
IF debug THEN
PRINT "RULE: <VOWEL> L -> <VOWEL> LX"
END IF
phonemeIndex(X) = 19 '// 'LX'
pos = pos + 1
'goto pos41611
_CONTINUE
END IF
' Is current phoneme S?
IF A = 32 THEN '// 'S'
' If prior phoneme is not G, move to next phoneme
IF phonemeIndex(pos - 1) <> 60 THEN
pos = pos + 1
'goto pos41611
_CONTINUE
END IF
' Replace S with Z and move on
IF debug THEN
PRINT "RULE: G S -> G Z"
END IF
phonemeIndex(pos) = 38 '// 'Z'
pos = pos + 1
'goto pos41611
_CONTINUE
END IF
' Is current phoneme K?
IF A = 72 THEN '// 'K'
' Get next phoneme
Y = phonemeIndex(pos + 1)
' If at end, replace current phoneme with KX
IF Y = 255 THEN
phonemeIndex(pos) = 75
' ML : prevents an index out of bounds problem
ELSE
' VOWELS AND DIPHTONGS ENDING WITH IY SOUND flag set?
A = flags(Y) AND 32
IF debug THEN
IF A = 0 THEN
PRINT "RULE: K <VOWEL OR DIPHTONG NOT ENDING WITH IY> -> KX <VOWEL OR DIPHTONG NOT ENDING WITH IY>"
END IF
END IF
' Replace with KX
IF A = 0 THEN
phonemeIndex(pos) = 75
END IF
' 'KX'
END IF
ELSE
' Is int8_tacter a G?
IF A = 60 THEN '// 'G'
' Get the following int8_tacter
DIM index AS _BYTE
index = phonemeIndex(pos + 1)
' At end of buffer?
IF index = 255 THEN '//prevent buffer overflow
pos = pos + 1
'goto pos41611
_CONTINUE
ELSE
' If diphtong ending with YX, move continue processing next phoneme
IF (flags(index) AND 32) <> 0 THEN
pos = pos + 1
'goto pos41611
_CONTINUE
END IF
' replace G with GX and continue processing next phoneme
IF debug THEN
PRINT "RULE: G <VOWEL OR DIPHTONG NOT ENDING WITH IY> -> GX <VOWEL OR DIPHTONG NOT ENDING WITH IY>"
END IF
phonemeIndex(pos) = 63 '// 'GX'
pos = pos + 1
'goto pos41611
_CONTINUE
END IF
END IF
END IF
Y = phonemeIndex(pos)
'pos41719:
' Replace with softer version?
A = flags(Y) AND 1
IF A = 0 THEN
GOTO pos41749
END IF
A = phonemeIndex(pos - 1)
IF A <> 32 THEN '// 'S'
A = Y
GOTO pos41812
END IF
' Replace with softer version
IF debug THEN
PRINT "RULE: S* "; CHR$(signInputTable1(Y)); CHR$(signInputTable2(Y)); " -> S* "; CHR$(signInputTable1(Y - 12)); CHR$(signInputTable2(Y - 12))
END IF
phonemeIndex(pos) = Y - 12
pos = pos + 1
'goto pos41611
_CONTINUE
pos41749:
' UW -> UX
A = phonemeIndex(X)
IF A = 53 THEN '// 'UW'
' ALVEOLAR flag set?
Y = phonemeIndex(X - 1)
A = flags2(Y) AND 4
' If not set, continue processing next phoneme
IF A = 0 THEN
pos = pos + 1
'goto pos41611
_CONTINUE
END IF
IF debug THEN
PRINT "RULE: <ALVEOLAR> UW -> <ALVEOLAR> UX"
END IF
phonemeIndex(X) = 16
pos = pos + 1
'goto pos41611
_CONTINUE
END IF
pos41779:
IF A = 42 THEN '// 'CH'
' pos41783:
IF debug THEN
PRINT "CH -> CH CH+1"
END IF
CALL Insert(X + 1, A + 1, mem59, stress(X))
pos = pos + 1
_CONTINUE
END IF
pos41788:
IF A = 44 THEN '// 'J'
IF debug THEN
PRINT "J -> J J+1"
END IF
CALL Insert(X + 1, A + 1, mem59, stress(X))
pos = pos + 1
_CONTINUE
END IF
' Jump here to continue
pos41812:
' Past this point, only process if phoneme is T or D
IF A <> 69 THEN '// 'T'
IF A <> 57 THEN
pos = pos + 1
_CONTINUE
END IF '// 'D'
END IF
'pos41825:
' If prior phoneme is not a vowel, continue processing phonemes
IF (flags(phonemeIndex(X - 1)) AND 128) = 0 THEN
pos = pos + 1
_CONTINUE
END IF
' Get next phoneme
X = X + 1
A = phonemeIndex(X)
'pos41841
' Is the next phoneme a pause?
IF A <> 0 THEN
' If next phoneme is not a pause, continue processing phonemes
IF (flags(A) AND 128) = 0 THEN
pos = pos + 1
_CONTINUE
END IF
' If next phoneme is stressed, continue processing phonemes
' FIXME: How does a pause get stressed?
IF stress(X) <> 0 THEN
pos = pos + 1
_CONTINUE
END IF
'pos41856:
' Set phonemes to DX
IF debug THEN
PRINT "RULE: Soften T or D following vowel or ER and preceding a pause -> DX"
END IF
phonemeIndex(pos) = 30 '// 'DX'
ELSE
A = phonemeIndex(X + 1)
IF A = 255 THEN '//prevent buffer overflow
A = 65 AND 128
ELSE
' Is next phoneme a vowel or ER?
A = flags(A) AND 128
END IF
IF debug THEN
IF A <> 0 THEN
PRINT "RULE: Soften T or D following vowel or ER and preceding a pause -> DX"
END IF
END IF
IF A <> 0 THEN
phonemeIndex(pos) = 30
END IF '// 'DX'
END IF
pos = pos + 1
LOOP '// while
END SUB ' Parser2
SUB AdjustLengths ()
' loop index
DIM X AS INTEGER
DIM index AS _BYTE
DIM A AS INTEGER
DIM loopIndex AS _BYTE
DIM mem56 AS INTEGER
DIM debugX AS INTEGER
' iterate through the phoneme list
loopIndex = 0
DO
' get a phoneme
X = loopIndex
index = phonemeIndex(X)
' exit loop if end on buffer token
IF index = 255 THEN
EXIT DO
END IF
' not punctuation?
IF (flags2(index) AND 1) = 0 THEN
' skip
X = X + 1
_CONTINUE
END IF
' hold index
loopIndex = X
' Loop backwards from this point
pos48644:
' back up one phoneme
X = X - 1
' stop once the beginning is reached
IF X = 0 THEN
EXIT DO
END IF
' get the preceding phoneme
index = phonemeIndex(X)
IF index <> 255 THEN 'inserted to prevent access overrun
IF (flags(index) AND 128) = 0 THEN
GOTO pos48644 ' if not a vowel, continue looping
END IF
END IF
'pos48657:
DO
' test for vowel
index = phonemeIndex(X)
IF index <> 255 THEN 'inserted to prevent access overrun
' test for fricative/unvoiced or not voiced
IF ((flags2(index) AND 32) = 0) OR ((flags(index) AND 4) <> 0) THEN 'nochmal berprfen
'A = flags(Y) & 4;
'if(A == 0) goto pos48688;
' get the phoneme length
A = phonemeLength(X)
' change phoneme length to (length * 1.5) + 1
A = (A \ 2) + A + 1
IF debug THEN
PRINT "RULE: Lengthen <FRICATIVE> or <VOICED> between <VOWEL> and <PUNCTUATION> by 1.5"
END IF
IF debug THEN
PRINT "PRE"
END IF
IF debug THEN
PRINT "phoneme"; X; "("; CHR$(signInputTable1(phonemeIndex(X))); CHR$(signInputTable2(phonemeIndex(X))); ") length"; phonemeLength(X)
END IF
phonemeLength(X) = A
IF debug THEN
PRINT "POST"
END IF
IF debug THEN
PRINT "phoneme"; X; "("; CHR$(signInputTable1(phonemeIndex(X))); CHR$(signInputTable2(phonemeIndex(X))); ") length"; phonemeLength(X)
END IF
END IF
END IF
' keep moving forward
X = X + 1
LOOP UNTIL X = loopIndex
' if (X != loopIndex) goto pos48657;
X = X + 1
LOOP
' Similar to the above routine, but shorten vowels under some circumstances
' Loop throught all phonemes
loopIndex = 0
'pos48697
DO
' get a phoneme
X = loopIndex
index = phonemeIndex(X)
' exit routine at end token
IF index = 255 THEN
EXIT SUB
END IF
' vowel?
A = flags(index) AND 128
IF A <> 0 THEN
' get next phoneme
X = X + 1
index = phonemeIndex(X)
' get flags
IF index = 255 THEN
mem56 = 65
ELSE
mem56 = flags(index)
END IF
' use if end marker
' not a consonant
IF (flags(index) AND 64) = 0 THEN
' RX or LX?
IF (index = 18) OR (index = 19) THEN ' 'RX' & 'LX'
' get the next phoneme
X = X + 1
index = phonemeIndex(X)
' next phoneme a consonant?
IF (flags(index) AND 64) <> 0 THEN
IF debug THEN
PRINT "RULE: <VOWEL> <RX | LX> <CONSONANT> - decrease length by 1"
END IF
IF debug THEN
PRINT "PRE"
END IF
IF debug THEN
PRINT "phoneme"; loopIndex; "("; CHR$(signInputTable1(phonemeIndex(loopIndex))); CHR$(signInputTable2(phonemeIndex(loopIndex))); ") length"; phonemeLength(loopIndex)
END IF
' decrease length of vowel by 1 frame
phonemeLength(loopIndex) = phonemeLength(loopIndex) - 1
IF debug THEN
PRINT "POST"
END IF
IF debug THEN
PRINT "phoneme"; loopIndex; "("; CHR$(signInputTable1(phonemeIndex(loopIndex))); CHR$(signInputTable2(phonemeIndex(loopIndex))); ") length"; phonemeLength(loopIndex)
END IF
END IF
' move ahead
loopIndex = loopIndex + 1
_CONTINUE
END IF
' move ahead
loopIndex = loopIndex + 1
_CONTINUE
END IF
' Got here if not <VOWEL>
' not voiced
IF (mem56 AND 4) = 0 THEN
' Unvoiced
' *, .*, ?*, ,*, -*, DX, S*, SH, F*, TH, /H, /X, CH, P*, T*, K*,
' KX
' not an unvoiced plosive?
IF (mem56 AND 1) = 0 THEN
' move ahead
loopIndex = loopIndex + 1
_CONTINUE
END IF
' P*, T*, K*, KX
' move back
X = X - 1
IF debug THEN
PRINT "RULE: <VOWEL> <UNVOICED PLOSIVE> - decrease vowel by 1/8th"
END IF
IF debug THEN
PRINT "PRE"
END IF
IF debug THEN
PRINT "phoneme"; X; "("; CHR$(signInputTable1(phonemeIndex(X))); CHR$(signInputTable2(phonemeIndex(X))); ") length"; phonemeLength(X)
END IF
' decrease length by 1/8th
mem56 = phonemeLength(X) \ 8
phonemeLength(X) = phonemeLength(X) - mem56
IF debug THEN
PRINT "POST"
END IF
IF debug THEN
PRINT "phoneme"; X; "("; CHR$(signInputTable1(phonemeIndex(X))); CHR$(signInputTable2(phonemeIndex(X))); ") length"; phonemeLength(X)
END IF
' move ahead
loopIndex = loopIndex + 1
_CONTINUE
END IF
IF debug THEN
PRINT "RULE: <VOWEL> <VOICED CONSONANT> - increase vowel by 1/2 + 1"
END IF
IF debug THEN
PRINT "PRE"
END IF
IF debug THEN
PRINT "phoneme"; X - 1; "("; CHR$(signInputTable1(phonemeIndex(X - 1))); CHR$(signInputTable2(phonemeIndex(X - 1))); ") length"; phonemeLength(X - 1)
END IF
' decrease length
A = phonemeLength(X - 1)
phonemeLength(X - 1) = (A \ 2) + A + 1
' 5/4*A + 1
IF debug THEN
PRINT "POST"
END IF
IF debug THEN
PRINT "phoneme"; X - 1; "("; CHR$(signInputTable1(phonemeIndex(X - 1))); CHR$(signInputTable2(phonemeIndex(X - 1))); ") length"; phonemeLength(X - 1)
END IF
' move ahead
loopIndex = loopIndex + 1
_CONTINUE
END IF
' WH, R*, L*, W*, Y*, Q*, Z*, ZH, V*, DH, J*, **,
'pos48821:
' nasal?
IF (flags2(index) AND 8) <> 0 THEN
' M*, N*, NX,
' get the next phoneme
X = X + 1
index = phonemeIndex(X)
' end of buffer?
IF index = 255 THEN
A = 65 AND 2
ELSE
A = flags(index) AND 2
END IF
'prevent buffer overflow
' check for stop consonant
' is next phoneme a stop consonant?
IF A <> 0 THEN
' B*, D*, G*, GX, P*, T*, K*, KX
IF debug THEN
PRINT "RULE: <NASAL> <STOP CONSONANT> - set nasal = 5, consonant = 6"
END IF
IF debug THEN
PRINT "POST"
END IF
IF debug THEN
PRINT "phoneme"; X; "("; CHR$(signInputTable1(phonemeIndex(X))); CHR$(signInputTable2(phonemeIndex(X))); ") length"; phonemeLength(X)
END IF
IF debug THEN
PRINT "phoneme"; X - 1; "("; CHR$(signInputTable1(phonemeIndex(X - 1))); CHR$(signInputTable2(phonemeIndex(X - 1))); ") length"; phonemeLength(X - 1)
END IF
' set stop consonant length to 6
phonemeLength(X) = 6
' set nasal length to 5
phonemeLength(X - 1) = 5
IF debug THEN
PRINT "POST"
END IF
IF debug THEN
PRINT "phoneme"; X; "("; CHR$(signInputTable1(phonemeIndex(X))); CHR$(signInputTable2(phonemeIndex(X))); ") length"; phonemeLength(X)
END IF
IF debug THEN
PRINT "phoneme"; X - 1; "("; CHR$(signInputTable1(phonemeIndex(X - 1))); CHR$(signInputTable2(phonemeIndex(X - 1))); ") length"; phonemeLength(X - 1)
END IF
END IF
' move to next phoneme
loopIndex = loopIndex + 1
_CONTINUE
END IF
IF (flags(index) AND 2) <> 0 THEN
' B*, D*, G*, GX
' move past silence
DO
' move ahead
X = X + 1
index = phonemeIndex(X)
LOOP UNTIL index = 0
' check for end of buffer
IF index = 255 THEN 'buffer overflow
' ignore, overflow code
IF (65 AND 2) = 0 THEN
loopIndex = loopIndex + 1
_CONTINUE
END IF
ELSEIF (flags(index) AND 2) = 0 THEN
' if another stop consonant, move ahead
loopIndex = loopIndex + 1
_CONTINUE
END IF
IF debug THEN
PRINT "RULE: <UNVOICED STOP CONSONANT> {optional silence} <STOP CONSONANT> - shorten both to 1/2 + 1"
END IF
IF debug THEN
PRINT "PRE"
END IF
IF debug THEN
PRINT "phoneme"; X; "("; CHR$(signInputTable1(phonemeIndex(X))); CHR$(signInputTable2(phonemeIndex(X))); ") length"; phonemeLength(X)
END IF
IF debug THEN
PRINT "phoneme"; X - 1; "("; CHR$(signInputTable1(phonemeIndex(X - 1))); CHR$(signInputTable2(phonemeIndex(X - 1))); ") length"; phonemeLength(X - 1)
END IF
' X gets overwritten, so hold prior X value for debug statement
debugX = X
' shorten the prior phoneme length to (length/2 + 1)
phonemeLength(X) = (phonemeLength(X) \ 2) + 1
X = loopIndex
' also shorten this phoneme length to (length/2 +1)
phonemeLength(loopIndex) = (phonemeLength(loopIndex) \ 2) + 1
IF debug THEN
PRINT "POST"
END IF
IF debug THEN
PRINT "phoneme"; debugX; "("; CHR$(signInputTable1(phonemeIndex(debugX))); CHR$(signInputTable2(phonemeIndex(debugX))); ") length"; phonemeLength(debugX)
END IF
IF debug THEN
PRINT "phoneme"; debugX - 1; "("; CHR$(signInputTable1(phonemeIndex(debugX - 1))); CHR$(signInputTable2(phonemeIndex(debugX - 1))); ") length"; phonemeLength(debugX - 1)
END IF
' move ahead
loopIndex = loopIndex + 1
_CONTINUE
END IF
' WH, R*, L*, W*, Y*, Q*, Z*, ZH, V*, DH, J*, **,
' liquic consonant?
IF (flags2(index) AND 16) <> 0 THEN
' R*, L*, W*, Y*
' get the prior phoneme
index = phonemeIndex(X - 1)
' prior phoneme a stop consonant>
IF (flags(index) AND 2) <> 0 THEN
IF debug THEN
PRINT "RULE: <LIQUID CONSONANT> <DIPHTONG> - decrease by 2"
END IF
IF debug THEN
PRINT "PRE"
END IF
IF debug THEN
PRINT "phoneme"; X; "("; CHR$(signInputTable1(phonemeIndex(X))); CHR$(signInputTable2(phonemeIndex(X))); ") length"; phonemeLength(X)
END IF
' decrease the phoneme length by 2 frames (20 ms)
phonemeLength(X) = phonemeLength(X) - 2
IF debug THEN
PRINT "POST"
END IF
IF debug THEN
PRINT "phoneme"; X; "("; CHR$(signInputTable1(phonemeIndex(X))); CHR$(signInputTable2(phonemeIndex(X))); ") length"; phonemeLength(X)
END IF
END IF
END IF
' move to next phoneme
loopIndex = loopIndex + 1
_CONTINUE
LOOP
END SUB
' -------------------------------------------------------------------------
' ML : Code47503 is division with remainder, and mem50 gets the sign
SUB Code47503 (mem52 AS _BYTE)
Y = 0
IF ((mem53 AND 128) <> 0) THEN
mem53 = -mem53
Y = 128
END IF
mem50 = Y
A = 0
FOR X = 8 TO 1 STEP -1
temp = mem53
mem53 = mem53 * 2 ' QB64PE uses * for left bit shift
A = A * 2 ' QB64PE uses * for left bit shift
IF (temp >= 128) THEN
A = A + 1
END IF
IF (A >= mem52) THEN
A = A - mem52
mem53 = mem53 + 1
END IF
NEXT X
mem51 = A
IF ((mem50 AND 128) <> 0) THEN
mem53 = -mem53
END IF
END SUB
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' END sam.c
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' BEGIN reciter.c
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' Explanation of Translation Choices and Important Considerations:
' Includes: C #include directives are replaced by QB64's inherent understanding of its own functions. We don't need stdio.h or string.h for basic input/output or string manipulation. The custom headers (reciter.h, reciter_tabs.h, debug.h) require different handling:
' reciter.h: If it contains function prototypes, we've replicated those as QB64 FUNCTION declarations. If it contains shared variables, we've declared them with DIM.
' reciter_tabs.h: This likely holds data tables. I've translated this into QB64 DATA statements and read them into arrays. You MUST replace the example DATA with the actual data from your reciter_tabs.h file. The size of the tab36376 array must also match the data.
' debug.h: For simple debugging, QB64's PRINT and STOP are sufficient. If debug.h has more complex debugging functions, you'll need to translate those to QB64 equivalents.
' #define assert(X): QB64 doesn't have a direct equivalent to C's assert. I've used an IF...THEN STOP construct to halt execution when a condition is false. You might want to add more sophisticated error handling.
' Data Types:
' uint32_t (unsigned 32-bit integer) is translated to UINTEGER in QB64.
' uint8_t (unsigned 8-bit integer) is translated to UBYTE in QB64.
' int32_t (signed 32-bit integer) is translated to LONG in QB64.
' int8_t* (pointer to signed 8-bit integer) is translated to STRING to hold character data. Fixed-length strings are used to mimic C arrays.
' Arrays: C arrays are 0-indexed by default. QB64 arrays are also 0-indexed by default, which simplifies the translation.
' String Handling: C uses character arrays to represent strings. QB64 has built-in string types. I've used MID$() and ASC() to access and manipulate characters within the inputtemp string, since it's acting as a character array. Remember that QB64 string indices are 1-based, while the C code is 0-based, so I've added/subtracted 1 where necessary.
' Bitwise Operators: QB64 uses AND, OR, XOR, NOT for bitwise operations, which are equivalent to C's &, |, ^, ~.
' Comments: C-style // comments are translated to QB64's ' (single quote) comments.
' Placeholders: The TextToPhonemes function is a placeholder, just like in the C code. You'll need to fill in the actual QB64 implementation.
' extern: QB64 doesn't use extern in the same way C does. Variables declared outside of subroutines/functions are generally global in scope. I've initialized debug directly.
' To complete the translation, you MUST:
' Replace the example DATA statement with the actual data from your reciter_tabs.h file. Ensure the DIM tab36376 array is sized correctly to hold all the data.
' Implement the TextToPhonemes function in QB64. This is the core logic of your C code, and you'll need to translate it line by line.
' Test the translated QB64 code thoroughly. Pay close attention to array indexing and string manipulation, as these are areas where errors can easily occur during translation.
' Key Points and Considerations:
' SecureCopyInput and GetRuleByte: These functions are critical and their QB64 implementations are missing. You'll need to define these based on how the rule data is structured and how the input string needs to be handled. SecureCopyInput is about preventing buffer overflows, which QB64 handles differently than C, but you still need to consider string length limits. GetRuleByte will likely involve accessing bytes from a DATA section, a string, or an array.
' String Handling: QB64 uses 1-based indexing for strings, hence the MID$(inputtemp, X + 1, 1) and ASC() to get the character code.
' Fixed-Length Strings: I've used a fixed-length string inputtemp AS STRING * 256 to mimic the character array behavior in C. Adjust the length (256) as needed.
' Hex Literals: QB64 doesn't support 0x80 directly. I've used &H80 which is the QB64 equivalent.
' assert: QB64 doesn't have assert. I've replaced it with a conditional STOP to halt execution if the condition is false. You might want to use error handling or debugging messages instead, depending on your needs.
' Comments: I've kept the original C comments where they were helpful and added some QB64-specific comments.
' Goto: QB64 supports GOTO, and I've used it to translate the goto statement.
' Data Storage: The way the "rules" are stored is not defined in the C code snippet. You'll need to decide how to store them in QB64 (e.g., DATA statements, arrays, or files) and implement GetRuleByte accordingly.
' To complete this translation, you MUST provide the implementations for SecureCopyInput and GetRuleByte. The GetRuleByte function is particularly important as it is central to how the program logic works.
' Important Considerations and Refinements
' Global Variables: The C code heavily relies on global variables (e.g., A, X, Y, inputtemp). In QB64, it's generally better to explicitly declare these, either globally (using _GLOBAL) if truly needed across multiple functions or locally within the function and passed as parameters if possible. I've made assumptions about their scope. You MUST review and correct the scoping of these variables.
' inputtemp Size: The size of inputtemp is critical. I've assumed 255 based on the original code's usage. You must determine the correct size based on the maximum expected input and declare it accordingly. If it's dynamically allocated in the full C code, you'll need a different approach in QB64 (which doesn't have dynamic allocation in the same way).
' SecureCopyInput: This is the most important function to implement correctly. The provided example assumes input is a QB64 string. If input in your full QB64 code is a C-style null-terminated byte array (_BYTE array), you'll need to modify SecureCopyInput to handle that. Buffer overflows are a serious risk if SecureCopyInput is not implemented correctly.
' GetRuleByte and rule_table: The C code accesses a rule_table using indices. You must define how this rule_table is represented in QB64 (e.g., as a byte array). The example I provided is a starting point. Ensure you add bounds checking to GetRuleByte to prevent errors.
' TestFlag and TestFlagDec: The bitwise operations are straightforward, but ensure they accurately reflect the C code's logic.
' GOTO Statements: The C code uses goto. QB64 supports GOTO, but structured control flow (e.g., DO...LOOP, SELECT CASE) is generally preferred for readability. I've kept the GOTOs to mirror the original C, but consider refactoring if it improves clarity.
' Error Handling: The C code has basic error handling (returning 0). You might want to add more robust error handling in the QB64 version (e.g., using error codes, printing error messages).
' Testing: Thoroughly test the QB64 code to ensure it behaves identically to the original C code, especially with various input strings and rule sets.
' Comments: I've added comments to explain the QB64 code and highlight areas that need your attention. Read the comments carefully!
'
' This translation provides a functional starting point. You'll need to complete the implementations of SecureCopyInput, GetRuleByte, TestFlag, and TestFlagDec and adapt the code to your specific needs and coding style. Remember to prioritize safety (especially regarding buffer overflows) and readability.
' Key Changes Made:
' Data Types: C's int32_t, uint8_t, and size_t are translated to QB64's LONG for integers and strings for character arrays.
' String Handling: QB64 uses strings, so I replaced byte-level access with string manipulation functions. I assumed inputtemp is a string. Character access is done using MID$.
' Constants: C's const is replaced with CONST. Hexadecimal constants are kept the same.
' Array Indexing: QB64 array/string indexing starts at 1, while C starts at 0. I've adjusted indexing accordingly (e.g., inputtemp[X] becomes MID$(inputtemp$, X + 1, 1)).
' Goto: C's goto statements are directly translated to QB64's GOTO.
' Function Return: The C function's return value is assigned to the QB64 function name.
' Bitwise Operations: C's bitwise AND (&) is translated to QB64's AND.
' Character Comparisons: Character comparisons are done using ASC to get the ASCII value of the character.
' Missing SecureCopyInput: I've included a placeholder SUB for SecureCopyInput since the C code doesn't provide its implementation. You'll need to implement this in QB64.
' SetChar Function: I created a SetChar function to mimic setting a character at a specific index in a string.
'
' Important Notes:
' SecureCopyInput Implementation: You must implement the SecureCopyInput sub in QB64. This function is crucial for safely copying the input string. The provided C code doesn't show its implementation, so you'll need to create it based on its intended behavior (likely a safe string copy to prevent buffer overflows).
' Error Handling: The C code lacks explicit error handling. You might want to add error checks in the QB64 code (e.g., checking string lengths, array bounds).
' Testing: Thoroughly test the translated QB64 code to ensure it behaves identically to the original C code. Pay close attention to edge cases and boundary conditions.
' QB64-Specific Optimizations: Consider QB64-specific optimizations if performance is critical.
' You're welcome! I'm glad I could help. Remember those key points for getting the QB64 code fully functional:
' Implement SecureCopyInput: This is the most critical part. Without a proper implementation, your code might have unexpected behavior or vulnerabilities.
' Thorough Testing: Carefully test the QB64 code against various inputs to ensure it mirrors the C code's logic.
' Key Points and Assumptions:
' int32_t and size_t: C's int32_t and size_t are translated to QB64's LONG.
' int8_t* input: C's int8_t* input is translated to QB64's input AS STRING. We're assuming the input is treated as a string.
' inputtemp: The C code uses inputtemp as an array. I've assumed it's a global string array in QB64 (DIM SHARED inputtemp AS STRING * 256 or similar). You'll need to declare this appropriately in your QB64 code.
' SecureCopyInput: The C code calls SecureCopyInput. I've assumed this is a QB64 SUB. You'll need to implement this সাবroutine in QB64, as the C code snippet doesn't provide its implementation.
' TestFlagDec and TestFlag: The C code uses TestFlagDec and TestFlag. I've assumed these are QB64 FUNCTIONs. You'll need to implement these functions in QB64, as the C code snippet doesn't provide their implementation. These likely perform bitwise operations.
' Goto Statements: C's goto statements are directly translated to QB64's GOTO.
' Character Access: C's array-style character access (inputtemp[X]) is translated to QB64's ASC(MID$(inputtemp$, X, 1)) assuming inputtemp is a string. Remember that QB64 string indexing is 1-based.
' Comments: C-style comments (//) are translated to QB64's single-line comments (').
' Hexadecimal: C-style hexadecimal (0x20, 0x80) is translated to QB64's hexadecimal (&H20, &H80).
'
' Important Considerations:
' SecureCopyInput, TestFlagDec, and TestFlag Implementation: You must implement the SecureCopyInput, TestFlagDec, and TestFlag functions/subroutines in QB64 for this translation to work correctly. The provided C code doesn't include their definitions, so you'll need to either provide them or create QB64 equivalents. TestFlagDec and TestFlag likely involve bitwise AND operations.
' Global Variables: The C code uses global variables. Make sure you handle these appropriately in QB64, likely using DIM SHARED.
' Array Bounds: Pay close attention to array bounds in your QB64 implementation to avoid errors.
' Testing: Thoroughly test the translated QB64 code to ensure it behaves identically to the original C code.
' Key Points and Considerations:
' Function Equivalents: C functions like SecureCopyInput, GetRuleByte, and TestFlag need to be implemented as QB64 FUNCTIONs. I've provided placeholders, but you'll need to fill in the actual logic based on what these functions are supposed to do.
' Data Types: QB64 uses data types like INTEGER, LONG, and STRING. I've tried to match the C int32_t, int8_t, and size_t types as closely as possible. Pay close attention to array indexing (which starts at 1 in QB64 by default).
' String Handling: QB64 uses string functions like MID$, ASC, CHR$, and SPACE$ for string manipulation.
' GOTO Statements: The C code uses goto. QB64 supports GOTO, but excessive use can make code harder to read. Consider if you can refactor parts of the logic into SUBs or FUNCTIONs to reduce GOTO usage if possible.
' Comments: I've added comments to explain the translation.
' Error Handling: The C code has a basic return 0 for error. In QB64, you might want to use error codes, print error messages, or handle errors in a more structured way. I've added a basic PRINT "Error" and a GOTO ExitSub, but you should adapt this.
' Array Indexing: C arrays are 0-based, while QB64 arrays are 1-based by default. I've adjusted the indexing in MID$ accordingly (e.g., inputtemp[X] becomes MID$(inputtemp, X + 1, 1)). If you use arrays elsewhere, be mindful of this.
' Bitwise Operations: C uses bitwise operators (e.g., 0x80). QB64 uses equivalent operators (e.g., &H80 for hexadecimal).
' Missing Logic: The provided C code snippet is incomplete. It's missing the implementations of SecureCopyInput, GetRuleByte, TestFlag, and the logic for L_nextrule, L_emitrule, and the pos37xxx labels. You will need to add the missing parts to make it a complete and working QB64 program.
' Testing: Thoroughly test the translated QB64 code to ensure it behaves exactly like the original C code.
' This translation provides a starting point. You'll need to complete the missing function implementations and adapt the error handling and control flow to fit your specific needs and QB64 best practices.
' Important Considerations and Improvements:
' Global Variables: The C code uses variables like X, Y, A, and inputtemp without explicit declaration within the function. In QB64, it's best to declare these as global variables using DIM SHARED at the module level if they are used across multiple subroutines/functions. I've added a DIM inputtemp AS STRING, but you'll likely need to add others.
' SecureCopyInput: The C code calls a function SecureCopyInput. This function is not defined in the provided C code. You'll need to implement this in QB64. It likely involves copying the input string and ensuring it doesn't exceed max_size. I've replaced it with a simple string assignment, but you'll need to adapt this.
' inputtemp Handling: C uses a character array (int8_t*). QB64 uses strings. I've approximated the C code's array access with QB64's string manipulation functions (LEFT$, MID$, CHR$, ASC). Be very careful with string indexing in QB64, as it's 1-based. The C code appears to use 0-based indexing at times.
' TestFlagInc Function: I've translated the TestFlagInc function. Note that QB64 passes arguments by value by default, so modifying value inside the function doesn't affect the original variable passed in.
' GOTO Statements: The C code uses goto. While QB64 supports GOTO, excessive use can make code hard to read. Consider refactoring to use DO...LOOP, WHILE...WEND, or SELECT CASE if possible for better structure, especially for the missing logic in L_nextrule and L_match_right.
' Incomplete Logic: The provided C code snippet is not a complete function. The logic for L_nextrule and L_match_right is missing. You'll need to fill in the missing parts based on the complete C code or the algorithm you're implementing. My QB64 translation includes placeholders for these.
' Error Handling: The C code doesn't have explicit error handling. You should add error checks in the QB64 code (e.g., checking string lengths, array bounds).
' Data Types: The C code uses int32_t and uint8_t. QB64's closest equivalents are LONG and integer types (e.g., INTEGER or BYTE depending on the range).
' Clarity: I've added comments to the QB64 code to explain the translation and point out areas that need further attention.
' This translation provides a starting point. You'll need to carefully review it, implement the missing logic, and adapt it to the specifics of your application.
' Explanation of Key Changes and Considerations:
' Variable Declarations: QB64 requires explicit variable declarations using DIM. I've declared variables with appropriate types based on the C code (INTEGER(32) for uint32_t, INTEGER(8) for uint8_t, and STRING for character arrays).
' Arrays: C arrays are different from QB64 arrays. In QB64, arrays are indexed from 1 by default (unless you use OPTION BASE 0). I've declared inputtemp as a byte array (INTEGER(8)) to mirror the C code. Accessing elements is done with parentheses: inputtemp(X).
' String Handling: QB64 uses strings. I've used ASC() to convert characters to their ASCII values and MID$() to access substrings.
' GOTO: QB64 supports GOTO, so I've directly translated the goto statements. However, excessive use of GOTO can make code harder to read, so consider refactoring to use DO...LOOP, SELECT CASE, or IF...THEN...ELSEIF where appropriate for better structure.
' Function Return Values: QB64 functions return values directly by assigning to the function name (e.g., TextToPhonemes = 0).
' Bitwise Operations: QB64 uses standard bitwise operators: AND, OR, XOR, NOT.
' Comments: I've added comments to explain the translations.
' SecureCopyInput Stub: I've provided a basic stub for SecureCopyInput. You'll need to implement the actual string copying logic within this SUB to handle the input string correctly and prevent buffer overflows. This is crucial for the code to function as intended.
' Missing Logic: The provided C code snippet is incomplete. The L_nextrule, L_match_right, and L_emitrule labels are present, but the code blocks following them are missing. You'll need to add the QB64 equivalent of that missing C code to make the translation complete.
' TestFlagInc Function: I've translated the TestFlagInc function to QB64.
'
' Important Notes:
' Complete the Missing Logic: This translation is incomplete without the code for the L_nextrule, L_match_right, and L_emitrule labels.
' Implement SecureCopyInput: The SecureCopyInput sub is a placeholder and needs a proper implementation.
' Testing: Thoroughly test the translated QB64 code to ensure it behaves identically to the original C code.
' Optimization: QB64 and C have different performance characteristics. You might need to optimize the QB64 code for speed if performance is critical.
' Error Handling: Consider adding error handling to make the QB64 code more robust.
' You're welcome! I'm glad I could help. Remember those important points from before:
' Complete the missing logic: Fill in the code for L_nextrule, L_match_right, and L_emitrule.
' Implement SecureCopyInput: Make sure SecureCopyInput does its job correctly.
' Test thoroughly: Verify that the QB64 version works exactly like the C version.
' Good luck with your project!
' Key Points and Considerations:
' SecureCopyInput and GetRuleByte: The C code relies on two functions, SecureCopyInput and GetRuleByte, that are not defined within the provided snippet. To complete the QB64 translation, you'll need to provide QB64 implementations of these functions.
' SecureCopyInput likely handles copying the input string into a buffer (inputtemp) safely. A QB64 equivalent would need to manage memory and prevent buffer overflows.
' GetRuleByte probably retrieves a byte from a rule table based on an index. You'll need to know how this rule table is structured and accessed in C to replicate it in QB64.
' inputtemp Array: In C, inputtemp is an array of int8_t. In QB64, I've declared it as an array of INTEGER. Ensure this aligns with how inputtemp is used, or adjust to BYTE if necessary.
' String Handling: C and QB64 handle strings differently. In C, strings are often treated as arrays of characters. In QB64, strings are a distinct data type. I've used MID$ and CHR$ to work with the input string, which is the closest equivalent. Note that QB64 string indices are 1-based, while C array indices are 0-based.
' debug and PrintRule: The C code includes a conditional block that depends on a debug variable and calls a PrintRule function. You'll need to define debug (likely as a global variable) and provide a QB64 implementation of PrintRule if you want to keep this debugging functionality.
' static const uint8_t end_token: QB64 doesn't have static variables within functions in the same way C does. If end_token is needed elsewhere, it should be declared outside the function as a CONST.
' GOTO: QB64 supports GOTO, and I've used it to mimic the C goto statements. While GOTO is available, consider if the logic can be restructured using DO...LOOP and EXIT DO for better readability.
' Comments: I've added comments to explain the translation and highlight areas where you'll need to provide additional information or functions.
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' test the flag bits for a specific char
' this is non ascii layout, but tests ascii chars
'uint32_t TestFlag(uint8_t in, uint8_t mask)
' {
' assert(in<sizeof(tab36376));
' const uint8_t val = tab36376[in];
' return val & mask;
' }
FUNCTION TestFlag (in AS UBYTE, mask AS UBYTE) AS UINTEGER
IF in > UBOUND(tab36376) THEN STOP 'QB64: Replace assert with STOP
' val = tab36376(in) 'Not needed, can use array element directly
TestFlag = tab36376(in) AND mask 'QB64: AND is bitwise AND
END FUNCTION
' test the flag bits for the pervious char in the stream
'uint32_t TestFlagDec(uint8_t mem59, uint8_t mask)
'{
' X = mem59;
' X--;
' A = inputtemp[X];
' Y = A;
' assert(Y<sizeof(tab36376));
' A = tab36376[Y];
' return A & mask;
'}
FUNCTION TestFlagDec (mem59 AS UBYTE, mask AS UBYTE) AS UINTEGER
X = mem59
X = X - 1
A = ASC(MID$(inputtemp, X + 1, 1)) 'QB64: Access char in string, ASC gets ASCII value
Y = A
IF Y > UBOUND(tab36376) THEN STOP
A = tab36376(Y)
TestFlagDec = A AND mask
END FUNCTION
' test the flag bits for the next char in the stream
'uint32_t TestFlagInc(uint8_t mem58, uint8_t mask)
'{
' X = mem58;
' X++;
' A = inputtemp[X];
' Y = A;
' assert(Y<sizeof(tab36376));
' A = tab36376[Y];
' return A & mask;
'}
FUNCTION TestFlagInc (mem58 AS UBYTE, mask AS UBYTE) AS UINTEGER
X = mem58
X = X + 1
A = ASC(MID$(inputtemp, X + 1, 1)) 'QB64: Access char in string, ASC gets ASCII value
Y = A
IF Y > UBOUND(tab36376) THEN STOP
A = tab36376(Y)
TestFlagInc = A AND mask
END FUNCTION
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' Key Changes and Considerations:
' Data Types: QB64PE has different data types. size_t and uint8_t from C are approximated with INTEGER in QB64PE. int8_t * is represented by a STRING.
' Arrays: QB64PE arrays are 0-based by default. The code assumes rule_tab and rules are arrays. You'll need to declare and dimension them appropriately before using these subs/functions.
' String Handling: QB64PE uses MID$, ASC, and CHR$ to manipulate strings. C uses character arrays. Also, QB64PE string indexes start at 1, not 0.
' sizeof Equivalent: The UBOUND function is used to get the upper bound of an array, similar to sizeof in C when used with arrays.
' Assertions: QB64PE doesn't have a direct equivalent to assert. I've replaced them with IF...THEN PRINT...STOP for basic error checking.
' Null Termination: C strings are null-terminated. QB64PE strings are not. The memset equivalent in QB64PE is input = STRING$(max_size, 0).
' continue Equivalent: The _CONTINUE statement is used to skip to the next loop iteration, similar to C's continue.
' Global Variables: The C code uses global variables (e.g., X, Y, A, inputtemp). In QB64PE, you'll likely need to declare these outside the subs/functions or use SHARED if you want them to be accessible globally. inputtemp is changed to inputtemp$ to indicate a string.
' Comments: I've added comments to explain the translations.
'
' Important Notes:
' Array Declarations: You MUST declare and dimension the arrays rule_tab and rules before using this code. For example:
'
' Code snippet
' DIM rule_tab(27) AS INTEGER ' Assuming 28 elements
' DIM rules(some_size) AS INTEGER ' Replace 'some_size' with the actual size
' DIM inputtemp$(some_other_size) AS STRING
' Error Handling: The error handling is basic. You might want to add more robust error reporting.
'
' String Size: Be mindful of the maximum size of strings in QB64PE.
'
' Testing: Thoroughly test this translated code to ensure it behaves exactly like the original C code.
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' verify that the reciter tables are well formed
SUB ReciterVerify ()
DIM ix AS INTEGER
ix = 0
FOR ix = 0 TO 27 ' Assuming rule_tab is 0-based index and has 28 elements [cite: 2]
DIM pos AS INTEGER
pos = rule_tab(ix)
' Assuming rules is an array and QB64PE arrays are 0-based
IF rules(pos) <> 93 THEN ' 93 is the ASCII code for ']'
PRINT "Assertion failed: rules(" ; pos ; ") <> ']'"
STOP
END IF
NEXT ix
END SUB
' lookup a byte for a specific rule in the table
FUNCTION GetRuleByte (rule_index AS INTEGER, Y AS INTEGER) AS INTEGER
' Assuming rules is an array of integers (since C uses uint8_t)
DIM end AS INTEGER
end = UBOUND(rules) 'UBOUND gives the highest index
DIM index AS INTEGER
index = rule_index + Y
IF index >= end THEN
PRINT "Assertion failed: index < end"
STOP
END IF
GetRuleByte = rules(index)
END FUNCTION
SUB SecureCopyInput (input AS STRING, max_size AS INTEGER)
' secure copy of input because input will be overwritten by phonemes
X = 1
Y = 0
DO WHILE Y < max_size
A = ASC(MID$(input, Y + 1, 1)) ' QB64PE strings are 1-based index
Y = Y + 1
IF A < 32 THEN '0x20 = 32
_CONTINUE
END IF
IF A = 96 THEN '0x60 = 96
_CONTINUE
END IF
IF A = 39 THEN '0x27 = 39
_CONTINUE
END IF
IF A >= 126 THEN '0x7E = 126
_CONTINUE
END IF
inputtemp$(X) = CHR$(A)
X = X + 1
LOOP
' Null-terminate the input string (important for C compatibility)
input = STRING$(max_size, 0) 'Fills the string with null characters (ASCII 0)
END SUB
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' Key Points and Considerations:
' String Handling: QB64 handles strings differently than C. Directly assigning to a character within a string requires using functions like LEFT$, MID$, and CHR$.
' SecureCopyInput and TestFlag: I've provided placeholder implementations. You must implement these functions correctly based on the original C code to ensure safety and accurate behavior. SecureCopyInput is crucial to prevent buffer overflows. TestFlag needs to replicate the bitwise logic of the C code.
' rule_tab: This is assumed to be an array. You'll need to declare and initialize it with the appropriate values from the C code. QB64 arrays are 1-based.
' GOTO: I've used GOTO to mimic the C goto. While it works, consider refactoring the code to use more structured control flow (e.g., DO...LOOP, WHILE...WEND, SELECT CASE) where possible, as GOTO can make code harder to read and maintain.
' Error Handling: QB64 doesn't have assert. I've added a basic check for the array bounds, but you might want to add more robust error handling.
' Comments: I've added comments to explain the translations and point out areas that need further attention.
' Incomplete Translation: This translation covers "PART 1" of the C code. You'll need to translate the remaining parts ("PART 2," etc.) and integrate them into this QB64 code to have a complete working program.
' Testing: Thoroughly test the QB64 code to ensure it behaves identically to the original C code. Pay close attention to boundary conditions and potential errors.
' To make it fully functional, you'll need to:
' Implement SecureCopyInput and TestFlag correctly: These are crucial for the program's logic and safety. Pay close attention to the original C code's bitwise operations and memory handling.
' Populate rule_tab: Fill the rule_tab array with the correct data.
' Translate the rest of the C code: The provided code only covers "PART 1." You'll need to translate "PART 2" and any other parts of the C code and integrate them into the QB64 program.
' Test thoroughly: Carefully test the QB64 code to ensure it produces the same output as the original C code, especially with various input strings and edge cases.
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' BEGIN PART 1
FUNCTION TextToPhonemes (input AS STRING, max_size AS LONG) AS LONG
max_size = 250
CONST end_token = 155 ' ESC | 0x80 [cite: 1, 2]
DIM out_pos AS LONG ' output position for phonemes [cite: 2]
DIM mem57 AS LONG
DIM mem58 AS LONG ' current pos, used mostly in rhs match [cite: 3]
DIM mem59 AS LONG
DIM mem60 AS LONG
DIM mem61 AS LONG [cite: 3, 4]
DIM rule_index AS LONG ' memory position of current rule [cite: 4]
DIM mem64 AS LONG ' position of '=' or current character [cite: 5]
DIM pos_rparen AS LONG ' position of ')' [cite: 5, 6]
DIM pos_lparen AS LONG ' position of '(' [cite: 6]
DIM mem36653 AS LONG
inputtemp$ = SPACE$(256) ' Assuming inputtemp is a string, adjust size as needed
inputtemp$ = " " + inputtemp$ 'inputtemp[0] = 0x20; // ' ' [cite: 6]
'SECURECOPYINPUT input$, input, max_size 'Need to implement SecureCopyInput (see below)
'For simplicity, assuming a direct copy for now. Adjust as needed for QB64 string handling
inputtemp$ = input ' Assuming direct copy; implement SecureCopyInput for safety
Y = 255
X = 255
inputtemp$ = LEFT$(inputtemp$, X) + CHR$(27) + MID$(inputtemp$, X + 2) 'inputtemp[X] = 27; // ESC [cite: 6]
mem61 = 255
A = 255
out_pos = 255
' ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
' START PARSE
' ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- [cite: 7]
L_start_parse:
DO
mem61 = mem61 + 1
X = mem61
' if end of input marker
A = ASC(MID$(inputtemp$, X + 1, 1)) 'A = inputtemp[X]; [cite: 7]
mem64 = A
IF A = ASC("[") THEN
out_pos = out_pos + 1
X = out_pos
A = end_token
'input[X] = A ' Cannot directly assign to input string like this
' Assuming input is passed by reference and we modify it. Need to convert A back to character
input = LEFT$(input, X) + CHR$(A) + MID$(input, X + 2) ' Modify input string [cite: 7, 8]
' success
TextToPhonemes = 1
EXIT FUNCTION
END IF
IF A = ASC(".") THEN
' check a flag for next input char?
X = X + 1
Y = ASC(MID$(inputtemp$, X + 1, 1)) 'Y = inputtemp[X]; [cite: 8, 9]
'A = TestFlag(Y, 1) ' Need to implement TestFlag (see below)
' Assuming TestFlag checks bit 0; using bitwise AND for now
A = (Y AND 1) ' Simple bit check, replace with actual TestFlag if needed
IF A = 0 THEN
' output a '.'
out_pos = out_pos + 1
X = out_pos
A = ASC(".")
'input[X] = A
input = LEFT$(input, X) + CHR$(A) + MID$(input, X + 2) ' Modify input string [cite: 9, 10]
ELSE
EXIT DO
END IF
ELSE
EXIT DO
END IF
LOOP 'while [cite: 10, 11, 12]
' if this character is non alpha
A = mem64
Y = A
'A = TestFlag(A, 255) ' Need to implement TestFlag
' Assuming TestFlag checks for non-alpha; QB64's ASCII range for A-Z is 65-90
IF (A >= 65 AND A <= 90) THEN
mem57 = 0 ' If it's A-Z, flag is 0 (not non-alpha)
ELSE
mem57 = 2 ' Otherwise, set flag bit 1 (0x02)
END IF 'Simplified, replace with actual TestFlag [cite: 12, 13, 14]
IF (mem57 AND 2) THEN 'if (A & 0x02)
rule_index = rule_tab(27) ' Assuming rule_tab is an array, and we have 27 elements
GOTO L_nextrule ' Use GOTO with caution, consider refactoring
END IF
' what be this ???
A = mem57 ' flag for A [cite: 14, 15, 16]
IF A = 0 THEN
A = ASC(" ")
inputtemp$ = LEFT$(inputtemp$, X) + CHR$(A) + MID$(inputtemp$, X + 2) 'inputtemp[X] = A; [cite: 16, 17]
out_pos = out_pos + 1
X = out_pos
' hard exit on too long?
IF X > max_size THEN
'input[max_size - 1] = end_token
input = LEFT$(input, max_size) + CHR$(end_token) + MID$(input, max_size + 2)
A = mem61
mem36653 = A
TextToPhonemes = 0
EXIT FUNCTION
ELSE
'input[X] = A
input = LEFT$(input, X) + CHR$(A) + MID$(input, X + 2) [cite: 17, 18, 19, 20]
GOTO L_start_parse
END IF
END IF
' what is A at this point?
A = mem57 AND 128 '0x80 in decimal [cite: 20, 21]
IF A = 0 THEN
' error
TextToPhonemes = 0
EXIT FUNCTION
END IF
' go to the right rules for this character.
X = mem64 - ASC("A")
'assert(X<26); ' QB64 doesn't have assert; can add a check if needed
IF X < 0 OR X > 25 THEN
' Handle out-of-bounds, e.g., PRINT "Error: Invalid character"; RETURN
PRINT "Error: Invalid character";
TextToPhonemes = 0
EXIT FUNCTION
END IF
rule_index = rule_tab(X + 1) ' QB64 arrays are 1-based [cite: 21, 22, 23]
'// ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
'// TRY MATCHING NEXT RULE
'// ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
L_nextrule:
'// find next rule
'// skip to next rule byte with 0x80 mask
Y = 0
DO
rule_index = rule_index + 1
A = GetRuleByte(rule_index, Y) '//Need to define GetRuleByte function
LOOP WHILE (A AND &H80) = 0 '// (A&0x80)==0
Y = Y + 1
'// if there are no more rules in this set
IF GetRuleByte(rule_index, Y) = ASC("]") THEN '// GetRuleByte(rule_index, Y)==']'
RETURN 0
END IF
'// identify key points in this rule
'// find '('
DO
'// fixme: fix infinite loop here with ' chars
A = GetRuleByte(rule_index, Y)
' assert((A & 0x80)==0); '// QB64 doesn't have assert, consider a conditional check
IF (A AND &H80) <> 0 THEN STOP '// If assert fails, stop execution
IF A = ASC("(") THEN EXIT DO '// if (A == '(')
Y = Y + 1
LOOP
pos_lparen = Y
'// find ')'
DO
Y = Y + 1
A = GetRuleByte(rule_index, Y)
LOOP WHILE A <> ASC(")") '// A != ')'
pos_rparen = Y
'// find '='
DO
Y = Y + 1
A = GetRuleByte(rule_index, Y)
A = A AND &H7F '// A = A & 0x7F;
LOOP WHILE A <> ASC("=") '// A != '='
mem64 = Y
X = mem61
mem60 = X
'// ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
'// MATCH EXPRESSION IN PARENTHESIS
'// ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
Y = pos_lparen
Y = Y + 1
'// pos36759:
DO
mem57 = ASC(MID$(inputtemp, X + 1, 1)) '// mem57 = inputtemp[X];
A = GetRuleByte(rule_index, Y)
IF A <> mem57 THEN '// if (A!=mem57)
'// no match lets apply next rule
GOTO L_nextrule
END IF
Y = Y + 1
IF Y = pos_rparen THEN EXIT DO '// if (Y==pos_rparen)
X = X + 1
mem60 = X
LOOP
'// the string in the bracket is correct
'// pos36787:
A = mem61
mem59 = mem61
'---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
'MATCH TO LEFT OF ( IN RULE
'---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
L_match_left:
' scan back to find start?
DO
pos_lparen = pos_lparen - 1
Y = pos_lparen
A = GetRuleByte(rule_index, Y) 'Need equivalent QB64 function. See below
mem57 = A
' if end of lhs pattern
IF (A AND &H80) THEN ' Check if the most significant bit is set
A = mem60
mem58 = A
GOTO L_match_right ' QB64 uses GOTO
END IF
'
X = A AND &H7F ' all but msb
A = TestFlag(X, &H80) 'Need equivalent QB64 function. See below
IF (A = 0) THEN
' parse special escape rule
EXIT DO ' QB64 uses EXIT DO to exit a DO loop
END IF
X = mem59 - 1
A = inputtemp(X)
IF (A <> mem57) THEN
GOTO L_nextrule ' QB64 uses GOTO
END IF
mem59 = X
LOOP
' test for special escape chars
A = mem57
SELECT CASE A
CASE 32 ' " "
GOTO pos36895
CASE 35 ' "#"
GOTO pos36910
CASE 46 ' "."
GOTO pos36920
CASE 38 ' "&"
GOTO pos36935
CASE 64 ' "@"
GOTO pos36967
CASE 94 ' "^"
GOTO pos37004
CASE 43 ' "+"
GOTO pos37019
CASE 58 ' ":"
GOTO pos37040
CASE ELSE
' error
RETURN 0
END SELECT
'---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
pos36895: ' handle " "
A = TestFlagDec(mem59, &H80) 'Need equivalent QB64 function. See below
IF (A = 0) THEN
mem59 = X
GOTO L_match_left
END IF
GOTO L_nextrule
'---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
pos36910: ' handle "#"
A = TestFlagDec(mem59, &H40) 'Need equivalent QB64 function. See below
IF (A <> 0) THEN
mem59 = X
GOTO L_match_left
END IF
GOTO L_nextrule
'---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
pos36920: ' handle "."
A = TestFlagDec(mem59, &H08) 'Need equivalent QB64 function. See below
IF (A <> 0) THEN
mem59 = X
GOTO L_match_left
END IF
GOTO L_nextrule
' ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
pos36935: ' handle '&' [cite: 6]
A = TestFlagDec(mem59, 16) '0x10 [cite: 6]
IF A <> 0 THEN
mem59 = X
GOTO L_match_left
END IF
A = ASC(MID$(inputtemp$, X + 1, 1))
IF A = ASC("H") THEN
X = X - 1
A = ASC(MID$(inputtemp$, X + 1, 1))
IF (A = ASC("C")) OR (A = ASC("S")) THEN
mem59 = X
GOTO L_match_left
END IF
END IF
GOTO L_nextrule
' ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
pos36967: ' handle '@' [cite: 8]
A = TestFlagDec(mem59, 4) '0x04 [cite: 8]
IF A <> 0 THEN
mem59 = X
GOTO L_match_left
END IF
A = ASC(MID$(inputtemp$, X + 1, 1))
IF (A <> ASC("H")) AND (A <> ASC("T")) AND (A <> ASC("C")) AND (A <> ASC("S")) THEN
GOTO L_nextrule
END IF
mem59 = X
GOTO L_match_left
' ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
pos37004: ' handle '^' [cite: 9]
A = TestFlagDec(mem59, 32) '0x20 [cite: 9]
IF A <> 0 THEN ' [cite: 10]
mem59 = X
GOTO L_match_left ' [cite: 10]
END IF ' [cite: 11]
GOTO L_nextrule
' ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
pos37019: ' handle '+' [cite: 6]
X = mem59 [cite: 6]
X = X - 1 [cite: 7]
A = ASC(MID$(inputtemp$, X, 1)) ' Assuming inputtemp$ is a string version
IF (A = ASC("E")) OR (A = ASC("I")) OR (A = ASC("Y")) THEN [cite: 7]
mem59 = X [cite: 7]
GOTO L_match_left
END IF
GOTO L_nextrule
' ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
pos37040: ' handle ':' [cite: 7]
A = TestFlagDec(mem59, &H20) ' Assuming TestFlagDec is a QB64 FUNCTION
IF A <> 0 THEN [cite: 7]
mem59 = X [cite: 7]
GOTO pos37040
END IF
GOTO L_match_left
' ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
pos37077: ' handle '%' [cite: 8]
X = mem58 + 1 [cite: 8]
A = ASC(MID$(inputtemp$, X, 1))
IF A <> ASC("E") THEN [cite: 8]
GOTO L_match_ing
END IF
X = X + 1
Y = ASC(MID$(inputtemp$, X, 1))
X = X - 1 [cite: 8]
A = TestFlag(Y, &H80) ' Assuming TestFlag is a QB64 FUNCTION [cite: 9]
IF A <> 0 THEN [cite: 9]
X = X + 1 [cite: 9]
A = ASC(MID$(inputtemp$, X, 1)) [cite: 9, 10]
IF A <> ASC("R") THEN [cite: 10]
GOTO pos37113 [cite: 10]
END IF
END IF
mem58 = X [cite: 11]
GOTO L_match_right [cite: 11]
'
'// ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
'pos37113: // unknown ???
pos37113:
IF (A = ASC("S")) OR (A = ASC("D")) THEN
mem58 = X
GOTO L_match_right
END IF
IF A <> ASC("L") THEN
GOTO pos37135
END IF
X = X + 1
A = ASC(MID$(inputtemp, X + 1, 1))
IF A <> ASC("Y") THEN
GOTO L_nextrule
END IF
mem58 = X
GOTO L_match_right
'pos37135: // match FUV
pos37135:
IF A <> ASC("F") THEN
GOTO L_nextrule
END IF
X = X + 1
A = ASC(MID$(inputtemp, X + 1, 1))
IF A <> ASC("U") THEN
GOTO L_nextrule
END IF
X = X + 1
A = ASC(MID$(inputtemp, X + 1, 1))
IF A <> ASC("V") THEN
GOTO L_nextrule
END IF
mem58 = X
GOTO L_match_right
'L_match_ing: // match 'ING'
L_match_ing:
IF A <> ASC("I") THEN
GOTO L_nextrule
END IF
X = X + 1
A = ASC(MID$(inputtemp, X + 1, 1))
IF A <> ASC("N") THEN
GOTO L_nextrule
END IF
X = X + 1
A = ASC(MID$(inputtemp, X + 1, 1))
IF A <> ASC("G") THEN
GOTO L_nextrule
END IF
mem58 = X
GOTO L_match_right
'// ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
'// MATCH RIGHT OF ) IN RULE
'// ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
L_match_right:
Y = pos_rparen + 1
IF Y = mem64 THEN
GOTO L_emitrule
END IF
pos_rparen = Y
'A = GetRuleByte(rule_index, Y);
'Need to define GetRuleByte function
'A = GetRuleByte(rule_index, Y)
'For now, placeholder:
A = 0 ' Placeholder
mem57 = A
X = A
'A = TestFlag(X, 0x80);
'Need to define TestFlag function
'A = TestFlag(X, &H80)
'For now, placeholder:
A = 0 'Placeholder
IF A = 0 THEN
A = mem57
SELECT CASE A
CASE ASC(" "): GOTO pos37295
CASE ASC("#"): GOTO pos37310
CASE ASC("."): GOTO pos37320
CASE ASC("&"): GOTO pos37335
CASE ASC("@"): GOTO pos37367
CASE ASC("^"): GOTO pos37404
CASE ASC("+"): GOTO pos37419
CASE ASC(":"): GOTO pos37440
CASE ASC("%"): GOTO pos37077
CASE ELSE
'// error
' return 0;
PRINT "Error"
'END 'Instead of return, you might want to handle this differently
GOTO ExitSub ' Add an exit label
END SELECT
ELSE
'// what this does ??
X = mem58 + 1
A = ASC(MID$(inputtemp, X + 1, 1))
IF A <> mem57 THEN
GOTO L_nextrule
END IF
mem58 = X
GOTO L_match_right
END IF
' ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
pos37295: ' handle ' ' [cite: 6, 7]
A = TestFlagInc(mem58, &H80)
IF A <> 0 THEN
GOTO L_nextrule
END IF
mem58 = X
GOTO L_match_right
' ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
pos37310: ' handle '#' [cite: 7]
A = TestFlagInc(mem58, &H40)
IF A <> 0 THEN
mem58 = X
GOTO L_match_right
END IF
GOTO L_nextrule
' ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
pos37320: ' handle '.' [cite: 7, 8]
A = TestFlagInc(mem58, &H08)
IF A = 0 THEN
GOTO L_nextrule
END IF
mem58 = X
GOTO L_match_right
' ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
pos37335: ' handle '&' [cite: 8]
A = TestFlagInc(mem58, &H10)
IF A <> 0 THEN
mem58 = X
GOTO L_match_right
END IF
A = ASC(MID$(inputtemp, X + 1, 1)) ' Corrected index [cite: 9, 10]
IF A <> ASC("H") THEN
GOTO L_nextrule
END IF
' is this really x++ not x--? [cite: 10, 11]
X = X + 1
A = ASC(MID$(inputtemp, X + 1, 1)) ' Corrected index [cite: 11]
IF (A = ASC("C")) OR (A = ASC("S")) THEN ' [cite: 12]
mem58 = X
GOTO L_match_right
END IF
GOTO L_nextrule
' ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
pos37367: ' handle '@' [cite: 6]
A = TestFlagInc(mem58, 4) ' 0x04 [cite: 6, 7]
IF A <> 0 THEN
mem58 = X ' [cite: 7]
GOTO L_match_right
END IF
A = inputtemp(X) ' [cite: 7]
IF (A <> ASC("H")) AND (A <> ASC("T")) AND (A <> ASC("C")) AND (A <> ASC("S")) THEN
GOTO L_nextrule ' [cite: 7]
END IF
mem58 = X ' [cite: 7]
GOTO L_match_right
' ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
pos37404: ' handle '^' [cite: 7]
A = TestFlagInc(mem58, 32) ' 0x20 [cite: 7, 8]
IF A = 0 THEN
GOTO L_nextrule ' [cite: 8]
END IF
mem58 = X ' [cite: 8]
GOTO L_match_right
' ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
pos37419: ' handle '+' [cite: 8]
X = mem58 ' [cite: 8]
X = X + 1 ' [cite: 8]
A = inputtemp(X) ' [cite: 8]
IF (A = ASC("E")) OR (A = ASC("I")) OR (A = ASC("Y")) THEN ' [cite: 9]
mem58 = X ' [cite: 9]
GOTO L_match_right
END IF
GOTO L_nextrule ' [cite: 10]
' ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
pos37440: ' handle ':' [cite: 10]
DO
A = TestFlagInc(mem58, 32) ' 0x20 [cite: 10]
IF A = 0 THEN
GOTO L_match_right ' [cite: 11]
END IF
mem58 = X ' [cite: 12]
LOOP
GOTO L_emitrule ' [cite: 12]
'// ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
'// EMIT RULE
'// ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
L_emitrule:
Y = mem64
mem61 = mem60
'if debug then ' Assuming 'debug' is a global variable.
' PrintRule rule_index ' Assuming PrintRule is a function.
'end if
DO
Y = Y + 1
'A = GetRuleByte(rule_index, Y) ' Assuming GetRuleByte is a function.
' Placeholder for GetRuleByte
' A = GetRuleByte(rule_index, Y) ' Needs QB64 Implementation
' Need to know how GetRuleByte works
mem57 = A
' mask out parity
A = A AND 127 '// 0x7f
IF A <> ASC("=") THEN
out_pos = out_pos + 1
X = out_pos
'input[X] = A ' Since 'input' is a string, we can't directly assign an integer to an index.
MID$(input, X + 1, 1) = CHR$(A) ' QB64 strings are 1-based index, C arrays are 0-based.
END IF
' if has parity set
IF (mem57 AND 128) <> 0 THEN ' //0x80
GOTO L_start_parse
END IF
LOOP
L_start_parse:
TextToPhonemes = out_pos
END FUNCTION
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' END reciter.c
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' BEGIN render.c
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' Key Changes Made:
' Comments: C-style comments (//) were changed to QB64's single-line comment style (').
' Data Types: Explicitly declared variable types using DIM AS _UNSIGNED _BYTE and DIM AS INTEGER. This is important in QB64.
' Arrays: It's assumed that phonemeIndexOutput, stressOutput, phonemeLengthOutput, freq1data, freq2data, freq3data, ampl1data, ampl2data, ampl3data, sampledConsonantFlags, frequency1, frequency2, frequency3, amplitude1, amplitude2, amplitude3, sampledConsonantFlag, pitches, and tab47492 are arrays. You'll need to declare these arrays with appropriate dimensions in your QB64 program. For example:
' Code snippet
' DIM phonemeIndexOutput(255) AS _UNSIGNED _BYTE
' DIM stressOutput(255) AS _UNSIGNED _BYTE
' ' ... etc.
' The size 255 is a placeholder; adjust it based on your actual needs.
' Boolean Logic: C uses == for comparison and != for "not equals". QB64 uses = and <> respectively.
' Subroutines: The void Render() function was converted to a SUB Render ... END SUB.
' Goto Replacement: The goto statements were replaced with a call to AddInflection. It's assumed that AddInflection is another SUB.
' Variable Scope: In QB64, variables are generally global unless explicitly declared within a SUB. Consider carefully if you intend these variables to be global or local.
' Missing Code: This conversion assumes the existence of freq1data, freq2data, freq3data, ampl1data, ampl2data, ampl3data, sampledConsonantFlags, phonemeIndexOutput, phonemeLengthOutput, stressOutput, tab47492, pitch, A, X, Y, mem44, mem56. You'll need to define these and initialize them in your QB64 program. Also, the AddInflection subroutine needs to be defined.
' Important Considerations:
' - Array Bounds: Make absolutely sure your array declarations are correct to prevent errors.
' - Global vs. Local: Decide on the scope of your variables.
' - Initialization: Initialize all variables before using them.
' - Data Loading: You'll need code to load the data into the arrays (e.g., from files or DATA statements).
' - AddInflection Subroutine: You MUST implement the AddInflection subroutine. The provided C code doesn't include it.
' - Testing: Thoroughly test the converted QB64 code to ensure it functions identically to the original C code.
' Key Changes Made:
' Variable Declarations: QB64 requires explicit variable declarations. You'll need to add DIM statements at the beginning of your program to declare the variables used (e.g., DIM mem48 AS INTEGER, DIM pitches(255) AS INTEGER, etc.). I've omitted these as I don't have the full context of the surrounding code.
' Array Indexing: QB64 array indices start at 0 by default. The C code uses array indexing, which translates directly to QB64.
' Bitwise Operators:
' C's & (bitwise AND) is AND in QB64.
' C's >> (right bit shift) is \ (integer division by a power of 2) in QB64 for positive numbers.
' C's | (bitwise OR) is BINAND in QB64.
' Boolean Logic: C uses ! for NOT and == for equality. QB64 uses NOT and =. I've used = 0 instead of ! where appropriate.
' GOTO Statements: C's goto is directly translatable to QB64's GOTO. While GOTO is generally discouraged in modern programming, it's used here to maintain the original program's logic.
' Comments: C-style comments (//) are replaced with QB64's ' or REM.
' Preprocessor Directives: C preprocessor directives like #if and #endif are replaced with QB64's #IF...#ENDIF.
' Function Calls: It's assumed that functions like PrintOutput, RenderSample, Output, and Read are defined elsewhere in your code. Make sure these are also translated to QB64.
' Data Types: QB64 has specific data types (INTEGER, LONG, SINGLE, DOUBLE, STRING). Ensure the C data types are correctly translated to their QB64 equivalents.
' continue: C's continue keyword is replaced with _CONTINUE in QB64 to continue to the next iteration of the DO loop.
' IIF: QB64 doesn't have a direct equivalent to C's ternary operator (condition ? value_if_true : value_if_false). I've used the IIF function to mimic this behavior. Note that IIF always evaluates both branches, which can have side-effects if you're not careful.
' Important Considerations:
' - Missing Code: This conversion is based solely on the provided Render function. You'll need to convert the rest of your C code (variable declarations, other functions, etc.) to QB64 for it to work.
' - External Functions: The code calls functions like PrintOutput, RenderSample, Output, and potentially Read. You must provide QB64 implementations of these functions.
' - Arrays: Ensure all arrays (e.g., phonemeLengthOutput, frequency1, amplitudeRescale, etc.) are properly declared and dimensioned in QB64.
' - Testing: Thoroughly test the converted QB64 code to ensure it behaves identically to the original C code. There might be subtle differences in how C and QB64 handle certain operations.
' - Optimization: This is a direct translation for clarity. You can likely optimize the QB64 code for better performance.
' Explanation of Key Changes and Considerations:
' Variable Declarations: C's uint8_t is mapped to QB64's _BYTE. int32_t is mapped to INTEGER to handle potential overflows. Arrays are explicitly dimensioned.
' Array Initialization: QB64 uses DATA and READ to initialize arrays.
' Goto Replacement: QB64 supports GOTO, but it's often better to use structured control flow. However, to stay close to the original C, I've kept the GOTO statements. In a more idiomatic QB64 version, you might refactor this with DO...LOOP and SELECT CASE.
' Bitwise Operations: QB64 uses different operators for bitwise operations:
' & (AND)
' OR
' XOR
' NOT
' \ for integer division (which is equivalent to a right bit shift if you're only shifting by 1)
' * 2 for left bit shift
' Carry Flag: QB64 doesn't give you direct access to the CPU's carry flag. The addition operation handles carries internally. You need to check for overflow after addition if you explicitly need to know if a carry occurred (e.g., IF temp > 255 THEN carry = 1).
' Comments: I've added comments to explain the code and highlight differences from the C code.
' Function Return: QB64 functions return values by assigning to the function name (e.g., trans% = mem39215). The % sign after the function name indicates it returns an integer.
' Subroutines: C functions become SUB procedures in QB64.
' Parameter Passing: QB64 uses BYVAL or BYREF (the default) for parameter passing. I've explicitly used AS _BYTE to define the parameter types.
' Integer Division: The right bit shift >> in C is replaced with integer division \ by 2.
' Important Notes:
' - Testing: This code is a direct translation. You must thoroughly test it to ensure it behaves exactly like the original C code. Pay close attention to edge cases and potential differences in how QB64 handles arithmetic.
' - Optimization: This translation prioritizes clarity and directness. There might be opportunities to optimize the QB64 code for speed or readability.
' - Context: This code snippet likely depends on other parts of a larger program. You'll need to integrate this QB64 code into the rest of your QB64 project.
' - QB64-Specific Idioms: Consider refactoring the code to use more common QB64 patterns (e.g., using SELECT CASE instead of complex IF...THEN...ELSEIF chains, using more descriptive variable names if appropriate for your project).
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' Main program (you might have other code here)
' Example calls (replace with your actual usage)
' CALL AddInflection(255, 0)
' CALL SetMouthThroat(100, 50)
' This code is a conversion of the provided C code to QB64.
' It attempts to maintain the original logic and variable names
' where possible, but QB64 syntax and features are used.
' RENDER THE PHONEMES IN THE LIST
'
' The phoneme list is converted into sound through the steps:
'
' 1. Copy each phoneme <length> number of times into the frames list,
' where each frame represents 10 milliseconds of sound.
'
' 2. Determine the transitions lengths between phonemes, and linearly
' interpolate the values across the frames.
'
' 3. Offset the pitches by the fundamental frequency.
'
' 4. Render the each frame.
Sub Render
Dim phase1 As _Unsigned _Byte ' mem43
Dim phase2 As _Unsigned _Byte
Dim phase3 As _Unsigned _Byte
Dim mem66 As _Unsigned _Byte
Dim mem38 As _Unsigned _Byte
Dim mem40 As _Unsigned _Byte
Dim speedcounter As _Unsigned _Byte ' mem45
Dim mem48 As _Unsigned _Byte
Dim i As Integer
Dim carry As Integer
If phonemeIndexOutput(0) = 255 Then
Exit Sub 'exit if no data
End If
A = 0
X = 0
mem44 = 0
' CREATE FRAMES
'
' The length parameter in the list corresponds to the number of frames
' to expand the phoneme to.
' Each frame represents 10 milliseconds of time.
' So a phoneme with a length of 7 = 7 frames = 70 milliseconds duration.
'
' The parameters are copied from the phoneme to the frame verbatim.
Do
' get the index
Y = mem44
' get the phoneme at the index
A = phonemeIndexOutput(mem44)
mem56 = A
' if terminal phoneme, exit the loop
If A = 255 Then Exit Do
' period phoneme *.
If A = 1 Then
' add rising inflection
A = 1
mem48 = 1
'goto pos48376;
AddInflection mem48, phase1
End If
'question mark phoneme?
If A = 2 Then
' create falling inflection
mem48 = 255
AddInflection mem48, phase1
End If
' pos47615:
' get the stress amount (more stress = higher pitch)
phase1 = tab47492(stressOutput(Y) + 1)
' get number of frames to write
phase2 = phonemeLengthOutput(Y)
Y = mem56
' copy from the source to the frames list
Do
frequency1(X) = freq1data(Y) ' F1 frequency
frequency2(X) = freq2data(Y) ' F2 frequency
frequency3(X) = freq3data(Y) ' F3 frequency
amplitude1(X) = ampl1data(Y) ' F1 amplitude
amplitude2(X) = ampl2data(Y) ' F2 amplitude
amplitude3(X) = ampl3data(Y) ' F3 amplitude
sampledConsonantFlag(X) = sampledConsonantFlags(Y) ' phoneme data for sampled consonants
pitches(X) = pitch + phase1 ' pitch
X = X + 1
phase2 = phase2 - 1
Loop Until phase2 = 0
mem44 = mem44 + 1
Loop Until mem44 = 0
'// -------------------
'//pos47694:
'// CREATE TRANSITIONS
'{here}
A = 0
mem44 = 0
mem49 = 0 '// mem49 starts at as 0
X = 0
While -1 '//while No. 1
'// get the current and following phoneme
Y = phonemeIndexOutput(X)
A = phonemeIndexOutput(X + 1)
X = X + 1
'// exit loop at end token
If A = 255 Then
Exit While
End If
'//goto pos47970;
'// get the ranking of each phoneme
X = A
mem56 = blendRank(A)
A = blendRank(Y)
'// compare the rank - lower rank value is stronger
If A = mem56 Then
'// same rank, so use out blend lengths from each phoneme
phase1 = outBlendLength(Y)
phase2 = outBlendLength(X)
ElseIf A < mem56 Then
'// first phoneme is stronger, so us it's blend lengths
phase1 = inBlendLength(X)
phase2 = outBlendLength(X)
Else
'// second phoneme is stronger, so use it's blend lengths
'// note the out/in are swapped
phase1 = outBlendLength(Y)
phase2 = inBlendLength(Y)
End If
Y = mem44
A = mem49 + phonemeLengthOutput(mem44)
'// A is mem49 + length
mem49 = A
'// mem49 now holds length + position
A = A + phase2
'//Maybe Problem because of carry flag
'//47776: ADC 42
speedcounter = A
mem47 = 168
phase3 = mem49 - phase1 '// what is mem49
A = phase1 + phase2
'// total transition?
mem38 = A
X = A
X = X - 2
If (X And 128) = 0 Then
Do '//while No. 2
'//pos47810:
'// mem47 is used to index the tables:
'// 168 pitches[]
'// 169 frequency1
'// 170 frequency2
'// 171 frequency3
'// 172 amplitude1
'// 173 amplitude2
'// 174 amplitude3
mem40 = mem38
If mem47 = 168 Then '// pitch
'// unlike the other values, the pitches[] interpolates from
'// the middle of the current phoneme to the middle of the
'// next phoneme
Dim mem36 As _Unsigned Integer, mem37 As _Unsigned Integer
'// half the width of the current phoneme
mem36 = phonemeLengthOutput(mem44) \ 2
'// half the width of the next phoneme
mem37 = phonemeLengthOutput(mem44 + 1) \ 2
'// sum the values
mem40 = mem36 + mem37
'// length of both halves
mem37 = mem37 + mem49
'// center of next phoneme
mem36 = mem49 - mem36
'// center index of current phoneme
' ****************************************************************************************************************************************************************
' *** NOT SURE WHAT THIS IS:
'A = Read(mem47, mem37)
' ****************************************************************************************************************************************************************
'// value at center of next phoneme - end interpolation value
'//A = mem[address];
Y = mem36 '// start index of interpolation
' ****************************************************************************************************************************************************************
' *** NOT SURE WHAT THIS IS:
'mem53 = A - Read(mem47, mem36)
' ****************************************************************************************************************************************************************
'// value to center of current phoneme
Else
'// value to interpolate to
' ****************************************************************************************************************************************************************
' *** NOT SURE WHAT THIS IS:
'A = Read(mem47, speedcounter)
' ****************************************************************************************************************************************************************
'// position to start interpolation from
Y = phase3
'// value to interpolate from
' ****************************************************************************************************************************************************************
' *** NOT SURE WHAT THIS IS:
'mem53 = A - Read(mem47, phase3)
' ****************************************************************************************************************************************************************
End If
'//Code47503(mem40);
'// ML : Code47503 is division with remainder, and mem50 gets the sign
'// calculate change per frame
mem50 = IIf(Sgn(mem53) = -1, 128, 0)
mem51 = Abs(mem53) Mod mem40
mem53 = mem53 \ mem40
'// interpolation range
X = mem40
'// number of frames to interpolate over
Y = phase3
'// starting frame
'// linearly interpolate values
mem56 = 0
'//47907: CLC
'//pos47908:
While -1 '//while No. 3
' ****************************************************************************************************************************************************************
' *** NOT SURE WHAT THIS IS:
'A = Read(mem47, Y) + mem53
' ****************************************************************************************************************************************************************
'//carry alway cleared
mem48 = A
Y = Y + 1
X = X - 1
If X = 0 Then
Exit While
End If
mem56 = mem56 + mem51
If mem56 >= mem40 Then '//???
mem56 = mem56 - mem40
'//carry? is set
'//if ((mem56 & 128)=0)
If (mem50 And 128) = 0 Then
'//47935: BIT 50
'//47937: BMI 47943
If mem48 <> 0 Then
mem48 = mem48 + 1
End If
Else
mem48 = mem48 - 1
End If
End If
'//pos47945:
Write mem47, Y, mem48
Wend '//while No. 3
'//pos47952:
mem47 = mem47 + 1
'//if (mem47 != 175) goto pos47810;
Loop Until mem47 = 175 '//while No. 2
End If
'//pos47963:
mem44 = mem44 + 1
X = mem44
Wend '//while No. 1
'//goto pos47701;
'//pos47970:
' add the length of this phoneme
mem48 = mem49 + phonemeLengthOutput(mem44)
' ASSIGN PITCH CONTOUR
'
' This subtracts the F1 frequency from the pitch to create a
' pitch contour.
' Without this, the output would be at a single
' pitch level (monotone).
' don't adjust pitch if in sing mode
If singmode = 0 Then
' iterate through the buffer
For i = 0 To 255
' subtract half the frequency of the formant 1.
' this adds variety to the voice
pitches(i) = pitches(i) - (frequency1(i) \ 2)
Next i
End If
phase1 = 0
phase2 = 0
phase3 = 0
mem49 = 0
speedcounter = 72 'sam standard speed
' RESCALE AMPLITUDE
'
' Rescale volume from a linear scale to decibels.
'
'amplitude rescaling
For i = 255 To 0 Step -1
amplitude1(i) = amplitudeRescale(amplitude1(i))
amplitude2(i) = amplitudeRescale(amplitude2(i))
amplitude3(i) = amplitudeRescale(amplitude3(i))
Next i
Y = 0
A = pitches(0)
mem44 = A
X = A
mem38 = A - (A \ 4) ' 3/4*A ???
If debug Then
PrintOutput sampledConsonantFlag, frequency1, frequency2, frequency3, amplitude1, amplitude2, amplitude3, pitches
End If
' PROCESS THE FRAMES
'
' In traditional vocal synthesis, the glottal pulse drives filters, which
' are attenuated to the frequencies of the formants.
'
' SAM generates these formants directly with sin and rectangular waves.
' To simulate them being driven by the glottal pulse, the waveforms are
' reset at the beginning of each glottal pulse.
'finally the loop for sound output
'pos48078:
Do
' get the sampled information on the phoneme
A = sampledConsonantFlag(Y)
mem39 = A
' unvoiced sampled phoneme?
A = A And 248
If A <> 0 Then
' render the sample for the phoneme
RenderSample mem66
' skip ahead two in the phoneme buffer
Y = Y + 2
mem48 = mem48 - 2
Else
' simulate the glottal pulse and formants
mem56 = multtable(BINAND(sinus(phase1), amplitude1(Y)))
carry = 0
If (mem56 + multtable(BINAND(sinus(phase2), amplitude2(Y)))) > 255 Then
carry = 1
End If
mem56 = mem56 + multtable(BINAND(sinus(phase2), amplitude2(Y)))
A = mem56 + multtable(BINAND(rectangle(phase3), amplitude3(Y))) + (IIf(carry = 1, 1, 0))
A = ((A + 136) And 255) \ 16 'there must be also a carry
'mem[54296] = A;
' output the accumulated value
' ****************************************************************************************************************************************************************
' *** NOT SURE WHAT THIS IS:
'Output 0, A
' ****************************************************************************************************************************************************************
speedcounter = speedcounter - 1
If speedcounter <> 0 Then
GoTo pos48155
End If
Y = Y + 1 'go to next amplitude
' decrement the frame count
mem48 = mem48 - 1
End If
' if the frame count is zero, exit the loop
If mem48 = 0 Then
Exit Do
End If
speedcounter = speed
pos48155:
' decrement the remaining length of the glottal pulse
mem44 = mem44 - 1
' finished with a glottal pulse?
If mem44 = 0 Then
pos48159:
' fetch the next glottal pulse length
A = pitches(Y)
mem44 = A
A = A - (A \ 4)
mem38 = A
' reset the formant wave generators to keep them in
' sync with the glottal pulse
phase1 = 0
phase2 = 0
phase3 = 0
_CONTINUE
End If
' decrement the count
mem38 = mem38 - 1
' is the count non-zero and the sampled flag is zero?
If (mem38 <> 0) Or (mem39 = 0) Then
' reset the phase of the formants to match the pulse
phase1 = phase1 + frequency1(Y)
phase2 = phase2 + frequency2(Y)
phase3 = phase3 + frequency3(Y)
_CONTINUE
End If
' voiced sampled phonemes interleave the sample with the
' glottal pulse. The sample flag is non-zero, so render
' the sample for the phoneme.
RenderSample mem66
GoTo pos48159
Loop 'while
'#IF 0
' The following code is never reached. It's left over from when
' the voiced sample code was part of this loop, instead of part
' of RenderSample();
'#ENDIF
'pos48315:
' DIM tempA AS Integer
' phase1 = A XOR 255
' Y = mem66
' DO
'pos48321:
'
' mem56 = 8
' A = Read(mem47, Y)
'
'pos48327:
' DO
' '48327: ASL A
' '48328: BCC 48337
' tempA = A
' A = A SHL 1
' IF (tempA AND 128) <> 0 THEN
' X = 26
' ' mem[54296] = X;
' bufferPos = bufferPos + 150
' buffer(bufferPos / 50) = (X AND 15) * 16
' ELSE
' 'mem[54296] = 6;
' X = 6
' bufferPos = bufferPos + 150
' buffer(bufferPos / 50) = (X AND 15) * 16
' END IF
'
' FOR X = wait2 TO 1 STEP -1
' 'wait
' NEXT X
' mem56 = mem56 - 1
' LOOP WHILE mem56 <> 0
'
' Y = Y + 1
' phase1 = phase1 + 1
' LOOP WHILE phase1 <> 0
' ' IF phase1 <> 0 GOTO pos48321
' A = 1
' mem44 = 1
' mem66 = Y
' Y = mem49
' RETURN
'#IF 0
'END IF
End Sub ' Render
' SUBROUTINES and FUNCTIONS
Sub AddInflection (mem48 As _Byte, phase1 As _Byte)
' store the location of the punctuation
mem49 = X
A = X
Atemp = A
' backup 30 frames
A = A - 30
' if index is before buffer, point to start of buffer
If Atemp <= 30 Then
A = 0
End If
X = A
' FIXME: Explain this fix better, it's not obvious
' ML : A =, fixes a problem with invalid pitch with '.'
Do While pitches(X) = 127
X = X + 1
Loop
' add the inflection direction
A = A + mem48
phase1 = A
' set the inflection
pitches(X) = A
' increment the position
X = X + 1
' exit if the punctuation has been reached
If X = mem49 Then
Exit Sub
End If
'goto pos47615;
If pitches(X) = 255 Then
GoTo pos48406
End If
A = phase1
GoTo pos48398
pos48406:
pos48398:
'48398: CLC (Carry flag is handled implicitly in QB64 addition)
'48399: ADC 48
' QB64 doesn't have direct carry flag manipulation like assembly,
' so addition handles carries naturally.
End Sub ' AddInflection
Sub SetMouthThroat (mouth As _Byte, throat As _Byte)
Dim initialFrequency As _Byte, newFrequency As _Byte
Dim posV As _Byte ' *** original variable name "pos" is reserved in QB64
' mouth formants (F1) 5..29 (Data already initialized)
' throat formants (F2) 5..29 (Data already initialized)
' formant 1 frequencies (mouth) 48..53 (Data already initialized)
' formant 2 frequencies (throat) 48..53 (Data already initialized)
posV = 5
'pos38942:
' recalculate formant frequencies 5..29 for the mouth (F1) and throat (F2)
Do While posV <> 30
' recalculate mouth frequency
initialFrequency = mouthFormants5_29(posV)
If initialFrequency <> 0 Then
newFrequency = trans(mouth, initialFrequency)
End If
freq1data(posV) = newFrequency
' recalculate throat frequency
initialFrequency = throatFormants5_29(posV)
If initialFrequency <> 0 Then
newFrequency = trans(throat, initialFrequency)
End If
freq2data(posV) = newFrequency
posV = posV + 1
Loop
'pos39059:
' recalculate formant frequencies 48..53
posV = 48
Y = 0
Do While posV <> 54
' recalculate F1 (mouth formant)
initialFrequency = mouthFormants48_53(Y)
newFrequency = trans(mouth, initialFrequency)
freq1data(posV) = newFrequency
' recalculate F2 (throat formant)
initialFrequency = throatFormants48_53(Y)
newFrequency = trans(throat, initialFrequency)
freq2data(posV) = newFrequency
Y = Y + 1
posV = posV + 1
Loop
End Sub ' SetMouthThroat
'return = (mem39212*mem39213) >> 1
Function trans% (mem39212 As _Byte, mem39213 As _Byte)
'pos39008:
Dim carry As _Byte
Dim temp As Integer ' Using INTEGER for intermediate calculations to avoid overflow
Dim mem39214 As _Byte, mem39215 As _Byte
A = 0
mem39215 = 0
mem39214 = 0
X = 8
Do
carry = mem39212 And 1
mem39212 = mem39212 \ 2 ' Integer division for right shift
If carry <> 0 Then
carry = 0
A = mem39215
temp = A + mem39213
A = A + mem39213
If temp > 255 Then
carry = 1
End If
mem39215 = A
End If
temp = mem39215 And 1
mem39215 = (mem39215 \ 2) Or (carry * 128)
carry = temp
X = X - 1
Loop Until X = 0
temp = mem39214 And 128
mem39214 = (mem39214 * 2) Or carry
carry = temp
temp = mem39215 And 128
mem39215 = (mem39215 * 2) Or carry
carry = temp
trans% = mem39215
End Function ' trans%
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' END render.c
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' BEGIN debug.c
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' Key Changes Made:
' Header Guards: #ifndef, #define, #endif replaced with QB64's '$IF NOT DEFINED, '$DEFINE, '$ENDIF.
' Includes: #include <stdio.h> is implicit in QB64. #include "debug.h" is handled with '$INCLUDE.
' Data Types: int32_t becomes INTEGER. uint8_t becomes UBYTE.
' Arrays: C-style pointer arithmetic is replaced with QB64 array access. Important: I've assumed signInputTable1, signInputTable2, and GetRuleByte are defined elsewhere. You'll need to provide QB64 equivalents if they are not. UBYTE arrays in QB64 are 0-based.
' printf: Replaced with QB64's PRINT and PRINT USING for formatted output.
' Character Handling: Character literals are converted using CHR$() and ASC().
' Bitwise Operations: QB64 uses the same bitwise operators as C (AND).
' External Declarations: extern is replaced with DECLARE SUB or DECLARE FUNCTION. Important: You MUST provide the actual implementations or declarations for signInputTable1, signInputTable2, and GetRuleByte.
' Comments: C-style comments (//) are replaced with QB64's single quote (').
' To use this in QB64:
' Save the code as debug.bas.
' Make sure you have QB64 installed.
' Open debug.bas in QB64.
' Crucially: You will need to provide the QB64 code for signInputTable1, signInputTable2, and GetRuleByte or the code will not compile/run correctly. This might involve creating DIM statements and populating the arrays, and creating a QB64 FUNCTION for GetRuleByte.
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
'extern uint8_t signInputTable1[]; => Needs to be declared if used in QB64, assuming from another module
'extern uint8_t signInputTable2[]; => Needs to be declared if used in QB64, assuming from another module
' These are problematic - QB64 doesn't directly support external arrays like C. For this translation,
' I'll assume they are defined elsewhere and accessible. If not, you'd need to create them in QB64.
' Since I don't have the definitions, I'll comment them out.
' TODO: Add actual DIM statements if these arrays are needed in this module
SUB PrintPhonemes (phonemeindex AS UBYTE, phonemeLength AS UBYTE, stress AS UBYTE)
DIM i AS INTEGER
i = 0
PRINT "==========================================="
PRINT "Internal Phoneme presentation:"
PRINT
PRINT " idx phoneme length stress"
PRINT "------------------------------"
DO WHILE (phonemeindex(i) <> 255) AND (i < 255) 'UBYTE arrays are indexed from 0 in QB64
IF phonemeindex(i) < 81 THEN
' Assuming signInputTable1 and signInputTable2 are available
' and are also UBYTE arrays
PRINT USING " ### \ \ ### #"; i; CHR$(signInputTable1(phonemeindex(i))); CHR$(signInputTable2(phonemeindex(i))); phonemeLength(i); stress(i) 'Format output
ELSE
PRINT USING " ### ?? ### #"; phonemeindex(i); phonemeLength(i); stress(i)
END IF
i = i + 1
LOOP
PRINT "==========================================="
PRINT
END SUB ' PrintPhonemes
SUB PrintOutput (flag AS UBYTE, f1 AS UBYTE, f2 AS UBYTE, f3 AS UBYTE, a1 AS UBYTE, a2 AS UBYTE, a3 AS UBYTE, p AS UBYTE)
PRINT "==========================================="
PRINT "Final data for speech output:"
PRINT
PRINT " flags ampl1 freq1 ampl2 freq2 ampl3 freq3 pitch"
PRINT "------------------------------------------------"
DIM i AS INTEGER
i = 0
DO WHILE i < 255
PRINT USING " ##### ##### ##### ##### ##### ##### ##### #####"; flag(i); a1(i); f1(i); a2(i); f2(i); a3(i); f3(i); p(i)
i = i + 1
LOOP
PRINT "==========================================="
END SUB ' PrintOutput
'extern uint8_t GetRuleByte(uint16_t mem62, uint8_t Y); => Needs declaration if used
' Assuming GetRuleByte is in another module.
' TODO: Add actual DECLARE FUNCTION if this function is needed in this module
SUB PrintRule (offset AS INTEGER)
DIM i AS INTEGER
DIM A AS UBYTE
i = 1
PRINT "Applying rule: ";
DO
' Assuming GetRuleByte returns a UBYTE
A = GetRuleByte(offset, i) 'Need to ensure GetRuleByte is available
IF (A AND 127) = ASC("=") THEN 'Bitwise AND and character comparison
PRINT " -> ";
ELSE
PRINT CHR$(A AND 127);
END IF
i = i + 1
LOOP WHILE (A AND 128) = 0
PRINT
END SUB ' PrintRule
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' END debug.c
' ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
![[Image: giphy.gif]](https://media1.giphy.com/media/v1.Y2lkPTc5MGI3NjExczNucmpsMGs1dW1rbHg0eGVyZGt5dDl6d21kZmJ3Y3hocTduYTJ1ZiZlcD12MV9pbnRlcm5hbF9naWZfYnlfaWQmY3Q9Zw/Dxb9vPUbXyYX6/giphy.gif)