Skip to content
Browse files

Revert "(re style -) Properly re-indenting preprocessor directives in…

… `execution/`." and "(new dup incomplete) Copying over the old `routine.c` and `ast.c`."

This reverts commit 8bf9f5f.
This reverts commit 569e20b.
  • Loading branch information...
1 parent 94c01d0 commit 8a1c18a5c7650d1274560c435550503a2f3c064e @ELLIOTTCABLE ELLIOTTCABLE committed
View
271 Source/Types/execution/ast.c
@@ -1,271 +0,0 @@
-# if !defined(AST_DECLARATIONS)
-# define AST_DECLARATIONS
-
-# if !defined(DECLARATIONS)
-# define AST_C__BEHEST
-# define DECLARATIONS
-# endif
-# include "Paws.c/Core.h"
-# include "Paws.c/Types/Types.h"
-# if defined(AST_C__BEHEST)
-# undef DECLARATIONS
-# endif
-
-
-/* ======
-= `ast` =
-====== */
-
-/* ### Data Types & Structures ### */
-
- struct E(ast); /* Our code storage system (an abstract syntax tree) */
- struct E(node); /* A single node of an `ast` */
-typedef struct E(ast)* E(ast);
-typedef struct E(node)* E(node);
-
-typedef unsigned long long int E(ast_size); /* The maximum storable character index into a Paws document */
-typedef unsigned int E(node_size); /* The maximum storable character index into a `WORD` node, as well as the maximum descendants to a node */
-
-/* This name is reserved, but unused */
-struct E(ast) { void *nothing; };
-
-struct E(node) {
- enum E(node_type) { E(SCOPE), E(EXPRESSION), E(WORD) } //»
- type; /* The node’s ‘type’ */
-
- E(ast_size) start; /* The character index of the start of this node */
- E(ast_size) end; /* The character index of the end of this node */
-
- E(node) archetype; /* The prototype of this node. */
-
- E(node_size) size; /* The number of child nodes, or the bytes in this `WORD` */
- void *content; /* A meta-pointer to the first child node, or to the cstring */
-};
-
-/* ### Method Declarations ### */
-
-/* This name is reserved, but unused */
-struct E(AST) { void (*nothing)(void); };
-# if !defined(EXTERNALIZE)
- struct E(AST) extern *AST;
-# endif
-
-struct E(Node) {
- /* `Node` functions */
- E(node) (*allocate) ( enum E(node_type) type );
- E(node) (*scope) ( void );
- E(node) (*expression) ( void );
- E(node) (*word) ( char *content );
-
- /* `struct node` methods */
- void (*insert) ( E(node) this, E(node) child, E(node_size) idx );
- void (*prefix) ( E(node) this, E(node) child );
- void (*affix) ( E(node) this, E(node) child );
- E(node) (*at) ( E(node) this, E(node_size) idx );
- char* (*native) ( E(node) this );
- E(node) (*duplicate) ( E(node) this );
- E(node) (*instantiate) ( E(node) this );
-};
-# if !defined(EXTERNALIZE)
- struct E(Node) extern *Node;
-# endif
-
-void Paws__register_AST ( void );
-void Paws__register_Node ( void );
-
-
-
-# endif
-# if !defined(AST_IMPLEMENTATION) && !defined(DECLARATIONS) /* ========================================== BODY */
-# define AST_IMPLEMENTATION
-
-# define DECLARATIONS
-# include <stdlib.h>
-# include <string.h>
-# include <stdbool.h>
-# undef DECLARATIONS
-
-/* A safer `strcpy()`, using `strncpy()` and `sizeof()` */
-#define STRCPY(TO, FROM, BYTES) \
- strncpy(TO, FROM, BYTES); TO[BYTES - 1] = '\0'
-
-
-/* ### Method Declarations ### */
-
- struct AST // »
- *AST = NULL;
-void Paws__register_AST(void) { AST = malloc(sizeof(struct AST));
-
- struct AST // »
- data = { .nothing = NULL };
-
- memcpy(AST, &data, sizeof(struct AST));
-}
-
-node Node__allocate (enum node_type type);
-node Node__scope (void);
-node Node__expression (void);
-node Node__word (char *content);
-
-void node__insert (node this, node child, node_size idx);
-void node__prefix (node this, node child);
-void node__affix (node this, node child);
-node node__at (node this, node_size idx);
-char* node__native (node this);
-node node__duplicate (node this);
-node node__instantiate (node this);
-
- struct Node // »
- *Node = NULL;
-void Paws__register_Node(void) { Node = malloc(sizeof(struct Node));
-
- struct Node // »
- data = {
- .allocate = Node__allocate,
- .scope = Node__scope,
- .expression = Node__expression,
- .word = Node__word,
-
- .insert = node__insert,
- .prefix = node__prefix,
- .affix = node__affix,
- .at = node__at,
- .native = node__native,
- .duplicate = node__duplicate,
- .instantiate = node__instantiate
- };
-
- memcpy(Node, &data, sizeof(struct Node));
-}
-
-
-/* ### Method Implementations ### */
-
-/* This method initializes a new `node`, with no children. All values are initialized to either `NULL` or zero.
- *
- * You really should not be using this method; the respective method for the type of node you actually need is
- * more appropriate, as it preforms type-specific initialization.
- */
-node Node__allocate(enum node_type type) {
- node this = malloc(sizeof(struct node));
-
- this->type = type;
-
- this->start = 0;
- this->end = 0;
-
- this->archetype = NULL;
-
- this->size = 0;
- this->content = NULL;
-
- return this;
-}
-
-/* This method initializes a new `node` with `.type` set to `SCOPE`. */
-node Node__scope(void) {
- node this = Node->allocate(SCOPE);
-
- return this;
-}
-
-/* This method initializes a new `node` with `.type` set to `EXPRESSION`. */
-node Node__expression(void) {
- node this = Node->allocate(EXPRESSION);
-
- return this;
-}
-
-/* This method initializes a new `node` with `.type` set to `WORD`, and then initializes the `.content` to an
- * empty cstring. */
-node Node__word(char *content) {
- node this = Node->allocate(WORD);
-
- this->size = strlen(content) + 1;
-
- char *copy = malloc(this->size);
- STRCPY(copy, content, this->size);
- this->content = copy;
-
- return this;
-}
-
-/* FIXME: Okay, I’m almost certain that this entire set of functions needs to be/can be reimplemented with calls
- to `realloc(3)` and `memmove(3)` instead of `alloc(3)` and `memcpy(3)`. However, is that actually more
- efficient? I need to find out if that path is actually *slower* or not. TO STACKOVERFLOW! */
-
-void node__insert(node this, node child, node_size idx) {
- /* TODO: Flip a nut if `this` isn’t an `SCOPE` or `EXPRESSION`.
- TODO: Flip a nut if `this` is a `SCOPE` and `child` is a `WORD`.
- TODO: Flip a nut if `size` is smaller than `idx`.
- TODO: Merge `Node->prefix()` and `Node->affix()` into this. */
-
- node *children = malloc(sizeof(node) * this->size + 1);
-
- memcpy(children + 0, (node *)this->content, sizeof(node) * idx);
- *(children + idx) = child;
- memcpy(children + idx + 1, (node *)this->content + idx, sizeof(node) * (this->size - idx));
-
- this->content = children;
- this->size++;
-}
-
-void node__prefix(node this, node child) {
- /* TODO: Flip a nut if `this` isn’t an `SCOPE` or `EXPRESSION`.
- TODO: Flip a nut if `this` is a `SCOPE` and `child` is a `WORD`. */
-
- node *children = malloc(sizeof(node) * this->size + 1);
- memcpy(children + 1, this->content, sizeof(node) * this->size);
- children[0] = child;
-
- this->content = children;
- this->size++;
-}
-
-void node__affix(node this, node child) {
- /* TODO: Flip a nut if `this` isn’t an `SCOPE` or `EXPRESSION`.
- TODO: Flip a nut if `this` is a `SCOPE` and `child` is a `WORD`. */
-
- this->content = realloc(this->content, sizeof(node) * ++this->size);
- ((node *)this->content)[this->size - 1] = child;
-}
-
-node node__at(node this, node_size idx) {
- /* TODO: Flip a nut if `this` isn’t an `SCOPE` or `EXPRESSION`.
- TODO: Flip a nut if `size` is smaller than `idx`. */
-
- return *((node *)this->content + idx);
-}
-
-char* node__native(node this) {
- /* TODO: Flip a nut if `this` isn’t a `WORD`. */
-
- return this->content;
-}
-
-node _node__duplicate (node this, bool set_archetype);
-node node__duplicate (node this) { return _node__duplicate(this, false); }
-node node__instantiate(node this) { return _node__duplicate(this, true); }
-
-node _node__duplicate(node this, bool set_archetype) {
- node new;
-
- if (this->type == WORD)
- new = Node->word(this->content);
- else {
- /* FIXME: If we use `Node->word()` here, we should use
- `Node->scope()` and `Node->expression()` as well. */
- new = Node->allocate(this->type);
- node *children = malloc(sizeof(node) * this->size);
- for (node_size i = 0; i < this->size; ++i)
- children[i] = _node__duplicate(((node *)this->content)[i], set_archetype);
- new->content = children; new->size = this->size;
- }
-
- if(set_archetype)
- new->archetype = this;
-
- return new;
-}
-
-# endif
View
240 Source/Types/execution/ast.tests.c
@@ -1,240 +0,0 @@
-# include "ast.c"
-
-# define DECLARATIONS
-# include "Cest.c"
-# undef DECLARATIONS
-
-
-CEST(Node, allocate) {
- node a_node;
-
- a_node = Node->allocate(SCOPE);
- ASSERT( a_node->start == 0 );
- ASSERT( a_node->end == 0 );
- ASSERT( a_node->archetype == NULL );
- ASSERT( a_node->size == 0 );
- ASSERT( a_node->content == NULL );
-
- ASSERT( a_node->type == SCOPE );
- a_node = Node->allocate(EXPRESSION);
- ASSERT( a_node->type == EXPRESSION );
- a_node = Node->allocate(WORD);
- ASSERT( a_node->type == WORD );
-
- SUCCEED;
-}
-
-CEST(Node, scope) {
- node a_scope;
-
- a_scope = Node->scope();
- ASSERT( a_scope->type == SCOPE );
-
- SUCCEED;
-}
-
-CEST(Node, expression) {
- node a_expression;
-
- a_expression = Node->expression();
- ASSERT( a_expression->type == EXPRESSION );
-
- SUCCEED;
-}
-
-CEST(Node, word) {
- node a_word;
-
- a_word = Node->word("foo");
- ASSERT( a_word->type == WORD );
- ASSERT( a_word->size == 4 );
-
- ASSERT( strcmp(a_word->content, "foo") == 0 );
-
- SUCCEED;
-}
-
-CEST(node, insert) {
- node parent = Node->expression(),
- child1 = Node->word("foo"),
- child2 = Node->word("bar"),
- child3 = Node->word("baz");
-
-
- Node->insert(parent, child1, 0);
- ASSERT( *((node *)parent->content + 0) == child1 );
- ASSERT( parent->size == 1 );
-
- Node->insert(parent, child3, 1);
- ASSERT( *((node *)parent->content + 0) == child1 );
- ASSERT( *((node *)parent->content + 1) == child3 );
- ASSERT( parent->size == 2 );
-
- Node->insert(parent, child2, 1);
- ASSERT( *((node *)parent->content + 0) == child1 );
- ASSERT( *((node *)parent->content + 1) == child2 );
- ASSERT( *((node *)parent->content + 2) == child3 );
- ASSERT( parent->size == 3 );
-
- SUCCEED;
-}
-
-CEST(node, prefix) {
- node parent = Node->expression(),
- child1 = Node->word("foo"),
- child2 = Node->word("bar"),
- child3 = Node->word("baz");
-
- Node->prefix(parent, child3);
- ASSERT( *((node *)parent->content + 0) == child3 );
- ASSERT( parent->size == 1 );
-
- Node->prefix(parent, child2);
- ASSERT( *((node *)parent->content + 0) == child2 );
- ASSERT( *((node *)parent->content + 1) == child3 );
- ASSERT( parent->size == 2 );
-
- Node->prefix(parent, child1);
- ASSERT( *((node *)parent->content + 0) == child1 );
- ASSERT( *((node *)parent->content + 1) == child2 );
- ASSERT( *((node *)parent->content + 2) == child3 );
- ASSERT( parent->size == 3 );
-
- SUCCEED;
-}
-
-CEST(node, affix) {
- node parent = Node->expression(),
- child1 = Node->word("foo"),
- child2 = Node->word("bar"),
- child3 = Node->word("baz");
-
- Node->affix(parent, child1);
- ASSERT( *((node *)parent->content + 0) == child1 );
- ASSERT( parent->size == 1 );
-
- Node->affix(parent, child2);
- ASSERT( *((node *)parent->content + 0) == child1 );
- ASSERT( *((node *)parent->content + 1) == child2 );
- ASSERT( parent->size == 2 );
-
- Node->affix(parent, child3);
- ASSERT( *((node *)parent->content + 0) == child1 );
- ASSERT( *((node *)parent->content + 1) == child2 );
- ASSERT( *((node *)parent->content + 2) == child3 );
- ASSERT( parent->size == 3 );
-
- SUCCEED;
-}
-
-CEST(node, at) {
- node parent = Node->expression(),
- child1 = Node->word("foo"),
- child2 = Node->word("bar"),
- child3 = Node->word("baz");
-
- Node->affix(parent, child1);
- Node->affix(parent, child2);
- Node->affix(parent, child3);
-
- ASSERT( Node->at(parent, 0) == child1 );
- ASSERT( Node->at(parent, 1) == child2 );
- ASSERT( Node->at(parent, 2) == child3 );
-
- SUCCEED;
-}
-
-CEST(node, native) {
- node a_word;
-
- a_word = Node->word("foo");
- ASSERT( strcmp(Node->native(a_word), "foo") == 0 );
-
- SUCCEED;
-}
-
-CEST(node, duplicate) {
- node a_word = Node->word("foo"), another_word;
-
- another_word = Node->duplicate(a_word);
- ASSERT( another_word != a_word );
- ASSERT( another_word->archetype == NULL );
-
- ASSERT( another_word->type == WORD );
- ASSERT( another_word->size == 4 );
-
- ASSERT( strcmp(another_word->content, "foo") == 0 );
-
-
- node an_expression = Node->expression(), another_expression,
- child1 = Node->word("foo"),
- child2 = Node->word("bar"),
- child3 = Node->word("baz");
-
- Node->affix(an_expression, child1);
- Node->affix(an_expression, child2);
- Node->affix(an_expression, child3);
-
- another_expression = Node->duplicate(an_expression);
- ASSERT( another_expression != an_expression );
- ASSERT( another_expression->archetype == NULL );
-
- ASSERT( another_expression->type == EXPRESSION );
- ASSERT( another_expression->size == 3 );
-
- ASSERT( Node->at(another_expression, 0) != child1 );
- ASSERT( Node->at(another_expression, 0)->archetype == NULL );
- ASSERT( Node->at(another_expression, 1) != child2 );
- ASSERT( Node->at(another_expression, 1)->archetype == NULL );
- ASSERT( Node->at(another_expression, 2) != child3 );
- ASSERT( Node->at(another_expression, 2)->archetype == NULL );
-
- ASSERT( strcmp(Node->at(another_expression, 0)->content, "foo") == 0 );
- ASSERT( strcmp(Node->at(another_expression, 1)->content, "bar") == 0 );
- ASSERT( strcmp(Node->at(another_expression, 2)->content, "baz") == 0 );
-
- SUCCEED;
-}
-
-CEST(node, instantiate) {
- node a_word = Node->word("foo"), another_word;
-
- another_word = Node->instantiate(a_word);
- ASSERT( another_word != a_word );
- ASSERT( another_word->archetype == a_word );
-
- ASSERT( another_word->type == WORD );
- ASSERT( another_word->size == 4 );
-
- ASSERT( strcmp(another_word->content, "foo") == 0 );
-
-
- node an_expression = Node->expression(), another_expression,
- child1 = Node->word("foo"),
- child2 = Node->word("bar"),
- child3 = Node->word("baz");
-
- Node->affix(an_expression, child1);
- Node->affix(an_expression, child2);
- Node->affix(an_expression, child3);
-
- another_expression = Node->instantiate(an_expression);
- ASSERT( another_expression != an_expression );
- ASSERT( another_expression->archetype == an_expression );
-
- ASSERT( another_expression->type == EXPRESSION );
- ASSERT( another_expression->size == 3 );
-
- ASSERT( Node->at(another_expression, 0) != child1 );
- ASSERT( Node->at(another_expression, 0)->archetype == child1 );
- ASSERT( Node->at(another_expression, 1) != child2 );
- ASSERT( Node->at(another_expression, 1)->archetype == child2 );
- ASSERT( Node->at(another_expression, 2) != child3 );
- ASSERT( Node->at(another_expression, 2)->archetype == child3 );
-
- ASSERT( strcmp(Node->at(another_expression, 0)->content, "foo") == 0 );
- ASSERT( strcmp(Node->at(another_expression, 1)->content, "bar") == 0 );
- ASSERT( strcmp(Node->at(another_expression, 2)->content, "baz") == 0 );
-
- SUCCEED;
-}
View
184 Source/Types/execution/execution.c
@@ -1,184 +0,0 @@
-# if !defined(ROUTINE_DECLARATIONS)
-# define ROUTINE_DECLARATIONS
-
-# if !defined(DECLARATIONS)
-# define ROUTINE_C__BEHEST
-# define DECLARATIONS
-# endif
-# include "Paws.c/Core.h"
-# include "Paws.c/Types/Types.h"
-
-# include "ast.c"
-# include "Paws.c/Types/list/list.c"
-
-# include <stdbool.h>
-# if defined(ROUTINE_C__BEHEST)
-# undef DECLARATIONS
-# endif
-
-
-/* =========================
-= `infrastructure routine` =
-========================= */
-
-/* ### Data Types & Structures ### */
-
-/* Don’t you gotta love C’s syntax for function pointers? :D Anyway, this type represents the standard function
- * signature for a ‘native routine’ in Paws—that is, if you write a C function that is intended to be usable as
- * a `routine` from libspace, then it needs to match this signature (or something which will mask out *against*
- * this signature—examples below), and then be wrapped in a `routine` object with `Routine->expose()`. */
-//typedef void (*)( E(thing) exe ) E(native);
- typedef void (*E(native))( E(thing) exe ) ;
-
-/* It’s important to note that Paws types ‘collapse’ (that is, you can mask one ‘down’ to another with a C cast;
- * see `Paws.c` for a much more thorough explanation); as long as your `native` takes soemthing that is mask-safe
- * against the above signature, it is supported. Some examples:
- *
- * void my_func(thing something);
- * void my_func(execution exe); // Only for complex natives
- * void my_func(list something);
- *
- */
-
-/* `infrastructure routine`, the core interally-available *code* data structure.
- *--
- * TODO: More description! */
-struct E(routine) {
- E(ll) content; /* The `ll` behind this `routine`’s `list` interface */
-
- bool simple; /* Whether or not `implementation` (if `native`) is to be treated ‘simply.’ */
- struct {
- bool native; /* Whether or not `implementation` is a pointer to a native function */
- union { E(node) scope; E(native) function; } //»
- _; /* A pointer to either a `SCOPE` `node` (this routine’s AST), or a native function */
- } implementation;
-};
-
-
-/* ### Method Declarations ### */
-
-struct E(Routine) {
- /* `Routine` functions */
- E(routine) (*allocate) ( E(node) implementation );
- E(routine) (*expose) ( E(native) implementation, bool simple );
-
- /* `struct routine` methods */
- E(thing) (*thing) ( E(routine) this );
- void (*execute) ( E(routine) this, E(thing) argument );
-};
-# if !defined(EXTERNALIZE)
- struct E(Routine) extern *Routine;
-# endif
-
-void Paws__register_Routine ( void );
-
-
-
-# endif
-# if !defined(ROUTINE_IMPLEMENTATION) && !defined(DECLARATIONS) /* ====================================== BODY */
-# define ROUTINE_IMPLEMENTATION
-
-# define DECLARATIONS
-# include "Paws.c/Paws.c"
-# include <stdlib.h>
-# include <string.h>
-# undef DECLARATIONS
-
-
-/* ### Method Declarations ### */
-
-routine Routine__allocate (node implementation);
-routine Routine__expose (native implementation, bool simple);
-
-thing routine__thing (routine this);
-void routine__execute (routine this, thing argument);
-
- struct Routine // »
- *Routine = NULL;
-void Paws__register_Routine(void) { Routine = malloc(sizeof(struct Routine));
- Paws->Routine = Routine;
-
- struct Routine // »
- data = {
- .allocate = Routine__allocate,
- .expose = Routine__expose,
-
- .thing = routine__thing,
- .execute = routine__execute
- };
-
- memcpy(Routine, &data, sizeof(struct Routine));
-
- Paws__register_AST();
- Paws__register_Node();
-}
-
-
-/* ### Method Implementations ### */
-
-/* This method allocates a new `infrastructure routine`, and returns a C `routine` (a pointer to a
- * `struct routine`.) It takes an either an AST’s `SCOPE` `node`, or a pointer to a native C function (the
- * signature of which is expected to match `void (*)( E(thing) exe )`, though the usual function-pointer
- * semantics apply). The second argument is a `bool` describing whether the first argument was the former or the
- * latter (to be `true` in the case of a function pointer).
- *
- * If you pass in an AST instead of a native implementation, this copies the content of that `SCOPE`, allowing
- * you to destroy or modify the passed AST as you desire. */
-routine _Routine__allocate(bool nate, bool simple) {
- routine this = malloc(sizeof(struct routine));
-
- this->content = LL->allocate();
-
- this->simple = simple;
- this->implementation.native = nate;
- this->implementation._.scope = NULL;
-
- return this;
-}
-
-routine Routine__allocate(node implementation) {
- routine this = _Routine__allocate(false, false);
-
- /* TODO: Check if `implementation` is actually a `SCOPE`-type `node`. */
- this->implementation.native = false;
- this->implementation._.scope = Node->duplicate(implementation);
-
- return this;
-}
-routine Routine__expose (native implementation, bool simple) {
- routine this = _Routine__allocate(true, simple);
-
- this->implementation.native = true;
- this->implementation._.function = implementation;
-
- return this;
-}
-
-
-/* This method wraps a pointer to a `struct list` into a new `thing` union, and returns that union. */
-thing routine__thing(routine this) {
- struct thing something = {
- .isa = ROUTINE,
- .pointer = { .routine = this }
- };
-
- return something;
-}
-
-/* This executes a `routine` directly, without requiring that you properly setting up an `execution`. Unless you
- * have a reason to be using this, you should probably be calling `Execution->exercise()` instead. */
-void routine__execute(routine this, thing argument) {
- if (this->implementation.native) {
- if (this->simple) ( (void (*)(thing)) this->implementation._.function )(argument );
- else ( (void (*)(execution))this->implementation._.function )(Paws->Execution->allocate());
- } else {
- /* TODO: Implement me! */
- }
-
- /* It’s important to note that this might not ever get around to `return`ing, because asynchronous routines
- * have a good chance of `pthread_exit(3)`ing (or otherwise terminating the `routine` execution early), if they
- * farm out a call to another `routine` or something. */
- return;
-}
-
-# endif
View
56 Source/Types/execution/execution.tests.c
@@ -1,56 +0,0 @@
-# include "routine.c"
-
-# define DECLARATIONS
-# include "Cest.c"
-# undef DECLARATIONS
-
-
-void a_native(void) { return; }
-
-CEST(Routine, allocate) {
- node a_scope, an_expression, a_word, another_word;
- routine a_routine;
-
- a_scope = Node->scope();
- an_expression = Node->expression(); Node->affix(a_scope, an_expression);
- a_word = Node->word("foo"); Node->affix(an_expression, a_word);
- another_word = Node->word("bar"); Node->affix(an_expression, another_word);
-
- a_routine = Routine->allocate(a_scope);
- ASSERT( a_routine->content->first == NULL );
- ASSERT( a_routine->content->last == NULL );
- ASSERT( a_routine->content->length == 0 );
-
- ASSERT(!a_routine->implementation.native );
- ASSERT( a_routine->implementation._.scope != a_scope );
- ASSERT( strcmp(Node->at(Node->at(a_routine->implementation._.scope, 0), 0)->content, "foo") == 0 );
- ASSERT( strcmp(Node->at(Node->at(a_routine->implementation._.scope, 0), 1)->content, "bar") == 0 );
-
- SUCCEED;
-}
-
-CEST(Routine, expose) {
- routine a_routine;
-
- a_routine = Routine->expose((native)a_native, false);
- ASSERT( a_routine->content->first == NULL );
- ASSERT( a_routine->content->last == NULL );
- ASSERT( a_routine->content->length == 0 );
-
- ASSERT( a_routine->implementation.native );
- ASSERT( (native)a_routine->implementation._.function == (native)a_native );
-
- SUCCEED;
-}
-
-CEST(routine, thing) {
- node a_scope = Node->scope();
- routine a_routine = Routine->allocate(a_scope);
-
- ASSERT( Routine->thing(a_routine).isa == ROUTINE );
- ASSERT( Routine->thing(a_routine).pointer.routine == a_routine );
-
- SUCCEED;
-}
-
-CEST(routine, execute) { PEND; }

0 comments on commit 8a1c18a

Please sign in to comment.
Something went wrong with that request. Please try again.