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
131
132
133
|
The Jim Interpreter
A small-footprint implementation of the Tcl programming language.
--------------------------------------------------------------------------------
WHAT IS JIM?
--------------------------------------------------------------------------------
Jim is a small footprint implementation of the Tcl programming language
written from scratch. Currently it's a work in progress, but already
capable to run non-trivial scripts (see the benchmark.tcl file for
an example). There are many Tcl core commands not implemented, but the
language itself offers already interesting features like {expand} and
[dict], that are features that will appear on Tcl8.5, [lambda] with
garbage collection, and a general GC/references system to build linked
data structure with automatic memory managment. Arrays in Jim are
not collection of variables, but instead syntax sugar for [dict]tionaries.
Ohter common features of the Tcl programming language are present, like
the "everything is a string" behaviour, implemented internally as
dual ported objects to ensure that the execution time does not reflect
the semantic of the language :)
--------------------------------------------------------------------------------
WHERE JIM IS USEFUL?
--------------------------------------------------------------------------------
1) If you are writing an application, and want to make it scriptable, with
Jim you have a way to do it that does not require to link your application
with a big system. You can just put jim.c and jim.h files in your project
and use the Jim API to write the glue code that makes your application
scriptable in Jim, with the following advantages:
- Jim is simple, 10k lines of code. If you want to adapt it you can hack
the source code to feet the needs of your application. It makes you
able to have scripting for default, and avoid external dependences.
Having scripting support *inside*, and in a way that a given version
of your program always gets shipped a given version of Jim, you can
write part of your application in Jim itself. Like it happens for
Emacs/Elisp, or Gimp/Scheme, both this applications have the interpreter
inside.
- Jim is Tcl, and Tcl looks like a configuration file if you want. So
if you use Jim you have also a flexible syntax for your config file.
This is a valid Tcl script:
set MyFeature on
ifssl {
set SslPort 45000
use compression
}
It looks like a configuration file, but if you implement the [ifssl]
and [use] commands, it's a valid Tcl script.
- Tcl scales with the user. Not all know it, but Tcl is so powerful that
you can reprogram the language in itself. Jim support this features
of the Tcl programming language. You can write new control structures,
use the flexible data types it offers (Lists are a central data structure,
with Dictioaries that are also lists). Still Tcl is simpler for the
casual programmer, expecially if compared to other languages offering
small footprint implementations (like Scheme and FORTH).
- Because of the Tcl semantic (pass by value, everything is a command
since there are no reserved words), there is a nice API to glue
your application with Jim. See under the 'docs' directory to find
examples and documentation about it.
- Jim is supported. If you need commercial software, contact the author
writing an email to 'antirez@gmail.com'.
2) The other "field" where Jim can be useful is obviously embedded systems.
3) We are working to make Jim as feature-complete as possible, thanks to
dynamically loaded extensions it may stay as little as it is today
but able to do interesting things for you. So it's not excluded that
in the future you will able to use Jim as a general purpose language.
--------------------------------------------------------------------------------
COPYRIGHT and LICENSE
--------------------------------------------------------------------------------
Copyright (C) 2005 Salvatore Sanfilippo
All Rights Reserved
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
A copy of the license is also included in the source distribution
of Jim, as a TXT file name called LICENSE.
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
--------------------------------------------------------------------------------
Extensions
--------------------------------------------------------------------------------
JIM-POSIX
This is the start of a library that should export to Jim useful bits of the
POSIX API. For now there are just a few utility functions, but it's
an example on how to write a simple library for Jim.
JIM-WIN32
This is the start of a library that should export to Jim useful bits of the
WIN32 API. Currently there is just one function that is used to call windows
applications. For example run jim and try the extension with:
load jim-win32.dll
win32.shellexecute open notepad
You should see a notepad application running.
--------------------------------------------------------------------------------
Thanks to...
--------------------------------------------------------------------------------
- First of all, thanks to every guy that's listed in the AUTHORS file,
that directly helped with code and ideas.
- Many people on the Tclers Chat that helped me to explore issues
about the use and the implementation of the Tcl programming language.
- David Welton for the tech info sharing and our chats about
programming languages design and the ability of software to scale down.
- The autors of "valgrind", for this wonderful tool, that helped me a
lot to fix bugs in minutes instead of hours.
|
