430bc99013
it build again.
Changes:
This is a major feature enhancement and bugfix release
* Added keyword and optional function arguments.
The syntax of a keyword parameter/argument is "identifier = expr".
Function Application
-------------------------------------------
f(a) f(1)
f(~a, b) f(~a = 10, 11) Required keyword argument
f(?a, b) f(~a = 10, 12) Optional keyword argument
f(12) -- defaults to empty
f(?a = 1, b) f(~a = 10, 11) Optional keyword argument with default value
f(~a = 1, b) f(11) -- ~a is same as ?a if there is a default value
f(?a = 10, 11) -- Arguments can use ?, but it means the same thing
Keyword arguments and normal arguments are processed
independently. Normal arguments have to appear in the same
order as in the parameter list, but keyword arguments can go
anywhere.
This also adds the function notation.
fun(x, y) =>
add($x, $y)
foreach(x => ..., a b c)
println($x)
where the "..." essentially means "parse as if the indented
block below was actually an expression in here"
Old-style foreach generate a warning.
* Added "program" syntax. This provides a more standard
programming language, where strings must be explicit, and
variables represent applications.
The outer syntax is normal; the program syntax is an ast to
ast translation. The translation is turned on with the command
".LANGUAGE: program", which is scoped like "export". Here is
an example:
#!/usr/bin/env osh
.LANGUAGE: program
f(x) =
return x + 1
println(f(f(1)))
The normal $-style expressions are always allowed, but in
program-syntax mode, identifiers stand for variables, function
application is the f(e1, ..., e2) form, and there are the
standard infix operators. To switch back to the default
syntax, use .LANGUAGE: make
Note, shell commands and rules never use program syntax,
except within function arguments.
This is not heavily tested.
* Added support for partial and curried function applications.
Normal funcation application still require using the correct
number of arguments (as relaxed by the introduction of optional
arguments), but apply function can be used to create curried
and partial applications.
f(x,y) =
return $(add $x, $y)
g = $(apply $f, 2) # Partial applications must use apply
println($(g 3)) # 5
ff(x) =
gg(y) =
return $(add $x, $y)
println($(apply $(ff), 3, 5)) # Prints 8, also need to use apply here
apply can also take keyword arguments.
* A high-quality C parser was added to OMake — see lib/parse/C/Parse.om
* Added a LaTeX parser and spellchecker - see lib/parse/LaTeX/README.txt
* New functions added: localtime, gmtime, mktime, normalize-tm,
utimes, digest-string, url-escaped, find-all, addprefixes
* New object added: Tm
* About 10 Bugs fixed
* [Experimental] Object methods can now export their fields
back into the parent object. For example,
Z. =
x = 1
f() =
x = 2
export
Z.f()
echo $(Z.x)
# Prints "2"
This works with arbitrary levels of nesting.
90 lines
3.2 KiB
Text
90 lines
3.2 KiB
Text
$NetBSD: patch-ak,v 1.1 2010/12/17 09:40:14 wiz Exp $
|
|
|
|
From upstream SVN.
|
|
|
|
--- src/libmojave-external/cutil/lm_notify.c.orig 2007-07-27 17:58:13.000000000 +0000
|
|
+++ src/libmojave-external/cutil/lm_notify.c
|
|
@@ -74,13 +74,13 @@ typedef struct {
|
|
|
|
#define CheckCode(fmt, expr) \
|
|
do { \
|
|
- enter_blocking_section(); \
|
|
+ caml_enter_blocking_section(); \
|
|
code = expr; \
|
|
- leave_blocking_section(); \
|
|
+ caml_leave_blocking_section(); \
|
|
if(code < 0) { \
|
|
char buffer[256]; \
|
|
ErrFmt(buffer, fmt); \
|
|
- failwith(buffer); \
|
|
+ caml_failwith(buffer); \
|
|
} \
|
|
} while(0)
|
|
|
|
@@ -145,11 +145,11 @@ value om_notify_open(value v_unit)
|
|
FAMInfo *info;
|
|
int code;
|
|
|
|
- v = alloc_custom(&fam_connection_ops, sizeof(FAMInfo), 0, 1);
|
|
+ v = caml_alloc_custom(&fam_connection_ops, sizeof(FAMInfo), 0, 1);
|
|
info = FAMInfo_val(v);
|
|
fc = malloc(sizeof(FAMConnection));
|
|
if(fc == 0)
|
|
- invalid_argument("om_notify_open: out of memory");
|
|
+ caml_invalid_argument("om_notify_open: out of memory");
|
|
info->fc = fc;
|
|
CheckCode("om_notify_open", FAMOpen(fc));
|
|
#ifdef HAVE_FAMNOEXISTS
|
|
@@ -180,7 +180,7 @@ value om_notify_fd(value v_fc)
|
|
fc = FAMConnection_val(v_fc);
|
|
return Val_int(fc->id);
|
|
#else /* FAM_PSEUDO && !FAM_INOTIFY */
|
|
- failwith("No file descriptors in pseudo-FAM");
|
|
+ caml_failwith("No file descriptors in pseudo-FAM");
|
|
return Val_unit;
|
|
#endif /* FAM_INOTIFY */
|
|
#else /* FAM_PSEUDO */
|
|
@@ -209,7 +209,7 @@ value om_notify_monitor_directory(value
|
|
#ifdef WIN32
|
|
CheckCode("om_notify_monitor_directory", FAMMonitorDirectoryTree(fc, name, &request, 0));
|
|
#else /* WIN32 */
|
|
- failwith("om_notify_monitor_directory: recursive monitoring is not allowed");
|
|
+ caml_failwith("om_notify_monitor_directory: recursive monitoring is not allowed");
|
|
#endif /* !WIN32 */
|
|
}
|
|
else
|
|
@@ -294,13 +294,13 @@ value om_notify_next_event(value v_fc)
|
|
CheckCode("om_notify_next_event", FAMNextEvent(fc, &event));
|
|
code = event.code;
|
|
if(code < 1 || code > 10)
|
|
- failwith("om_notify_next_event: code out of bounds");
|
|
+ caml_failwith("om_notify_next_event: code out of bounds");
|
|
|
|
/* Allocate the string name */
|
|
- v_name = copy_string(event.filename);
|
|
+ v_name = caml_copy_string(event.filename);
|
|
|
|
/* Allocate the tuple */
|
|
- v_tuple = alloc_tuple(3);
|
|
+ v_tuple = caml_alloc_tuple(3);
|
|
Field(v_tuple, 0) = Val_int(event.fr.reqnum);
|
|
Field(v_tuple, 1) = v_name;
|
|
Field(v_tuple, 2) = Val_int(code - 1);
|
|
@@ -330,7 +330,7 @@ value om_notify_open(value v_unit)
|
|
*/
|
|
value om_notify_fd(value v_fc)
|
|
{
|
|
- invalid_argument("FAM not enabled");
|
|
+ caml_invalid_argument("FAM not enabled");
|
|
return Val_unit;
|
|
}
|
|
|
|
@@ -389,7 +389,7 @@ value om_notify_pending(value v_fc)
|
|
*/
|
|
value om_notify_next_event(value v_fc)
|
|
{
|
|
- invalid_argument("FAM not enabled");
|
|
+ caml_invalid_argument("FAM not enabled");
|
|
return Val_unit;
|
|
}
|
|
|