diff --git a/.gitignore b/.gitignore index 9db2d5c..10e7f57 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,7 @@ -*.s +pcomp/*.s +progs/*.s +tests/*.s +examples/*.s *.o *.exe *.bin @@ -20,8 +23,10 @@ graph2.pas chase.pas !runtime.s **/tridoracpu.*/ -rtl/arty-a7/mig_dram_0/_tmp -rtl/arty-a7/mig_dram_0/mig_dram_0 +rtl/arty-a7/mig_dram_0/_tmp/* +rtl/arty-a7/mig_dram_0/doc/* +rtl/arty-a7/mig_dram_0/mig_dram_0* rtl/arty-a7/mig_dram_0/xil_txt.* rtl/arty-a7/mig_dram_0/*.veo rtl/arty-a7/mig_dram_0/*.tcl +rtl/arty-a7/mig_dram_0/*.xml diff --git a/lib/corelib.s b/lib/corelib.s new file mode 100644 index 0000000..57f35a8 --- /dev/null +++ b/lib/corelib.s @@ -0,0 +1,1501 @@ +; Copyright 2021-2024 Sebastian Lederer. See the file LICENSE.md for details + + .EQU CR 13 + .EQU LF 10 + .EQU UART_REG 2048 + .EQU IRQC_REG 2432 + + .EQU PROG_START 24576 + .EQU FP_START 24060 + .EQU RP_START 24064 +NEWLINE: + LOADC CR + LOADCP CONOUT + CALL + LOADC LF + LOADCP CONOUT + CALL + RET + +; print string of byte characters +; takes pointer to string on eval stack +PRINTLINE: + DUP ; duplicate address as arg to printchar + LOADCP _PRINTCHAR + CALL + CBRANCH.Z PRINTLINE_EXIT ; if char is zero, exit + INC 1 ; increment address + BRANCH PRINTLINE +PRINTLINE_EXIT: + DROP ; remove address from stack + RET + +; print a single character +; takes a byte pointer on eval stack +; returns character on eval stack +_PRINTCHAR: + LOADI.S1.X2Y ; load word, keep address on stack + BSEL ; select byte of a word via address + DUP ; check for null byte + CBRANCH.Z _PRINTCHAR_XT + DUP + LOADCP CONOUT + CALL +_PRINTCHAR_XT: + RET + +; print a 32-bit hexadecimal number +; takes the value on the stack +PRINTHEXW: + BROT + DUP + LOADCP _PRINTHEXB + CALL + BROT + DUP + LOADCP _PRINTHEXB + CALL + BROT + DUP + LOADCP _PRINTHEXB + CALL + BROT + LOADCP _PRINTHEXB + CALL + RET + +_PRINTHEXB: + DUP + SHR + SHR + SHR + SHR + LOADCP _PRINTNIBBLE + CALL + LOADCP _PRINTNIBBLE + CALL + RET + +_PRINTNIBBLE: + LOADC 15 ; isolate nibble + AND + LOADC 10 + CMPU.S0 GE ; nibble >= 10 ? + CBRANCH.NZ _PRINTNIBBLE_1 ; then print a-f + LOADC '0' ; else print 0-9 + BRANCH _PRINTNIBBLE_2 +_PRINTNIBBLE_1: + LOADC 55 ; 55 + 10 == 'A' +_PRINTNIBBLE_2: + ADD + LOADCP CONOUT + CALL + RET + +_MUL10: + SHL ; x * 2 + DUP + SHL 2 ; x * 8 + ADD ; x * 2 + x * 8 = x * 10 + RET + +; shift left multiple times +; parameters: value, count +; returns: shifted value +_SHLM: + DUP + CBRANCH.Z _SHLM_X ; if count is zero, exit + LOADC 8 + CMPU.S0 LT ; count is less than 8? + CBRANCH _SHLM_1 + ; if >= 8, continue here + DEC 8 ; decrement counter by 8 + SWAP ; swap counter and value + BROT ; byte rotate value + LOADCP $FFFFFF00 ; and mask the lowest 8 bits + AND ; to get a shift left by 8 + SWAP ; swap back counter and value + BRANCH _SHLM +_SHLM_1: + DEC 1 + SWAP + SHL + SWAP + BRANCH _SHLM +_SHLM_X: + DROP ; drop counter + RET + +; shift right multiple times +; parameters: value, count +; returns: shifted value +_SHRM: + DUP + CBRANCH.Z _SHRM_X ; if count is zero, exit + DEC 1 + SWAP + SHR + SWAP + BRANCH _SHRM +_SHRM_X: + DROP ; remove counter + RET + + +; --- print signed integer as decimal +; parameter: value +PRINTDEC: + DUP + LOADC 0 + CMP GE + CBRANCH PRINTDECU + LOADC '-' + LOADCP CONOUT + CALL + NOT + INC 1 ; negate value + ; fallthrough to PRINTDECU + +; print unsigned integer as decimal +; parameter: value +; local vars: +; 0: current value +; 4: pointer to digit value table +; 8: digit counter +; 12: flag for leading zeroes +PRINTDECU: + FPADJ -16 + STORE 0 + LOADCP CONVDEC_TAB + STORE 4 + LOADC 0 + STORE 12 +PRDEC_NEXTDIGIT: + LOADC 0 + STORE 8 + LOAD 4 + LOADI ; load via pointer + CBRANCH.Z PRDECU_DONE ; if digit value is 0, we are done +DIGIT_LOOP: + LOAD 4 + LOADI + LOAD 0 + CMPU GT + CBRANCH DIGIT_DONE + LOAD 0 + LOAD 4 + LOADI + SUB + STORE 0 + LOAD 8 + INC 1 + STORE 8 + BRANCH DIGIT_LOOP +DIGIT_DONE: + LOAD 8 + CBRANCH.NZ DIGIT_OUT ; if digit is not 0, print it + LOAD 12 ; is it a leading zero, ignore it + CBRANCH.Z DIGIT_NEXT +DIGIT_OUT: + LOADC 1 ; set leading zero flag + STORE 12 + LOAD 8 + LOADCP _PRINTDIGIT + CALL +DIGIT_NEXT: + LOAD 4 ; increment digit value pointer + INC 4 + STORE 4 + BRANCH PRDEC_NEXTDIGIT +PRDECU_DONE: + LOAD 0 + LOADCP _PRINTDIGIT + CALL + FPADJ 16 + RET + +_PRINTDIGIT: + LOADC '0' + ADD + LOADCP CONOUT + CALL + RET +CONVDEC_TAB: + .WORD 1000000000,100000000,10000000,1000000,100000,10000,1000,100,10,0 + +; ------ read a 8-digit hexadecimal number from the console +; stores variables on the user stack, so the FP register must be +; inizialized. +; returns two values on the eval stack: +; - return code (topmost) +; 0 - no valid number +; 1 - valid number +; 2 - valid number and enter was pressed +; - result value +_READHEX: + FPADJ -8 + LOADC 0 ; current value + STORE 0 + LOADC 8 ; max number of digits + STORE 4 ; remaining digits counter +_READHEX_1: + LOADCP CONIN + CALL + LOADC CR ; RETURN pressed? + CMP.S0 EQ + CBRANCH _READHEX_RT + DUP + LOADCP CONOUT ; echo character + CALL + LOADCP _CONVHEXDIGIT + CALL + LOADC -1 + CMP.S0 EQ ; invalid character? + CBRANCH.NZ _READHEX_XT + LOAD 0 + SHL 1 ; shift previous nibble + SHL 1 + SHL 1 + SHL 1 + OR ; combine with last digit + STORE 0 + LOAD 4 + DEC 1 + DUP + STORE 4 + CBRANCH.NZ _READHEX_1 + BRANCH _READHEX_XT1 +_READHEX_RT: ; if no digits were entered, set return code + DROP ; drop read character + LOAD 4 ;remaining digits counter + LOADC 8 + CMP NE + CBRANCH _READHEX_RT2 + LOADC 0 ; no valid input + BRANCH _READHEX_XT3 +_READHEX_RT2: + LOADC 2 ; valid input and return pressed + BRANCH _READHEX_XT3 +_READHEX_XT: + DROP + LOAD 4 + LOADC 8 + CMP EQ ; if no digits were entered + CBRANCH _READHEX_XT0 +_READHEX_XT1: + LOADC 1 ; valid input flag + BRANCH _READHEX_XT3 +_READHEX_XT0: + LOADC 0 +_READHEX_XT3: + LOAD 0 + SWAP + FPADJ 8 + RET + +; ------ convert character on the eval stack to upper case +UPCASE: + LOADC 'a' + CMP.S0 LT + CBRANCH UPCASE_XT + LOADC 'z' + CMP.S0 GT + CBRANCH UPCASE_XT + LOADC 32 + SUB +UPCASE_XT: + RET + +; ------ convert hexadecimal digit to integer +; ------ takes an ascii character as parameter on the eval stack +; ------ returns an integer value from 0-15 on the eval stack, +; ------ or -1 if the character was not a valid hexadecimal digit +_CONVHEXDIGIT: + LOADCP UPCASE + CALL + LOADC '0' + CMP.S0 LT ; character < '0'? + CBRANCH.NZ _CONVHEXDIGIT_ERR + LOADC '9' + CMP.S0 GT ; character > '9'? + CBRANCH.NZ _CONVHEXDIGIT_ISALPHA + LOADC '0' ; character is between '0' and '9', subtract '0' + SUB + BRANCH _CONVHEXDIGIT_NBL +_CONVHEXDIGIT_ISALPHA: + LOADC 'A' + CMP.S0 LT ; character < 'A'? + CBRANCH.NZ _CONVHEXDIGIT_ERR + LOADC 'F' + CMP.S0 GT ; character > 'F'? + CBRANCH.NZ _CONVHEXDIGIT_ERR + LOADC 55 ; character is between 'A' and 'F', subtract ('A' - 10) + SUB +_CONVHEXDIGIT_NBL: + RET +_CONVHEXDIGIT_ERR: + DROP ; remove character from stack + LOADC -1 ; error + RET + +; --------- output a character on serial console +; --------- takes a character (as the lsb of a word) on the eval stack +CONOUT: + LOADC UART_REG ; address of UART register + LOADI ; load status + LOADC 256 ; check bit 8 (tx_busy) + AND + CBRANCH.NZ CONOUT ; loop if bit 8 is not zero + + ; transmitter is idle now, write character + LOADC 1024 ; TX enable bit + OR + LOADC UART_REG ; I/O address + SWAP ; swap addr and value as args for STOREI + STOREI + DROP + RET + +; ---------- check if a character has been received +; returns: 1 if a character has been received, 0 otherwise +CONAVAIL: + LOADC 0 ; preliminary result + LOADC UART_REG ; address of UART register + LOADI ; load status + LOADC 512 ; check bit 9 (rx_avail) + AND + CBRANCH.Z CONAVAIL_0 ; if bit is zero, we are done + INC 1 ; add 1 to preliminary result +CONAVAIL_0: + RET + +; ---------- wait until a character is received and return it on eval stack +CONIN: + LOADC UART_REG ; address of UART register + LOADI ; load status + LOADC 512 ; check bit 9 (rx_avail) + AND + CBRANCH.Z CONIN ; loop if bit 9 is zero + LOADC UART_REG + LOADI ; read register again + LOADC 255 ; mask status bits + AND + LOADC UART_REG ; I/O address + LOADC 512 ; set bit 9 (rx_clear) + STOREI ; write register + DROP + RET + +; return absolute value +; parameters: value +; returns: abs(value) +ABS: + LOADC 0 + CMP.S0 GE + CBRANCH ABS_XT + DEC 1 ; negate + NOT +ABS_XT: + RET + +; signed multiplication +_MUL: + ; fallthrough to MULU + +; unsigned multiplication: x * y +; parameters: [x, y] +; returns: x * y +_MULU: + FPADJ -16 + STORE 0 ; x + STORE 4 ; y + LOADC 32 + STORE 8 ; bit count + LOADC 0 + STORE 12 ; result +MULU_LOOP: + LOAD 8 + CBRANCH.Z MULU_XT ; if count is zero, exit + LOAD 0 + LOADC 1 + AND.S0 ; get bit 0 + CBRANCH.Z MULU_1 ; if bit 0 is zero, next binary digit + LOAD 12 + LOAD 4 + ADD ; result = result + y + STORE 12 +MULU_1: + SHR ; x = x >> 1 + STORE 0 + LOAD 4 + SHL ; y = y << 1 + STORE 4 + LOAD 8 + DEC 1 ; count = count -1 + STORE 8 + BRANCH MULU_LOOP +MULU_XT: + LOAD 12 + FPADJ 16 + RET + +; signed integer division +; parameters: [x,y] +; result: x/y +_DIV: + FPADJ -4 + LOADC 0 + STORE 0 ; clear negate flag + DUP + LOADC 0 + CMP GE ; is y positive? + CBRANCH DIV_ISPOS + ; y is negative + NOT + INC 1 ; negate y + LOADC -1 + STORE 0 ; set negate flag +DIV_ISPOS: + SWAP ; swap x and y + DUP + LOADC 0 + CMP GE ; is x positive? + CBRANCH DIV_ISPOS2 + ; x is negative + NOT + INC 1 ; negate x + LOAD 0 + NOT ; invert negate flag + STORE 0 +DIV_ISPOS2: + SWAP ; swap back y and x + LOADCP _DIVMODU + CALL + DROP ; throw away remainder + LOAD 0 + CBRANCH.Z DIV_XT ; negate flag set? + NOT + INC 1 ; negate value +DIV_XT: + FPADJ 4 + RET + +; signed integer modulo +; the result is negative if x is negative. +; the sign of y is ignored. +; parameters: [x,y] +; returns: remainder of x/y +_MOD: + FPADJ -4 + LOADC 0 + STORE 0 ; clear negate flag + DUP + LOADC 0 + CMP GE ; is y positive? + CBRANCH MOD_ISPOS + ; y is negative + NOT + INC 1 ; negate y +MOD_ISPOS: + SWAP ; swap x and y + DUP + LOADC 0 + CMP GE ; is x positive? + CBRANCH MOD_ISPOS2 + ; x is negative + NOT + INC 1 ; negate x + LOAD 0 + NOT ; invert negate flag + STORE 0 +MOD_ISPOS2: + SWAP ; swap back y and x + LOADCP _DIVMODU + CALL + NIP ; throw away quotient + LOAD 0 + CBRANCH.Z MOD_XT ; negate flag set? + NOT + INC 1 ; negate value +MOD_XT: + + FPADJ 4 + RET + +; unsigned integer division +; parameters: [x,y] +; result: x/y +_DIVU: + LOADCP _DIVMODU ; just call DIVMODU and throw away the remainder + CALL + DROP + RET + +; unsigned integer division with remainder +; parameters: [x,y] +; result: [ quotient, remainder ] +_DIVMODU: + FPADJ -20 + STORE 0 ; y + STORE 4 ; x + LOADC 32 + STORE 8 ; bit count + LOADC 0 + STORE 12 ; tmp value + LOADC 0 + STORE 16 ; result +DIVU_LOOP: + LOAD 8 + CBRANCH.Z DIVU_END ; if count is zero, exit + LOAD 16 + SHL ; result = result << 1 + STORE 16 + LOAD 12 + SHL ; tmp << 1 + LOAD 4 + LOADCP $80000000 ; msb of x + AND + CBRANCH.Z DIVU_1 + INC 1 ; tmp[0] is 0, so +1 means tmp[0] = 1 +DIVU_1: + DUP + STORE 12 ; tmp = tmp << 1 | msb + LOAD 0 + CMPU GE ; tmp >= y? + CBRANCH.Z DIVU_2 + LOAD 16 + INC 1 ; result = result | 1 + STORE 16 + LOAD 12 + LOAD 0 + SUB + STORE 12 ; tmp = tmp - y +DIVU_2: + LOAD 4 + SHL + STORE 4 + LOAD 8 + DEC 1 + STORE 8 + BRANCH DIVU_LOOP +DIVU_END: + LOAD 16 ; result (quotient) + LOAD 12 ; remainder + FPADJ 20 + RET + + .CPOOL + +; wait approx. 1 millisecond +; +; 83.333 MHz Clock, three instructions a 4 cycles +; 83333 / 12 = 6944.4166 +; works only if executed without wait states (i.e. +; from BRAM/SRAM) +WAIT1MSEC: + LOADCP 6944 +WAIT1LOOP: + DEC 1 + DUP + CBRANCH.NZ WAIT1LOOP + DROP + RET + +; clear a memory block +; parameters: addr, length in bytes +; length must be multiple of wordsize. +; if it is not, the last (partial) word is not cleared. +_CLEARMEM: + SHR + SHR ; calculate length in words + +CLEARMEM_L: + DUP + CBRANCH.Z CLEARMEM_X ; if zero words to do, exit + SWAP ; swap counter and addr + LOADC 0 + STOREI 4 ; store with post-increment + SWAP ; swap counter and addr back + DEC 1 ; decrement counter + BRANCH CLEARMEM_L +CLEARMEM_X: + DROP + DROP + RET + +; copy a number of words from source to destination +; parameters: [ dest, source, count ] +; source and destination may not overlap + .EQU COPYWORDS_COUNT 0 + .EQU COPYWORDS_SRC 4 + .EQU COPYWORDS_DEST 8 +_COPYWORDS: + FPADJ -12 + STORE COPYWORDS_COUNT ; store args to local vars + STORE COPYWORDS_SRC + STORE COPYWORDS_DEST + LOAD COPYWORDS_COUNT ; we will keep count on the stack inside the loop +COPYWORDS_L0: + DUP ; count is on tos, duplicate it + CBRANCH.Z COPYWORDS_XT ; check if count is zero + DEC 1 ; if not, decrement + LOAD COPYWORDS_DEST ; load dest addr for STOREI below + LOAD COPYWORDS_SRC ; load src addr + INC.S1.X2Y 4 ; increment by 4 and put as new value on tos + STORE COPYWORDS_SRC ; store again, old addr is now on tos + LOADI ; load value by old addr + STOREI 4 ; store value and post-increment + STORE COPYWORDS_DEST ; store post-incremented addr + BRANCH COPYWORDS_L0 +COPYWORDS_XT: + DROP ; drop count value + FPADJ 12 + RET + +; compare a number of words +; parameters: [ dest, source, count ] +; returns: 1 if all words are equal, 0 otherwise + .EQU CMPWORDS_COUNT 0 + .EQU CMPWORDS_SRC 4 + .EQU CMPWORDS_DEST 8 +_CMPWORDS: + FPADJ -12 + STORE CMPWORDS_COUNT ; store args to local vars + STORE CMPWORDS_SRC + STORE CMPWORDS_DEST + LOAD CMPWORDS_COUNT +CMPWORDS_L0: + DUP ; count is on tos, duplicate it + CBRANCH.Z CMPWORDS_XT ; check if count is zero + DEC 1 ; if not, decrement + LOAD CMPWORDS_SRC ; load src addr + INC.S1.X2Y 4 ; increment by 4 and put as new value on tos + STORE CMPWORDS_SRC ; store again, old addr is now on tos + LOADI ; load src value + LOAD CMPWORDS_DEST ; load dest addr + INC.S1.X2Y 4 ; increment by 4 and put as new value on tos + STORE CMPWORDS_DEST ; store again, old addr is now on tos + LOADI ; load dest value + CMPU EQ + CBRANCH CMPWORDS_L0 ; if words are equal, continue loop + DROP ; drop count value + LOADC 0 ; load exit code 0 + BRANCH CMPWORDS_XT2 +CMPWORDS_XT: + DROP ; drop count value + LOADC 1 ; load exit code 1 +CMPWORDS_XT2: + FPADJ 12 + RET + + .CPOOL +; --------- Graphics Library --------------- + ; vga controller registers + .EQU FB_RA $900 + .EQU FB_WA $901 + .EQU FB_IO $902 + .EQU FB_PS $903 + .EQU FB_PD $904 + .EQU FB_CTL $905 +; set a pixel in fb memory +; parameters: x,y - coordinates +PUTPIXEL_1BPP: + ; calculate vmem address: + OVER ; duplicate x + ; divide x by 32 + SHR + SHR + SHR + SHR + SHR + SWAP + ; multiply y by words per line + SHL 2 + SHL 2 + SHL + + ADD ; add results together for vmem addr + + DUP + LOADCP FB_WA + SWAP + STOREI ; store to framebuffer write addr register + DROP + LOADCP FB_RA ; and to framebuffer read addr register + SWAP + STOREI + DROP + + ; x is now at top of stack + ; get bit value from x modulo 32 + LOADC 31 + AND + SHL 2 ; (x & 31) * 4 = offset into table + LOADCP INT_TO_PIX_TABLE + ADD + LOADI + + LOADCP FB_IO + ; read old vmem value + LOADCP FB_IO + LOADI + ; or in new bit + OR + ; write new value + STOREI + DROP + + RET + +INT_TO_PIX_TABLE: + .WORD %10000000_00000000_00000000_00000000 + .WORD %01000000_00000000_00000000_00000000 + .WORD %00100000_00000000_00000000_00000000 + .WORD %00010000_00000000_00000000_00000000 + .WORD %00001000_00000000_00000000_00000000 + .WORD %00000100_00000000_00000000_00000000 + .WORD %00000010_00000000_00000000_00000000 + .WORD %00000001_00000000_00000000_00000000 + .WORD %00000000_10000000_00000000_00000000 + .WORD %00000000_01000000_00000000_00000000 + .WORD %00000000_00100000_00000000_00000000 + .WORD %00000000_00010000_00000000_00000000 + .WORD %00000000_00001000_00000000_00000000 + .WORD %00000000_00000100_00000000_00000000 + .WORD %00000000_00000010_00000000_00000000 + .WORD %00000000_00000001_00000000_00000000 + .WORD %00000000_00000000_10000000_00000000 + .WORD %00000000_00000000_01000000_00000000 + .WORD %00000000_00000000_00100000_00000000 + .WORD %00000000_00000000_00010000_00000000 + .WORD %00000000_00000000_00001000_00000000 + .WORD %00000000_00000000_00000100_00000000 + .WORD %00000000_00000000_00000010_00000000 + .WORD %00000000_00000000_00000001_00000000 + .WORD %00000000_00000000_00000000_10000000 + .WORD %00000000_00000000_00000000_01000000 + .WORD %00000000_00000000_00000000_00100000 + .WORD %00000000_00000000_00000000_00010000 + .WORD %00000000_00000000_00000000_00001000 + .WORD %00000000_00000000_00000000_00000100 + .WORD %00000000_00000000_00000000_00000010 + .WORD %00000000_00000000_00000000_00000001 + +PUTMPIXEL: + LOADC 1 +; set a pixel in fb memory +; parameters: x,y,color - coordinates, color value (0-15) +PUTPIXEL: +PUTPIXEL_4BPP: + .EQU PUTPIXEL_X 0 + .EQU PUTPIXEL_Y 4 + .EQU PUTPIXEL_COLOR 8 + .EQU PUTPIXEL_PIXPOS 12 + .EQU PUTPIXEL_FS 16 + + FPADJ -PUTPIXEL_FS + + STORE PUTPIXEL_COLOR + STORE PUTPIXEL_Y + STORE PUTPIXEL_X + + + ; calculate vmem address: (x / 8) + (y * 80) + LOAD PUTPIXEL_X + ; divide x by 8 + SHR + SHR + SHR + + LOAD PUTPIXEL_Y + ; multiply y by words per line + SHL 2 + SHL 2 ; * 16 + DUP + SHL 2; * 64 + ADD ; x*16 + x*64 + + ADD ; add results together for vmem addr + + LOADCP FB_WA + OVER + STOREI ; store to framebuffer write addr register + DROP + LOADCP FB_RA ; and to framebuffer read addr register + SWAP ; swap addr and value for STOREI + STOREI + DROP + + LOAD PUTPIXEL_X + ; |0000.0000|0000.0000|0000.0000|0000.1111| + LOADC 7 + AND ; calculate pixel position in word + LOADC 7 + SWAP + SUB ; pixpos = 7 - (x & 7) + STORE PUTPIXEL_PIXPOS + + LOAD PUTPIXEL_COLOR + LOAD PUTPIXEL_PIXPOS + SHR ; rcount = pixpos / 2 +ROTLOOP_: + DUP ; exit loop if rcount is 0 + CBRANCH.Z ROTLOOP_END + SWAP ; pixel value is now on top of stack + BROT ; value = value << 8 + SWAP ; rcount is now on top of stack + DEC 1 ; rcount = rcount - 1 + BRANCH ROTLOOP_ +ROTLOOP_END: + DROP ; drop rcount + ; shifted pixel value is now at top of stack + LOAD PUTPIXEL_PIXPOS + LOADC 1 + AND + CBRANCH.Z EVEN_PIXPOS + SHL 2 ; if pixpos is odd, shift by 4 bits + SHL 2 +EVEN_PIXPOS: + LOAD PUTPIXEL_X + ; get bit value from x modulo 8 + LOADC 7 + AND + SHL 2 ; (x & 7) * 4 = offset into table + LOADCP INT_TO_MASK_TABLE + ADD + LOADI + + ; read old vmem value + LOADCP FB_IO + LOADI + ; mask bits + AND + ; or in shifted pixel value + OR + + ; write new value + LOADCP FB_IO + SWAP + STOREI + DROP + + FPADJ PUTPIXEL_FS + RET + + .CPOOL + +INT_TO_MASK_TABLE: + .WORD %00001111_11111111_11111111_11111111 + .WORD %11110000_11111111_11111111_11111111 + .WORD %11111111_00001111_11111111_11111111 + .WORD %11111111_11110000_11111111_11111111 + .WORD %11111111_11111111_00001111_11111111 + .WORD %11111111_11111111_11110000_11111111 + .WORD %11111111_11111111_11111111_00001111 + .WORD %11111111_11111111_11111111_11110000 + +; draw a line between two points +; parameters: x0, y0, x1, y1, color + .EQU DL_X0 0 + .EQU DL_Y0 4 + .EQU DL_X1 8 + .EQU DL_Y1 12 + .EQU DL_DX 16 + .EQU DL_DY 20 + .EQU DL_ERR 24 + .EQU DL_E2 28 + .EQU DL_SX 32 + .EQU DL_SY 36 + .EQU DL_COL 40 + .EQU STACKFRAME_SIZE 44 + +DRAWLINE_M: + LOADC 1 +DRAWLINE: + FPADJ -STACKFRAME_SIZE + + STORE DL_COL ; store args + STORE DL_Y1 + STORE DL_X1 + STORE DL_Y0 + STORE DL_X0 + + LOAD DL_X1 ; dx = abs(x1-x0) + LOAD DL_X0 + SUB + LOADCP ABS + CALL + STORE DL_DX + + LOAD DL_Y1 ; dy = -abs(y1-y0) + LOAD DL_Y0 + SUB + LOADCP ABS + CALL + DEC 1 + NOT + STORE DL_DY + + LOAD DL_X0 ; sx = (x0 dy + LOAD DL_DY + CMP GT + CBRANCH.Z DL_SKIP1 + + LOAD DL_ERR ; err += dy + LOAD DL_DY + ADD + STORE DL_ERR + + LOAD DL_X0 ; x0 += sx + LOAD DL_SX + ADD + STORE DL_X0 + +DL_SKIP1: + LOAD DL_E2 ; if e2 < dx + LOAD DL_DX + CMP LT + CBRANCH.Z DL_SKIP2 + + LOAD DL_ERR ; err += dx + LOAD DL_DX + ADD + STORE DL_ERR + + LOAD DL_Y0 ; y0 += sy + LOAD DL_SY + ADD + STORE DL_Y0 + +DL_SKIP2: + BRANCH DL_LOOP +DL_END: + FPADJ STACKFRAME_SIZE + RET + +; initialize the palette registers +INITPALETTE: + LOADCP DEFAULT_PALETTE ; load pointer to color table + LOADC 0 ; load counter +INITPAL_0: + DUP + LOADC FB_PS ; store counter to palette select register + SWAP ; swap addr and value for STOREI + STOREI + DROP + + SWAP ; pointer on top of stack + DUP + LOADI ; load color value + LOADC FB_PD + SWAP ; swap addr and value for STOREI + STOREI ; store to palette data register + DROP + INC 4 ; increment pointer + + SWAP ; counter on top of stack + DUP + LOADC 15 + CMPU EQ + CBRANCH INITPAL_X ; exit if counter is 15 + + INC 1 ; increment counter + BRANCH INITPAL_0 + +INITPAL_X: + DROP ; remove counter and pointer + DROP + RET + +; set a palette register +; parameters [ palette slot nr, color value ] +SETPALETTE: + SWAP ; slot nr to top + LOADC FB_PS ; load address of palette select register + SWAP ; swap addr and slot nr for STOREI + STOREI + DROP ; remove addr from STOREI + ; left on stack now: color value + LOADC FB_PD ; load address of palette data register + SWAP ; swap addr and color value for STOREI + STOREI + DROP ; remove addr + + RET + +DEFAULT_PALETTE: + .WORD 0, $FFF, $F00, $0F0, $00F, $0FF, $F0F, $FF0 + .WORD $777, $777, $700, $070, $007, $077, $707, $770 + +; set whole video memory to zero +CLEARGRAPHICS: + LOADC 0 +CL_LOOP: + LOADC FB_WA + OVER ; duplicate value + STOREI + DROP + + LOADC FB_IO + LOADC 0 + STOREI + DROP + + INC 1 + + LOADCP 32768 + CMP.S0 NE + CBRANCH CL_LOOP + + DROP + + RET + +INITGRAPHICS: + LOADCP CLEARGRAPHICS + CALL + LOADCP INITPALETTE + CALL + RET + +; wait for vertical blank +; we first wait for the VBLANK bit +; to become zero to make sure we +; catch the beginning of the vertical blank +WAITVSYNC: + ; wait for VBLANK to become zero + LOADC FB_CTL + LOADI ; read control register + LOADC 1 ; check bit 0 (VBLANK) + AND + CBRANCH.NZ WAITVSYNC ; if set, loop +VSYNC_WAIT1: + ; wait for VBLANK to become one + LOADC FB_CTL + LOADI ; read control register + LOADC 1 ; check bit 0 (VBLANK) + AND + CBRANCH.Z VSYNC_WAIT1 ; if not set, loop + RET + +; args: number of bytes, pointer to buf, +HEXDUMP: + DUP + LOADI + LOADCP PRINTHEXW + CALL + LOADC ' ' + LOADCP CONOUT + CALL + INC 4 + + DUP + LOADI + LOADCP PRINTHEXW + CALL + LOADC ' ' + LOADCP CONOUT + CALL + INC 4 + + DUP + LOADI + LOADCP PRINTHEXW + CALL + LOADC ' ' + LOADCP CONOUT + CALL + INC 4 + + DUP + LOADI + LOADCP PRINTHEXW + CALL + LOADC ' ' + LOADCP CONOUT + CALL + INC 4 + + LOADCP NEWLINE + CALL + + SWAP ; swap pointer and counter + LOADC 16 + SUB + DUP + CBRANCH.Z HEXDUMP_END ; end if counter is zero + SWAP ; swap back counter and pointer + BRANCH HEXDUMP + +HEXDUMP_END: + DROP + DROP + RET + +; inquire cursor position +; args: pointer to columns variable, pointer to rows variable +GETCURSORPOS: + LOADCP TERM_CPR_STR + LOADCP PRINTLINE + CALL + + LOADCP CONIN ; skip ESC + CALL + DROP + LOADCP CONIN ; and '[' + CALL + DROP + + LOADC ';' + LOADCP _TERMRCVINT + CALL + STOREI + DROP + + LOADC 'R' + LOADCP _TERMRCVINT + CALL + STOREI + DROP + + RET + +; receive digits and compose an integer value +; up to a termination character or an ';' +; args: termination character +; returns: -1 on error (invalid digit) + +_TERMRCVINT: + FPADJ -4 + STORE 0 + + LOADC 0 ; start with 0 value +RCVINT_L: + LOADCP CONIN + CALL + + DUP ; duplicate received char + LOAD 0 ; compare with terminator + CMP EQ ; if equal, + CBRANCH RCVINT_XT ; exit + + LOADC '0' ; subtract ascii value to get + SUB ; numerical value + + DUP + LOADC 0 ; check if less than zero + CMP LT + CBRANCH RCVINT_ERR ; if yes, error + + DUP + LOADC 9 + CMP GT ; check if > 9 + CBRANCH RCVINT_ERR ; if yes, error + + SWAP + LOADCP _MUL10 ; old value * 10 (shift digits to the left) + CALL + + ADD ; add to value + BRANCH RCVINT_L ; next digit +RCVINT_ERR: + DROP + DROP + LOADC -1 + BRANCH RCVINT_XT2 +RCVINT_XT: + DROP +RCVINT_XT2: + FPADJ 4 + RET + +TERM_CPR_STR: .BYTE 27, "[6n", 0 ; ANSI Cursor Position Report + + .CPOOL + +GETTICKS: + LOADC IRQC_REG + LOADI + LOADC -256 + AND + BROT + BROT + BROT + RET + + .EQU CRLD_BLOCK 0 + .EQU CRLD_BYTES 4 + .EQU CRLD_ADDR 8 + .EQU CRLD_FS 12 + +; load a program image from sd card +; args: device id, block no, size in bytes +CORELOAD: + ; We need to set the FP and RP registers, + ; because we might overwrite that + ; memory area where the calling program + ; has its user and return stack + + LOADCP FP_START + STOREREG FP + LOADCP RP_START + STOREREG RP + + FPADJ -CRLD_FS + STORE CRLD_BYTES + STORE CRLD_BLOCK + DROP ; ignore device ID, + ; we support only one sd card + + ; divide bytes by 512 and add one + ; to get block count + LOAD CRLD_BYTES + LOADC 9 + LOADCP _SHRM + CALL + INC 1 + ; keep block count on stack + + ; start at address 24576 + LOADCP PROG_START + STORE CRLD_ADDR + +CRLD_LP: + ; read a block + LOAD CRLD_BLOCK + LOADCP CARDREADBLK + CALL + DROP ; ignore error for now + + LOAD CRLD_ADDR + LOADCP CARD_BUF + LOADC 128 + LOADCP _COPYWORDS + CALL + + ; advance dest pointer + LOAD CRLD_ADDR + LOADC 512 + ADD + STORE CRLD_ADDR + + ; increment block number + LOAD CRLD_BLOCK + INC 1 + STORE CRLD_BLOCK + + ; decrement block count on stack + DEC 1 + DUP + CBRANCH.NZ CRLD_LP ; if block count not zero, loop + DROP ; remove block count +CRLD_CLEAN: + ; clean up partial block + LOADC 512 + LOAD CRLD_BYTES + INC 3 ; round up to next word + LOADC -4 + AND + LOADC 511 ; get remainder by 512 + AND + SUB ; subtract to get number of remaining bytes + ; in last block + + LOAD CRLD_ADDR ; this is now the addr of the last + ; byte in the last block + 1 + OVER ; duplicate number of remaining bytes + SUB ; and subtract from addr + + SWAP ; swap addr and number of remaining bytes + LOADCP _CLEARMEM + CALL + + ; clear estack + + ; release our stack frame + FPADJ CRLD_FS + + ; jump to program start address + LOADCP PROG_START + JUMP + + ; no RET + + .CPOOL + +READDIRBLK: +; parameters: [ blkno, ptr to DirBlock, ptr to error return value, device id ] +; same routine as READBLOCK, is referenced by two names to convert buffer types + +; parameters: [ blkno, ptr to PartitionTableBlock, ptr to error return value, device id ] +READPARTBLK: +; same routine as READBLOCK, is referenced by two names to convert buffer types + +READBLOCK: +; parameters: [ blkno, ptr to IOBlock, ptr to error return value, device id ] + DROP ; ignore device id + + LOADC 0 + STOREI ; set return value to zero + DROP + SWAP ; swap blkno and ptr + LOADCP CARDREADBLK ; read that block number + CALL + DROP ; ignore error for now + ; TODO: store it via error ptr + ; ptr to PartitionTableBlock is now on ToS + LOADCP CARD_BUF + LOADC 128 + LOADCP _COPYWORDS ; copy block to destination buffer + CALL + + RET + +WRITEPARTBLK: +WRITEDIRBLK: +; parameters: [ blkno, ptr to IOBlock, ptr to error return value, device id ] +WRITEBLOCK: + DROP ; ignore device id + + LOADC 0 + STOREI ; set return value to zero + DROP + + LOADCP CARD_BUF + SWAP + LOADC 128 + LOADCP _COPYWORDS ; copy block to card_buf + CALL + + LOADCP CARDWRITEBLK ; write that block number + CALL + DROP ; ignore error for now + ; TODO: store it via error ptr + ; ptr to PartitionTableBlock is now on ToS + RET + +%include "sdcardlib.s" + + .CPOOL + +SHELLWORKFILE: .WORD 0,68 + .BLOCK 17 +SHELLCMD: .WORD 0,40 + .BLOCK 8 +SHELLARG: .WORD 0 +PARGCOUNT: .WORD 0 +PARGS: .WORD 0,80 + .BLOCK 20 + .WORD 0,80 + .BLOCK 20 + .WORD 0,80 + .BLOCK 20 + .WORD 0,80 + .BLOCK 20 + .WORD 0,80 + .BLOCK 20 + .WORD 0,80 + .BLOCK 20 + .WORD 0,80 + .BLOCK 20 + .WORD 0,80 + .BLOCK 20 + +DEFAULTVOLUME: .WORD 0,32 + .BLOCK 8 + +SYSCLOCK: + .BLOCK 6 +SYSBOOTTICKS: + .WORD 0 +SYSLASTTICKS: + .WORD 0 + +; copy words to screen memory +; args: pointer to 32000 words of pixel data +PUTSCREEN: + LOADC FB_WA + LOADC 0 ; initialize write address register + STOREI + DROP + + LOADCP 32000 ; word count +PUTSCREEN_L0: + SWAP ; [ count, addr ] + DUP + LOADI ; load pixel word + LOADC FB_IO + SWAP ; swap addr and value for STOREI + STOREI ; store to vmem io register + DROP + + INC 4 ; next word + + SWAP ; swap addr and count + DEC 1 ; decrement count + + DUP + CBRANCH.NZ PUTSCREEN_L0 ; loop if count is not zero + + DROP ; remove counter and addr + DROP + + RET + + +%export _MUL +%export _MULU +%export _DIV +%export _DIVU +%export _MOD +%export _DIVMODU +%export _SHRM +%export _SHLM +%export _COPYWORDS +%export _CMPWORDS +%export _CLEARMEM diff --git a/lib/coreloader.s b/lib/coreloader.s new file mode 100644 index 0000000..542b667 --- /dev/null +++ b/lib/coreloader.s @@ -0,0 +1,279 @@ +; Copyright 2021-2024 Sebastian Lederer. See the file LICENSE.md for details + .ORG 4096 + +CORELOADER: + ; initialize program stack and + ; return stack pointers + LOADCP 24060 + STOREREG FP + LOADCP 24064 + STOREREG RP + + LOADCP SYSBOOTTICKS + LOADCP GETTICKS + CALL + STOREI + DROP + + LOADCP INITSDCARD + CALL + + ;LOADCP FIND_SYSPART ; no need to call, it never + ;CALL ; returns, so just fall through + + .EQU PART_START 0 + .EQU EXTENT_SIZE 4 + .EQU DIR_SIZE 8 + .EQU SLOT_NO 12 + .EQU SIZE_BYTES 16 + .EQU PRG_START_BLK 20 + .EQU FIND_FS 24 + + .EQU PARTENTRY_SIZE 64 + .EQU DIRENTRY_SIZE 64 +FIND_SYSPART: + FPADJ -FIND_FS + ; load block 0 + LOADC 0 + LOADCP CARDREADBLK + CALL + + DUP ; non-zero return code means error + CBRANCH.Z FIND_1 + + LOADCP PRINTHEXW + CALL + LOADCP NEWLINE + CALL + LOADC 0 + JUMP + +FIND_1: + DROP ; remove return code + + ;LOADC 512 + ;LOADCP CARD_BUF + ;LOADCP HEXDUMP + ;CALL + + ; address of the first partition entry + LOADCP CARD_BUF +FIND_L: + DUP ; dup addr for comparison + LOADCP SYSPART_NAME + LOADC SYSNAME_WORDS + LOADCP _CMPWORDS + CALL + CBRANCH.NZ FIND_FOUND + ; go to next entry + LOADC PARTENTRY_SIZE + ADD + + ; check if address is still + ; within the data block + DUP + LOADCP CARD_BUF,512 + CMP LT + CBRANCH FIND_L + + ; remove address + DROP + + ; not found, complain and + ; go back to ROM monitor + LOADCP SYSPART_ERR + LOADCP PRINTLINE + CALL + + LOADC 0 + JUMP + +FIND_FOUND: + ; address of the part entry is on stack + + ; check if partition is enabled + DUP ; duplicate address + LOADC 40 ; add PartFlags field offset + ADD + LOADI + LOADC 1 + AND ; check bit 0 (PartEnabled) + CBRANCH.Z FIND_L ; if not set, continue loop + + + ; address of part entry is still on stack + DUP + LOADC 44 ; add startBlock field offset + ADD + LOADI ; get start block number + STORE PART_START + + ; address of part entry is still on stack + DUP + LOADC 52 ; move to extentSize field + ADD + LOADI ; get value + STORE EXTENT_SIZE + + ; address of part entry is still on stack + LOADC 56 ; move to dirSize field + ADD + LOADI ; get value + STORE DIR_SIZE + + LOADC 0 + STORE SLOT_NO ; start with dirslot 0 + + LOAD PART_START ; start with first block of the partition +FIND_FILE: + DUP ; duplicate block number + LOADCP CARDREADBLK ; read that block + CALL + DROP ; ignore error + + ; scan directory entries for shell file name + LOADCP CARD_BUF +FIND_FILE_L: + DUP + LOADCP SHELL_NAME + LOADC SHELLNAME_WORDS + LOADCP _CMPWORDS ; compare names + CALL + CBRANCH.NZ FIND_F_FOUND ; exit loop if names match + + ; check if current dirslot no + ; is below maximum number of slots + LOAD SLOT_NO + LOAD DIR_SIZE + CMP GE + CBRANCH FIND_F_NOTFOUND ; max slots reached, exit + + ; add 1 to SLOT_NO + LOAD SLOT_NO + INC 1 + STORE SLOT_NO + + ; address is still on stack + LOADC DIRENTRY_SIZE + ADD ; go to next dir entry + + ; check if address is still + ; below end of data block + DUP + LOADCP CARD_BUF,512 + CMP LT + CBRANCH FIND_FILE_L ; if it is below, loop + + DROP ; remove dir entry addr + + ; block no is still on stack + INC 1 + BRANCH FIND_FILE ; read next block + +FIND_F_NOTFOUND: + LOADCP SHELL_ERR + LOADCP PRINTLINE + CALL + + ; remove entry addr and block number + DROP + DROP + LOADC 0 + JUMP + +FIND_F_FOUND: + ; found the file name, now check if it has the right flags + + ; address of dir entry is still on stack + DUP + LOADC 40 ; add flags field offset + ADD + LOADI ; load flags + LOADC 16 ; test for SlotFirst flag + AND + CBRANCH.Z FIND_FILE_L ; if not set, continue loop + + ;LOADCP FOUND_MSG + ;LOADCP PRINTLINE + ;CALL + + ; we got the right file, now calculate start block + ; and get file size from dir entry + + ; address of dir entry is still on stack + ; phys start block = part start + slot_no * (extent_size/512) + LOAD EXTENT_SIZE + LOADC 9 + LOADCP _SHRM + CALL + LOAD SLOT_NO + LOADCP _MUL + CALL + LOAD PART_START + ADD + + ;DUP + ;LOADCP PRINTHEXW + ;CALL + ;LOADC ' ' + ;LOADCP CONOUT + ;CALL + + STORE PRG_START_BLK + + ; address of dir entry is still on stack + LOADC 44 + ADD ; add sizeBytes field offset + LOADI ; get size in bytes + + ;DUP + ;LOADCP PRINTHEXW + ;CALL + ;LOADCP NEWLINE + ;CALL + + STORE SIZE_BYTES + + ; remove block number + DROP + + ; set argument count to 0 + ; in case this gets called + ; by a terminating program + LOADCP PARGCOUNT + LOADC 0 + STOREI + DROP + + LOADC 0 ; device id is always 0 + LOAD PRG_START_BLK + LOAD SIZE_BYTES + ; release our stack frame + FPADJ FIND_FS + + ; load program + LOADCP CORELOAD + CALL + + LOADC 0 + JUMP + + .CPOOL + + .EQU SYSNAME_WORDS 4 +SYSPART_NAME: + .WORD 6, 32 + .BYTE "SYSTEM" +SYSPART_ERR: + .BYTE "No ""SYSTEM"" partition.",13,10,10,0 + .EQU SHELLNAME_WORDS 5 +SHELL_NAME: + .WORD 10,32 + .BYTE "shell.prog" +SHELL_ERR: + .BYTE "No shell on ""SYSTEM"" partition.",13,10,10,0 + +FOUND_MSG: + .BYTE " shell.prog ",0 + +%include corelib.s diff --git a/lib/float32.s b/lib/float32.s new file mode 100644 index 0000000..4b0ad9c --- /dev/null +++ b/lib/float32.s @@ -0,0 +1,1053 @@ +; Copyright 2021-2024 Sebastian Lederer. See the file LICENSE.md for details + +; FLOAT32 format: +;| 31 | 30-8 | 7-0 | +;|sign| fraction | exp | + +; exp has a bias of 128 +; sign = 1: negative number + + .EQU FLOAT32_EXPMASK %00000000000000000000000011111111 + .EQU FLOAT32_FRCMASK %01111111111111111111111100000000 + .EQU FLOAT32_SGNMASK %10000000000000000000000000000000 + .EQU FLOAT32_FRCMSBM %01000000000000000000000000000000 + .EQU FLOAT32_OVRFLOW %10000000000000000000000000000000 + .EQU FLOAT32_RNDMASK %00000000000000000000000010000000 + .EQU FLOAT32_RNDINCR %00000000000000000000000100000000 + .EQU FLOAT32_FRCLSB %00000000000000000000000100000000 + + .EQU FLOAT32_MAX_EXP 255 + .EQU FLOAT32_BIAS 127 + .EQU FLOAT32_FRCBITS 23 + .EQU FLOAT32_EXP_BITS 8 + +; unpack a float32 value into +; three fields: exponent, fraction, sign +; ptr is a pointer to an array with the three fields +; the sign flag is 0 or 1. + +; parameters: [ floatval, ptr ] +_UNPACKFLOAT32: + OVER ; [ float, ptr, float ] + LOADC FLOAT32_EXPMASK ; [ float, ptr, float, mask ] + AND ; [ float, ptr, exp ] + STOREI 4 ; [ float, ptr + 4 ] + OVER ; [ float, ptr + 4, float ] + LOADCP FLOAT32_FRCMASK ; [ float, ptr + 4 , float, mask ] + AND ; [ float, ptr + 4 , frac ] + STOREI 4 ; [ float, ptr + 8 ] + SWAP ; [ ptr + 8, float ] + LOADCP FLOAT32_SGNMASK ; [ ptr + 8, float, mask ] + AND ; [ ptr + 8, signbit ] + LOADC 0 ; [ ptr + 8, signbit, 0 ] + CMPU NE ; [ ptr + 8, sign ] + STOREI ; [ ptr + 8 ] + DROP ; [] + RET + +; pack exponent, fraction, sign into a single 32-bit value +; ptr is a pointer to an array with the three fields +; parameters: [ ptr ] +; returns: float value +_PACKFLOAT32: + LOADI.S1.X2Y ; [ ptr, exp ] + OVER ; [ ptr, exp, ptr ] + INC 4 ; [ ptr, exp, ptr + 4 ] + LOADI ; [ ptr, exp, frac ] + LOADCP FLOAT32_FRCMASK ; [ ptr, exp, frac, mask ] + AND ; [ ptr, exp, frac ] + OR ; [ ptr, exp|frac ] + OVER ; [ ptr, exp|frac, ptr ] + INC 8 ; [ ptr, exp|frac, ptr + 8] + LOADI ; [ ptr, exp|frac, signflag ] + CBRANCH.Z PACKFL_1 ; [ ptr, exp | frac ] + LOADCP FLOAT32_SGNMASK ; [ ptr, exp|frac, signmask ] + ADD ; [ ptr, floatval ] +PACKFL_1: + SWAP ; [ floatval, ptr ] + DROP ; [ floatval ] + RET + +; adds to floating point values a and b +; parameters: [ a, b ] +; returns: sum of a and b + .EQU FL_E_A 0 + .EQU FL_F_A 4 + .EQU FL_S_A 8 + .EQU FL_E_B 12 + .EQU FL_F_B 16 + .EQU FL_S_B 20 + .EQU FL_E_R 24 + .EQU FL_F_R 28 + .EQU FL_S_R 32 + .EQU ADDFL_SUB 36 + .EQU ADDFL_FS 40 + +_ADDFLOAT32: + FPADJ -ADDFL_FS + ; unpack b into e_b and f_b + LOADREG FP + LOADC FL_E_B + ADD ; addr of FL_E_B + LOADCP _UNPACKFLOAT32 + CALL + ; unpack a into e_a and f_a + LOADREG FP ; addr of FL_E_A + LOADCP _UNPACKFLOAT32 + CALL + + + ; if abs(a) < abs(b), swap a and b (this includes e_a < e_b) + LOAD FL_E_A + LOAD FL_E_B + CMPU GT + CBRANCH ADDFL_1 ; don't swap if e_a > e_b + ; e_a <= e_b + ; check if e_a < e_b + LOAD FL_E_A + LOAD FL_E_B + CMPU LT + CBRANCH ADDFL_1_1 ; swap if e_a < e_b + ; e_a = e_b + ; check fractions + LOAD FL_F_A + LOAD FL_F_B + CMPU GE + CBRANCH ADDFL_1 ; dont't swap if f_a >= f_b + +ADDFL_1_1: + ;LOADC '"' + ;LOADCP CONOUT + ;CALL + + LOAD FL_E_A + LOAD FL_E_B + STORE FL_E_A + STORE FL_E_B + LOAD FL_F_A + LOAD FL_F_B + STORE FL_F_A + STORE FL_F_B + LOAD FL_S_A + LOAD FL_S_B + STORE FL_S_A + STORE FL_S_B +ADDFL_1: + ; e_r := e_a, result exp is exp from a + LOAD FL_E_A + STORE FL_E_R + + LOAD FL_S_A ; take result sign from a (which might be swapped with b here) + STORE FL_S_R + + LOAD FL_S_A ; check if the signs of a and b differ + LOAD FL_S_B + XOR ; if the xor of both sign flags is 1, signs are not the same + STORE ADDFL_SUB ; then we do a subtraction later + + ; ? if (e_a - e_b) > precision +1: + ; ? set f_r to f_a + + ; shift right f_b by (e_a - e_b) bits + LOAD FL_E_A + LOAD FL_E_B + SUB + + ;LOADCP NEWLINE + ;CALL + ;LOADC 'e' + ;LOADCP CONOUT + ;CALL + ;DUP + ;LOADCP PRINTDEC + ;CALL + ;LOADCP NEWLINE + ;CALL + + LOAD FL_F_B ; on stack now: [ counter, f_b ] +ADDFL_L1: + OVER ; check counter for zero + CBRANCH.Z ADDFL_2 ; if yes, loop is done + SHR ; shift right + SWAP ; swap counter and value + DEC 1 ; decrement counter + SWAP ; swap back + BRANCH ADDFL_L1 ; next +ADDFL_2: + STORE FL_F_B ; store result + DROP ; remove counter + + ;LOADC 'a' + ;LOADCP CONOUT + ;CALL + ;LOAD FL_F_A + ;LOADCP PRINTHEXW + ;CALL + ;LOADCP NEWLINE + ;CALL + ;LOADC 'b' + ;LOADCP CONOUT + ;CALL + ;LOAD FL_F_B + ;LOADCP PRINTHEXW + ;CALL + ;LOADCP NEWLINE + ;CALL + + ; set f_r to f_a + f_b + ; (or f_r = f_a - f_b if we have a negative sign somewhere) + LOAD FL_F_A + LOAD FL_F_B + LOAD ADDFL_SUB ; do we need a subtract? + CBRANCH ADDFL_2_1 ; yes, skip add instruction + ADD ; no, do add and skip sub instruction + BRANCH ADDFL_2_2 +ADDFL_2_1: + ;LOADC '-' + ;LOADCP CONOUT + ;CALL + ;LOADCP NEWLINE + ;CALL + + SUB +ADDFL_2_2: + ;DUP + ;LOADCP PRINTHEXW + ;CALL + ;LOADCP NEWLINE + ;CALL + + ; normalize: + ; if overflow bit of f_r is set, scale right + DUP + LOADCP FLOAT32_OVRFLOW ; isolate overflow bit + AND + + CBRANCH.Z ADDFL_3 + + ;LOADC 'V' + ;LOADCP CONOUT + ;CALL + + ; scale right: shift right f_r by one, increment e_r by one + SHR + LOAD FL_E_R + INC 1 + STORE FL_E_R +ADDFL_3: + ; check if result is zero + DUP + CBRANCH.NZ ADDFL_3_1 + ; set exponent to something useful + LOADC 0 + STORE FL_E_R + ; clear sign, we don't want -0 + LOADC 0 + STORE FL_S_R + + BRANCH ADDFL_4 + +ADDFL_3_1: + ; if bit 30 of f_r is zero, scale left + DUP + LOADCP FLOAT32_FRCMSBM ; isolate msb of fraction + AND + CBRANCH.NZ ADDFL_4 + + ;LOADC '<' + ;LOADCP CONOUT + ;CALL + ;LOADCP NEWLINE + ;CALL + + ; scale left and repeat previous step + SHL ; shift fraction + LOAD FL_E_R ; decrement exponent + DEC 1 + STORE FL_E_R + BRANCH ADDFL_3 ; repeat +ADDFL_4: + ; round: + ; simple round algorithm: if the bit below + ; the least significat bit is 1, round up + ; and check the overflow bit again + + DUP + LOADC FLOAT32_RNDMASK ; test rounding bit + AND + CBRANCH.Z ADDFL_5 ; if not set, skip rounding + + ;LOADC '~' + ;LOADCP CONOUT + ;CALL + ;LOADCP NEWLINE + ;CALL + + LOADC FLOAT32_RNDINCR + ADD + + LOADCP FLOAT32_FRCMASK ; remove rounded off bits + AND + + BRANCH ADDFL_3_1 ; check for overflow again +ADDFL_5: + + STORE FL_F_R + + ;LOADCP NEWLINE + ;CALL + ;LOADC 'E' + ;LOADCP CONOUT + ;CALL + + ;LOAD FL_E_R + ;LOADCP PRINTHEXW + ;CALL + ;LOADCP NEWLINE + ;CALL + + ; check exponent range overflow + LOADCP FLOAT32_EXP_CHECK + CALL +ADDFL_6: + ; pack e_r,f_r,s_r into r + LOADREG FP + LOADC FL_E_R + ADD + LOADCP _PACKFLOAT32 + CALL + + FPADJ ADDFL_FS + RET + +; check exponent value of local var FL_E_R +; for overflow and issue runtime error on failure. +; uses stack frame of caller. +FLOAT32_EXP_CHECK: + ; check exponent range overflow + LOAD FL_E_R + LOADC FLOAT32_MAX_EXP + CMPU LE + CBRANCH FLOAT32_EXP_XT + + LOADCP FLOAT32_ERR_OVR + LOADCP _RUNTIME_ERR + JUMP +FLOAT32_EXP_XT: + RET + +; subtract floating point value b from a +; parameters: [ a, b ] +; returns: a - b +_SUBFLOAT32: + ; just flip sign bit of b and continue with _ADDFLOAT32 + LOADCP $80000000 + XOR + BRANCH _ADDFLOAT32 + +; multiply two floating point values a and b +; parameters: [ a, b ] +; returns: a * b + .EQU MULFL_FS 36 +_MULFLOAT32: + FPADJ -MULFL_FS ; same stack frame layout as _ADDFLOAT32 + + DUP + CBRANCH.NZ _MULFLOAT32_1 ; check if b is zero + ; if yes, just return zero + NIP ; remove a, take b (which is zero) as return value + BRANCH _MULFLOAT32_X +_MULFLOAT32_1: + ; unpack b into e_b and f_b + LOADREG FP + LOADC FL_E_B + ADD ; addr of FL_E_B + LOADCP _UNPACKFLOAT32 + CALL + + DUP + CBRANCH.NZ _MULFLOAT32_2 ; check if a is zero + ; if yes, return zero + ; take a (which is zero) as return value + BRANCH _MULFLOAT32_X +_MULFLOAT32_2: + ; unpack a into e_a and f_a + LOADREG FP ; addr of FL_E_A + LOADCP _UNPACKFLOAT32 + CALL + + ; s_r = s_a xor s_b + LOAD FL_S_A + LOAD FL_S_B + XOR + STORE FL_S_R + + ; e_r = e_a + e_b - bias + LOAD FL_E_A + LOAD FL_E_B + ADD + LOADC FLOAT32_BIAS + SUB + STORE FL_E_R + + ; check exponent range overflow + LOADCP FLOAT32_EXP_CHECK + CALL + ; f_r = fractmult(f_a, f_b) + LOADCP _FRACTMULT + CALL + + LOADCP NORMROUND_FL ; normalize and round + CALL + + ; pack result + LOADREG FP + LOADC FL_E_R + ADD + LOADCP _PACKFLOAT32 + CALL +_MULFLOAT32_X: + ; 32 bit float result is now on stack + FPADJ MULFL_FS + RET + +; multiply fractions. +; uses stack frame/local variables from caller. +; FL_F_B is destroyed. +; result is written to FL_R +_FRACTMULT: + LOADC FLOAT32_FRCBITS ; this is the counter which we keep on stack + + LOADC 0 ; start with result zero + STORE FL_F_R + + ; for each digit of the fraction of b, from right to left, + ; the fraction of a is added to the result, if that digit is 1. + ; on each iteration, the result is shifted right. +_FRACTMULT_1: + LOAD FL_F_R + SHR + STORE FL_F_R ; shift result frac for next iteration + + LOAD FL_F_B + LOADC FLOAT32_FRCLSB + AND ; isolate lowest bit + + CBRANCH.Z _FRACTMULT_2 ; if not set, don't add in this iteration + + LOAD FL_F_R ; otherwise, add fraction of a to result + LOAD FL_F_A + ADD + STORE FL_F_R + +_FRACTMULT_2: + LOAD FL_F_B + SHR + STORE FL_F_B ; shift fraction b for next digit + + DEC 1 ; decrease counter + DUP + CBRANCH _FRACTMULT_1 ; if not zero, next loop iteration + + DROP ; drop counter + RET + +; divide floating point value a by b +; parameters: [ a, b ] +; returns: a / b + .EQU DIVFL_FS 36 +_DIVFLOAT32: + FPADJ -DIVFL_FS ; same stack frame layout as _ADDFLOAT32 + DUP + CBRANCH.NZ _DIVFLOAT32_0 ; check b for zero + LOADCP FLOAT32_ERR_DIVZ ; if it is, we have a division by zero + LOADCP _RUNTIME_ERR ; and we issue a runtime error + JUMP +_DIVFLOAT32_0: + OVER ; check a for zero + CBRANCH.NZ _DIVFLOAT32_0_1 + ; if it is we just return zero + DROP ; remove args + DROP + LOADC 0 + BRANCH _DIVFLOAT32_XT + +_DIVFLOAT32_0_1: + ; unpack b into e_b and f_b + LOADREG FP + LOADC FL_E_B + ADD ; addr of FL_E_B + LOADCP _UNPACKFLOAT32 + CALL + ; unpack a into e_a and f_a + LOADREG FP ; addr of FL_E_A + LOADCP _UNPACKFLOAT32 + CALL + + ; s_r = s_a xor s_b + LOAD FL_S_A + LOAD FL_S_B + XOR + STORE FL_S_R + + ; e_r = e_a - e_b + bias + LOAD FL_E_A + LOAD FL_E_B + SUB + LOADC FLOAT32_BIAS + ADD + STORE FL_E_R + + ; check exponent range overflow + LOADCP FLOAT32_EXP_CHECK + CALL + ; f_r = fractdiv(f_a, f_b) + LOADCP _FRACTDIV + CALL + + LOADCP NORMROUND_FL ; normalize and round + CALL + + ; pack result + LOADREG FP + LOADC FL_E_R + ADD + LOADCP _PACKFLOAT32 + CALL +_DIVFLOAT32_XT: + ; 32 bit float result is now on stack + FPADJ DIVFL_FS + RET + +; divide fraction of a by b. +; uses stackframe of caller. +; FL_F_A is destroyed. +; places result into FL_F_R. +_FRACTDIV: + LOADC 0 + STORE FL_F_R + + LOADC FLOAT32_FRCBITS ; load counter +_FRACTDIV_1: + LOAD FL_F_R ; load result for later + LOAD FL_F_B + LOAD FL_F_A + CMPU GT + CBRANCH _FRACTDIV_2 ; if b > a, skip next section + INC 1 ; a fits into b, so add 1 to result + LOAD FL_F_A ; subtract divisor from dividend + LOAD FL_F_B + SUB + STORE FL_F_A + +_FRACTDIV_2: + SHL ; shift result left for next digit + STORE FL_F_R ; and store it again + LOAD FL_F_A ; shift the dividend left for next digit + SHL + STORE FL_F_A + + DEC 1 ; decrement counter + DUP + CBRANCH.NZ _FRACTDIV_1 ; loop if it is not zero + + DROP ; remove counter + + LOAD FL_F_R ; undo the last shift of the result + SHR + BROT ; and shift left again to make room for the exponent + STORE FL_F_R + RET + + +; normalize and round f_r. +; uses stack frame of caller. +NORMROUND_FL: + LOAD FL_F_R +NORMFL_0: + ; if overflow bit of f_r is set, scale right + DUP + LOADCP FLOAT32_OVRFLOW ; isolate overflow bit + AND + CBRANCH.Z NORMFL_1 ; if bit is zero, skip the scaling + + ; scale right: shift right f_r by one, increment e_r by one + SHR + LOAD FL_E_R + INC 1 + STORE FL_E_R + +NORMFL_1: + ; check if result is zero + DUP + CBRANCH.NZ NORMFL_1_1 + ; set exponent to something useful + LOADC 0 + STORE FL_E_R + ; clear sign flag, we don't want -0 + LOADC 0 + STORE FL_S_R + + BRANCH NORMFL_2 + + ; normalize: + ; if bit 30 of f_r is zero, scale left +NORMFL_1_1: + DUP + LOADCP FLOAT32_FRCMSBM ; isolate msb of fraction + AND + CBRANCH.NZ NORMFL_2 ; skip if bit is set + ; scale left and repeat previous step + SHL ; shift fraction + LOAD FL_E_R ; decrement exponent + DEC 1 + STORE FL_E_R + BRANCH NORMFL_1_1 ; repeat + +NORMFL_2: + ; round: + ; simple round algorithm: if the bit below + ; the least significat bit is 1, round up + ; and check the overflow bit again + DUP + LOADC FLOAT32_RNDMASK ; test rounding bit + AND + CBRANCH.Z NORMFL_3 ; if not set, skip rounding + + LOADC FLOAT32_RNDINCR + ADD + + LOADCP FLOAT32_FRCMASK ; remove rounded off bits + AND + + BRANCH NORMFL_0 ; check for overflow again +NORMFL_3: + STORE FL_F_R + RET + +; return the fractional part of a floating point number +; parameters: float32 value +; returns: float32 value + .EQU FRACTFL_EXP 12 + .EQU FRACTFL_FS 20 +_FRACTFLOAT32: + FPADJ -FRACTFL_FS + DUP ; check for zero + CBRANCH.Z FRACTFL_XT ; if yes, just return zero + LOADREG FP + LOADCP _UNPACKFLOAT32 + CALL + + LOAD FL_E_A ; remove bias from exponent + LOADC FLOAT32_BIAS + SUB + DUP + STORE FRACTFL_EXP + + LOADC 0 ; if the exponent is negative, + CMP LT ; there are no digits before the point + CBRANCH FRACTFL_PK ; and we just return the same value + + LOAD FRACTFL_EXP ; the exponent indicates how far + ; we need to shift the fraction to the left + INC 1 ; at exp 0 we need to shift by 1 + + LOADC FLOAT32_BIAS - 1 + STORE FL_E_A ; the new exponent is -1 because we + ; shifted by (old exp + 1) bits + + LOAD FL_F_A ; load fraction, shift count is already on stack +FRACTFL_L: + SHL ; shift fraction + SWAP ; swap fraction and shift count + DEC 1 ; decrement count + SWAP ; swap back shift count and fraction + OVER ; check count for zero + CBRANCH FRACTFL_L ; if not, loop + + NIP ; remove count + LOADCP FLOAT32_FRCMASK + AND ; remove superfluous bits + + DUP ; check if fraction is zero + CBRANCH.NZ FRACTFL_1 + ; if yes, directly return + BRANCH FRACTFL_XT + + ; normalize +FRACTFL_1: + DUP + LOADCP FLOAT32_FRCMSBM ; isolate msb of fraction + AND + CBRANCH.NZ FRACTFL_2 ; skip if bit is set + ; scale left and repeat previous step + SHL ; shift fraction + LOAD FL_E_A ; decrement exponent + DEC 1 + STORE FL_E_A + BRANCH FRACTFL_1 ; repeat +FRACTFL_2: + STORE FL_F_A +FRACTFL_PK: + LOADREG FP + LOADCP _PACKFLOAT32 + CALL +FRACTFL_XT: + FPADJ FRACTFL_FS + RET + +; truncate a floating point number - return +; the integer value before the decimal point. +; issues a runtime error if the integer value +; does not fit into a signed 32-bit integer. +; parameters: float32 value +; returns: integer + .EQU TRUNCFL_SHIFT 12 + .EQU TRUNCFL_FS 16 +_TRUNCFLOAT32: + FPADJ -TRUNCFL_FS + LOADREG FP + LOADCP _UNPACKFLOAT32 + CALL + + LOAD FL_E_A ; remove bias from exponent + LOADC FLOAT32_BIAS + SUB + DUP + STORE FL_E_A + + ; if the exponent + LOADC 0 ; is negative, + CMP LT ; our result is zero + CBRANCH TRUNCFL_ZERO + + ; shift fraction all the way to the right + LOAD FL_F_A ; shift fraction right by 8 bits + BROT ; by rotating 3*8 bits left + BROT ; we know that the original bits 7-0 + BROT ; are zero + + ; calculate number of bits to shift: + ; fraction bits - 1 - exponent + LOADC FLOAT32_FRCBITS - 1 + LOAD FL_E_A + SUB + DUP + STORE TRUNCFL_SHIFT + LOADC 0 ; is shift count >= 0? + CMP GE + CBRANCH TRUNCFL_2 + + ; shift count is negative, need to shift left + ; check for integer overflow first + LOAD TRUNCFL_SHIFT + NOT ; negate shift count + INC 1 + + DUP ; shift count >= bits in a word - bits in the fraction? + LOADC 32 - FLOAT32_FRCBITS + CMP GE + CBRANCH TRUNCFL_ERR ; then we have an overflow + + ; otherwise, shift n bits left +TRUNCFL_1: + DUP + CBRANCH.Z TRUNCFL_3 ; if zero, we are done + + DEC 1 ; decrement shift count + SWAP ; swap shift count and fraction + SHL ; shift fraction left + SWAP ; swap back + BRANCH TRUNCFL_1 ; and loop + +TRUNCFL_2: ; shift right, fraction is on ToS + LOAD TRUNCFL_SHIFT ; bits to shift +TRUNCFL_L1: + DUP + CBRANCH.Z TRUNCFL_3 ; if zero, we are done + + DEC 1 ; decrement shift count + SWAP ; swap shift count and fraction + SHR ; shift fraction right + SWAP ; swap back + BRANCH TRUNCFL_L1 ; and loop +TRUNCFL_3: + DROP ; drop shift count + BRANCH TRUNCFL_EXIT +TRUNCFL_ZERO: + LOADC 0 +TRUNCFL_EXIT: + LOAD FL_S_A ; check sign + CBRANCH.Z TRUNCFL_EXIT1 + ; if not zero, negate result + NOT + INC 1 +TRUNCFL_EXIT1: + FPADJ TRUNCFL_FS + RET + +TRUNCFL_ERR: + DROP + LOADCP FLOAT32_ERR_TRUNC + LOADCP _RUNTIME_ERR + JUMP + +; like _TRUNCFLOAT32, but return a float32 value +; parameters [ float value ] +; returns: float value +; TODO: write a real routine which might be faster +; than just calling _TRUNCFLOAT32 and INTTOFLOAT32. +; Also, _TRUNCFLOAT32 can cause an integer overflow +; where INT should not. +_INTFLOAT32: + LOADCP _TRUNCFLOAT32 + CALL + LOADCP _INTTOFLOAT32 + CALL + RET + + .CPOOL + +; multiply/divide a float value by a multitude of 2 +; shift count < 1: shift right (divide) +; shuft count > 0: shift left (multiply) +; parameters: [ float value, shift count ] +; returns: float value + .EQU SHF32_FS 36 + .EQU SHF32_COUNT 12 +SHIFTFLOAT32: + FPADJ -SHF32_FS + + ; store shift count parameter + STORE SHF32_COUNT + ; Unpack float value. + ; We use the result variable slot + ; because EXP_CHECK uses that. + LOADREG FP + LOADC FL_E_R + ADD + LOADCP _UNPACKFLOAT32 + CALL + + ; we just add the shift count to + ; the exponent + LOAD FL_E_R + LOAD SHF32_COUNT + ADD + STORE FL_E_R + + ; and check for overflow + LOADCP FLOAT32_EXP_CHECK + CALL + + ; pack up the result + LOADREG FP + LOADC FL_E_R + ADD + LOADCP _PACKFLOAT32 + CALL + + FPADJ SHF32_FS + RET + +; convert an integer to a float32 +; parameters: an integer +; returns: a float32 value + .EQU INTF32_FS 12 +_INTTOFLOAT32: + FPADJ -INTF32_FS + + ; is intval zero? + DUP + CBRANCH.Z INTTOFLOAT32_XT ; if yes, we are done, float zero has the same + ; representation as integer zero + + ; is intval < 0? + LOADC 0 + CMP.S0 LT + DUP + STORE FL_S_A ; store cmp result as sign flag + CBRANCH.Z INTF32_1 ; skip negate if cmp result is 0 + ; negate + NOT + INC 1 +INTF32_1: + LOADC 30 ; set counter +INTF32_L: + ; loop if bit 31 is not set: + SWAP ; swap counter and value (value is now ToS) + + LOADCP $40000000 + AND.S0 + CBRANCH INTF32_2 + ; shift left + SHL + ; swap counter and value again (counter is now ToS) + SWAP + ; decrease counter + DEC 1 + BRANCH INTF32_L +INTF32_2: + ; store shifted value as fraction + STORE FL_F_A + ; set exponent to counter + bias + LOADC FLOAT32_BIAS + ADD + STORE FL_E_A + ; pack components + LOADREG FP + LOADCP _PACKFLOAT32 + CALL + BRANCH INTTOFLOAT32_XT +INTTOFLOAT32_XT: + FPADJ INTF32_FS + RET + +; get the binary exponent of a floating point value +; (without the bias) +; parameters: [ float value ] +; returns: exponent (-128..128) +_GETFLOAT32EXP: + LOADC FLOAT32_EXPMASK + AND + LOADC FLOAT32_BIAS + SUB + RET + +; compare an integer to a floating point value +; parameters: a:integer, b: float +; calls INTTOFLOAT32 on a, then calls CMPFLOAT32 +; returns: -1 if a < b +; 0 if a = b +_CMPINTFLOAT32: + SWAP ; swap a and b, a is now on top of stack + LOADCP _INTTOFLOAT32 + CALL ; a is now a float + SWAP ; swap a and b back, b is on top of stack again + ; fallthrough to CMPFLOAT32 + +; compare two floating point values +; parameters: two floating point values a and b +; returns: -1 if a < b +; 0 if a = b +; 1 if a > b + .EQU CMPFL_FS 24 +_CMPFLOAT32: + FPADJ -CMPFL_FS + ; unpack b + LOADREG FP + LOADC FL_E_B + ADD + LOADCP _UNPACKFLOAT32 + CALL + ;unpack a + LOADREG FP + LOADCP _UNPACKFLOAT32 + CALL + + ;if sign(a) and not sign(b): + ; return -1 + ;if not sign(a) and sign(b): + ; return 1 + LOAD FL_S_A + LOAD FL_S_B + XOR + CBRANCH.Z CMPFL_2 ; jump if signs are the same + ; signs are not the same + LOAD FL_S_A + CBRANCH.Z CMPFL_1 ; jump if a is positive + ; a is negative, b must be positive, so a < b +CMPFL_M1: + LOADC -1 + BRANCH CMPFL_XT +CMPFL_1: + ; a is positive, b must be negative, so a > b + LOADC 1 + BRANCH CMPFL_XT +CMPFL_2: + ; signs are the same, compare exponents now. + ; we can compare the exponent values directly without + ; subtracting the bias because negative exponents + ; are smaller than positive exponents due to the added + ; bias. + ; if we determine a result, from now on the result + ; must be inverted if the sign of a and b is negative. + + ;if exp(a) < exp(b): + ; return -1 * sign(a) + LOAD FL_E_A + LOAD FL_E_B + CMPU GE + CBRANCH CMPFL_3 ; jump if exp(a) >= exp(b) + ; exp(a) < exp(b), so abs(a) < abs(b) + LOADC -1 +CMPFL_2_1: + ; invert result if signs of a and b are negative + LOAD FL_S_A + CBRANCH.Z CMPFL_XT ; sign is clear, no need to invert + + NOT ; negate result and exit + INC 1 + BRANCH CMPFL_XT +CMPFL_3: + ; exp(a) >= exp(b) + ; check if exp(a) > exp(b) + LOAD FL_E_A + LOAD FL_E_B + CMPU GT + CBRANCH CMPFL_5 ; jump if yes + ; exp(a) = exp(b) + ; exponents are the same, compare fractions now + + ;if frac(a) < frac(b): + ; return -1 * sign(a) + LOAD FL_F_A + LOAD FL_F_B + CMPU GE + CBRANCH CMPFL_4 ; jump if frac(a) >= frac(b) + + ; frac(a) < frac(b) + LOADC -1 + BRANCH CMPFL_2_1 ; check for inversion of result + ;if frac(a) > frac(b): + ; return 1 * neg_result +CMPFL_4: + ; frac(a) >= frac(b) + ; check if frac(a) > frac(b) + LOAD FL_F_A + LOAD FL_F_B + CMPU GT + CBRANCH CMPFL_5 ; jump if frac(a) > frac(b) + ; frac(a) = frac(b) + LOADC 0 + BRANCH CMPFL_XT +CMPFL_5: + ; exp(a) > exp(b): + ; return 1 * sign(a) + LOADC 1 + BRANCH CMPFL_2_1 ; check for inversion of result +CMPFL_XT: + FPADJ CMPFL_FS + RET + +; Negate a float32 number. +; just flip the highest bit, no +; need to unpack. +; if it is zero, do nothing, we +; do not want a -0.0 value +_NEGFLOAT32: + DUP + CBRANCH.Z _NEGFL_XT + LOADCP $80000000 + XOR +_NEGFL_XT: + RET + + .CPOOL + +FLOAT32_ERR_OVR: + .BYTE "floating point overflow",0 +FLOAT32_ERR_TRUNC: + .BYTE "integer overflow",0 +FLOAT32_ERR_DIVZ: + .BYTE "float division by zero",0 diff --git a/lib/rommon.s b/lib/rommon.s new file mode 100644 index 0000000..a967e4b --- /dev/null +++ b/lib/rommon.s @@ -0,0 +1,805 @@ + .EQU CR 13 + .EQU LF 10 + .EQU EOT 4 + .EQU ACK 6 + .EQU NAK 21 + .EQU STX 2 + .EQU UART_REG 2048 + .EQU MON_ADDR 64512 + + BRANCH 2 ; the very first instruction is not + ; executed correctly + LOADCP 65020 ; initialise FP and RP registers + STOREREG FP + LOADCP 65024 + STOREREG RP + + LOADCP MON_ADDR + LOADCP 4096 + STOREI + DROP +CMDLOOP0: + LOADC MESSAGE + LOADC PRINTLINE + CALL + +CMDLOOP: + LOADC NEWLINE + CALL + LOADC PROMPT + CALL +CMDLOOP1: + LOADC CONIN + CALL + LOADC TOUPPER + CALL + + DUP + LOADC CONOUT + CALL + + LOADC 'A' + CMP.S0 EQ + CBRANCH.Z CMD1 + LOADC CMD_A + CALL + BRANCH CMDLOOP2 +CMD1: + LOADC 'X' + CMP.S0 EQ + CBRANCH.Z CMD2 + LOADC CMD_X + CALL + BRANCH CMDLOOP2 +CMD2: + LOADC 'D' + CMP.S0 EQ + CBRANCH.Z CMD3 + LOADC CMD_D + CALL + BRANCH CMDLOOP2 +CMD3: + LOADC 'G' + CMP.S0 EQ + CBRANCH.Z CMD4 + LOADC CMD_G + CALL + BRANCH CMDLOOP2 +CMD4: + LOADC 'L' + CMP.S0 EQ + CBRANCH.Z CMD5 + LOADC CMD_L + CALL + BRANCH CMDLOOP2 +CMD5: + LOADC 'B' + CMP.S0 EQ + CBRANCH.Z CMD6 + LOADC CMD_B + CALL + BRANCH CMDLOOP2 +CMD6: + DROP + BRANCH CMDLOOP0 +CMDLOOP2: + DROP + BRANCH CMDLOOP + +; ---- Command 'A': set current address +CMD_A: + LOADC 32 + LOADC CONOUT + CALL + LOADC READHEX + CALL + CBRANCH.Z CMD_A_INVALID ; 0 if not valid input + LOADCP MON_ADDR + SWAP + STOREI + DROP ; drop STOREI address + RET +CMD_A_INVALID: + DROP + LOADC '.' + LOADC CONOUT + CALL + RET + +; ---- Command 'X': examine current address +CMD_X: + FPADJ -8 ; reserve space for 4 bytes of local variables + LOADCP MON_ADDR + LOADI + STORE 0 ; current memory address + LOADC 4 ; print 8 words + STORE 4 ; Loop counter +CMD_X_LOOP: + LOADC 32 ; print a a space + LOADC CONOUT + CALL + LOAD 0 ; load word via current address + LOADI + LOADC PRINTHEXW ; print it + CALL + LOAD 0 + INC 4 ; increment current address + STORE 0 + LOAD 4 + DEC 1 + DUP + STORE 4 + CBRANCH.NZ CMD_X_LOOP + LOADCP MON_ADDR + LOAD 0 + STOREI + DROP + FPADJ 8 + RET + +; ---- Command 'D': deposit words at current address +CMD_D: + FPADJ -4 + LOADC 4 ; max number of words + STORE 0 +CMD_D_LOOP: + LOADC 32 ; print a space + LOADC CONOUT + CALL + LOADC READHEX + CALL + DUP + CBRANCH.Z CMD_D_EXIT ; check for invalid input + SWAP ; swap return code and value + LOADCP MON_ADDR + LOADI ; get current address + SWAP ; swap address and value for STOREI + STOREI 4 ; store the value with post-increment of address + LOADCP MON_ADDR + SWAP ; swap destination address and value for STOREI + STOREI ; store the new address + DROP + LOADC 2 ; compare return code (swapped above) to 2 + CMP EQ ; check for valid input and return key + CBRANCH CMD_D_EXIT + LOAD 0 + DEC 1 + DUP + STORE 0 + CBRANCH.NZ CMD_D_LOOP +CMD_D_EXIT: + FPADJ 4 + RET + +CMD_G: + DROP ; remove input char + LOADCP NEWLINE + CALL + LOADCP MON_ADDR + LOADI + JUMP + +CMD_L: + LOADCP NEWLINE + CALL + LOADCP RCVBLOCKS + CALL + LOADCP NEWLINE + CALL + RET + +PROMPT: + LOADC '[' + LOADC CONOUT + CALL + LOADCP MON_ADDR + LOADI + LOADC PRINTHEXW + CALL + LOADC PROMPT2 + LOADC PRINTLINE + CALL + RET + +NEWLINE: + LOADC CR + LOADC CONOUT + CALL + LOADC LF + LOADC CONOUT + CALL + RET + +; print string of byte characters +; takes pointer to string on eval stack +PRINTLINE: + DUP ; duplicate address as arg to printchar + LOADC PRINTCHAR + CALL + CBRANCH.Z PRINTLINE_EXIT ; if char is zero, exit + INC 1 ; increment address + BRANCH PRINTLINE +PRINTLINE_EXIT: + DROP ; remove address from stack + RET + +; print a single character +; takes a byte pointer on eval stack +; returns character on eval stack +PRINTCHAR: + LOADI.S1.X2Y ; load word, keep address on stack + BSEL ; select byte of a word via address + DUP ; check for null byte + CBRANCH.Z PRINTCHAR_XT + DUP + LOADC CONOUT + CALL +PRINTCHAR_XT: + RET + +; print a 32-bit hexadecimal number +; takes the value on the stack + +PRINTHEXW: + BROT + DUP + LOADC PRINTHEXB + CALL + BROT + DUP + LOADC PRINTHEXB + CALL + BROT + DUP + LOADC PRINTHEXB + CALL + BROT + LOADC PRINTHEXB + CALL + RET + +PRINTHEXB: + DUP + SHR + SHR + SHR + SHR + LOADC PRINTNIBBLE + CALL + LOADC PRINTNIBBLE + CALL + RET + +PRINTNIBBLE: + LOADC 15 + AND ; isolate nibble + LOADC 10 + CMPU.S0 GE ; nibble >= 10 ? + CBRANCH.NZ PRINTNIBBLE_1 ; then print a-f + LOADC '0' ; else print 0-9 + BRANCH PRINTNIBBLE_2 +PRINTNIBBLE_1: + LOADC 55 ; 55 + 10 == 'A' +PRINTNIBBLE_2: + ADD + LOADC CONOUT + CALL + RET + +; ------ read a 8-digit hexadecimal number from the console +; stores variables on the user stack, so the FP register must be +; inizialized. +; returns two values on the eval stack: +; - return code (topmost) +; 0 - no valid number +; 1 - valid number +; 2 - valid number and enter was pressed +; - result value + +READHEX: + FPADJ -8 + LOADC 0 ; current value + STORE 0 + LOADC 8 ; max number of digits + STORE 4 ; remaining digits counter +READHEX_1: + LOADC CONIN + CALL + LOADC CR ; RETURN pressed? + CMP.S0 EQ + CBRANCH READHEX_RT + DUP + LOADC CONOUT ; echo character + CALL + LOADC CONVHEXDIGIT + CALL + LOADC -1 + CMP.S0 EQ ; invalid character? + CBRANCH.NZ READHEX_XT + LOAD 0 + SHL 2 ; shift previous nibble + SHL 2 + OR ; combine with last digit + STORE 0 + LOAD 4 + DEC 1 + DUP + STORE 4 + CBRANCH.NZ READHEX_1 + BRANCH READHEX_XT1 +READHEX_RT: ; if no digits were entered, set return code + DROP ; drop read character + LOAD 4 ;remaining digits counter + LOADC 8 + CMP NE + CBRANCH READHEX_RT2 + LOADC 0 ; no valid input + BRANCH READHEX_XT3 +READHEX_RT2: + LOADC 2 ; valid input and return pressed + BRANCH READHEX_XT3 +READHEX_XT: + DROP + LOAD 4 + LOADC 8 + CMP EQ ; if no digits were entered + CBRANCH READHEX_XT0 +READHEX_XT1: + LOADC 1 ; valid input flag + BRANCH READHEX_XT3 +READHEX_XT0: + LOADC 0 +READHEX_XT3: + LOAD 0 + SWAP + FPADJ 8 + RET + +; ------ convert character on the eval stack to upper case +TOUPPER: + LOADC 'a' + CMP.S0 LT + CBRANCH TOUPPER_XT + LOADC 'z' + CMP.S0 GT + CBRANCH TOUPPER_XT + LOADC 32 + SUB +TOUPPER_XT: + RET + +; ------ convert hexadecimal digit to integer +; ------ takes an ascii character as parameter on the eval stack +; ------ returns an integer value from 0-15 on the eval stack, +; ------ or -1 if the character was not a valid hexadecimal digit + +CONVHEXDIGIT: + LOADC TOUPPER + CALL + LOADC '0' + CMP.S0 LT ; character < '0'? + CBRANCH.NZ CONVHEXDIGIT_ERR + LOADC '9' + CMP.S0 GT ; character > '9'? + CBRANCH.NZ CONVHEXDIGIT_ISALPHA + LOADC '0' ; character is between '0' and '9', subtract '0' + SUB + BRANCH CONVHEXDIGIT_NBL +CONVHEXDIGIT_ISALPHA: + LOADC 'A' + CMP.S0 LT ; character < 'A'? + CBRANCH.NZ CONVHEXDIGIT_ERR + LOADC 'F' + CMP.S0 GT ; character > 'F'? + CBRANCH.NZ CONVHEXDIGIT_ERR + LOADC 55 ; character is between 'A' and 'F', subtract ('A' - 10) + SUB +CONVHEXDIGIT_NBL: + RET +CONVHEXDIGIT_ERR: + DROP ; remove character from stack + LOADC -1 ; error + RET + +; --------- output a character on serial console +; --------- takes a character (padded to a word) on the eval stack +CONOUT: + LOADC UART_REG ; address of UART register + LOADI ; load status + LOADC 256 ; check bit 8 (tx_busy) + AND + CBRANCH.NZ CONOUT ; loop if bit 8 is not zero + + ; transmitter is idle now, write character + LOADC UART_REG ; address of UART register + SWAP ; swap character and address for STOREI + LOADC 1024 ; TX enable bit + OR ; OR in the character + STOREI + DROP + RET + +; ---- wait until a character is received and return it on eval stack +CONIN: + LOADC WAITFORBYTE + CALL + LOADC -1 ; -1 means timeout + CMP.S0 NE + CBRANCH CONIN_XT ; exit if no timeout + DROP ; remove last result + BRANCH CONIN +CONIN_XT: + RET + + + .EQU L_BLOCKSIZE 32 + .EQU L_WORDSIZE 4 + .EQU CKSUM_PATTERN $AFFECAFE +RCVBLOCKS: + LOADCP MON_ADDR ; pointer to current write position, + LOADI ; kept on stack +RCVBLOCKS_L: + LOADC WAITFORBYTE ; read header byte + CALL + LOADC -1 + CMP.S0 EQ + CBRANCH RCVBLOCKS_XT ; exit on timeout + + ; check for EOT -> end + LOADC EOT + CMP.S0 EQ + CBRANCH RCVBLOCKS_XT + + ; check for STX -> read block + LOADC STX + CMP.S0 EQ + CBRANCH RCVBLOCKS_CONT + + ; anything else -> send NAK + BRANCH RCVBLOCKS_RETRY + +RCVBLOCKS_CONT: + DROP ; remove header byte + DUP ; duplicate pointer + LOADC READBLOCK + CALL + LOADC -1 + CMP.S0 EQ ; check for timeout + CBRANCH RCVBLOCKS_XT ; exit on timeout + + LOADC -2 + CMP.S0 EQ ; check for checksum error + CBRANCH RCVBLOCKS_RETRY + + DROP ; remove return code + LOADC L_BLOCKSIZE ; advance pointer + ADD + + LOADC ACK ; send ACK + LOADC CONOUT + CALL + + ; next block + BRANCH RCVBLOCKS_L + +RCVBLOCKS_RETRY: + DROP ; remove read byte + ; send NAK + LOADC NAK + LOADC CONOUT + CALL + + ; next block + BRANCH RCVBLOCKS_L + +RCVBLOCKS_XT: + DROP ; remove pointer + DROP ; remove read byte + RET + + +; ---- read a sequence of binary words and store into memory +; - arguments: pointer to memory area +READBLOCK: + FPADJ -12 + STORE 0 ; buffer pointer + LOADCP L_BLOCKSIZE + STORE 4 ; remaining bytes + LOADC 0 + STORE 8 ; checksum +READBLOCK_L: + LOADCP READWORD ; read a word + CALL + LOADC -1 ; check for timeout + CMP EQ + CBRANCH.NZ READBLOCK_ERR + + ; DUP ; debug + ; LOADC PRINTHEXW + ; CALL + + + DUP ; duplicate read word + LOAD 8 ; load checksum + ADD ; checksum = ((checksum + data) ^ pattern) << 1 + LOADCP CKSUM_PATTERN + XOR + SHL + STORE 8 ; store new checkcsum + + LOAD 0 ; load buffer pointer + SWAP ; swap value and pointer for STOREI + STOREI 4 ; store word and increment pointer + STORE 0 ; store pointer + + LOAD 4 ; load remaining bytes + DEC L_WORDSIZE ; decrement by word size + DUP + STORE 4 ; store + CBRANCH.NZ READBLOCK_L ; loop if remaining words not zero + + + LOADCP READWORD ; read checksum + CALL + LOADC -1 ; check for timeout + CMP EQ + CBRANCH READBLOCK_ERR + + LOAD 8 ; load checksum + CMP EQ + CBRANCH READBLOCK_OK + LOADC -2 ; return code for checksum error + BRANCH READBLOCK_XT +READBLOCK_OK: + LOADC 0 ; return 0 +READBLOCK_XT: + FPADJ 12 + RET + +READBLOCK_ERR: + DROP ; remove result + LOAD 4 ; return number of missing bytes + FPADJ 8 + RET + +; --- read four bytes (msb to lsb) and return as word +; returns: word, error code (-1 for error, 0 otherwise) + +READWORD: + LOADCP WAITFORBYTE + CALL + DUP + LOADC -1 ; check for error + CMP EQ + CBRANCH.NZ READWORD_ERR + ; first byte is now on stack + BROT ; rotate byte left + + LOADCP WAITFORBYTE + CALL + DUP + LOADC -1 ; check for error + CMP EQ + CBRANCH.NZ READWORD_ERR + ; second byte is now on stack + OR ; OR last byte with this byte + BROT ; rotate bytes left + + LOADCP WAITFORBYTE + CALL + DUP + LOADC -1 ; check for error + CMP EQ + CBRANCH.NZ READWORD_ERR + ; third byte is now on stack + OR ; OR last byte with this byte + BROT + + LOADCP WAITFORBYTE + CALL + DUP + LOADC -1 ; check for error + CMP EQ + CBRANCH.NZ READWORD_ERR + ; fourth byte is now on stack + OR ; OR last byte with this byte + + LOADC 0 ; error code (0: no error) + RET + +READWORD_ERR: + LOADC -1 ; error code + RET + +;---- wait a fixed amount of cycles for a character to be +; received on the UART. +; returns character or -1 on timeout + + .EQU MAX_WAIT 20000000 +WAITFORBYTE: + LOADCP MAX_WAIT ; maximum wait loops +WAITFORBYTE_L: + LOADC UART_REG ; address of UART register + LOADI ; load status + LOADC 512 ; check bit 9 (rx_avail) + AND + CBRANCH WAITFORBYTE_RX ; if bit 9 is one, a character is available + DEC 1 + DUP + CBRANCH.NZ WAITFORBYTE_L + DROP ; remove wait counter from stack + LOADC -1 ; error code + RET +WAITFORBYTE_RX: + DROP ; remove wait counter from stack + LOADC UART_REG + LOADI ; read register again + LOADC 255 ; mask status bits + AND + LOADC UART_REG ; I/O address + LOADC 512 ; set bit 9 (rx_clear) + STOREI ; write register + DROP ; remove address left by STOREI + RET + + .CPOOL + +;---- boot from SD-card + + ; declare buffer addresses used by sdcardlib.s + .EQU CSD_BUF 63984 + .EQU CARD_BUF 64000 +CMD_B: + DROP ; remove input char + LOADCP NEWLINE + CALL + + FPADJ -4 + ; initialize card + LOADC INITSDCARD + CALL + + ; read partition block + LOADC 0 + LOADC CARDREADBLK + CALL + + DUP ; non-zero return code means error + CBRANCH.Z CMD_B_1 +CMD_B_ERR: + LOADC PRINTHEXW ; print error code + CALL + LOADC NEWLINE + CALL + LOADC 0 ; if we return, we need to + ; put a fake input char back on the + ; stack because the main loop will + ; try to remove it + FPADJ 4 + RET + +CMD_B_1: + DROP ; remove error code + ; check boot partition slot (boot flag) + LOADCP CARD_BUF,104 ; offset partition flags second part slot + LOADI + LOADC 2 ; PartFlags [PartBoot] + CMP EQ + CBRANCH CMD_B_C + + ; no boot partition + LOADC $B0 + BRANCH CMD_B_ERR + +CMD_B_C: + ; get start block + LOADCP CARD_BUF,108 ; offset startBlock + LOADI + ; get block count + LOADCP CARD_BUF,124 ; offset bootBlocks + LOADI + + FPADJ -4 ; allocate space for address var + LOADCP MON_ADDR + LOADI + STORE 0 ; initialize dest addr +CMD_B_L: + ; read block + OVER ; duplicate block no + LOADC CARDREADBLK + CALL + + DUP ; check for error + CBRANCH.Z CMD_B_C2 ; continue if zero (no error) + + NIP ; remove start and count, keep error code + NIP + BRANCH CMD_B_ERR +CMD_B_C2: DROP ; remove error code +CMD_B_2: + ; copy to destination + LOAD 0 ; dest addr + LOADC COPY_BLK + CALL + + ; decrement count and loop + LOAD 0 ; increment dest addr + LOADC 512 + ADD + STORE 0 + + SWAP ; swap block no/count, blockno is now ToS + INC 1 + SWAP ; count is now ToS + DEC 1 + DUP + CBRANCH.NZ CMD_B_L ; if not zero, loop + + ; jump to coreloader + DROP + DROP + FPADJ 4 + LOADCP MON_ADDR + LOADI + JUMP + +CMD_B_XT: + FPADJ 4 + RET + +; copy a sdcard block to destination address +; block size is always 512 byte, source +; is always CARD_BUF +; parameters: dest addr +COPY_BLK: + FPADJ -4 + LOADC 128 ; word count + STORE 0 + + LOADCP CARD_BUF ; src addr +COPY_BLK1: + SWAP + ; [ src addr, dest addr ] + OVER ; [ saddr, daddr, saddr ] + LOADI ; [ saddr, daddr, sword ] + STOREI 4 ; [ saddr, daddr + 4 ] + SWAP ; [ daddr + 4, saddr ] + INC 4 ; [ daddr + 4, saddr + 4] + + LOAD 0 ; load and decrement counter + DEC 1 + DUP + STORE 0 ; store it again + CBRANCH.NZ COPY_BLK1 ; if not zero, loop + + DROP ; remove saddr and daddr + DROP + + FPADJ 4 + RET + + .CPOOL + +; wait approx. 1 millisecond +; +; 83.333 MHz Clock, three instructions a 4 cycles +; 83333 / 12 = 6944.4166 +; works only if executed without wait states (i.e. +; from BRAM/SRAM) +WAIT1MSEC: + LOADCP 6944 +WAIT1LOOP: + DEC 1 + DUP + CBRANCH.NZ WAIT1LOOP + DROP + RET + +%include "sdcardboot.s" + .CPOOL +MESSAGE: + .BYTE 13,10,"ROM Monitor v3.0.3", 13, 10, + "Set A)ddress D)eposit eX)amine L)oad G)o B)oot",13,10,0 +PROMPT2: + .BYTE "]> ",0 +END: diff --git a/lib/sdcardboot.s b/lib/sdcardboot.s new file mode 100644 index 0000000..f3b7c9c --- /dev/null +++ b/lib/sdcardboot.s @@ -0,0 +1,613 @@ + .EQU SPIREG $880 + + .EQU SPI_CTRL_WRITE %100000000000000 + .EQU SPI_RX_FILTER_EN %010000000000000 + .EQU SPI_TXRX_EN %001000000000000 + .EQU SPI_CLK_F_EN %000100000000000 + .EQU SPI_CLK_DIV_WR %000010000000000 + .EQU SPI_RX_RD %000001000000000 + .EQU SPI_TX_WR %000000100000000 + + .EQU SPI_C_D %100000000000000 + .EQU SPI_C_CHG %010000000000000 + .EQU SPDI_C_BUSY %001000000000000 + .EQU SPI_TX_RDY %000100000000000 + .EQU SPI_TX_EMPTY %000010000000000 + .EQU SPI_RX_AVAIL %000001000000000 + .EQU SPI_RX_OVR %000000100000000 + + .EQU SPI_TXRX_EN_MASK ~SPI_TXRX_EN + +_WAIT: + LOADC 10 +_WAITL: + LOADC WAIT1MSEC + CALL + DEC 1 + DUP + CBRANCH.NZ _WAITL + DROP + RET + +INITSDCARD: + LOADC WAIT1MSEC + CALL + + LOADC _SPIINIT1 + CALL + + ;LOADC 'I' + ;LOADCP CONOUT + ;CALL + + LOADC _WAITSPITXRDY + CALL + + ;LOADC 'W' + ;LOADCP CONOUT + ;CALL + + ; send RESET CARD command + LOADC $95 ; send cmd0 with arg 0 and checksum $95 + LOADC $0 + LOADC $0 + LOADC SENDCMD_R1 + CALL + + DROP ; TODO: handle errors + ;LOADCP PRINTHEXW ; print status returned by the card + ;CALL + ;LOADCP NEWLINE + ;CALL + + ;LOADC '9' + ;LOADCP CONOUT + ;CALL + + LOADC _WAITSPITXRDY + CALL + + LOADC _WAIT + CALL + + ;LOADC '1' + ;LOADCP CONOUT + ;CALL + + LOADC $87 + LOADC $01AA + LOADC $8 + LOADC SENDCMD_R7 + CALL + + DROP + + LOADC _WAITSPITXRDY + CALL + + ;LOADC '2' + ;LOADCP CONOUT + ;CALL + + ;LOADCP _WAIT + ;CALL + + ;LOADC '.' + ;LOADCP CONOUT + ;CALL + + LOADC CARDINITV2 + CALL + + ;LOADC '+' + ;LOADCP CONOUT + ;CALL + + + LOADC CARDFASTCLK + CALL + + ;LOADC '3' + ;LOADCP CONOUT + ;CALL + + ; CMD16: set block size to 512 byte + LOADC 0 + LOADC 512 + LOADC 16 + LOADCP SENDCMD_R1 + CALL + + DROP + + ;LOADCP _WAIT + ;CALL + + ;LOADC '4' + ;LOADCP CONOUT + ;CALL + + RET + +; read a 512-byte-block from the card +; args: block number +; returns: 0 on success +CARDREADBLK: + LOADC 128 ; number of words in a block + SWAP ; move block number up the stack + LOADCP CARD_BUF + SWAP + LOADC 0 + SWAP + LOADC 17 ; CMD17: read block + LOADC SENDCMD_PKT + CALL + RET + +; send the card initialization command +; wait until the card responds +CARDINITV2: + LOADC 100 ; try up to 100 times +CARD_LOOP1: + LOADC 50 ; wait 50 msec +CARD_LOOP2: + LOADC WAIT1MSEC + CALL + DEC 1 + DUP + CBRANCH.NZ CARD_LOOP2 + DROP ; remove loop count value + + LOADC $0 + LOADC $0 + LOADC 58 + LOADC SENDCMD_R7 ; send CMD58 + CALL + DROP ; ignore result (why?) + + LOADC $0 + LOADCP $40000000 + LOADC 41 + LOADC SENDACMD_R1 ; send ACMD41 + CALL + + CBRANCH.Z CARD_OK ; if result is zero, the command succeded + ; and the card initialization is finished + DEC 1 + DUP + CBRANCH.NZ CARD_LOOP1 + DROP ; remove outer loop count value + + RET +CARD_OK: + DROP ; remove outer loop count value + + ; CMD16: set block size to 512 byte + LOADC 0 + LOADC 512 + LOADC 16 + LOADC SENDCMD_R1 + CALL + DROP ; ignore return value + + RET + +; set fast transfer rate +CARDFASTCLK: + LOADC SPIREG + ; set clock divider to ~2,6MHz + LOADC SPI_CLK_DIV_WR+10 + STOREI + DROP + RET + +; perform first phase of card initialization +; which is to enable clock and wait a bit +; leaves the clock running +_SPIINIT1: + LOADC SPIREG + ; set clock divider to ~325KHz + LOADC SPI_CLK_DIV_WR+64 + STOREI + DROP + + ; clear all flags + enable clock + ; /CS and MOSI are default high + LOADC SPIREG + LOADCP SPI_CTRL_WRITE,SPI_CLK_F_EN + STOREI + DROP + + ; we should wait at least for 74 clock cycles now + LOADC 2 ; wait 2 msec, that should be ~300 cycles +_SPIINIT1L: + LOADC WAIT1MSEC + CALL + DEC 1 + DUP + CBRANCH.NZ _SPIINIT1L + DROP + + LOADC SPIREG + LOADCP SPI_CTRL_WRITE ; disable clock + STOREI + DROP + + LOADCP WAIT1MSEC + CALL + + RET + +; wait for transmission to finish +; (wait for TX_EMPTY bit) +_SPIWAITTX: + LOADC SPIREG + LOADI + LOADCP SPI_TX_EMPTY + AND + CBRANCH.Z _SPIWAITTX + RET + +; finalize a command that has been sent: +; wait until the transmitter is idle +; then disable clock and set MOSI high +_SPIENDCMD: + LOADC $FF + LOADC _SENDBYTE + CALL + LOADC $FF + LOADC _SENDBYTE + CALL + + ;LOADC 'E' + ;LOADCP CONOUT + ;CALL + + LOADC _SPIWAITTX + CALL + + ;LOADC 'w' + ;LOADCP CONOUT + ;CALL + LOADC _WAIT_S ; wait a short time + CALL + + LOADC SPIREG + LOADCP SPI_IDLE_FLAGS ; turn off transceiver + LOADI + STOREI + DROP + + ; wait for a few instructions + LOADC 100 +SPIEND_LP: DEC 1 + DUP + CBRANCH.NZ SPIEND_LP + DROP + + RET + +_WAIT_S: + LOADC 100 +_WAIT_S_L: + DEC 1 + DUP + CBRANCH.NZ _WAIT_S_L + DROP + RET + +; clear RX fifo +CLEAR_RX_FIFO: +CLEAR_RX_L1: + LOADC SPIREG + LOADI + + ;DUP + ;LOADCP PRINTHEXW + ;CALL + ;LOADCP NEWLINE + ;CALL + + LOADC SPI_RX_AVAIL + AND + CBRANCH.Z CLEAR_RX_X + LOADC SPIREG + LOADC SPI_RX_RD + STOREI + DROP + + ; FIXME: it seems that this + ; does not remove a byte from the fifo, + ; rx_avail stays on, but only after the first + ; byte has been received and read + + ;LOADC 'x' + ;LOADCP CONOUT + ;CALL + + BRANCH CLEAR_RX_L1 +CLEAR_RX_X: + RET + +_WAITSPITXRDY: + LOADC SPIREG + LOADI + LOADCP SPI_TX_RDY + AND + CBRANCH.Z _WAITSPITXRDY + RET + +; send a command and receive a data packet response +; args: packet size in words, buffer pointer +; checksum byte, 32-bit cmd arg, cmd number +; returns: 0 on success +SENDCMD_PKT: + ; first send the command + LOADC SENDCMD_0 + CALL + + LOADC _RCVBYTE ; receive R1 response + CALL + + CBRANCH.NZ SENDCMD_PKT_E ; on success we get 0 + + ; now wait for data token +SENDCMD_PKT_L: + LOADC _RCVBYTE + CALL + LOADC $FF + CMP EQ + CBRANCH SENDCMD_PKT_L + + ; parameters for _RCVWORDS are on the stack now + LOADC _RCVWORDS + CALL + + ; receive 2 crc bytes + LOADC _RCVBYTE + CALL + BROT + LOADC _RCVBYTE + CALL + OR + + ; terminate command + LOADC _SPIENDCMD + CALL + + DROP ; we ignore the checksum for now + + LOADC 0 + RET +SENDCMD_PKT_E: + DROP ; remove remaining args + DROP + LOADC -1 ; return code for error + RET + +; send a command and receive a 1-byte-response (R1) +; args: checksum byte, 32-bit cmd arg, cmd number +; returns: received byte +SENDCMD_R1: + LOADC SENDCMD_0 + CALL + + LOADC _RCVBYTE + CALL + + ;LOADC 'R' + ;LOADCP CONOUT + ;CALL + + ;terminate command (/cs high, disable clock) + LOADC _SPIENDCMD + CALL + + RET + +; send a command +; args: checksum byte, 32-bit cmd arg, cmd number +SENDCMD_0: + ; clear RX FIFO first + LOADC CLEAR_RX_FIFO + CALL + + ;LOADC '>' + ;LOADCP CONOUT + ;CALL + + ; cmd byte is at TOS at this point + LOADC $40 ; or in start of frame bit + OR + LOADC _SENDBYTE + CALL + ; cmd arg is at TOS now + LOADC _SENDWORD + CALL + ; checksum byte is at TOS now + LOADC _SENDBYTE + CALL + + LOADC _XCVR_ENABLE ; enable transceiver last, + CALL ; a complete command should + RET ; fit into the tx fifo + +; send ACMD and receive a 1-byte-response (R1) +; args: checksum byte, 32-bit cmd arg, ACMD number +; returns: received byte or -1 if first response byte +; indicated an error +SENDACMD_R1: + LOADC $0 + LOADC $0 + LOADC 55 ; send CMD55 + LOADC SENDCMD_R1 + CALL + + LOADC 1 ; 1 = idle state, no errors + CMP NE + CBRANCH.NZ SENDACMD_ERR + + ; pass our args to SENDCMD_R1 + LOADC SENDCMD_R1 + CALL + RET + +SENDACMD_ERR: + LOADCP -1 + RET + +; send a command and receive a 4+1-byte-response (R7) +; args: checksum byte, 32-bit cmd arg, cmd number +; returns: received word or -1 if first response byte +; indicated an error + +SENDCMD_R7: + ; send the command + LOADC SENDCMD_0 + CALL + + ;LOADC '7' + ;LOADCP CONOUT + ;CALL + + LOADC _RCVBYTE + CALL + + LOADC _RCVWORD + CALL + + ;terminate command (/cs high, disable clock) + LOADC _SPIENDCMD + CALL + + SWAP ; swap 1st response byte with received word + LOADC %011111110 ; check for any error flags + AND + CBRANCH.Z SENDCMD_R7_NOERR + DROP + LOADC -1 +SENDCMD_R7_NOERR: + RET + +; send a word as 4 bytes, msb first +_SENDWORD: + DUP ; remember original value for later + + BROT ; rotate msb to lsb (byte 0) + LOADC 255 + AND.S0 ; isolate byte, keep previous value + LOADC _SENDBYTE + CALL + + BROT ; byte 1 + LOADC 255 + AND.S0 + LOADC _SENDBYTE + CALL + + BROT ; byte 2 + LOADC 255 + AND + LOADC _SENDBYTE + CALL + + ; byte 3 is already on the stack + LOADC 255 + AND + LOADC _SENDBYTE + CALL + + RET + +; receive multiple 4-byte-words and store into +; memory buffer +; args: number of words, pointer to buffer +_RCVWORDS: + FPADJ -4 + STORE 0 ; store pointer arg into local variable + ; keep counter on stack +_RCVWORDS_LP: + LOAD 0 ; load buf pointer for STOREI + LOADC _RCVWORD + CALL ; receive a word + STOREI 4 ; store to buf with postincrement + STORE 0 ; store pointer variable + + DEC 1 ; decrement word counter + DUP + CBRANCH.NZ _RCVWORDS_LP ; if not null, loop + DROP ; remove counter value + + FPADJ 4 + RET + +; receive 4 bytes, return as word +_RCVWORD: + LOADC _RCVBYTE ; receive first byte + CALL + BROT ; rotate byte to left + + LOADC _RCVBYTE ; receive second byte + CALL + OR ; or first and second byte together + BROT ; rotate 1st + 2nd to left + + LOADC _RCVBYTE ; receive third byte + CALL + OR + BROT + + LOADCP _RCVBYTE ; receive fourth byte + CALL + OR + RET + +_XCVR_ENABLE: + LOADC SPIREG + LOADC SPI_TX_FLAGS + LOADI + STOREI + DROP + RET + +; send a byte +; args: byte to be sent +_SENDBYTE: + LOADC SPIREG + LOADI ; load spi io register + LOADCP SPI_TX_RDY + AND ; check tx_rdy bit + CBRANCH.Z _SENDBYTE ; if not set, loop + + LOADC SPI_TX_WR ; TX_WR bit + OR ; OR in byte to be send + + LOADC SPIREG + SWAP ; swap value and addr for STOREI + STOREI ; store word (flags + data) to io register + DROP ; remove STOREI result + + RET + +; receive a byte. receiver must be enabled. +; returns: received byte +_RCVBYTE: + LOADC SPIREG + LOADI ; load spi io register + LOADC SPI_RX_AVAIL + AND.S0 ; check rx_avail bit, keep original value + CBRANCH.NZ RECVGOTIT + DROP ; rx_avail not set, remove register value and loop + BRANCH _RCVBYTE +RECVGOTIT: + LOADC SPIREG + LOADC SPI_RX_RD ; remove one byte from rx fifo + STOREI + DROP + + LOADC 255 + AND ; keep bits 7-0 + RET + +SPI_TX_FLAGS: .WORD SPI_CTRL_WRITE + SPI_TXRX_EN + SPI_RX_FILTER_EN +SPI_IDLE_FLAGS: .WORD SPI_CTRL_WRITE diff --git a/lib/sdcardlib.s b/lib/sdcardlib.s new file mode 100644 index 0000000..9b45e05 --- /dev/null +++ b/lib/sdcardlib.s @@ -0,0 +1,795 @@ +; Copyright 2021-2024 Sebastian Lederer. See the file LICENSE.md for details + .EQU SPIREG $880 + + .EQU SPI_CTRL_WRITE %100000000000000 + .EQU SPI_RX_FILTER_EN %010000000000000 + .EQU SPI_TXRX_EN %001000000000000 + .EQU SPI_CLK_F_EN %000100000000000 + .EQU SPI_CLK_DIV_WR %000010000000000 + .EQU SPI_RX_RD %000001000000000 + .EQU SPI_TX_WR %000000100000000 + + .EQU SPI_C_D %100000000000000 + .EQU SPI_C_CHG %010000000000000 + .EQU SPDI_C_BUSY %001000000000000 + .EQU SPI_TX_RDY %000100000000000 + .EQU SPI_TX_EMPTY %000010000000000 + .EQU SPI_RX_AVAIL %000001000000000 + .EQU SPI_RX_OVR %000000100000000 + + .EQU SPI_TXRX_EN_MASK ~SPI_TXRX_EN + +_WAIT: + LOADC 10 +_WAITL: + LOADCP WAIT1MSEC + CALL + DEC 1 + DUP + CBRANCH.NZ _WAITL + DROP + RET + +INITSDCARD: + LOADCP WAIT1MSEC + CALL + + LOADCP _SPIINIT1 + CALL + + ;LOADC 'I' + ;LOADCP CONOUT + ;CALL + + LOADCP _WAITSPITXRDY + CALL + + ;LOADC 'W' + ;LOADCP CONOUT + ;CALL + + ; send RESET CARD command + LOADC $95 ; send cmd0 with arg 0 and checksum $95 + LOADC $0 + LOADC $0 + LOADCP SENDCMD_R1 + CALL + + DROP ; TODO: handle errors + ;LOADCP PRINTHEXW ; print status returned by the card + ;CALL + ;LOADCP NEWLINE + ;CALL + + ;LOADC '9' + ;LOADCP CONOUT + ;CALL + + LOADCP _WAITSPITXRDY + CALL + + LOADCP _WAIT + CALL + + ;LOADC '1' + ;LOADCP CONOUT + ;CALL + + LOADC $87 + LOADC $01AA + LOADC $8 + LOADCP SENDCMD_R7 + CALL + + DROP + + LOADCP _WAITSPITXRDY + CALL + + ;LOADC '2' + ;LOADCP CONOUT + ;CALL + + ;LOADCP _WAIT + ;CALL + + ;LOADC '.' + ;LOADCP CONOUT + ;CALL + + LOADCP CARDINITV2 + CALL + + ;LOADC '+' + ;LOADCP CONOUT + ;CALL + + + LOADCP CARDFASTCLK + CALL + + ;LOADC '3' + ;LOADCP CONOUT + ;CALL + + ; CMD16: set block size to 512 byte + LOADC 0 + LOADC 512 + LOADC 16 + LOADCP SENDCMD_R1 + CALL + + DROP + + ;LOADCP _WAIT + ;CALL + + ;LOADC '4' + ;LOADCP CONOUT + ;CALL + + RET + +; read a 512-byte-block from the card +; args: block number +; returns: 0 on success +CARDREADBLK: + LOADC 128 ; number of words in a block + SWAP ; move block number up the stack + LOADCP CARD_BUF + SWAP + LOADC 0 + SWAP + LOADC 17 ; CMD17: read block + LOADCP SENDCMD_PKT + CALL + RET + +; determine number of blocks +; returns: number of blocks or -1 on error +CARDSIZE: + LOADC 4 + LOADCP CSD_BUF + LOADC 0 + LOADC 0 + LOADC 9 + LOADCP SENDCMD_PKT ; send CMD9 + CALL + + CBRANCH.NZ CARDSIZE_ERR ; if response is zero, an error occurred + + ; take bytes 7, 8 and 9 from CSD data + ; and add 1 to get card size in ksectors + LOADCP CSD_BUF + INC 4 + LOADI + LOADC $3F ; get byte 7 (bits 22-16) + AND + BROT + BROT + + LOADCP CSD_BUF ; get bytes 8 and 9 (bits 15-0) + INC 8 + LOADI + BROT + BROT + LOADCP $FFFF + AND + + OR + + INC 1 + + BROT + SHL 2; multiply by 1024 to get size in sectors + + RET + +CARDSIZE_ERR: + LOADC -1 + RET + +; returns 1 if the card was changed, 0 otherwise +CARDCHANGED: + LOADCP SPIREG + LOADI + LOADCP SPI_C_CHG + AND + LOADC 0 + CMPU NE + RET + +; write a 512-byte-block to the card +; args: block number +; returns: 0 on success +CARDWRITEBLK: + LOADC 128 ; number of words in a block + SWAP ; move block number up the stack + LOADCP CARD_BUF + SWAP + LOADC 0 + SWAP + LOADC 24 ; CMD24: write block + LOADCP SENDCMD_TXPKT + CALL + RET +; send the card initialization command +; wait until the card responds +CARDINITV2: + LOADC 100 ; try up to 100 times +CARD_LOOP1: + LOADC 50 ; wait 50 msec +CARD_LOOP2: + LOADCP WAIT1MSEC + CALL + DEC 1 + DUP + CBRANCH.NZ CARD_LOOP2 + DROP ; remove loop count value + + LOADC $0 + LOADC $0 + LOADC 58 + LOADCP SENDCMD_R7 ; send CMD58 + CALL + DROP ; ignore result (why?) + + LOADC $0 + LOADCP $40000000 + LOADC 41 + LOADCP SENDACMD_R1 ; send ACMD41 + CALL + + CBRANCH.Z CARD_OK ; if result is zero, the command succeded + ; and the card initialization is finished + DEC 1 + DUP + CBRANCH.NZ CARD_LOOP1 + DROP ; remove outer loop count value + + RET +CARD_OK: + DROP ; remove outer loop count value + + ; CMD16: set block size to 512 byte + LOADC 0 + LOADC 512 + LOADC 16 + LOADCP SENDCMD_R1 + CALL + DROP ; ignore return value + + RET + +; set fast transfer rate +CARDFASTCLK: + LOADC SPIREG + ; set clock divider to ~2,6MHz + LOADCP SPI_CLK_DIV_WR,10 ; using the LOADCP with offset syntax here + STOREI + DROP + RET + +; perform first phase of card initialization +; which is to enable clock and wait a bit +; leaves the clock running +_SPIINIT1: + LOADC SPIREG + ; set clock divider to ~325KHz + LOADCP SPI_CLK_DIV_WR,64 ; LOADCP with offset + STOREI + DROP + + ; clear all flags + enable clock + ; /CS and MOSI are default high + LOADC SPIREG + LOADCP SPI_CTRL_WRITE,SPI_CLK_F_EN + STOREI + DROP + + ; we should wait at least for 74 clock cycles now + LOADC 2 ; wait 2 msec, that should be ~300 cycles +_SPIINIT1L: + LOADCP WAIT1MSEC + CALL + DEC 1 + DUP + CBRANCH.NZ _SPIINIT1L + DROP + + LOADC SPIREG + LOADCP SPI_CTRL_WRITE ; disable clock + STOREI + DROP + + LOADCP WAIT1MSEC + CALL + + RET + +; wait for transmission to finish +; (wait for TX_EMPTY bit) +_SPIWAITTX: + LOADC SPIREG + LOADI + LOADCP SPI_TX_EMPTY + AND + CBRANCH.Z _SPIWAITTX + RET + +; finalize a command that has been sent: +; wait until the transmitter is idle +; then disable clock and set MOSI high +_SPIENDCMD: + LOADCP $FF + LOADCP _SENDBYTE + CALL + LOADCP $FF + LOADCP _SENDBYTE + CALL + + ;LOADC 'E' + ;LOADCP CONOUT + ;CALL + + LOADCP _SPIWAITTX + CALL + + ;LOADC 'w' + ;LOADCP CONOUT + ;CALL + LOADCP _WAIT_S ; wait a short time + CALL + + LOADC SPIREG + LOADCP SPI_IDLE_FLAGS ; turn off transceiver + LOADI + STOREI + DROP + + ; wait for a few instructions + LOADC 100 +SPIEND_LP: DEC 1 + DUP + CBRANCH.NZ SPIEND_LP + DROP + + RET + +_WAIT_S: + LOADC 100 +_WAIT_S_L: + DEC 1 + DUP + CBRANCH.NZ _WAIT_S_L + DROP + RET + +; clear RX fifo +CLEAR_RX_FIFO: +CLEAR_RX_L1: + LOADC SPIREG + LOADI + + ;DUP + ;LOADCP PRINTHEXW + ;CALL + ;LOADCP NEWLINE + ;CALL + + LOADC SPI_RX_AVAIL + AND + CBRANCH.Z CLEAR_RX_X + LOADC SPIREG + LOADC SPI_RX_RD + STOREI + DROP + + ; FIXME: it seems that this + ; does not remove a byte from the fifo, + ; rx_avail stays on, but only after the first + ; byte has been received and read + + ;LOADC 'x' + ;LOADCP CONOUT + ;CALL + + BRANCH CLEAR_RX_L1 +CLEAR_RX_X: + RET + +_WAITSPITXRDY: + LOADC SPIREG + LOADI + LOADCP SPI_TX_RDY + AND + CBRANCH.Z _WAITSPITXRDY + RET + +; send a command and receive a data packet response +; args: packet size in words, buffer pointer +; checksum byte, 32-bit cmd arg, cmd number +; returns: 0 on success +SENDCMD_PKT: + ; first send the command + LOADCP SENDCMD_0 + CALL + + LOADCP _RCVBYTE ; receive R1 response + CALL + + CBRANCH.NZ SENDCMD_PKT_E ; on success we get 0 + + ; now wait for data token +SENDCMD_PKT_L: + LOADCP _RCVBYTE + CALL + LOADC $FF + CMP EQ + CBRANCH SENDCMD_PKT_L + + ; parameters for _RCVWORDS are on the stack now + LOADCP _RCVWORDS + CALL + + ; receive 2 crc bytes + LOADCP _RCVBYTE + CALL + BROT + LOADCP _RCVBYTE + CALL + OR + + ; terminate command + LOADCP _SPIENDCMD + CALL + + DROP ; we ignore the checksum for now + + LOADC 0 + RET +SENDCMD_PKT_E: + DROP ; remove remaining args + DROP + LOADC -1 ; return code for error + RET + +; send a command and send a data packet +; args: packet size in words, buffer pointer +; checksum byte, 32-bit cmd arg, cmd number +; returns: 0 on success +SENDCMD_TXPKT: + ; first send the command + LOADCP SENDCMD_0 + CALL + + ;LOADCP _RCVBYTE + ;CALL + ;DROP ; remove byte received during transmit + + LOADCP _RCVBYTE ; receive R1 response + CALL + + CBRANCH.NZ SENDCMD_TXPKT_E ; on error we get nonzero + + ; send stuff byte + LOADC $FF + LOADCP _SENDBYTE + CALL + + ; now send data token + LOADCP %11111110 + LOADCP _SENDBYTE + CALL + + ; send data block + ; parameters for _SENDWORDS are on the stack now + LOADCP _SENDWORDS + CALL + + ; send 2 dummy crc bytes + LOADC 0 + LOADCP _SENDBYTE + CALL + LOADC 0 + LOADCP _SENDBYTE + CALL + + ;receive data response byte +SENDCMD_TXPKT_LR: + LOADCP _RCVBYTE + CALL + LOADC $FF ; discard $FF bytes + CMP.S0 NE + CBRANCH SENDCMD_TXPKT_CT + DROP + BRANCH SENDCMD_TXPKT_LR + +SENDCMD_TXPKT_CT: + LOADC $1F + AND ; isolate status bits + LOADC $5 ; command accepted bit set? + CMP NE ; if not, exit with error + CBRANCH SENDCMD_TXPKT_E2 + + ; wait until card is busy +SENDCMD_TXPKT_LB: + LOADCP _RCVBYTE ; receive byte + CALL + CBRANCH.NZ SENDCMD_TXPKT_LB ; loop until byte is 0 + ; wait until card is not busy +SENDCMD_TXPKT_L2: + LOADCP _RCVBYTE ;receive byte + CALL + CBRANCH.Z SENDCMD_TXPKT_L2 ; loop if byte is 0 (i.e. MISO is held low) + + LOADC 0 + BRANCH SENDCMD_TXPKT_X + +SENDCMD_TXPKT_E: + DROP ; remove remaining args + DROP +SENDCMD_TXPKT_E2: + LOADC -1 ; return code for error +SENDCMD_TXPKT_X: + ; terminate command + LOADCP _SPIENDCMD + CALL + + RET + +; send a command and receive a 1-byte-response (R1) +; args: checksum byte, 32-bit cmd arg, cmd number +; returns: received byte +SENDCMD_R1: + LOADCP SENDCMD_0 + CALL + + LOADCP _RCVBYTE + CALL + + ;LOADC 'R' + ;LOADCP CONOUT + ;CALL + + ;terminate command (/cs high, disable clock) + LOADCP _SPIENDCMD + CALL + + RET + +; send a command +; args: checksum byte, 32-bit cmd arg, cmd number +SENDCMD_0: + ; clear RX FIFO first + LOADCP CLEAR_RX_FIFO + CALL + + ;LOADC '>' + ;LOADCP CONOUT + ;CALL + + ; cmd byte is at TOS at this point + LOADC $40 ; or in start of frame bit + OR + LOADCP _SENDBYTE + CALL + ; cmd arg is at TOS now + LOADCP _SENDWORD + CALL + ; checksum byte is at TOS now + LOADCP _SENDBYTE + CALL + + LOADCP _XCVR_ENABLE ; enable transceiver last, + CALL ; a complete command should + RET ; fit into the tx fifo + +; send ACMD and receive a 1-byte-response (R1) +; args: checksum byte, 32-bit cmd arg, ACMD number +; returns: received byte or -1 if first response byte +; indicated an error +SENDACMD_R1: + LOADC $0 + LOADC $0 + LOADC 55 ; send CMD55 + LOADCP SENDCMD_R1 + CALL + + LOADC 1 ; 1 = idle state, no errors + CMP NE + CBRANCH.NZ SENDACMD_ERR + + ; pass our args to SENDCMD_R1 + LOADCP SENDCMD_R1 + CALL + RET + +SENDACMD_ERR: + LOADCP -1 + RET + +; send a command and receive a 4+1-byte-response (R7) +; args: checksum byte, 32-bit cmd arg, cmd number +; returns: received word or -1 if first response byte +; indicated an error + +SENDCMD_R7: + ; send the command + LOADCP SENDCMD_0 + CALL + + ;LOADC '7' + ;LOADCP CONOUT + ;CALL + + LOADCP _RCVBYTE + CALL + + LOADCP _RCVWORD + CALL + + ;terminate command (/cs high, disable clock) + LOADCP _SPIENDCMD + CALL + + SWAP ; swap 1st response byte with received word + LOADC %011111110 ; check for any error flags + AND + CBRANCH.Z SENDCMD_R7_NOERR + DROP + LOADC -1 +SENDCMD_R7_NOERR: + RET + +; send a word as 4 bytes, msb first +_SENDWORD: + DUP ; remember original value for later + + BROT ; rotate msb to lsb (byte 0) + LOADC 255 + AND.S0 ; isolate byte, keep previous value + LOADCP _SENDBYTE + CALL + + BROT ; byte 1 + LOADC 255 + AND.S0 + LOADCP _SENDBYTE + CALL + + BROT ; byte 2 + LOADC 255 + AND + LOADCP _SENDBYTE + CALL + + ; byte 3 is already on the stack + LOADC 255 + AND + LOADCP _SENDBYTE + CALL + + RET + +; send multiple 4-byte-words +; args: number of words, pointer to buffer +_SENDWORDS: + FPADJ -4 + STORE 0 ; store pointer arg into local variable + ; keep counter on stack +_SENDWORDS_LP: + LOAD 0 ; load buf pointer + DUP ; duplicate it + INC 4 ; increment pointer + STORE 0 ; and store it back + LOADI ; load from previously duped pointer + LOADCP _SENDWORD + CALL ; send a word + + DEC 1 ; decrement word counter + DUP + CBRANCH.NZ _SENDWORDS_LP ; if not null, loop + DROP ; remove counter value + + FPADJ 4 + RET + +; receive multiple 4-byte-words and store into +; memory buffer +; args: number of words, pointer to buffer +_RCVWORDS: + FPADJ -4 + STORE 0 ; store pointer arg into local variable + ; keep counter on stack +_RCVWORDS_LP: + LOAD 0 ; load buf pointer for STOREI + LOADCP _RCVWORD + CALL ; receive a word + STOREI 4 ; store to buf with postincrement + STORE 0 ; store pointer variable + + DEC 1 ; decrement word counter + DUP + CBRANCH.NZ _RCVWORDS_LP ; if not null, loop + DROP ; remove counter value + + FPADJ 4 + RET + +; receive 4 bytes, return as word +_RCVWORD: + LOADCP _RCVBYTE ; receive first byte + CALL + BROT ; rotate byte to left + + LOADCP _RCVBYTE ; receive second byte + CALL + OR ; or first and second byte together + BROT ; rotate 1st + 2nd to left + + LOADCP _RCVBYTE ; receive third byte + CALL + OR + BROT + + LOADCP _RCVBYTE ; receive fourth byte + CALL + OR + RET + +_XCVR_ENABLE: + LOADC SPIREG + LOADCP SPI_TX_FLAGS + LOADI + STOREI + DROP + RET + +; send a byte +; args: byte to be sent +_SENDBYTE: + LOADC SPIREG + LOADI ; load spi io register + LOADCP SPI_TX_RDY + AND ; check tx_rdy bit + CBRANCH.Z _SENDBYTE ; if not set, loop + + LOADC SPI_TX_WR ; TX_WR bit + OR ; OR in byte to be send + + LOADC SPIREG + SWAP ; swap value and addr for STOREI + STOREI ; store word (flags + data) to io register + DROP ; remove STOREI result + + RET + +; receive a byte. receiver must be enabled. +; returns: received byte +_RCVBYTE: + LOADC SPIREG + LOADI ; load spi io register + LOADC SPI_RX_AVAIL + AND.S0 ; check rx_avail bit, keep original value + CBRANCH.NZ RECV_GOTIT + DROP ; rx_avail not set, remove register value and loop + BRANCH _RCVBYTE +RECV_GOTIT: + LOADC SPIREG + LOADC SPI_RX_RD ; remove one byte from rx fifo + STOREI + DROP + + LOADC 255 + AND ; keep bits 7-0 + RET + +SPI_TX_FLAGS: .WORD SPI_CTRL_WRITE + SPI_TXRX_EN + SPI_RX_FILTER_EN +SPI_IDLE_FLAGS: .WORD SPI_CTRL_WRITE + + .CPOOL + +CSD_BUF: .BLOCK 4 +CARD_BUF: .BLOCK 128 + diff --git a/lib/stdlib.s b/lib/stdlib.s new file mode 100644 index 0000000..ca5d3ad --- /dev/null +++ b/lib/stdlib.s @@ -0,0 +1,9181 @@ +_NST_STDLIB38ISLEAPYEAR: + FPADJ -12 + LOADREG BP + STORE 4 + DUP + STOREREG BP + STORE 0 + LOAD.B 40 ; NEWYEAR + LOADC 4 + LOADCP _MOD + CALL + LOADC 0 + CMP EQ + LOAD.B 40 ; NEWYEAR + LOADC 100 + LOADCP _MOD + CALL + LOADC 0 + CMP NE + AND + LOAD.B 40 ; NEWYEAR + LOADC 400 + LOADCP _MOD + CALL + LOADC 0 + CMP EQ + OR + STORE 8 ; ISLEAPYEAR + LOAD 8 ; ISLEAPYEAR + LOAD 4 + STOREREG BP + FPADJ 12 + RET +ADVANCETIME: + FPADJ -64 + STORE 4 ; SECONDS + STORE 0 ; D + LOAD 4 ; SECONDS + LOADC 60 + LOADCP _MOD + CALL + STORE 8 ; SECSREST + LOAD 4 ; SECONDS + LOADC 60 + LOADCP _DIV + CALL + STORE 44 ; MINUTESDELTA + LOAD 44 ; MINUTESDELTA + LOADC 60 + LOADCP _MOD + CALL + STORE 12 ; MINUTESREST + LOAD 0 ; D + LOADC 20 + ADD + LOADI + LOAD 8 ; SECSREST + ADD + STORE 20 ; NEWSECS + LOAD 20 ; NEWSECS + LOADC 60 + CMP GE + .LCBRANCHZ _IF_ELSE0_STDLIB + LOAD 20 ; NEWSECS + LOADC 60 + SUB + STORE 20 ; NEWSECS + LOAD 44 ; MINUTESDELTA + LOADC 1 + ADD + STORE 44 ; MINUTESDELTA + LOAD 12 ; MINUTESREST + LOADC 1 + ADD + STORE 12 ; MINUTESREST +_IF_ELSE0_STDLIB: +_IF_END0_STDLIB: + LOAD 0 ; D + LOADC 20 + ADD + LOAD 20 ; NEWSECS + DUP + LOADC 0 + LOADC 59 + LOADCP _RANGECHECK + CALL + STOREI + DROP + LOAD 44 ; MINUTESDELTA + LOADC 60 + LOADCP _DIV + CALL + STORE 48 ; HOURSDELTA + LOAD 48 ; HOURSDELTA + LOADC 24 + LOADCP _MOD + CALL + STORE 16 ; HOURSREST + LOAD 0 ; D + LOADC 16 + ADD + LOADI + LOAD 12 ; MINUTESREST + ADD + STORE 24 ; NEWMINUTES + LOAD 24 ; NEWMINUTES + LOADC 60 + CMP GE + .LCBRANCHZ _IF_ELSE1_STDLIB + LOAD 24 ; NEWMINUTES + LOADC 60 + SUB + STORE 24 ; NEWMINUTES + LOAD 48 ; HOURSDELTA + LOADC 1 + ADD + STORE 48 ; HOURSDELTA + LOAD 16 ; HOURSREST + LOADC 1 + ADD + STORE 16 ; HOURSREST +_IF_ELSE1_STDLIB: +_IF_END1_STDLIB: + LOAD 0 ; D + LOADC 16 + ADD + LOAD 24 ; NEWMINUTES + DUP + LOADC 0 + LOADC 59 + LOADCP _RANGECHECK + CALL + STOREI + DROP + LOAD 48 ; HOURSDELTA + LOADC 24 + LOADCP _DIV + CALL + STORE 52 ; DAYSDELTA + LOAD 0 ; D + INC 12 + LOADI + LOAD 16 ; HOURSREST + ADD + STORE 28 ; NEWHOURS + LOAD 28 ; NEWHOURS + LOADC 24 + CMP GE + .LCBRANCHZ _IF_ELSE2_STDLIB + LOAD 28 ; NEWHOURS + LOADC 24 + SUB + STORE 28 ; NEWHOURS + LOAD 52 ; DAYSDELTA + LOADC 1 + ADD + STORE 52 ; DAYSDELTA +_IF_ELSE2_STDLIB: +_IF_END2_STDLIB: + LOAD 0 ; D + INC 12 + LOAD 28 ; NEWHOURS + DUP + LOADC 0 + LOADC 23 + LOADCP _RANGECHECK + CALL + STOREI + DROP + LOAD 0 ; D + INC 8 + LOADI + LOAD 52 ; DAYSDELTA + ADD + STORE 32 ; NEWDAYS + LOAD 0 ; D + INC 4 + LOADI + STORE 36 ; NEWMONTH + LOAD 0 ; D + LOADI + STORE 40 ; NEWYEAR + LOADREG FP + LOADCP _NST_STDLIB38ISLEAPYEAR + CALL + .LCBRANCHZ _IF_ELSE3_STDLIB + LOADC 1 + STORE 56 ; MPDINDEX + .LBRANCH _IF_END3_STDLIB +_IF_ELSE3_STDLIB: + LOADC 0 + STORE 56 ; MPDINDEX +_IF_END3_STDLIB: + LOADCP DATETIMEMTAB ; DATETIMEMTAB + LOAD 56 ; MPDINDEX + DUP + LOADC 2 + LOADCP _BOUNDSCHECK + CALL + LOADC 48 + LOADCP _MULU + CALL + ADD + LOAD 36 ; NEWMONTH + DEC 1 + DUP + LOADC 12 + LOADCP _BOUNDSCHECK + CALL + SHL 2 + ADD + LOADI + STORE 60 ; DAYSPERMONTH +_WHILE_START0_STDLIB: + LOAD 32 ; NEWDAYS + LOAD 60 ; DAYSPERMONTH + CMP GT + .LCBRANCHZ _WHILE_END0_STDLIB + LOAD 36 ; NEWMONTH + LOADC 1 + ADD + STORE 36 ; NEWMONTH + LOAD 32 ; NEWDAYS + LOAD 60 ; DAYSPERMONTH + SUB + STORE 32 ; NEWDAYS + LOAD 36 ; NEWMONTH + LOADC 12 + CMP GT + .LCBRANCHZ _IF_ELSE4_STDLIB + LOAD 40 ; NEWYEAR + LOADC 1 + ADD + STORE 40 ; NEWYEAR + LOADC 1 + STORE 36 ; NEWMONTH + LOADREG FP + LOADCP _NST_STDLIB38ISLEAPYEAR + CALL + .LCBRANCHZ _IF_ELSE5_STDLIB + LOADC 1 + STORE 56 ; MPDINDEX + .LBRANCH _IF_END5_STDLIB + .CPOOL +_IF_ELSE5_STDLIB: + LOADC 0 + STORE 56 ; MPDINDEX +_IF_END5_STDLIB: +_IF_ELSE4_STDLIB: +_IF_END4_STDLIB: + LOADCP DATETIMEMTAB ; DATETIMEMTAB + LOAD 56 ; MPDINDEX + DUP + LOADC 2 + LOADCP _BOUNDSCHECK + CALL + LOADC 48 + LOADCP _MULU + CALL + ADD + LOAD 36 ; NEWMONTH + DEC 1 + DUP + LOADC 12 + LOADCP _BOUNDSCHECK + CALL + SHL 2 + ADD + LOADI + STORE 60 ; DAYSPERMONTH + .LBRANCH _WHILE_START0_STDLIB +_WHILE_END0_STDLIB: + LOAD 0 ; D + INC 8 + LOAD 32 ; NEWDAYS + DUP + LOADC 1 + LOADC 31 + LOADCP _RANGECHECK + CALL + STOREI + DROP + LOAD 0 ; D + INC 4 + LOAD 36 ; NEWMONTH + DUP + LOADC 1 + LOADC 12 + LOADCP _RANGECHECK + CALL + STOREI + DROP + LOAD 0 ; D + LOAD 40 ; NEWYEAR + STOREI + DROP + FPADJ 64 + RET +GETTIME: + FPADJ -16 + STORE 0 ; GETTIME + LOADCP SYSCLOCK ; SYSCLOCK + LOADI + LOADC 0 + CMP EQ + .LCBRANCHZ _IF_ELSE6_STDLIB + LOADCP SYSCLOCK ; SYSCLOCK + LOADC 2001 + STOREI + DROP + LOADCP SYSCLOCK,4 ; SYSCLOCK + LOADC 1 + DUP + LOADC 1 + LOADC 12 + LOADCP _RANGECHECK + CALL + STOREI + DROP + LOADCP SYSCLOCK,8 ; SYSCLOCK + LOADC 1 + DUP + LOADC 1 + LOADC 31 + LOADCP _RANGECHECK + CALL + STOREI + DROP +_IF_ELSE6_STDLIB: +_IF_END6_STDLIB: + LOADCP GETTICKS + CALL + STORE 4 ; NOW + LOAD 4 ; NOW + LOADCP SYSLASTTICKS ; SYSLASTTICKS + LOADI + SUB + STORE 8 ; DELTA + LOADCP SYSLASTTICKS ; SYSLASTTICKS + LOAD 4 ; NOW + STOREI + DROP + LOAD 8 ; DELTA + LOADC 20 + LOADCP _DIV + CALL + STORE 12 ; SECS + LOADCP SYSCLOCK ; SYSCLOCK + LOAD 12 ; SECS + LOADCP ADVANCETIME + CALL + LOAD 0 ; GETTIME + LOADCP SYSCLOCK ; SYSCLOCK + LOADC 6 + LOADCP _COPYWORDS + CALL + LOAD 0 ; GETTIME + FPADJ 16 + RET +TIMESTR: + FPADJ -44 + STORE 28 ; TIMESTR + STORE 24 ; SHOWSECONDS + ; D + LOADREG FP + SWAP + LOADC 6 + LOADCP _COPYWORDS + CALL + LOADC 4 + ; DIGITS + LOADREG FP + LOADC 32 + ADD + LOADCP _INITSTRINGF + CALL + LOAD 12 ; D + LOADC 0 + ; DIGITS + LOADREG FP + LOADC 32 + ADD + LOADCP INTSTR + CALL + LOAD 12 ; D + LOADC 10 + CMP LT + .LCBRANCHZ _IF_ELSE7_STDLIB + LOAD 28 ; TIMESTR + LOADCP _C_S_0_STDLIB + LOADCP _COPYSTRING + CALL +_IF_ELSE7_STDLIB: +_IF_END7_STDLIB: + LOAD 28 ; TIMESTR + LOAD 28 ; TIMESTR + LOADREG FP + LOADC 88 + SUB + SWAP + LOADC 80 + FPADJ -88 + LOADCP _INITSTRINGFROM + CALL + FPADJ 88 + LOADREG FP + LOADC 88 + SUB + ; DIGITS + LOADREG FP + LOADC 32 + ADD + FPADJ -88 + LOADCP _APPENDSTRING + CALL + FPADJ 88 + LOADREG FP + LOADC 88 + SUB + LOADCP _C_S_1_STDLIB + FPADJ -88 + LOADCP _APPENDSTRING + CALL + FPADJ 88 + LOADREG FP + LOADC 88 + SUB + FPADJ -88 + LOADCP _COPYSTRING + CALL + FPADJ 88 + LOAD 16 ; D + LOADC 0 + ; DIGITS + LOADREG FP + LOADC 32 + ADD + LOADCP INTSTR + CALL + LOAD 16 ; D + LOADC 10 + CMP LT + .LCBRANCHZ _IF_ELSE8_STDLIB + LOAD 28 ; TIMESTR + LOADC 48 + LOADCP APPENDCHAR + CALL +_IF_ELSE8_STDLIB: +_IF_END8_STDLIB: + LOAD 28 ; TIMESTR + LOAD 28 ; TIMESTR + LOADREG FP + LOADC 88 + SUB + SWAP + LOADC 80 + FPADJ -88 + LOADCP _INITSTRINGFROM + CALL + FPADJ 88 + LOADREG FP + LOADC 88 + SUB + ; DIGITS + LOADREG FP + LOADC 32 + ADD + FPADJ -88 + LOADCP _APPENDSTRING + CALL + FPADJ 88 + LOADREG FP + LOADC 88 + SUB + FPADJ -88 + LOADCP _COPYSTRING + CALL + FPADJ 88 + LOAD 24 ; SHOWSECONDS + .LCBRANCHZ _IF_ELSE9_STDLIB + LOAD 28 ; TIMESTR + LOADC 58 + LOADCP APPENDCHAR + CALL + LOAD 20 ; D + LOADC 0 + ; DIGITS + LOADREG FP + LOADC 32 + ADD + LOADCP INTSTR + CALL + LOAD 20 ; D + LOADC 10 + CMP LT + .LCBRANCHZ _IF_ELSE10_STDLIB + LOAD 28 ; TIMESTR + LOADC 48 + LOADCP APPENDCHAR + CALL +_IF_ELSE10_STDLIB: +_IF_END10_STDLIB: + LOAD 28 ; TIMESTR + LOAD 28 ; TIMESTR + LOADREG FP + LOADC 88 + SUB + SWAP + LOADC 80 + FPADJ -88 + LOADCP _INITSTRINGFROM + CALL + FPADJ 88 + LOADREG FP + LOADC 88 + SUB + ; DIGITS + LOADREG FP + LOADC 32 + ADD + FPADJ -88 + LOADCP _APPENDSTRING + CALL + FPADJ 88 + LOADREG FP + LOADC 88 + SUB + FPADJ -88 + LOADCP _COPYSTRING + CALL + FPADJ 88 +_IF_ELSE9_STDLIB: +_IF_END9_STDLIB: + LOAD 28 ; TIMESTR + FPADJ 44 + RET + .CPOOL +DATESTR: + FPADJ -40 + STORE 24 ; DATESTR + ; D + LOADREG FP + SWAP + LOADC 6 + LOADCP _COPYWORDS + CALL + LOADC 4 + ; DIGITS + LOADREG FP + LOADC 28 + ADD + LOADCP _INITSTRINGF + CALL + LOAD 0 ; D + LOADC 0 + ; DIGITS + LOADREG FP + LOADC 28 + ADD + LOADCP INTSTR + CALL + LOAD 24 ; DATESTR + LOAD 24 ; DATESTR + LOADREG FP + LOADC 88 + SUB + SWAP + LOADC 80 + FPADJ -88 + LOADCP _INITSTRINGFROM + CALL + FPADJ 88 + LOADREG FP + LOADC 88 + SUB + ; DIGITS + LOADREG FP + LOADC 28 + ADD + FPADJ -88 + LOADCP _APPENDSTRING + CALL + FPADJ 88 + LOADREG FP + LOADC 88 + SUB + LOADCP _C_S_2_STDLIB + FPADJ -88 + LOADCP _APPENDSTRING + CALL + FPADJ 88 + LOADREG FP + LOADC 88 + SUB + FPADJ -88 + LOADCP _COPYSTRING + CALL + FPADJ 88 + LOAD 4 ; D + LOADC 0 + ; DIGITS + LOADREG FP + LOADC 28 + ADD + LOADCP INTSTR + CALL + LOAD 4 ; D + LOADC 10 + CMP LT + .LCBRANCHZ _IF_ELSE11_STDLIB + LOAD 24 ; DATESTR + LOADC 48 + LOADCP APPENDCHAR + CALL +_IF_ELSE11_STDLIB: +_IF_END11_STDLIB: + LOAD 24 ; DATESTR + LOAD 24 ; DATESTR + LOADREG FP + LOADC 88 + SUB + SWAP + LOADC 80 + FPADJ -88 + LOADCP _INITSTRINGFROM + CALL + FPADJ 88 + LOADREG FP + LOADC 88 + SUB + ; DIGITS + LOADREG FP + LOADC 28 + ADD + FPADJ -88 + LOADCP _APPENDSTRING + CALL + FPADJ 88 + LOADREG FP + LOADC 88 + SUB + FPADJ -88 + LOADCP _COPYSTRING + CALL + FPADJ 88 + LOAD 24 ; DATESTR + LOADC 45 + LOADCP APPENDCHAR + CALL + LOAD 8 ; D + LOADC 0 + ; DIGITS + LOADREG FP + LOADC 28 + ADD + LOADCP INTSTR + CALL + LOAD 8 ; D + LOADC 10 + CMP LT + .LCBRANCHZ _IF_ELSE12_STDLIB + LOAD 24 ; DATESTR + LOADC 48 + LOADCP APPENDCHAR + CALL +_IF_ELSE12_STDLIB: +_IF_END12_STDLIB: + LOAD 24 ; DATESTR + LOAD 24 ; DATESTR + LOADREG FP + LOADC 88 + SUB + SWAP + LOADC 80 + FPADJ -88 + LOADCP _INITSTRINGFROM + CALL + FPADJ 88 + LOADREG FP + LOADC 88 + SUB + ; DIGITS + LOADREG FP + LOADC 28 + ADD + FPADJ -88 + LOADCP _APPENDSTRING + CALL + FPADJ 88 + LOADREG FP + LOADC 88 + SUB + FPADJ -88 + LOADCP _COPYSTRING + CALL + FPADJ 88 + LOAD 24 ; DATESTR + FPADJ 40 + RET +GETTIMESTAMP: + FPADJ -12 + STORE 0 ; D + LOAD 0 ; D + LOADI + LOADC 1970 + SUB + LOADC 24 + LOADCP _SHLM + CALL + STORE 8 ; I + LOAD 8 ; I + LOAD 0 ; D + INC 4 + LOADI + LOADC 20 + LOADCP _SHLM + CALL + OR + STORE 8 ; I + LOAD 8 ; I + LOAD 0 ; D + INC 8 + LOADI + LOADC 15 + LOADCP _SHLM + CALL + OR + STORE 8 ; I + LOAD 8 ; I + LOAD 0 ; D + INC 12 + LOADI + LOADC 10 + LOADCP _SHLM + CALL + OR + STORE 8 ; I + LOAD 8 ; I + LOAD 0 ; D + LOADC 16 + ADD + LOADI + LOADC 4 + LOADCP _SHLM + CALL + OR + STORE 8 ; I + LOAD 8 ; I + LOAD 0 ; D + LOADC 20 + ADD + LOADI + LOADC 2 + LOADCP _SHRM + CALL + OR + STORE 8 ; I + LOAD 8 ; I + STORE 4 ; GETTIMESTAMP + LOAD 4 ; GETTIMESTAMP + FPADJ 12 + RET +GETDATETIME: + FPADJ -8 + STORE 4 ; GETDATETIME + STORE 0 ; TS + LOAD 4 ; GETDATETIME + LOADC 20 + ADD + LOAD 0 ; TS + LOADC 15 + AND + LOADC 2 + LOADCP _SHLM + CALL + DUP + LOADC 0 + LOADC 59 + LOADCP _RANGECHECK + CALL + STOREI + DROP + LOAD 0 ; TS + LOADC 4 + LOADCP _SHRM + CALL + STORE 0 ; TS + LOAD 4 ; GETDATETIME + LOADC 16 + ADD + LOAD 0 ; TS + LOADC 63 + AND + DUP + LOADC 0 + LOADC 59 + LOADCP _RANGECHECK + CALL + STOREI + DROP + LOAD 0 ; TS + LOADC 6 + LOADCP _SHRM + CALL + STORE 0 ; TS + LOAD 4 ; GETDATETIME + INC 12 + LOAD 0 ; TS + LOADC 31 + AND + DUP + LOADC 0 + LOADC 23 + LOADCP _RANGECHECK + CALL + STOREI + DROP + LOAD 0 ; TS + LOADC 5 + LOADCP _SHRM + CALL + STORE 0 ; TS + LOAD 4 ; GETDATETIME + INC 8 + LOAD 0 ; TS + LOADC 31 + AND + DUP + LOADC 1 + LOADC 31 + LOADCP _RANGECHECK + CALL + STOREI + DROP + LOAD 0 ; TS + LOADC 5 + LOADCP _SHRM + CALL + STORE 0 ; TS + LOAD 4 ; GETDATETIME + INC 4 + LOAD 0 ; TS + LOADC 15 + AND + DUP + LOADC 1 + LOADC 12 + LOADCP _RANGECHECK + CALL + STOREI + DROP + LOAD 0 ; TS + LOADC 4 + LOADCP _SHRM + CALL + STORE 0 ; TS + LOAD 4 ; GETDATETIME + LOADC 1970 + LOAD 0 ; TS + LOADC 255 + AND + ADD + STOREI + DROP + LOAD 4 ; GETDATETIME + FPADJ 8 + RET + .CPOOL +GETCURTIMESTAMP: + FPADJ -28 + ; NOW + LOADREG FP + INC 4 + LOADREG FP + LOADC 24 + SUB + FPADJ -24 + LOADCP GETTIME + CALL + FPADJ 24 + LOADC 6 + FPADJ -24 + LOADCP _COPYWORDS + CALL + FPADJ 24 + ; NOW + LOADREG FP + INC 4 + LOADCP GETTIMESTAMP + CALL + STORE 0 ; GETCURTIMESTAMP + LOAD 0 ; GETCURTIMESTAMP + FPADJ 28 + RET +COPY: + FPADJ -104 + STORE 96 ; COPY + STORE 92 ; COUNT + STORE 88 ; INDEX + ; S + LOADREG FP + SWAP + LOADC 80 + LOADCP _INITSTRINGFROM + CALL + LOAD 96 ; COPY + LOADCP _C_S_3_STDLIB + LOADCP _COPYSTRING + CALL + ; S + LOADREG FP + LOADCP LENGTH + CALL + STORE 100 ; LEN + LOAD 88 ; INDEX + LOADC 1 + CMP LT + .LCBRANCHZ _IF_ELSE13_STDLIB + LOADC 1 + STORE 88 ; INDEX +_IF_ELSE13_STDLIB: +_IF_END13_STDLIB: +_WHILE_START1_STDLIB: + LOAD 92 ; COUNT + LOADC 0 + CMP GT + LOAD 88 ; INDEX + LOAD 100 ; LEN + CMP LE + AND + .LCBRANCHZ _WHILE_END1_STDLIB + LOAD 96 ; COPY + LOAD 96 ; COPY + LOADREG FP + LOADC 88 + SUB + SWAP + LOADC 80 + FPADJ -88 + LOADCP _INITSTRINGFROM + CALL + FPADJ 88 + LOADREG FP + LOADC 88 + SUB + ; S + LOADREG FP + LOAD 88 ; INDEX + LOADCP _INDEXSTRING + CALL + LOADI.S1.X2Y + BSEL + LOADREG FP + LOADC 100 + SUB + SWAP + OVER + LOADCP _CHARTOSTRING + CALL + FPADJ -100 + LOADCP _APPENDSTRING + CALL + FPADJ 100 + LOADREG FP + LOADC 88 + SUB + FPADJ -100 + LOADCP _COPYSTRING + CALL + FPADJ 100 + LOAD 88 ; INDEX + LOADC 1 + ADD + STORE 88 ; INDEX + LOAD 92 ; COUNT + LOADC 1 + SUB + STORE 92 ; COUNT + .LBRANCH _WHILE_START1_STDLIB +_WHILE_END1_STDLIB: + LOAD 96 ; COPY + FPADJ 104 + RET +INSERT: + FPADJ -112 + STORE 92 ; POSITION + STORE 88 ; DEST + ; INS + LOADREG FP + SWAP + LOADC 80 + LOADCP _INITSTRINGFROM + CALL + LOAD 92 ; POSITION + LOADC 1 + CMP LT + .LCBRANCHZ _IF_ELSE14_STDLIB + LOADC 1 + STORE 92 ; POSITION +_IF_ELSE14_STDLIB: +_IF_END14_STDLIB: + LOAD 92 ; POSITION + LOAD 88 ; DEST + LOADCP LENGTH + CALL + LOADC 1 + ADD + CMP GT + .LCBRANCHZ _IF_ELSE15_STDLIB + LOAD 88 ; DEST + LOADCP LENGTH + CALL + LOADC 1 + ADD + STORE 92 ; POSITION +_IF_ELSE15_STDLIB: +_IF_END15_STDLIB: + LOAD 88 ; DEST + LOADCP LENGTH + CALL + STORE 104 ; FROM + LOAD 88 ; DEST + LOADCP LENGTH + CALL + LOAD 92 ; POSITION + SUB + LOADC 1 + ADD + STORE 100 ; COUNT + LOAD 104 ; FROM + ; INS + LOADREG FP + LOADCP LENGTH + CALL + ADD + STORE 108 ; TO_ + LOAD 88 ; DEST + LOAD 88 ; DEST + LOADCP LENGTH + CALL + ; INS + LOADREG FP + LOADCP LENGTH + CALL + ADD + LOADCP _SETSTRINGLENGTH + CALL + LOADC 1 + STORE 96 ; I + LOAD 100 ; COUNT +_FOR_START0_STDLIB: + LOAD 96 ; I + OVER + CMP GT + .LCBRANCH _FOR_END0_STDLIB + LOAD 108 ; TO_ + LOAD 88 ; DEST + LOADCP MAXLENGTH + CALL + CMP LE + .LCBRANCHZ _IF_ELSE16_STDLIB + LOAD 88 ; DEST + LOAD 108 ; TO_ + LOADCP _INDEXSTRING + CALL + LOAD 88 ; DEST + LOAD 104 ; FROM + LOADCP _INDEXSTRING + CALL + LOADI.S1.X2Y + BSEL + LOADCP _SETSTRINGCHAR + CALL + LOAD 108 ; TO_ + LOADC 1 + SUB + STORE 108 ; TO_ + LOAD 104 ; FROM + LOADC 1 + SUB + STORE 104 ; FROM +_IF_ELSE16_STDLIB: +_IF_END16_STDLIB: + LOAD 96 ; I + INC 1 + STORE 96 ; I + .LBRANCH _FOR_START0_STDLIB +_FOR_END0_STDLIB: + DROP + LOAD 92 ; POSITION + STORE 108 ; TO_ + ; INS + LOADREG FP + LOADCP LENGTH + CALL + STORE 100 ; COUNT + LOADC 1 + STORE 96 ; I + LOAD 100 ; COUNT +_FOR_START1_STDLIB: + LOAD 96 ; I + OVER + CMP GT + .LCBRANCH _FOR_END1_STDLIB + LOAD 108 ; TO_ + LOAD 88 ; DEST + LOADCP MAXLENGTH + CALL + CMP LE + .LCBRANCHZ _IF_ELSE17_STDLIB + LOAD 88 ; DEST + LOAD 108 ; TO_ + LOADCP _INDEXSTRING + CALL + ; INS + LOADREG FP + LOAD 96 ; I + LOADCP _INDEXSTRING + CALL + LOADI.S1.X2Y + BSEL + LOADCP _SETSTRINGCHAR + CALL + LOAD 108 ; TO_ + LOADC 1 + ADD + STORE 108 ; TO_ +_IF_ELSE17_STDLIB: +_IF_END17_STDLIB: + LOAD 96 ; I + INC 1 + STORE 96 ; I + .LBRANCH _FOR_START1_STDLIB + .CPOOL +_FOR_END1_STDLIB: + DROP + FPADJ 112 + RET +DELETE: + FPADJ -24 + STORE 8 ; COUNT + STORE 4 ; FROM + STORE 0 ; S + LOAD 0 ; S + LOADCP LENGTH + CALL + STORE 16 ; LEN + LOAD 4 ; FROM + LOADC 0 + CMP GT + LOAD 4 ; FROM + LOAD 16 ; LEN + CMP LE + AND + LOAD 8 ; COUNT + LOADC 0 + CMP GT + AND + .LCBRANCHZ _IF_ELSE18_STDLIB + LOAD 4 ; FROM + LOAD 8 ; COUNT + ADD + LOAD 16 ; LEN + CMP LE + .LCBRANCHZ _IF_ELSE19_STDLIB + LOAD 16 ; LEN + LOAD 8 ; COUNT + SUB + STORE 20 ; LAST + LOAD 4 ; FROM + STORE 12 ; I + LOAD 20 ; LAST +_FOR_START2_STDLIB: + LOAD 12 ; I + OVER + CMP GT + .LCBRANCH _FOR_END2_STDLIB + LOAD 0 ; S + LOAD 12 ; I + LOADCP _INDEXSTRING + CALL + LOAD 0 ; S + LOAD 12 ; I + LOAD 8 ; COUNT + ADD + LOADCP _INDEXSTRING + CALL + LOADI.S1.X2Y + BSEL + LOADCP _SETSTRINGCHAR + CALL + LOAD 12 ; I + INC 1 + STORE 12 ; I + .LBRANCH _FOR_START2_STDLIB +_FOR_END2_STDLIB: + DROP + .LBRANCH _IF_END19_STDLIB +_IF_ELSE19_STDLIB: + LOAD 4 ; FROM + LOADC 1 + SUB + STORE 20 ; LAST +_IF_END19_STDLIB: + LOAD 0 ; S + LOAD 20 ; LAST + LOADCP _SETSTRINGLENGTH + CALL +_IF_ELSE18_STDLIB: +_IF_END18_STDLIB: + FPADJ 24 + RET +POS: + FPADJ -124 + STORE 88 ; S + ; SUBSTR + LOADREG FP + SWAP + LOADC 80 + LOADCP _INITSTRINGFROM + CALL + LOADC 0 + STORE 116 ; FOUND + ; SUBSTR + LOADREG FP + LOADCP LENGTH + CALL + STORE 96 ; SUBSTRLEN + LOAD 88 ; S + LOADCP LENGTH + CALL + STORE 100 ; SLEN + LOADC 1 + STORE 104 ; SEARCHPOS + LOADC 1 + STORE 112 ; SUBPOS + LOAD 96 ; SUBSTRLEN + LOADC 0 + CMP GT + LOAD 100 ; SLEN + LOADC 0 + CMP GT + AND + .LCBRANCHZ _IF_ELSE20_STDLIB +_WHILE_START2_STDLIB: + LOAD 116 ; FOUND + LOADC 0 + CMP EQ + LOAD 104 ; SEARCHPOS + LOAD 100 ; SLEN + CMP LE + AND + .LCBRANCHZ _WHILE_END2_STDLIB + ; SUBSTR + LOADREG FP + LOAD 112 ; SUBPOS + LOADCP _INDEXSTRING + CALL + LOADI.S1.X2Y + BSEL + LOAD 88 ; S + LOAD 104 ; SEARCHPOS + LOADCP _INDEXSTRING + CALL + LOADI.S1.X2Y + BSEL + CMP NE + .LCBRANCHZ _IF_ELSE21_STDLIB + LOAD 112 ; SUBPOS + LOADC 1 + CMP EQ + .LCBRANCHZ _IF_ELSE22_STDLIB + LOAD 104 ; SEARCHPOS + LOADC 1 + ADD + STORE 104 ; SEARCHPOS +_IF_ELSE22_STDLIB: +_IF_END22_STDLIB: + LOADC 1 + STORE 112 ; SUBPOS + .LBRANCH _IF_END21_STDLIB +_IF_ELSE21_STDLIB: + LOAD 112 ; SUBPOS + LOADC 1 + CMP EQ + .LCBRANCHZ _IF_ELSE23_STDLIB + LOAD 104 ; SEARCHPOS + STORE 92 ; POS +_IF_ELSE23_STDLIB: +_IF_END23_STDLIB: + LOAD 112 ; SUBPOS + LOAD 96 ; SUBSTRLEN + CMP EQ + .LCBRANCHZ _IF_ELSE24_STDLIB + LOADC 1 + STORE 116 ; FOUND + .LBRANCH _IF_END24_STDLIB +_IF_ELSE24_STDLIB: + LOAD 112 ; SUBPOS + LOADC 1 + ADD + STORE 112 ; SUBPOS + LOAD 104 ; SEARCHPOS + LOADC 1 + ADD + STORE 104 ; SEARCHPOS +_IF_END24_STDLIB: +_IF_END21_STDLIB: + .LBRANCH _WHILE_START2_STDLIB +_WHILE_END2_STDLIB: +_IF_ELSE20_STDLIB: +_IF_END20_STDLIB: + LOAD 116 ; FOUND + LOADC 0 + CMP EQ + .LCBRANCHZ _IF_ELSE25_STDLIB + LOADC 0 + STORE 92 ; POS +_IF_ELSE25_STDLIB: +_IF_END25_STDLIB: + LOAD 92 ; POS + FPADJ 124 + RET +PWROFTEN: + FPADJ -20 + STORE 0 ; EXP + LOAD 0 ; EXP + LOADC 0 + CMP EQ + .LCBRANCHZ _IF_ELSE26_STDLIB + LOADC 1 + LOADCP _INTTOFLOAT32 + CALL + STORE 12 ; RES + .LBRANCH _IF_END26_STDLIB + .CPOOL +_IF_ELSE26_STDLIB: + LOAD 0 ; EXP + LOADC 1 + CMP EQ + .LCBRANCHZ _IF_ELSE27_STDLIB + LOADC 10 + LOADCP _INTTOFLOAT32 + CALL + STORE 12 ; RES + .LBRANCH _IF_END27_STDLIB +_IF_ELSE27_STDLIB: + LOADC 1 + STORE 16 ; SOFAR + LOADC 10 + LOADCP _INTTOFLOAT32 + CALL + STORE 12 ; RES +_WHILE_START3_STDLIB: + LOAD 16 ; SOFAR + LOADC 1 + LOADCP _SHLM + CALL + LOAD 0 ; EXP + CMP LE + .LCBRANCHZ _WHILE_END3_STDLIB + LOAD 12 ; RES + LOAD 12 ; RES + LOADCP _MULFLOAT32 + CALL + STORE 12 ; RES + LOAD 16 ; SOFAR + LOADC 1 + LOADCP _SHLM + CALL + STORE 16 ; SOFAR + .LBRANCH _WHILE_START3_STDLIB +_WHILE_END3_STDLIB: + LOAD 16 ; SOFAR + LOADC 1 + ADD + STORE 8 ; I + LOAD 0 ; EXP +_FOR_START3_STDLIB: + LOAD 8 ; I + OVER + CMP GT + .LCBRANCH _FOR_END3_STDLIB + LOAD 12 ; RES + LOADC 10 + LOADCP _INTTOFLOAT32 + CALL + LOADCP _MULFLOAT32 + CALL + STORE 12 ; RES + LOAD 8 ; I + INC 1 + STORE 8 ; I + .LBRANCH _FOR_START3_STDLIB +_FOR_END3_STDLIB: + DROP +_IF_END27_STDLIB: +_IF_END26_STDLIB: + LOAD 12 ; RES + STORE 4 ; PWROFTEN + LOAD 4 ; PWROFTEN + FPADJ 20 + RET +EXP: + FPADJ -28 + STORE 0 ; EXPONENT + LOAD 0 ; EXPONENT + STORE 8 ; X + LOAD 8 ; X + STORE 16 ; FRC + LOADCP 1073741951 + LOAD 8 ; X + LOADCP _ADDFLOAT32 + CALL + STORE 12 ; P + LOADCP 1073741951 + STORE 20 ; I +_REPEAT_START0_STDLIB: + LOAD 20 ; I + LOADCP 1073741951 + LOADCP _ADDFLOAT32 + CALL + STORE 20 ; I + LOAD 16 ; FRC + LOAD 8 ; X + LOAD 20 ; I + LOADCP _DIVFLOAT32 + CALL + LOADCP _MULFLOAT32 + CALL + STORE 16 ; FRC + LOAD 12 ; P + STORE 24 ; L + LOAD 12 ; P + LOAD 16 ; FRC + LOADCP _ADDFLOAT32 + CALL + STORE 12 ; P + LOAD 24 ; L + LOAD 12 ; P + LOADCP _CMPFLOAT32 + CALL + LOADC 0 + CMP EQ + .LCBRANCHZ _REPEAT_START0_STDLIB +_REPEAT_END0_STDLIB: + LOAD 12 ; P + STORE 4 ; EXP + LOAD 4 ; EXP + FPADJ 28 + RET +LN: + FPADJ -36 + STORE 0 ; N + LOADC 0 + STORE 8 ; A + LOAD 0 ; N + LOADC 0 + LOADCP _INTTOFLOAT32 + CALL + LOADCP _CMPFLOAT32 + CALL + LOADC 0 + CMP GT + .LCBRANCHZ _IF_ELSE28_STDLIB + LOAD 0 ; N + LOADCP 1459366528 + LOADCP _DIVFLOAT32 + CALL + STORE 20 ; D +_WHILE_START4_STDLIB: + LOAD 20 ; D + LOADCP 1073741951 + LOADCP _CMPFLOAT32 + CALL + LOADC 0 + CMP GT + .LCBRANCHZ _WHILE_END4_STDLIB + LOAD 8 ; A + LOADC 1 + ADD + STORE 8 ; A + LOAD 20 ; D + STORE 0 ; N + LOAD 0 ; N + LOADCP 1459366528 + LOADCP _DIVFLOAT32 + CALL + STORE 20 ; D + .LBRANCH _WHILE_START4_STDLIB +_WHILE_END4_STDLIB: + LOAD 0 ; N + LOADCP 1459366528 + LOADCP _MULFLOAT32 + CALL + STORE 20 ; D +_WHILE_START5_STDLIB: + LOAD 20 ; D + LOADCP 1073741951 + LOADCP _CMPFLOAT32 + CALL + LOADC 0 + CMP LT + .LCBRANCHZ _WHILE_END5_STDLIB + LOAD 8 ; A + LOADC 1 + SUB + STORE 8 ; A + LOAD 20 ; D + STORE 0 ; N + LOAD 0 ; N + LOADCP 1459366528 + LOADCP _MULFLOAT32 + CALL + STORE 20 ; D + .LBRANCH _WHILE_START5_STDLIB +_WHILE_END5_STDLIB: + LOADCP 1073741951 + LOAD 0 ; N + LOADC 1 + LOADCP _INTTOFLOAT32 + CALL + LOADCP _SUBFLOAT32 + CALL + LOADCP _DIVFLOAT32 + CALL + STORE 20 ; D + LOAD 20 ; D + LOAD 20 ; D + LOADCP _ADDFLOAT32 + CALL + LOADCP 1073741951 + LOADCP _ADDFLOAT32 + CALL + STORE 20 ; D + LOAD 20 ; D + LOAD 20 ; D + LOADCP _MULFLOAT32 + CALL + STORE 24 ; E + LOADC 0 + LOADCP _INTTOFLOAT32 + CALL + STORE 16 ; C + LOADC 1 + STORE 12 ; B + LOADCP 1073741951 + STORE 28 ; F + LOAD 16 ; C + LOADCP 1073741951 + LOAD 12 ; B + LOAD 28 ; F + SWAP + LOADCP _INTTOFLOAT32 + CALL + SWAP + LOADCP _MULFLOAT32 + CALL + LOADCP _DIVFLOAT32 + CALL + LOADCP _ADDFLOAT32 + CALL + STORE 32 ; CN +_WHILE_START6_STDLIB: + LOAD 16 ; C + LOADCP 1407374958 + LOADCP _ADDFLOAT32 + CALL + LOAD 32 ; CN + LOADCP _CMPFLOAT32 + CALL + LOADC 0 + CMP LT + .LCBRANCHZ _WHILE_END6_STDLIB + LOAD 32 ; CN + STORE 16 ; C + LOAD 12 ; B + LOADC 2 + ADD + STORE 12 ; B + LOAD 28 ; F + LOAD 24 ; E + LOADCP _MULFLOAT32 + CALL + STORE 28 ; F + LOAD 16 ; C + LOADCP 1073741951 + LOAD 12 ; B + LOAD 28 ; F + SWAP + LOADCP _INTTOFLOAT32 + CALL + SWAP + LOADCP _MULFLOAT32 + CALL + LOADCP _DIVFLOAT32 + CALL + LOADCP _ADDFLOAT32 + CALL + STORE 32 ; CN + .LBRANCH _WHILE_START6_STDLIB + .CPOOL +_WHILE_END6_STDLIB: + LOAD 32 ; CN + LOADCP 1073741952 + LOADCP _MULFLOAT32 + CALL + LOAD 20 ; D + LOADCP _DIVFLOAT32 + CALL + STORE 16 ; C + .LBRANCH _IF_END28_STDLIB +_IF_ELSE28_STDLIB: + LOADCP MATHERROR ; MATHERROR + LOADCP RUNTIMEERROR + CALL +_IF_END28_STDLIB: + LOAD 8 ; A + LOAD 16 ; C + SWAP + LOADCP _INTTOFLOAT32 + CALL + SWAP + LOADCP _ADDFLOAT32 + CALL + STORE 4 ; LN + LOAD 4 ; LN + FPADJ 36 + RET +SQRT: + FPADJ -28 + STORE 0 ; N + LOAD 0 ; N + LOADC 0 + LOADCP _CMPFLOAT32 + CALL + LOADC 0 + CMP LT + .LCBRANCHZ _IF_ELSE29_STDLIB + LOADCP MATHERROR ; MATHERROR + LOADCP RUNTIMEERROR + CALL + .LBRANCH _IF_END29_STDLIB +_IF_ELSE29_STDLIB: + LOAD 0 ; N + LOADC 0 + LOADCP _CMPFLOAT32 + CALL + LOADC 0 + CMP EQ + .LCBRANCHZ _IF_ELSE30_STDLIB + LOADC 0 + STORE 4 ; SQRT + .LBRANCH _IF_END30_STDLIB +_IF_ELSE30_STDLIB: + LOAD 0 ; N + LOADCP 1073741952 + LOADCP _DIVFLOAT32 + CALL + STORE 12 ; GUESS + LOAD 0 ; N + LOADCP 100000 + LOADCP _INTTOFLOAT32 + CALL + LOADCP _DIVFLOAT32 + CALL + STORE 8 ; ERROR + LOADC 0 + STORE 20 ; DIFF +_REPEAT_START1_STDLIB: + LOAD 20 ; DIFF + STORE 24 ; LASTDIFF + LOAD 12 ; GUESS + LOAD 0 ; N + LOAD 12 ; GUESS + LOADCP _DIVFLOAT32 + CALL + LOADCP _ADDFLOAT32 + CALL + LOADC -1 + LOADCP SHIFTFLOAT32 + CALL + STORE 16 ; NEWGUESS + LOAD 16 ; NEWGUESS + LOAD 12 ; GUESS + LOADCP _SUBFLOAT32 + CALL + LOADCP $7FFFFFFF + AND + STORE 20 ; DIFF + LOAD 16 ; NEWGUESS + STORE 12 ; GUESS + LOAD 20 ; DIFF + LOAD 8 ; ERROR + LOADCP _CMPFLOAT32 + CALL + LOADC 0 + CMP LT + LOAD 12 ; GUESS + LOADC 0 + LOADCP _CMPFLOAT32 + CALL + LOADC 0 + CMP EQ + OR + LOAD 20 ; DIFF + LOAD 24 ; LASTDIFF + LOADCP _CMPFLOAT32 + CALL + LOADC 0 + CMP EQ + OR + .LCBRANCHZ _REPEAT_START1_STDLIB +_REPEAT_END1_STDLIB: + LOAD 12 ; GUESS + STORE 4 ; SQRT +_IF_END30_STDLIB: +_IF_END29_STDLIB: + LOAD 4 ; SQRT + FPADJ 28 + RET +FLOOR: + FPADJ -8 + STORE 0 ; X + LOAD 0 ; X + LOADC 0 + LOADCP _CMPFLOAT32 + CALL + LOADC 0 + CMP LT + .LCBRANCHZ _IF_ELSE31_STDLIB + LOAD 0 ; X + LOADCP 2147483518 + LOADCP _SUBFLOAT32 + CALL + STORE 0 ; X +_IF_ELSE31_STDLIB: +_IF_END31_STDLIB: + LOAD 0 ; X + LOADCP _TRUNCFLOAT32 + CALL + STORE 4 ; FLOOR + LOAD 4 ; FLOOR + FPADJ 8 + RET +ROUND: + FPADJ -8 + STORE 0 ; X + LOAD 0 ; X + LOADCP 1073741950 + LOADCP _ADDFLOAT32 + CALL + LOADCP _TRUNCFLOAT32 + CALL + STORE 4 ; ROUND + LOAD 4 ; ROUND + FPADJ 8 + RET +_NST_STDLIB56SIN_TAYLOR: + FPADJ -28 + LOADREG BP + STORE 4 + DUP + STOREREG BP + STORE 0 + STORE 8 ; X + LOAD 8 ; X + LOAD 8 ; X + LOADCP _MULFLOAT32 + CALL + STORE 16 ; X2 + LOAD 16 ; X2 + LOAD 8 ; X + LOADCP _MULFLOAT32 + CALL + STORE 20 ; X3 + LOAD 20 ; X3 + LOAD 16 ; X2 + LOADCP _MULFLOAT32 + CALL + STORE 24 ; X5 + LOAD 8 ; X + LOAD 20 ; X3 + LOADCP 1610612865 + LOADCP _DIVFLOAT32 + CALL + LOADCP _SUBFLOAT32 + CALL + LOAD 24 ; X5 + LOADCP 2013266053 + LOADCP _DIVFLOAT32 + CALL + LOADCP _ADDFLOAT32 + CALL + STORE 12 ; SIN_TAYLOR + LOAD 12 ; SIN_TAYLOR + LOAD 4 + STOREREG BP + FPADJ 28 + RET +SIN: + FPADJ -24 + STORE 0 ; X + LOAD 0 ; X + LOADC 0 + LOADCP _INTTOFLOAT32 + CALL + LOADCP _CMPFLOAT32 + CALL + LOADC 0 + CMP LT + .LCBRANCHZ _IF_ELSE32_STDLIB + LOAD 0 ; X + LOADCP _NEGFLOAT32 + CALL + STORE 0 ; X + LOADC 1 + STORE 20 ; INVERT + .LBRANCH _IF_END32_STDLIB + .CPOOL +_IF_ELSE32_STDLIB: + LOADC 0 + STORE 20 ; INVERT +_IF_END32_STDLIB: + LOAD 0 ; X + LOADCP 1367130494 + LOADCP _MULFLOAT32 + CALL + LOADCP FLOOR + CALL + LOADCP _INTTOFLOAT32 + CALL + STORE 8 ; K + LOAD 0 ; X + LOAD 8 ; K + LOADCP 1686629759 + LOADCP _MULFLOAT32 + CALL + LOADCP _SUBFLOAT32 + CALL + STORE 12 ; Y + LOAD 8 ; K + LOADCP _TRUNCFLOAT32 + CALL + LOADC 4 + LOADCP _MOD + CALL + STORE 16 ; QUADRANT + LOAD 16 ; QUADRANT +_CASE_0_0_0_STDLIB: + DUP + LOADC 0 + CMP NE + .LCBRANCH _CASE_0_0_1_STDLIB +_CASE_0_0M_STDLIB: + LOAD 12 ; Y + LOADREG FP + LOADCP _NST_STDLIB56SIN_TAYLOR + CALL + STORE 4 ; SIN + .LBRANCH _CASE_0_STDLIB_END +_CASE_0_0_1_STDLIB: +_CASE_0_1_0_STDLIB: + DUP + LOADC 1 + CMP NE + .LCBRANCH _CASE_0_1_1_STDLIB +_CASE_0_1M_STDLIB: + LOADCP 1686629759 + LOAD 12 ; Y + LOADCP _SUBFLOAT32 + CALL + LOADREG FP + LOADCP _NST_STDLIB56SIN_TAYLOR + CALL + STORE 4 ; SIN + .LBRANCH _CASE_0_STDLIB_END +_CASE_0_1_1_STDLIB: +_CASE_0_2_0_STDLIB: + DUP + LOADC 2 + CMP NE + .LCBRANCH _CASE_0_2_1_STDLIB +_CASE_0_2M_STDLIB: + LOAD 12 ; Y + LOADREG FP + LOADCP _NST_STDLIB56SIN_TAYLOR + CALL + LOADCP _NEGFLOAT32 + CALL + STORE 4 ; SIN + .LBRANCH _CASE_0_STDLIB_END +_CASE_0_2_1_STDLIB: +_CASE_0_3_0_STDLIB: + DUP + LOADC 3 + CMP NE + .LCBRANCH _CASE_0_3_1_STDLIB +_CASE_0_3M_STDLIB: + LOADCP 1686629759 + LOAD 12 ; Y + LOADCP _SUBFLOAT32 + CALL + LOADREG FP + LOADCP _NST_STDLIB56SIN_TAYLOR + CALL + LOADCP _NEGFLOAT32 + CALL + STORE 4 ; SIN + .LBRANCH _CASE_0_STDLIB_END +_CASE_0_3_1_STDLIB: +_CASE_0_4_STDLIB: +_CASE_0_STDLIB_END: + DROP + LOAD 20 ; INVERT + .LCBRANCHZ _IF_ELSE33_STDLIB + LOAD 4 ; SIN + LOADCP _NEGFLOAT32 + CALL + STORE 4 ; SIN +_IF_ELSE33_STDLIB: +_IF_END33_STDLIB: + LOAD 4 ; SIN + FPADJ 24 + RET +COS: + FPADJ -8 + STORE 0 ; X + LOAD 0 ; X + LOADCP 1686629759 + LOADCP _ADDFLOAT32 + CALL + LOADCP SIN + CALL + STORE 4 ; COS + LOAD 4 ; COS + FPADJ 8 + RET +ARCTAN: + FPADJ -20 + STORE 0 ; X + LOAD 0 ; X + LOADC 0 + LOADCP _CMPFLOAT32 + CALL + LOADC 0 + CMP LT + .LCBRANCHZ _IF_ELSE34_STDLIB + LOAD 0 ; X + LOADCP _NEGFLOAT32 + CALL + STORE 0 ; X + LOADC 1 + STORE 16 ; NEGATE + .LBRANCH _IF_END34_STDLIB +_IF_ELSE34_STDLIB: + LOADC 0 + STORE 16 ; NEGATE +_IF_END34_STDLIB: + LOAD 0 ; X + LOADCP 1149555328 + LOADCP _CMPFLOAT32 + CALL + LOADC 0 + CMP GT + .LCBRANCHZ _IF_ELSE35_STDLIB + LOADCP 1686629759 + STORE 8 ; Y + LOADCP 1073741951 + LOAD 0 ; X + LOADCP _DIVFLOAT32 + CALL + LOADCP _NEGFLOAT32 + CALL + STORE 0 ; X + .LBRANCH _IF_END35_STDLIB +_IF_ELSE35_STDLIB: + LOAD 0 ; X + LOADCP 1779033725 + LOADCP _CMPFLOAT32 + CALL + LOADC 0 + CMP GT + .LCBRANCHZ _IF_ELSE36_STDLIB + LOADCP 1686629758 + STORE 8 ; Y + LOAD 0 ; X + LOADCP 1073741951 + LOADCP _SUBFLOAT32 + CALL + LOAD 0 ; X + LOADCP 1073741951 + LOADCP _ADDFLOAT32 + CALL + LOADCP _DIVFLOAT32 + CALL + STORE 0 ; X + .LBRANCH _IF_END36_STDLIB +_IF_ELSE36_STDLIB: + LOADC 0 + STORE 8 ; Y +_IF_END36_STDLIB: +_IF_END35_STDLIB: + LOAD 0 ; X + LOAD 0 ; X + LOADCP _MULFLOAT32 + CALL + STORE 12 ; Z + LOAD 8 ; Y + LOADCP 1383622779 + LOAD 12 ; Z + LOADCP _MULFLOAT32 + CALL + LOADCP 1192084092 + LOADCP _SUBFLOAT32 + CALL + LOAD 12 ; Z + LOADCP _MULFLOAT32 + CALL + LOADCP 1716072316 + LOADCP _ADDFLOAT32 + CALL + LOAD 12 ; Z + LOADCP _MULFLOAT32 + CALL + LOADCP 1431639165 + LOADCP _SUBFLOAT32 + CALL + LOAD 12 ; Z + LOADCP _MULFLOAT32 + CALL + LOAD 0 ; X + LOADCP _MULFLOAT32 + CALL + LOADCP _ADDFLOAT32 + CALL + LOAD 0 ; X + LOADCP _ADDFLOAT32 + CALL + STORE 8 ; Y + LOAD 16 ; NEGATE + .LCBRANCHZ _IF_ELSE37_STDLIB + LOAD 8 ; Y + LOADCP _NEGFLOAT32 + CALL + STORE 8 ; Y +_IF_ELSE37_STDLIB: +_IF_END37_STDLIB: + LOAD 8 ; Y + STORE 4 ; ARCTAN + LOAD 4 ; ARCTAN + FPADJ 20 + RET + .CPOOL +TANCOT: + FPADJ -32 + STORE 4 ; DOCOT + STORE 0 ; X + LOAD 0 ; X + LOADC 0 + LOADCP _INTTOFLOAT32 + CALL + LOADCP _CMPFLOAT32 + CALL + LOADC 0 + CMP LT + .LCBRANCHZ _IF_ELSE38_STDLIB + LOAD 0 ; X + LOADCP _NEGFLOAT32 + CALL + STORE 0 ; X + LOADC 1 + STORE 28 ; NEGATE + .LBRANCH _IF_END38_STDLIB +_IF_ELSE38_STDLIB: + LOADC 0 + STORE 28 ; NEGATE +_IF_END38_STDLIB: + LOAD 0 ; X + LOADCP 1073741964 + LOADCP _CMPFLOAT32 + CALL + LOADC 0 + CMP GT + .LCBRANCHZ _IF_ELSE39_STDLIB + LOADCP MATHERROR ; MATHERROR + LOADCP RUNTIMEERROR + CALL +_IF_ELSE39_STDLIB: +_IF_END39_STDLIB: + LOADCP 1367130495 + LOAD 0 ; X + LOADCP _MULFLOAT32 + CALL + LOADCP _TRUNCFLOAT32 + CALL + STORE 24 ; J + LOAD 24 ; J + LOADCP _INTTOFLOAT32 + CALL + STORE 12 ; Y + LOAD 24 ; J + LOADC 1 + AND + LOADC 0 + CMP NE + .LCBRANCHZ _IF_ELSE40_STDLIB + LOAD 24 ; J + LOADC 1 + ADD + STORE 24 ; J + LOAD 12 ; Y + LOADCP 1073741951 + LOADCP _ADDFLOAT32 + CALL + STORE 12 ; Y +_IF_ELSE40_STDLIB: +_IF_END40_STDLIB: + LOAD 0 ; X + LOAD 12 ; Y + LOADCP 1686110334 + LOADCP _MULFLOAT32 + CALL + LOADCP _SUBFLOAT32 + CALL + LOAD 12 ; Y + LOADCP 2127560562 + LOADCP _MULFLOAT32 + CALL + LOADCP _SUBFLOAT32 + CALL + LOAD 12 ; Y + LOADCP 1360049254 + LOADCP _MULFLOAT32 + CALL + LOADCP _SUBFLOAT32 + CALL + STORE 16 ; Z + LOAD 16 ; Z + LOAD 16 ; Z + LOADCP _MULFLOAT32 + CALL + STORE 20 ; ZZ + LOAD 0 ; X + LOADCP 1759218545 + LOADCP _CMPFLOAT32 + CALL + LOADC 0 + CMP GT + .LCBRANCHZ _IF_ELSE41_STDLIB + LOADCP 1289919864 + LOAD 20 ; ZZ + LOADCP _MULFLOAT32 + CALL + LOADCP 1715195510 + LOADCP _ADDFLOAT32 + CALL + LOAD 20 ; ZZ + LOADCP _MULFLOAT32 + CALL + LOADCP 1678826105 + LOADCP _ADDFLOAT32 + CALL + LOAD 20 ; ZZ + LOADCP _MULFLOAT32 + CALL + LOADCP 1835197562 + LOADCP _ADDFLOAT32 + CALL + LOAD 20 ; ZZ + LOADCP _MULFLOAT32 + CALL + LOADCP 1145794172 + LOADCP _ADDFLOAT32 + CALL + LOAD 20 ; ZZ + LOADCP _MULFLOAT32 + CALL + LOADCP 1431648125 + LOADCP _ADDFLOAT32 + CALL + LOAD 20 ; ZZ + LOADCP _MULFLOAT32 + CALL + LOAD 16 ; Z + LOADCP _MULFLOAT32 + CALL + LOAD 16 ; Z + LOADCP _ADDFLOAT32 + CALL + STORE 12 ; Y + .LBRANCH _IF_END41_STDLIB +_IF_ELSE41_STDLIB: + LOAD 16 ; Z + STORE 12 ; Y +_IF_END41_STDLIB: + LOAD 24 ; J + LOADC 2 + AND + LOADC 0 + CMP NE + .LCBRANCHZ _IF_ELSE42_STDLIB + LOAD 4 ; DOCOT + .LCBRANCHZ _IF_ELSE43_STDLIB + LOAD 12 ; Y + LOADCP _NEGFLOAT32 + CALL + STORE 12 ; Y + .LBRANCH _IF_END43_STDLIB +_IF_ELSE43_STDLIB: + LOADCP -1073741697 + LOAD 12 ; Y + LOADCP _DIVFLOAT32 + CALL + STORE 12 ; Y +_IF_END43_STDLIB: + .LBRANCH _IF_END42_STDLIB +_IF_ELSE42_STDLIB: + LOAD 4 ; DOCOT + .LCBRANCHZ _IF_ELSE44_STDLIB + LOADCP 1073741951 + LOAD 12 ; Y + LOADCP _DIVFLOAT32 + CALL + STORE 12 ; Y +_IF_ELSE44_STDLIB: +_IF_END44_STDLIB: +_IF_END42_STDLIB: + LOAD 28 ; NEGATE + .LCBRANCHZ _IF_ELSE45_STDLIB + LOAD 12 ; Y + LOADCP _NEGFLOAT32 + CALL + STORE 12 ; Y +_IF_ELSE45_STDLIB: +_IF_END45_STDLIB: + LOAD 12 ; Y + STORE 8 ; TANCOT + LOAD 8 ; TANCOT + FPADJ 32 + RET +TAN: + FPADJ -8 + STORE 0 ; X + LOAD 0 ; X + LOADC 0 + LOADCP TANCOT + CALL + STORE 4 ; TAN + LOAD 4 ; TAN + FPADJ 8 + RET +COTAN: + FPADJ -8 + STORE 0 ; X + LOAD 0 ; X + LOADC 1 + LOADCP TANCOT + CALL + STORE 4 ; COTAN + LOAD 4 ; COTAN + FPADJ 8 + RET + .CPOOL +FILLCHAR: + FPADJ -28 + STORE 12 ; THECHAR + STORE 8 ; COUNT + STORE 4 ; STARTPOS + STORE 0 ; S + LOAD 0 ; S + LOADCP LENGTH + CALL + STORE 20 ; ENDPOS + LOAD 0 ; S + LOAD 20 ; ENDPOS + LOAD 8 ; COUNT + ADD + LOADCP _SETSTRINGLENGTH + CALL + LOAD 4 ; STARTPOS + LOAD 8 ; COUNT + ADD + STORE 24 ; P1 + LOAD 20 ; ENDPOS + STORE 16 ; I + LOAD 4 ; STARTPOS +_FOR_START4_STDLIB: + LOAD 16 ; I + OVER + CMP LT + .LCBRANCH _FOR_END4_STDLIB + LOAD 0 ; S + LOAD 16 ; I + LOAD 8 ; COUNT + ADD + LOADCP _INDEXSTRING + CALL + LOAD 0 ; S + LOAD 16 ; I + LOADCP _INDEXSTRING + CALL + LOADI.S1.X2Y + BSEL + LOADCP _SETSTRINGCHAR + CALL + LOAD 16 ; I + DEC 1 + STORE 16 ; I + .LBRANCH _FOR_START4_STDLIB +_FOR_END4_STDLIB: + DROP + LOAD 24 ; P1 + LOADC 1 + SUB + STORE 24 ; P1 + LOAD 4 ; STARTPOS + STORE 16 ; I + LOAD 24 ; P1 +_FOR_START5_STDLIB: + LOAD 16 ; I + OVER + CMP GT + .LCBRANCH _FOR_END5_STDLIB + LOAD 0 ; S + LOAD 16 ; I + LOADCP _INDEXSTRING + CALL + LOAD 12 ; THECHAR + LOADCP _SETSTRINGCHAR + CALL + LOAD 16 ; I + INC 1 + STORE 16 ; I + .LBRANCH _FOR_START5_STDLIB +_FOR_END5_STDLIB: + DROP + FPADJ 28 + RET +INTSTR: + FPADJ -44 + STORE 8 ; RBUF + STORE 4 ; FIELDWIDTH + STORE 0 ; V + LOADC 12 + ; BUF + LOADREG FP + INC 12 + LOADCP _INITSTRINGF + CALL + ; BUF + LOADREG FP + INC 12 + LOADCP _C_S_3_STDLIB + LOADCP _COPYSTRING + CALL + LOADC 0 + STORE 40 ; ISNEGATIVE + LOAD 0 ; V + LOADCP -2147483648 + CMP EQ + .LCBRANCHZ _IF_ELSE46_STDLIB + ; BUF + LOADREG FP + INC 12 + LOADCP _C_S_4_STDLIB + LOADCP _COPYSTRING + CALL + LOADC 1 + STORE 40 ; ISNEGATIVE + .LBRANCH _IF_END46_STDLIB +_IF_ELSE46_STDLIB: + LOAD 0 ; V + LOADC 0 + CMP LT + .LCBRANCHZ _IF_ELSE47_STDLIB + LOADC 1 + STORE 40 ; ISNEGATIVE + LOAD 0 ; V + NOT + INC 1 + STORE 0 ; V +_IF_ELSE47_STDLIB: +_IF_END47_STDLIB: +_REPEAT_START2_STDLIB: + LOAD 0 ; V + LOADC 10 + LOADCP _MOD + CALL + STORE 32 ; DIGIT + LOAD 0 ; V + LOADC 10 + LOADCP _DIV + CALL + STORE 0 ; V + ; BUF + LOADREG FP + INC 12 + ; BUF + LOADREG FP + INC 12 + LOADREG FP + LOADC 92 + SUB + SWAP + LOADC 80 + FPADJ -92 + LOADCP _INITSTRINGFROM + CALL + FPADJ 92 + LOADREG FP + LOADC 92 + SUB + LOAD 32 ; DIGIT + LOADC 48 + ADD + LOADREG FP + LOADC 104 + SUB + SWAP + OVER + LOADCP _CHARTOSTRING + CALL + FPADJ -104 + LOADCP _APPENDSTRING + CALL + FPADJ 104 + LOADREG FP + LOADC 92 + SUB + FPADJ -104 + LOADCP _COPYSTRING + CALL + FPADJ 104 + LOAD 0 ; V + LOADC 0 + CMP EQ + .LCBRANCHZ _REPEAT_START2_STDLIB +_REPEAT_END2_STDLIB: +_IF_END46_STDLIB: + LOAD 8 ; RBUF + LOADCP _C_S_3_STDLIB + LOADCP _COPYSTRING + CALL + LOAD 40 ; ISNEGATIVE + .LCBRANCHZ _IF_ELSE48_STDLIB + LOAD 8 ; RBUF + LOAD 8 ; RBUF + LOADREG FP + LOADC 88 + SUB + SWAP + LOADC 80 + FPADJ -88 + LOADCP _INITSTRINGFROM + CALL + FPADJ 88 + LOADREG FP + LOADC 88 + SUB + LOADCP _C_S_2_STDLIB + FPADJ -88 + LOADCP _APPENDSTRING + CALL + FPADJ 88 + LOADREG FP + LOADC 88 + SUB + FPADJ -88 + LOADCP _COPYSTRING + CALL + FPADJ 88 +_IF_ELSE48_STDLIB: +_IF_END48_STDLIB: + LOAD 4 ; FIELDWIDTH + LOAD 8 ; RBUF + LOADCP LENGTH + CALL + CMP GT + .LCBRANCHZ _IF_ELSE49_STDLIB + LOAD 8 ; RBUF + LOADC 1 + LOAD 4 ; FIELDWIDTH + LOAD 8 ; RBUF + LOADCP LENGTH + CALL + SUB + LOADC 32 + LOADCP FILLCHAR + CALL +_IF_ELSE49_STDLIB: +_IF_END49_STDLIB: + ; BUF + LOADREG FP + INC 12 + LOADCP LENGTH + CALL + STORE 36 ; I + LOADC 1 +_FOR_START6_STDLIB: + LOAD 36 ; I + OVER + CMP LT + .LCBRANCH _FOR_END6_STDLIB + LOAD 8 ; RBUF + LOAD 8 ; RBUF + LOADREG FP + LOADC 88 + SUB + SWAP + LOADC 80 + FPADJ -88 + LOADCP _INITSTRINGFROM + CALL + FPADJ 88 + LOADREG FP + LOADC 88 + SUB + ; BUF + LOADREG FP + INC 12 + LOAD 36 ; I + LOADCP _INDEXSTRING + CALL + LOADI.S1.X2Y + BSEL + LOADREG FP + LOADC 100 + SUB + SWAP + OVER + LOADCP _CHARTOSTRING + CALL + FPADJ -100 + LOADCP _APPENDSTRING + CALL + FPADJ 100 + LOADREG FP + LOADC 88 + SUB + FPADJ -100 + LOADCP _COPYSTRING + CALL + FPADJ 100 + LOAD 36 ; I + DEC 1 + STORE 36 ; I + .LBRANCH _FOR_START6_STDLIB + .CPOOL +_FOR_END6_STDLIB: + DROP + FPADJ 44 + RET +REALSTR: + FPADJ -32 + STORE 12 ; S + STORE 8 ; D + STORE 4 ; W + STORE 0 ; X + LOAD 4 ; W + LOADC 0 + CMP LT + LOAD 8 ; D + LOADC 0 + CMP LT + OR + .LCBRANCHZ _IF_ELSE50_STDLIB + LOADC 0 + STORE 4 ; W + LOADC 0 + STORE 8 ; D +_IF_ELSE50_STDLIB: +_IF_END50_STDLIB: + LOAD 0 ; X + LOADC 0 + LOADCP _INTTOFLOAT32 + CALL + LOADCP _CMPFLOAT32 + CALL + LOADC 0 + CMP LT + .LCBRANCHZ _IF_ELSE51_STDLIB + LOAD 0 ; X + LOADCP _NEGFLOAT32 + CALL + STORE 0 ; X + LOAD 12 ; S + LOADCP _C_S_2_STDLIB + LOADCP _COPYSTRING + CALL + .LBRANCH _IF_END51_STDLIB +_IF_ELSE51_STDLIB: + LOAD 12 ; S + LOADCP _C_S_5_STDLIB + LOADCP _COPYSTRING + CALL +_IF_END51_STDLIB: + LOADC 0 + STORE 24 ; EXPX + LOAD 0 ; X + STORE 28 ; NORMX + LOAD 0 ; X + LOADCP 1073741951 + LOADCP _CMPFLOAT32 + CALL + LOADC 0 + CMP GE + .LCBRANCHZ _IF_ELSE52_STDLIB +_WHILE_START7_STDLIB: + LOAD 28 ; NORMX + LOADCP 1342177410 + LOADCP _CMPFLOAT32 + CALL + LOADC 0 + CMP GE + .LCBRANCHZ _WHILE_END7_STDLIB + LOAD 24 ; EXPX + LOADC 1 + ADD + STORE 24 ; EXPX + LOAD 0 ; X + LOAD 24 ; EXPX + LOADCP PWROFTEN + CALL + LOADCP _DIVFLOAT32 + CALL + STORE 28 ; NORMX + .LBRANCH _WHILE_START7_STDLIB +_WHILE_END7_STDLIB: + .LBRANCH _IF_END52_STDLIB +_IF_ELSE52_STDLIB: + LOAD 0 ; X + LOADC 0 + LOADCP _INTTOFLOAT32 + CALL + LOADCP _CMPFLOAT32 + CALL + LOADC 0 + CMP NE + .LCBRANCHZ _IF_ELSE53_STDLIB +_REPEAT_START3_STDLIB: + LOAD 24 ; EXPX + LOADC 1 + SUB + STORE 24 ; EXPX + LOAD 0 ; X + LOAD 24 ; EXPX + NOT + INC 1 + LOADCP PWROFTEN + CALL + LOADCP _MULFLOAT32 + CALL + STORE 28 ; NORMX + LOAD 28 ; NORMX + LOADC 1 + LOADCP _INTTOFLOAT32 + CALL + LOADCP _CMPFLOAT32 + CALL + LOADC 0 + CMP GE + .LCBRANCHZ _REPEAT_START3_STDLIB +_REPEAT_END3_STDLIB: +_IF_ELSE53_STDLIB: +_IF_END53_STDLIB: +_IF_END52_STDLIB: + LOAD 8 ; D + LOADC 0 + CMP EQ + LOAD 8 ; D + LOAD 24 ; EXPX + ADD + LOADC 1 + ADD + LOADC 7 + CMP GT + OR + .LCBRANCHZ _IF_ELSE54_STDLIB + LOAD 28 ; NORMX + LOADC 5 + LOADCP _INTTOFLOAT32 + CALL + LOADC 7 + LOADCP PWROFTEN + CALL + LOADCP _DIVFLOAT32 + CALL + LOADCP _ADDFLOAT32 + CALL + STORE 28 ; NORMX + .LBRANCH _IF_END54_STDLIB +_IF_ELSE54_STDLIB: + LOAD 8 ; D + LOAD 24 ; EXPX + ADD + LOADC 1 + ADD + LOADC 0 + LOADCP _CMPINTFLOAT32 + CALL + LOADC 0 + CMP GE + .LCBRANCHZ _IF_ELSE55_STDLIB + LOAD 28 ; NORMX + LOADC 5 + LOADCP _INTTOFLOAT32 + CALL + LOAD 8 ; D + LOAD 24 ; EXPX + ADD + LOADC 1 + ADD + LOADCP PWROFTEN + CALL + LOADCP _DIVFLOAT32 + CALL + LOADCP _ADDFLOAT32 + CALL + STORE 28 ; NORMX +_IF_ELSE55_STDLIB: +_IF_END55_STDLIB: +_IF_END54_STDLIB: + LOAD 28 ; NORMX + LOADCP 1342177410 + LOADCP _CMPFLOAT32 + CALL + LOADC 0 + CMP GE + .LCBRANCHZ _IF_ELSE56_STDLIB + LOAD 24 ; EXPX + LOADC 1 + ADD + STORE 24 ; EXPX + LOAD 28 ; NORMX + LOADCP 1342177410 + LOADCP _DIVFLOAT32 + CALL + STORE 28 ; NORMX +_IF_ELSE56_STDLIB: +_IF_END56_STDLIB: + LOADC 1 + STORE 16 ; J + LOADC 7 +_FOR_START7_STDLIB: + LOAD 16 ; J + OVER + CMP GT + .LCBRANCH _FOR_END7_STDLIB + LOAD 28 ; NORMX + LOADCP _TRUNCFLOAT32 + CALL + STORE 20 ; TRUNCX + LOAD 12 ; S + LOAD 12 ; S + LOADREG FP + LOADC 92 + SUB + SWAP + LOADC 80 + FPADJ -92 + LOADCP _INITSTRINGFROM + CALL + FPADJ 92 + LOADREG FP + LOADC 92 + SUB + LOAD 20 ; TRUNCX + LOADC 48 + ADD + LOADREG FP + LOADC 104 + SUB + SWAP + OVER + LOADCP _CHARTOSTRING + CALL + FPADJ -104 + LOADCP _APPENDSTRING + CALL + FPADJ 104 + LOADREG FP + LOADC 92 + SUB + FPADJ -104 + LOADCP _COPYSTRING + CALL + FPADJ 104 + LOAD 28 ; NORMX + LOAD 20 ; TRUNCX + LOADCP _INTTOFLOAT32 + CALL + LOADCP _SUBFLOAT32 + CALL + LOADC 1 + LOADCP PWROFTEN + CALL + LOADCP _MULFLOAT32 + CALL + STORE 28 ; NORMX + LOAD 16 ; J + INC 1 + STORE 16 ; J + .LBRANCH _FOR_START7_STDLIB + .CPOOL +_FOR_END7_STDLIB: + DROP + LOAD 8 ; D + LOADC 0 + CMP EQ + LOAD 24 ; EXPX + LOADC 6 + CMP GE + OR + .LCBRANCHZ _IF_ELSE57_STDLIB + LOADC 46 + LOADREG FP + DEC 12 + SWAP + OVER + LOADCP _CHARTOSTRING + CALL + LOAD 12 ; S + LOADC 3 + FPADJ -12 + LOADCP INSERT + CALL + FPADJ 12 + LOAD 24 ; EXPX + LOADC 0 + CMP NE + .LCBRANCHZ _IF_ELSE58_STDLIB + LOAD 12 ; S + LOAD 12 ; S + LOADREG FP + LOADC 92 + SUB + SWAP + LOADC 80 + FPADJ -92 + LOADCP _INITSTRINGFROM + CALL + FPADJ 92 + LOADREG FP + LOADC 92 + SUB + LOADCP _C_S_6_STDLIB + FPADJ -92 + LOADCP _APPENDSTRING + CALL + FPADJ 92 + LOADREG FP + LOADC 92 + SUB + FPADJ -92 + LOADCP _COPYSTRING + CALL + FPADJ 92 + LOAD 24 ; EXPX + LOADC 0 + CMP LT + .LCBRANCHZ _IF_ELSE59_STDLIB + LOAD 12 ; S + LOAD 12 ; S + LOADREG FP + LOADC 92 + SUB + SWAP + LOADC 80 + FPADJ -92 + LOADCP _INITSTRINGFROM + CALL + FPADJ 92 + LOADREG FP + LOADC 92 + SUB + LOADCP _C_S_2_STDLIB + FPADJ -92 + LOADCP _APPENDSTRING + CALL + FPADJ 92 + LOADREG FP + LOADC 92 + SUB + FPADJ -92 + LOADCP _COPYSTRING + CALL + FPADJ 92 + LOAD 24 ; EXPX + NOT + INC 1 + STORE 24 ; EXPX +_IF_ELSE59_STDLIB: +_IF_END59_STDLIB: + LOAD 24 ; EXPX + LOADC 9 + CMP GT + .LCBRANCHZ _IF_ELSE60_STDLIB + LOAD 12 ; S + LOAD 12 ; S + LOADREG FP + LOADC 92 + SUB + SWAP + LOADC 80 + FPADJ -92 + LOADCP _INITSTRINGFROM + CALL + FPADJ 92 + LOADREG FP + LOADC 92 + SUB + LOAD 24 ; EXPX + LOADC 10 + FPADJ -92 + LOADCP _DIV + CALL + FPADJ 92 + LOADC 48 + ADD + LOADREG FP + LOADC 104 + SUB + SWAP + OVER + LOADCP _CHARTOSTRING + CALL + FPADJ -104 + LOADCP _APPENDSTRING + CALL + FPADJ 104 + LOADREG FP + LOADC 92 + SUB + FPADJ -104 + LOADCP _COPYSTRING + CALL + FPADJ 104 +_IF_ELSE60_STDLIB: +_IF_END60_STDLIB: + LOAD 12 ; S + LOAD 12 ; S + LOADREG FP + LOADC 92 + SUB + SWAP + LOADC 80 + FPADJ -92 + LOADCP _INITSTRINGFROM + CALL + FPADJ 92 + LOADREG FP + LOADC 92 + SUB + LOAD 24 ; EXPX + LOADC 10 + FPADJ -92 + LOADCP _MOD + CALL + FPADJ 92 + LOADC 48 + ADD + LOADREG FP + LOADC 104 + SUB + SWAP + OVER + LOADCP _CHARTOSTRING + CALL + FPADJ -104 + LOADCP _APPENDSTRING + CALL + FPADJ 104 + LOADREG FP + LOADC 92 + SUB + FPADJ -104 + LOADCP _COPYSTRING + CALL + FPADJ 104 +_IF_ELSE58_STDLIB: +_IF_END58_STDLIB: + .LBRANCH _IF_END57_STDLIB +_IF_ELSE57_STDLIB: + LOAD 24 ; EXPX + LOADC 0 + CMP GE + .LCBRANCHZ _IF_ELSE61_STDLIB + LOADC 46 + LOADREG FP + DEC 12 + SWAP + OVER + LOADCP _CHARTOSTRING + CALL + LOAD 12 ; S + LOADC 3 + LOAD 24 ; EXPX + ADD + FPADJ -12 + LOADCP INSERT + CALL + FPADJ 12 + LOADC 1 + STORE 16 ; J + LOAD 8 ; D + LOADC 5 + LOAD 24 ; EXPX + SUB + SUB +_FOR_START8_STDLIB: + LOAD 16 ; J + OVER + CMP GT + .LCBRANCH _FOR_END8_STDLIB + LOAD 12 ; S + LOAD 12 ; S + LOADREG FP + LOADC 92 + SUB + SWAP + LOADC 80 + FPADJ -92 + LOADCP _INITSTRINGFROM + CALL + FPADJ 92 + LOADREG FP + LOADC 92 + SUB + LOADCP _C_S_5_STDLIB + FPADJ -92 + LOADCP _APPENDSTRING + CALL + FPADJ 92 + LOADREG FP + LOADC 92 + SUB + FPADJ -92 + LOADCP _COPYSTRING + CALL + FPADJ 92 + LOAD 16 ; J + INC 1 + STORE 16 ; J + .LBRANCH _FOR_START8_STDLIB + .CPOOL +_FOR_END8_STDLIB: + DROP + LOAD 12 ; S + LOADC 3 + LOAD 24 ; EXPX + ADD + LOAD 8 ; D + ADD + LOADCP _SETSTRINGLENGTH + CALL + .LBRANCH _IF_END61_STDLIB +_IF_ELSE61_STDLIB: + LOADCP _C_S_7_STDLIB + LOAD 12 ; S + LOADC 2 + LOADCP INSERT + CALL + LOADC 1 + STORE 16 ; J + LOAD 24 ; EXPX + NOT + INC 1 + LOADC 1 + SUB +_FOR_START9_STDLIB: + LOAD 16 ; J + OVER + CMP GT + .LCBRANCH _FOR_END9_STDLIB + LOADC 48 + LOADREG FP + DEC 12 + SWAP + OVER + LOADCP _CHARTOSTRING + CALL + LOAD 12 ; S + LOADC 4 + FPADJ -12 + LOADCP INSERT + CALL + FPADJ 12 + LOAD 16 ; J + INC 1 + STORE 16 ; J + .LBRANCH _FOR_START9_STDLIB +_FOR_END9_STDLIB: + DROP + LOAD 12 ; S + LOADC 3 + LOAD 8 ; D + ADD + LOADCP _SETSTRINGLENGTH + CALL +_IF_END61_STDLIB: +_IF_END57_STDLIB: + LOAD 4 ; W + LOAD 12 ; S + LOADCP LENGTH + CALL + CMP GT + .LCBRANCHZ _IF_ELSE62_STDLIB + LOAD 12 ; S + LOADC 1 + LOAD 4 ; W + LOAD 12 ; S + LOADCP LENGTH + CALL + SUB + LOADC 32 + LOADCP FILLCHAR + CALL +_IF_ELSE62_STDLIB: +_IF_END62_STDLIB: + FPADJ 32 + RET +ISDIGIT: + FPADJ -8 + STORE 0 ; ACHAR + LOAD 0 ; ACHAR + LOADC 48 + CMP GE + LOAD 0 ; ACHAR + LOADC 57 + CMP LE + AND + STORE 4 ; ISDIGIT + LOAD 4 ; ISDIGIT + FPADJ 8 + RET +ISWHITE: + FPADJ -8 + STORE 0 ; ACHAR + LOAD 0 ; ACHAR + LOADCP _C_A_5_STDLIB + LOADC 4 + LOADCP _ISINTINARRAY + CALL + STORE 4 ; ISWHITE + LOAD 4 ; ISWHITE + FPADJ 8 + RET +SKIPWHITE: + FPADJ -16 + STORE 4 ; I + STORE 0 ; S + LOAD 0 ; S + DUP + LOADI + SWAP + INC 8 +_FOR_START10_STDLIB: + OVER + .LCBRANCHZ _FOR_END10_STDLIB + DUP + LOADI.S1.X2Y + BSEL + STORE 12 ; C + LOAD 12 ; C + LOADCP _C_A_6_STDLIB + LOADC 4 + LOADCP _ISINTINARRAY + CALL + LOADC 0 + CMP EQ + .LCBRANCHZ _IF_ELSE63_STDLIB + .LBRANCH _FOR_END10_STDLIB + .LBRANCH _IF_END63_STDLIB +_IF_ELSE63_STDLIB: + LOAD 4 ; I + LOAD 4 ; I + LOADI + LOADC 1 + ADD + STOREI + DROP +_IF_END63_STDLIB: + INC 1 + SWAP + DEC 1 + SWAP + .LBRANCH _FOR_START10_STDLIB +_FOR_END10_STDLIB: + DROP + DROP + FPADJ 16 + RET +INTVAL: + FPADJ -124 + STORE 92 ; CODE + STORE 88 ; VALUE + ; S + LOADREG FP + SWAP + LOADC 80 + LOADCP _INITSTRINGFROM + CALL + LOADC 1 + STORE 96 ; I + LOADC 0 + STORE 100 ; V + ; S + LOADREG FP + LOADCP LENGTH + CALL + STORE 104 ; L + LOADC 0 + STORE 116 ; NEGATE + LOADC 0 + STORE 120 ; VALID + ; S + LOADREG FP + ; I + LOADREG FP + LOADC 96 + ADD + LOADCP SKIPWHITE + CALL + LOAD 92 ; CODE + LOAD 104 ; L + LOADC 1 + ADD + STOREI + DROP + ; S + LOADREG FP + LOADCP LENGTH + CALL + LOAD 96 ; I + CMP GE + .LCBRANCHZ _IF_ELSE64_STDLIB + ; S + LOADREG FP + LOAD 96 ; I + LOADCP _INDEXSTRING + CALL + LOADI.S1.X2Y + BSEL + STORE 112 ; DIGIT + LOAD 112 ; DIGIT + LOADC 45 + CMP EQ + .LCBRANCHZ _IF_ELSE65_STDLIB + LOADC 1 + STORE 116 ; NEGATE + LOAD 96 ; I + LOADC 1 + ADD + STORE 96 ; I + .LBRANCH _IF_END65_STDLIB + .CPOOL +_IF_ELSE65_STDLIB: + LOAD 112 ; DIGIT + LOADC 43 + CMP EQ + .LCBRANCHZ _IF_ELSE66_STDLIB + LOAD 96 ; I + LOADC 1 + ADD + STORE 96 ; I +_IF_ELSE66_STDLIB: +_IF_END66_STDLIB: +_IF_END65_STDLIB: +_WHILE_START8_STDLIB: + LOAD 96 ; I + LOAD 104 ; L + CMP LE + .LCBRANCHZ _WHILE_END8_STDLIB + ; S + LOADREG FP + LOAD 96 ; I + LOADCP _INDEXSTRING + CALL + LOADI.S1.X2Y + BSEL + STORE 112 ; DIGIT + LOAD 112 ; DIGIT + LOADCP ISDIGIT + CALL + STORE 120 ; VALID + LOAD 120 ; VALID + .LCBRANCHZ _IF_ELSE67_STDLIB + LOAD 112 ; DIGIT + LOADC 48 + SUB + STORE 108 ; D + LOAD 100 ; V + LOADC 10 + LOADCP _MUL + CALL + LOAD 108 ; D + ADD + STORE 100 ; V + .LBRANCH _IF_END67_STDLIB +_IF_ELSE67_STDLIB: + LOAD 92 ; CODE + LOAD 96 ; I + STOREI + DROP + .LBRANCH _WHILE_END8_STDLIB +_IF_END67_STDLIB: + LOAD 96 ; I + LOADC 1 + ADD + STORE 96 ; I + .LBRANCH _WHILE_START8_STDLIB +_WHILE_END8_STDLIB: +_IF_ELSE64_STDLIB: +_IF_END64_STDLIB: + LOAD 120 ; VALID + LOAD 96 ; I + LOAD 104 ; L + LOADC 1 + ADD + CMP EQ + AND + .LCBRANCHZ _IF_ELSE68_STDLIB + LOAD 116 ; NEGATE + .LCBRANCHZ _IF_ELSE69_STDLIB + LOAD 88 ; VALUE + LOAD 100 ; V + NOT + INC 1 + STOREI + DROP + .LBRANCH _IF_END69_STDLIB +_IF_ELSE69_STDLIB: + LOAD 88 ; VALUE + LOAD 100 ; V + STOREI + DROP +_IF_END69_STDLIB: + LOAD 92 ; CODE + LOADC 0 + STOREI + DROP +_IF_ELSE68_STDLIB: +_IF_END68_STDLIB: + FPADJ 124 + RET +_NST_STDLIB70NEXTCHAR: + FPADJ -12 + LOADREG BP + STORE 4 + DUP + STOREREG BP + STORE 0 + LOAD.B 116 ; I + ; S + LOADREG BP + LOADCP LENGTH + CALL + CMP LE + .LCBRANCHZ _IF_ELSE70_STDLIB + ; S + LOADREG BP + LOAD.B 116 ; I + LOADCP _INDEXSTRING + CALL + LOADI.S1.X2Y + BSEL + STORE 8 ; NEXTCHAR + LOAD.B 116 ; I + LOADC 1 + ADD + STORE.B 116 ; I + LOADC 0 + STORE.B 120 ; FEOF + .LBRANCH _IF_END70_STDLIB +_IF_ELSE70_STDLIB: + LOADC 0 + STORE 8 ; NEXTCHAR + LOADC 1 + STORE.B 120 ; FEOF +_IF_END70_STDLIB: + LOAD 8 ; NEXTCHAR + LOAD 4 + STOREREG BP + FPADJ 12 + RET +_NST_STDLIB71SREADINT: + FPADJ -28 + LOADREG BP + STORE 4 + DUP + STOREREG BP + STORE 0 + STORE 8 ; E + LOADC 4 + ; DIGITS + LOADREG FP + INC 12 + LOADCP _INITSTRINGF + CALL + LOAD 8 ; E + LOADC 0 + STOREI + DROP + ; DIGITS + LOADREG FP + INC 12 + ; S + LOADREG BP + LOAD.B 116 ; I + LOADC 4 + LOADC 80 + LOADREG FP + LOADC 88 + SUB + LOADCP _INITSTRINGF + CALL + LOADREG FP + LOADC 88 + SUB + FPADJ -88 + LOADCP COPY + CALL + FPADJ 88 + FPADJ -88 + LOADCP _COPYSTRING + CALL + FPADJ 88 + ; DIGITS + LOADREG FP + INC 12 + LOAD 8 ; E + ; STATUS + LOADREG FP + LOADC 24 + ADD + LOADCP INTVAL + CALL + LOAD 24 ; STATUS + LOADC 0 + CMP NE + .LCBRANCHZ _IF_ELSE71_STDLIB + LOAD.B 116 ; I + LOAD 24 ; STATUS + ADD + STORE.B 116 ; I + LOADC 0 + STORE.B 104 ; XVALID + .LBRANCH _IF_END71_STDLIB +_IF_ELSE71_STDLIB: + LOAD.B 116 ; I + ; DIGITS + LOADREG FP + INC 12 + LOADCP LENGTH + CALL + ADD + STORE.B 116 ; I +_IF_END71_STDLIB: + LOAD 4 + STOREREG BP + FPADJ 28 + RET +REALVAL: + FPADJ -128 + STORE 92 ; CODE + STORE 88 ; V + ; S + LOADREG FP + SWAP + LOADC 80 + LOADCP _INITSTRINGFROM + CALL + LOADC 1 + STORE 116 ; I + LOADC 0 + LOADCP _INTTOFLOAT32 + CALL + STORE 112 ; X + LOADC 0 + STORE 100 ; NEG + LOADC 0 + STORE 104 ; XVALID + ; S + LOADREG FP + ; I + LOADREG FP + LOADC 116 + ADD + LOADCP SKIPWHITE + CALL + LOADREG FP + LOADCP _NST_STDLIB70NEXTCHAR + CALL + STORE 96 ; CH + LOAD 96 ; CH + LOADC 43 + CMP EQ + LOAD 96 ; CH + LOADC 45 + CMP EQ + OR + .LCBRANCHZ _IF_ELSE72_STDLIB + LOAD 96 ; CH + LOADC 45 + CMP EQ + STORE 100 ; NEG + LOADREG FP + LOADCP _NST_STDLIB70NEXTCHAR + CALL + STORE 96 ; CH +_IF_ELSE72_STDLIB: +_IF_END72_STDLIB: +_WHILE_START9_STDLIB: + LOAD 96 ; CH + LOADCP ISDIGIT + CALL + LOAD 120 ; FEOF + LOADC 0 + CMP EQ + AND + .LCBRANCHZ _WHILE_END9_STDLIB + LOADC 1 + STORE 104 ; XVALID + LOAD 112 ; X + LOADC 10 + LOADCP _INTTOFLOAT32 + CALL + LOADCP _MULFLOAT32 + CALL + LOAD 96 ; CH + LOADC 48 + SUB + LOADCP _INTTOFLOAT32 + CALL + LOADCP _ADDFLOAT32 + CALL + STORE 112 ; X + LOADREG FP + LOADCP _NST_STDLIB70NEXTCHAR + CALL + STORE 96 ; CH + .LBRANCH _WHILE_START9_STDLIB + .CPOOL +_WHILE_END9_STDLIB: + LOAD 120 ; FEOF + .LCBRANCHZ _IF_ELSE73_STDLIB + .LBRANCH _L69EXT_STDLIB +_IF_ELSE73_STDLIB: +_IF_END73_STDLIB: + LOADC -1 + STORE 108 ; IPOT + LOAD 96 ; CH + LOADC 46 + CMP EQ + .LCBRANCHZ _IF_ELSE74_STDLIB + LOADC 0 + STORE 108 ; IPOT +_REPEAT_START4_STDLIB: + LOADREG FP + LOADCP _NST_STDLIB70NEXTCHAR + CALL + STORE 96 ; CH + LOAD 96 ; CH + LOADCP ISDIGIT + CALL + .LCBRANCHZ _IF_ELSE75_STDLIB + LOADC 1 + STORE 104 ; XVALID + LOAD 108 ; IPOT + LOADC 1 + ADD + STORE 108 ; IPOT + LOAD 96 ; CH + LOADC 48 + SUB + LOADCP _INTTOFLOAT32 + CALL + LOAD 108 ; IPOT + LOADCP PWROFTEN + CALL + LOADCP _DIVFLOAT32 + CALL + STORE 124 ; DIGITVAL + LOAD 112 ; X + LOAD 124 ; DIGITVAL + LOADCP _ADDFLOAT32 + CALL + STORE 112 ; X +_IF_ELSE75_STDLIB: +_IF_END75_STDLIB: + LOAD 120 ; FEOF + LOAD 96 ; CH + LOADCP ISDIGIT + CALL + LOADC 0 + CMP EQ + OR + .LCBRANCHZ _REPEAT_START4_STDLIB +_REPEAT_END4_STDLIB: + LOAD 120 ; FEOF + .LCBRANCHZ _IF_ELSE76_STDLIB + .LBRANCH _L69EXT_STDLIB +_IF_ELSE76_STDLIB: +_IF_END76_STDLIB: +_IF_ELSE74_STDLIB: +_IF_END74_STDLIB: + LOAD 96 ; CH + LOADC 101 + CMP EQ + LOAD 96 ; CH + LOADC 69 + CMP EQ + OR + LOAD 104 ; XVALID + LOAD 108 ; IPOT + LOADC 0 + CMP LT + OR + AND + .LCBRANCHZ _IF_ELSE77_STDLIB + ; IPOT + LOADREG FP + LOADC 108 + ADD + LOADREG FP + LOADCP _NST_STDLIB71SREADINT + CALL + LOAD 120 ; FEOF + .LCBRANCHZ _IF_ELSE78_STDLIB + .LBRANCH _L69EXT_STDLIB +_IF_ELSE78_STDLIB: +_IF_END78_STDLIB: + LOAD 108 ; IPOT + LOADC 0 + CMP LT + .LCBRANCHZ _IF_ELSE79_STDLIB + LOAD 112 ; X + LOAD 108 ; IPOT + LOADCP ABS + CALL + LOADCP PWROFTEN + CALL + LOADCP _DIVFLOAT32 + CALL + STORE 112 ; X + .LBRANCH _IF_END79_STDLIB +_IF_ELSE79_STDLIB: + LOAD 112 ; X + LOAD 108 ; IPOT + LOADCP PWROFTEN + CALL + LOADCP _MULFLOAT32 + CALL + STORE 112 ; X +_IF_END79_STDLIB: +_IF_ELSE77_STDLIB: +_IF_END77_STDLIB: +_L69EXT_STDLIB: + LOAD 116 ; I + ; S + LOADREG FP + LOADCP LENGTH + CALL + CMP LE + .LCBRANCHZ _IF_ELSE80_STDLIB + LOADC 0 + STORE 104 ; XVALID +_IF_ELSE80_STDLIB: +_IF_END80_STDLIB: + LOAD 104 ; XVALID + .LCBRANCHZ _IF_ELSE81_STDLIB + LOAD 100 ; NEG + .LCBRANCHZ _IF_ELSE82_STDLIB + LOAD 112 ; X + LOADCP _NEGFLOAT32 + CALL + STORE 112 ; X +_IF_ELSE82_STDLIB: +_IF_END82_STDLIB: + LOAD 88 ; V + LOAD 112 ; X + STOREI + DROP + LOAD 92 ; CODE + LOADC 0 + STOREI + DROP + .LBRANCH _IF_END81_STDLIB +_IF_ELSE81_STDLIB: + LOAD 92 ; CODE + LOAD 116 ; I + LOADC 1 + SUB + STOREI + DROP +_IF_END81_STDLIB: + FPADJ 128 + RET +CHECKERROR: + FPADJ -4 + STORE 0 ; FIL + LOAD 0 ; FIL + INC 4 + LOADI + LOADC 0 + CMP NE + .LCBRANCHZ _IF_ELSE83_STDLIB + LOAD 0 ; FIL + INC 8 + LOADI + LOADC 0 + CMP EQ + .LCBRANCHZ _IF_ELSE84_STDLIB + LOADCP IOERRORDESC ; IOERRORDESC + LOAD 0 ; FIL + INC 4 + LOADI + DUP + LOADC 12 + LOADCP _BOUNDSCHECK + CALL + LOADC 28 + LOADCP _MULU + CALL + ADD + LOADC 20 + OVER + LOADCP _INITSTRING + CALL + LOADCP RUNTIMEERROR + CALL + .LBRANCH _IF_END84_STDLIB + .CPOOL +_IF_ELSE84_STDLIB: + LOAD 0 ; FIL + INC 4 + LOADC 0 + STOREI + DROP + LOAD 0 ; FIL + INC 8 + LOADC 0 + STOREI + DROP +_IF_END84_STDLIB: +_IF_ELSE83_STDLIB: +_IF_END83_STDLIB: + FPADJ 4 + RET +HANDLEBACKSPACE: + FPADJ -24 + STORE 8 ; BYTESREMOVED + STORE 4 ; BUF + STORE 0 ; AFILE + LOAD 8 ; BYTESREMOVED + LOADC 0 + STOREI + DROP + LOAD 4 ; BUF + LOADCP LENGTH + CALL + STORE 12 ; LEN + LOAD 12 ; LEN + LOADC 0 + CMP GT + .LCBRANCHZ _IF_ELSE85_STDLIB + LOAD 0 ; AFILE + LOADC 16 + ADD + LOADI + LOADC 0 + CMP EQ + .LCBRANCHZ _IF_ELSE86_STDLIB + LOAD 0 ; AFILE + LOADC 8 + LOADCP WRITECHANNEL + CALL + LOAD 0 ; AFILE + LOADC 32 + LOADCP WRITECHANNEL + CALL + LOAD 0 ; AFILE + LOADC 8 + LOADCP WRITECHANNEL + CALL +_IF_ELSE86_STDLIB: +_IF_END86_STDLIB: +_REPEAT_START5_STDLIB: + LOAD 4 ; BUF + LOAD 12 ; LEN + LOADCP _INDEXSTRING + CALL + LOADI.S1.X2Y + BSEL + STORE 16 ; REMOVEDCHAR + LOAD 8 ; BYTESREMOVED + LOAD 8 ; BYTESREMOVED + LOADI + LOADC 1 + ADD + STOREI + DROP + LOAD 12 ; LEN + LOADC 1 + SUB + STORE 12 ; LEN + LOAD 16 ; REMOVEDCHAR + LOADC 192 + AND + STORE 20 ; HIGHBITS + LOAD 20 ; HIGHBITS + LOADC 128 + CMP NE + LOAD 12 ; LEN + LOADC 0 + CMP EQ + OR + .LCBRANCHZ _REPEAT_START5_STDLIB +_REPEAT_END5_STDLIB: + LOAD 4 ; BUF + LOAD 12 ; LEN + LOADCP _SETSTRINGLENGTH + CALL +_IF_ELSE85_STDLIB: +_IF_END85_STDLIB: + FPADJ 24 + RET +_NST_STDLIB75ISSEPARATOR: + FPADJ -16 + LOADREG BP + STORE 4 + DUP + STOREREG BP + STORE 0 + STORE 8 ; ACHAR + LOAD.B 4 ; MODE +_CASE_1_0_0_STDLIB: + DUP + LOADC 0 + CMP NE + .LCBRANCH _CASE_1_0_1_STDLIB +_CASE_1_0M_STDLIB: + LOAD 8 ; ACHAR + LOADCP ISDIGIT + CALL + LOAD 8 ; ACHAR + LOADC 45 + CMP EQ + OR + LOADC 0 + CMP EQ + STORE 12 ; ISSEPARATOR + .LBRANCH _CASE_1_STDLIB_END +_CASE_1_0_1_STDLIB: +_CASE_1_1_0_STDLIB: + DUP + LOADC 1 + CMP NE + .LCBRANCH _CASE_1_1_1_STDLIB +_CASE_1_1M_STDLIB: + LOAD 8 ; ACHAR + LOADCP ISDIGIT + CALL + LOAD 8 ; ACHAR + LOADCP _C_A_7_STDLIB + LOADC 5 + LOADCP _ISINTINARRAY + CALL + OR + LOADC 0 + CMP EQ + STORE 12 ; ISSEPARATOR + .LBRANCH _CASE_1_STDLIB_END +_CASE_1_1_1_STDLIB: +_CASE_1_2_0_STDLIB: + DUP + LOADC 2 + CMP NE + .LCBRANCH _CASE_1_2_1_STDLIB +_CASE_1_2M_STDLIB: + LOAD 8 ; ACHAR + LOADC 13 + CMP EQ + LOAD 8 ; ACHAR + LOADC 10 + CMP EQ + OR + STORE 12 ; ISSEPARATOR + .LBRANCH _CASE_1_STDLIB_END +_CASE_1_2_1_STDLIB: +_CASE_1_3_STDLIB: +_CASE_1_STDLIB_END: + DROP + LOAD 12 ; ISSEPARATOR + LOAD 4 + STOREREG BP + FPADJ 16 + RET +FSCANBUF: + FPADJ -40 + STORE 8 ; BUF + STORE 4 ; MODE + STORE 0 ; AFILE + LOAD 8 ; BUF + LOADCP MAXLENGTH + CALL + STORE 16 ; MAXBYTES + LOADC 0 + STORE 12 ; BYTESREAD + LOADC 0 + STORE 24 ; DONE + LOADC 0 + STORE 36 ; SKIPCHAR + LOAD 8 ; BUF + LOADCP _C_S_3_STDLIB + LOADCP _COPYSTRING + CALL + LOAD 0 ; AFILE + LOADC 16 + ADD + LOADI + LOADC 0 + CMP EQ + STORE 32 ; ISCHANNEL +_REPEAT_START6_STDLIB: + LOAD 0 ; AFILE + LOADCP EOF + CALL + .LCBRANCHZ _IF_ELSE87_STDLIB + LOADC 1 + STORE 24 ; DONE + .LBRANCH _IF_END87_STDLIB +_IF_ELSE87_STDLIB: + LOAD 0 ; AFILE + LOADCP FREADCHAR + CALL + STORE 20 ; ACHAR + LOAD 32 ; ISCHANNEL + .LCBRANCHZ _IF_ELSE88_STDLIB + LOAD 20 ; ACHAR + LOADC 127 + CMP EQ + .LCBRANCHZ _IF_ELSE89_STDLIB + LOAD 0 ; AFILE + LOADC 40 + ADD + LOADI + LOAD 0 ; AFILE + LOADC 36 + ADD + LOADI + OR + LOADC 0 + CMP EQ + .LCBRANCHZ _IF_ELSE90_STDLIB + LOAD 0 ; AFILE + LOAD 8 ; BUF + ; BYTESREMOVED + LOADREG FP + LOADC 28 + ADD + LOADCP HANDLEBACKSPACE + CALL + LOAD 12 ; BYTESREAD + LOAD 28 ; BYTESREMOVED + SUB + STORE 12 ; BYTESREAD +_IF_ELSE90_STDLIB: +_IF_END90_STDLIB: + LOADC 1 + STORE 36 ; SKIPCHAR + .LBRANCH _IF_END89_STDLIB + .CPOOL +_IF_ELSE89_STDLIB: + LOAD 20 ; ACHAR + LOADC 4 + CMP EQ + .LCBRANCHZ _IF_ELSE91_STDLIB + LOADC 1 + STORE 36 ; SKIPCHAR + .LBRANCH _IF_END91_STDLIB +_IF_ELSE91_STDLIB: + LOADC 0 + STORE 36 ; SKIPCHAR +_IF_END91_STDLIB: +_IF_END89_STDLIB: +_IF_ELSE88_STDLIB: +_IF_END88_STDLIB: + LOAD 36 ; SKIPCHAR + LOADC 0 + CMP EQ + .LCBRANCHZ _IF_ELSE92_STDLIB + LOAD 20 ; ACHAR + LOADREG FP + LOADCP _NST_STDLIB75ISSEPARATOR + CALL + .LCBRANCHZ _IF_ELSE93_STDLIB + LOADC 1 + STORE 24 ; DONE + LOAD 0 ; AFILE + LOAD 20 ; ACHAR + LOADCP PUSHBACK + CALL + .LBRANCH _IF_END93_STDLIB +_IF_ELSE93_STDLIB: + LOAD 8 ; BUF + LOAD 20 ; ACHAR + LOADCP APPENDCHAR + CALL + LOAD 12 ; BYTESREAD + LOADC 1 + ADD + STORE 12 ; BYTESREAD +_IF_END93_STDLIB: +_IF_ELSE92_STDLIB: +_IF_END92_STDLIB: +_IF_END87_STDLIB: + LOAD 12 ; BYTESREAD + LOAD 16 ; MAXBYTES + CMP EQ + .LCBRANCHZ _IF_ELSE94_STDLIB + LOADC 1 + STORE 24 ; DONE +_IF_ELSE94_STDLIB: +_IF_END94_STDLIB: + LOAD 24 ; DONE + .LCBRANCHZ _REPEAT_START6_STDLIB +_REPEAT_END6_STDLIB: + FPADJ 40 + RET +FSKIPWHITE: + FPADJ -8 + STORE 0 ; F +_REPEAT_START7_STDLIB: + LOAD 0 ; F + LOADCP FREADCHAR + CALL + STORE 4 ; C + LOAD 0 ; F + LOADCP EOF + CALL + LOAD 4 ; C + LOADCP ISWHITE + CALL + LOADC 0 + CMP EQ + OR + .LCBRANCHZ _REPEAT_START7_STDLIB +_REPEAT_END7_STDLIB: + LOAD 0 ; F + LOAD 4 ; C + LOADCP PUSHBACK + CALL + FPADJ 8 + RET +FREADINT: + FPADJ -44 + STORE 4 ; F + STORE 0 ; V + LOADC 24 + ; BUF + LOADREG FP + INC 8 + LOADCP _INITSTRINGF + CALL + LOADC -1 + STORE 40 ; ERRPOS + LOAD 4 ; F + LOADCP FSKIPWHITE + CALL + LOAD 4 ; F + LOADC 0 + ; BUF + LOADREG FP + INC 8 + LOADCP FSCANBUF + CALL + LOAD 4 ; F + INC 4 + LOADI + LOADC 0 + CMP EQ + .LCBRANCHZ _IF_ELSE95_STDLIB + ; BUF + LOADREG FP + INC 8 + LOAD 0 ; V + ; ERRPOS + LOADREG FP + LOADC 40 + ADD + LOADCP INTVAL + CALL +_IF_ELSE95_STDLIB: +_IF_END95_STDLIB: + LOAD 40 ; ERRPOS + LOADC 0 + CMP NE + .LCBRANCHZ _IF_ELSE96_STDLIB + LOAD 4 ; F + LOADC 10 + LOADCP FILEERROR + CALL + LOAD 4 ; F + LOADCP CHECKERROR + CALL +_IF_ELSE96_STDLIB: +_IF_END96_STDLIB: + FPADJ 44 + RET +FREADREAL: + FPADJ -60 + STORE 4 ; F + STORE 0 ; V + LOADC 40 + ; BUF + LOADREG FP + INC 8 + LOADCP _INITSTRINGF + CALL + LOAD 4 ; F + LOADCP FSKIPWHITE + CALL + LOAD 4 ; F + LOADC 1 + ; BUF + LOADREG FP + INC 8 + LOADCP FSCANBUF + CALL + LOAD 4 ; F + INC 4 + LOADI + LOADC 0 + CMP EQ + .LCBRANCHZ _IF_ELSE97_STDLIB + ; BUF + LOADREG FP + INC 8 + LOAD 0 ; V + ; ERRPOS + LOADREG FP + LOADC 56 + ADD + LOADCP REALVAL + CALL +_IF_ELSE97_STDLIB: +_IF_END97_STDLIB: + LOAD 56 ; ERRPOS + LOADC 0 + CMP NE + .LCBRANCHZ _IF_ELSE98_STDLIB + LOAD 4 ; F + LOADC 10 + LOADCP FILEERROR + CALL +_IF_ELSE98_STDLIB: +_IF_END98_STDLIB: + FPADJ 60 + RET +FREADSTRING: + FPADJ -8 + STORE 4 ; F + STORE 0 ; S + LOAD 4 ; F + LOADC 2 + LOAD 0 ; S + LOADCP FSCANBUF + CALL + FPADJ 8 + RET +SKIPEOLN: + FPADJ -8 + STORE 0 ; AFILE +_REPEAT_START8_STDLIB: + LOAD 0 ; AFILE + LOADCP FREADCHAR + CALL + STORE 4 ; ACHAR + LOAD 4 ; ACHAR + LOADC 13 + CMP EQ + LOAD 0 ; AFILE + LOADCP EOF + CALL + OR + .LCBRANCHZ _REPEAT_START8_STDLIB +_REPEAT_END8_STDLIB: + LOAD 0 ; AFILE + LOADC 16 + ADD + LOADI + LOADC 0 + CMP NE + .LCBRANCHZ _IF_ELSE99_STDLIB + LOAD 0 ; AFILE + LOADCP EOF + CALL + LOADC 0 + CMP EQ + .LCBRANCHZ _IF_ELSE100_STDLIB + LOAD 0 ; AFILE + LOADCP FREADCHAR + CALL + STORE 4 ; ACHAR + LOAD 4 ; ACHAR + LOADC 10 + CMP NE + .LCBRANCHZ _IF_ELSE101_STDLIB + LOAD 0 ; AFILE + LOAD 4 ; ACHAR + LOADCP PUSHBACK + CALL +_IF_ELSE101_STDLIB: +_IF_END101_STDLIB: +_IF_ELSE100_STDLIB: +_IF_END100_STDLIB: +_IF_ELSE99_STDLIB: +_IF_END99_STDLIB: + FPADJ 8 + RET + .CPOOL +SETDEFAULTVOLUME: + FPADJ -44 + ; VOLNAME + LOADREG FP + SWAP + LOADC 32 + LOADCP _INITSTRINGFROM + CALL + ; VOLNAME + LOADREG FP + LOADCP FINDVOLUME + CALL + STORE 40 ; VOLID + LOAD 40 ; VOLID + LOADC 0 + CMP GT + .LCBRANCHZ _IF_ELSE102_STDLIB + LOADCP DEFAULTVOLUME ; DEFAULTVOLUME + ; VOLNAME + LOADREG FP + LOADCP _COPYSTRING + CALL + LOADCP DEFAULTVOLUMEID ; DEFAULTVOLUMEID + LOAD 40 ; VOLID + STOREI + DROP +_IF_ELSE102_STDLIB: +_IF_END102_STDLIB: + FPADJ 44 + RET +ADDPARTITIONS: + FPADJ -20 + STORE 8 ; ISLAST + STORE 4 ; PARTBLK + STORE 0 ; DEVID + LOADC 0 + STORE 12 ; PARTNO + LOADC 0 + STORE 12 ; PARTNO + LOADC 7 +_FOR_START11_STDLIB: + LOAD 12 ; PARTNO + OVER + CMP GT + .LCBRANCH _FOR_END11_STDLIB + LOAD 4 ; PARTBLK + LOAD 12 ; PARTNO + DUP + LOADC 8 + LOADCP _BOUNDSCHECK + CALL + SHL 2 + SHL 2 + SHL 2 + ADD + LOADC 40 + ADD + LOADI + STORE 16 ; FLAGS + LOADC 2 + LOAD 16 ; FLAGS + LOADCP _TESTBIT + CALL + .LCBRANCHZ _IF_ELSE103_STDLIB + LOAD 8 ; ISLAST + LOADC 1 + STOREI + DROP +_IF_ELSE103_STDLIB: +_IF_END103_STDLIB: + LOADC 0 + LOAD 16 ; FLAGS + LOADCP _TESTBIT + CALL + .LCBRANCHZ _IF_ELSE104_STDLIB + LOADCP VOLUMECOUNT ; VOLUMECOUNT + LOADCP VOLUMECOUNT ; VOLUMECOUNT + LOADI + LOADC 1 + ADD + STOREI + DROP + LOADCP VOLUMETABLE ; VOLUMETABLE + LOADCP VOLUMECOUNT ; VOLUMECOUNT + LOADI + DEC 1 + DUP + LOADC 32 + LOADCP _BOUNDSCHECK + CALL + LOADC 96 + LOADCP _MULU + CALL + ADD + LOADREG FP + DEC 4 + SWAP + STOREI + DROP + LOADREG FP + DEC 4 + LOADI + LOAD 4 ; PARTBLK + LOAD 12 ; PARTNO + DUP + LOADC 8 + LOADCP _BOUNDSCHECK + CALL + SHL 2 + SHL 2 + SHL 2 + ADD + LOADC 16 + FPADJ -4 + LOADCP _COPYWORDS + CALL + FPADJ 4 + LOADREG FP + DEC 4 + LOADI + LOADC 64 + ADD + LOAD 0 ; DEVID + STOREI + DROP + LOADREG FP + DEC 4 + LOADI + LOADC 68 + ADD + LOAD 12 ; PARTNO + STOREI + DROP + LOADREG FP + DEC 4 + LOADI + LOADC 72 + ADD + LOADC 0 + STOREI + DROP + LOADREG FP + DEC 4 + LOADI + LOADC 76 + ADD + LOADC 0 + STOREI + DROP + LOADREG FP + DEC 4 + LOADI + LOADC 80 + ADD + LOADC 0 + STOREI + DROP + LOADREG FP + DEC 4 + LOADI + LOADC 84 + ADD + LOADC -1 + STOREI + DROP + LOADREG FP + DEC 4 + LOADI + LOADC 88 + ADD + LOADC 0 + STOREI + DROP + LOADREG FP + DEC 4 + LOADI + LOADC 92 + ADD + LOADC 0 + STOREI + DROP +_IF_ELSE104_STDLIB: +_IF_END104_STDLIB: + LOAD 12 ; PARTNO + INC 1 + STORE 12 ; PARTNO + .LBRANCH _FOR_START11_STDLIB +_FOR_END11_STDLIB: + DROP + FPADJ 20 + RET +READPARTITIONS: + LOADREG FP + LOADC 528 + SUB + STOREREG FP + STORE 0 ; DEVID + ; PARTBLK + LOADREG FP + INC 8 + LOADC 512 + LOADCP _CLEARMEM + CALL + LOADC 0 + STORE 4 ; BLKNO + LOADC 0 + STORE 520 ; ISLAST + LOADC 0 + STORE 524 ; ERROR + LOADC 0 + STORE 4 ; BLKNO + LOADC 7 +_FOR_START12_STDLIB: + LOAD 4 ; BLKNO + OVER + CMP GT + .LCBRANCH _FOR_END12_STDLIB + LOAD 4 ; BLKNO + ; PARTBLK + LOADREG FP + INC 8 + ; ERROR + LOADREG FP + LOADC 524 + ADD + LOAD 0 ; DEVID + LOADCP READPARTBLK + CALL + LOAD 524 ; ERROR + LOADC 0 + CMP EQ + .LCBRANCHZ _IF_ELSE105_STDLIB + LOAD 0 ; DEVID + ; PARTBLK + LOADREG FP + INC 8 + ; ISLAST + LOADREG FP + LOADC 520 + ADD + LOADCP ADDPARTITIONS + CALL + .LBRANCH _IF_END105_STDLIB + .CPOOL +_IF_ELSE105_STDLIB: + LOADCP _C_S_8_STDLIB + LOADCP OUTPUT + DUP + LOADCP CHECKERROR + CALL + SWAP + OVER + LOADC 0 + LOADCP FWRITESTRING + CALL + LOAD 4 ; BLKNO + OVER + LOADC 0 + LOADCP FWRITEINT + CALL + LOADCP NEWLINESTR + OVER + LOADC 0 + LOADCP FWRITESTRING + CALL + DROP +_IF_END105_STDLIB: + LOAD 520 ; ISLAST + LOAD 524 ; ERROR + LOADC 0 + CMP NE + OR + .LCBRANCHZ _IF_ELSE106_STDLIB + .LBRANCH _FOR_END12_STDLIB +_IF_ELSE106_STDLIB: +_IF_END106_STDLIB: + LOAD 4 ; BLKNO + INC 1 + STORE 4 ; BLKNO + .LBRANCH _FOR_START12_STDLIB +_FOR_END12_STDLIB: + DROP + LOADREG FP + LOADC 528 + ADD + STOREREG FP + RET +READDEVICE: + FPADJ -16 + STORE 12 ; ERROR + STORE 8 ; BUF + STORE 4 ; BLOCKNO + STORE 0 ; DEVICEID + LOAD 4 ; BLOCKNO + LOAD 8 ; BUF + LOAD 12 ; ERROR + LOAD 0 ; DEVICEID + LOADCP READBLOCK + CALL + FPADJ 16 + RET +WRITEDEVICE: + FPADJ -16 + STORE 12 ; ERROR + STORE 8 ; BUF + STORE 4 ; BLOCKNO + STORE 0 ; DEVICEID + LOAD 4 ; BLOCKNO + LOAD 8 ; BUF + LOAD 12 ; ERROR + LOAD 0 ; DEVICEID + LOADCP WRITEBLOCK + CALL + FPADJ 16 + RET +GETPHYSBLOCKNO: + FPADJ -12 + STORE 4 ; BLOCKNO + STORE 0 ; VOLUMEID + LOADCP VOLUMETABLE ; VOLUMETABLE + LOAD 0 ; VOLUMEID + DEC 1 + DUP + LOADC 32 + LOADCP _BOUNDSCHECK + CALL + LOADC 96 + LOADCP _MULU + CALL + ADD + LOADC 44 + ADD + LOADI + LOAD 4 ; BLOCKNO + ADD + STORE 8 ; GETPHYSBLOCKNO + LOAD 8 ; GETPHYSBLOCKNO + FPADJ 12 + RET +READVOLUMEBLKS: + FPADJ -32 + STORE 16 ; ERROR + STORE 12 ; BLKCOUNT + STORE 8 ; BLKNO + STORE 4 ; DESTBUF + STORE 0 ; VOLUMEID + LOAD 0 ; VOLUMEID + LOAD 8 ; BLKNO + LOADCP GETPHYSBLOCKNO + CALL + STORE 20 ; DEVICEBLK + LOADCP VOLUMETABLE ; VOLUMETABLE + LOAD 0 ; VOLUMEID + DEC 1 + DUP + LOADC 32 + LOADCP _BOUNDSCHECK + CALL + LOADC 96 + LOADCP _MULU + CALL + ADD + LOADC 64 + ADD + LOADI + STORE 24 ; DEVICEID + LOADC 0 + STORE 28 ; I +_WHILE_START10_STDLIB: + LOAD 12 ; BLKCOUNT + LOADC 0 + CMP GT + .LCBRANCHZ _WHILE_END10_STDLIB + LOAD 24 ; DEVICEID + LOAD 20 ; DEVICEBLK + ; DESTBUF + LOADREG FP + INC 4 + LOADI + LOAD 28 ; I + DUP + LOADC 8 + LOADCP _BOUNDSCHECK + CALL + BROT + LOADC -$100 + AND + SHL + ADD + LOAD 16 ; ERROR + LOADCP READDEVICE + CALL + LOAD 12 ; BLKCOUNT + LOADC 1 + SUB + STORE 12 ; BLKCOUNT + LOAD 20 ; DEVICEBLK + LOADC 1 + ADD + STORE 20 ; DEVICEBLK + LOAD 28 ; I + LOADC 1 + ADD + STORE 28 ; I + .LBRANCH _WHILE_START10_STDLIB +_WHILE_END10_STDLIB: + FPADJ 32 + RET +WRITEVOLUMEBLKS: + FPADJ -32 + STORE 16 ; ERROR + STORE 12 ; BLKCOUNT + STORE 8 ; BLKNO + STORE 4 ; SRCBUF + STORE 0 ; VOLUMEID + LOAD 0 ; VOLUMEID + LOAD 8 ; BLKNO + LOADCP GETPHYSBLOCKNO + CALL + STORE 20 ; DEVICEBLK + LOADCP VOLUMETABLE ; VOLUMETABLE + LOAD 0 ; VOLUMEID + DEC 1 + DUP + LOADC 32 + LOADCP _BOUNDSCHECK + CALL + LOADC 96 + LOADCP _MULU + CALL + ADD + LOADC 64 + ADD + LOADI + STORE 24 ; DEVICEID + LOADC 0 + STORE 28 ; I +_WHILE_START11_STDLIB: + LOAD 12 ; BLKCOUNT + LOADC 0 + CMP GT + .LCBRANCHZ _WHILE_END11_STDLIB + LOAD 24 ; DEVICEID + LOAD 20 ; DEVICEBLK + ; SRCBUF + LOADREG FP + INC 4 + LOADI + LOAD 28 ; I + DUP + LOADC 8 + LOADCP _BOUNDSCHECK + CALL + BROT + LOADC -$100 + AND + SHL + ADD + LOAD 16 ; ERROR + LOADCP WRITEDEVICE + CALL + LOAD 12 ; BLKCOUNT + LOADC 1 + SUB + STORE 12 ; BLKCOUNT + LOAD 20 ; DEVICEBLK + LOADC 1 + ADD + STORE 20 ; DEVICEBLK + LOAD 28 ; I + LOADC 1 + ADD + STORE 28 ; I + .LBRANCH _WHILE_START11_STDLIB + .CPOOL +_WHILE_END11_STDLIB: + FPADJ 32 + RET +FINDVOLUME: + FPADJ -96 + ; NAME + LOADREG FP + SWAP + LOADC 80 + LOADCP _INITSTRINGFROM + CALL + LOADCP INITDEVICES + CALL + LOADC 0 + STORE 88 ; FINDVOLUME + LOADC 1 + STORE 92 ; VOLIDX + LOADCP VOLUMECOUNT ; VOLUMECOUNT + LOADI +_FOR_START13_STDLIB: + LOAD 92 ; VOLIDX + OVER + CMP GT + .LCBRANCH _FOR_END13_STDLIB + LOADCP VOLUMETABLE ; VOLUMETABLE + LOAD 92 ; VOLIDX + DEC 1 + DUP + LOADC 32 + LOADCP _BOUNDSCHECK + CALL + LOADC 96 + LOADCP _MULU + CALL + ADD + ; NAME + LOADREG FP + LOADCP _CMPSTRING + CALL + .LCBRANCHZ _IF_ELSE107_STDLIB + LOAD 92 ; VOLIDX + STORE 88 ; FINDVOLUME + .LBRANCH _FOR_END13_STDLIB +_IF_ELSE107_STDLIB: +_IF_END107_STDLIB: + LOAD 92 ; VOLIDX + INC 1 + STORE 92 ; VOLIDX + .LBRANCH _FOR_START13_STDLIB +_FOR_END13_STDLIB: + DROP + LOAD 88 ; FINDVOLUME + FPADJ 96 + RET +FLUSHDIRCACHE: + FPADJ -8 + STORE 4 ; ERROR + STORE 0 ; VOLUMEID + LOADCP VOLUMETABLE ; VOLUMETABLE + LOAD 0 ; VOLUMEID + DEC 1 + DUP + LOADC 32 + LOADCP _BOUNDSCHECK + CALL + LOADC 96 + LOADCP _MULU + CALL + ADD + LOADREG FP + DEC 4 + SWAP + STOREI + DROP + LOADREG FP + DEC 4 + LOADI + LOADC 80 + ADD + LOADI + LOADC 0 + CMP NE + LOADREG FP + DEC 4 + LOADI + LOADC 84 + ADD + LOADI + LOADC 0 + CMP GE + AND + LOADREG FP + DEC 4 + LOADI + LOADC 88 + ADD + LOADI + AND + .LCBRANCHZ _IF_ELSE108_STDLIB + LOAD 0 ; VOLUMEID + LOADREG FP + DEC 4 + LOADI + LOADC 84 + ADD + LOADI + FPADJ -4 + LOADCP GETPHYSBLOCKNO + CALL + FPADJ 4 + LOADREG FP + DEC 4 + LOADI + LOADC 80 + ADD + LOADI + LOAD 4 ; ERROR + LOADREG FP + DEC 4 + LOADI + LOADC 64 + ADD + LOADI + FPADJ -4 + LOADCP WRITEDIRBLK + CALL + FPADJ 4 + LOADREG FP + DEC 4 + LOADI + LOADC 88 + ADD + LOADC 0 + STOREI + DROP +_IF_ELSE108_STDLIB: +_IF_END108_STDLIB: + FPADJ 8 + RET +OPENVOLUMEID: + FPADJ -4 + STORE 0 ; VOLID + LOADCP VOLUMETABLE ; VOLUMETABLE + LOAD 0 ; VOLID + DEC 1 + DUP + LOADC 32 + LOADCP _BOUNDSCHECK + CALL + LOADC 96 + LOADCP _MULU + CALL + ADD + LOADREG FP + DEC 4 + SWAP + STOREI + DROP + LOADREG FP + DEC 4 + LOADI + LOADC 80 + ADD + LOADI + LOADC 0 + CMP EQ + .LCBRANCHZ _IF_ELSE109_STDLIB + LOADREG FP + DEC 4 + LOADI + LOADC 80 + ADD + LOADC 512 + FPADJ -4 + LOADCP _MEM_ALLOC + CALL + FPADJ 4 + DUP + LOADC 512 + LOADCP _CLEARMEM + CALL + FPADJ -4 + LOADCP _CHECK_ALLOC + CALL + FPADJ 4 + STOREI + DROP +_IF_ELSE109_STDLIB: +_IF_END109_STDLIB: + LOADREG FP + DEC 4 + LOADI + LOADC 92 + ADD + LOADREG FP + DEC 4 + LOADI + LOADC 92 + ADD + LOADI + LOADC 1 + ADD + STOREI + DROP + FPADJ 4 + RET +CLOSEVOLUMEID: + FPADJ -8 + STORE 0 ; VOLID + LOADCP VOLUMETABLE ; VOLUMETABLE + LOAD 0 ; VOLID + DEC 1 + DUP + LOADC 32 + LOADCP _BOUNDSCHECK + CALL + LOADC 96 + LOADCP _MULU + CALL + ADD + LOADREG FP + DEC 4 + SWAP + STOREI + DROP + LOADREG FP + DEC 4 + LOADI + LOADC 92 + ADD + LOADREG FP + DEC 4 + LOADI + LOADC 92 + ADD + LOADI + LOADC 1 + SUB + STOREI + DROP + LOADREG FP + DEC 4 + LOADI + LOADC 92 + ADD + LOADI + LOADC 0 + CMP EQ + .LCBRANCHZ _IF_ELSE110_STDLIB + LOAD 0 ; VOLID + ; ERROR + LOADREG FP + INC 4 + FPADJ -4 + LOADCP FLUSHDIRCACHE + CALL + FPADJ 4 + LOADREG FP + DEC 4 + LOADI + LOADC 84 + ADD + LOADC -1 + STOREI + DROP + LOADREG FP + DEC 4 + LOADI + LOADC 80 + ADD + LOADI + FPADJ -4 + LOADCP _MEM_FREE + CALL + FPADJ 4 + LOADREG FP + DEC 4 + LOADI + LOADC 80 + ADD + LOADC 0 + STOREI + DROP +_IF_ELSE110_STDLIB: +_IF_END110_STDLIB: + FPADJ 8 + RET + .CPOOL +LOADDIRBLOCK: + FPADJ -12 + STORE 8 ; ERROR + STORE 4 ; DIRBLKNO + STORE 0 ; VOLUMEID + LOADCP VOLUMETABLE ; VOLUMETABLE + LOAD 0 ; VOLUMEID + DEC 1 + DUP + LOADC 32 + LOADCP _BOUNDSCHECK + CALL + LOADC 96 + LOADCP _MULU + CALL + ADD + LOADREG FP + DEC 4 + SWAP + STOREI + DROP + LOADREG FP + DEC 4 + LOADI + LOADC 84 + ADD + LOADI + LOAD 4 ; DIRBLKNO + CMP NE + .LCBRANCHZ _IF_ELSE111_STDLIB + LOAD 0 ; VOLUMEID + LOAD 8 ; ERROR + FPADJ -4 + LOADCP FLUSHDIRCACHE + CALL + FPADJ 4 + LOAD 0 ; VOLUMEID + LOAD 4 ; DIRBLKNO + FPADJ -4 + LOADCP GETPHYSBLOCKNO + CALL + FPADJ 4 + LOADREG FP + DEC 4 + LOADI + LOADC 80 + ADD + LOADI + LOAD 8 ; ERROR + LOADREG FP + DEC 4 + LOADI + LOADC 64 + ADD + LOADI + FPADJ -4 + LOADCP READDIRBLK + CALL + FPADJ 4 + LOADREG FP + DEC 4 + LOADI + LOADC 84 + ADD + LOAD 4 ; DIRBLKNO + STOREI + DROP +_IF_ELSE111_STDLIB: +_IF_END111_STDLIB: + FPADJ 12 + RET +GETDIRSLOT: + FPADJ -24 + STORE 12 ; ERROR + STORE 8 ; RESULT + STORE 4 ; SLOTNO + STORE 0 ; VOLUMEID + LOAD 12 ; ERROR + LOADC 0 + STOREI + DROP + LOADCP VOLUMETABLE ; VOLUMETABLE + LOAD 0 ; VOLUMEID + DEC 1 + DUP + LOADC 32 + LOADCP _BOUNDSCHECK + CALL + LOADC 96 + LOADCP _MULU + CALL + ADD + LOADREG FP + DEC 4 + SWAP + STOREI + DROP + LOAD 4 ; SLOTNO + LOADC 8 + FPADJ -4 + LOADCP _DIV + CALL + FPADJ 4 + STORE 16 ; DIRBLKNO + LOAD 4 ; SLOTNO + LOADC 8 + FPADJ -4 + LOADCP _MOD + CALL + FPADJ 4 + STORE 20 ; SLOTOFFSET + LOAD 0 ; VOLUMEID + LOAD 16 ; DIRBLKNO + LOAD 12 ; ERROR + FPADJ -4 + LOADCP LOADDIRBLOCK + CALL + FPADJ 4 + LOAD 8 ; RESULT + LOADREG FP + DEC 4 + LOADI + LOADC 80 + ADD + LOADI + LOAD 20 ; SLOTOFFSET + DUP + LOADC 8 + LOADCP _BOUNDSCHECK + CALL + SHL 2 + SHL 2 + SHL 2 + ADD + LOADC 16 + FPADJ -4 + LOADCP _COPYWORDS + CALL + FPADJ 4 + FPADJ 24 + RET +PUTDIRSLOT: + FPADJ -24 + STORE 12 ; ERROR + STORE 8 ; DIRSLOT + STORE 4 ; SLOTNO + STORE 0 ; VOLUMEID + LOADCP VOLUMETABLE ; VOLUMETABLE + LOAD 0 ; VOLUMEID + DEC 1 + DUP + LOADC 32 + LOADCP _BOUNDSCHECK + CALL + LOADC 96 + LOADCP _MULU + CALL + ADD + LOADREG FP + DEC 4 + SWAP + STOREI + DROP + LOAD 4 ; SLOTNO + LOADC 8 + FPADJ -4 + LOADCP _DIV + CALL + FPADJ 4 + STORE 16 ; DIRBLKNO + LOAD 4 ; SLOTNO + LOADC 8 + FPADJ -4 + LOADCP _MOD + CALL + FPADJ 4 + STORE 20 ; SLOTOFFSET + LOAD 0 ; VOLUMEID + LOAD 16 ; DIRBLKNO + LOAD 12 ; ERROR + FPADJ -4 + LOADCP LOADDIRBLOCK + CALL + FPADJ 4 + LOADREG FP + DEC 4 + LOADI + LOADC 80 + ADD + LOADI + LOAD 20 ; SLOTOFFSET + DUP + LOADC 8 + LOADCP _BOUNDSCHECK + CALL + SHL 2 + SHL 2 + SHL 2 + ADD + LOAD 8 ; DIRSLOT + LOADC 16 + FPADJ -4 + LOADCP _COPYWORDS + CALL + FPADJ 4 + LOADREG FP + DEC 4 + LOADI + LOADC 88 + ADD + LOADC 1 + STOREI + DROP + FPADJ 24 + RET +FINDDIRSLOT: + FPADJ -88 + STORE 4 ; ERROR + STORE 0 ; VOLID + ; DIRSLOT + LOADREG FP + LOADC 20 + ADD + LOADC 64 + LOADCP _CLEARMEM + CALL + LOADC -1 + STORE 8 ; FINDDIRSLOT + LOADCP VOLUMETABLE ; VOLUMETABLE + LOAD 0 ; VOLID + DEC 1 + DUP + LOADC 32 + LOADCP _BOUNDSCHECK + CALL + LOADC 96 + LOADCP _MULU + CALL + ADD + LOADREG FP + DEC 4 + SWAP + STOREI + DROP + LOADREG FP + DEC 4 + LOADI + LOADC 56 + ADD + LOADI + STORE 16 ; MAXSLOTS + LOADREG FP + DEC 4 + LOADI + LOADC 72 + ADD + LOADI + STORE 12 ; SLOTNO + LOADC 0 + STORE 84 ; DONE +_REPEAT_START9_STDLIB: + LOAD 0 ; VOLID + LOAD 12 ; SLOTNO + ; DIRSLOT + LOADREG FP + LOADC 20 + ADD + LOAD 4 ; ERROR + FPADJ -4 + LOADCP GETDIRSLOT + CALL + FPADJ 4 + LOADC 0 + LOAD 60 ; DIRSLOT + LOADCP _TESTBIT + CALL + .LCBRANCHZ _IF_ELSE112_STDLIB + LOAD 12 ; SLOTNO + STORE 8 ; FINDDIRSLOT + LOADC 1 + STORE 84 ; DONE + LOADREG FP + DEC 4 + LOADI + LOADC 76 + ADD + LOAD 12 ; SLOTNO + STOREI + DROP +_IF_ELSE112_STDLIB: +_IF_END112_STDLIB: + LOAD 12 ; SLOTNO + LOADC 1 + ADD + STORE 12 ; SLOTNO + LOAD 84 ; DONE + LOAD 12 ; SLOTNO + LOAD 16 ; MAXSLOTS + CMP GE + OR + LOAD 4 ; ERROR + LOADI + LOADC 0 + CMP NE + OR + .LCBRANCHZ _REPEAT_START9_STDLIB +_REPEAT_END9_STDLIB: + LOAD 8 ; FINDDIRSLOT + FPADJ 88 + RET + .CPOOL +READBUF: + FPADJ -12 + STORE 4 ; ERROR + STORE 0 ; FIL + LOAD 0 ; FIL + LOADC 32 + ADD + LOAD 0 ; FIL + LOADC 28 + ADD + LOADI + LOAD 0 ; FIL + LOADC 28 + ADD + LOADI + LOADC 512 + LOADCP _MOD + CALL + SUB + STOREI + DROP + LOAD 0 ; FIL + LOADC 32 + ADD + LOADI + LOADC 512 + LOADCP _DIV + CALL + LOAD 0 ; FIL + LOADC 24 + ADD + LOADI + LOAD 0 ; FIL + LOADC 48 + ADD + LOADI + LOADCP _MUL + CALL + ADD + STORE 8 ; BLKNO + LOAD 0 ; FIL + LOADC 20 + ADD + LOADI + LOAD 0 ; FIL + LOADC 56 + ADD + LOADI + LOAD 8 ; BLKNO + LOAD 0 ; FIL + LOADC 44 + ADD + LOADI + LOAD 4 ; ERROR + LOADCP READVOLUMEBLKS + CALL + FPADJ 12 + RET +FILEERROR: + FPADJ -8 + STORE 4 ; ERROR + STORE 0 ; FIL + LOAD 0 ; FIL + INC 4 + LOAD 4 ; ERROR + STOREI + DROP + LOAD 0 ; FIL + INC 8 + LOADC 0 + STOREI + DROP + FPADJ 8 + RET +IORESULT: + FPADJ -8 + STORE 0 ; FIL + LOAD 0 ; FIL + INC 4 + LOADI + STORE 4 ; IORESULT + LOAD 0 ; FIL + INC 8 + LOADC 1 + STOREI + DROP + LOAD 4 ; IORESULT + FPADJ 8 + RET +ERRORSTR: + FPADJ -8 + STORE 4 ; ERRORSTR + STORE 0 ; ERR + LOAD 0 ; ERR + LOADC 11 + CMP LE + .LCBRANCHZ _IF_ELSE113_STDLIB + LOAD 4 ; ERRORSTR + LOADCP IOERRORDESC ; IOERRORDESC + LOAD 0 ; ERR + DUP + LOADC 12 + LOADCP _BOUNDSCHECK + CALL + LOADC 28 + LOADCP _MULU + CALL + ADD + LOADCP _COPYSTRING + CALL + .LBRANCH _IF_END113_STDLIB +_IF_ELSE113_STDLIB: + LOAD 4 ; ERRORSTR + LOADCP _C_S_9_STDLIB + LOADCP _COPYSTRING + CALL +_IF_END113_STDLIB: + LOAD 4 ; ERRORSTR + FPADJ 8 + RET +EOF: + FPADJ -8 + STORE 0 ; FIL + LOAD 0 ; FIL + LOADC 16 + ADD + LOADI + LOADC 1 + CMP EQ + .LCBRANCHZ _IF_ELSE114_STDLIB + LOAD 0 ; FIL + LOADC 28 + ADD + LOADI + LOAD 0 ; FIL + LOADC 36 + ADD + LOADI + CMP GE + STORE 4 ; EOF + .LBRANCH _IF_END114_STDLIB +_IF_ELSE114_STDLIB: + LOAD 0 ; FIL + LOADC 32 + ADD + LOADI + STORE 4 ; EOF +_IF_END114_STDLIB: + LOAD 4 ; EOF + FPADJ 8 + RET +EOLN: + FPADJ -8 + STORE 0 ; FIL + LOAD 0 ; FIL + LOADCP EOF + CALL + LOAD 0 ; FIL + INC 12 + LOADI + OR + STORE 4 ; EOLN + LOAD 4 ; EOLN + FPADJ 8 + RET +READFS: + FPADJ -32 + STORE 8 ; LEN + STORE 4 ; DESTBUF + STORE 0 ; FIL + LOADC 0 + STORE 28 ; ERROR + LOADC 0 + STORE 20 ; DESTPOS + LOAD 0 ; FIL + LOADC 28 + ADD + LOADI + LOAD 8 ; LEN + ADD + LOAD 0 ; FIL + LOADC 36 + ADD + LOADI + CMP GT + .LCBRANCHZ _IF_ELSE115_STDLIB + LOAD 0 ; FIL + LOADC 36 + ADD + LOADI + LOAD 0 ; FIL + LOADC 28 + ADD + LOADI + SUB + STORE 8 ; LEN +_IF_ELSE115_STDLIB: +_IF_END115_STDLIB: +_WHILE_START12_STDLIB: + LOAD 8 ; LEN + LOADC 0 + CMP GT + LOAD 28 ; ERROR + LOADC 0 + CMP EQ + AND + .LCBRANCHZ _WHILE_END12_STDLIB + LOAD 0 ; FIL + LOADC 60 + ADD + LOADI + LOAD 0 ; FIL + LOADC 64 + ADD + LOADI + CMP LT + .LCBRANCHZ _IF_ELSE116_STDLIB + LOAD 0 ; FIL + LOADC 64 + ADD + LOADI + LOAD 0 ; FIL + LOADC 60 + ADD + LOADI + SUB + STORE 12 ; BUFLEFT + LOAD 8 ; LEN + LOAD 12 ; BUFLEFT + CMP GT + .LCBRANCHZ _IF_ELSE117_STDLIB + LOAD 12 ; BUFLEFT + STORE 16 ; PARTIAL + .LBRANCH _IF_END117_STDLIB + .CPOOL +_IF_ELSE117_STDLIB: + LOAD 8 ; LEN + STORE 16 ; PARTIAL +_IF_END117_STDLIB: + LOAD 4 ; DESTBUF + LOAD 20 ; DESTPOS + LOAD 0 ; FIL + LOADC 56 + ADD + LOADI + LOAD 0 ; FIL + LOADC 60 + ADD + LOADI + LOAD 16 ; PARTIAL + LOADCP COPYBUF + CALL + LOAD 8 ; LEN + LOAD 16 ; PARTIAL + SUB + STORE 8 ; LEN + LOAD 0 ; FIL + LOADC 60 + ADD + LOAD 0 ; FIL + LOADC 60 + ADD + LOADI + LOAD 16 ; PARTIAL + ADD + STOREI + DROP + LOAD 0 ; FIL + LOADC 28 + ADD + LOAD 0 ; FIL + LOADC 28 + ADD + LOADI + LOAD 16 ; PARTIAL + ADD + STOREI + DROP + LOAD 20 ; DESTPOS + LOAD 16 ; PARTIAL + ADD + STORE 20 ; DESTPOS + .LBRANCH _IF_END116_STDLIB +_IF_ELSE116_STDLIB: + LOAD 0 ; FIL + ; ERROR + LOADREG FP + LOADC 28 + ADD + LOADCP READBUF + CALL + LOAD 0 ; FIL + LOADC 60 + ADD + LOADC 0 + STOREI + DROP +_IF_END116_STDLIB: + .LBRANCH _WHILE_START12_STDLIB +_WHILE_END12_STDLIB: + LOAD 28 ; ERROR + LOADC 0 + CMP NE + .LCBRANCHZ _IF_ELSE118_STDLIB + LOAD 0 ; FIL + LOAD 28 ; ERROR + LOADCP FILEERROR + CALL +_IF_ELSE118_STDLIB: +_IF_END118_STDLIB: + FPADJ 32 + RET +FLUSHFILE: + FPADJ -12 + STORE 0 ; FIL + LOAD 0 ; FIL + LOADC 32 + ADD + LOADI + LOADC 512 + LOADCP _DIV + CALL + LOAD 0 ; FIL + LOADC 24 + ADD + LOADI + LOAD 0 ; FIL + LOADC 48 + ADD + LOADI + LOADCP _MUL + CALL + ADD + STORE 4 ; BLKNO + LOAD 0 ; FIL + LOADC 20 + ADD + LOADI + LOAD 0 ; FIL + LOADC 56 + ADD + LOADI + LOAD 4 ; BLKNO + LOAD 0 ; FIL + LOADC 44 + ADD + LOADI + ; ERROR + LOADREG FP + INC 8 + LOADCP WRITEVOLUMEBLKS + CALL + LOAD 8 ; ERROR + LOADC 0 + CMP NE + .LCBRANCHZ _IF_ELSE119_STDLIB + LOAD 0 ; FIL + LOAD 8 ; ERROR + LOADCP FILEERROR + CALL +_IF_ELSE119_STDLIB: +_IF_END119_STDLIB: + LOAD 0 ; FIL + LOADC 68 + ADD + LOADC 0 + STOREI + DROP + FPADJ 12 + RET +SEEK: + FPADJ -16 + STORE 4 ; POSITION + STORE 0 ; FIL + LOAD 0 ; FIL + LOADCP CHECKERROR + CALL + LOAD 0 ; FIL + LOADC 16 + ADD + LOADI + LOADC 0 + CMP EQ + .LCBRANCHZ _IF_ELSE120_STDLIB + LOAD 0 ; FIL + LOADC 6 + LOADCP FILEERROR + CALL + .LBRANCH _IF_END120_STDLIB +_IF_ELSE120_STDLIB: + LOAD 0 ; FIL + LOADC 68 + ADD + LOADI + .LCBRANCHZ _IF_ELSE121_STDLIB + LOAD 0 ; FIL + LOADCP FLUSHFILE + CALL +_IF_ELSE121_STDLIB: +_IF_END121_STDLIB: + LOAD 4 ; POSITION + LOAD 0 ; FIL + LOADC 36 + ADD + LOADI + CMP GT + LOAD 0 ; FIL + LOADI + LOADC 4 + CMP EQ + OR + .LCBRANCHZ _IF_ELSE122_STDLIB + LOAD 0 ; FIL + LOADC 6 + LOADCP FILEERROR + CALL + .LBRANCH _IF_END122_STDLIB +_IF_ELSE122_STDLIB: + LOAD 0 ; FIL + LOADC 28 + ADD + LOAD 4 ; POSITION + STOREI + DROP + LOAD 0 ; FIL + LOADC 60 + ADD + LOAD 4 ; POSITION + LOAD 0 ; FIL + LOADC 64 + ADD + LOADI + LOADCP _MOD + CALL + STOREI + DROP + LOAD 4 ; POSITION + LOAD 0 ; FIL + LOADC 32 + ADD + LOADI + CMP LT + LOAD 4 ; POSITION + LOAD 0 ; FIL + LOADC 32 + ADD + LOADI + LOAD 0 ; FIL + LOADC 64 + ADD + LOADI + ADD + CMP GE + OR + .LCBRANCHZ _IF_ELSE123_STDLIB + LOAD 0 ; FIL + ; ERROR + LOADREG FP + INC 12 + LOADCP READBUF + CALL + LOAD 12 ; ERROR + LOADC 0 + CMP NE + .LCBRANCHZ _IF_ELSE124_STDLIB + LOAD 0 ; FIL + LOAD 12 ; ERROR + LOADCP FILEERROR + CALL +_IF_ELSE124_STDLIB: +_IF_END124_STDLIB: +_IF_ELSE123_STDLIB: +_IF_END123_STDLIB: +_IF_END122_STDLIB: +_IF_END120_STDLIB: + FPADJ 16 + RET + .CPOOL +FILEPOS: + FPADJ -8 + STORE 0 ; FIL + LOAD 0 ; FIL + LOADC 16 + ADD + LOADI + LOADC 0 + CMP EQ + .LCBRANCHZ _IF_ELSE125_STDLIB + LOADC 0 + STORE 4 ; FILEPOS + .LBRANCH _IF_END125_STDLIB +_IF_ELSE125_STDLIB: + LOAD 0 ; FIL + LOADC 28 + ADD + LOADI + STORE 4 ; FILEPOS +_IF_END125_STDLIB: + LOAD 4 ; FILEPOS + FPADJ 8 + RET +FILESIZE: + FPADJ -8 + STORE 0 ; FIL + LOAD 0 ; FIL + LOADC 16 + ADD + LOADI + LOADC 0 + CMP EQ + .LCBRANCHZ _IF_ELSE126_STDLIB + LOADC -1 + STORE 4 ; FILESIZE + .LBRANCH _IF_END126_STDLIB +_IF_ELSE126_STDLIB: + LOAD 0 ; FIL + LOADC 36 + ADD + LOADI + STORE 4 ; FILESIZE +_IF_END126_STDLIB: + LOAD 4 ; FILESIZE + FPADJ 8 + RET +EXTENDFILE: + FPADJ -88 + STORE 4 ; NEWSIZE + STORE 0 ; FIL + ; ENTRY + LOADREG FP + INC 12 + LOADC 64 + LOADCP _CLEARMEM + CALL + LOAD 4 ; NEWSIZE + LOAD 0 ; FIL + LOADC 36 + ADD + LOADI + CMP GT + .LCBRANCHZ _IF_ELSE127_STDLIB + LOAD 4 ; NEWSIZE + LOAD 0 ; FIL + LOADC 48 + ADD + LOADI + LOADC 512 + LOADCP _MUL + CALL + LOADCP _DIV + CALL + LOADC 1 + ADD + STORE 8 ; NEWEXTENTS + LOAD 8 ; NEWEXTENTS + LOAD 0 ; FIL + LOADC 40 + ADD + LOADI + CMP GT + .LCBRANCHZ _IF_ELSE128_STDLIB + LOAD 0 ; FIL + LOADC 24 + ADD + LOADI + LOAD 8 ; NEWEXTENTS + ADD + LOADC 1 + SUB + STORE 76 ; ENDSLOT + LOAD 0 ; FIL + LOADC 24 + ADD + LOADI + LOAD 0 ; FIL + LOADC 40 + ADD + LOADI + ADD + STORE 80 ; I + LOAD 76 ; ENDSLOT +_FOR_START14_STDLIB: + LOAD 80 ; I + OVER + CMP GT + .LCBRANCH _FOR_END14_STDLIB + LOAD 0 ; FIL + LOADC 20 + ADD + LOADI + LOAD 80 ; I + ; ENTRY + LOADREG FP + INC 12 + ; ERROR + LOADREG FP + LOADC 84 + ADD + LOADCP GETDIRSLOT + CALL + LOADC 0 + LOAD 52 ; ENTRY + LOADCP _TESTBIT + CALL + LOADC 0 + CMP EQ + .LCBRANCHZ _IF_ELSE129_STDLIB + LOAD 0 ; FIL + LOADC 7 + LOADCP FILEERROR + CALL + .LBRANCH _FOR_END14_STDLIB + .LBRANCH _IF_END129_STDLIB +_IF_ELSE129_STDLIB: + LOAD 52 ; ENTRY + LOADC 0 + LOADC 0 + LOADCP _SETBIT + CALL + LOADC 3 + LOADCP _SETBIT + CALL + NOT + AND + LOADC 0 + LOADC 5 + LOADCP _SETBIT + CALL + OR + STORE 52 ; ENTRY + LOAD 0 ; FIL + LOADC 20 + ADD + LOADI + LOAD 80 ; I + ; ENTRY + LOADREG FP + INC 12 + ; ERROR + LOADREG FP + LOADC 84 + ADD + LOADCP PUTDIRSLOT + CALL + LOAD 84 ; ERROR + LOADC 0 + CMP NE + .LCBRANCHZ _IF_ELSE130_STDLIB + LOAD 0 ; FIL + LOAD 84 ; ERROR + LOADCP FILEERROR + CALL +_IF_ELSE130_STDLIB: +_IF_END130_STDLIB: +_IF_END129_STDLIB: + LOAD 80 ; I + INC 1 + STORE 80 ; I + .LBRANCH _FOR_START14_STDLIB +_FOR_END14_STDLIB: + DROP +_IF_ELSE128_STDLIB: +_IF_END128_STDLIB: + LOAD 0 ; FIL + INC 4 + LOADI + LOADC 0 + CMP EQ + .LCBRANCHZ _IF_ELSE131_STDLIB + LOAD 0 ; FIL + LOADC 36 + ADD + LOAD 4 ; NEWSIZE + STOREI + DROP + LOAD 0 ; FIL + LOADC 40 + ADD + LOAD 8 ; NEWEXTENTS + STOREI + DROP +_IF_ELSE131_STDLIB: +_IF_END131_STDLIB: +_IF_ELSE127_STDLIB: +_IF_END127_STDLIB: + FPADJ 88 + RET + .CPOOL +WRITEFS: + FPADJ -36 + STORE 8 ; LEN + STORE 4 ; SRCBUF + STORE 0 ; FIL + LOAD 0 ; FIL + LOADC 64 + ADD + LOADI + LOAD 0 ; FIL + LOADC 60 + ADD + LOADI + SUB + STORE 12 ; BUFLEFT + LOAD 8 ; LEN + STORE 16 ; SRCLEFT + LOADC 0 + STORE 20 ; SRCPOS + LOADC 0 + STORE 32 ; ERROR + LOAD 0 ; FIL + LOADI + LOADC 0 + CMP EQ + .LCBRANCHZ _IF_ELSE132_STDLIB + LOAD 0 ; FIL + LOADC 8 + LOADCP FILEERROR + CALL + .LBRANCH _L105ERREXIT_STDLIB +_IF_ELSE132_STDLIB: +_IF_END132_STDLIB: + LOAD 0 ; FIL + LOADC 28 + ADD + LOADI + LOAD 8 ; LEN + ADD + STORE 28 ; NEWPOS + LOAD 28 ; NEWPOS + LOAD 0 ; FIL + LOADC 36 + ADD + LOADI + CMP GT + .LCBRANCHZ _IF_ELSE133_STDLIB + LOAD 0 ; FIL + LOAD 28 ; NEWPOS + LOADCP EXTENDFILE + CALL + LOAD 0 ; FIL + INC 4 + LOADI + LOADC 0 + CMP NE + .LCBRANCHZ _IF_ELSE134_STDLIB + .LBRANCH _L105ERREXIT_STDLIB +_IF_ELSE134_STDLIB: +_IF_END134_STDLIB: +_IF_ELSE133_STDLIB: +_IF_END133_STDLIB: +_WHILE_START13_STDLIB: + LOAD 16 ; SRCLEFT + LOADC 0 + CMP GT + LOAD 32 ; ERROR + LOADC 0 + CMP EQ + AND + .LCBRANCHZ _WHILE_END13_STDLIB + LOAD 0 ; FIL + LOADC 52 + ADD + LOADC 1 + STOREI + DROP + LOAD 0 ; FIL + LOADC 68 + ADD + LOADC 1 + STOREI + DROP + LOAD 16 ; SRCLEFT + LOAD 12 ; BUFLEFT + CMP GT + .LCBRANCHZ _IF_ELSE135_STDLIB + LOAD 0 ; FIL + LOADC 56 + ADD + LOADI + LOAD 0 ; FIL + LOADC 60 + ADD + LOADI + LOAD 4 ; SRCBUF + LOAD 20 ; SRCPOS + LOAD 12 ; BUFLEFT + LOADCP COPYBUF + CALL + LOAD 0 ; FIL + LOADC 60 + ADD + LOADC 0 + STOREI + DROP + LOAD 0 ; FIL + LOADC 28 + ADD + LOAD 0 ; FIL + LOADC 28 + ADD + LOADI + LOAD 12 ; BUFLEFT + ADD + STOREI + DROP + LOAD 16 ; SRCLEFT + LOAD 12 ; BUFLEFT + SUB + STORE 16 ; SRCLEFT + LOAD 20 ; SRCPOS + LOAD 12 ; BUFLEFT + ADD + STORE 20 ; SRCPOS + LOAD 0 ; FIL + LOADC 64 + ADD + LOADI + STORE 12 ; BUFLEFT + .LBRANCH _IF_END135_STDLIB +_IF_ELSE135_STDLIB: + LOAD 0 ; FIL + LOADC 56 + ADD + LOADI + LOAD 0 ; FIL + LOADC 60 + ADD + LOADI + LOAD 4 ; SRCBUF + LOAD 20 ; SRCPOS + LOAD 16 ; SRCLEFT + LOADCP COPYBUF + CALL + LOAD 0 ; FIL + LOADC 60 + ADD + LOAD 0 ; FIL + LOADC 60 + ADD + LOADI + LOAD 16 ; SRCLEFT + ADD + STOREI + DROP + LOAD 0 ; FIL + LOADC 28 + ADD + LOAD 0 ; FIL + LOADC 28 + ADD + LOADI + LOAD 16 ; SRCLEFT + ADD + STOREI + DROP + LOAD 12 ; BUFLEFT + LOAD 16 ; SRCLEFT + SUB + STORE 12 ; BUFLEFT + LOADC 0 + STORE 16 ; SRCLEFT +_IF_END135_STDLIB: + LOAD 0 ; FIL + LOADC 28 + ADD + LOADI + LOAD 0 ; FIL + LOADC 32 + ADD + LOADI + LOAD 0 ; FIL + LOADC 64 + ADD + LOADI + ADD + CMP GE + .LCBRANCHZ _IF_ELSE136_STDLIB + LOAD 0 ; FIL + LOADCP FLUSHFILE + CALL + LOAD 16 ; SRCLEFT + LOAD 0 ; FIL + LOADC 64 + ADD + LOADI + CMP LT + .LCBRANCHZ _IF_ELSE137_STDLIB + LOAD 0 ; FIL + ; ERROR + LOADREG FP + LOADC 32 + ADD + LOADCP READBUF + CALL + .LBRANCH _IF_END137_STDLIB + .CPOOL +_IF_ELSE137_STDLIB: + LOAD 0 ; FIL + LOADC 32 + ADD + LOAD 0 ; FIL + LOADC 32 + ADD + LOADI + LOAD 0 ; FIL + LOADC 64 + ADD + LOADI + ADD + STOREI + DROP +_IF_END137_STDLIB: +_IF_ELSE136_STDLIB: +_IF_END136_STDLIB: + LOAD 32 ; ERROR + LOADC 0 + CMP NE + .LCBRANCHZ _IF_ELSE138_STDLIB + LOAD 0 ; FIL + LOAD 32 ; ERROR + LOADCP FILEERROR + CALL +_IF_ELSE138_STDLIB: +_IF_END138_STDLIB: + .LBRANCH _WHILE_START13_STDLIB +_WHILE_END13_STDLIB: +_L105ERREXIT_STDLIB: + FPADJ 36 + RET +FINDFILE: + FPADJ -36 + STORE 12 ; ERROR + STORE 8 ; DIRSLOT + STORE 4 ; NAME + STORE 0 ; VOLID + LOADC -1 + STORE 16 ; FINDFILE + LOADCP VOLUMETABLE ; VOLUMETABLE + LOAD 0 ; VOLID + DEC 1 + DUP + LOADC 32 + LOADCP _BOUNDSCHECK + CALL + LOADC 96 + LOADCP _MULU + CALL + ADD + LOADREG FP + DEC 4 + SWAP + STOREI + DROP + LOADREG FP + DEC 4 + LOADI + LOADC 56 + ADD + LOADI + STORE 24 ; MAXSLOTS + LOADREG FP + DEC 4 + LOADI + LOADC 72 + ADD + LOADI + STORE 20 ; SLOTNO + LOADC 0 + STORE 28 ; DONE + LOADC 0 + STORE 32 ; FOUND +_REPEAT_START10_STDLIB: + LOAD 0 ; VOLID + LOAD 20 ; SLOTNO + LOAD 8 ; DIRSLOT + LOAD 12 ; ERROR + FPADJ -4 + LOADCP GETDIRSLOT + CALL + FPADJ 4 + LOADC 2 + LOAD 8 ; DIRSLOT + LOADC 40 + ADD + LOADI + LOADCP _TESTBIT + CALL + LOADC 0 + CMP EQ + LOADC 4 + LOAD 8 ; DIRSLOT + LOADC 40 + ADD + LOADI + LOADCP _TESTBIT + CALL + AND + LOAD 4 ; NAME + LOAD 8 ; DIRSLOT + FPADJ -4 + LOADCP _CMPSTRING + CALL + FPADJ 4 + AND + .LCBRANCHZ _IF_ELSE139_STDLIB + LOAD 20 ; SLOTNO + STORE 16 ; FINDFILE + LOADC 1 + STORE 28 ; DONE + LOADC 1 + STORE 32 ; FOUND +_IF_ELSE139_STDLIB: +_IF_END139_STDLIB: + LOADC 3 + LOAD 8 ; DIRSLOT + LOADC 40 + ADD + LOADI + LOADCP _TESTBIT + CALL + .LCBRANCHZ _IF_ELSE140_STDLIB + LOADC 1 + STORE 28 ; DONE +_IF_ELSE140_STDLIB: +_IF_END140_STDLIB: + LOAD 20 ; SLOTNO + LOADC 1 + ADD + STORE 20 ; SLOTNO + LOAD 28 ; DONE + LOAD 20 ; SLOTNO + LOAD 24 ; MAXSLOTS + CMP GE + OR + LOAD 12 ; ERROR + LOADI + LOADC 0 + CMP NE + OR + .LCBRANCHZ _REPEAT_START10_STDLIB +_REPEAT_END10_STDLIB: + LOAD 12 ; ERROR + LOADI + LOADC 0 + CMP EQ + LOAD 32 ; FOUND + LOADC 0 + CMP EQ + AND + .LCBRANCHZ _IF_ELSE141_STDLIB + LOAD 12 ; ERROR + LOADC 1 + STOREI + DROP +_IF_ELSE141_STDLIB: +_IF_END141_STDLIB: + LOAD 16 ; FINDFILE + FPADJ 36 + RET +OPENFILE: + FPADJ -24 + STORE 16 ; MODE + STORE 12 ; AFILE + STORE 8 ; DIRSLOT + STORE 4 ; SLOTNO + STORE 0 ; VOLID + LOADCP VOLUMETABLE ; VOLUMETABLE + LOAD 0 ; VOLID + DEC 1 + DUP + LOADC 32 + LOADCP _BOUNDSCHECK + CALL + LOADC 96 + LOADCP _MULU + CALL + ADD + LOADC 52 + ADD + LOADI + STORE 20 ; EXTENTSIZE + LOAD 12 ; AFILE + LOADC 16 + ADD + LOADC 1 + STOREI + DROP + LOAD 12 ; AFILE + LOAD 16 ; MODE + STOREI + DROP + LOAD 12 ; AFILE + LOADC 56 + ADD + LOADC 4095 + INC 1 + LOADCP _MEM_ALLOC + CALL + LOADCP _CHECK_ALLOC + CALL + STOREI + DROP + LOAD 12 ; AFILE + LOADC 60 + ADD + LOADC 0 + STOREI + DROP + LOAD 12 ; AFILE + LOADC 64 + ADD + LOADC 4095 + INC 1 + STOREI + DROP + LOAD 12 ; AFILE + LOADC 68 + ADD + LOADC 0 + STOREI + DROP + LOAD 12 ; AFILE + LOADC 52 + ADD + LOADC 0 + STOREI + DROP + LOAD 12 ; AFILE + INC 4 + LOADC 0 + STOREI + DROP + LOAD 12 ; AFILE + INC 8 + LOADC 0 + STOREI + DROP + LOAD 12 ; AFILE + LOADC 20 + ADD + LOAD 0 ; VOLID + STOREI + DROP + LOAD 12 ; AFILE + LOADC 24 + ADD + LOAD 4 ; SLOTNO + STOREI + DROP + LOAD 12 ; AFILE + LOADC 28 + ADD + LOADC 0 + STOREI + DROP + LOAD 12 ; AFILE + LOADC 32 + ADD + LOADC 1 + STOREI + DROP + LOAD 12 ; AFILE + LOADC 36 + ADD + LOAD 8 ; DIRSLOT + LOADC 44 + ADD + LOADI + STOREI + DROP + LOAD 12 ; AFILE + LOADC 40 + ADD + LOAD 8 ; DIRSLOT + LOADC 44 + ADD + LOADI + LOAD 20 ; EXTENTSIZE + LOADCP _DIV + CALL + LOADC 1 + ADD + STOREI + DROP + LOAD 12 ; AFILE + LOADC 44 + ADD + LOADC 8 + STOREI + DROP + LOAD 12 ; AFILE + LOADC 48 + ADD + LOAD 20 ; EXTENTSIZE + LOADC 512 + LOADCP _DIV + CALL + STOREI + DROP + LOAD 12 ; AFILE + LOADC 0 + LOADCP SEEK + CALL + FPADJ 24 + RET + .CPOOL +UPDATEDIRSLOT: + FPADJ -72 + STORE 0 ; AFILE + ; DIRS + LOADREG FP + INC 4 + LOADC 64 + LOADCP _CLEARMEM + CALL + LOAD 0 ; AFILE + LOADC 20 + ADD + LOADI + LOAD 0 ; AFILE + LOADC 24 + ADD + LOADI + ; DIRS + LOADREG FP + INC 4 + ; ERROR + LOADREG FP + LOADC 68 + ADD + LOADCP GETDIRSLOT + CALL + LOAD 68 ; ERROR + LOADC 0 + CMP EQ + .LCBRANCHZ _IF_ELSE142_STDLIB + LOAD 0 ; AFILE + LOADC 36 + ADD + LOADI + STORE 48 ; DIRS + LOADCP GETCURTIMESTAMP + CALL + STORE 56 ; DIRS + LOAD 0 ; AFILE + LOADC 20 + ADD + LOADI + LOAD 0 ; AFILE + LOADC 24 + ADD + LOADI + ; DIRS + LOADREG FP + INC 4 + ; ERROR + LOADREG FP + LOADC 68 + ADD + LOADCP PUTDIRSLOT + CALL +_IF_ELSE142_STDLIB: +_IF_END142_STDLIB: + LOAD 0 ; AFILE + LOAD 68 ; ERROR + LOADCP FILEERROR + CALL + FPADJ 72 + RET +CLOSE: + FPADJ -4 + STORE 0 ; AFILE + LOAD 0 ; AFILE + LOADC 16 + ADD + LOADI + LOADC 1 + CMP EQ + .LCBRANCHZ _IF_ELSE143_STDLIB + LOAD 0 ; AFILE + LOADC 68 + ADD + LOADI + .LCBRANCHZ _IF_ELSE144_STDLIB + LOAD 0 ; AFILE + LOADCP FLUSHFILE + CALL +_IF_ELSE144_STDLIB: +_IF_END144_STDLIB: + LOAD 0 ; AFILE + INC 4 + LOADI + LOADC 0 + CMP EQ + .LCBRANCHZ _IF_ELSE145_STDLIB + LOAD 0 ; AFILE + LOADC 5 + LOADCP FILEERROR + CALL + LOAD 0 ; AFILE + LOADC 56 + ADD + LOADI + LOADCP _MEM_FREE + CALL + LOAD 0 ; AFILE + LOADC 56 + ADD + LOADC 0 + STOREI + DROP + LOAD 0 ; AFILE + LOADC 52 + ADD + LOADI + .LCBRANCHZ _IF_ELSE146_STDLIB + LOAD 0 ; AFILE + LOADCP UPDATEDIRSLOT + CALL +_IF_ELSE146_STDLIB: +_IF_END146_STDLIB: +_IF_ELSE145_STDLIB: +_IF_END145_STDLIB: + LOAD 0 ; AFILE + LOADC 20 + ADD + LOADI + LOADCP CLOSEVOLUMEID + CALL +_IF_ELSE143_STDLIB: +_IF_END143_STDLIB: + FPADJ 4 + RET +DELETEFILE: + FPADJ -16 + STORE 12 ; ERROR + STORE 8 ; DIRSLOT + STORE 4 ; SLOTNO + STORE 0 ; VOLID + LOAD 8 ; DIRSLOT + LOADC 40 + ADD + LOAD 8 ; DIRSLOT + LOADC 40 + ADD + LOADI + LOADC 0 + LOADC 4 + LOADCP _SETBIT + CALL + NOT + AND + LOADC 0 + LOADC 2 + LOADCP _SETBIT + CALL + OR + STOREI + DROP + LOAD 0 ; VOLID + LOAD 4 ; SLOTNO + LOAD 8 ; DIRSLOT + LOAD 12 ; ERROR + LOADCP PUTDIRSLOT + CALL + FPADJ 16 + RET +CREATEFILE: + FPADJ -144 + STORE 56 ; ERROR + STORE 52 ; DIRSLOT + STORE 48 ; SLOTNO + STORE 44 ; OVERWRITE + ; NAME + LOADREG FP + INC 4 + SWAP + LOADC 32 + LOADCP _INITSTRINGFROM + CALL + STORE 0 ; VOLID + ; OLDDIRSLOT + LOADREG FP + LOADC 72 + ADD + LOADC 64 + LOADCP _CLEARMEM + CALL + LOADC 0 + STORE 60 ; GENERATION + LOAD 0 ; VOLID + ; NAME + LOADREG FP + INC 4 + ; OLDDIRSLOT + LOADREG FP + LOADC 72 + ADD + LOAD 56 ; ERROR + LOADCP FINDFILE + CALL + STORE 68 ; OLDSLOTNO + LOAD 44 ; OVERWRITE + LOADC 0 + CMP EQ + LOAD 68 ; OLDSLOTNO + LOADC 0 + CMP GT + AND + .LCBRANCHZ _IF_ELSE147_STDLIB + LOAD 56 ; ERROR + LOADC 4 + STOREI + DROP + LOAD 48 ; SLOTNO + LOADC -1 + STOREI + DROP + .LBRANCH _IF_END147_STDLIB +_IF_ELSE147_STDLIB: + LOADCP GETCURTIMESTAMP + CALL + STORE 140 ; NOWTS + LOAD 44 ; OVERWRITE + LOAD 68 ; OLDSLOTNO + LOADC 0 + CMP GT + AND + .LCBRANCHZ _IF_ELSE148_STDLIB + LOAD 128 ; OLDDIRSLOT + LOADC 1 + ADD + STORE 60 ; GENERATION + LOAD 120 ; OLDDIRSLOT + STORE 136 ; CREATETS + .LBRANCH _IF_END148_STDLIB + .CPOOL +_IF_ELSE148_STDLIB: + LOAD 140 ; NOWTS + STORE 136 ; CREATETS +_IF_END148_STDLIB: + LOAD 48 ; SLOTNO + LOAD 0 ; VOLID + LOAD 56 ; ERROR + LOADCP FINDDIRSLOT + CALL + STOREI + DROP + LOAD 48 ; SLOTNO + LOADI + LOADC 0 + CMP LE + .LCBRANCHZ _IF_ELSE149_STDLIB + LOAD 56 ; ERROR + LOADC 7 + STOREI + DROP + .LBRANCH _IF_END149_STDLIB +_IF_ELSE149_STDLIB: + LOAD 48 ; SLOTNO + LOADI + LOADC 0 + CMP GT + LOAD 56 ; ERROR + LOADI + LOADC 0 + CMP EQ + AND + .LCBRANCHZ _IF_ELSE150_STDLIB + LOAD 0 ; VOLID + LOAD 48 ; SLOTNO + LOADI + LOAD 52 ; DIRSLOT + LOAD 56 ; ERROR + LOADCP GETDIRSLOT + CALL + LOAD 52 ; DIRSLOT + ; NAME + LOADREG FP + INC 4 + LOADC 32 + LOADCP _INITSTRINGFROM + CALL + LOAD 52 ; DIRSLOT + LOADC 40 + ADD + LOADC 0 + LOADC 4 + LOADCP _SETBIT + CALL + STOREI + DROP + LOAD 52 ; DIRSLOT + LOADC 44 + ADD + LOADC 0 + STOREI + DROP + LOAD 52 ; DIRSLOT + LOADC 56 + ADD + LOAD 60 ; GENERATION + STOREI + DROP + LOAD 52 ; DIRSLOT + LOADC 60 + ADD + LOADC 0 + STOREI + DROP + LOAD 52 ; DIRSLOT + LOADC 52 + ADD + LOAD 140 ; NOWTS + STOREI + DROP + LOAD 52 ; DIRSLOT + LOADC 48 + ADD + LOAD 136 ; CREATETS + STOREI + DROP + LOAD 0 ; VOLID + LOAD 48 ; SLOTNO + LOADI + LOAD 52 ; DIRSLOT + LOAD 56 ; ERROR + LOADCP PUTDIRSLOT + CALL + LOAD 44 ; OVERWRITE + LOAD 68 ; OLDSLOTNO + LOADC 0 + CMP GT + AND + .LCBRANCHZ _IF_ELSE151_STDLIB + LOAD 0 ; VOLID + LOAD 68 ; OLDSLOTNO + ; OLDDIRSLOT + LOADREG FP + LOADC 72 + ADD + LOAD 56 ; ERROR + LOADCP DELETEFILE + CALL +_IF_ELSE151_STDLIB: +_IF_END151_STDLIB: +_IF_ELSE150_STDLIB: +_IF_END150_STDLIB: +_IF_END149_STDLIB: +_IF_END147_STDLIB: + FPADJ 144 + RET +INITDEVICES: + LOADCP CARDCHANGED + CALL + .LCBRANCHZ _IF_ELSE152_STDLIB + LOADCP DEVICESINITIALIZED ; DEVICESINITIALIZED + LOADC 0 + STOREI + DROP +_IF_ELSE152_STDLIB: +_IF_END152_STDLIB: + LOADCP DEVICESINITIALIZED ; DEVICESINITIALIZED + LOADI + LOADC 0 + CMP EQ + .LCBRANCHZ _IF_ELSE153_STDLIB + LOADCP DEFAULTVOLUMEID ; DEFAULTVOLUMEID + LOADC 0 + STOREI + DROP + LOADCP INITSDCARD + CALL + LOADCP VOLUMECOUNT ; VOLUMECOUNT + LOADC 0 + STOREI + DROP + LOADC 0 + LOADCP READPARTITIONS + CALL + LOADCP DEVICESINITIALIZED ; DEVICESINITIALIZED + LOADC 1 + STOREI + DROP + LOADCP DEFAULTVOLUME ; DEFAULTVOLUME + LOADCP LENGTH + CALL + LOADC 0 + CMP GT + .LCBRANCHZ _IF_ELSE154_STDLIB + LOADCP DEFAULTVOLUMEID ; DEFAULTVOLUMEID + LOADCP DEFAULTVOLUME ; DEFAULTVOLUME + LOADCP FINDVOLUME + CALL + STOREI + DROP +_IF_ELSE154_STDLIB: +_IF_END154_STDLIB: + LOADCP DEFAULTVOLUMEID ; DEFAULTVOLUMEID + LOADI + LOADC 0 + CMP EQ + LOADCP VOLUMECOUNT ; VOLUMECOUNT + LOADI + LOADC 0 + CMP GT + AND + .LCBRANCHZ _IF_ELSE155_STDLIB + LOADCP DEFAULTVOLUMEID ; DEFAULTVOLUMEID + LOADC 1 + STOREI + DROP +_IF_ELSE155_STDLIB: +_IF_END155_STDLIB: +_IF_ELSE153_STDLIB: +_IF_END153_STDLIB: + RET +READDIRNEXT: + FPADJ -24 + STORE 12 ; ERROR + STORE 8 ; DIRSLOT + STORE 4 ; INDEX + STORE 0 ; VOLID + LOADCP VOLUMETABLE ; VOLUMETABLE + LOAD 0 ; VOLID + DEC 1 + DUP + LOADC 32 + LOADCP _BOUNDSCHECK + CALL + LOADC 96 + LOADCP _MULU + CALL + ADD + LOADC 56 + ADD + LOADI + LOADC 1 + SUB + STORE 16 ; LASTSLOT + LOADC 0 + STORE 20 ; FOUND +_REPEAT_START11_STDLIB: + LOAD 0 ; VOLID + LOAD 4 ; INDEX + LOADI + LOAD 8 ; DIRSLOT + LOAD 12 ; ERROR + LOADCP GETDIRSLOT + CALL + LOAD 4 ; INDEX + LOAD 4 ; INDEX + LOADI + LOADC 1 + ADD + STOREI + DROP + LOADC 4 + LOAD 8 ; DIRSLOT + LOADC 40 + ADD + LOADI + LOADCP _TESTBIT + CALL + STORE 20 ; FOUND + LOAD 20 ; FOUND + LOADC 3 + LOAD 8 ; DIRSLOT + LOADC 40 + ADD + LOADI + LOADCP _TESTBIT + CALL + OR + LOAD 4 ; INDEX + LOADI + LOAD 16 ; LASTSLOT + CMP EQ + OR + LOAD 12 ; ERROR + LOADI + LOADC 0 + CMP NE + OR + .LCBRANCHZ _REPEAT_START11_STDLIB +_REPEAT_END11_STDLIB: + LOAD 20 ; FOUND + LOADC 0 + CMP EQ + .LCBRANCHZ _IF_ELSE156_STDLIB + LOAD 4 ; INDEX + LOADC -1 + STOREI + DROP +_IF_ELSE156_STDLIB: +_IF_END156_STDLIB: + FPADJ 24 + RET + .CPOOL +READDIRFIRST: + FPADJ -16 + STORE 12 ; ERROR + STORE 8 ; DIRSLOT + STORE 4 ; INDEX + STORE 0 ; VOLID + LOADCP INITDEVICES + CALL + LOAD 4 ; INDEX + LOADCP VOLUMETABLE ; VOLUMETABLE + LOAD 0 ; VOLID + DEC 1 + DUP + LOADC 32 + LOADCP _BOUNDSCHECK + CALL + LOADC 96 + LOADCP _MULU + CALL + ADD + LOADC 72 + ADD + LOADI + STOREI + DROP + LOAD 0 ; VOLID + LOAD 4 ; INDEX + LOAD 8 ; DIRSLOT + LOAD 12 ; ERROR + LOADCP READDIRNEXT + CALL + FPADJ 16 + RET +CHARPOS: + FPADJ -20 + STORE 4 ; S + STORE 0 ; SEARCHCHAR + LOADC 0 + STORE 8 ; CHARPOS + LOADC 1 + STORE 16 ; P + LOAD 4 ; S + DUP + LOADI + SWAP + INC 8 +_FOR_START15_STDLIB: + OVER + .LCBRANCHZ _FOR_END15_STDLIB + DUP + LOADI.S1.X2Y + BSEL + STORE 12 ; C + LOAD 12 ; C + LOAD 0 ; SEARCHCHAR + CMP EQ + .LCBRANCHZ _IF_ELSE157_STDLIB + LOAD 16 ; P + STORE 8 ; CHARPOS + .LBRANCH _FOR_END15_STDLIB +_IF_ELSE157_STDLIB: +_IF_END157_STDLIB: + LOAD 16 ; P + LOADC 1 + ADD + STORE 16 ; P + INC 1 + SWAP + DEC 1 + SWAP + .LBRANCH _FOR_START15_STDLIB +_FOR_END15_STDLIB: + DROP + DROP + LOAD 8 ; CHARPOS + FPADJ 20 + RET +OPENVOLPATH: + FPADJ -144 + STORE 92 ; ERROR + STORE 88 ; DIRS + STORE 84 ; SLOTNO + STORE 80 ; FNAME + STORE 76 ; VOLID + ; PATH + LOADREG FP + SWAP + LOADC 68 + LOADCP _INITSTRINGFROM + CALL + LOADC 32 + ; VOLNAME + LOADREG FP + LOADC 104 + ADD + LOADCP _INITSTRINGF + CALL + LOADCP INITDEVICES + CALL + LOAD 84 ; SLOTNO + LOADC 0 + STOREI + DROP + LOAD 92 ; ERROR + LOADC 0 + STOREI + DROP + LOAD 76 ; VOLID + LOADC 0 + STOREI + DROP + ; PATH + LOADREG FP + LOADC 1 + LOADCP _INDEXSTRING + CALL + LOADI.S1.X2Y + BSEL + LOADC 35 + CMP EQ + .LCBRANCHZ _IF_ELSE158_STDLIB + LOADC 58 + ; PATH + LOADREG FP + LOADCP CHARPOS + CALL + STORE 100 ; SEPARATORPOS + LOAD 100 ; SEPARATORPOS + LOADC 0 + CMP GT + .LCBRANCHZ _IF_ELSE159_STDLIB + ; VOLNAME + LOADREG FP + LOADC 104 + ADD + ; PATH + LOADREG FP + LOADC 2 + LOAD 100 ; SEPARATORPOS + LOADC 2 + SUB + LOADC 80 + LOADREG FP + LOADC 88 + SUB + LOADCP _INITSTRINGF + CALL + LOADREG FP + LOADC 88 + SUB + FPADJ -88 + LOADCP COPY + CALL + FPADJ 88 + FPADJ -88 + LOADCP _COPYSTRING + CALL + FPADJ 88 + LOAD 80 ; FNAME + ; PATH + LOADREG FP + LOAD 100 ; SEPARATORPOS + LOADC 1 + ADD + ; PATH + LOADREG FP + LOADCP LENGTH + CALL + LOAD 100 ; SEPARATORPOS + SUB + LOADC 80 + LOADREG FP + LOADC 88 + SUB + LOADCP _INITSTRINGF + CALL + LOADREG FP + LOADC 88 + SUB + FPADJ -88 + LOADCP COPY + CALL + FPADJ 88 + FPADJ -88 + LOADCP _COPYSTRING + CALL + FPADJ 88 + LOAD 76 ; VOLID + ; VOLNAME + LOADREG FP + LOADC 104 + ADD + LOADCP FINDVOLUME + CALL + STOREI + DROP +_IF_ELSE159_STDLIB: +_IF_END159_STDLIB: + .LBRANCH _IF_END158_STDLIB +_IF_ELSE158_STDLIB: + LOAD 76 ; VOLID + LOADCP DEFAULTVOLUMEID ; DEFAULTVOLUMEID + LOADI + STOREI + DROP + LOAD 80 ; FNAME + ; PATH + LOADREG FP + LOADCP _COPYSTRING + CALL +_IF_END158_STDLIB: + LOAD 76 ; VOLID + LOADI + LOADC 0 + CMP GT + .LCBRANCHZ _IF_ELSE160_STDLIB + LOAD 76 ; VOLID + LOADI + LOADCP OPENVOLUMEID + CALL + LOAD 84 ; SLOTNO + LOAD 76 ; VOLID + LOADI + LOAD 80 ; FNAME + LOAD 88 ; DIRS + LOAD 92 ; ERROR + LOADCP FINDFILE + CALL + STOREI + DROP + .LBRANCH _IF_END160_STDLIB + .CPOOL +_IF_ELSE160_STDLIB: + LOAD 92 ; ERROR + LOADC 2 + STOREI + DROP +_IF_END160_STDLIB: + FPADJ 144 + RET +RENAME: + FPADJ -264 + STORE 80 ; ERROR + ; NEWNAME + LOADREG FP + LOADC 40 + ADD + SWAP + LOADC 32 + LOADCP _INITSTRINGFROM + CALL + ; OLDNAME + LOADREG FP + SWAP + LOADC 32 + LOADCP _INITSTRINGFROM + CALL + ; OLDDIRS + LOADREG FP + LOADC 84 + ADD + LOADC 64 + LOADCP _CLEARMEM + CALL + ; NEWDIRS + LOADREG FP + LOADC 148 + ADD + LOADC 64 + LOADCP _CLEARMEM + CALL + LOADC 32 + ; FNAME + LOADREG FP + LOADC 224 + ADD + LOADCP _INITSTRINGF + CALL + LOADC 0 + STORE 212 ; VOLID + ; NEWNAME + LOADREG FP + LOADC 40 + ADD + LOADC 1 + LOADCP _INDEXSTRING + CALL + LOADI.S1.X2Y + BSEL + LOADCP _C_A_8_STDLIB + LOADC 2 + LOADCP _ISINTINARRAY + CALL + .LCBRANCHZ _IF_ELSE161_STDLIB + LOAD 80 ; ERROR + LOADC 3 + STOREI + DROP + .LBRANCH _IF_END161_STDLIB +_IF_ELSE161_STDLIB: + ; OLDNAME + LOADREG FP + ; VOLID + LOADREG FP + LOADC 212 + ADD + ; FNAME + LOADREG FP + LOADC 224 + ADD + ; OLDSLOTNO + LOADREG FP + LOADC 216 + ADD + ; OLDDIRS + LOADREG FP + LOADC 84 + ADD + LOAD 80 ; ERROR + LOADCP OPENVOLPATH + CALL + LOAD 80 ; ERROR + LOADI + LOADC 0 + CMP EQ + .LCBRANCHZ _IF_ELSE162_STDLIB + LOAD 212 ; VOLID + ; NEWNAME + LOADREG FP + LOADC 40 + ADD + ; NEWDIRS + LOADREG FP + LOADC 148 + ADD + LOAD 80 ; ERROR + LOADCP FINDFILE + CALL + STORE 220 ; NEWSLOTNO + LOAD 80 ; ERROR + LOADI + LOADC 1 + CMP EQ + .LCBRANCHZ _IF_ELSE163_STDLIB + LOAD 80 ; ERROR + LOADC 0 + STOREI + DROP + ; OLDDIRS + LOADREG FP + LOADC 84 + ADD + ; NEWNAME + LOADREG FP + LOADC 40 + ADD + LOADC 32 + LOADCP _INITSTRINGFROM + CALL + LOAD 212 ; VOLID + LOAD 216 ; OLDSLOTNO + ; OLDDIRS + LOADREG FP + LOADC 84 + ADD + LOAD 80 ; ERROR + LOADCP PUTDIRSLOT + CALL + .LBRANCH _IF_END163_STDLIB +_IF_ELSE163_STDLIB: + LOAD 80 ; ERROR + LOADI + LOADC 0 + CMP EQ + .LCBRANCHZ _IF_ELSE164_STDLIB + LOAD 80 ; ERROR + LOADC 4 + STOREI + DROP +_IF_ELSE164_STDLIB: +_IF_END164_STDLIB: +_IF_END163_STDLIB: +_IF_ELSE162_STDLIB: +_IF_END162_STDLIB: + LOAD 212 ; VOLID + LOADC 0 + CMP GT + .LCBRANCHZ _IF_ELSE165_STDLIB + LOAD 212 ; VOLID + LOADCP CLOSEVOLUMEID + CALL +_IF_ELSE165_STDLIB: +_IF_END165_STDLIB: +_IF_END161_STDLIB: + FPADJ 264 + RET +ERASE: + FPADJ -192 + STORE 76 ; ERROR + ; NAME + LOADREG FP + SWAP + LOADC 68 + LOADCP _INITSTRINGFROM + CALL + ; DIRS + LOADREG FP + LOADC 80 + ADD + LOADC 64 + LOADCP _CLEARMEM + CALL + LOADC 32 + ; FNAME + LOADREG FP + LOADC 152 + ADD + LOADCP _INITSTRINGF + CALL + LOAD 76 ; ERROR + LOADC 0 + STOREI + DROP + ; NAME + LOADREG FP + LOADC 1 + LOADCP _INDEXSTRING + CALL + LOADI.S1.X2Y + BSEL + LOADC 37 + CMP EQ + .LCBRANCHZ _IF_ELSE166_STDLIB + LOAD 76 ; ERROR + LOADC 3 + STOREI + DROP + .LBRANCH _IF_END166_STDLIB +_IF_ELSE166_STDLIB: + ; NAME + LOADREG FP + ; VOLID + LOADREG FP + LOADC 144 + ADD + ; FNAME + LOADREG FP + LOADC 152 + ADD + ; SLOTNO + LOADREG FP + LOADC 148 + ADD + ; DIRS + LOADREG FP + LOADC 80 + ADD + LOAD 76 ; ERROR + LOADCP OPENVOLPATH + CALL + LOAD 76 ; ERROR + LOADI + LOADC 0 + CMP EQ + .LCBRANCHZ _IF_ELSE167_STDLIB + LOADC 6 + LOAD 120 ; DIRS + LOADCP _TESTBIT + CALL + .LCBRANCHZ _IF_ELSE168_STDLIB + LOAD 76 ; ERROR + LOADC 8 + STOREI + DROP + .LBRANCH _IF_END168_STDLIB + .CPOOL +_IF_ELSE168_STDLIB: + LOAD 144 ; VOLID + LOAD 148 ; SLOTNO + ; DIRS + LOADREG FP + LOADC 80 + ADD + LOAD 76 ; ERROR + LOADCP DELETEFILE + CALL +_IF_END168_STDLIB: +_IF_ELSE167_STDLIB: +_IF_END167_STDLIB: + LOAD 144 ; VOLID + LOADC 0 + CMP GT + .LCBRANCHZ _IF_ELSE169_STDLIB + LOAD 144 ; VOLID + LOADCP CLOSEVOLUMEID + CALL +_IF_ELSE169_STDLIB: +_IF_END169_STDLIB: +_IF_END166_STDLIB: + FPADJ 192 + RET +WRITECHANNEL: + FPADJ -8 + STORE 4 ; ACHAR + STORE 0 ; F + LOAD 4 ; ACHAR + LOADCP CONOUT + CALL + FPADJ 8 + RET +WRITECHANNELW: + FPADJ -8 + STORE 4 ; WORD + STORE 0 ; F + LOAD 4 ; WORD + LOADCP CONOUTW + CALL + FPADJ 8 + RET +ECHOCHANNEL: + FPADJ -8 + STORE 4 ; ACHAR + STORE 0 ; F + LOAD 0 ; F + LOADC 36 + ADD + LOADI + LOADC 0 + CMP EQ + .LCBRANCHZ _IF_ELSE170_STDLIB + LOAD 0 ; F + LOADC 40 + ADD + LOADI + .LCBRANCHZ _IF_ELSE171_STDLIB + LOAD 0 ; F + LOAD 4 ; ACHAR + LOADCP WRITECHANNEL + CALL + .LBRANCH _IF_END171_STDLIB +_IF_ELSE171_STDLIB: + LOAD 4 ; ACHAR + LOADC 8 + CMP NE + LOAD 4 ; ACHAR + LOADC 9 + CMP NE + AND + LOAD 4 ; ACHAR + LOADC 4 + CMP NE + AND + .LCBRANCHZ _IF_ELSE172_STDLIB + LOAD 0 ; F + LOAD 4 ; ACHAR + LOADCP WRITECHANNEL + CALL + LOAD 4 ; ACHAR + LOADC 13 + CMP EQ + .LCBRANCHZ _IF_ELSE173_STDLIB + LOAD 0 ; F + LOADC 10 + LOADCP WRITECHANNEL + CALL +_IF_ELSE173_STDLIB: +_IF_END173_STDLIB: +_IF_ELSE172_STDLIB: +_IF_END172_STDLIB: +_IF_END171_STDLIB: +_IF_ELSE170_STDLIB: +_IF_END170_STDLIB: + FPADJ 8 + RET +READCHANNEL: + FPADJ -12 + STORE 0 ; F + LOAD 0 ; F + LOADC 28 + ADD + LOADI + LOADC 0 + CMP GT + .LCBRANCHZ _IF_ELSE174_STDLIB + LOAD 0 ; F + LOADC 24 + ADD + LOADI + STORE 8 ; ACHAR + LOAD 0 ; F + LOADC 28 + ADD + LOADC 0 + STOREI + DROP + .LBRANCH _IF_END174_STDLIB +_IF_ELSE174_STDLIB: + LOADCP CONIN + CALL + STORE 8 ; ACHAR + LOAD 0 ; F + LOAD 8 ; ACHAR + LOADCP ECHOCHANNEL + CALL +_IF_END174_STDLIB: + LOAD 0 ; F + LOADC 32 + ADD + LOAD 8 ; ACHAR + LOADC 4 + CMP EQ + STOREI + DROP + LOAD 0 ; F + LOADC 44 + ADD + LOADI + LOADC 0 + CMP EQ + LOAD 8 ; ACHAR + LOADC 3 + CMP EQ + AND + .LCBRANCHZ _IF_ELSE175_STDLIB + LOAD 0 ; F + LOADC 11 + LOADCP FILEERROR + CALL + LOAD 0 ; F + LOADCP CHECKERROR + CALL +_IF_ELSE175_STDLIB: +_IF_END175_STDLIB: + LOAD 8 ; ACHAR + STORE 4 ; READCHANNEL + LOAD 4 ; READCHANNEL + FPADJ 12 + RET +FREADCHAR: + FPADJ -12 + STORE 0 ; F + LOAD 0 ; F + LOADC 16 + ADD + LOADI + LOADC 0 + CMP EQ + .LCBRANCHZ _IF_ELSE176_STDLIB + LOAD 0 ; F + LOADCP READCHANNEL + CALL + STORE 4 ; FREADCHAR + .LBRANCH _IF_END176_STDLIB +_IF_ELSE176_STDLIB: + LOAD 0 ; F + LOADCP READFSCHAR + CALL + STORE 4 ; FREADCHAR +_IF_END176_STDLIB: + LOAD 0 ; F + INC 12 + LOAD 4 ; FREADCHAR + LOADC 13 + CMP EQ + LOAD 4 ; FREADCHAR + LOADC 10 + CMP EQ + OR + STOREI + DROP + LOAD 4 ; FREADCHAR + FPADJ 12 + RET +FWRITECHAR: + FPADJ -8 + STORE 4 ; F + STORE 0 ; ACHAR + LOAD 4 ; F + LOADC 16 + ADD + LOADI + LOADC 0 + CMP EQ + .LCBRANCHZ _IF_ELSE177_STDLIB + LOAD 4 ; F + LOAD 0 ; ACHAR + LOADCP WRITECHANNEL + CALL + .LBRANCH _IF_END177_STDLIB + .CPOOL +_IF_ELSE177_STDLIB: + LOAD 4 ; F + LOAD 0 ; ACHAR + LOADCP WRITEFSCHAR + CALL +_IF_END177_STDLIB: + FPADJ 8 + RET +FWRITESTRING: + FPADJ -24 + STORE 8 ; W + STORE 4 ; F + STORE 0 ; ASTRING + LOAD 8 ; W + LOAD 0 ; ASTRING + LOADCP LENGTH + CALL + SUB + STORE 16 ; MISSING + LOAD 16 ; MISSING + LOADC 0 + CMP GT + .LCBRANCHZ _IF_ELSE178_STDLIB + LOADC 1 + STORE 20 ; I + LOAD 16 ; MISSING +_FOR_START16_STDLIB: + LOAD 20 ; I + OVER + CMP GT + .LCBRANCH _FOR_END16_STDLIB + LOADC 32 + LOAD 4 ; F + LOADCP FWRITECHAR + CALL + LOAD 20 ; I + INC 1 + STORE 20 ; I + .LBRANCH _FOR_START16_STDLIB +_FOR_END16_STDLIB: + DROP +_IF_ELSE178_STDLIB: +_IF_END178_STDLIB: + LOAD 4 ; F + LOADC 16 + ADD + LOADI + LOADC 0 + CMP EQ + .LCBRANCHZ _IF_ELSE179_STDLIB + LOAD 0 ; ASTRING + DUP + LOADI + SWAP + INC 8 +_FOR_START17_STDLIB: + OVER + .LCBRANCHZ _FOR_END17_STDLIB + DUP + LOADI.S1.X2Y + BSEL + STORE 12 ; CH + LOAD 4 ; F + LOAD 12 ; CH + LOADCP WRITECHANNEL + CALL + INC 1 + SWAP + DEC 1 + SWAP + .LBRANCH _FOR_START17_STDLIB +_FOR_END17_STDLIB: + DROP + DROP + .LBRANCH _IF_END179_STDLIB +_IF_ELSE179_STDLIB: + LOAD 4 ; F + LOAD 0 ; ASTRING + LOADCP WRITEFSSTRING + CALL +_IF_END179_STDLIB: + FPADJ 24 + RET +FWRITEINT: + FPADJ -32 + STORE 8 ; W + STORE 4 ; F + STORE 0 ; V + LOADC 12 + ; RBUF + LOADREG FP + INC 12 + LOADCP _INITSTRINGF + CALL + LOAD 0 ; V + LOADC 0 + ; RBUF + LOADREG FP + INC 12 + LOADCP INTSTR + CALL + ; RBUF + LOADREG FP + INC 12 + LOAD 4 ; F + LOAD 8 ; W + LOADCP FWRITESTRING + CALL + FPADJ 32 + RET +FWRITEREAL: + FPADJ -72 + STORE 12 ; D + STORE 8 ; W + STORE 4 ; F + STORE 0 ; V + LOADC 48 + ; RBUF + LOADREG FP + LOADC 16 + ADD + LOADCP _INITSTRINGF + CALL + LOAD 0 ; V + LOAD 8 ; W + LOAD 12 ; D + ; RBUF + LOADREG FP + LOADC 16 + ADD + LOADCP REALSTR + CALL + ; RBUF + LOADREG FP + LOADC 16 + ADD + LOAD 4 ; F + LOAD 8 ; W + LOADCP FWRITESTRING + CALL + FPADJ 72 + RET +FWRITEWORDS: + FPADJ -12 + STORE 8 ; SIZE + STORE 4 ; F + STORE 0 ; WORDS + LOAD 4 ; F + LOADC 16 + ADD + LOADI + LOADC 1 + CMP EQ + .LCBRANCHZ _IF_ELSE180_STDLIB + LOAD 4 ; F + LOAD 0 ; WORDS + LOAD 8 ; SIZE + LOADCP WRITEFS + CALL + .LBRANCH _IF_END180_STDLIB +_IF_ELSE180_STDLIB: + LOAD 4 ; F + LOAD 0 ; WORDS + LOAD 8 ; SIZE + LOADC 2 + LOADCP _SHRM + CALL + LOADCP WRITECHANWORDS + CALL +_IF_END180_STDLIB: + FPADJ 12 + RET +FREADWORDS: + FPADJ -20 + STORE 8 ; SIZE + STORE 4 ; F + STORE 0 ; WORDS + LOAD 4 ; F + LOADC 16 + ADD + LOADI + LOADC 1 + CMP EQ + .LCBRANCHZ _IF_ELSE181_STDLIB + LOAD 4 ; F + LOAD 0 ; WORDS + LOAD 8 ; SIZE + LOADCP READFS + CALL + .LBRANCH _IF_END181_STDLIB +_IF_ELSE181_STDLIB: + LOAD 4 ; F + LOAD 0 ; WORDS + LOAD 8 ; SIZE + LOADC 2 + LOADCP _SHRM + CALL + LOADCP READCHANWORDS + CALL +_IF_END181_STDLIB: + FPADJ 20 + RET +PUSHBACK: + FPADJ -8 + STORE 4 ; ACHAR + STORE 0 ; AFILE + LOAD 0 ; AFILE + LOADC 16 + ADD + LOADI + LOADC 1 + CMP EQ + .LCBRANCHZ _IF_ELSE182_STDLIB + LOAD 0 ; AFILE + LOAD 0 ; AFILE + LOADC 28 + ADD + LOADI + LOADC 1 + SUB + LOADCP SEEK + CALL + .LBRANCH _IF_END182_STDLIB + .CPOOL +_IF_ELSE182_STDLIB: + LOAD 0 ; AFILE + LOADC 24 + ADD + LOAD 4 ; ACHAR + STOREI + DROP + LOAD 0 ; AFILE + LOADC 28 + ADD + LOADC 1 + STOREI + DROP +_IF_END182_STDLIB: + FPADJ 8 + RET +OPENCHANNEL: + FPADJ -52 + STORE 48 ; ERROR + STORE 44 ; MODE + STORE 40 ; F + ; NAME + LOADREG FP + SWAP + LOADC 32 + LOADCP _INITSTRINGFROM + CALL + LOAD 40 ; F + LOADC 16 + ADD + LOADC 0 + STOREI + DROP + LOAD 40 ; F + LOAD 44 ; MODE + STOREI + DROP + LOAD 40 ; F + LOADC 28 + ADD + LOADC 0 + STOREI + DROP + LOAD 40 ; F + LOADC 32 + ADD + LOADC 0 + STOREI + DROP + LOAD 40 ; F + LOADC 36 + ADD + LOADC 0 + STOREI + DROP + LOAD 40 ; F + LOADC 40 + ADD + LOADC 0 + STOREI + DROP + LOAD 40 ; F + LOADC 44 + ADD + LOADC 0 + STOREI + DROP + ; NAME + LOADREG FP + LOADCP _C_S_10_STDLIB + LOADCP _CMPSTRING + CALL + .LCBRANCHZ _IF_ELSE183_STDLIB + LOAD 40 ; F + LOADC 20 + ADD + LOADC 0 + STOREI + DROP + .LBRANCH _IF_END183_STDLIB +_IF_ELSE183_STDLIB: + ; NAME + LOADREG FP + LOADCP _C_S_11_STDLIB + LOADCP _CMPSTRING + CALL + .LCBRANCHZ _IF_ELSE184_STDLIB + LOAD 40 ; F + LOADC 20 + ADD + LOADC 0 + STOREI + DROP + LOAD 40 ; F + LOADC 36 + ADD + LOADC 1 + STOREI + DROP + LOAD 40 ; F + LOADC 40 + ADD + LOADC 1 + STOREI + DROP + .LBRANCH _IF_END184_STDLIB +_IF_ELSE184_STDLIB: + ; NAME + LOADREG FP + LOADCP _C_S_12_STDLIB + LOADCP _CMPSTRING + CALL + .LCBRANCHZ _IF_ELSE185_STDLIB + LOAD 40 ; F + LOADC 20 + ADD + LOADC 0 + STOREI + DROP + LOAD 40 ; F + LOADC 36 + ADD + LOADC 1 + STOREI + DROP + LOAD 40 ; F + LOADC 40 + ADD + LOADC 1 + STOREI + DROP + LOAD 40 ; F + LOADC 44 + ADD + LOADC 1 + STOREI + DROP + .LBRANCH _IF_END185_STDLIB +_IF_ELSE185_STDLIB: + LOAD 48 ; ERROR + LOADC 1 + STOREI + DROP +_IF_END185_STDLIB: +_IF_END184_STDLIB: +_IF_END183_STDLIB: + FPADJ 52 + RET +OPEN: + FPADJ -212 + STORE 80 ; MODE + ; NAME + LOADREG FP + INC 4 + SWAP + LOADC 68 + LOADCP _INITSTRINGFROM + CALL + STORE 0 ; F + ; DIRS + LOADREG FP + LOADC 88 + ADD + LOADC 64 + LOADCP _CLEARMEM + CALL + LOADC 32 + ; FNAME + LOADREG FP + LOADC 172 + ADD + LOADCP _INITSTRINGF + CALL + ; NAME + LOADREG FP + INC 4 + LOADC 1 + LOADCP _INDEXSTRING + CALL + LOADI.S1.X2Y + BSEL + LOADC 37 + CMP EQ + .LCBRANCHZ _IF_ELSE186_STDLIB + ; NAME + LOADREG FP + INC 4 + LOAD 0 ; F + LOAD 80 ; MODE + ; ERROR + LOADREG FP + LOADC 84 + ADD + LOADCP OPENCHANNEL + CALL + .LBRANCH _IF_END186_STDLIB +_IF_ELSE186_STDLIB: + LOADC 0 + STORE 156 ; VOLID + LOAD 80 ; MODE + LOADC 1 + CMP EQ + STORE 160 ; EXCLUSIVE + LOAD 80 ; MODE + LOADC 3 + CMP EQ + STORE 164 ; OVERWRITE + LOAD 80 ; MODE + LOADC 1 + CMP EQ + LOAD 80 ; MODE + LOADC 3 + CMP EQ + OR + LOAD 80 ; MODE + LOADC 4 + CMP EQ + OR + STORE 168 ; CREATEMISSING + ; NAME + LOADREG FP + INC 4 + ; VOLID + LOADREG FP + LOADC 156 + ADD + ; FNAME + LOADREG FP + LOADC 172 + ADD + ; SLOTNO + LOADREG FP + LOADC 152 + ADD + ; DIRS + LOADREG FP + LOADC 88 + ADD + ; ERROR + LOADREG FP + LOADC 84 + ADD + LOADCP OPENVOLPATH + CALL + LOAD 84 ; ERROR + LOADC 0 + CMP EQ + LOAD 160 ; EXCLUSIVE + AND + .LCBRANCHZ _IF_ELSE187_STDLIB + LOAD 0 ; F + LOADC 4 + LOADCP FILEERROR + CALL + LOADC 4 + STORE 84 ; ERROR +_IF_ELSE187_STDLIB: +_IF_END187_STDLIB: + LOAD 84 ; ERROR + LOADC 1 + CMP EQ + LOAD 168 ; CREATEMISSING + AND + LOAD 84 ; ERROR + LOADC 0 + CMP EQ + LOAD 164 ; OVERWRITE + AND + OR + .LCBRANCHZ _IF_ELSE188_STDLIB + LOAD 156 ; VOLID + ; FNAME + LOADREG FP + LOADC 172 + ADD + LOAD 164 ; OVERWRITE + ; SLOTNO + LOADREG FP + LOADC 152 + ADD + ; DIRS + LOADREG FP + LOADC 88 + ADD + ; ERROR + LOADREG FP + LOADC 84 + ADD + LOADCP CREATEFILE + CALL +_IF_ELSE188_STDLIB: +_IF_END188_STDLIB: + LOAD 84 ; ERROR + LOADC 0 + CMP EQ + .LCBRANCHZ _IF_ELSE189_STDLIB + LOAD 156 ; VOLID + LOAD 152 ; SLOTNO + ; DIRS + LOADREG FP + LOADC 88 + ADD + LOAD 0 ; F + LOAD 80 ; MODE + LOADCP OPENFILE + CALL + LOAD 80 ; MODE + LOADC 4 + CMP EQ + .LCBRANCHZ _IF_ELSE190_STDLIB + LOAD 0 ; F + LOAD 0 ; F + LOADC 36 + ADD + LOADI + LOADCP SEEK + CALL +_IF_ELSE190_STDLIB: +_IF_END190_STDLIB: +_IF_ELSE189_STDLIB: +_IF_END189_STDLIB: + LOAD 84 ; ERROR + LOADC 0 + CMP NE + LOAD 156 ; VOLID + LOADC 0 + CMP GT + AND + .LCBRANCHZ _IF_ELSE191_STDLIB + LOAD 156 ; VOLID + LOADCP CLOSEVOLUMEID + CALL +_IF_ELSE191_STDLIB: +_IF_END191_STDLIB: + LOAD 84 ; ERROR + LOADC 0 + CMP NE + .LCBRANCHZ _IF_ELSE192_STDLIB + LOAD 0 ; F + LOAD 84 ; ERROR + LOADCP FILEERROR + CALL +_IF_ELSE192_STDLIB: +_IF_END192_STDLIB: +_IF_END186_STDLIB: + FPADJ 212 + RET + .CPOOL +NOECHO: + FPADJ -12 + STORE 8 ; OLD + STORE 4 ; NOECHO + STORE 0 ; F + LOAD 0 ; F + LOADC 16 + ADD + LOADI + LOADC 0 + CMP NE + .LCBRANCHZ _IF_ELSE193_STDLIB + LOAD 0 ; F + LOADC 9 + LOADCP FILEERROR + CALL + .LBRANCH _IF_END193_STDLIB +_IF_ELSE193_STDLIB: + LOAD 8 ; OLD + LOAD 0 ; F + LOADC 36 + ADD + LOADI + STOREI + DROP + LOAD 0 ; F + LOADC 36 + ADD + LOAD 4 ; NOECHO + STOREI + DROP +_IF_END193_STDLIB: + FPADJ 12 + RET +RANDOM: + FPADJ -8 + LOADCP RANDOM_STATE ; RANDOM_STATE + LOADI + STORE 4 ; X + LOAD 4 ; X + LOAD 4 ; X + LOADC 13 + LOADCP _SHLM + CALL + XOR + STORE 4 ; X + LOAD 4 ; X + LOAD 4 ; X + LOADC 17 + LOADCP _SHRM + CALL + XOR + STORE 4 ; X + LOAD 4 ; X + LOAD 4 ; X + LOADC 5 + LOADCP _SHLM + CALL + XOR + STORE 4 ; X + LOADCP RANDOM_STATE ; RANDOM_STATE + LOAD 4 ; X + STOREI + DROP + LOAD 4 ; X + LOADC 0 + CMP LT + .LCBRANCHZ _IF_ELSE194_STDLIB + LOAD 4 ; X + LOADCP ABS + CALL + STORE 4 ; X +_IF_ELSE194_STDLIB: +_IF_END194_STDLIB: + LOAD 4 ; X + STORE 0 ; RANDOM + LOAD 0 ; RANDOM + FPADJ 8 + RET +RANDOMIZE: + LOADCP RANDOM_STATE ; RANDOM_STATE + LOADCP GETTICKS + CALL + LOADCP -1342256386 + XOR + STOREI + DROP + RET +CLRSCR: + LOADC 27 + LOADCP OUTPUT + DUP + LOADCP CHECKERROR + CALL + SWAP + OVER + LOADCP FWRITECHAR + CALL + LOADCP _C_S_13_STDLIB + OVER + LOADC 0 + LOADCP FWRITESTRING + CALL + DROP + LOADC 27 + LOADCP OUTPUT + DUP + LOADCP CHECKERROR + CALL + SWAP + OVER + LOADCP FWRITECHAR + CALL + LOADCP _C_S_14_STDLIB + OVER + LOADC 0 + LOADCP FWRITESTRING + CALL + DROP + RET +CLREOL: + LOADC 27 + LOADCP OUTPUT + DUP + LOADCP CHECKERROR + CALL + SWAP + OVER + LOADCP FWRITECHAR + CALL + LOADCP _C_S_15_STDLIB + OVER + LOADC 0 + LOADCP FWRITESTRING + CALL + DROP + RET +CRTINIT: + LOADC 27 + LOADCP OUTPUT + DUP + LOADCP CHECKERROR + CALL + SWAP + OVER + LOADCP FWRITECHAR + CALL + LOADC 99 + OVER + LOADCP FWRITECHAR + CALL + DROP + RET +GOTOXY: + FPADJ -8 + STORE 4 ; Y + STORE 0 ; X + LOADC 27 + LOADCP OUTPUT + DUP + LOADCP CHECKERROR + CALL + SWAP + OVER + LOADCP FWRITECHAR + CALL + LOADC 91 + OVER + LOADCP FWRITECHAR + CALL + LOAD 4 ; Y + OVER + LOADC 0 + LOADCP FWRITEINT + CALL + LOADC 59 + OVER + LOADCP FWRITECHAR + CALL + LOAD 0 ; X + OVER + LOADC 0 + LOADCP FWRITEINT + CALL + LOADC 72 + OVER + LOADCP FWRITECHAR + CALL + DROP + FPADJ 8 + RET +INSLINE: + LOADC 27 + LOADCP OUTPUT + DUP + LOADCP CHECKERROR + CALL + SWAP + OVER + LOADCP FWRITECHAR + CALL + LOADCP _C_S_16_STDLIB + OVER + LOADC 0 + LOADCP FWRITESTRING + CALL + DROP + RET +DELLINE: + LOADC 27 + LOADCP OUTPUT + DUP + LOADCP CHECKERROR + CALL + SWAP + OVER + LOADCP FWRITECHAR + CALL + LOADCP _C_S_17_STDLIB + OVER + LOADC 0 + LOADCP FWRITESTRING + CALL + DROP + RET +GETTERMSIZE: + FPADJ -16 + STORE 4 ; MAXY + STORE 0 ; MAXX + ; X + LOADREG FP + INC 8 + ; Y + LOADREG FP + INC 12 + LOADCP GETCURSORPOS + CALL + LOADCP 9999 + LOADCP 9999 + LOADCP GOTOXY + CALL + LOAD 0 ; MAXX + LOAD 4 ; MAXY + LOADCP GETCURSORPOS + CALL + LOAD 8 ; X + LOAD 12 ; Y + LOADCP GOTOXY + CALL + FPADJ 16 + RET + .CPOOL +TEXTCOLOR: + FPADJ -4 + STORE 0 ; COL + LOADC 27 + LOADCP OUTPUT + DUP + LOADCP CHECKERROR + CALL + SWAP + OVER + LOADCP FWRITECHAR + CALL + LOADCP _C_S_18_STDLIB + OVER + LOADC 0 + LOADCP FWRITESTRING + CALL + LOAD 0 ; COL + OVER + LOADC 0 + LOADCP FWRITEINT + CALL + LOADC 109 + OVER + LOADCP FWRITECHAR + CALL + DROP + FPADJ 4 + RET +TEXTBACKGROUND: + FPADJ -4 + STORE 0 ; BGCOL + LOADC 27 + LOADCP OUTPUT + DUP + LOADCP CHECKERROR + CALL + SWAP + OVER + LOADCP FWRITECHAR + CALL + LOADCP _C_S_19_STDLIB + OVER + LOADC 0 + LOADCP FWRITESTRING + CALL + LOAD 0 ; BGCOL + OVER + LOADC 0 + LOADCP FWRITEINT + CALL + LOADC 109 + OVER + LOADCP FWRITECHAR + CALL + DROP + FPADJ 4 + RET +TEXTDEFAULT: + LOADC 27 + LOADCP OUTPUT + DUP + LOADCP CHECKERROR + CALL + SWAP + OVER + LOADCP FWRITECHAR + CALL + LOADCP _C_S_20_STDLIB + OVER + LOADC 0 + LOADCP FWRITESTRING + CALL + DROP + RET +PEXEC: + FPADJ -216 + STORE 84 ; ERROR + STORE 80 ; ARGCOUNT + STORE 76 ; ARGS + ; PRGFILE + LOADREG FP + SWAP + LOADC 68 + LOADCP _INITSTRINGFROM + CALL + LOADC 32 + ; FNAME + LOADREG FP + LOADC 92 + ADD + LOADCP _INITSTRINGF + CALL + ; DIRSLOT + LOADREG FP + LOADC 132 + ADD + LOADC 64 + LOADCP _CLEARMEM + CALL + LOAD 80 ; ARGCOUNT + LOADC 7 + CMP GE + LOAD 80 ; ARGCOUNT + LOADC 0 + CMP LT + OR + .LCBRANCHZ _IF_ELSE195_STDLIB + LOAD 84 ; ERROR + LOADC 9 + STOREI + DROP + .LBRANCH _IF_END195_STDLIB +_IF_ELSE195_STDLIB: + ; PRGFILE + LOADREG FP + ; VOLID + LOADREG FP + LOADC 88 + ADD + ; FNAME + LOADREG FP + LOADC 92 + ADD + ; SLOTNO + LOADREG FP + LOADC 196 + ADD + ; DIRSLOT + LOADREG FP + LOADC 132 + ADD + LOAD 84 ; ERROR + LOADCP OPENVOLPATH + CALL + LOAD 84 ; ERROR + LOADI + LOADC 0 + CMP EQ + .LCBRANCHZ _IF_ELSE196_STDLIB + LOADCP VOLUMETABLE ; VOLUMETABLE + LOAD 88 ; VOLID + DEC 1 + DUP + LOADC 32 + LOADCP _BOUNDSCHECK + CALL + LOADC 96 + LOADCP _MULU + CALL + ADD + LOADREG FP + DEC 4 + SWAP + STOREI + DROP + LOADREG FP + DEC 4 + LOADI + LOADC 64 + ADD + LOADI + STORE 212 ; DEVID + LOAD 196 ; SLOTNO + LOADREG FP + DEC 4 + LOADI + LOADC 52 + ADD + LOADI + FPADJ -4 + LOADCP _MUL + CALL + FPADJ 4 + LOADC 512 + FPADJ -4 + LOADCP _DIV + CALL + FPADJ 4 + STORE 204 ; STARTBLOCK + LOAD 88 ; VOLID + LOAD 204 ; STARTBLOCK + LOADCP GETPHYSBLOCKNO + CALL + STORE 208 ; PHYSBLOCK + LOAD 88 ; VOLID + LOADCP CLOSEVOLUMEID + CALL + LOADCP PARGS ; PARGS + LOADC 0 + DUP + LOADC 8 + LOADCP _BOUNDSCHECK + CALL + LOADC 88 + LOADCP _MULU + CALL + ADD + ; PRGFILE + LOADREG FP + LOADC 80 + LOADCP _INITSTRINGFROM + CALL + LOADC 1 + STORE 200 ; I + LOAD 80 ; ARGCOUNT +_FOR_START18_STDLIB: + LOAD 200 ; I + OVER + CMP GT + .LCBRANCH _FOR_END18_STDLIB + LOADCP PARGS ; PARGS + LOAD 200 ; I + DUP + LOADC 8 + LOADCP _BOUNDSCHECK + CALL + LOADC 88 + LOADCP _MULU + CALL + ADD + LOAD 76 ; ARGS + LOAD 200 ; I + LOADC 1 + SUB + DUP + LOADC 8 + LOADCP _BOUNDSCHECK + CALL + LOADC 88 + LOADCP _MULU + CALL + ADD + LOADC 80 + LOADCP _INITSTRINGFROM + CALL + LOAD 200 ; I + INC 1 + STORE 200 ; I + .LBRANCH _FOR_START18_STDLIB + .CPOOL +_FOR_END18_STDLIB: + DROP + LOAD 80 ; ARGCOUNT + LOADC 1 + ADD + STORE 200 ; I + LOADC 7 +_FOR_START19_STDLIB: + LOAD 200 ; I + OVER + CMP GT + .LCBRANCH _FOR_END19_STDLIB + LOADCP PARGS ; PARGS + LOAD 200 ; I + DUP + LOADC 8 + LOADCP _BOUNDSCHECK + CALL + LOADC 88 + LOADCP _MULU + CALL + ADD + LOADCP _C_S_3_STDLIB + LOADC 80 + LOADCP _INITSTRINGFROM + CALL + LOAD 200 ; I + INC 1 + STORE 200 ; I + .LBRANCH _FOR_START19_STDLIB +_FOR_END19_STDLIB: + DROP + LOADCP PARGCOUNT ; PARGCOUNT + LOAD 80 ; ARGCOUNT + STOREI + DROP + LOAD 212 ; DEVID + LOAD 208 ; PHYSBLOCK + LOAD 176 ; DIRSLOT + LOADCP CORELOAD + CALL +_IF_ELSE196_STDLIB: +_IF_END196_STDLIB: +_IF_END195_STDLIB: + FPADJ 216 + RET +PEXEC2: + LOADREG FP + LOADC 872 + SUB + STOREREG FP + STORE 164 ; ERROR + ; ARG1 + LOADREG FP + LOADC 76 + ADD + SWAP + LOADC 80 + LOADCP _INITSTRINGFROM + CALL + ; PRGFILE + LOADREG FP + SWAP + LOADC 68 + LOADCP _INITSTRINGFROM + CALL + ; ARGS + LOADREG FP + LOADC 168 + ADD + LOADC 704 + LOADCP _CLEARMEM + CALL + ; ARGS + LOADREG FP + LOADC 168 + ADD + LOADC 0 + DUP + LOADC 8 + LOADCP _BOUNDSCHECK + CALL + LOADC 88 + LOADCP _MULU + CALL + ADD + ; ARG1 + LOADREG FP + LOADC 76 + ADD + LOADC 80 + LOADCP _INITSTRINGFROM + CALL + ; PRGFILE + LOADREG FP + ; ARGS + LOADREG FP + LOADC 168 + ADD + LOADC 1 + LOAD 164 ; ERROR + LOADCP PEXEC + CALL + LOADREG FP + LOADC 872 + ADD + STOREREG FP + RET +PEXEC3: + LOADREG FP + LOADC 960 + SUB + STOREREG FP + STORE 252 ; ERROR + ; ARG2 + LOADREG FP + LOADC 164 + ADD + SWAP + LOADC 80 + LOADCP _INITSTRINGFROM + CALL + ; ARG1 + LOADREG FP + LOADC 76 + ADD + SWAP + LOADC 80 + LOADCP _INITSTRINGFROM + CALL + ; PRGFILE + LOADREG FP + SWAP + LOADC 68 + LOADCP _INITSTRINGFROM + CALL + ; ARGS + LOADREG FP + LOADC 256 + ADD + LOADC 704 + LOADCP _CLEARMEM + CALL + ; ARGS + LOADREG FP + LOADC 256 + ADD + LOADC 0 + DUP + LOADC 8 + LOADCP _BOUNDSCHECK + CALL + LOADC 88 + LOADCP _MULU + CALL + ADD + ; ARG1 + LOADREG FP + LOADC 76 + ADD + LOADC 80 + LOADCP _INITSTRINGFROM + CALL + ; ARGS + LOADREG FP + LOADC 256 + ADD + LOADC 1 + DUP + LOADC 8 + LOADCP _BOUNDSCHECK + CALL + LOADC 88 + LOADCP _MULU + CALL + ADD + ; ARG2 + LOADREG FP + LOADC 164 + ADD + LOADC 80 + LOADCP _INITSTRINGFROM + CALL + ; PRGFILE + LOADREG FP + ; ARGS + LOADREG FP + LOADC 256 + ADD + LOADC 2 + LOAD 252 ; ERROR + LOADCP PEXEC + CALL + LOADREG FP + LOADC 960 + ADD + STOREREG FP + RET +PARAMSTR: + FPADJ -8 + STORE 4 ; PARAMSTR + STORE 0 ; I + LOAD 0 ; I + LOADC 0 + CMP LT + LOAD 0 ; I + LOADC 7 + CMP GT + OR + .LCBRANCHZ _IF_ELSE197_STDLIB + LOAD 4 ; PARAMSTR + LOADCP _C_S_3_STDLIB + LOADCP _COPYSTRING + CALL + .LBRANCH _IF_END197_STDLIB +_IF_ELSE197_STDLIB: + LOAD 4 ; PARAMSTR + LOADCP PARGS ; PARGS + LOAD 0 ; I + DUP + LOADC 8 + LOADCP _BOUNDSCHECK + CALL + LOADC 88 + LOADCP _MULU + CALL + ADD + LOADCP _COPYSTRING + CALL +_IF_END197_STDLIB: + LOAD 4 ; PARAMSTR + FPADJ 8 + RET +PARAMCOUNT: + FPADJ -4 + LOADCP PARGCOUNT ; PARGCOUNT + LOADI + STORE 0 ; PARAMCOUNT + LOAD 0 ; PARAMCOUNT + FPADJ 4 + RET +SETSHELLCMD: + FPADJ -52 + STORE 48 ; ARG + ; CMD + LOADREG FP + SWAP + LOADC 40 + LOADCP _INITSTRINGFROM + CALL + LOADCP SHELLCMD ; SHELLCMD + ; CMD + LOADREG FP + LOADCP _COPYSTRING + CALL + LOADCP SHELLARG ; SHELLARG + LOAD 48 ; ARG + STOREI + DROP + FPADJ 52 + RET + .CPOOL +DELAY: + FPADJ -8 + STORE 0 ; MS + LOAD 0 ; MS + STORE 4 ; COUNT +_WHILE_START14_STDLIB: + LOAD 4 ; COUNT + LOADC 0 + CMP GT + .LCBRANCHZ _WHILE_END14_STDLIB + LOADCP WAIT1MSEC + CALL + LOAD 4 ; COUNT + LOADC 1 + SUB + STORE 4 ; COUNT + .LBRANCH _WHILE_START14_STDLIB +_WHILE_END14_STDLIB: + FPADJ 8 + RET + .CPOOL +INPUT: .BLOCK 18 +OUTPUT: .BLOCK 18 +DEFAULTVOLUMEID: .WORD 0 +VOLUMETABLE: .BLOCK 768 +VOLUMECOUNT: .WORD 0 +DEVICESINITIALIZED: .WORD 0 +RANDOM_STATE: .WORD 0 +_C_S_0_STDLIB: + .WORD 1,0 + .BYTE "0" +_C_S_1_STDLIB: + .WORD 1,0 + .BYTE ":" +_C_S_2_STDLIB: + .WORD 1,0 + .BYTE "-" +_C_S_3_STDLIB: + .WORD 0,0 +_C_S_4_STDLIB: + .WORD 10,0 + .BYTE "8463847412" +_C_S_5_STDLIB: + .WORD 1,0 + .BYTE " " +_C_S_6_STDLIB: + .WORD 1,0 + .BYTE "E" +_C_S_7_STDLIB: + .WORD 2,0 + .BYTE "0." +_C_S_8_STDLIB: + .WORD 30,0 + .BYTE "Error reading partition block " +_C_S_9_STDLIB: + .WORD 18,0 + .BYTE "Invalid error code" +_C_S_10_STDLIB: + .WORD 4,0 + .BYTE "%CON" +_C_S_11_STDLIB: + .WORD 4,0 + .BYTE "%KBD" +_C_S_12_STDLIB: + .WORD 4,0 + .BYTE "%RAW" +_C_S_13_STDLIB: + .WORD 3,0 + .BYTE "[2J" +_C_S_14_STDLIB: + .WORD 2,0 + .BYTE "[H" +_C_S_15_STDLIB: + .WORD 2,0 + .BYTE "[K" +_C_S_16_STDLIB: + .WORD 2,0 + .BYTE "[L" +_C_S_17_STDLIB: + .WORD 2,0 + .BYTE "[M" +_C_S_18_STDLIB: + .WORD 6,0 + .BYTE "[38;5;" +_C_S_19_STDLIB: + .WORD 6,0 + .BYTE "[48;5;" +_C_S_20_STDLIB: + .WORD 3,0 + .BYTE "[0m" +IOERRORDESC: +_C_A_1_STDLIB: + + .WORD 8,20 + .BYTE "No error" + .BLOCK 3 + + .WORD 14,20 + .BYTE "File not found" + .BLOCK 1 + + .WORD 16,20 + .BYTE "Volume not found" + .BLOCK 1 + + .WORD 12,20 + .BYTE "Path invalid" + .BLOCK 2 + + .WORD 19,20 + .BYTE "File already exists" + + .WORD 11,20 + .BYTE "File closed" + .BLOCK 2 + + .WORD 12,20 + .BYTE "Seek invalid" + .BLOCK 2 + + .WORD 8,20 + .BYTE "No space" + .BLOCK 3 + + .WORD 16,20 + .BYTE "File is readonly" + .BLOCK 1 + + .WORD 17,20 + .BYTE "Invalid operation" + + .WORD 14,20 + .BYTE "Invalid format" + .BLOCK 1 + + .WORD 19,20 + .BYTE "Interrupted by user" + +MATHERROR: +_C_A_2_STDLIB: + + .WORD 37,38 + .BYTE "Invalid argument to sqrt/ln/tan/cotan" + +PEXECERROR: +_C_A_3_STDLIB: + + .WORD 27,28 + .BYTE "Invalid arguments for PExec" + +DATETIMEMTAB: +_C_A_4_STDLIB: + + .WORD 31,28,31,30,31,30,31,31 + .WORD 30,31,30,31,31,29,31,30 + .WORD 31,30,31,31,30,31,30,31 +_C_A_5_STDLIB: + + .WORD 32,9,13,10 +_C_A_6_STDLIB: + + .WORD 10,13,32,9 +_C_A_7_STDLIB: + + .WORD 43,45,46,69,101 +_C_A_8_STDLIB: + + .WORD 35,37 diff --git a/rtl/arty-a7/mig_dram_0/mig_dram_0.xci b/rtl/arty-a7/mig_dram_0/mig_dram_0.xci index 3da3694..9027805 100644 --- a/rtl/arty-a7/mig_dram_0/mig_dram_0.xci +++ b/rtl/arty-a7/mig_dram_0/mig_dram_0.xci @@ -1,2876 +1,1572 @@ - - - xilinx.com - xci - unknown - 1.0 - - - mig_dram_0 - - - 0 - 0 - - 0 - 0 - TDM - 8 - false - 11 - 11 - true - - true - 8 - - COMPONENTS - ROW_COLUMN_BANK - Single - 1250 - 0 - TDM - 8 - false - 11 - 11 - true - - true - 8 - - COMPONENTS - ROW_COLUMN_BANK - Single - 1250 - 0 - 0 - - - - 0 - 0 - - - - 0 - 0 - - - - 0 - 0 - - - - 0 - 0 - - - - 0 - 0 - 0 - 0 - 0 - 0 - false - 100000000 - - - - 100000000 - 0 - 0 - 0.000 - 0 - - 0 - 0 - TDM - 8 - false - 11 - 11 - true - - true - 8 - - COMPONENTS - ROW_COLUMN_BANK - Single - 1250 - 0 - TDM - 8 - false - 11 - 11 - true - - true - 8 - - COMPONENTS - ROW_COLUMN_BANK - Single - 1250 - 0 - 0 - - - - 0 - 0 - - - - 0 - 0 - - - - 0 - 0 - - - - 0 - 0 - - - - 0 - 0 - 0 - 0 - 0 - 0 - false - 100000000 - - - - 100000000 - 0 - 0 - 0.000 - 0 - - 0 - 0 - TDM - 8 - false - 11 - 11 - true - - true - 8 - - COMPONENTS - ROW_COLUMN_BANK - Single - 1250 - 0 - TDM - 8 - false - 11 - 11 - true - - true - 8 - - COMPONENTS - ROW_COLUMN_BANK - Single - 1250 - 0 - 0 - - - - 0 - 0 - - - - 0 - 0 - - - - 0 - 0 - - - - 0 - 0 - - - - 0 - 0 - 0 - 0 - 0 - 0 - false - 100000000 - - - - 100000000 - 0 - 0 - 0.000 - 0 - - 0 - 0 - TDM - 8 - false - 11 - 11 - true - - true - 8 - - COMPONENTS - ROW_COLUMN_BANK - Single - 1250 - 0 - TDM - 8 - false - 11 - 11 - true - - true - 8 - - COMPONENTS - ROW_COLUMN_BANK - Single - 1250 - 0 - 0 - - - - 0 - 0 - - - - 0 - 0 - - - - 0 - 0 - - - - 0 - 0 - - - - 0 - 0 - 0 - 0 - 0 - 0 - false - 100000000 - - - - 100000000 - 0 - 0 - 0.000 - 0 - - 0 - 0 - TDM - 8 - false - 11 - 11 - true - - true - 8 - - COMPONENTS - ROW_COLUMN_BANK - Single - 1250 - 0 - TDM - 8 - false - 11 - 11 - true - - true - 8 - - COMPONENTS - ROW_COLUMN_BANK - Single - 1250 - 0 - 0 - - - - 0 - 0 - - - - 0 - 0 - - - - 0 - 0 - - - - 0 - 0 - - - - 0 - 0 - 0 - 0 - 0 - 0 - false - 100000000 - - - - 100000000 - 0 - 0 - 0.000 - 0 - - 0 - 0 - TDM - 8 - false - 11 - 11 - true - - true - 8 - - COMPONENTS - ROW_COLUMN_BANK - Single - 1250 - 0 - TDM - 8 - false - 11 - 11 - true - - true - 8 - - COMPONENTS - ROW_COLUMN_BANK - Single - 1250 - 0 - 0 - - - - 0 - 0 - - - - 0 - 0 - - - - 0 - 0 - - - - 0 - 0 - - - - 0 - 0 - 0 - 0 - 0 - 0 - false - 100000000 - - - - 100000000 - 0 - 0 - 0.000 - 0 - - 0 - 0 - TDM - 8 - false - 11 - 11 - true - - true - 8 - - COMPONENTS - ROW_COLUMN_BANK - Single - 1250 - 0 - TDM - 8 - false - 11 - 11 - true - - true - 8 - - COMPONENTS - ROW_COLUMN_BANK - Single - 1250 - 0 - 0 - - - - 0 - 0 - - - - 0 - 0 - - - - 0 - 0 - - - - 0 - 0 - - - - 0 - 0 - 0 - 0 - 0 - 0 - false - 100000000 - - - - 100000000 - 0 - 0 - 0.000 - 0 - - 0 - 0 - TDM - 8 - false - 11 - 11 - true - - true - 8 - - COMPONENTS - ROW_COLUMN_BANK - Single - 1250 - 0 - TDM - 8 - false - 11 - 11 - true - - true - 8 - - COMPONENTS - ROW_COLUMN_BANK - Single - 1250 - 0 - 0 - - - - 0 - 0 - - - - 0 - 0 - - - - 0 - 0 - - - - 0 - 0 - - - - 0 - 0 - 0 - 0 - 0 - 0 - false - 100000000 - - - - 100000000 - 0 - 0 - 0.000 - false - 100000000 - - - - 100000000 - 0 - 0 - 0.000 - - 0 - 0 - TDM - 8 - false - 11 - 11 - true - - true - 8 - - COMPONENTS - ROW_COLUMN_BANK - Single - 1250 - 0 - TDM - 8 - false - 11 - 11 - true - - true - 8 - - COMPONENTS - ROW_COLUMN_BANK - Single - 1250 - 0 - 0 - - - - 0 - 0 - - - - 0 - 0 - - - - 0 - 0 - - - - 0 - 0 - - - - 0 - 0 - 0 - 0 - 0 - 0 - 1 - 0 - 0 - 0 - - 1 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 1 - 1 - 1 - 1 - 1 - 0.000 - AXI4LITE - READ_WRITE - 0 - 0 - 0 - 0 - 0 - 1 - 0 - 0 - 0 - - 1 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 1 - 1 - 1 - 1 - 1 - 0.000 - AXI4LITE - READ_WRITE - 0 - 0 - 0 - 0 - 0 - 1 - 0 - 0 - 0 - - 1 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 1 - 1 - 1 - 1 - 1 - 0.000 - AXI4LITE - READ_WRITE - 0 - 0 - 0 - 0 - 0 - 1 - 0 - 0 - 0 - - 1 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 1 - 1 - 1 - 1 - 1 - 0.000 - AXI4LITE - READ_WRITE - 0 - 0 - 0 - 0 - 0 - 1 - 0 - 0 - 0 - - 1 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 1 - 1 - 1 - 1 - 1 - 0.000 - AXI4LITE - READ_WRITE - 0 - 0 - 0 - 0 - 0 - 1 - 0 - 0 - 0 - - 1 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 1 - 1 - 1 - 1 - 1 - 0.000 - AXI4LITE - READ_WRITE - 0 - 0 - 0 - 0 - 0 - 1 - 0 - 0 - 0 - - 1 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 1 - 1 - 1 - 1 - 1 - 0.000 - AXI4LITE - READ_WRITE - 0 - 0 - 0 - 0 - 0 - 1 - 0 - 0 - 0 - - 1 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 1 - 1 - 1 - 1 - 1 - 0.000 - AXI4LITE - READ_WRITE - 0 - 0 - 0 - 0 - 0 - 1 - 0 - 0 - 0 - - 1 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 1 - 1 - 1 - 1 - 1 - 0.000 - AXI4LITE - READ_WRITE - 0 - 0 - 0 - 0 - 0 - 1 - 0 - 0 - 0 - - 1 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 1 - 1 - 1 - 1 - 1 - 0.000 - AXI4LITE - READ_WRITE - 0 - 0 - 0 - 0 - 0 - 1 - 0 - 0 - 0 - - 1 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 1 - 1 - 1 - 1 - 1 - 0.000 - AXI4LITE - READ_WRITE - 0 - 0 - 0 - 0 - 0 - 1 - 0 - 0 - 0 - - 1 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 1 - 1 - 1 - 1 - 1 - 0.000 - AXI4LITE - READ_WRITE - 0 - 0 - 0 - 0 - 0 - 1 - 0 - 0 - 0 - - 1 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 1 - 1 - 1 - 1 - 1 - 0.000 - AXI4LITE - READ_WRITE - 0 - 0 - 0 - 0 - 0 - 1 - 0 - 0 - 0 - - 1 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 1 - 1 - 1 - 1 - 1 - 0.000 - AXI4LITE - READ_WRITE - 0 - 0 - 0 - 0 - 0 - 1 - 0 - 0 - 0 - - 1 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 1 - 1 - 1 - 1 - 1 - 0.000 - AXI4LITE - READ_WRITE - 0 - 0 - 0 - 0 - 0 - 1 - 0 - 0 - 0 - - 1 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 1 - 1 - 1 - 1 - 1 - 0.000 - AXI4LITE - READ_WRITE - 0 - 0 - 0 - 0 - 0 - 0 - false - 100000000 - - - - 100000000 - 0 - 0 - 0.000 - 1 - 0 - 0 - 0 - - 1 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 1 - 1 - 1 - 1 - 1 - 0.000 - AXI4LITE - READ_WRITE - 0 - 0 - 0 - 0 - 0 - 1 - 0 - 0 - 0 - - 1 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 0 - 1 - 1 - 1 - 1 - 1 - 0.000 - AXI4LITE - READ_WRITE - 0 - 0 - 0 - 0 - 0 - 32 - 32 - 32 - 4 - 1048576 - 32 - 4 - 1048576 - 8 - 3 - 1 - 1 - 1 - 8 - OFF - 1 - 1 - 1 - 8 - 1 - OFF - 14 - 1 - 1 - 1 - 2 - 1 - 8 - 3 - 1 - 1 - 1 - 8 - OFF - 1 - 1 - 1 - 8 - 1 - OFF - 14 - 1 - 1 - 1 - 2 - 1 - 8 - 8 - 2 - OFF - 1 - OFF - 100.0 - FALSE - 8 - 3 - 1 - 1 - 1 - 8 - OFF - 1 - 1 - 1 - 8 - OFF - 14 - 1 - 1 - 1 - 2 - 1 - DDR3 - FALSE - 10.0 - FALSE - 10 - FALSE - 10 - FALSE - 10 - FALSE - 10 - 1200.0 - 0.000 - ACTIVE_LOW - 29 - 1 - 8 - 18 - OFF - 1 - 29 - 2 - 1 - 1 - 18 - OFF - 1 - 1 - 1 - 8 - 1 - 29 - 1 - 29 - 2 - 1 - 1 - 18 - OFF - 1 - 1 - 1 - 8 - 1 - 29 - 1 - 29 - 2 - 1 - 18 - 1 - 1 - DIFF - FALSE - 0 - 32 - 32 - 32 - 4 - 1048576 - 32 - 4 - 1048576 - 8 - 3 - 1 - 1 - 1 - 8 - OFF - 1 - 1 - 1 - 8 - 1 - OFF - 14 - 1 - 1 - 1 - 2 - 1 - 8 - 3 - 1 - 1 - 1 - 8 - OFF - 1 - 1 - 1 - 8 - 1 - OFF - 14 - 1 - 1 - 1 - 2 - 1 - 8 - 8 - 2 - OFF - 1 - OFF - 100.0 - FALSE - 8 - 3 - 1 - 1 - 1 - 8 - OFF - 1 - 1 - 1 - 8 - OFF - 14 - 1 - 1 - 1 - 2 - 1 - DDR3 - FALSE - 10.0 - FALSE - 10 - FALSE - 10 - FALSE - 10 - FALSE - 10 - 1200.0 - 0.000 - ACTIVE_LOW - 29 - 1 - 8 - 18 - OFF - 1 - 29 - 2 - 1 - 1 - 18 - OFF - 1 - 1 - 1 - 8 - 1 - 29 - 1 - 29 - 2 - 1 - 1 - 18 - OFF - 1 - 1 - 1 - 8 - 1 - 29 - 1 - 29 - 2 - 1 - 18 - 1 - 1 - DIFF - FALSE - 0 - 32 - 32 - 32 - 4 - 1048576 - 32 - 4 - 1048576 - 8 - 3 - 1 - 1 - 1 - 8 - OFF - 1 - 1 - 1 - 8 - 1 - OFF - 14 - 1 - 1 - 1 - 2 - 1 - 8 - 3 - 1 - 1 - 1 - 8 - OFF - 1 - 1 - 1 - 8 - 1 - OFF - 14 - 1 - 1 - 1 - 2 - 1 - 8 - 8 - 2 - OFF - 1 - OFF - 100.0 - FALSE - 8 - 3 - 1 - 1 - 1 - 8 - OFF - 1 - 1 - 1 - 8 - OFF - 14 - 1 - 1 - 1 - 2 - 1 - DDR3 - FALSE - 10.0 - FALSE - 10 - FALSE - 10 - FALSE - 10 - FALSE - 10 - 1200.0 - 0.000 - ACTIVE_LOW - 29 - 1 - 8 - 18 - OFF - 1 - 29 - 2 - 1 - 1 - 18 - OFF - 1 - 1 - 1 - 8 - 1 - 29 - 1 - 29 - 2 - 1 - 1 - 18 - OFF - 1 - 1 - 1 - 8 - 1 - 29 - 1 - 29 - 2 - 1 - 18 - 1 - 1 - DIFF - FALSE - 0 - 32 - 32 - 32 - 4 - 1048576 - 32 - 4 - 1048576 - 8 - 3 - 1 - 1 - 1 - 8 - OFF - 1 - 1 - 1 - 8 - 1 - OFF - 14 - 1 - 1 - 1 - 2 - 1 - 8 - 3 - 1 - 1 - 1 - 8 - OFF - 1 - 1 - 1 - 8 - 1 - OFF - 14 - 1 - 1 - 1 - 2 - 1 - 8 - 8 - 2 - OFF - 1 - OFF - 100.0 - FALSE - 8 - 3 - 1 - 1 - 1 - 8 - OFF - 1 - 1 - 1 - 8 - OFF - 14 - 1 - 1 - 1 - 2 - 1 - DDR3 - FALSE - 10.0 - FALSE - 10 - FALSE - 10 - FALSE - 10 - FALSE - 10 - 1200.0 - 0.000 - ACTIVE_LOW - 29 - 1 - 8 - 18 - OFF - 1 - 29 - 2 - 1 - 1 - 18 - OFF - 1 - 1 - 1 - 8 - 1 - 29 - 1 - 29 - 2 - 1 - 1 - 18 - OFF - 1 - 1 - 1 - 8 - 1 - 29 - 1 - 29 - 2 - 1 - 18 - 1 - 1 - DIFF - FALSE - 0 - 32 - 32 - 32 - 4 - 1048576 - 32 - 4 - 1048576 - 8 - 3 - 1 - 1 - 1 - 8 - OFF - 1 - 1 - 1 - 8 - 1 - OFF - 14 - 1 - 1 - 1 - 2 - 1 - 8 - 3 - 1 - 1 - 1 - 8 - OFF - 1 - 1 - 1 - 8 - 1 - OFF - 14 - 1 - 1 - 1 - 2 - 1 - 8 - 8 - 2 - OFF - 1 - OFF - 100.0 - FALSE - 8 - 3 - 1 - 1 - 1 - 8 - OFF - 1 - 1 - 1 - 8 - OFF - 14 - 1 - 1 - 1 - 2 - 1 - DDR3 - FALSE - 10.0 - FALSE - 10 - FALSE - 10 - FALSE - 10 - FALSE - 10 - 1200.0 - 0.000 - ACTIVE_LOW - 29 - 1 - 8 - 18 - OFF - 1 - 29 - 2 - 1 - 1 - 18 - OFF - 1 - 1 - 1 - 8 - 1 - 29 - 1 - 29 - 2 - 1 - 1 - 18 - OFF - 1 - 1 - 1 - 8 - 1 - 29 - 1 - 29 - 2 - 1 - 18 - 1 - 1 - DIFF - FALSE - 0 - 32 - 32 - 32 - 4 - 1048576 - 32 - 4 - 1048576 - 8 - 3 - 1 - 1 - 1 - 8 - OFF - 1 - 1 - 1 - 8 - 1 - OFF - 14 - 1 - 1 - 1 - 2 - 1 - 8 - 3 - 1 - 1 - 1 - 8 - OFF - 1 - 1 - 1 - 8 - 1 - OFF - 14 - 1 - 1 - 1 - 2 - 1 - 8 - 8 - 2 - OFF - 1 - OFF - 100.0 - FALSE - 8 - 3 - 1 - 1 - 1 - 8 - OFF - 1 - 1 - 1 - 8 - OFF - 14 - 1 - 1 - 1 - 2 - 1 - DDR3 - FALSE - 10.0 - FALSE - 10 - FALSE - 10 - FALSE - 10 - FALSE - 10 - 1200.0 - 0.000 - ACTIVE_LOW - 29 - 1 - 8 - 18 - OFF - 1 - 29 - 2 - 1 - 1 - 18 - OFF - 1 - 1 - 1 - 8 - 1 - 29 - 1 - 29 - 2 - 1 - 1 - 18 - OFF - 1 - 1 - 1 - 8 - 1 - 29 - 1 - 29 - 2 - 1 - 18 - 1 - 1 - DIFF - FALSE - 0 - 32 - 32 - 32 - 4 - 1048576 - 32 - 4 - 1048576 - 8 - 3 - 1 - 1 - 1 - 8 - OFF - 1 - 1 - 1 - 8 - 1 - OFF - 14 - 1 - 1 - 1 - 2 - 1 - 8 - 3 - 1 - 1 - 1 - 8 - OFF - 1 - 1 - 1 - 8 - 1 - OFF - 14 - 1 - 1 - 1 - 2 - 1 - 8 - 8 - 2 - OFF - 1 - OFF - 100.0 - FALSE - 8 - 3 - 1 - 1 - 1 - 8 - OFF - 1 - 1 - 1 - 8 - OFF - 14 - 1 - 1 - 1 - 2 - 1 - DDR3 - FALSE - 10.0 - FALSE - 10 - FALSE - 10 - FALSE - 10 - FALSE - 10 - 1200.0 - 0.000 - ACTIVE_LOW - 29 - 1 - 8 - 18 - OFF - 1 - 29 - 2 - 1 - 1 - 18 - OFF - 1 - 1 - 1 - 8 - 1 - 29 - 1 - 29 - 2 - 1 - 1 - 18 - OFF - 1 - 1 - 1 - 8 - 1 - 29 - 1 - 29 - 2 - 1 - 18 - 1 - 1 - DIFF - FALSE - 0 - 32 - 32 - 32 - 4 - 1048576 - 32 - 4 - 1048576 - 8 - 3 - 1 - 1 - 1 - 8 - OFF - 1 - 1 - 1 - 8 - 1 - OFF - 14 - 1 - 1 - 1 - 2 - 1 - 8 - 3 - 1 - 1 - 1 - 8 - OFF - 1 - 1 - 1 - 8 - 1 - OFF - 14 - 1 - 1 - 1 - 2 - 1 - 8 - 8 - 2 - OFF - 1 - OFF - 100.0 - FALSE - 8 - 3 - 1 - 1 - 1 - 8 - OFF - 1 - 1 - 1 - 8 - OFF - 14 - 1 - 1 - 1 - 2 - 1 - DDR3 - FALSE - 10.0 - FALSE - 10 - FALSE - 10 - FALSE - 10 - FALSE - 10 - 1200.0 - 0.000 - ACTIVE_LOW - 29 - 1 - 8 - 18 - OFF - 1 - 29 - 2 - 1 - 1 - 18 - OFF - 1 - 1 - 1 - 8 - 1 - 29 - 1 - 29 - 2 - 1 - 1 - 18 - OFF - 1 - 1 - 1 - 8 - 1 - 29 - 1 - 29 - 2 - 1 - 18 - 1 - 1 - DIFF - FALSE - 0 - 0 - 28 - 32 - 32 - 4 - 1048576 - 128 - 2 - 268435456 - 8 - 3 - 1 - 1 - 1 - 8 - OFF - 1 - 1 - 1 - 8 - 1 - OFF - 14 - 1 - 1 - 1 - 2 - 1 - 28 - 3 - 1 - 1 - 1 - 16 - OFF - 2 - 1 - 2 - 16 - 1 - OFF - 14 - 1 - 1 - 1 - 4 - 1 - 8 - 8 - 2 - OFF - 1 - OFF - 83333333 - FALSE - 8 - 3 - 1 - 1 - 1 - 8 - OFF - 1 - 1 - 1 - 8 - OFF - 14 - 1 - 1 - 1 - 2 - 1 - DDR3 - FALSE - 10.0 - FALSE - 10 - FALSE - 10 - FALSE - 10 - FALSE - 10 - 666 - 1 - 0.000 - ACTIVE_LOW - 29 - 1 - 8 - 18 - OFF - 1 - NOBUF - 29 - 2 - 1 - 1 - 18 - OFF - 1 - 1 - 1 - 8 - 1 - 29 - 1 - 29 - 2 - 1 - 1 - 18 - OFF - 1 - 1 - 1 - 8 - 1 - 29 - 1 - 29 - 2 - 1 - 18 - 1 - 1 - NOBUF - INTERNAL - FALSE - 0 - Custom - mig_dram_0 - Custom - Custom - mig_b.prj - artix7 - digilentinc.com:arty-a7-35:part0:1.0 - - xc7a35ti - csg324 - VERILOG - - MIXED - -1L - - I - TRUE - TRUE - IP_Flow - 1 - TRUE - . - - . - 2020.1 - OUT_OF_CONTEXT - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +{ + "schema": "xilinx.com:schema:json_instance:1.0", + "ip_inst": { + "xci_name": "mig_dram_0", + "component_reference": "xilinx.com:ip:mig_7series:4.2", + "ip_revision": "1", + "gen_directory": ".", + "parameters": { + "component_parameters": { + "XML_INPUT_FILE": [ { "value": "mig_b.prj", "value_src": "user", "resolve_type": "user", "usage": "all" } ], + "RESET_BOARD_INTERFACE": [ { "value": "Custom", "value_src": "user", "resolve_type": "user", "usage": "all" } ], + "MIG_DONT_TOUCH_PARAM": [ { "value": "Custom", "value_src": "user", "resolve_type": "user", "usage": "all" } ], + "BOARD_MIG_PARAM": [ { "value": "Custom", "value_src": "user", "resolve_type": "user", "usage": "all" } ], + "Component_Name": [ { "value": "mig_dram_0", "resolve_type": "user", "usage": "all" } ] + }, + "model_parameters": { + "NoOfControllers": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "COMBINED_INTERFACE": [ { "value": "0", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "REFCLK_TYPE": [ { "value": "NOBUF", "resolve_type": "generated", "usage": "all" } ], + "MEM_TYPE": [ { "value": "DDR3", "resolve_type": "generated", "usage": "all" } ], + "TEMP_MON_CONTROL": [ { "value": "INTERNAL", "resolve_type": "generated", "usage": "all" } ], + "POLARITY": [ { "value": "ACTIVE_LOW", "resolve_type": "generated", "usage": "all" } ], + "IS_CLK_SHARED": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "SYSCLK_TYPE": [ { "value": "NOBUF", "resolve_type": "generated", "usage": "all" } ], + "USE_AXI": [ { "value": "0", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "ECC": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "DDR3_DQ_WIDTH": [ { "value": "16", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "DDR3_DQS_WIDTH": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "DDR3_ROW_WIDTH": [ { "value": "14", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "DDR3_BANK_WIDTH": [ { "value": "3", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "DDR3_CK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "DDR3_CKE_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "DDR3_CS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "DDR3_nCS_PER_RANK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "DDR3_DM_WIDTH": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "DDR3_ODT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "DDR3_USE_CS_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "DDR3_USE_DM_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "DDR3_USE_ODT_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "DDR3_REG_CTRL": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "DDR3_DQS_CNT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "DDR3_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "DDR2_DQ_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "DDR2_DQS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "DDR2_ROW_WIDTH": [ { "value": "14", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "DDR2_BANK_WIDTH": [ { "value": "3", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "DDR2_CK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "DDR2_CKE_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "DDR2_CS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "DDR2_nCS_PER_RANK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "DDR2_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "DDR2_ODT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "DDR2_USE_CS_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "DDR2_USE_DM_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "DDR2_USE_ODT_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "DDR2_REG_CTRL": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "DDR2_DQS_CNT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "DDR2_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "LPDDR2_DQ_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "LPDDR2_DQS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "LPDDR2_ROW_WIDTH": [ { "value": "14", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "LPDDR2_BANK_WIDTH": [ { "value": "3", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "LPDDR2_CK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "LPDDR2_CKE_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "LPDDR2_CS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "LPDDR2_nCS_PER_RANK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "LPDDR2_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "LPDDR2_USE_CS_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "LPDDR2_USE_DM_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "LPDDR2_USE_ODT_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "LPDDR2_REG_CTRL": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "LPDDR2_DQS_CNT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "LPDDR2_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "DQS_CNT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "DDRX_ADDR_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "DDRX_nCK_PER_CLK": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "DDRX_DATA_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "DDR3_ADDR_WIDTH": [ { "value": "28", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "DDR3_nCK_PER_CLK": [ { "value": "4", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "DDR3_DATA_WIDTH": [ { "value": "16", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "DDR2_ADDR_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "DDR2_nCK_PER_CLK": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "DDR2_DATA_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "LPDDR2_ADDR_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "LPDDR2_nCK_PER_CLK": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "LPDDR2_DATA_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "FREQ_HZ": [ { "value": "83333333", "resolve_type": "generated", "format": "float", "usage": "all" } ], + "PHASE": [ { "value": "0.000", "resolve_type": "generated", "format": "float", "usage": "all" } ], + "UI_EXTRA_CLOCKS": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "MMCM_VCO": [ { "value": "666", "resolve_type": "generated", "format": "float", "usage": "all" } ], + "MMCM_CLKOUT0_FREQ": [ { "value": "10.0", "resolve_type": "generated", "format": "float", "usage": "all" } ], + "MMCM_CLKOUT1_FREQ": [ { "value": "10", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "MMCM_CLKOUT2_FREQ": [ { "value": "10", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "MMCM_CLKOUT3_FREQ": [ { "value": "10", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "MMCM_CLKOUT4_FREQ": [ { "value": "10", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "MMCM_CLKOUT0_EN": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "MMCM_CLKOUT2_EN": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "MMCM_CLKOUT1_EN": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "MMCM_CLKOUT3_EN": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "MMCM_CLKOUT4_EN": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C_S_AXI_CTRL_ID_WIDTH": [ { "value": "4", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C_S_AXI_CTRL_DATA_WIDTH": [ { "value": "32", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C_S_AXI_CTRL_ADDR_WIDTH": [ { "value": "32", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C_S_AXI_CTRL_MEM_SIZE": [ { "value": "1048576", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C_S_AXI_ID_WIDTH": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C_S_AXI_DATA_WIDTH": [ { "value": "128", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C_S_AXI_ADDR_WIDTH": [ { "value": "28", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C_S_AXI_MEM_SIZE": [ { "value": "268435456", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "QDRIIP_NUM_DEVICES": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "QDRIIP_DATA_WIDTH": [ { "value": "18", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "QDRIIP_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "QDRIIP_BW_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "QDRIIP_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "QDRIIP_BURST_LEN": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "RLDII_NUM_DEVICES": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "RLDII_DATA_WIDTH": [ { "value": "18", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "RLDII_RLD_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "RLDII_QK_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "RLDII_CK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "RLDII_DK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "RLDII_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "RLDII_BANK_WIDTH": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "RLDII_QVLD_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "RLDII_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "RLDIII_NUM_DEVICES": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "RLDIII_DATA_WIDTH": [ { "value": "18", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "RLDIII_RLD_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "RLDIII_QK_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "RLDIII_CK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "RLDIII_DK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "RLDIII_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "RLDIII_BANK_WIDTH": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "RLDIII_QVLD_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "RLDIII_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "RLDX_CMD_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "RLDX_DATA_WIDTH": [ { "value": "18", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "RLDX_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "RLDX_BANK_WIDTH": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "RLDX_nCK_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "RLDX_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "RLDII_CMD_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "RLDII_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "RLDII_nCK_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "RLDIII_CMD_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "RLDIII_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "RLDIII_nCK_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_MEM_TYPE": [ { "value": "DDR3", "resolve_type": "generated", "usage": "all" } ], + "C0_IS_CLK_SHARED": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C0_SYSCLK_TYPE": [ { "value": "DIFF", "resolve_type": "generated", "usage": "all" } ], + "C0_USE_AXI": [ { "value": "0", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_ECC": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C0_DDR3_DQ_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_DDR3_DQS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_DDR3_ROW_WIDTH": [ { "value": "14", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_DDR3_BANK_WIDTH": [ { "value": "3", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_DDR3_CK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_DDR3_CKE_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_DDR3_CS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_DDR3_nCS_PER_RANK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_DDR3_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_DDR3_ODT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_DDR3_USE_CS_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_DDR3_USE_DM_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_DDR3_USE_ODT_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_DDR3_REG_CTRL": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C0_DDR3_DQS_CNT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_DDR3_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C0_DDR2_DQ_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_DDR2_DQS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_DDR2_ROW_WIDTH": [ { "value": "14", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_DDR2_BANK_WIDTH": [ { "value": "3", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_DDR2_CK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_DDR2_CKE_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_DDR2_CS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_DDR2_nCS_PER_RANK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_DDR2_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_DDR2_ODT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_DDR2_USE_CS_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_DDR2_USE_DM_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_DDR2_USE_ODT_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_DDR2_REG_CTRL": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C0_DDR2_DQS_CNT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_DDR2_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C0_LPDDR2_DQ_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_LPDDR2_DQS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_LPDDR2_ROW_WIDTH": [ { "value": "14", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_LPDDR2_BANK_WIDTH": [ { "value": "3", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_LPDDR2_CK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_LPDDR2_CKE_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_LPDDR2_CS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_LPDDR2_nCS_PER_RANK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_LPDDR2_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_LPDDR2_USE_CS_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_LPDDR2_USE_DM_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_LPDDR2_USE_ODT_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_LPDDR2_REG_CTRL": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C0_LPDDR2_DQS_CNT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_LPDDR2_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C0_DQS_CNT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C0_DDRX_ADDR_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_DDRX_nCK_PER_CLK": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_DDRX_DATA_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_DDR3_ADDR_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_DDR3_nCK_PER_CLK": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_DDR3_DATA_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_DDR2_ADDR_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_DDR2_nCK_PER_CLK": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_DDR2_DATA_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_LPDDR2_ADDR_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_LPDDR2_nCK_PER_CLK": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_LPDDR2_DATA_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_FREQ_HZ": [ { "value": "100.0", "resolve_type": "generated", "format": "float", "usage": "all" } ], + "C0_PHASE": [ { "value": "0.000", "resolve_type": "generated", "format": "float", "usage": "all" } ], + "C0_UI_EXTRA_CLOCKS": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C0_MMCM_VCO": [ { "value": "1200.0", "resolve_type": "generated", "format": "float", "usage": "all" } ], + "C0_MMCM_CLKOUT0_FREQ": [ { "value": "10.0", "resolve_type": "generated", "format": "float", "usage": "all" } ], + "C0_MMCM_CLKOUT1_FREQ": [ { "value": "10", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_MMCM_CLKOUT2_FREQ": [ { "value": "10", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_MMCM_CLKOUT3_FREQ": [ { "value": "10", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_MMCM_CLKOUT4_FREQ": [ { "value": "10", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_MMCM_CLKOUT0_EN": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C0_MMCM_CLKOUT2_EN": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C0_MMCM_CLKOUT1_EN": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C0_MMCM_CLKOUT3_EN": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C0_MMCM_CLKOUT4_EN": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C0_C_S_AXI_CTRL_ID_WIDTH": [ { "value": "4", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_C_S_AXI_CTRL_DATA_WIDTH": [ { "value": "32", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_C_S_AXI_CTRL_ADDR_WIDTH": [ { "value": "32", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_C_S_AXI_CTRL_MEM_SIZE": [ { "value": "1048576", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_C_S_AXI_ID_WIDTH": [ { "value": "4", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_C_S_AXI_DATA_WIDTH": [ { "value": "32", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_C_S_AXI_ADDR_WIDTH": [ { "value": "32", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_C_S_AXI_MEM_SIZE": [ { "value": "1048576", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_QDRIIP_NUM_DEVICES": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_QDRIIP_DATA_WIDTH": [ { "value": "18", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_QDRIIP_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_QDRIIP_BW_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_QDRIIP_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C0_QDRIIP_BURST_LEN": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_RLDII_NUM_DEVICES": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_RLDII_DATA_WIDTH": [ { "value": "18", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_RLDII_RLD_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_RLDII_QK_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_RLDII_CK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_RLDII_DK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_RLDII_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_RLDII_BANK_WIDTH": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_RLDII_QVLD_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_RLDII_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C0_RLDIII_NUM_DEVICES": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_RLDIII_DATA_WIDTH": [ { "value": "18", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_RLDIII_RLD_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_RLDIII_QK_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_RLDIII_CK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_RLDIII_DK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_RLDIII_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_RLDIII_BANK_WIDTH": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_RLDIII_QVLD_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_RLDIII_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C0_RLDX_CMD_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_RLDX_DATA_WIDTH": [ { "value": "18", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_RLDX_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_RLDX_BANK_WIDTH": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_RLDX_nCK_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_RLDX_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_RLDII_CMD_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_RLDII_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_RLDII_nCK_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_RLDIII_CMD_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_RLDIII_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_RLDIII_nCK_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C0_POLARITY": [ { "value": "ACTIVE_LOW", "resolve_type": "generated", "usage": "all" } ], + "C1_MEM_TYPE": [ { "value": "DDR3", "resolve_type": "generated", "usage": "all" } ], + "C1_IS_CLK_SHARED": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C1_SYSCLK_TYPE": [ { "value": "DIFF", "resolve_type": "generated", "usage": "all" } ], + "C1_USE_AXI": [ { "value": "0", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_ECC": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C1_DDR3_DQ_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_DDR3_DQS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_DDR3_ROW_WIDTH": [ { "value": "14", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_DDR3_BANK_WIDTH": [ { "value": "3", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_DDR3_CK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_DDR3_CKE_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_DDR3_CS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_DDR3_nCS_PER_RANK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_DDR3_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_DDR3_ODT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_DDR3_USE_CS_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_DDR3_USE_DM_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_DDR3_USE_ODT_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_DDR3_REG_CTRL": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C1_DDR3_DQS_CNT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_DDR3_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C1_DDR2_DQ_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_DDR2_DQS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_DDR2_ROW_WIDTH": [ { "value": "14", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_DDR2_BANK_WIDTH": [ { "value": "3", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_DDR2_CK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_DDR2_CKE_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_DDR2_CS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_DDR2_nCS_PER_RANK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_DDR2_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_DDR2_ODT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_DDR2_USE_CS_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_DDR2_USE_DM_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_DDR2_USE_ODT_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_DDR2_REG_CTRL": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C1_DDR2_DQS_CNT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_DDR2_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C1_LPDDR2_DQ_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_LPDDR2_DQS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_LPDDR2_ROW_WIDTH": [ { "value": "14", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_LPDDR2_BANK_WIDTH": [ { "value": "3", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_LPDDR2_CK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_LPDDR2_CKE_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_LPDDR2_CS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_LPDDR2_nCS_PER_RANK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_LPDDR2_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_LPDDR2_USE_CS_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_LPDDR2_USE_DM_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_LPDDR2_USE_ODT_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_LPDDR2_REG_CTRL": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C1_LPDDR2_DQS_CNT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_LPDDR2_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C1_DQS_CNT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C1_DDRX_ADDR_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_DDRX_nCK_PER_CLK": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_DDRX_DATA_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_DDR3_ADDR_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_DDR3_nCK_PER_CLK": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_DDR3_DATA_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_DDR2_ADDR_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_DDR2_nCK_PER_CLK": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_DDR2_DATA_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_LPDDR2_ADDR_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_LPDDR2_nCK_PER_CLK": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_LPDDR2_DATA_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_FREQ_HZ": [ { "value": "100.0", "resolve_type": "generated", "format": "float", "usage": "all" } ], + "C1_PHASE": [ { "value": "0.000", "resolve_type": "generated", "format": "float", "usage": "all" } ], + "C1_UI_EXTRA_CLOCKS": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C1_MMCM_VCO": [ { "value": "1200.0", "resolve_type": "generated", "format": "float", "usage": "all" } ], + "C1_MMCM_CLKOUT0_FREQ": [ { "value": "10.0", "resolve_type": "generated", "format": "float", "usage": "all" } ], + "C1_MMCM_CLKOUT1_FREQ": [ { "value": "10", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_MMCM_CLKOUT2_FREQ": [ { "value": "10", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_MMCM_CLKOUT3_FREQ": [ { "value": "10", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_MMCM_CLKOUT4_FREQ": [ { "value": "10", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_MMCM_CLKOUT0_EN": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C1_MMCM_CLKOUT2_EN": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C1_MMCM_CLKOUT1_EN": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C1_MMCM_CLKOUT3_EN": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C1_MMCM_CLKOUT4_EN": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C1_C_S_AXI_CTRL_ID_WIDTH": [ { "value": "4", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_C_S_AXI_CTRL_DATA_WIDTH": [ { "value": "32", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_C_S_AXI_CTRL_ADDR_WIDTH": [ { "value": "32", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_C_S_AXI_CTRL_MEM_SIZE": [ { "value": "1048576", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_C_S_AXI_ID_WIDTH": [ { "value": "4", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_C_S_AXI_DATA_WIDTH": [ { "value": "32", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_C_S_AXI_ADDR_WIDTH": [ { "value": "32", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_C_S_AXI_MEM_SIZE": [ { "value": "1048576", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_QDRIIP_NUM_DEVICES": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_QDRIIP_DATA_WIDTH": [ { "value": "18", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_QDRIIP_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_QDRIIP_BW_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_QDRIIP_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C1_QDRIIP_BURST_LEN": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_RLDII_NUM_DEVICES": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_RLDII_DATA_WIDTH": [ { "value": "18", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_RLDII_RLD_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_RLDII_QK_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_RLDII_CK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_RLDII_DK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_RLDII_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_RLDII_BANK_WIDTH": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_RLDII_QVLD_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_RLDII_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C1_RLDIII_NUM_DEVICES": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_RLDIII_DATA_WIDTH": [ { "value": "18", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_RLDIII_RLD_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_RLDIII_QK_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_RLDIII_CK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_RLDIII_DK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_RLDIII_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_RLDIII_BANK_WIDTH": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_RLDIII_QVLD_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_RLDIII_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C1_RLDX_CMD_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_RLDX_DATA_WIDTH": [ { "value": "18", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_RLDX_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_RLDX_BANK_WIDTH": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_RLDX_nCK_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_RLDX_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_RLDII_CMD_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_RLDII_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_RLDII_nCK_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_RLDIII_CMD_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_RLDIII_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_RLDIII_nCK_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C1_POLARITY": [ { "value": "ACTIVE_LOW", "resolve_type": "generated", "usage": "all" } ], + "C2_MEM_TYPE": [ { "value": "DDR3", "resolve_type": "generated", "usage": "all" } ], + "C2_IS_CLK_SHARED": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C2_SYSCLK_TYPE": [ { "value": "DIFF", "resolve_type": "generated", "usage": "all" } ], + "C2_USE_AXI": [ { "value": "0", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_ECC": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C2_DDR3_DQ_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_DDR3_DQS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_DDR3_ROW_WIDTH": [ { "value": "14", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_DDR3_BANK_WIDTH": [ { "value": "3", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_DDR3_CK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_DDR3_CKE_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_DDR3_CS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_DDR3_nCS_PER_RANK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_DDR3_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_DDR3_ODT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_DDR3_USE_CS_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_DDR3_USE_DM_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_DDR3_USE_ODT_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_DDR3_REG_CTRL": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C2_DDR3_DQS_CNT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_DDR3_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C2_DDR2_DQ_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_DDR2_DQS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_DDR2_ROW_WIDTH": [ { "value": "14", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_DDR2_BANK_WIDTH": [ { "value": "3", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_DDR2_CK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_DDR2_CKE_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_DDR2_CS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_DDR2_nCS_PER_RANK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_DDR2_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_DDR2_ODT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_DDR2_USE_CS_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_DDR2_USE_DM_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_DDR2_USE_ODT_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_DDR2_REG_CTRL": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C2_DDR2_DQS_CNT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_DDR2_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C2_LPDDR2_DQ_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_LPDDR2_DQS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_LPDDR2_ROW_WIDTH": [ { "value": "14", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_LPDDR2_BANK_WIDTH": [ { "value": "3", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_LPDDR2_CK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_LPDDR2_CKE_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_LPDDR2_CS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_LPDDR2_nCS_PER_RANK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_LPDDR2_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_LPDDR2_USE_CS_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_LPDDR2_USE_DM_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_LPDDR2_USE_ODT_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_LPDDR2_REG_CTRL": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C2_LPDDR2_DQS_CNT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_LPDDR2_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C2_DQS_CNT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C2_DDRX_ADDR_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_DDRX_nCK_PER_CLK": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_DDRX_DATA_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_DDR3_ADDR_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_DDR3_nCK_PER_CLK": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_DDR3_DATA_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_DDR2_ADDR_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_DDR2_nCK_PER_CLK": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_DDR2_DATA_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_LPDDR2_ADDR_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_LPDDR2_nCK_PER_CLK": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_LPDDR2_DATA_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_FREQ_HZ": [ { "value": "100.0", "resolve_type": "generated", "format": "float", "usage": "all" } ], + "C2_PHASE": [ { "value": "0.000", "resolve_type": "generated", "format": "float", "usage": "all" } ], + "C2_UI_EXTRA_CLOCKS": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C2_MMCM_VCO": [ { "value": "1200.0", "resolve_type": "generated", "format": "float", "usage": "all" } ], + "C2_MMCM_CLKOUT0_FREQ": [ { "value": "10.0", "resolve_type": "generated", "format": "float", "usage": "all" } ], + "C2_MMCM_CLKOUT1_FREQ": [ { "value": "10", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_MMCM_CLKOUT2_FREQ": [ { "value": "10", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_MMCM_CLKOUT3_FREQ": [ { "value": "10", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_MMCM_CLKOUT4_FREQ": [ { "value": "10", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_MMCM_CLKOUT0_EN": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C2_MMCM_CLKOUT2_EN": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C2_MMCM_CLKOUT1_EN": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C2_MMCM_CLKOUT3_EN": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C2_MMCM_CLKOUT4_EN": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C2_C_S_AXI_CTRL_ID_WIDTH": [ { "value": "4", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_C_S_AXI_CTRL_DATA_WIDTH": [ { "value": "32", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_C_S_AXI_CTRL_ADDR_WIDTH": [ { "value": "32", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_C_S_AXI_CTRL_MEM_SIZE": [ { "value": "1048576", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_C_S_AXI_ID_WIDTH": [ { "value": "4", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_C_S_AXI_DATA_WIDTH": [ { "value": "32", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_C_S_AXI_ADDR_WIDTH": [ { "value": "32", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_C_S_AXI_MEM_SIZE": [ { "value": "1048576", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_QDRIIP_NUM_DEVICES": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_QDRIIP_DATA_WIDTH": [ { "value": "18", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_QDRIIP_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_QDRIIP_BW_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_QDRIIP_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C2_QDRIIP_BURST_LEN": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_RLDII_NUM_DEVICES": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_RLDII_DATA_WIDTH": [ { "value": "18", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_RLDII_RLD_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_RLDII_QK_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_RLDII_CK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_RLDII_DK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_RLDII_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_RLDII_BANK_WIDTH": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_RLDII_QVLD_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_RLDII_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C2_RLDIII_NUM_DEVICES": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_RLDIII_DATA_WIDTH": [ { "value": "18", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_RLDIII_RLD_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_RLDIII_QK_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_RLDIII_CK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_RLDIII_DK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_RLDIII_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_RLDIII_BANK_WIDTH": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_RLDIII_QVLD_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_RLDIII_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C2_RLDX_CMD_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_RLDX_DATA_WIDTH": [ { "value": "18", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_RLDX_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_RLDX_BANK_WIDTH": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_RLDX_nCK_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_RLDX_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_RLDII_CMD_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_RLDII_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_RLDII_nCK_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_RLDIII_CMD_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_RLDIII_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_RLDIII_nCK_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C2_POLARITY": [ { "value": "ACTIVE_LOW", "resolve_type": "generated", "usage": "all" } ], + "C3_MEM_TYPE": [ { "value": "DDR3", "resolve_type": "generated", "usage": "all" } ], + "C3_IS_CLK_SHARED": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C3_SYSCLK_TYPE": [ { "value": "DIFF", "resolve_type": "generated", "usage": "all" } ], + "C3_USE_AXI": [ { "value": "0", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_ECC": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C3_DDR3_DQ_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_DDR3_DQS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_DDR3_ROW_WIDTH": [ { "value": "14", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_DDR3_BANK_WIDTH": [ { "value": "3", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_DDR3_CK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_DDR3_CKE_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_DDR3_CS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_DDR3_nCS_PER_RANK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_DDR3_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_DDR3_ODT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_DDR3_USE_CS_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_DDR3_USE_DM_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_DDR3_USE_ODT_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_DDR3_REG_CTRL": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C3_DDR3_DQS_CNT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_DDR3_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C3_DDR2_DQ_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_DDR2_DQS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_DDR2_ROW_WIDTH": [ { "value": "14", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_DDR2_BANK_WIDTH": [ { "value": "3", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_DDR2_CK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_DDR2_CKE_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_DDR2_CS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_DDR2_nCS_PER_RANK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_DDR2_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_DDR2_ODT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_DDR2_USE_CS_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_DDR2_USE_DM_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_DDR2_USE_ODT_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_DDR2_REG_CTRL": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C3_DDR2_DQS_CNT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_DDR2_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C3_LPDDR2_DQ_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_LPDDR2_DQS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_LPDDR2_ROW_WIDTH": [ { "value": "14", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_LPDDR2_BANK_WIDTH": [ { "value": "3", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_LPDDR2_CK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_LPDDR2_CKE_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_LPDDR2_CS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_LPDDR2_nCS_PER_RANK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_LPDDR2_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_LPDDR2_USE_CS_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_LPDDR2_USE_DM_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_LPDDR2_USE_ODT_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_LPDDR2_REG_CTRL": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C3_LPDDR2_DQS_CNT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_LPDDR2_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C3_DQS_CNT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C3_DDRX_ADDR_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_DDRX_nCK_PER_CLK": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_DDRX_DATA_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_DDR3_ADDR_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_DDR3_nCK_PER_CLK": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_DDR3_DATA_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_DDR2_ADDR_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_DDR2_nCK_PER_CLK": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_DDR2_DATA_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_LPDDR2_ADDR_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_LPDDR2_nCK_PER_CLK": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_LPDDR2_DATA_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_FREQ_HZ": [ { "value": "100.0", "resolve_type": "generated", "format": "float", "usage": "all" } ], + "C3_PHASE": [ { "value": "0.000", "resolve_type": "generated", "format": "float", "usage": "all" } ], + "C3_UI_EXTRA_CLOCKS": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C3_MMCM_VCO": [ { "value": "1200.0", "resolve_type": "generated", "format": "float", "usage": "all" } ], + "C3_MMCM_CLKOUT0_FREQ": [ { "value": "10.0", "resolve_type": "generated", "format": "float", "usage": "all" } ], + "C3_MMCM_CLKOUT1_FREQ": [ { "value": "10", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_MMCM_CLKOUT2_FREQ": [ { "value": "10", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_MMCM_CLKOUT3_FREQ": [ { "value": "10", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_MMCM_CLKOUT4_FREQ": [ { "value": "10", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_MMCM_CLKOUT0_EN": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C3_MMCM_CLKOUT2_EN": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C3_MMCM_CLKOUT1_EN": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C3_MMCM_CLKOUT3_EN": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C3_MMCM_CLKOUT4_EN": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C3_C_S_AXI_CTRL_ID_WIDTH": [ { "value": "4", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_C_S_AXI_CTRL_DATA_WIDTH": [ { "value": "32", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_C_S_AXI_CTRL_ADDR_WIDTH": [ { "value": "32", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_C_S_AXI_CTRL_MEM_SIZE": [ { "value": "1048576", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_C_S_AXI_ID_WIDTH": [ { "value": "4", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_C_S_AXI_DATA_WIDTH": [ { "value": "32", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_C_S_AXI_ADDR_WIDTH": [ { "value": "32", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_C_S_AXI_MEM_SIZE": [ { "value": "1048576", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_QDRIIP_NUM_DEVICES": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_QDRIIP_DATA_WIDTH": [ { "value": "18", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_QDRIIP_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_QDRIIP_BW_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_QDRIIP_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C3_QDRIIP_BURST_LEN": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_RLDII_NUM_DEVICES": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_RLDII_DATA_WIDTH": [ { "value": "18", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_RLDII_RLD_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_RLDII_QK_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_RLDII_CK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_RLDII_DK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_RLDII_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_RLDII_BANK_WIDTH": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_RLDII_QVLD_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_RLDII_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C3_RLDIII_NUM_DEVICES": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_RLDIII_DATA_WIDTH": [ { "value": "18", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_RLDIII_RLD_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_RLDIII_QK_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_RLDIII_CK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_RLDIII_DK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_RLDIII_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_RLDIII_BANK_WIDTH": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_RLDIII_QVLD_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_RLDIII_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C3_RLDX_CMD_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_RLDX_DATA_WIDTH": [ { "value": "18", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_RLDX_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_RLDX_BANK_WIDTH": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_RLDX_nCK_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_RLDX_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_RLDII_CMD_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_RLDII_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_RLDII_nCK_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_RLDIII_CMD_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_RLDIII_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_RLDIII_nCK_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C3_POLARITY": [ { "value": "ACTIVE_LOW", "resolve_type": "generated", "usage": "all" } ], + "C4_MEM_TYPE": [ { "value": "DDR3", "resolve_type": "generated", "usage": "all" } ], + "C4_IS_CLK_SHARED": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C4_SYSCLK_TYPE": [ { "value": "DIFF", "resolve_type": "generated", "usage": "all" } ], + "C4_USE_AXI": [ { "value": "0", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_ECC": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C4_DDR3_DQ_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_DDR3_DQS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_DDR3_ROW_WIDTH": [ { "value": "14", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_DDR3_BANK_WIDTH": [ { "value": "3", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_DDR3_CK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_DDR3_CKE_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_DDR3_CS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_DDR3_nCS_PER_RANK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_DDR3_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_DDR3_ODT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_DDR3_USE_CS_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_DDR3_USE_DM_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_DDR3_USE_ODT_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_DDR3_REG_CTRL": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C4_DDR3_DQS_CNT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_DDR3_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C4_DDR2_DQ_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_DDR2_DQS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_DDR2_ROW_WIDTH": [ { "value": "14", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_DDR2_BANK_WIDTH": [ { "value": "3", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_DDR2_CK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_DDR2_CKE_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_DDR2_CS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_DDR2_nCS_PER_RANK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_DDR2_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_DDR2_ODT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_DDR2_USE_CS_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_DDR2_USE_DM_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_DDR2_USE_ODT_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_DDR2_REG_CTRL": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C4_DDR2_DQS_CNT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_DDR2_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C4_LPDDR2_DQ_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_LPDDR2_DQS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_LPDDR2_ROW_WIDTH": [ { "value": "14", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_LPDDR2_BANK_WIDTH": [ { "value": "3", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_LPDDR2_CK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_LPDDR2_CKE_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_LPDDR2_CS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_LPDDR2_nCS_PER_RANK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_LPDDR2_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_LPDDR2_USE_CS_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_LPDDR2_USE_DM_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_LPDDR2_USE_ODT_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_LPDDR2_REG_CTRL": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C4_LPDDR2_DQS_CNT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_LPDDR2_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C4_DQS_CNT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C4_DDRX_ADDR_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_DDRX_nCK_PER_CLK": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_DDRX_DATA_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_DDR3_ADDR_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_DDR3_nCK_PER_CLK": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_DDR3_DATA_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_DDR2_ADDR_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_DDR2_nCK_PER_CLK": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_DDR2_DATA_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_LPDDR2_ADDR_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_LPDDR2_nCK_PER_CLK": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_LPDDR2_DATA_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_FREQ_HZ": [ { "value": "100.0", "resolve_type": "generated", "format": "float", "usage": "all" } ], + "C4_PHASE": [ { "value": "0.000", "resolve_type": "generated", "format": "float", "usage": "all" } ], + "C4_UI_EXTRA_CLOCKS": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C4_MMCM_VCO": [ { "value": "1200.0", "resolve_type": "generated", "format": "float", "usage": "all" } ], + "C4_MMCM_CLKOUT0_FREQ": [ { "value": "10.0", "resolve_type": "generated", "format": "float", "usage": "all" } ], + "C4_MMCM_CLKOUT1_FREQ": [ { "value": "10", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_MMCM_CLKOUT2_FREQ": [ { "value": "10", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_MMCM_CLKOUT3_FREQ": [ { "value": "10", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_MMCM_CLKOUT4_FREQ": [ { "value": "10", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_MMCM_CLKOUT0_EN": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C4_MMCM_CLKOUT2_EN": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C4_MMCM_CLKOUT1_EN": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C4_MMCM_CLKOUT3_EN": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C4_MMCM_CLKOUT4_EN": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C4_C_S_AXI_CTRL_ID_WIDTH": [ { "value": "4", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_C_S_AXI_CTRL_DATA_WIDTH": [ { "value": "32", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_C_S_AXI_CTRL_ADDR_WIDTH": [ { "value": "32", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_C_S_AXI_CTRL_MEM_SIZE": [ { "value": "1048576", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_C_S_AXI_ID_WIDTH": [ { "value": "4", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_C_S_AXI_DATA_WIDTH": [ { "value": "32", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_C_S_AXI_ADDR_WIDTH": [ { "value": "32", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_C_S_AXI_MEM_SIZE": [ { "value": "1048576", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_QDRIIP_NUM_DEVICES": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_QDRIIP_DATA_WIDTH": [ { "value": "18", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_QDRIIP_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_QDRIIP_BW_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_QDRIIP_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C4_QDRIIP_BURST_LEN": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_RLDII_NUM_DEVICES": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_RLDII_DATA_WIDTH": [ { "value": "18", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_RLDII_RLD_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_RLDII_QK_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_RLDII_CK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_RLDII_DK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_RLDII_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_RLDII_BANK_WIDTH": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_RLDII_QVLD_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_RLDII_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C4_RLDIII_NUM_DEVICES": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_RLDIII_DATA_WIDTH": [ { "value": "18", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_RLDIII_RLD_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_RLDIII_QK_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_RLDIII_CK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_RLDIII_DK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_RLDIII_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_RLDIII_BANK_WIDTH": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_RLDIII_QVLD_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_RLDIII_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C4_RLDX_CMD_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_RLDX_DATA_WIDTH": [ { "value": "18", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_RLDX_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_RLDX_BANK_WIDTH": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_RLDX_nCK_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_RLDX_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_RLDII_CMD_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_RLDII_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_RLDII_nCK_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_RLDIII_CMD_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_RLDIII_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_RLDIII_nCK_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C4_POLARITY": [ { "value": "ACTIVE_LOW", "resolve_type": "generated", "usage": "all" } ], + "C5_MEM_TYPE": [ { "value": "DDR3", "resolve_type": "generated", "usage": "all" } ], + "C5_IS_CLK_SHARED": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C5_SYSCLK_TYPE": [ { "value": "DIFF", "resolve_type": "generated", "usage": "all" } ], + "C5_USE_AXI": [ { "value": "0", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_ECC": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C5_DDR3_DQ_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_DDR3_DQS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_DDR3_ROW_WIDTH": [ { "value": "14", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_DDR3_BANK_WIDTH": [ { "value": "3", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_DDR3_CK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_DDR3_CKE_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_DDR3_CS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_DDR3_nCS_PER_RANK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_DDR3_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_DDR3_ODT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_DDR3_USE_CS_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_DDR3_USE_DM_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_DDR3_USE_ODT_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_DDR3_REG_CTRL": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C5_DDR3_DQS_CNT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_DDR3_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C5_DDR2_DQ_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_DDR2_DQS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_DDR2_ROW_WIDTH": [ { "value": "14", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_DDR2_BANK_WIDTH": [ { "value": "3", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_DDR2_CK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_DDR2_CKE_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_DDR2_CS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_DDR2_nCS_PER_RANK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_DDR2_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_DDR2_ODT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_DDR2_USE_CS_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_DDR2_USE_DM_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_DDR2_USE_ODT_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_DDR2_REG_CTRL": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C5_DDR2_DQS_CNT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_DDR2_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C5_LPDDR2_DQ_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_LPDDR2_DQS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_LPDDR2_ROW_WIDTH": [ { "value": "14", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_LPDDR2_BANK_WIDTH": [ { "value": "3", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_LPDDR2_CK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_LPDDR2_CKE_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_LPDDR2_CS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_LPDDR2_nCS_PER_RANK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_LPDDR2_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_LPDDR2_USE_CS_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_LPDDR2_USE_DM_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_LPDDR2_USE_ODT_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_LPDDR2_REG_CTRL": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C5_LPDDR2_DQS_CNT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_LPDDR2_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C5_DQS_CNT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C5_DDRX_ADDR_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_DDRX_nCK_PER_CLK": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_DDRX_DATA_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_DDR3_ADDR_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_DDR3_nCK_PER_CLK": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_DDR3_DATA_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_DDR2_ADDR_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_DDR2_nCK_PER_CLK": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_DDR2_DATA_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_LPDDR2_ADDR_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_LPDDR2_nCK_PER_CLK": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_LPDDR2_DATA_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_FREQ_HZ": [ { "value": "100.0", "resolve_type": "generated", "format": "float", "usage": "all" } ], + "C5_PHASE": [ { "value": "0.000", "resolve_type": "generated", "format": "float", "usage": "all" } ], + "C5_UI_EXTRA_CLOCKS": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C5_MMCM_VCO": [ { "value": "1200.0", "resolve_type": "generated", "format": "float", "usage": "all" } ], + "C5_MMCM_CLKOUT0_FREQ": [ { "value": "10.0", "resolve_type": "generated", "format": "float", "usage": "all" } ], + "C5_MMCM_CLKOUT1_FREQ": [ { "value": "10", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_MMCM_CLKOUT2_FREQ": [ { "value": "10", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_MMCM_CLKOUT3_FREQ": [ { "value": "10", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_MMCM_CLKOUT4_FREQ": [ { "value": "10", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_MMCM_CLKOUT0_EN": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C5_MMCM_CLKOUT2_EN": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C5_MMCM_CLKOUT1_EN": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C5_MMCM_CLKOUT3_EN": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C5_MMCM_CLKOUT4_EN": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C5_C_S_AXI_CTRL_ID_WIDTH": [ { "value": "4", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_C_S_AXI_CTRL_DATA_WIDTH": [ { "value": "32", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_C_S_AXI_CTRL_ADDR_WIDTH": [ { "value": "32", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_C_S_AXI_CTRL_MEM_SIZE": [ { "value": "1048576", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_C_S_AXI_ID_WIDTH": [ { "value": "4", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_C_S_AXI_DATA_WIDTH": [ { "value": "32", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_C_S_AXI_ADDR_WIDTH": [ { "value": "32", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_C_S_AXI_MEM_SIZE": [ { "value": "1048576", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_QDRIIP_NUM_DEVICES": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_QDRIIP_DATA_WIDTH": [ { "value": "18", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_QDRIIP_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_QDRIIP_BW_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_QDRIIP_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C5_QDRIIP_BURST_LEN": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_RLDII_NUM_DEVICES": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_RLDII_DATA_WIDTH": [ { "value": "18", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_RLDII_RLD_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_RLDII_QK_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_RLDII_CK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_RLDII_DK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_RLDII_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_RLDII_BANK_WIDTH": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_RLDII_QVLD_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_RLDII_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C5_RLDIII_NUM_DEVICES": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_RLDIII_DATA_WIDTH": [ { "value": "18", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_RLDIII_RLD_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_RLDIII_QK_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_RLDIII_CK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_RLDIII_DK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_RLDIII_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_RLDIII_BANK_WIDTH": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_RLDIII_QVLD_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_RLDIII_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C5_RLDX_CMD_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_RLDX_DATA_WIDTH": [ { "value": "18", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_RLDX_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_RLDX_BANK_WIDTH": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_RLDX_nCK_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_RLDX_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_RLDII_CMD_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_RLDII_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_RLDII_nCK_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_RLDIII_CMD_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_RLDIII_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_RLDIII_nCK_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C5_POLARITY": [ { "value": "ACTIVE_LOW", "resolve_type": "generated", "usage": "all" } ], + "C6_MEM_TYPE": [ { "value": "DDR3", "resolve_type": "generated", "usage": "all" } ], + "C6_IS_CLK_SHARED": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C6_SYSCLK_TYPE": [ { "value": "DIFF", "resolve_type": "generated", "usage": "all" } ], + "C6_USE_AXI": [ { "value": "0", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_ECC": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C6_DDR3_DQ_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_DDR3_DQS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_DDR3_ROW_WIDTH": [ { "value": "14", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_DDR3_BANK_WIDTH": [ { "value": "3", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_DDR3_CK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_DDR3_CKE_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_DDR3_CS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_DDR3_nCS_PER_RANK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_DDR3_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_DDR3_ODT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_DDR3_USE_CS_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_DDR3_USE_DM_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_DDR3_USE_ODT_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_DDR3_REG_CTRL": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C6_DDR3_DQS_CNT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_DDR3_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C6_DDR2_DQ_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_DDR2_DQS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_DDR2_ROW_WIDTH": [ { "value": "14", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_DDR2_BANK_WIDTH": [ { "value": "3", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_DDR2_CK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_DDR2_CKE_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_DDR2_CS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_DDR2_nCS_PER_RANK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_DDR2_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_DDR2_ODT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_DDR2_USE_CS_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_DDR2_USE_DM_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_DDR2_USE_ODT_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_DDR2_REG_CTRL": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C6_DDR2_DQS_CNT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_DDR2_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C6_LPDDR2_DQ_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_LPDDR2_DQS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_LPDDR2_ROW_WIDTH": [ { "value": "14", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_LPDDR2_BANK_WIDTH": [ { "value": "3", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_LPDDR2_CK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_LPDDR2_CKE_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_LPDDR2_CS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_LPDDR2_nCS_PER_RANK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_LPDDR2_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_LPDDR2_USE_CS_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_LPDDR2_USE_DM_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_LPDDR2_USE_ODT_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_LPDDR2_REG_CTRL": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C6_LPDDR2_DQS_CNT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_LPDDR2_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C6_DQS_CNT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C6_DDRX_ADDR_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_DDRX_nCK_PER_CLK": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_DDRX_DATA_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_DDR3_ADDR_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_DDR3_nCK_PER_CLK": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_DDR3_DATA_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_DDR2_ADDR_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_DDR2_nCK_PER_CLK": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_DDR2_DATA_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_LPDDR2_ADDR_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_LPDDR2_nCK_PER_CLK": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_LPDDR2_DATA_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_FREQ_HZ": [ { "value": "100.0", "resolve_type": "generated", "format": "float", "usage": "all" } ], + "C6_PHASE": [ { "value": "0.000", "resolve_type": "generated", "format": "float", "usage": "all" } ], + "C6_UI_EXTRA_CLOCKS": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C6_MMCM_VCO": [ { "value": "1200.0", "resolve_type": "generated", "format": "float", "usage": "all" } ], + "C6_MMCM_CLKOUT0_FREQ": [ { "value": "10.0", "resolve_type": "generated", "format": "float", "usage": "all" } ], + "C6_MMCM_CLKOUT1_FREQ": [ { "value": "10", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_MMCM_CLKOUT2_FREQ": [ { "value": "10", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_MMCM_CLKOUT3_FREQ": [ { "value": "10", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_MMCM_CLKOUT4_FREQ": [ { "value": "10", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_MMCM_CLKOUT0_EN": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C6_MMCM_CLKOUT2_EN": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C6_MMCM_CLKOUT1_EN": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C6_MMCM_CLKOUT3_EN": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C6_MMCM_CLKOUT4_EN": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C6_C_S_AXI_CTRL_ID_WIDTH": [ { "value": "4", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_C_S_AXI_CTRL_DATA_WIDTH": [ { "value": "32", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_C_S_AXI_CTRL_ADDR_WIDTH": [ { "value": "32", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_C_S_AXI_CTRL_MEM_SIZE": [ { "value": "1048576", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_C_S_AXI_ID_WIDTH": [ { "value": "4", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_C_S_AXI_DATA_WIDTH": [ { "value": "32", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_C_S_AXI_ADDR_WIDTH": [ { "value": "32", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_C_S_AXI_MEM_SIZE": [ { "value": "1048576", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_QDRIIP_NUM_DEVICES": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_QDRIIP_DATA_WIDTH": [ { "value": "18", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_QDRIIP_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_QDRIIP_BW_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_QDRIIP_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C6_QDRIIP_BURST_LEN": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_RLDII_NUM_DEVICES": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_RLDII_DATA_WIDTH": [ { "value": "18", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_RLDII_RLD_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_RLDII_QK_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_RLDII_CK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_RLDII_DK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_RLDII_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_RLDII_BANK_WIDTH": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_RLDII_QVLD_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_RLDII_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C6_RLDIII_NUM_DEVICES": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_RLDIII_DATA_WIDTH": [ { "value": "18", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_RLDIII_RLD_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_RLDIII_QK_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_RLDIII_CK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_RLDIII_DK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_RLDIII_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_RLDIII_BANK_WIDTH": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_RLDIII_QVLD_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_RLDIII_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C6_RLDX_CMD_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_RLDX_DATA_WIDTH": [ { "value": "18", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_RLDX_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_RLDX_BANK_WIDTH": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_RLDX_nCK_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_RLDX_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_RLDII_CMD_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_RLDII_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_RLDII_nCK_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_RLDIII_CMD_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_RLDIII_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_RLDIII_nCK_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C6_POLARITY": [ { "value": "ACTIVE_LOW", "resolve_type": "generated", "usage": "all" } ], + "C7_MEM_TYPE": [ { "value": "DDR3", "resolve_type": "generated", "usage": "all" } ], + "C7_IS_CLK_SHARED": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C7_SYSCLK_TYPE": [ { "value": "DIFF", "resolve_type": "generated", "usage": "all" } ], + "C7_USE_AXI": [ { "value": "0", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_ECC": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C7_DDR3_DQ_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_DDR3_DQS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_DDR3_ROW_WIDTH": [ { "value": "14", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_DDR3_BANK_WIDTH": [ { "value": "3", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_DDR3_CK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_DDR3_CKE_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_DDR3_CS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_DDR3_nCS_PER_RANK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_DDR3_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_DDR3_ODT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_DDR3_USE_CS_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_DDR3_USE_DM_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_DDR3_USE_ODT_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_DDR3_REG_CTRL": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C7_DDR3_DQS_CNT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_DDR3_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C7_DDR2_DQ_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_DDR2_DQS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_DDR2_ROW_WIDTH": [ { "value": "14", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_DDR2_BANK_WIDTH": [ { "value": "3", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_DDR2_CK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_DDR2_CKE_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_DDR2_CS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_DDR2_nCS_PER_RANK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_DDR2_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_DDR2_ODT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_DDR2_USE_CS_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_DDR2_USE_DM_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_DDR2_USE_ODT_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_DDR2_REG_CTRL": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C7_DDR2_DQS_CNT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_DDR2_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C7_LPDDR2_DQ_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_LPDDR2_DQS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_LPDDR2_ROW_WIDTH": [ { "value": "14", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_LPDDR2_BANK_WIDTH": [ { "value": "3", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_LPDDR2_CK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_LPDDR2_CKE_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_LPDDR2_CS_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_LPDDR2_nCS_PER_RANK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_LPDDR2_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_LPDDR2_USE_CS_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_LPDDR2_USE_DM_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_LPDDR2_USE_ODT_PORT": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_LPDDR2_REG_CTRL": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C7_LPDDR2_DQS_CNT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_LPDDR2_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C7_DQS_CNT_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C7_DDRX_ADDR_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_DDRX_nCK_PER_CLK": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_DDRX_DATA_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_DDR3_ADDR_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_DDR3_nCK_PER_CLK": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_DDR3_DATA_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_DDR2_ADDR_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_DDR2_nCK_PER_CLK": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_DDR2_DATA_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_LPDDR2_ADDR_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_LPDDR2_nCK_PER_CLK": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_LPDDR2_DATA_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_FREQ_HZ": [ { "value": "100.0", "resolve_type": "generated", "format": "float", "usage": "all" } ], + "C7_PHASE": [ { "value": "0.000", "resolve_type": "generated", "format": "float", "usage": "all" } ], + "C7_UI_EXTRA_CLOCKS": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C7_MMCM_VCO": [ { "value": "1200.0", "resolve_type": "generated", "format": "float", "usage": "all" } ], + "C7_MMCM_CLKOUT0_FREQ": [ { "value": "10.0", "resolve_type": "generated", "format": "float", "usage": "all" } ], + "C7_MMCM_CLKOUT1_FREQ": [ { "value": "10", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_MMCM_CLKOUT2_FREQ": [ { "value": "10", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_MMCM_CLKOUT3_FREQ": [ { "value": "10", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_MMCM_CLKOUT4_FREQ": [ { "value": "10", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_MMCM_CLKOUT0_EN": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C7_MMCM_CLKOUT2_EN": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C7_MMCM_CLKOUT1_EN": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C7_MMCM_CLKOUT3_EN": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C7_MMCM_CLKOUT4_EN": [ { "value": "FALSE", "resolve_type": "generated", "usage": "all" } ], + "C7_C_S_AXI_CTRL_ID_WIDTH": [ { "value": "4", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_C_S_AXI_CTRL_DATA_WIDTH": [ { "value": "32", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_C_S_AXI_CTRL_ADDR_WIDTH": [ { "value": "32", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_C_S_AXI_CTRL_MEM_SIZE": [ { "value": "1048576", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_C_S_AXI_ID_WIDTH": [ { "value": "4", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_C_S_AXI_DATA_WIDTH": [ { "value": "32", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_C_S_AXI_ADDR_WIDTH": [ { "value": "32", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_C_S_AXI_MEM_SIZE": [ { "value": "1048576", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_QDRIIP_NUM_DEVICES": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_QDRIIP_DATA_WIDTH": [ { "value": "18", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_QDRIIP_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_QDRIIP_BW_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_QDRIIP_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C7_QDRIIP_BURST_LEN": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_RLDII_NUM_DEVICES": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_RLDII_DATA_WIDTH": [ { "value": "18", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_RLDII_RLD_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_RLDII_QK_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_RLDII_CK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_RLDII_DK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_RLDII_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_RLDII_BANK_WIDTH": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_RLDII_QVLD_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_RLDII_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C7_RLDIII_NUM_DEVICES": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_RLDIII_DATA_WIDTH": [ { "value": "18", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_RLDIII_RLD_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_RLDIII_QK_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_RLDIII_CK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_RLDIII_DK_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_RLDIII_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_RLDIII_BANK_WIDTH": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_RLDIII_QVLD_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_RLDIII_DEBUG_PORT": [ { "value": "OFF", "resolve_type": "generated", "usage": "all" } ], + "C7_RLDX_CMD_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_RLDX_DATA_WIDTH": [ { "value": "18", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_RLDX_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_RLDX_BANK_WIDTH": [ { "value": "2", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_RLDX_nCK_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_RLDX_DM_WIDTH": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_RLDII_CMD_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_RLDII_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_RLDII_nCK_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_RLDIII_CMD_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_RLDIII_ADDR_WIDTH": [ { "value": "29", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_RLDIII_nCK_PER_CLK": [ { "value": "1", "resolve_type": "generated", "format": "long", "usage": "all" } ], + "C7_POLARITY": [ { "value": "ACTIVE_LOW", "resolve_type": "generated", "usage": "all" } ] + }, + "project_parameters": { + "ARCHITECTURE": [ { "value": "artix7" } ], + "BASE_BOARD_PART": [ { "value": "digilentinc.com:arty-a7-35:part0:1.0" } ], + "BOARD_CONNECTIONS": [ { "value": "" } ], + "DEVICE": [ { "value": "xc7a35ti" } ], + "NEXTGEN_VERSAL": [ { "value": "0" } ], + "PACKAGE": [ { "value": "csg324" } ], + "PREFHDL": [ { "value": "VERILOG" } ], + "SILICON_REVISION": [ { "value": "" } ], + "SIMULATOR_LANGUAGE": [ { "value": "MIXED" } ], + "SPEEDGRADE": [ { "value": "-1L" } ], + "STATIC_POWER": [ { "value": "" } ], + "TEMPERATURE_GRADE": [ { "value": "I" } ] + }, + "runtime_parameters": { + "IPCONTEXT": [ { "value": "IP_Flow" } ], + "IPREVISION": [ { "value": "1" } ], + "MANAGED": [ { "value": "TRUE" } ], + "OUTPUTDIR": [ { "value": "." } ], + "SELECTEDSIMMODEL": [ { "value": "" } ], + "SHAREDDIR": [ { "value": "." } ], + "SWVERSION": [ { "value": "2024.1" } ], + "SYNTHESISFLOW": [ { "value": "OUT_OF_CONTEXT" } ] + } + }, + "boundary": { + "ports": { + "sys_rst": [ { "direction": "in" } ], + "clk_ref_i": [ { "direction": "in", "display_name": "Clock P", "description": "Clock P" } ], + "ddr3_dq": [ { "direction": "inout", "size_left": "15", "size_right": "0", "display_name": "Data", "description": "Data" } ], + "ddr3_dqs_p": [ { "direction": "inout", "size_left": "1", "size_right": "0", "display_name": "Data Strobe", "description": "Data Strobe" } ], + "ddr3_dqs_n": [ { "direction": "inout", "size_left": "1", "size_right": "0", "display_name": "Data Strobe", "description": "Data Strobe" } ], + "ddr3_addr": [ { "direction": "out", "size_left": "13", "size_right": "0", "display_name": "Address", "description": "Address" } ], + "ddr3_ba": [ { "direction": "out", "size_left": "2", "size_right": "0", "display_name": "Bank Address", "description": "Bank Address" } ], + "ddr3_ras_n": [ { "direction": "out", "display_name": "row address strobe", "description": "row address strobe" } ], + "ddr3_cas_n": [ { "direction": "out", "display_name": "column address strobe", "description": "column address strobe" } ], + "ddr3_we_n": [ { "direction": "out", "display_name": "write enable", "description": "write enable" } ], + "ddr3_reset_n": [ { "direction": "out", "display_name": "reset to memory device", "description": "reset to memory device" } ], + "ddr3_ck_p": [ { "direction": "out", "size_left": "0", "size_right": "0", "display_name": "clock to memory device", "description": "clock to memory device" } ], + "ddr3_ck_n": [ { "direction": "out", "size_left": "0", "size_right": "0", "display_name": "clock to memory device", "description": "clock to memory device" } ], + "ddr3_cke": [ { "direction": "out", "size_left": "0", "size_right": "0", "display_name": "clock enable", "description": "clock enable" } ], + "ddr3_cs_n": [ { "direction": "out", "size_left": "0", "size_right": "0", "display_name": "chip select", "description": "chip select" } ], + "ddr3_dm": [ { "direction": "out", "size_left": "1", "size_right": "0", "display_name": "data mask", "description": "data mask" } ], + "ddr3_odt": [ { "direction": "out", "size_left": "0", "size_right": "0", "display_name": "on die termination", "description": "on die termination" } ], + "app_addr": [ { "direction": "in", "size_left": "7", "size_right": "0" } ], + "app_cmd": [ { "direction": "in", "size_left": "2", "size_right": "0" } ], + "app_en": [ { "direction": "in" } ], + "app_wdf_data": [ { "direction": "in", "size_left": "31", "size_right": "0" } ], + "app_wdf_end": [ { "direction": "in" } ], + "app_wdf_mask": [ { "direction": "in", "size_left": "3", "size_right": "0" } ], + "app_wdf_wren": [ { "direction": "in" } ], + "app_rd_data": [ { "direction": "out", "size_left": "31", "size_right": "0" } ], + "app_rd_data_end": [ { "direction": "out" } ], + "app_rd_data_valid": [ { "direction": "out" } ], + "app_rdy": [ { "direction": "out" } ], + "app_wdf_rdy": [ { "direction": "out" } ], + "app_sr_req": [ { "direction": "in" } ], + "app_sr_active": [ { "direction": "out" } ], + "app_ref_req": [ { "direction": "in" } ], + "app_ref_ack": [ { "direction": "out" } ], + "app_zq_req": [ { "direction": "in" } ], + "app_zq_ack": [ { "direction": "out" } ], + "ui_clk_sync_rst": [ { "direction": "out" } ], + "ui_clk": [ { "direction": "out" } ], + "sys_clk_i": [ { "direction": "in", "display_name": "Clock P", "description": "Clock P" } ], + "init_calib_complete": [ { "direction": "out" } ], + "aresetn": [ { "direction": "in" } ] + }, + "interfaces": { + "SYSTEM_RESET": { + "vlnv": "xilinx.com:signal:reset:1.0", + "abstraction_type": "xilinx.com:signal:reset_rtl:1.0", + "mode": "slave", + "parameters": { + "POLARITY": [ { "value": "ACTIVE_LOW", "resolve_type": "dependent", "usage": "all" } ], + "BOARD.ASSOCIATED_PARAM": [ { "value": "RESET_BOARD_INTERFACE", "value_src": "constant", "usage": "all" } ], + "INSERT_VIP": [ { "value": "0", "value_src": "user", "resolve_type": "user", "format": "long", "usage": "simulation.rtl", "is_ips_inferred": true, "is_static_object": false } ] + }, + "port_maps": { + "RST": [ { "physical_name": "sys_rst" } ] + } + }, + "CLK_REF_I": { + "vlnv": "xilinx.com:signal:clock:1.0", + "abstraction_type": "xilinx.com:signal:clock_rtl:1.0", + "mode": "slave", + "parameters": { + "FREQ_HZ": [ { "value": "100000000", "resolve_type": "generated", "format": "long", "is_ips_inferred": true, "is_static_object": false } ], + "FREQ_TOLERANCE_HZ": [ { "value": "0", "resolve_type": "generated", "format": "long", "is_ips_inferred": true, "is_static_object": false } ], + "PHASE": [ { "value": "0.000", "resolve_type": "generated", "format": "float", "is_ips_inferred": true, "is_static_object": false } ], + "CLK_DOMAIN": [ { "value": "", "resolve_type": "generated", "is_ips_inferred": true, "is_static_object": false } ], + "ASSOCIATED_BUSIF": [ { "value": "", "resolve_type": "generated", "is_ips_inferred": true, "is_static_object": false } ], + "ASSOCIATED_PORT": [ { "value": "", "resolve_type": "generated", "is_ips_inferred": true, "is_static_object": false } ], + "ASSOCIATED_RESET": [ { "value": "", "resolve_type": "generated", "is_ips_inferred": true, "is_static_object": false } ], + "INSERT_VIP": [ { "value": "0", "value_src": "user", "resolve_type": "user", "format": "long", "usage": "simulation.rtl", "is_ips_inferred": true, "is_static_object": false } ] + }, + "port_maps": { + "CLK": [ { "physical_name": "clk_ref_i" } ] + } + }, + "DDR3": { + "vlnv": "xilinx.com:interface:ddrx:1.0", + "abstraction_type": "xilinx.com:interface:ddrx_rtl:1.0", + "mode": "master", + "parameters": { + "CAN_DEBUG": [ { "value": "false", "resolve_type": "generated", "format": "bool", "is_ips_inferred": true, "is_static_object": false } ], + "TIMEPERIOD_PS": [ { "value": "1250", "resolve_type": "generated", "is_ips_inferred": true, "is_static_object": false } ], + "MEMORY_TYPE": [ { "value": "COMPONENTS", "resolve_type": "generated", "is_ips_inferred": true, "is_static_object": false } ], + "MEMORY_PART": [ { "value": "", "resolve_type": "generated", "is_ips_inferred": true, "is_static_object": false } ], + "DATA_WIDTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "is_ips_inferred": true, "is_static_object": false } ], + "CS_ENABLED": [ { "value": "true", "resolve_type": "generated", "format": "bool", "is_ips_inferred": true, "is_static_object": false } ], + "DATA_MASK_ENABLED": [ { "value": "true", "resolve_type": "generated", "format": "bool", "is_ips_inferred": true, "is_static_object": false } ], + "SLOT": [ { "value": "Single", "resolve_type": "generated", "is_ips_inferred": true, "is_static_object": false } ], + "CUSTOM_PARTS": [ { "value": "", "resolve_type": "generated", "is_ips_inferred": true, "is_static_object": false } ], + "MEM_ADDR_MAP": [ { "value": "ROW_COLUMN_BANK", "resolve_type": "generated", "is_ips_inferred": true, "is_static_object": false } ], + "BURST_LENGTH": [ { "value": "8", "resolve_type": "generated", "format": "long", "is_ips_inferred": true, "is_static_object": false } ], + "AXI_ARBITRATION_SCHEME": [ { "value": "TDM", "resolve_type": "generated", "is_ips_inferred": true, "is_static_object": false } ], + "CAS_LATENCY": [ { "value": "11", "resolve_type": "generated", "format": "long", "is_ips_inferred": true, "is_static_object": false } ], + "CAS_WRITE_LATENCY": [ { "value": "11", "resolve_type": "generated", "format": "long", "is_ips_inferred": true, "is_static_object": false } ] + }, + "port_maps": { + "DQ": [ { "physical_name": "ddr3_dq" } ], + "DQS_P": [ { "physical_name": "ddr3_dqs_p" } ], + "DQS_N": [ { "physical_name": "ddr3_dqs_n" } ], + "ADDR": [ { "physical_name": "ddr3_addr" } ], + "BA": [ { "physical_name": "ddr3_ba" } ], + "RAS_N": [ { "physical_name": "ddr3_ras_n" } ], + "CAS_N": [ { "physical_name": "ddr3_cas_n" } ], + "WE_N": [ { "physical_name": "ddr3_we_n" } ], + "RESET_N": [ { "physical_name": "ddr3_reset_n" } ], + "CK_P": [ { "physical_name": "ddr3_ck_p" } ], + "CK_N": [ { "physical_name": "ddr3_ck_n" } ], + "CKE": [ { "physical_name": "ddr3_cke" } ], + "CS_N": [ { "physical_name": "ddr3_cs_n" } ], + "DM": [ { "physical_name": "ddr3_dm" } ], + "ODT": [ { "physical_name": "ddr3_odt" } ] + } + }, + "RESET": { + "vlnv": "xilinx.com:signal:reset:1.0", + "abstraction_type": "xilinx.com:signal:reset_rtl:1.0", + "mode": "master", + "parameters": { + "POLARITY": [ { "value": "ACTIVE_HIGH", "value_src": "constant", "usage": "all" } ], + "INSERT_VIP": [ { "value": "0", "value_src": "user", "resolve_type": "user", "format": "long", "usage": "simulation.rtl", "is_ips_inferred": true, "is_static_object": false } ] + }, + "port_maps": { + "RST": [ { "physical_name": "ui_clk_sync_rst" } ] + } + }, + "DDR3_RESET": { + "vlnv": "xilinx.com:signal:reset:1.0", + "abstraction_type": "xilinx.com:signal:reset_rtl:1.0", + "mode": "master", + "parameters": { + "POLARITY": [ { "value": "ACTIVE_HIGH", "value_src": "constant", "usage": "all" } ], + "INSERT_VIP": [ { "value": "0", "value_src": "user", "resolve_type": "user", "format": "long", "usage": "simulation.rtl", "is_ips_inferred": true, "is_static_object": false } ] + } + }, + "DDR2_RESET": { + "vlnv": "xilinx.com:signal:reset:1.0", + "abstraction_type": "xilinx.com:signal:reset_rtl:1.0", + "mode": "master", + "parameters": { + "POLARITY": [ { "value": "ACTIVE_HIGH", "value_src": "constant", "usage": "all" } ], + "INSERT_VIP": [ { "value": "0", "value_src": "user", "resolve_type": "user", "format": "long", "usage": "simulation.rtl", "is_ips_inferred": true, "is_static_object": false } ] + } + }, + "LPDDR2_RESET": { + "vlnv": "xilinx.com:signal:reset:1.0", + "abstraction_type": "xilinx.com:signal:reset_rtl:1.0", + "mode": "master", + "parameters": { + "POLARITY": [ { "value": "ACTIVE_HIGH", "value_src": "constant", "usage": "all" } ], + "INSERT_VIP": [ { "value": "0", "value_src": "user", "resolve_type": "user", "format": "long", "usage": "simulation.rtl", "is_ips_inferred": true, "is_static_object": false } ] + } + }, + "QDRIIP_RESET": { + "vlnv": "xilinx.com:signal:reset:1.0", + "abstraction_type": "xilinx.com:signal:reset_rtl:1.0", + "mode": "master", + "parameters": { + "POLARITY": [ { "value": "ACTIVE_HIGH", "value_src": "constant", "usage": "all" } ], + "INSERT_VIP": [ { "value": "0", "value_src": "user", "resolve_type": "user", "format": "long", "usage": "simulation.rtl", "is_ips_inferred": true, "is_static_object": false } ] + } + }, + "RLDII_RESET": { + "vlnv": "xilinx.com:signal:reset:1.0", + "abstraction_type": "xilinx.com:signal:reset_rtl:1.0", + "mode": "master", + "parameters": { + "POLARITY": [ { "value": "ACTIVE_HIGH", "value_src": "constant", "usage": "all" } ], + "INSERT_VIP": [ { "value": "0", "value_src": "user", "resolve_type": "user", "format": "long", "usage": "simulation.rtl", "is_ips_inferred": true, "is_static_object": false } ] + } + }, + "RLDIII_RESET": { + "vlnv": "xilinx.com:signal:reset:1.0", + "abstraction_type": "xilinx.com:signal:reset_rtl:1.0", + "mode": "master", + "parameters": { + "POLARITY": [ { "value": "ACTIVE_HIGH", "value_src": "constant", "usage": "all" } ], + "INSERT_VIP": [ { "value": "0", "value_src": "user", "resolve_type": "user", "format": "long", "usage": "simulation.rtl", "is_ips_inferred": true, "is_static_object": false } ] + } + }, + "CLOCK": { + "vlnv": "xilinx.com:signal:clock:1.0", + "abstraction_type": "xilinx.com:signal:clock_rtl:1.0", + "mode": "master", + "parameters": { + "FREQ_HZ": [ { "value": "83333333", "resolve_type": "dependent", "format": "float", "usage": "all" } ], + "ASSOCIATED_BUSIF": [ { "value": "S_AXI:S_AXI_CTRL", "value_src": "constant", "usage": "all" } ], + "ASSOCIATED_RESET": [ { "value": "aresetn:ui_clk_sync_rst", "value_src": "constant", "usage": "all" } ], + "PHASE": [ { "value": "0", "resolve_type": "dependent", "format": "float", "usage": "all" } ], + "FREQ_TOLERANCE_HZ": [ { "value": "0", "resolve_type": "generated", "format": "long", "is_ips_inferred": true, "is_static_object": false } ], + "CLK_DOMAIN": [ { "value": "", "resolve_type": "generated", "is_ips_inferred": true, "is_static_object": false } ], + "ASSOCIATED_PORT": [ { "value": "", "resolve_type": "generated", "is_ips_inferred": true, "is_static_object": false } ], + "INSERT_VIP": [ { "value": "0", "value_src": "user", "resolve_type": "user", "format": "long", "usage": "simulation.rtl", "is_ips_inferred": true, "is_static_object": false } ] + }, + "port_maps": { + "CLK": [ { "physical_name": "ui_clk" } ] + } + }, + "MMCM_CLKOUT0": { + "vlnv": "xilinx.com:signal:clock:1.0", + "abstraction_type": "xilinx.com:signal:clock_rtl:1.0", + "mode": "master", + "parameters": { + "FREQ_HZ": [ { "value": "10", "resolve_type": "dependent", "format": "float", "usage": "all" } ], + "ASSOCIATED_ASYNC_RESET": [ { "value": "aresetn", "value_src": "constant", "usage": "all" } ], + "PHASE": [ { "value": "0", "resolve_type": "dependent", "format": "float", "usage": "all" } ], + "FREQ_TOLERANCE_HZ": [ { "value": "0", "resolve_type": "generated", "format": "long", "is_ips_inferred": true, "is_static_object": false } ], + "CLK_DOMAIN": [ { "value": "", "resolve_type": "generated", "is_ips_inferred": true, "is_static_object": false } ], + "ASSOCIATED_BUSIF": [ { "value": "", "resolve_type": "generated", "is_ips_inferred": true, "is_static_object": false } ], + "ASSOCIATED_PORT": [ { "value": "", "resolve_type": "generated", "is_ips_inferred": true, "is_static_object": false } ], + "ASSOCIATED_RESET": [ { "value": "", "resolve_type": "generated", "is_ips_inferred": true, "is_static_object": false } ], + "INSERT_VIP": [ { "value": "0", "value_src": "user", "resolve_type": "user", "format": "long", "usage": "simulation.rtl", "is_ips_inferred": true, "is_static_object": false } ] + } + }, + "MMCM_CLKOUT1": { + "vlnv": "xilinx.com:signal:clock:1.0", + "abstraction_type": "xilinx.com:signal:clock_rtl:1.0", + "mode": "master", + "parameters": { + "FREQ_HZ": [ { "value": "10", "resolve_type": "dependent", "format": "float", "usage": "all" } ], + "ASSOCIATED_ASYNC_RESET": [ { "value": "aresetn", "value_src": "constant", "usage": "all" } ], + "PHASE": [ { "value": "0", "resolve_type": "dependent", "format": "float", "usage": "all" } ], + "FREQ_TOLERANCE_HZ": [ { "value": "0", "resolve_type": "generated", "format": "long", "is_ips_inferred": true, "is_static_object": false } ], + "CLK_DOMAIN": [ { "value": "", "resolve_type": "generated", "is_ips_inferred": true, "is_static_object": false } ], + "ASSOCIATED_BUSIF": [ { "value": "", "resolve_type": "generated", "is_ips_inferred": true, "is_static_object": false } ], + "ASSOCIATED_PORT": [ { "value": "", "resolve_type": "generated", "is_ips_inferred": true, "is_static_object": false } ], + "ASSOCIATED_RESET": [ { "value": "", "resolve_type": "generated", "is_ips_inferred": true, "is_static_object": false } ], + "INSERT_VIP": [ { "value": "0", "value_src": "user", "resolve_type": "user", "format": "long", "usage": "simulation.rtl", "is_ips_inferred": true, "is_static_object": false } ] + } + }, + "MMCM_CLKOUT2": { + "vlnv": "xilinx.com:signal:clock:1.0", + "abstraction_type": "xilinx.com:signal:clock_rtl:1.0", + "mode": "master", + "parameters": { + "FREQ_HZ": [ { "value": "10", "resolve_type": "dependent", "format": "float", "usage": "all" } ], + "ASSOCIATED_ASYNC_RESET": [ { "value": "aresetn", "value_src": "constant", "usage": "all" } ], + "PHASE": [ { "value": "0", "resolve_type": "dependent", "format": "float", "usage": "all" } ], + "FREQ_TOLERANCE_HZ": [ { "value": "0", "resolve_type": "generated", "format": "long", "is_ips_inferred": true, "is_static_object": false } ], + "CLK_DOMAIN": [ { "value": "", "resolve_type": "generated", "is_ips_inferred": true, "is_static_object": false } ], + "ASSOCIATED_BUSIF": [ { "value": "", "resolve_type": "generated", "is_ips_inferred": true, "is_static_object": false } ], + "ASSOCIATED_PORT": [ { "value": "", "resolve_type": "generated", "is_ips_inferred": true, "is_static_object": false } ], + "ASSOCIATED_RESET": [ { "value": "", "resolve_type": "generated", "is_ips_inferred": true, "is_static_object": false } ], + "INSERT_VIP": [ { "value": "0", "value_src": "user", "resolve_type": "user", "format": "long", "usage": "simulation.rtl", "is_ips_inferred": true, "is_static_object": false } ] + } + }, + "MMCM_CLKOUT3": { + "vlnv": "xilinx.com:signal:clock:1.0", + "abstraction_type": "xilinx.com:signal:clock_rtl:1.0", + "mode": "master", + "parameters": { + "FREQ_HZ": [ { "value": "10", "resolve_type": "dependent", "format": "float", "usage": "all" } ], + "ASSOCIATED_ASYNC_RESET": [ { "value": "aresetn", "value_src": "constant", "usage": "all" } ], + "PHASE": [ { "value": "0", "resolve_type": "dependent", "format": "float", "usage": "all" } ], + "FREQ_TOLERANCE_HZ": [ { "value": "0", "resolve_type": "generated", "format": "long", "is_ips_inferred": true, "is_static_object": false } ], + "CLK_DOMAIN": [ { "value": "", "resolve_type": "generated", "is_ips_inferred": true, "is_static_object": false } ], + "ASSOCIATED_BUSIF": [ { "value": "", "resolve_type": "generated", "is_ips_inferred": true, "is_static_object": false } ], + "ASSOCIATED_PORT": [ { "value": "", "resolve_type": "generated", "is_ips_inferred": true, "is_static_object": false } ], + "ASSOCIATED_RESET": [ { "value": "", "resolve_type": "generated", "is_ips_inferred": true, "is_static_object": false } ], + "INSERT_VIP": [ { "value": "0", "value_src": "user", "resolve_type": "user", "format": "long", "usage": "simulation.rtl", "is_ips_inferred": true, "is_static_object": false } ] + } + }, + "MMCM_CLKOUT4": { + "vlnv": "xilinx.com:signal:clock:1.0", + "abstraction_type": "xilinx.com:signal:clock_rtl:1.0", + "mode": "master", + "parameters": { + "FREQ_HZ": [ { "value": "10", "resolve_type": "dependent", "format": "float", "usage": "all" } ], + "ASSOCIATED_ASYNC_RESET": [ { "value": "aresetn", "value_src": "constant", "usage": "all" } ], + "PHASE": [ { "value": "0", "resolve_type": "dependent", "format": "float", "usage": "all" } ], + "FREQ_TOLERANCE_HZ": [ { "value": "0", "resolve_type": "generated", "format": "long", "is_ips_inferred": true, "is_static_object": false } ], + "CLK_DOMAIN": [ { "value": "", "resolve_type": "generated", "is_ips_inferred": true, "is_static_object": false } ], + "ASSOCIATED_BUSIF": [ { "value": "", "resolve_type": "generated", "is_ips_inferred": true, "is_static_object": false } ], + "ASSOCIATED_PORT": [ { "value": "", "resolve_type": "generated", "is_ips_inferred": true, "is_static_object": false } ], + "ASSOCIATED_RESET": [ { "value": "", "resolve_type": "generated", "is_ips_inferred": true, "is_static_object": false } ], + "INSERT_VIP": [ { "value": "0", "value_src": "user", "resolve_type": "user", "format": "long", "usage": "simulation.rtl", "is_ips_inferred": true, "is_static_object": false } ] + } + }, + "SYS_CLK_I": { + "vlnv": "xilinx.com:signal:clock:1.0", + "abstraction_type": "xilinx.com:signal:clock_rtl:1.0", + "mode": "slave", + "parameters": { + "FREQ_HZ": [ { "value": "100000000", "resolve_type": "generated", "format": "long", "is_ips_inferred": true, "is_static_object": false } ], + "FREQ_TOLERANCE_HZ": [ { "value": "0", "resolve_type": "generated", "format": "long", "is_ips_inferred": true, "is_static_object": false } ], + "PHASE": [ { "value": "0.000", "resolve_type": "generated", "format": "float", "is_ips_inferred": true, "is_static_object": false } ], + "CLK_DOMAIN": [ { "value": "", "resolve_type": "generated", "is_ips_inferred": true, "is_static_object": false } ], + "ASSOCIATED_BUSIF": [ { "value": "", "resolve_type": "generated", "is_ips_inferred": true, "is_static_object": false } ], + "ASSOCIATED_PORT": [ { "value": "", "resolve_type": "generated", "is_ips_inferred": true, "is_static_object": false } ], + "ASSOCIATED_RESET": [ { "value": "", "resolve_type": "generated", "is_ips_inferred": true, "is_static_object": false } ], + "INSERT_VIP": [ { "value": "0", "value_src": "user", "resolve_type": "user", "format": "long", "usage": "simulation.rtl", "is_ips_inferred": true, "is_static_object": false } ] + }, + "port_maps": { + "CLK": [ { "physical_name": "sys_clk_i" } ] + } + }, + "ARESETN": { + "vlnv": "xilinx.com:signal:reset:1.0", + "abstraction_type": "xilinx.com:signal:reset_rtl:1.0", + "mode": "slave", + "parameters": { + "POLARITY": [ { "value": "ACTIVE_LOW", "value_src": "constant", "usage": "all" } ], + "INSERT_VIP": [ { "value": "0", "value_src": "user", "resolve_type": "user", "format": "long", "usage": "simulation.rtl", "is_ips_inferred": true, "is_static_object": false } ] + }, + "port_maps": { + "ARESETN": [ { "physical_name": "aresetn" } ] + } + }, + "C0_ARESETN": { + "vlnv": "xilinx.com:signal:reset:1.0", + "abstraction_type": "xilinx.com:signal:reset_rtl:1.0", + "mode": "slave", + "parameters": { + "POLARITY": [ { "value": "ACTIVE_LOW", "value_src": "constant", "usage": "all" } ], + "INSERT_VIP": [ { "value": "0", "value_src": "user", "resolve_type": "user", "format": "long", "usage": "simulation.rtl", "is_ips_inferred": true, "is_static_object": false } ] + } + }, + "C1_ARESETN": { + "vlnv": "xilinx.com:signal:reset:1.0", + "abstraction_type": "xilinx.com:signal:reset_rtl:1.0", + "mode": "slave", + "parameters": { + "POLARITY": [ { "value": "ACTIVE_LOW", "value_src": "constant", "usage": "all" } ], + "INSERT_VIP": [ { "value": "0", "value_src": "user", "resolve_type": "user", "format": "long", "usage": "simulation.rtl", "is_ips_inferred": true, "is_static_object": false } ] + } + }, + "C2_ARESETN": { + "vlnv": "xilinx.com:signal:reset:1.0", + "abstraction_type": "xilinx.com:signal:reset_rtl:1.0", + "mode": "slave", + "parameters": { + "POLARITY": [ { "value": "ACTIVE_LOW", "value_src": "constant", "usage": "all" } ], + "INSERT_VIP": [ { "value": "0", "value_src": "user", "resolve_type": "user", "format": "long", "usage": "simulation.rtl", "is_ips_inferred": true, "is_static_object": false } ] + } + }, + "C3_ARESETN": { + "vlnv": "xilinx.com:signal:reset:1.0", + "abstraction_type": "xilinx.com:signal:reset_rtl:1.0", + "mode": "slave", + "parameters": { + "POLARITY": [ { "value": "ACTIVE_LOW", "value_src": "constant", "usage": "all" } ], + "INSERT_VIP": [ { "value": "0", "value_src": "user", "resolve_type": "user", "format": "long", "usage": "simulation.rtl", "is_ips_inferred": true, "is_static_object": false } ] + } + }, + "C4_ARESETN": { + "vlnv": "xilinx.com:signal:reset:1.0", + "abstraction_type": "xilinx.com:signal:reset_rtl:1.0", + "mode": "slave", + "parameters": { + "POLARITY": [ { "value": "ACTIVE_LOW", "value_src": "constant", "usage": "all" } ], + "INSERT_VIP": [ { "value": "0", "value_src": "user", "resolve_type": "user", "format": "long", "usage": "simulation.rtl", "is_ips_inferred": true, "is_static_object": false } ] + } + }, + "C5_ARESETN": { + "vlnv": "xilinx.com:signal:reset:1.0", + "abstraction_type": "xilinx.com:signal:reset_rtl:1.0", + "mode": "slave", + "parameters": { + "POLARITY": [ { "value": "ACTIVE_LOW", "value_src": "constant", "usage": "all" } ], + "INSERT_VIP": [ { "value": "0", "value_src": "user", "resolve_type": "user", "format": "long", "usage": "simulation.rtl", "is_ips_inferred": true, "is_static_object": false } ] + } + }, + "C6_ARESETN": { + "vlnv": "xilinx.com:signal:reset:1.0", + "abstraction_type": "xilinx.com:signal:reset_rtl:1.0", + "mode": "slave", + "parameters": { + "POLARITY": [ { "value": "ACTIVE_LOW", "value_src": "constant", "usage": "all" } ], + "INSERT_VIP": [ { "value": "0", "value_src": "user", "resolve_type": "user", "format": "long", "usage": "simulation.rtl", "is_ips_inferred": true, "is_static_object": false } ] + } + }, + "C7_ARESETN": { + "vlnv": "xilinx.com:signal:reset:1.0", + "abstraction_type": "xilinx.com:signal:reset_rtl:1.0", + "mode": "slave", + "parameters": { + "POLARITY": [ { "value": "ACTIVE_LOW", "value_src": "constant", "usage": "all" } ], + "INSERT_VIP": [ { "value": "0", "value_src": "user", "resolve_type": "user", "format": "long", "usage": "simulation.rtl", "is_ips_inferred": true, "is_static_object": false } ] + } + } + } + } + } +} \ No newline at end of file diff --git a/rtl/arty-a7/tridoracpu.tcl b/rtl/arty-a7/tridoracpu.tcl index e18483e..46ab1d1 100644 --- a/rtl/arty-a7/tridoracpu.tcl +++ b/rtl/arty-a7/tridoracpu.tcl @@ -15,56 +15,15 @@ # run results please launch the synthesis/implementation runs as needed. # #***************************************************************************************** -# NOTE: In order to use this script for source control purposes, please make sure that the -# following files are added to the source control system:- -# -# 1. This project restoration tcl script (tridoracpu.tcl) that was generated. -# -# 2. The following source(s) files that were local or imported into the original project. -# (Please see the '$orig_proj_dir' and '$origin_dir' variable setting below at the start of the script) -# -# "C:/Users/sebastian/develop/fpga/tridoracpu/tridoracpu.srcs/sources_1/new/cpuclk.v" -# "C:/Users/sebastian/develop/fpga/tridoracpu/tridoracpu.srcs/sources_1/new/display_clock.v" -# "C:/Users/sebastian/develop/fpga/tridoracpu/tridoracpu.srcs/sources_1/new/mem.v" -# "C:/Users/sebastian/develop/fpga/tridoracpu/tridoracpu.srcs/sources_1/new/stack.v" -# "C:/Users/sebastian/develop/fpga/tridoracpu/tridoracpu.srcs/sources_1/new/stackcpu.v" -# "C:/Users/sebastian/develop/fpga/tridoracpu/tridoracpu.srcs/sources_1/new/vgafb.v" -# "C:/Users/sebastian/develop/fpga/tridoracpu/tridoracpu.srcs/sources_1/new/top.v" -# "C:/Users/sebastian/develop/fpga/tridoracpu/tridoracpu.srcs/sources_1/new/testbench.v" -# "C:/Users/sebastian/develop/fpga/tridoracpu/rom.mem" -# "C:/Users/sebastian/develop/fpga/tridoracpu/tridoracpu.srcs/sources_1/ip/mig_dram_0/mig_a.prj" -# "C:/Users/sebastian/develop/fpga/tridoracpu/tridoracpu.srcs/sources_1/ip/mig_dram_0/mig_b.prj" -# "C:/Users/sebastian/develop/fpga/tridoracpu/tridoracpu.srcs/sources_1/new/dram_bridge.v" -# "C:/Users/sebastian/develop/fpga/tridoracpu/tridoracpu.srcs/sources_1/new/sdspi.v" -# "C:/Users/sebastian/develop/fpga/tridoracpu/tridoracpu.srcs/sources_1/new/bram_tdp.v" -# "C:/Users/sebastian/develop/fpga/tridoracpu/tridoracpu.srcs/sources_1/new/palette.v" -# "C:/Users/sebastian/develop/fpga/tridoracpu/tridoracpu.srcs/sources_1/new/irqctrl.v" -# "C:/Users/sebastian/develop/fpga/tridoracpu/tridoracpu.srcs/sources_1/new/fifo.v" -# "C:/Users/sebastian/develop/fpga/tridoracpu/tridoracpu.srcs/sources_1/new/fifo_testbench.v" -# "C:/Users/sebastian/develop/fpga/tridoracpu/tridoracpu.srcs/sources_1/new/sdspi_testbench.v" -# "C:/Users/sebastian/develop/fpga/tridoracpu/tridoracpu.srcs/sources_1/ip/mig_dram_0/mig_dram_0.xci" -# "C:/Users/sebastian/develop/fpga/tridoracpu/tridoracpu.srcs/sim_1/new/uart_tb.v" -# "C:/Users/sebastian/develop/fpga/tridoracpu/testbench_behav1.wcfg" -# "C:/Users/sebastian/develop/fpga/tridoracpu/tridoracpu.srcs/sources_1/new/fifo.v" -# "C:/Users/sebastian/develop/fpga/tridoracpu/tridoracpu.srcs/sources_1/new/fifo_testbench.v" -# "C:/Users/sebastian/develop/fpga/tridoracpu/sdspi_testbench_behav.wcfg" -# -# 3. The following remote source files that were added to the original project:- -# -# "C:/Users/sebastian/develop/fpga/tridoracpu/tridoracpu.srcs/sources_1/imports/verilog/uart.v" -# "C:/Users/sebastian/develop/fpga/tridoracpu/tridoracpu.srcs/constrs_1/imports/fpga/Arty-A7-35-Master.xdc" -# -#***************************************************************************************** -#xhub::refresh_catalog [xhub::get_xstores xilinx_board_store] +# uncomment next two statements if you have never initialized the Xilinx Board Store # this will take quite some time +#xhub::refresh_catalog [xhub::get_xstores xilinx_board_store] #xhub::install [xhub::get_xitems] -# Set the reference directory for source file relative paths (by default the value is script directory path) -set origin_dir "C:/Users/sebastian/develop/Tridora/rtl" +# Set the reference directory for source file relative paths +set origin_dir "change_this_to_your_rtl_directory" -# Oh come on, Xilinx, why? -#set xilinx_board_store_dir "../../../../AppData/Roaming/Xilinx/Vivado/2020.1/xhub/board_store/xilinx_board_store" set xilinx_board_store_dir [get_property LOCAL_ROOT_DIR [xhub::get_xstores xilinx_board_store]] set_param board.repoPaths [get_property LOCAL_ROOT_DIR [xhub::get_xstores xilinx_board_store]]