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