\begin{describe}[SodClass]{cls}
{[nick = cls, link = SodObject] \\
- class SodClass : SodObject \{ \\ \ind
+ class SodClass: SodObject \{ \\ \ind
const char *name; \\
const char *nick; \\
size_t initsz; \\
\begin{prog}
class Sub; \\+
-class Super : SodObject \{ \\ \ind
+class Super: SodObject \{ \\ \ind
Sub *sub; \-\\
\}; \\+
-class Sub : Super \{ \\ \ind
+class Sub: Super \{ \\ \ind
/* \dots\ */ \-\\
\};
\end{prog}
For example,
\begin{prog}
[nick = eg] \\
-class Example : Super \{ \\ \ind
+class Example: Super \{ \\ \ind
int foo = 17; \-\\
\};
\end{prog}
means the same as
\begin{prog}
[nick = eg] \\
-class Example : Super \{ \\ \ind
+class Example: Super \{ \\ \ind
int foo; \\
eg.foo = 17; \-\\
\};
\begin{prog}
/* -*-sod-*- */ \\+
- code c : includes \{ \\
+ code c: includes \{ \\
\#include "greeter.h" \\
\} \\+
- code h : includes \{ \\
+ code h: includes \{ \\
\#include <stdio.h> \\
\#include <sod/sod.h> \\
\} \\+
- class Greeter : SodObject \{ \\ \ind
+ class Greeter: SodObject \{ \\ \ind
void greet(FILE *fp) \{ \\ \ind
fputs("Hello, world!\textbackslash n", fp); \-\\
\} \-\\
The basic syntax for @"code" stanzas is
\begin{prog}
- code @<file-label> : @<section> \{ \\ \ind
+ code @<file-label>: @<section> \{ \\ \ind
@<code> \-\\
\}
\end{prog}
set##_KWSET(KWSET__SUPPLIEDP) \
set##_KWSET(KWSET__STRUCTMEM) \
}
-#define KWSET__SUPPLIEDP(type, name, dflt) unsigned name##_suppliedp : 1;
+#define KWSET__SUPPLIEDP(type, name, dflt) unsigned name##_suppliedp: 1;
#define KWSET__STRUCTMEM(type, name, dflt) type name;
/* --- @KWSET_PARSEFN@ --- *
(definst suppliedp-struct (stream) (flags var)
(format stream
- "~@<struct { ~2I~_~{unsigned ~A : 1;~^ ~_~} ~I~_} ~A;~:>"
+ "~@<struct { ~2I~_~{unsigned ~A: 1;~^ ~_~} ~I~_} ~A;~:>"
flags var))
;; Initialization.
(c-function-keywords type))))
(when keys
(format stream "struct ~A {~%~
- ~{ unsigned ~A : 1;~%~}~
+ ~{ unsigned ~A: 1;~%~}~
};~2%"
(direct-method-suppliedp-struct-tag method)
(mapcar #'argument-name keys))))))))
class)
(format stream "~&struct ~A {~%"
(effective-method-keyword-struct-tag method))
- (format stream "~{ unsigned ~A__suppliedp : 1;~%~}"
+ (format stream "~{ unsigned ~A__suppliedp: 1;~%~}"
(mapcar #'argument-name keys))
(dolist (key keys)
(write-string " " stream)
* A simple SOD module for testing.
*/
-code c : includes {
+code c: includes {
#include <stdio.h>
#include "chimaera.h"
}
-code h : includes {
+code h: includes {
#include "sod.h"
}
[nick = nml, link = SodObject]
-class Animal : SodObject {
+class Animal: SodObject {
int tickles = 0;
[combination = progn] void tickle();
[role = before] void nml.tickle() { me->nml.tickles++; }
}
-class Lion : Animal {
+class Lion: Animal {
void bite() { puts("Munch!"); }
void nml.tickle() { Lion_bite(me); }
}
-class Goat : Animal {
+class Goat: Animal {
void butt() { puts("Bonk!"); }
void nml.tickle() { Goat_butt(me); }
}
-class Serpent : Animal {
+class Serpent: Animal {
int limit = 2;
void hiss() { puts("Sssss!"); }
}
[nick = sir, link = Animal]
-class Chimaera : Lion, Goat, Serpent {
+class Chimaera: Lion, Goat, Serpent {
serpent.limit = 1;
}
-code c : user {
+code c: user {
/*----- Main driver code --------------------------------------------------*/
static void tickle_animal(Animal *a)
/* -*-sod-*- */
-code h : includes {
+code h: includes {
#include "sod.h"
}
-code c : includes {
+code c: includes {
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "test.h"
}
-code c : early_user {
+code c: early_user {
/*----- Preliminary definitions -------------------------------------------*/
/* Confuse the fragment scanner... */
}
-code c : (tests head)
+code c: (tests head)
[user (tests head) tests (tests tail) main (user end)]
{
/*----- Test machinery ----------------------------------------------------*/
static void tests(void)
LBRACE
}
-code c : (tests tail) {
+code c: (tests tail) {
RBRACE
}
-code c : main {
+code c: main {
/*----- Main program ------------------------------------------------------*/
int main(void)
/*----- Various kinds of method combinations ------------------------------*/
-code h : early_user {
+code h: early_user {
struct item {
struct item *next;
const char *p;
}
-code c : early_user {
+code c: early_user {
static void *xmalloc(size_t n)
{
void *p = malloc(n);
}
[link = SodObject, nick = t1base]
-class T1Base : SodObject {
+class T1Base: SodObject {
[combination = progn] void aprogn() { STEP(1); }
[combination = sum] int asum() { return 1; }
[combination = and] int aand() { return 8; }
}
[link = T1Base, nick = t1sub]
-class T1Sub : T1Base {
+class T1Sub: T1Base {
void t1base.aprogn() { STEP(0); }
int t1base.asum() { return 2; }
int t1base.aand() { return 6; }
int t1base.avec() { return 4; }
}
-code c : tests {
+code c: tests {
prepare("aggregate, base");
{ SOD_DECL(T1Base, t1, NO_KWARGS);
struct item *l;
/*----- Slot and user initargs --------------------------------------------*/
[link = SodObject, nick = t2]
-class T2 : SodObject {
+class T2: SodObject {
[initarg = x] int x = 0;
initarg int y = 1;
init { if (!y) STEP(0); }
}
-code c : tests {
+code c: tests {
prepare("initargs, defaults");
{ SOD_DECL(T2, t, NO_KWARGS);
if (t->t2.x == 0) STEP(0);
/*----- Keyword argument propagation --------------------------------------*/
[link = SodObject, nick = base]
-class T3Base : SodObject {
+class T3Base: SodObject {
void m0(?int x) { STEP(x); }
void m1(?) { }
}
[link = T3Base, nick = mid]
-class T3Mid : T3Base {
+class T3Mid: T3Base {
void base.m0(?int y) { STEP(y); CALL_NEXT_METHOD; }
void base.m1(?) { STEP(4); CALL_NEXT_METHOD; }
}
[link = T3Mid, nick = sub]
-class T3Sub : T3Mid {
+class T3Sub: T3Mid {
void base.m0(?int z) { STEP(z); CALL_NEXT_METHOD; }
void base.m1(?int z) { STEP(z); CALL_NEXT_METHOD; }
}
-code c : tests {
+code c: tests {
prepare("kwargs");
{ SOD_DECL(T3Sub, t, NO_KWARGS);
T3Base_m0(t, KWARGS(K(z, 0) K(y, 1) K(x, 2)));
~mdw / sod / commitdiff