KitCreator
Check-in [878ff79575]
Login
HomeDownloadsSource CodeTicketsWiki
Overview
Comment:Updated all references to the KitDLL VFS to be "CVFS"
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | merge-kitdll-kitsh-common
Files: files | file ages | folders
SHA1: 878ff79575765c40fc8ee67803903bfa75772307
User & Date: rkeene on 2011-05-24 06:05:19
Other Links: branch diff | manifest | tags
Context
2011-05-26
15:51
Updated to remove stub Tclkits created for bootstrapping purposes check-in: 44d0148003 user: rkeene tags: merge-kitdll-kitsh-common
2011-05-24
06:05
Updated all references to the KitDLL VFS to be "CVFS" check-in: 878ff79575 user: rkeene tags: merge-kitdll-kitsh-common
2011-05-23
21:10
Corrected typo check-in: 58e2899b04 user: rkeene tags: merge-kitdll-kitsh-common
Changes
Hide Diffs Side-by-Side Diffs Ignore Whitespace Patch

Modified kitsh/buildsrc/kitsh-0.0/Makefile.common.in from [6640ec3deb] to [537f4f602e].

︙
13
14
15
16
17
18
19
20
21
22



23
24
25
26


27
28
29
30
31
32
33

13
14
15
16
17
18
19



20
21
22
23
24


25
26
27
28
29
30
31
32
33








-
-
-
+
+
+


-
-
+
+








LDRUNPATH = @LDRUNPATH@
EXTRA_KIT_DEPS = @EXTRA_KIT_DEPS@
EXTRA_VFS_OBJS = @EXTRA_VFS_OBJS@
TCLSH_NATIVE = tclsh

# Build targets
## VFS Build
vfs_kitdll_data_tcl.o: vfs_kitdll_data_tcl.c
vfs_kitdll_data_tcl.c: dir2c.tcl starpack.vfs vfs_kitdll_data.c
	"$(TCLSH_NATIVE)" dir2c.tcl tcl starpack.vfs > vfs_kitdll_data_tcl.c
cvfs_data_tcl.o: cvfs_data_tcl.c
cvfs_data_tcl.c: dir2c.tcl starpack.vfs cvfs_data.c
	"$(TCLSH_NATIVE)" dir2c.tcl tcl starpack.vfs > cvfs_data_tcl.c

## Tcl scripts that need to be converted to C headers
vfs_kitdll.tcl.h: vfs_kitdll.tcl
	"$(TCLSH_NATIVE)" ./stringify.tcl vfs_kitdll.tcl > vfs_kitdll.tcl.h
cvfs.tcl.h: cvfs.tcl
	"$(TCLSH_NATIVE)" ./stringify.tcl cvfs.tcl > cvfs.tcl.h

boot.tcl.h: boot.tcl
	"$(TCLSH_NATIVE)" ./stringify.tcl boot.tcl > boot.tcl.h

zipvfs.tcl.h: zipvfs.tcl
	"$(TCLSH_NATIVE)" ./stringify.tcl zipvfs.tcl > zipvfs.tcl.h
︙
42
43
44
45
46
47
48
49
50


51
52
53
54
55
56
57
58
59

60
61
62
63
64

42
43
44
45
46
47
48


49
50
51
52
53
54
55
56
57

58
59
60
61
62
63
64








-
-
+
+







-

+






	$(RC) -o kit.res.o $(CPPFLAGS) kit.rc

# Cleanup routines
clean:
	rm -f kit kit.res.o
	rm -f libtclkit@KITDLL_LIB_VERSION@.@SHOBJEXT@
	rm -f $(OBJS) $(EXTRA_OBJS) $(EXTRA_VFS_OBJS)
	rm -f vfs_kitdll_data_tcl.c
	rm -f vfs_kitdll.tcl.h
	rm -f cvfs_data_tcl.c cvfs_data_tcl.o
	rm -f cvfs.tcl.h
	rm -f tclsh.o tclsh tclsh.exe
	rm -f wish.o wish wish.exe

distclean: clean
	rm -f Makefile Makefile.in Makefile.common
	rm -f config.status config.log
	rm -f *~
	rm -rf autom4te.cache
	rm -rf starpack.vfs
	rm -rf autom4te.cache

mrproper: distclean
	rm -f configure config.h boot.tcl.h zipvfs.tcl.h

.PHONY: all clean distclean mrproper

Modified kitsh/buildsrc/kitsh-0.0/boot.tcl from [29ebce96a4] to [19424b6588].

︙
70
71
72
73
74
75
76
77

78
79
80
81
82
83
84

85
86
87
88
89
90
91

70
71
72
73
74
75
76

77
78
79
80
81
82
83

84
85
86
87
88
89
90
91








-
+






