272 lines
17 KiB
Text
272 lines
17 KiB
Text
0 (kaute)
|
|
1
|
|
2 'ss:Sheet var
|
|
3
|
|
4 :ss:rows (-n) @ss:Sheet fetch ;
|
|
5 :ss:cols (-n) @ss:Sheet n:inc fetch ;
|
|
6 :ss:load (a-) !ss:Sheet ;
|
|
7 :ss:size (-n) ss:rows ss:cols n:mul ;
|
|
8 :ss:new (rc-a) here !ss:Sheet swap comma comma
|
|
9 ss:size #2 n:mul [ #0 comma ] times
|
|
10 @ss:Sheet ;
|
|
11 :ss:create (rcs-) d:create ss:new drop ;
|
|
12 :ss:offset (rc-n) swap ss:cols n:mul n:add ;
|
|
13 :ss:data (rc-a) ss:offset @ss:Sheet n:add #2 n:add ;
|
|
14 :ss:types (rc-a) ss:data ss:size n:add ;
|
|
15
|
|
save next new
|
|
0 (kaute)
|
|
1
|
|
2 :ss:store-n (nrc-) dup-pair [ [ ss:data store ] dip ] dip
|
|
3 ss:types #0 swap store ;
|
|
4 :ss:store-s (src-) dup-pair
|
|
5 [ [ ss:data &s:keep dip store ] dip ] dip
|
|
6 ss:types #1 swap store ;
|
|
7 :ss:store-a (nrc-) dup-pair [ [ ss:data store ] dip ] dip
|
|
8 ss:types #2 swap store ;
|
|
9
|
|
10 :ss:fetch (arc-vt) ss:data &fetch sip ss:size n:add fetch ;
|
|
11
|
|
12 :ss:action (rc-nt) ss:fetch #2 eq?
|
|
13 [ call ] [ drop #0 #0 ] choose ;
|
|
14
|
|
15
|
|
save next new
|
|
0 (kaute)
|
|
1
|
|
2 :~name (vr-vrs) over I n:to-s s:append ;
|
|
3 :~define (r-r) &dtc compile:call
|
|
4 &internal:lit comma
|
|
5 dup comma
|
|
6 &internal:lit comma
|
|
7 I comma
|
|
8 #0 comma ;
|
|
9
|
|
10
|
|
11 :ss:make-fields (rcv-)
|
|
12 '_ [ #0 s:store ] sip roll
|
|
13 [ ~name d:create ~define ] indexed-times drop-pair ;
|
|
14
|
|
15
|
|
save next new
|
|
0 (kaute)
|
|
1
|
|
2 #0 #5 $A ss:make-fields #1 #5 $B ss:make-fields
|
|
3 #2 #5 $C ss:make-fields #3 #5 $D ss:make-fields
|
|
4 #4 #5 $E ss:make-fields #5 #5 $F ss:make-fields
|
|
5 #6 #5 $G ss:make-fields #7 #5 $H ss:make-fields
|
|
6 #8 #5 $I ss:make-fields #9 #5 $J ss:make-fields
|
|
7 #10 #5 $K ss:make-fields #11 #5 $L ss:make-fields
|
|
8 #12 #5 $M ss:make-fields #13 #5 $N ss:make-fields
|
|
9 #14 #5 $O ss:make-fields
|
|
10
|
|
11 . Quick fetches to guarantee return type validity
|
|
12
|
|
13 :ss:fetch-n (rc-n) ss:fetch n:-zero? [ drop #0 ] if ;
|
|
14 :ss:fetch-s (rc-s) ss:fetch #1 -eq? [ drop '_ ] if ;
|
|
15 :ss:fetch-a (rc-a) ss:fetch #2 -eq? [ drop [ ] ] if ;
|
|
save next new
|
|
0 (kaute)
|
|
1
|
|
2 :ss:NUMBER #0 ;
|
|
3 :ss:STRING #1 ;
|
|
4 :ss:ACTION #2 ;
|
|
5
|
|
6
|
|
7
|
|
8
|
|
9
|
|
10
|
|
11
|
|
12
|
|
13
|
|
14
|
|
15
|
|
save next new
|
|
0
|
|
1
|
|
2
|
|
3
|
|
4
|
|
5
|
|
6
|
|
7
|
|
8
|
|
9
|
|
10
|
|
11
|
|
12
|
|
13
|
|
14
|
|
15
|
|
save next new
|
|
0 kaute : a headless spreadsheet : overview
|
|
1
|
|
2 The kaute vocabulary provides support for creating and working
|
|
3 with data stored in a spreadsheet format. It primarily provides
|
|
4 functionality, not presentation.
|
|
5
|
|
6
|
|
7
|
|
8
|
|
9
|
|
10
|
|
11
|
|
12
|
|
13
|
|
14
|
|
15
|
|
save next new
|
|
0 kaute : a headless spreadsheet : data structure
|
|
1
|
|
2 In memory, a sheet is structured as:
|
|
3
|
|
4 rows
|
|
5 columns
|
|
6 ... ( rows cells * ) ... data
|
|
7 ... ( rows cells * ) ... types
|
|
8
|
|
9
|
|
10
|
|
11
|
|
12
|
|
13
|
|
14
|
|
15
|
|
save next new
|
|
0 kaute : a headless spreadsheet : data types
|
|
1
|
|
2 # Types
|
|
3
|
|
4 Kaute currently supports three types of data in a cell:
|
|
5
|
|
6 - numbers
|
|
7 - pointers to strings
|
|
8 - pointers to actions
|
|
9
|
|
10
|
|
11
|
|
12
|
|
13
|
|
14
|
|
15
|
|
save next new
|
|
0 kaute : a headless spreadsheet : actions
|
|
1
|
|
2 # Actions
|
|
3
|
|
4 Action cells are written as quotes, which return a value & type
|
|
5 pair. An example might look like:
|
|
6
|
|
7 [ A1 ss:fetch-n A2 ss:fetch-n n:mul ss:NUMBER ]
|
|
8
|
|
9
|
|
10
|
|
11
|
|
12
|
|
13
|
|
14
|
|
15
|
|
save next new
|
|
0 kaute : a headless spreadsheet : strings
|
|
1
|
|
2
|
|
3
|
|
4
|
|
5
|
|
6
|
|
7
|
|
8
|
|
9
|
|
10
|
|
11
|
|
12
|
|
13
|
|
14
|
|
15
|
|
save next new
|
|
0 kaute : a headless spreadsheet : numbers
|
|
1
|
|
2 Most cells contain numbers. These are just standard numeric
|
|
3 values, and can be in any format that fits in a cell. I mostly
|
|
4 use simple integers, but do sometimes make use of scaled values.
|
|
5
|
|
6 It might be of interest to expand this, to separate out the use
|
|
7 of integers, scaled values, and dusk's fixed & floating point
|
|
8 values. I'm not going to work on this for now (May 2024).
|
|
9
|
|
10
|
|
11
|
|
12
|
|
13
|
|
14
|
|
15
|
|
save next new
|
|
0
|
|
1
|
|
2
|
|
3
|
|
4
|
|
5
|
|
6
|
|
7
|
|
8
|
|
9
|
|
10
|
|
11
|
|
12
|
|
13
|
|
14
|
|
15
|
|
save next new
|
|
0
|
|
1
|
|
2
|
|
3
|
|
4
|
|
5
|
|
6
|
|
7
|
|
8
|
|
9
|
|
10
|
|
11
|
|
12
|
|
13
|
|
14
|
|
15
|
|
save next new
|
|
0
|
|
1
|
|
2
|
|
3
|
|
4
|
|
5
|
|
6
|
|
7
|
|
8
|
|
9
|
|
10
|
|
11
|
|
12
|
|
13
|
|
14
|
|
15
|
|
save next new
|
|
0 (LOAD:kaute)
|
|
1
|
|
2 '(kaute) needs
|
|
3
|
|
4
|
|
5
|
|
6
|
|
7
|
|
8
|
|
9
|
|
10
|
|
11
|
|
12
|
|
13
|
|
14
|
|
15
|
|
save next new
|