10 /* This marks the function as having no side effects and depending on
11 * nothing but its arguments, which allows the optimizer to avoid
12 * duplicate calls to naNil(). */
13 #define GCC_PURE __attribute__((__pure__))
18 typedef struct Context* naContext;
20 // The function signature for an extension function:
21 typedef naRef (*naCFunction)(naContext ctx, naRef me, int argc, naRef* args);
23 // The function signature for an extension function with userdata passed back:
24 typedef naRef (*naCFunctionU)
25 (naContext ctx, naRef me, int argc, naRef* args, void* user_data);
27 // All Nasal code runs under the watch of a naContext:
28 naContext naNewContext();
29 void naFreeContext(naContext c);
31 // Use this when making a call to a new context "underneath" a
32 // preexisting context on the same stack. It allows stack walking to
33 // see through the boundary, and eliminates the need to release the
34 // mod lock (i.e. must be called with the mod lock held!)
35 naContext naSubContext(naContext super);
37 // The naContext supports a user data pointer that can be used to
38 // store data specific to an naCall invocation without exposing it to
39 // Nasal as a ghost. FIXME: this API is semi-dangerous, there is no
40 // provision for sharing it, nor for validating the source or type of
41 // the pointer returned.
42 void naSetUserData(naContext c, void* p);
43 void* naGetUserData(naContext c) GCC_PURE;
45 // run GC now (may block)
48 // "Save" this object in the context, preventing it (and objects
49 // referenced by it) from being garbage collected.
50 // TODO do we need a context? It is not used anyhow...
51 void naSave(naContext ctx, naRef obj);
53 // "Save" this object and get a key which allows do mark the object as free
54 // later on (with naGCFree).
55 int naGCSave(naRef obj);
57 // Release an object previously passed to naGCSave to allow it being cleaned up
58 // by the garbage collector.
59 void naGCRelease(int key);
61 // Drop all saved references
64 // Similar, but the object is automatically released when the
65 // context next runs native bytecode. Useful for saving off C-space
66 // temporaries to protect them before passing back into a naCall.
67 void naTempSave(naContext c, naRef r);
69 // Parse a buffer in memory into a code object. The srcFile parameter
70 // is a Nasal string representing the "file" from which the code is
71 // read. The "first line" is typically 1, but is settable for
72 // situations where the Nasal code is embedded in another context with
73 // its own numbering convetions. If an error occurs, returns nil and
74 // sets the errLine pointer to point to the line at fault. The string
75 // representation of the error can be retrieved with naGetError() on
77 naRef naParseCode(naContext c, naRef srcFile, int firstLine,
78 char* buf, int len, int* errLine);
80 // Binds a bare code object (as returned from naParseCode) with a
81 // closure object (a hash) to act as the outer scope / namespace.
82 naRef naBindFunction(naContext ctx, naRef code, naRef closure);
84 // Similar, but it binds to the current context's closure (i.e. the
85 // namespace at the top of the current call stack).
86 naRef naBindToContext(naContext ctx, naRef code);
88 // Call a code or function object with the specified arguments "on"
89 // the specified object and using the specified hash for the local
90 // variables. Passing a null args array skips the parameter variables
91 // (e.g. "arg") assignments; to get a zero-length arg instead, pass in
92 // argc==0 and a non-null args vector. The obj or locals parameters
93 // may be nil. Will attempt to acquire the mod lock, so call
94 // naModUnlock() first if the lock is already held.
95 naRef naCall(naContext ctx, naRef func, int argc, naRef* args,
96 naRef obj, naRef locals);
98 // As naCall(), but continues execution at the operation after a
99 // previous die() call or runtime error. Useful to do "yield"
100 // semantics, leaving the context in a condition where it can be
101 // restarted from C code. Cannot be used currently to restart a
102 // failed operation. Will attempt to acquire the mod lock, so call
103 // naModUnlock() first if the lock is already held.
104 naRef naContinue(naContext ctx);
106 // Throw an error from the current call stack. This function makes a
107 // longjmp call to a handler in naCall() and DOES NOT RETURN. It is
108 // intended for use in library code that cannot otherwise report an
109 // error via the return value, and MUST be used carefully. If in
110 // doubt, return naNil() as your error condition. Works like
112 void naRuntimeError(naContext c, const char* fmt, ...);
114 // "Re-throws" a runtime error caught from the subcontext. Acts as a
115 // naRuntimeError() called on the parent context. Does not return.
116 void naRethrowError(naContext subc);
118 // Retrieve the specified member from the object, respecting the
119 // "parents" array as for "object.field". Returns zero for missing
121 int naMember_get(naContext c, naRef obj, naRef field, naRef* out);
122 int naMember_cget(naContext c, naRef obj, const char* field, naRef* out);
124 // Returns a hash containing functions from the Nasal standard library
125 // Useful for passing as a namespace to an initial function call
126 naRef naInit_std(naContext c);
128 // Ditto, for other core libraries
129 naRef naInit_math(naContext c);
130 naRef naInit_bits(naContext c);
131 naRef naInit_io(naContext c);
132 naRef naInit_regex(naContext c);
133 naRef naInit_unix(naContext c);
134 naRef naInit_thread(naContext c);
135 naRef naInit_utf8(naContext c);
136 naRef naInit_sqlite(naContext c);
137 naRef naInit_readline(naContext c);
138 naRef naInit_gtk(naContext ctx);
139 naRef naInit_cairo(naContext ctx);
141 // Returns a hash which can be used to add methods callable on strings
142 naRef naInit_string(naContext c);
144 // Context stack inspection, frame zero is the "top"
145 int naStackDepth(naContext ctx);
146 int naGetLine(naContext ctx, int frame);
147 naRef naGetSourceFile(naContext ctx, int frame);
148 char* naGetError(naContext ctx);
151 int naIsNil(naRef r) GCC_PURE;
152 int naIsNum(naRef r) GCC_PURE;
153 int naIsString(naRef r) GCC_PURE;
154 int naIsScalar(naRef r) GCC_PURE;
155 int naIsVector(naRef r) GCC_PURE;
156 int naIsHash(naRef r) GCC_PURE;
157 int naIsCode(naRef r) GCC_PURE;
158 int naIsFunc(naRef r) GCC_PURE;
159 int naIsCCode(naRef r) GCC_PURE;
161 // Allocators/generators:
162 naRef naNil() GCC_PURE;
163 naRef naNum(double num) GCC_PURE;
164 naRef naNewString(naContext c);
165 naRef naNewVector(naContext c);
166 naRef naNewHash(naContext c);
167 naRef naNewFunc(naContext c, naRef code);
170 * Register extension function
172 * @param fptr Pointer to C-function
173 * @param user_data Optional user data passed back on calling the function
174 * @param destroy Optional callback called if function gets freed by garbage
175 * collector to free user data if required.
177 naRef naNewCCode(naContext c, naCFunction fptr);
178 naRef naNewCCodeU(naContext c, naCFunctionU fptr, void* user_data);
179 naRef naNewCCodeUD(naContext c, naCFunctionU fptr, void* user_data,
180 void (*destroy)(void*));
182 // Some useful conversion/comparison routines
183 int naEqual(naRef a, naRef b) GCC_PURE;
184 int naStrEqual(naRef a, naRef b) GCC_PURE;
185 int naTrue(naRef b) GCC_PURE;
186 naRef naNumValue(naRef n) GCC_PURE;
187 naRef naStringValue(naContext c, naRef n);
190 int naStr_len(naRef s) GCC_PURE;
191 char* naStr_data(naRef s) GCC_PURE;
192 naRef naStr_fromdata(naRef dst, const char* data, int len);
193 naRef naStr_concat(naRef dest, naRef s1, naRef s2);
194 naRef naStr_substr(naRef dest, naRef str, int start, int len);
195 naRef naInternSymbol(naRef sym);
196 naRef getStringMethods(naContext c);
199 int naVec_size(naRef v);
200 naRef naVec_get(naRef v, int i);
201 void naVec_set(naRef vec, int i, naRef o);
202 int naVec_append(naRef vec, naRef o);
203 void naVec_setsize(naContext c, naRef vec, int sz);
206 * Remove and retrieve the first element of the vector.
208 * This operation reduces the size of the vector by one and moves all elements
209 * by one towards the begin of the vector.
211 * @return The element removed from the begin
213 naRef naVec_removefirst(naRef vec);
216 * Remove and retrieve the last element of the vector.
218 * This operation reduces the size of the vector by one.
220 * @return The element removed from the end
222 naRef naVec_removelast(naRef vec);
225 int naHash_size(naRef h);
226 int naHash_get(naRef hash, naRef key, naRef* out);
227 naRef naHash_cget(naRef hash, char* key);
228 void naHash_set(naRef hash, naRef key, naRef val);
229 void naHash_cset(naRef hash, char* key, naRef val);
230 void naHash_delete(naRef hash, naRef key);
232 * Store the keys in ::hash into the vector at ::dst
236 void naHash_keys(naRef dst, naRef hash);
239 typedef struct naGhostType {
240 void(*destroy)(void*);
242 const char*(*get_member)(naContext c, void*, naRef key, naRef* out);
243 void(*set_member)(naContext c, void*, naRef key, naRef val);
247 * Create a ghost for an object without any attributes. If ::t contains pointers
248 * to get_member or set_member function they will be ignored.
250 naRef naNewGhost(naContext c, naGhostType* t, void* ghost);
252 * Create a ghost for an object. This version uses the get_member and set_member
253 * function pointers in ::t upon trying to get or set a member respectively from
256 naRef naNewGhost2(naContext c, naGhostType* t, void* ghost);
257 naGhostType* naGhost_type(naRef ghost);
258 void* naGhost_ptr(naRef ghost);
259 int naIsGhost(naRef r);
261 // Acquires a "modification lock" on a context, allowing the C code to
262 // modify Nasal data without fear that such data may be "lost" by the
263 // garbage collector (nasal data on the C stack is not examined in
264 // GC!). This disallows garbage collection until the current thread
265 // can be blocked. The lock should be acquired whenever nasal objects
266 // are being modified. It need not be acquired when only read access
267 // is needed, PRESUMING that the Nasal data being read is findable by
268 // the collector (via naSave, for example) and that another Nasal
269 // thread cannot or will not delete the reference to the data. It
270 // MUST NOT be acquired by naCFunction's, as those are called with the
271 // lock already held; acquiring two locks for the same thread will
272 // cause a deadlock when the GC is invoked. It should be UNLOCKED by
273 // naCFunction's when they are about to do any long term non-nasal
274 // processing and/or blocking I/O. Note that naModLock() may need to
275 // block to allow garbage collection to occur, and that garbage
276 // collection by other threads may be blocked until naModUnlock() is
277 // called. It must also be UNLOCKED by threads that hold a lock
278 // already before making a naCall() or naContinue() call -- these
279 // functions will attempt to acquire the lock again.
283 // Library utilities. Generate namespaces and add symbols.
284 typedef struct { char* name; naCFunction func; } naCFuncItem;
285 naRef naGenLib(naContext c, naCFuncItem *funcs);
286 void naAddSym(naContext c, naRef ns, char *sym, naRef val);