-
+








				}

				seek $::tclKitStorage_fd 0
				set vfsHandler [list ::vfs::zip::handler $::tclKitStorage_fd]
				unset ::tclKitStorage_fd
			}
			"cvfs" {
				set vfsHandler [list ::vfs::kitdll::vfshandler tcl]
				set vfsHandler [list ::vfs::cvfs::vfshandler tcl]

				# Load these, the original Tclkit does so it should be safe.
				foreach vfsfile [list vfsUtils vfslib] {
					unset -nocomplain s

					catch {
						set s [::vfs::kitdll::data::getData tcl "lib/vfs/${vfsfile}.tcl"]
						set s [::vfs::cvfs::data::getData tcl "lib/vfs/${vfsfile}.tcl"]
					}

					if {![info exists s]} {
						continue
					}

					uplevel #0 $s
︙

Modified kitsh/buildsrc/kitsh-0.0/configure.ac from [501466d9c8] to [20795b4d45].

︙
179
180
181
182
183
184
185
186

187
188
189
190


191
192
193
194
195
196
197

179
180
181
182
183
184
185

186
187
188


189
190
191
192
193
194
195
196
197








-
+


-
-
+
+








		dnl Add appropriate dependencies
		EXTRA_KIT_DEPS="zipvfs.tcl.h"
	],
	cvfs, [
		AC_DEFINE([KIT_STORAGE_CVFS], [1], [Define if you are going to use C-VFS for kit storage])

		dnl Define that C-VFS should be make [load]-able
		AC_DEFINE([KITDLL_MAKE_LOADABLE], [1], [Specify that the C-VFS should be able to be loaded])
		AC_DEFINE([CVFS_MAKE_LOADABLE], [1], [Specify that the C-VFS should be able to be loaded])

		dnl Add appropriate dependencies
		EXTRA_KIT_DEPS="vfs_kitdll.tcl.h"
		EXTRA_VFS_OBJS="${EXTRA_VFS_OBJS} vfs_kitdll_data_tcl.o"
		EXTRA_KIT_DEPS="cvfs.tcl.h"
		EXTRA_VFS_OBJS="${EXTRA_VFS_OBJS} cvfs_data_tcl.o"
	]
)

AC_SUBST(EXTRA_KIT_DEPS)

dnl Put correct Makefile template in place
rm -f Makefile.in
︙

Renamed and modified kitsh/buildsrc/kitsh-0.0/vfs_kitdll.tcl [662da588b0] to kitsh/buildsrc/kitsh-0.0/cvfs.tcl [20e6e11465]. 

1
2
3
4
5

6
7
8
9


10
11

12
13
14
15

16
17
18
19
20
21
22


23
24
25

26
27
28
29
30
31

32
33
34

35
36
37
38
39
40

41
42
43

44
45
46
47
48
49
50
51

52
53

54
55
56
57
58

59
60

61
62
63
64
65
66
67

68
69
70
71
72


73
74
75
76
77
78


79
80
81
82

83
84
85
86
87
88
89
90
91
92


93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

111
112
113
114
115
116
117

118
119
120
121
122
123


124
125
126
127
128
129
130

1
2
3
4

5
6
7


8
9
10

11
12
13
14

15
16
17
18
19
20


21
22
23
24

25
26
27
28
29
30

31
32
33

34
35
36
37
38
39

40
41
42

43
44
45
46
47
48
49
50

51
52

53
54
55
56
57

58
59

60
61
62
63
64
65
66

67
68
69
70


71
72
73
74
75
76


77
78
79
80
81

82
83
84
85
86
87
88
89
90


91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

110
111
112
113
114
115
116

117
118
119
120
121


122
123
124
125
126
127
128
129
130





-
+


-
-
+
+

-
+



-
+





-
-
+
+


-
+





-
+


-
+





-
+


-
+







-
+

-
+




-
+

-
+






-
+



-
-
+
+




-
-
+
+



-
+








-
-
+
+

















-
+






-
+




-
-
+
+








#! /usr/bin/env tcl

package require vfs

namespace eval ::vfs::kitdll {}
namespace eval ::vfs::cvfs {}

# Convience functions
proc ::vfs::kitdll::Mount {hashkey local} {
	vfs::filesystem mount $local [list ::vfs::kitdll::vfshandler $hashkey]
proc ::vfs::cvfs::Mount {hashkey local} {
	vfs::filesystem mount $local [list ::vfs::cvfs::vfshandler $hashkey]
	catch {
		vfs::RegisterMount $local [list ::vfs::kitdll::Unmount]
		vfs::RegisterMount $local [list ::vfs::cvfs::Unmount]
	}
}

proc ::vfs::kitdll::Unmount {local} {
proc ::vfs::cvfs::Unmount {local} {
	vfs::filesystem unmount $local
}

# Implementation
## I/O Handlers (pass to appropriate hashkey)
namespace eval ::vfs::kitdll::data {}
proc ::vfs::kitdll::data::getChildren args {
namespace eval ::vfs::cvfs::data {}
proc ::vfs::cvfs::data::getChildren args {
	set hashkey [lindex $args 0]

	set cmd "::vfs::kitdll::data::${hashkey}::getChildren"
	set cmd "::vfs::cvfs::data::${hashkey}::getChildren"
	set cmd [linsert $args 0 $cmd]

	eval $cmd
}

proc ::vfs::kitdll::data::getMetadata args {
proc ::vfs::cvfs::data::getMetadata args {
	set hashkey [lindex $args 0]

	set cmd "::vfs::kitdll::data::${hashkey}::getMetadata"
	set cmd "::vfs::cvfs::data::${hashkey}::getMetadata"
	set cmd [linsert $args 0 $cmd]

	eval $cmd
}

proc ::vfs::kitdll::data::getData args {
proc ::vfs::cvfs::data::getData args {
	set hashkey [lindex $args 0]

	set cmd "::vfs::kitdll::data::${hashkey}::getData"
	set cmd "::vfs::cvfs::data::${hashkey}::getData"
	set cmd [linsert $args 0 $cmd]

	eval $cmd
}

## VFS and Chan I/O
### Dispatchers
proc ::vfs::kitdll::vfshandler {hashkey subcmd args} {
proc ::vfs::cvfs::vfshandler {hashkey subcmd args} {
	set cmd $args
	set cmd [linsert $cmd 0 "::vfs::kitdll::vfsop_${subcmd}" $hashkey]
	set cmd [linsert $cmd 0 "::vfs::cvfs::vfsop_${subcmd}" $hashkey]

	return [eval $cmd]
}

proc ::vfs::kitdll::chanhandler {hashkey subcmd args} {
proc ::vfs::cvfs::chanhandler {hashkey subcmd args} {
	set cmd $args
	set cmd [linsert $cmd 0 "::vfs::kitdll::chanop_${subcmd}" $hashkey]
	set cmd [linsert $cmd 0 "::vfs::cvfs::chanop_${subcmd}" $hashkey]

	return [eval $cmd]
}

### Actual handlers
#### Channel operation handlers
proc ::vfs::kitdll::chanop_initialize {hashkey chanId mode} {
proc ::vfs::cvfs::chanop_initialize {hashkey chanId mode} {
	return [list initialize finalize watch read seek]
}

proc ::vfs::kitdll::chanop_finalize {hashkey chanId} {
	unset -nocomplain ::vfs::kitdll::chandata([list $hashkey $chanId])
proc ::vfs::cvfs::chanop_finalize {hashkey chanId} {
	unset -nocomplain ::vfs::cvfs::chandata([list $hashkey $chanId])

	return
}

proc ::vfs::kitdll::chanop_watch {hashkey chanId eventSpec} {
	array set chaninfo $::vfs::kitdll::chandata([list $hashkey $chanId])
proc ::vfs::cvfs::chanop_watch {hashkey chanId eventSpec} {
	array set chaninfo $::vfs::cvfs::chandata([list $hashkey $chanId])

	set chaninfo(watching) $eventSpec

	set ::vfs::kitdll::chandata([list $hashkey $chanId]) [array get chaninfo]
	set ::vfs::cvfs::chandata([list $hashkey $chanId]) [array get chaninfo]

	if {[lsearch -exact $chaninfo(watching) "read"] != -1} {
		after 0 [list catch "chan postevent $chanId [list {read}]"]
	}

	return
}

proc ::vfs::kitdll::chanop_read {hashkey chanId bytes} {
	array set chaninfo $::vfs::kitdll::chandata([list $hashkey $chanId])
proc ::vfs::cvfs::chanop_read {hashkey chanId bytes} {
	array set chaninfo $::vfs::cvfs::chandata([list $hashkey $chanId])

	set pos $chaninfo(pos)
	set len $chaninfo(len)

	if {[lsearch -exact $chaninfo(watching) "read"] != -1} {
		after 0 [list catch "chan postevent $chanId [list {read}]"]
	}

	if {$pos == $len} {
		return ""
	}

	set end [expr {$pos + $bytes}]
	if {$end > $len} {
		set end $len
	}

	set data [::vfs::kitdll::data::getData $hashkey $chaninfo(file) $pos $end]
	set data [::vfs::cvfs::data::getData $hashkey $chaninfo(file) $pos $end]

	set dataLen [string length $data]
	incr pos $dataLen

	set chaninfo(pos) $pos

	set ::vfs::kitdll::chandata([list $hashkey $chanId]) [array get chaninfo]
	set ::vfs::cvfs::chandata([list $hashkey $chanId]) [array get chaninfo]

	return $data
}

proc ::vfs::kitdll::chanop_seek {hashkey chanId offset origin} {
	array set chaninfo $::vfs::kitdll::chandata([list $hashkey $chanId])
proc ::vfs::cvfs::chanop_seek {hashkey chanId offset origin} {
	array set chaninfo $::vfs::cvfs::chandata([list $hashkey $chanId])

	set pos $chaninfo(pos)
	set len $chaninfo(len)

	switch -- $origin {
		"start" - "0" {
			set pos $offset
︙
142
143
144
145
146
147
148
149

150
151
152
153
154
155

156
157

158
159
160
161
162
163
164
165
166
167
168


169
170
171
172
173
174
175
176
177

178
179
180
181

182
183
184
185
186
187
188
189
190
191

192
193
194
195
196
197
198
199
200
201
202
203

204
205
206
207
208
209
210

142
143
144
145
146
147
148

149
150
151
152
153
154

155
156

157
158
159
160
161
162
163
164
165
166


167
168
169
170
171
172
173
174
175
176

177
178
179
180

181
182
183
184
185
186
187
188
189
190

191
192
193
194
195
196
197
198
199
200
201
202

203
204
205
206
207
208
209
210








-
+





-
+

-
+









-
-
+
+








-
+



-
+









-
+











-
+








	}

	if {$pos > $len} {
		set pos $len
	}

	set chaninfo(pos) $pos
	set ::vfs::kitdll::chandata([list $hashkey $chanId]) [array get chaninfo]
	set ::vfs::cvfs::chandata([list $hashkey $chanId]) [array get chaninfo]

	return $pos
}

#### VFS operation handlers
proc ::vfs::kitdll::vfsop_stat {hashkey root relative actualpath} {
proc ::vfs::cvfs::vfsop_stat {hashkey root relative actualpath} {
	catch {
		set ret [::vfs::kitdll::data::getMetadata $hashkey $relative]
		set ret [::vfs::cvfs::data::getMetadata $hashkey $relative]
	}

	if {![info exists ret]} {
		vfs::filesystem posixerror $::vfs::posix(ENOENT)
	}

	return $ret
}

proc ::vfs::kitdll::vfsop_access {hashkey root relative actualpath mode} {
	set ret [::vfs::kitdll::data::getMetadata $hashkey $relative]
proc ::vfs::cvfs::vfsop_access {hashkey root relative actualpath mode} {
	set ret [::vfs::cvfs::data::getMetadata $hashkey $relative]

	if {$mode & 0x2} {
		vfs::filesystem posixerror $::vfs::posix(EROFS)
	}

	return 1
}

proc ::vfs::kitdll::vfsop_matchindirectory {hashkey root relative actualpath pattern types} {
proc ::vfs::cvfs::vfsop_matchindirectory {hashkey root relative actualpath pattern types} {
	set ret [list]

	catch {
		array set metadata [::vfs::kitdll::data::getMetadata $hashkey $relative]
		array set metadata [::vfs::cvfs::data::getMetadata $hashkey $relative]
	}

	if {![info exists metadata]} {
		return [list]
	}

	if {$pattern == ""} {
		set children [list $relative]
	} else {
		set children [::vfs::kitdll::data::getChildren $hashkey $relative]
		set children [::vfs::cvfs::data::getChildren $hashkey $relative]
	}

	foreach child $children {
		if {$pattern != ""} {
			if {![string match $pattern $child]} {
				continue
			}
		}

		unset -nocomplain metadata
		catch {
			array set metadata [::vfs::kitdll::data::getMetadata $hashkey $child]
			array set metadata [::vfs::cvfs::data::getMetadata $hashkey $child]
		}

		if {[string index $root end] == "/"} {
			set child "${root}${child}"
		} else {
			set child "${root}/${child}"
		}
︙
238
239
240
241
242
243
244
245

246
247
248
249
250
251
252
253
254
255
256

257
258
259
260
261
262
263

238
239
240
241
242
243
244

245
246
247
248
249
250
251
252
253
254
255

256
257
258
259
260
261
262
263








-
+










-
+









		lappend ret $child
	}

	return $ret
}

proc ::vfs::kitdll::vfsop_fileattributes {hashkey root relative actualpath {index -1} {value ""}} {
proc ::vfs::cvfs::vfsop_fileattributes {hashkey root relative actualpath {index -1} {value ""}} {
	set attrs [list -owner -group -permissions]

	if {$value != ""} {
		vfs::filesystem posixerror $::vfs::posix(EROFS)
	}

	if {$index == -1} {
		return $attrs
	}

	array set metadata [::vfs::kitdll::data::getMetadata $hashkey $relative]
	array set metadata [::vfs::cvfs::data::getMetadata $hashkey $relative]

	set attr [lindex $attrs $index]

	switch -- $attr {
		"-owner" {
			return $metadata(uid)
		}
︙
272
273
274
275
276
277
278
279

280
281
282
283
284
285

286
287
288
289
290
291
292
293
294
295
296
297

298
299

300
301
302
303
304
305
306
307
308
309
310
311

312
313

314
315
316
317
318
319
320
321
322

323
324
325

326
327
328

329
330
331

332
333
334
335


272
273
274
275
276
277
278

279
280
281
282
283
284

285
286
287
288
289
290
291
292
293
294
295
296

297
298

299
300
301
302
303
304
305
306
307
308
309
310

311
312

313
314
315
316
317
318
319
320
321

322
323
324

325
326
327

328
329
330

331
332
333
334

335








-
+





-
+











-
+

-
+











-
+

-
+








-
+


-
+


-
+


-
+



-
+

			return [format {0%o} $metadata(mode)]
		}
	}

	return -code error "Invalid index"
}

proc ::vfs::kitdll::vfsop_open {hashkey root relative actualpath mode permissions} {
proc ::vfs::cvfs::vfsop_open {hashkey root relative actualpath mode permissions} {
	if {$mode != "" && $mode != "r"} {
		vfs::filesystem posixerror $::vfs::posix(EROFS)
	}

	catch {
		array set metadata [::vfs::kitdll::data::getMetadata $hashkey $relative]
		array set metadata [::vfs::cvfs::data::getMetadata $hashkey $relative]
	}

	if {![info exists metadata]} {
		vfs::filesystem posixerror $::vfs::posix(ENOENT)
	}

	if {$metadata(type) == "directory"} {
		vfs::filesystem posixerror $::vfs::posix(EISDIR)
	}

	if {[info command chan] != ""} {
		set chan [chan create [list "read"] [list ::vfs::kitdll::chanhandler $hashkey]]
		set chan [chan create [list "read"] [list ::vfs::cvfs::chanhandler $hashkey]]

		set ::vfs::kitdll::chandata([list $hashkey $chan]) [list file $relative pos 0 len $metadata(size) watching ""]
		set ::vfs::cvfs::chandata([list $hashkey $chan]) [list file $relative pos 0 len $metadata(size) watching ""]

		return [list $chan]
	}

	if {[info command rechan] == ""} {
		catch {
			package require rechan
		}
	}

	if {[info command rechan] != ""} {
		set chan [rechan [list ::vfs::kitdll::chanhandler $hashkey] 2]
		set chan [rechan [list ::vfs::cvfs::chanhandler $hashkey] 2]

		set ::vfs::kitdll::chandata([list $hashkey $chan]) [list file $relative pos 0 len $metadata(size) watching ""]
		set ::vfs::cvfs::chandata([list $hashkey $chan]) [list file $relative pos 0 len $metadata(size) watching ""]

		return [list $chan]
	}

	return -code error "No way to generate a channel, need either Tcl 8.5+, \"rechan\""
}

##### No-Ops since we are a readonly filesystem
proc ::vfs::kitdll::vfsop_createdirectory {args} {
proc ::vfs::cvfs::vfsop_createdirectory {args} {
	vfs::filesystem posixerror $::vfs::posix(EROFS)
}
proc ::vfs::kitdll::vfsop_deletefile {args} {
proc ::vfs::cvfs::vfsop_deletefile {args} {
	vfs::filesystem posixerror $::vfs::posix(EROFS)
}
proc ::vfs::kitdll::vfsop_removedirectory {args} {
proc ::vfs::cvfs::vfsop_removedirectory {args} {
	vfs::filesystem posixerror $::vfs::posix(EROFS)
}
proc ::vfs::kitdll::vfsop_utime {} {
proc ::vfs::cvfs::vfsop_utime {} {
	vfs::filesystem posixerror $::vfs::posix(EROFS)
}

package provide vfs::kitdll 1.0
package provide vfs::cvfs 1.0

Renamed and modified kitsh/buildsrc/kitsh-0.0/vfs_kitdll_data.c [e51d57abbf] to kitsh/buildsrc/kitsh-0.0/cvfs_data.c [dcf0f1a5fd]. 

1
2
3
4
5
6
7

8
9
10
11
12
13
14
15
16
17
18

19
20
21
22
23
24
25

1
2
3
4
5
6

7
8
9
10
11
12
13
14
15
16
17

18
19
20
21
22
23
24
25







-
+










-
+








#include <tcl.h>

#ifdef HAVE_STDLIB_H
#  include <stdlib.h>
#endif

typedef struct kitdll_data *(cmd_getData_t)(const char *, unsigned long);
typedef struct cvfs_data *(cmd_getData_t)(const char *, unsigned long);
typedef unsigned long (cmd_getChildren_t)(const char *, unsigned long *, unsigned long);

/* Your implementation must provide these */
static cmd_getData_t *getCmdData(const char *hashkey);
static cmd_getChildren_t *getCmdChildren(const char *hashkey);

/* Tcl Commands */
static int getMetadata(ClientData cd, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
	cmd_getData_t *cmd_getData;
	cmd_getChildren_t *cmd_getChildren;
	struct kitdll_data *finfo = NULL;
	struct cvfs_data *finfo = NULL;
	Tcl_Obj *ret_list, *ret_list_items[20];
	unsigned long num_children;
	const char *hashkey;
	const char *file;

	if (objc != 3) {
		Tcl_SetResult(interp, "wrong # args: should be \"getMetadata hashKey fileName\"", TCL_STATIC);
︙
48
49
50
51
52
53
54
55

56
57
58
59
60
61
62

48
49
50
51
52
53
54

55
56
57
58
59
60
61
62








-
+








	}

	/* Values that can be derived from "finfo" */
	ret_list_items[0] = Tcl_NewStringObj("type", 4);
	ret_list_items[2] = Tcl_NewStringObj("mode", 4);
	ret_list_items[4] = Tcl_NewStringObj("nlink", 5);

	if (finfo->type == KITDLL_FILETYPE_DIR) {
	if (finfo->type == CVFS_FILETYPE_DIR) {
		num_children = cmd_getChildren(file, NULL, 0);

		ret_list_items[1] = Tcl_NewStringObj("directory", 9);
		ret_list_items[3] = Tcl_NewLongObj(040555);
		ret_list_items[5] = Tcl_NewLongObj(num_children);
	} else {
		ret_list_items[1] = Tcl_NewStringObj("file", 4);
︙
90
91
92
93
94
95
96
97

98
99
100
101
102
103
104

90
91
92
93
94
95
96

97
98
99
100
101
102
103
104








-
+









	Tcl_SetObjResult(interp, ret_list);

	return(TCL_OK);
}

static int getData(ClientData cd, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
	struct kitdll_data *finfo = NULL;
	struct cvfs_data *finfo = NULL;
	cmd_getData_t *cmd_getData;
	const char *hashkey;
	const char *file;
	const char *end_str;
	Tcl_Obj *ret_str;
	long start = 0;
	long end = -1;
︙
146
147
148
149
150
151
152
153

154
155
156
157
158
159
160

146
147
148
149
150
151
152

153
154
155
156
157
158
159
160








-
+









	if (finfo == NULL) {
		Tcl_SetResult(interp, "No such file or directory", TCL_STATIC);

		return(TCL_ERROR);
	}

	if (finfo->type != KITDLL_FILETYPE_FILE) {
	if (finfo->type != CVFS_FILETYPE_FILE) {
		Tcl_SetResult(interp, "Not a file", TCL_STATIC);

		return(TCL_ERROR);
	}

	if (end == -1) {
		end = finfo->size;
︙
182
183
184
185
186
187
188
189

190
191
192
193
194
195
196

182
183
184
185
186
187
188

189
190
191
192
193
194
195
196








-
+









	Tcl_SetObjResult(interp, ret_str);

	return(TCL_OK);
}

static int getChildren(ClientData cd, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
	struct kitdll_data *finfo = NULL;
	struct cvfs_data *finfo = NULL;
	cmd_getChildren_t *cmd_getChildren;
	cmd_getData_t *cmd_getData;
	unsigned long num_children, idx;
	unsigned long *children;
	const char *hashkey;
	const char *file;
	const char *child;
︙
218
219
220
221
222
223
224
225

226
227
228
229
230
231
232

218
219
220
221
222
223
224

225
226
227
228
229
230
231
232








-
+









	if (finfo == NULL) {
		Tcl_SetResult(interp, "No such file or directory", TCL_STATIC);

		return(TCL_ERROR);
	}

	if (finfo->type != KITDLL_FILETYPE_DIR) {
	if (finfo->type != CVFS_FILETYPE_DIR) {
		Tcl_SetResult(interp, "Not a directory", TCL_STATIC);

		return(TCL_ERROR);
	}

	num_children = cmd_getChildren(file, NULL, 0);
︙

Modified kitsh/buildsrc/kitsh-0.0/dir2c.tcl from [28f9b94a91] to [903b20a63c]. 

1
2
3
4

5
6
7
8
9
10
11

1
2
3

4
5
6
7
8
9
10
11




-
+








#! /usr/bin/env tclsh

if {[llength $argv] != 2} {
	puts stderr "Usage: kitdll <hashkey> <startdir>"
	puts stderr "Usage: dir2c.tcl <hashkey> <startdir>"

	exit 1
}

set hashkey [lindex $argv 0]
set startdir [lindex $argv 1]
︙
72
73
74
75
76
77
78
79

80
81
82
83
84
85
86

72
73
74
75
76
77
78

79
80
81
82
83
84
85
86








-
+









	set ret "\"$ret\""

	return $ret
}

# This function must be kept in-sync with the generated C function below
proc kitdll_hash {path} {
proc cvfs_hash {path} {
	set h 0
	set g 0

	for {set idx 0} {$idx < [string length $path]} {incr idx} {
		binary scan [string index $path $idx] H* char
		set char "0x$char"
︙
99
100
101
102
103
104
105
106
107


108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129


130
131
132
133
134



135
136

137
138
139
140

141
142
143
144

145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

160
161
162

163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179

180
181
182
183
184
185
186
187
188
189
190

191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208

209
210
211
212
213

214
215
216
217
218
219
220

99
100
101
102
103
104
105


106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127


128
129
130
131



132
133
134
135

136
137
138
139

140
141
142
143

144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

159
160
161

162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178

179
180
181
182
183
184
185
186
187
188
189

190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207

208
209
210
211
212

213
214
215
216
217
218
219
220








-
-
+
+




















-
-
+
+


-
-
-
+
+
+

-
+



-
+



-
+














-
+


-
+
















-
+










-
+

















-
+




-
+








# Generate list of files to include in output
set files [recursive_glob $startdir]

# Insert dummy entry cooresponding to C dummy entry
set files [linsert $files 0 "__DUMMY__"]

# Produce C89 compatible header
set cpp_tag "KITDLL_[string toupper $hashkey]"
set code_tag "kitdll_[string tolower $hashkey]"
set cpp_tag "CVFS_[string toupper $hashkey]"
set code_tag "cvfs_[string tolower $hashkey]"
set hashkey [string tolower $hashkey]

puts "#ifndef $cpp_tag"
puts "#  define $cpp_tag 1"
puts {
#  ifdef HAVE_STDC
#    ifndef HAVE_UNISTD_H
#      define HAVE_UNISTD_H 1
#    endif
#    ifndef HAVE_STRING_H
#      define HAVE_STRING_H 1
#    endif
#  endif
#  ifdef HAVE_UNISTD_H
#    include <unistd.h>
#  endif
#  ifdef HAVE_STRING_H
#    include <string.h>
#  endif

#  ifndef LOADED_KITDLL_COMMON
#    define LOADED_KITDLL_COMMON 1
#  ifndef LOADED_CVFS_COMMON
#    define LOADED_CVFS_COMMON 1

typedef enum {
	KITDLL_FILETYPE_FILE,
	KITDLL_FILETYPE_DIR
} kitdll_filetype_t;
	CVFS_FILETYPE_FILE,
	CVFS_FILETYPE_DIR
} cvfs_filetype_t;

struct kitdll_data {
struct cvfs_data {
	const char *             name;
	unsigned long            index;
	unsigned long            size;
	kitdll_filetype_t        type;
	cvfs_filetype_t          type;
	const unsigned char *    data;
};

static unsigned long kitdll_hash(const unsigned char *path) {
static unsigned long cvfs_hash(const unsigned char *path) {
	unsigned long i, h = 0, g = 0;

	for (i = 0; path[i]; i++) {
		h = (h << 4) + path[i];
		g = h & 0xf0000000;
		if (g) {
			h ^= (g >> 24);
		}
		h &= ((~g) & 0xffffffffLU);
	}
        
        return(h);
}

#  endif /* !LOADED_KITDLL_COMMON */}
#  endif /* !LOADED_CVFS_COMMON */}
puts ""

puts "static struct kitdll_data ${code_tag}_data\[\] = {"
puts "static struct cvfs_data ${code_tag}_data\[\] = {"
puts "\t{"
puts "\t\t.name  = NULL,"
puts "\t\t.index = 0,"
puts "\t\t.type  = 0,"
puts "\t\t.size  = 0,"
puts "\t\t.data  = NULL,"
puts "\t},"
for {set idx 1} {$idx < [llength $files]} {incr idx} {
	set file [lindex $files $idx]
	set shortfile [shorten_file $startdir $file]

	unset -nocomplain finfo type
	file stat $file finfo

	switch -- $finfo(type) {
		"file" {
			set type "KITDLL_FILETYPE_FILE"
			set type "CVFS_FILETYPE_FILE"
			set size $finfo(size)

			set fd [open $file]
			fconfigure $fd -translation binary
			set data [read $fd]
			close $fd

			set data "(unsigned char *) [stringify $data]"
		}
		"directory" {
			set type "KITDLL_FILETYPE_DIR"
			set type "CVFS_FILETYPE_DIR"
			set data "NULL"
			set size 0
		}
	}

	puts "\t{"
	puts "\t\t.name  = \"$shortfile\","
	puts "\t\t.index = $idx,"
	puts "\t\t.type  = $type,"
	puts "\t\t.size  = $size,"
	puts "\t\t.data  = $data,"
	puts "\t},"
}
puts "};"
puts ""

puts "static unsigned long ${code_tag}_lookup_index(const char *path) {"
puts "\tswitch (kitdll_hash((unsigned char *) path)) {"
puts "\tswitch (cvfs_hash((unsigned char *) path)) {"

for {set idx 1} {$idx < [llength $files]} {incr idx} {
	set file [lindex $files $idx]
	set shortfile [shorten_file $startdir $file]
	set hash [kitdll_hash $shortfile]
	set hash [cvfs_hash $shortfile]

	lappend indexes_per_hash($hash) [list $shortfile $idx]
}

foreach {hash idx_list} [array get indexes_per_hash] {
	puts "\t\tcase $hash:"
︙
234
235
236
237
238
239
240
241

242
243
244
245
246
247
248

234
235
236
237
238
239
240

241
242
243
244
245
246
247
248








-
+








}

puts "\t}"
puts "\treturn(0);"
puts "}"
puts ""

puts "static struct kitdll_data *${code_tag}_getData(const char *path, unsigned long index) {"
puts "static struct cvfs_data *${code_tag}_getData(const char *path, unsigned long index) {"
puts "\tif (path != NULL) {"
puts "\t\tindex = ${code_tag}_lookup_index(path);"
puts "\t}"
puts ""
puts "\tif (index == 0) {"
puts "\t\treturn(NULL);"
puts "\t}"
︙
262
263
264
265
266
267
268
269

270
271
272
273
274
275
276

262
263
264
265
266
267
268

269
270
271
272
273
274
275
276








-
+








puts "\tunsigned long num_children = 0;"
puts ""
puts "\tindex = ${code_tag}_lookup_index(path);"
puts "\tif (index == 0) {"
puts "\t\treturn(0);"
puts "\t}"
puts ""
puts "\tif (${code_tag}_data\[index\].type != KITDLL_FILETYPE_DIR) {"
puts "\tif (${code_tag}_data\[index\].type != CVFS_FILETYPE_DIR) {"
puts "\t\treturn(0);"
puts "\t}"
puts ""
puts "\tif (strcmp(path, ${code_tag}_data\[index\].name) != 0) {"
puts "\t\treturn(0);"
puts "\t}"
puts ""
︙
347
348
349
350
351
352
353
354

355
356

357
358
359
360
361
362
363
364
365
366
367
368
369
370

371
372
373





374

375
376
377
378
379

380
381
382
383
384
385
386
387
388
389

390
391
392
393

394
395

347
348
349
350
351
352
353

354
355

356
357
358
359
360
361
362
363
364
365
366
367
368
369

370
371
372
373
374
375
376
377
378

379
380
381
382
383

384
385
386
387
388






389
390
391
392

393
394
395








-
+

-
+













-
+



+
+
+
+
+
-
+




-
+




-
-
-
-
-
-
+



-
+




puts "\t}"
puts ""
puts "\treturn(num_children);"
puts "}"
puts ""

puts "#  ifdef KITDLL_MAKE_LOADABLE"
puts "#  ifdef CVFS_MAKE_LOADABLE"

set fd [open "vfs_kitdll_data.c"]
set fd [open "cvfs_data.c"]
puts [read $fd]
close $fd


puts "static cmd_getData_t *getCmdData(const char *hashkey) {"
puts "\treturn(${code_tag}_getData);"
puts "}"
puts ""
puts "static cmd_getChildren_t *getCmdChildren(const char *hashkey) {"
puts "\treturn(${code_tag}_getChildren);"
puts "}"
puts ""

puts "int Vfs_kitdll_data_${hashkey}_Init(Tcl_Interp *interp) {"
puts "int Cvfs_data_${hashkey}_Init(Tcl_Interp *interp) {"
puts "\tTcl_Command tclCreatComm_ret;"
puts "\tint tclPkgProv_ret;"
puts ""
puts "\ttclCreatComm_ret = Tcl_CreateObjCommand(interp, \"::vfs::cvfs::data::${hashkey}::getMetadata\", getMetadata, NULL, NULL);"
puts "\tif (!tclCreatComm_ret) {"
puts "\t\treturn(TCL_ERROR);"
puts "\t}"
puts ""
puts "\ttclCreatComm_ret = Tcl_CreateObjCommand(interp, \"::vfs::kitdll::data::${hashkey}::getMetadata\", getMetadata, NULL, NULL);"
puts "\ttclCreatComm_ret = Tcl_CreateObjCommand(interp, \"::vfs::cvfs::data::${hashkey}::getData\", getData, NULL, NULL);"
puts "\tif (!tclCreatComm_ret) {"
puts "\t\treturn(TCL_ERROR);"
puts "\t}"
puts ""
puts "\ttclCreatComm_ret = Tcl_CreateObjCommand(interp, \"::vfs::kitdll::data::${hashkey}::getData\", getData, NULL, NULL);"
puts "\ttclCreatComm_ret = Tcl_CreateObjCommand(interp, \"::vfs::cvfs::data::${hashkey}::getChildren\", getChildren, NULL, NULL);"
puts "\tif (!tclCreatComm_ret) {"
puts "\t\treturn(TCL_ERROR);"
puts "\t}"
puts ""
puts "\ttclCreatComm_ret = Tcl_CreateObjCommand(interp, \"::vfs::kitdll::data::${hashkey}::getChildren\", getChildren, NULL, NULL);"
puts "\tif (!tclCreatComm_ret) {"
puts "\t\treturn(TCL_ERROR);"
puts "\t}"
puts ""
puts "\ttclPkgProv_ret = Tcl_PkgProvide(interp, \"vfs::kitdll::data::${hashkey}\", \"1.0\");"
puts "\ttclPkgProv_ret = Tcl_PkgProvide(interp, \"vfs::cvfs::data::${hashkey}\", \"1.0\");"
puts ""
puts "\treturn(tclPkgProv_ret);"
puts "\t}"
puts "#  endif /* KITDLL_MAKE_LOADABLE */"
puts "#  endif /* CVFS_MAKE_LOADABLE */"

puts "#endif /* !$cpp_tag */"

Modified kitsh/buildsrc/kitsh-0.0/kitInit.c from [108a80f35a] to [901380bcbe].

︙
71
72
73
74
75
76
77
78

79
80
81
82
83
84
85

71
72
73
74
75
76
77

78
79
80
81
82
83
84
85








-
+








#ifdef KIT_INCLUDES_PWB
Tcl_AppInitProc	Pwb_Init;
#endif
#ifdef KIT_INCLUDES_ZLIB
Tcl_AppInitProc Zlib_Init;
#endif
#ifdef KIT_STORAGE_CVFS
Tcl_AppInitProc Vfs_kitdll_data_tcl_Init;
Tcl_AppInitProc Cvfs_data_tcl_Init;
#endif
#ifdef TCL_THREADS
Tcl_AppInitProc	Thread_Init;
#endif
#ifdef _WIN32
Tcl_AppInitProc	Dde_Init, Registry_Init;
#endif
︙
184
185
186
187
188
189
190
191
192


193
194
195

196
197
198
199
200
201
202

184
185
186
187
188
189
190


191
192
193
194

195
196
197
198
199
200
201
202








-
-
+
+


-
+








		"}\n"
	"}\n"
#endif /* KIT_STORAGE_ZIP */
#ifdef KIT_STORAGE_CVFS
	"set ::tclKitStorage \"cvfs\"\n"
	"load {} rechan\n"
	"load {} vfs\n"
	"load {} vfs_kitdll_data_tcl\n"
#include "vfs_kitdll.tcl.h"
	"load {} cvfs_data_tcl\n"
#include "cvfs.tcl.h"
	"if {![info exists s]} {\n"
		"catch {\n"
			"set s [::vfs::kitdll::data::getData tcl boot.tcl]\n"
			"set s [::vfs::cvfs::data::getData tcl boot.tcl]\n"
		"}\n"
	"}\n"
#endif /* KIT_STORAGE_CVFS */
#ifndef TCLKIT_DLL
	"if {![info exists s]} {\n"
		"set f [open setup.tcl]\n"
		"set s [read $f]\n"
︙
351
352
353
354
355
356
357
358

359
360
361
362
363
364
365

351
352
353
354
355
356
357

358
359
360
361
362
363
364
365








-
+








#endif 
	Tcl_StaticPackage(0, "rechan", Rechan_Init, NULL);
	Tcl_StaticPackage(0, "vfs", Vfs_Init, NULL);
#ifdef KIT_INCLUDES_ZLIB
	Tcl_StaticPackage(0, "zlib", Zlib_Init, NULL);
#endif
#ifdef KIT_STORAGE_CVFS
	Tcl_StaticPackage(0, "vfs_kitdll_data_tcl", Vfs_kitdll_data_tcl_Init, NULL);
	Tcl_StaticPackage(0, "cvfs_data_tcl", Cvfs_data_tcl_Init, NULL);
#endif
#ifdef TCL_THREADS
	Tcl_StaticPackage(0, "Thread", Thread_Init, NULL);
#endif
#ifdef _WIN32
	Tcl_StaticPackage(0, "dde", Dde_Init, NULL);
	Tcl_StaticPackage(0, "registry", Registry_Init, NULL);
︙

Powered by Fossil · RSS