about summary refs log tree commit diff stats
path: root/dwm.h
blob: 29aa6a29d2bf7528451c4bafee03a018f5d24eb6 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
/*
 * (C)opyright MMVI Anselm R. Garbe <garbeam at gmail dot com>
 * See LICENSE file for license details.
 */

#include <X11/Xlib.h>

/********** CUSTOMIZE **********/

#define FONT				"-*-terminus-medium-*-*-*-13-*-*-*-*-*-iso10646-*"
#define BGCOLOR				"#666699"
#define FGCOLOR				"#eeeeee"
#define BORDERCOLOR			"#9999CC"
#define MASTERW				52 /* percent */
#define WM_PROTOCOL_DELWIN	1

/* tags */
enum { Tscratch, Tdev, Twww, Twork, TLast };

/********** CUSTOMIZE **********/

typedef union Arg Arg;
typedef struct DC DC;
typedef struct Client Client;
typedef struct Fnt Fnt;
typedef struct Key Key;
typedef struct Rule Rule;

union Arg {
	const char **argv;
	int i;
};

/* atoms */
enum { WMProtocols, WMDelete, WMLast };
enum { NetSupported, NetWMName, NetLast };

/* cursor */
enum { CurNormal, CurResize, CurMove, CurInput, CurLast };

struct Fnt {
	XFontStruct *xfont;
	XFontSet set;
	int ascent;
	int descent;
	int height;
};

struct DC { /* draw context */
	GC gc;
	Drawable drawable;
	int x, y, w, h;
	Fnt font;
	unsigned long bg;
	unsigned long fg;
	unsigned long border;
};

struct Client {
	char name[256];
	char *tags[TLast];
	int proto;
	int x, y, w, h;
	int tx, ty, tw, th;
	int basew, baseh, incw, inch, maxw, maxh, minw, minh;
	int grav;
	unsigned int border;
	long flags; 
	Bool floating;
	Window win;
	Window title;
	Client *next;
	Client *revert;
};

struct Rule {
	const char *class;
	const char *instance;
	char *tags[TLast];
	Bool floating;
};

struct Key {
	unsigned long mod;
	KeySym keysym;
	void (*func)(Arg *arg);
	Arg arg;
};

extern Display *dpy;
extern Window root, barwin;
extern Atom wm_atom[WMLast], net_atom[NetLast];
extern Cursor cursor[CurLast];
extern Bool running, issel;
extern void (*handler[LASTEvent])(XEvent *);
extern void (*arrange)(Arg *);

extern int tsel, screen, sx, sy, sw, sh, bx, by, bw, bh, mw;
extern char *tags[TLast], stext[1024];

extern DC dc;
extern Client *clients, *sel;

/* bar.c */
extern void draw_bar();
extern void barclick(XButtonPressedEvent *e);

/* client.c */
extern void manage(Window w, XWindowAttributes *wa);
extern void unmanage(Client *c);
extern Client *getclient(Window w);
extern void focus(Client *c);
extern void update_name(Client *c);
extern void draw_client(Client *c);
extern void resize(Client *c, Bool inc);
extern void update_size(Client *c);
extern Client *gettitle(Window w);
extern void craise(Client *c);
extern void lower(Client *c);
extern void ckill(Arg *arg);
extern void nextc(Arg *arg);
extern void prevc(Arg *arg);
extern void max(Arg *arg);
extern void floating(Arg *arg);
extern void tiling(Arg *arg);
extern void ttrunc(Arg *arg);
extern void tappend(Arg *arg);
extern void view(Arg *arg);
extern void zoom(Arg *arg);
extern void gravitate(Client *c, Bool invert);

/* draw.c */
extern void drawtext(const char *text, Bool border);
extern unsigned long initcolor(const char *colstr);
extern void initfont(const char *fontstr);
extern unsigned int textnw(char *text, unsigned int len);
extern unsigned int textw(char *text);
extern unsigned int texth(void);

/* event.c */
extern void discard_events(long even_mask);

/* dev.c */
extern void update_keys(void);
extern void keypress(XEvent *e);
extern void mresize(Client *c);
extern void mmove(Client *c);

/* main.c */
extern int error_handler(Display *dsply, XErrorEvent *e);
extern void send_message(Window w, Atom a, long value);
extern int win_proto(Window w);
extern void quit(Arg *arg);

/* util.c */
extern void error(const char *errstr, ...);
extern void *emallocz(unsigned int size);
extern void *emalloc(unsigned int size);
extern void *erealloc(void *ptr, unsigned int size);
extern char *estrdup(const char *str);
extern void spawn(Arg *arg);
extern void swap(void **p1, void **p2);
/span> id="L10" class="LineNr"> 10 </span><span class="Delimiter">:(scenario deep_copy_number)</span> <span id="L11" class="LineNr"> 11 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [ <span id="L12" class="LineNr"> 12 </span> local-scope <span id="L13" class="LineNr"> 13 </span> <span class="Normal">x</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span> <span id="L14" class="LineNr"> 14 </span> <span class="Normal">y</span>:num<span class="Special"> &lt;- </span>deep-copy x <span id="L15" class="LineNr"> 15 </span> <span class="Constant">10</span>:<span class="Normal">bool</span>/<span class="Special">raw &lt;- </span>equal x<span class="Delimiter">,</span> y <span id="L16" class="LineNr"> 16 </span>] <span id="L17" class="LineNr"> 17 </span><span class="Comment"># non-address primitives are identical</span> <span id="L18" class="LineNr"> 18 </span><span class="traceContains">+mem: storing 1 in location 10</span> <span id="L19" class="LineNr"> 19 </span> <span id="L20" class="LineNr"> 20 </span><span class="Delimiter">:(scenario deep_copy_null_pointer)</span> <span id="L21" class="LineNr"> 21 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [ <span id="L22" class="LineNr"> 22 </span> local-scope <span id="L23" class="LineNr"> 23 </span> <span class="Normal">x</span>:&amp;:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span> <span id="L24" class="LineNr"> 24 </span> <span class="Normal">y</span>:&amp;:num<span class="Special"> &lt;- </span>deep-copy x <span id="L25" class="LineNr"> 25 </span> <span class="Constant">10</span>:<span class="Normal">bool</span>/<span class="Special">raw &lt;- </span>equal x<span class="Delimiter">,</span> y <span id="L26" class="LineNr"> 26 </span>] <span id="L27" class="LineNr"> 27 </span><span class="Comment"># null addresses are identical</span> <span id="L28" class="LineNr"> 28 </span><span class="traceContains">+mem: storing 1 in location 10</span> <span id="L29" class="LineNr"> 29 </span> <span id="L30" class="LineNr"> 30 </span><span class="Delimiter">:(scenario deep_copy_container_without_address)</span> <span id="L31" class="LineNr"> 31 </span><span class="muData">container</span> foo [ <span id="L32" class="LineNr"> 32 </span> <span class="Normal">x</span>:num <span id="L33" class="LineNr"> 33 </span> <span class="Normal">y</span>:num <span id="L34" class="LineNr"> 34 </span>] <span id="L35" class="LineNr"> 35 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [ <span id="L36" class="LineNr"> 36 </span> local-scope <span id="L37" class="LineNr"> 37 </span> <span class="Normal">a</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">34</span><span class="Delimiter">,</span> <span class="Constant">35</span> <span id="L38" class="LineNr"> 38 </span> <span class="Normal">b</span>:foo<span class="Special"> &lt;- </span>deep-copy a <span id="L39" class="LineNr"> 39 </span> <span class="Constant">10</span>:<span class="Normal">bool</span>/<span class="Special">raw &lt;- </span>equal a<span class="Delimiter">,</span> b <span id="L40" class="LineNr"> 40 </span>] <span id="L41" class="LineNr"> 41 </span><span class="Comment"># containers are identical as long as they don't contain addresses</span> <span id="L42" class="LineNr"> 42 </span><span class="traceContains">+mem: storing 1 in location 10</span> <span id="L43" class="LineNr"> 43 </span> <span id="L44" class="LineNr"> 44 </span><span class="Delimiter">:(scenario deep_copy_address)</span> <span id="L45" class="LineNr"> 45 </span><span class="Special">% Memory_allocated_until = 200;</span> <span id="L46" class="LineNr"> 46 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [ <span id="L47" class="LineNr"> 47 </span> <span class="Comment"># avoid all memory allocations except the implicit ones inside deep-copy, so</span> <span id="L48" class="LineNr"> 48 </span> <span class="Comment"># that the result is deterministic</span> <span id="L49" class="LineNr"> 49 </span> <span class="Constant">1</span>:&amp;:num<span class="Special"> &lt;- </span>copy <span class="Constant">100</span>/unsafe <span class="Comment"># pretend allocation</span> <span id="L50" class="LineNr"> 50 </span> *<span class="Constant">1</span>:&amp;:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span> <span id="L51" class="LineNr"> 51 </span> <span class="Constant">2</span>:&amp;:num<span class="Special"> &lt;- </span>deep-copy <span class="Constant">1</span>:&amp;:num <span id="L52" class="LineNr"> 52 </span> <span class="Constant">10</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>equal <span class="Constant">1</span>:&amp;:num<span class="Delimiter">,</span> <span class="Constant">2</span>:&amp;:num <span id="L53" class="LineNr"> 53 </span> <span class="Constant">11</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>equal *<span class="Constant">1</span>:&amp;:num<span class="Delimiter">,</span> *<span class="Constant">2</span>:&amp;:num <span id="L54" class="LineNr"> 54 </span> <span class="Constant">2</span>:&amp;:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span> <span id="L55" class="LineNr"> 55 </span>] <span id="L56" class="LineNr"> 56 </span><span class="Comment"># the result of deep-copy is a new address</span> <span id="L57" class="LineNr"> 57 </span><span class="traceContains">+mem: storing 0 in location 10</span> <span id="L58" class="LineNr"> 58 </span><span class="Comment"># however, the contents are identical</span> <span id="L59" class="LineNr"> 59 </span><span class="traceContains">+mem: storing 1 in location 11</span> <span id="L60" class="LineNr"> 60 </span> <span id="L61" class="LineNr"> 61 </span><span class="Delimiter">:(scenario deep_copy_address_to_container)</span> <span id="L62" class="LineNr"> 62 </span><span class="Special">% Memory_allocated_until = 200;</span> <span id="L63" class="LineNr"> 63 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [ <span id="L64" class="LineNr"> 64 </span> <span class="Comment"># avoid all memory allocations except the implicit ones inside deep-copy, so</span> <span id="L65" class="LineNr"> 65 </span> <span class="Comment"># that the result is deterministic</span> <span id="L66" class="LineNr"> 66 </span> <span class="Constant">1</span>:&amp;:point<span class="Special"> &lt;- </span>copy <span class="Constant">100</span>/unsafe <span class="Comment"># pretend allocation</span> <span id="L67" class="LineNr"> 67 </span> *<span class="Constant">1</span>:&amp;:point<span class="Special"> &lt;- </span>merge <span class="Constant">34</span><span class="Delimiter">,</span> <span class="Constant">35</span> <span id="L68" class="LineNr"> 68 </span> <span class="Constant">2</span>:&amp;:point<span class="Special"> &lt;- </span>deep-copy <span class="Constant">1</span>:&amp;:point <span id="L69" class="LineNr"> 69 </span> <span class="Constant">10</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>equal <span class="Constant">1</span>:&amp;:point<span class="Delimiter">,</span> <span class="Constant">2</span>:&amp;:point <span id="L70" class="LineNr"> 70 </span> <span class="Constant">11</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>equal *<span class="Constant">1</span>:&amp;:point<span class="Delimiter">,</span> *<span class="Constant">2</span>:&amp;:point <span id="L71" class="LineNr"> 71 </span>] <span id="L72" class="LineNr"> 72 </span><span class="Comment"># the result of deep-copy is a new address</span> <span id="L73" class="LineNr"> 73 </span><span class="traceContains">+mem: storing 0 in location 10</span> <span id="L74" class="LineNr"> 74 </span><span class="Comment"># however, the contents are identical</span> <span id="L75" class="LineNr"> 75 </span><span class="traceContains">+mem: storing 1 in location 11</span> <span id="L76" class="LineNr"> 76 </span> <span id="L77" class="LineNr"> 77 </span><span class="Delimiter">:(scenario deep_copy_address_to_address)</span> <span id="L78" class="LineNr"> 78 </span><span class="Special">% Memory_allocated_until = 200;</span> <span id="L79" class="LineNr"> 79 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [ <span id="L80" class="LineNr"> 80 </span> <span class="Comment"># avoid all memory allocations except the implicit ones inside deep-copy, so</span> <span id="L81" class="LineNr"> 81 </span> <span class="Comment"># that the result is deterministic</span> <span id="L82" class="LineNr"> 82 </span> <span class="Constant">1</span>:&amp;:&amp;:num<span class="Special"> &lt;- </span>copy <span class="Constant">100</span>/unsafe <span class="Comment"># pretend allocation</span> <span id="L83" class="LineNr"> 83 </span> *<span class="Constant">1</span>:&amp;:&amp;:num<span class="Special"> &lt;- </span>copy <span class="Constant">150</span>/unsafe <span id="L84" class="LineNr"> 84 </span> **<span class="Constant">1</span>:&amp;:&amp;:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span> <span id="L85" class="LineNr"> 85 </span> <span class="Constant">2</span>:&amp;:&amp;:num<span class="Special"> &lt;- </span>deep-copy <span class="Constant">1</span>:&amp;:&amp;:num <span id="L86" class="LineNr"> 86 </span> <span class="Constant">10</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>equal <span class="Constant">1</span>:&amp;:&amp;:num<span class="Delimiter">,</span> <span class="Constant">2</span>:&amp;:&amp;:num <span id="L87" class="LineNr"> 87 </span> <span class="Constant">11</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>equal *<span class="Constant">1</span>:&amp;:&amp;:num<span class="Delimiter">,</span> *<span class="Constant">2</span>:&amp;:&amp;:num <span id="L88" class="LineNr"> 88 </span> <span class="Constant">12</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>equal **<span class="Constant">1</span>:&amp;:&amp;:num<span class="Delimiter">,</span> **<span class="Constant">2</span>:&amp;:&amp;:num <span id="L89" class="LineNr"> 89 </span>] <span id="L90" class="LineNr"> 90 </span><span class="Comment"># the result of deep-copy is a new address</span> <span id="L91" class="LineNr"> 91 </span><span class="traceContains">+mem: storing 0 in location 10</span> <span id="L92" class="LineNr"> 92 </span><span class="Comment"># any addresses in it or pointed to it are also new</span> <span id="L93" class="LineNr"> 93 </span><span class="traceContains">+mem: storing 0 in location 11</span> <span id="L94" class="LineNr"> 94 </span><span class="Comment"># however, the non-address contents are identical</span> <span id="L95" class="LineNr"> 95 </span><span class="traceContains">+mem: storing 1 in location 12</span> <span id="L96" class="LineNr"> 96 </span> <span id="L97" class="LineNr"> 97 </span><span class="Delimiter">:(scenario deep_copy_array)</span> <span id="L98" class="LineNr"> 98 </span><span class="Special">% Memory_allocated_until = 200;</span> <span id="L99" class="LineNr"> 99 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [ <span id="L100" class="LineNr">100 </span> <span class="Comment"># avoid all memory allocations except the implicit ones inside deep-copy, so</span> <span id="L101" class="LineNr">101 </span> <span class="Comment"># that the result is deterministic</span> <span id="L102" class="LineNr">102 </span> <span class="Constant">100</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">3</span> <span class="Comment"># pretend array length</span> <span id="L103" class="LineNr">103 </span> <span class="Constant">1</span>:&amp;:@:num<span class="Special"> &lt;- </span>copy <span class="Constant">100</span>/unsafe <span class="Comment"># pretend allocation</span> <span id="L104" class="LineNr">104 </span> put-index *<span class="Constant">1</span>:&amp;:@:num<span class="Delimiter">,</span> <span class="Constant">0</span><span class="Delimiter">,</span> <span class="Constant">34</span> <span id="L105" class="LineNr">105 </span> put-index *<span class="Constant">1</span>:&amp;:@:num<span class="Delimiter">,</span> <span class="Constant">1</span><span class="Delimiter">,</span> <span class="Constant">35</span> <span id="L106" class="LineNr">106 </span> put-index *<span class="Constant">1</span>:&amp;:@:num<span class="Delimiter">,</span> <span class="Constant">2</span><span class="Delimiter">,</span> <span class="Constant">36</span> <span id="L107" class="LineNr">107 </span> stash [old:]<span class="Delimiter">,</span> *<span class="Constant">1</span>:&amp;:@:num <span id="L108" class="LineNr">108 </span> <span class="Constant">2</span>:&amp;:@:num<span class="Special"> &lt;- </span>deep-copy <span class="Constant">1</span>:&amp;:@:num <span id="L109" class="LineNr">109 </span> stash <span class="Constant">2</span>:&amp;:@:num <span id="L110" class="LineNr">110 </span> stash [<span class="Normal">new</span>:]<span class="Delimiter">,</span> *<span class="Constant">2</span>:&amp;:@:num <span id="L111" class="LineNr">111 </span> <span class="Constant">10</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>equal <span class="Constant">1</span>:&amp;:@:num<span class="Delimiter">,</span> <span class="Constant">2</span>:&amp;:@:num <span id="L112" class="LineNr">112 </span> <span class="Constant">11</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>equal *<span class="Constant">1</span>:&amp;:@:num<span class="Delimiter">,</span> *<span class="Constant">2</span>:&amp;:@:num <span id="L113" class="LineNr">113 </span>] <span id="L114" class="LineNr">114 </span><span class="traceContains">+app: old: 3 34 35 36</span> <span id="L115" class="LineNr">115 </span><span class="traceContains">+app: new: 3 34 35 36</span> <span id="L116" class="LineNr">116 </span><span class="Comment"># the result of deep-copy is a new address</span> <span id="L117" class="LineNr">117 </span><span class="traceContains">+mem: storing 0 in location 10</span> <span id="L118" class="LineNr">118 </span><span class="Comment"># however, the contents are identical</span> <span id="L119" class="LineNr">119 </span><span class="traceContains">+mem: storing 1 in location 11</span> <span id="L120" class="LineNr">120 </span> <span id="L121" class="LineNr">121 </span><span class="Delimiter">:(scenario deep_copy_container_with_address)</span> <span id="L122" class="LineNr">122 </span><span class="muData">container</span> foo [ <span id="L123" class="LineNr">123 </span> <span class="Normal">x</span>:num <span id="L124" class="LineNr">124 </span> <span class="Normal">y</span>:&amp;:num <span id="L125" class="LineNr">125 </span>] <span id="L126" class="LineNr">126 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [ <span id="L127" class="LineNr">127 </span> local-scope <span id="L128" class="LineNr">128 </span> <span class="Normal">y0</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span> <span id="L129" class="LineNr">129 </span> *y0<span class="Special"> &lt;- </span>copy <span class="Constant">35</span> <span id="L130" class="LineNr">130 </span> <span class="Normal">a</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">34</span><span class="Delimiter">,</span> y0 <span id="L131" class="LineNr">131 </span> <span class="Normal">b</span>:foo<span class="Special"> &lt;- </span>deep-copy a <span id="L132" class="LineNr">132 </span> <span class="Constant">10</span>:<span class="Normal">bool</span>/<span class="Special">raw &lt;- </span>equal a<span class="Delimiter">,</span> b <span id="L133" class="LineNr">133 </span> <span class="Normal">y1</span>:&amp;:num<span class="Special"> &lt;- </span>get b<span class="Delimiter">,</span> <span class="Constant">y:offset</span> <span id="L134" class="LineNr">134 </span> <span class="Constant">11</span>:<span class="Normal">bool</span>/<span class="Special">raw &lt;- </span>equal y0<span class="Delimiter">,</span> y1 <span id="L135" class="LineNr">135 </span> <span class="Constant">12</span>:num/<span class="Special">raw &lt;- </span>copy *y1 <span id="L136" class="LineNr">136 </span>] <span id="L137" class="LineNr">137 </span><span class="Comment"># containers containing addresses are not identical to their deep copies</span> <span id="L138" class="LineNr">138 </span><span class="traceContains">+mem: storing 0 in location 10</span> <span id="L139" class="LineNr">139 </span><span class="Comment"># the addresses they contain are not identical either</span> <span id="L140" class="LineNr">140 </span><span class="traceContains">+mem: storing 0 in location 11</span> <span id="L141" class="LineNr">141 </span><span class="traceContains">+mem: storing 35 in location 12</span> <span id="L142" class="LineNr">142 </span> <span id="L143" class="LineNr">143 </span><span class="Delimiter">:(scenario deep_copy_exclusive_container_with_address)</span> <span id="L144" class="LineNr">144 </span><span class="muData">exclusive-container</span> foo [ <span id="L145" class="LineNr">145 </span> <span class="Normal">x</span>:num <span id="L146" class="LineNr">146 </span> <span class="Normal">y</span>:&amp;:num <span id="L147" class="LineNr">147 </span>] <span id="L148" class="LineNr">148 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [ <span id="L149" class="LineNr">149 </span> local-scope <span id="L150" class="LineNr">150 </span> <span class="Normal">y0</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span> <span id="L151" class="LineNr">151 </span> *y0<span class="Special"> &lt;- </span>copy <span class="Constant">34</span> <span id="L152" class="LineNr">152 </span> <span class="Normal">a</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">1</span>/y<span class="Delimiter">,</span> y0 <span id="L153" class="LineNr">153 </span> <span class="Normal">b</span>:foo<span class="Special"> &lt;- </span>deep-copy a <span id="L154" class="LineNr">154 </span> <span class="Constant">10</span>:<span class="Normal">bool</span>/<span class="Special">raw &lt;- </span>equal a<span class="Delimiter">,</span> b <span id="L155" class="LineNr">155 </span> <span class="Normal">y1</span>:&amp;:num<span class="Delimiter">,</span> z:<span class="Normal">bool</span><span class="Special"> &lt;- </span>maybe-convert b<span class="Delimiter">,</span> <span class="Constant">y:variant</span> <span id="L156" class="LineNr">156 </span> <span class="Constant">11</span>:<span class="Normal">bool</span>/<span class="Special">raw &lt;- </span>equal y0<span class="Delimiter">,</span> y1 <span id="L157" class="LineNr">157 </span> <span class="Constant">12</span>:num/<span class="Special">raw &lt;- </span>copy *y1 <span id="L158" class="LineNr">158 </span>] <span id="L159" class="LineNr">159 </span><span class="Comment"># exclusive containers containing addresses are not identical to their deep copies</span> <span id="L160" class="LineNr">160 </span><span class="traceContains">+mem: storing 0 in location 10</span> <span id="L161" class="LineNr">161 </span><span class="Comment"># the addresses they contain are not identical either</span> <span id="L162" class="LineNr">162 </span><span class="traceContains">+mem: storing 0 in location 11</span> <span id="L163" class="LineNr">163 </span><span class="traceContains">+mem: storing 34 in location 12</span> <span id="L164" class="LineNr">164 </span> <span id="L165" class="LineNr">165 </span><span class="Delimiter">:(scenario deep_copy_exclusive_container_with_container_with_address)</span> <span id="L166" class="LineNr">166 </span><span class="muData">exclusive-container</span> foo [ <span id="L167" class="LineNr">167 </span> <span class="Normal">x</span>:num <span id="L168" class="LineNr">168 </span> <span class="Normal">y</span>:bar <span class="Comment"># inline</span> <span id="L169" class="LineNr">169 </span>] <span id="L170" class="LineNr">170 </span><span class="muData">container</span> bar [ <span id="L171" class="LineNr">171 </span> <span class="Normal">x</span>:&amp;:num <span id="L172" class="LineNr">172 </span>] <span id="L173" class="LineNr">173 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [ <span id="L174" class="LineNr">174 </span> local-scope <span id="L175" class="LineNr">175 </span> <span class="Normal">y0</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span> <span id="L176" class="LineNr">176 </span> *y0<span class="Special"> &lt;- </span>copy <span class="Constant">34</span> <span id="L177" class="LineNr">177 </span> <span class="Normal">a</span>:bar<span class="Special"> &lt;- </span>merge y0 <span id="L178" class="LineNr">178 </span> <span class="Normal">b</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">1</span>/y<span class="Delimiter">,</span> a <span id="L179" class="LineNr">179 </span> <span class="Normal">c</span>:foo<span class="Special"> &lt;- </span>deep-copy b <span id="L180" class="LineNr">180 </span> <span class="Constant">10</span>:<span class="Normal">bool</span>/<span class="Special">raw &lt;- </span>equal b<span class="Delimiter">,</span> c <span id="L181" class="LineNr">181 </span> <span class="Normal">d</span>:bar<span class="Delimiter">,</span> z:<span class="Normal">bool</span><span class="Special"> &lt;- </span>maybe-convert c<span class="Delimiter">,</span> <span class="Constant">y:variant</span> <span id="L182" class="LineNr">182 </span> <span class="Normal">y1</span>:&amp;:num<span class="Special"> &lt;- </span>get d<span class="Delimiter">,</span> <span class="Constant">x:offset</span> <span id="L183" class="LineNr">183 </span> <span class="Constant">11</span>:<span class="Normal">bool</span>/<span class="Special">raw &lt;- </span>equal y0<span class="Delimiter">,</span> y1 <span id="L184" class="LineNr">184 </span> <span class="Constant">12</span>:num/<span class="Special">raw &lt;- </span>copy *y1 <span id="L185" class="LineNr">185 </span>] <span id="L186" class="LineNr">186 </span><span class="Comment"># exclusive containers containing addresses are not identical to their deep copies</span> <span id="L187" class="LineNr">187 </span><span class="traceContains">+mem: storing 0 in location 10</span> <span id="L188" class="LineNr">188 </span><span class="Comment"># sub-containers containing addresses are not identical either</span> <span id="L189" class="LineNr">189 </span><span class="traceContains">+mem: storing 0 in location 11</span> <span id="L190" class="LineNr">190 </span><span class="traceContains">+mem: storing 34 in location 12</span> <span id="L191" class="LineNr">191 </span> <span id="L192" class="LineNr">192 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Declarations&quot;)</span> <span id="L193" class="LineNr">193 </span>DEEP_COPY<span class="Delimiter">,</span> <span id="L194" class="LineNr">194 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Numbers&quot;)</span> <span id="L195" class="LineNr">195 </span><a href='001help.cc.html#L221'>put</a><span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span> <span class="Constant">&quot;deep-copy&quot;</span><span class="Delimiter">,</span> DEEP_COPY<span class="Delimiter">);</span> <span id="L196" class="LineNr">196 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Checks&quot;)</span> <span id="L197" class="LineNr">197 </span><span class="Normal">case</span> DEEP_COPY: <span class="Delimiter">{</span> <span id="L198" class="LineNr">198 </span> <span class="Normal">if</span> <span class="Delimiter">(</span><a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">)</span> != <span class="Constant">1</span><span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L199" class="LineNr">199 </span> <a href='003trace.cc.html#L174'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'deep-copy' takes exactly one ingredient rather than '&quot;</span> &lt;&lt; to_original_string<span class="Delimiter">(</span>inst<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L203'>end</a><span class="Delimiter">();</span> <span id="L200" class="LineNr">200 </span> <span class="Identifier">break</span><span class="Delimiter">;</span> <span id="L201" class="LineNr">201 </span> <span class="Delimiter">}</span> <span id="L202" class="LineNr">202 </span> <span class="Normal">if</span> <span class="Delimiter">(</span><a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">)</span> != <span class="Constant">1</span><span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L203" class="LineNr">203 </span> <a href='003trace.cc.html#L174'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'deep-copy' takes exactly one ingredient rather than '&quot;</span> &lt;&lt; to_original_string<span class="Delimiter">(</span>inst<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L203'>end</a><span class="Delimiter">();</span> <span id="L204" class="LineNr">204 </span> <span class="Identifier">break</span><span class="Delimiter">;</span> <span id="L205" class="LineNr">205 </span> <span class="Delimiter">}</span> <span id="L206" class="LineNr">206 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>!types_strictly_match<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">),</span> inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">)))</span> <span class="Delimiter">{</span> <span id="L207" class="LineNr">207 </span> <a href='003trace.cc.html#L174'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'deep-copy' requires its ingredient and product to be the same type, but got '&quot;</span> &lt;&lt; to_original_string<span class="Delimiter">(</span>inst<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L203'>end</a><span class="Delimiter">();</span> <span id="L208" class="LineNr">208 </span> <span class="Identifier">break</span><span class="Delimiter">;</span> <span id="L209" class="LineNr">209 </span> <span class="Delimiter">}</span> <span id="L210" class="LineNr">210 </span> <span class="Identifier">break</span><span class="Delimiter">;</span> <span id="L211" class="LineNr">211 </span><span class="Delimiter">}</span> <span id="L212" class="LineNr">212 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Implementations&quot;)</span> <span id="L213" class="LineNr">213 </span><span class="Normal">case</span> DEEP_COPY: <span class="Delimiter">{</span> <span id="L214" class="LineNr">214 </span> products<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>deep_copy<span class="Delimiter">(</span><a href='026call.cc.html#L89'>current_instruction</a><span class="Delimiter">().</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">)));</span> <span id="L215" class="LineNr">215 </span> <span class="Identifier">break</span><span class="Delimiter">;</span> <span id="L216" class="LineNr">216 </span><span class="Delimiter">}</span> <span id="L217" class="LineNr">217 </span> <span id="L218" class="LineNr">218 </span><span class="Delimiter">:(code)</span> <span id="L219" class="LineNr">219 </span>vector&lt;<span class="Normal">double</span>&gt; deep_copy<span class="Delimiter">(</span><span class="Normal">const</span> reagent&amp; in<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L220" class="LineNr">220 </span> <span class="Comment">// allocate a tiny bit of temporary space for deep_copy()</span> <span id="L221" class="LineNr">221 </span> <a href='003trace.cc.html#L167'>trace</a><span class="Delimiter">(</span><span class="Constant">9991</span><span class="Delimiter">,</span> <span class="Constant">&quot;run&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;deep-copy: allocating space for temporary&quot;</span> &lt;&lt; <a href='003trace.cc.html#L203'>end</a><span class="Delimiter">();</span> <span id="L222" class="LineNr">222 </span> reagent tmp<span class="Delimiter">(</span><span class="Constant">&quot;tmp:<a href='043space.cc.html#L80'>address</a>:number&quot;</span><span class="Delimiter">);</span> <span id="L223" class="LineNr">223 </span> tmp<span class="Delimiter">.</span><a href='010vm.cc.html#L66'>set_value</a><span class="Delimiter">(</span>allocate<span class="Delimiter">(</span><span class="Constant">1</span><span class="Delimiter">));</span> <span id="L224" class="LineNr">224 </span> map&lt;<span class="Normal">int</span><span class="Delimiter">,</span> <span class="Normal">int</span>&gt; addresses_copied<span class="Delimiter">;</span> <span id="L225" class="LineNr">225 </span> vector&lt;<span class="Normal">double</span>&gt; result = deep_copy<span class="Delimiter">(</span>in<span class="Delimiter">,</span> addresses_copied<span class="Delimiter">,</span> tmp<span class="Delimiter">);</span> <span id="L226" class="LineNr">226 </span> <span class="Comment">// reclaim Mu memory allocated for tmp</span> <span id="L227" class="LineNr">227 </span> <a href='003trace.cc.html#L167'>trace</a><span class="Delimiter">(</span><span class="Constant">9991</span><span class="Delimiter">,</span> <span class="Constant">&quot;run&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;deep-copy: reclaiming temporary&quot;</span> &lt;&lt; <a href='003trace.cc.html#L203'>end</a><span class="Delimiter">();</span> <span id="L228" class="LineNr">228 </span> <a href='037abandon.cc.html#L48'>abandon</a><span class="Delimiter">(</span>tmp<span class="Delimiter">.</span>value<span class="Delimiter">,</span> <a href='036refcount.cc.html#L1'>payload_size</a><span class="Delimiter">(</span>tmp<span class="Delimiter">));</span> <span id="L229" class="LineNr">229 </span> <span class="Comment">// reclaim host memory allocated for tmp.type when tmp goes out of scope</span> <span id="L230" class="LineNr">230 </span> <span class="Identifier">return</span> result<span class="Delimiter">;</span> <span id="L231" class="LineNr">231 </span><span class="Delimiter">}</span> <span id="L232" class="LineNr">232 </span> <span id="L233" class="LineNr">233 </span>vector&lt;<span class="Normal">double</span>&gt; deep_copy<span class="Delimiter">(</span>reagent<span class="Comment">/*</span><span class="Comment">copy</span><span class="Comment">*/</span> in<span class="Delimiter">,</span> map&lt;<span class="Normal">int</span><span class="Delimiter">,</span> <span class="Normal">int</span>&gt;&amp; addresses_copied<span class="Delimiter">,</span> <span class="Normal">const</span> reagent&amp; tmp<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L234" class="LineNr">234 </span> canonize<span class="Delimiter">(</span>in<span class="Delimiter">);</span> <span id="L235" class="LineNr">235 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>is_mu_address<span class="Delimiter">(</span>in<span class="Delimiter">))</span> <span class="Delimiter">{</span> <span id="L236" class="LineNr">236 </span> <span class="Comment">// hack: skip primitive containers that do their own locking; they're designed to be shared between routines</span> <span id="L237" class="LineNr">237 </span> type_tree* payload = in<span class="Delimiter">.</span>type<span class="Delimiter">-&gt;</span>right<span class="Delimiter">;</span> <span id="L238" class="LineNr">238 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>payload<span class="Delimiter">-&gt;</span>left<span class="Delimiter">-&gt;</span>name == <span class="Constant">&quot;channel&quot;</span> || payload<span class="Delimiter">-&gt;</span>left<span class="Delimiter">-&gt;</span>name == <span class="Constant">&quot;screen&quot;</span> || payload<span class="Delimiter">-&gt;</span>left<span class="Delimiter">-&gt;</span>name == <span class="Constant">&quot;console&quot;</span> || payload<span class="Delimiter">-&gt;</span>left<span class="Delimiter">-&gt;</span>name == <span class="Constant">&quot;resources&quot;</span><span class="Delimiter">)</span> <span id="L239" class="LineNr">239 </span> <span class="Identifier">return</span> read_memory<span class="Delimiter">(</span>in<span class="Delimiter">);</span> <span id="L240" class="LineNr">240 </span> <span class="Delimiter">}</span> <span id="L241" class="LineNr">241 </span> vector&lt;<span class="Normal">double</span>&gt; result<span class="Delimiter">;</span> <span id="L242" class="LineNr">242 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>is_mu_address<span class="Delimiter">(</span>in<span class="Delimiter">))</span> <span id="L243" class="LineNr">243 </span> result<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span><a href='071deep_copy.cc.html#L250'>deep_copy_address</a><span class="Delimiter">(</span>in<span class="Delimiter">,</span> addresses_copied<span class="Delimiter">,</span> tmp<span class="Delimiter">));</span> <span id="L244" class="LineNr">244 </span> <span class="Normal">else</span> <span id="L245" class="LineNr">245 </span> deep_copy<span class="Delimiter">(</span>in<span class="Delimiter">,</span> addresses_copied<span class="Delimiter">,</span> tmp<span class="Delimiter">,</span> result<span class="Delimiter">);</span> <span id="L246" class="LineNr">246 </span> <span class="Identifier">return</span> result<span class="Delimiter">;</span> <span id="L247" class="LineNr">247 </span><span class="Delimiter">}</span> <span id="L248" class="LineNr">248 </span> <span id="L249" class="LineNr">249 </span><span class="Comment">// deep-copy an address and return a new address</span> <span id="L250" class="LineNr">250 </span><span class="Normal">int</span> <a href='071deep_copy.cc.html#L250'>deep_copy_address</a><span class="Delimiter">(</span><span class="Normal">const</span> reagent&amp; canonized_in<span class="Delimiter">,</span> map&lt;<span class="Normal">int</span><span class="Delimiter">,</span> <span class="Normal">int</span>&gt;&amp; addresses_copied<span class="Delimiter">,</span> <span class="Normal">const</span> reagent&amp; tmp<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L251" class="LineNr">251 </span> <span class="Normal">if</span> <span class="Delimiter">(</span><a href='071deep_copy.cc.html#L316'>address_value</a><span class="Delimiter">(</span>canonized_in<span class="Delimiter">)</span> == <span class="Constant">0</span><span class="Delimiter">)</span> <span class="Identifier">return</span> <span class="Constant">0</span><span class="Delimiter">;</span> <span id="L252" class="LineNr">252 </span> <span class="Normal">int</span> in_address = <a href='071deep_copy.cc.html#L310'>payload_address</a><span class="Delimiter">(</span>canonized_in<span class="Delimiter">);</span> <span id="L253" class="LineNr">253 </span> <a href='003trace.cc.html#L167'>trace</a><span class="Delimiter">(</span><span class="Constant">9991</span><span class="Delimiter">,</span> <span class="Constant">&quot;run&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;deep-copy: copying <a href='043space.cc.html#L80'>address</a> &quot;</span> &lt;&lt; in_address &lt;&lt; <a href='003trace.cc.html#L203'>end</a><span class="Delimiter">();</span> <span id="L254" class="LineNr">254 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>contains_key<span class="Delimiter">(</span>addresses_copied<span class="Delimiter">,</span> in_address<span class="Delimiter">))</span> <span class="Delimiter">{</span> <span id="L255" class="LineNr">255 </span> <span class="Normal">int</span> out = get<span class="Delimiter">(</span>addresses_copied<span class="Delimiter">,</span> in_address<span class="Delimiter">);</span> <span id="L256" class="LineNr">256 </span> <a href='003trace.cc.html#L167'>trace</a><span class="Delimiter">(</span><span class="Constant">9991</span><span class="Delimiter">,</span> <span class="Constant">&quot;run&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;deep-copy: copy already exists: &quot;</span> &lt;&lt; out &lt;&lt; <a href='003trace.cc.html#L203'>end</a><span class="Delimiter">();</span> <span id="L257" class="LineNr">257 </span> <span class="Identifier">return</span> out<span class="Delimiter">;</span> <span id="L258" class="LineNr">258 </span> <span class="Delimiter">}</span> <span id="L259" class="LineNr">259 </span> <span class="Normal">int</span> out = allocate<span class="Delimiter">(</span><a href='036refcount.cc.html#L1'>payload_size</a><span class="Delimiter">(</span>canonized_in<span class="Delimiter">));</span> <span id="L260" class="LineNr">260 </span> <a href='003trace.cc.html#L167'>trace</a><span class="Delimiter">(</span><span class="Constant">9991</span><span class="Delimiter">,</span> <span class="Constant">&quot;run&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;deep-copy: new <a href='043space.cc.html#L80'>address</a> is &quot;</span> &lt;&lt; out &lt;&lt; <a href='003trace.cc.html#L203'>end</a><span class="Delimiter">();</span> <span id="L261" class="LineNr">261 </span> <a href='001help.cc.html#L221'>put</a><span class="Delimiter">(</span>addresses_copied<span class="Delimiter">,</span> in_address<span class="Delimiter">,</span> out<span class="Delimiter">);</span> <span id="L262" class="LineNr">262 </span> reagent<span class="Comment">/*</span><span class="Comment">copy</span><span class="Comment">*/</span> payload = canonized_in<span class="Delimiter">;</span> <span id="L263" class="LineNr">263 </span> payload<span class="Delimiter">.</span>properties<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>pair&lt;string<span class="Delimiter">,</span> string_tree*&gt;<span class="Delimiter">(</span><span class="Constant">&quot;lookup&quot;</span><span class="Delimiter">,</span> <span class="Constant">NULL</span><span class="Delimiter">));</span> <span id="L264" class="LineNr">264 </span> <a href='003trace.cc.html#L167'>trace</a><span class="Delimiter">(</span><span class="Constant">9991</span><span class="Delimiter">,</span> <span class="Constant">&quot;run&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;recursing on payload &quot;</span> &lt;&lt; payload<span class="Delimiter">.</span>value &lt;&lt; <span class="Constant">' '</span> &lt;&lt; <a href='028call_return.cc.html#L163'>to_string</a><span class="Delimiter">(</span>payload<span class="Delimiter">)</span> &lt;&lt; <a href='003trace.cc.html#L203'>end</a><span class="Delimiter">();</span> <span id="L265" class="LineNr">265 </span> vector&lt;<span class="Normal">double</span>&gt; data = deep_copy<span class="Delimiter">(</span>payload<span class="Delimiter">,</span> addresses_copied<span class="Delimiter">,</span> tmp<span class="Delimiter">);</span> <span id="L266" class="LineNr">266 </span> <a href='003trace.cc.html#L167'>trace</a><span class="Delimiter">(</span><span class="Constant">9991</span><span class="Delimiter">,</span> <span class="Constant">&quot;run&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;deep-copy: writing result &quot;</span> &lt;&lt; out &lt;&lt; <span class="Constant">&quot;: &quot;</span> &lt;&lt; <a href='028call_return.cc.html#L163'>to_string</a><span class="Delimiter">(</span>data<span class="Delimiter">)</span> &lt;&lt; <a href='003trace.cc.html#L203'>end</a><span class="Delimiter">();</span> <span id="L267" class="LineNr">267 </span> <span class="Comment">// HACK: write_memory interface isn't ideal for this situation; we need</span> <span id="L268" class="LineNr">268 </span> <span class="Comment">// a temporary location to help copy the payload.</span> <span id="L269" class="LineNr">269 </span> <a href='003trace.cc.html#L167'>trace</a><span class="Delimiter">(</span><span class="Constant">9991</span><span class="Delimiter">,</span> <span class="Constant">&quot;run&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;deep-copy: writing temporary &quot;</span> &lt;&lt; tmp<span class="Delimiter">.</span>value &lt;&lt; <span class="Constant">&quot;: &quot;</span> &lt;&lt; out &lt;&lt; <a href='003trace.cc.html#L203'>end</a><span class="Delimiter">();</span> <span id="L270" class="LineNr">270 </span> <a href='001help.cc.html#L221'>put</a><span class="Delimiter">(</span>Memory<span class="Delimiter">,</span> tmp<span class="Delimiter">.</span>value<span class="Delimiter">,</span> out<span class="Delimiter">);</span> <span id="L271" class="LineNr">271 </span> payload<span class="Delimiter">.</span><a href='010vm.cc.html#L66'>set_value</a><span class="Delimiter">(</span>tmp<span class="Delimiter">.</span>value<span class="Delimiter">);</span> <span class="Comment">// now modified for output</span> <span id="L272" class="LineNr">272 </span> vector&lt;<span class="Normal">double</span>&gt; old_data = read_memory<span class="Delimiter">(</span>payload<span class="Delimiter">);</span> <span id="L273" class="LineNr">273 </span> <a href='003trace.cc.html#L167'>trace</a><span class="Delimiter">(</span><span class="Constant">9991</span><span class="Delimiter">,</span> <span class="Constant">&quot;run&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;deep-copy: really writing to &quot;</span> &lt;&lt; payload<span class="Delimiter">.</span>value &lt;&lt; <span class="Constant">' '</span> &lt;&lt; <a href='028call_return.cc.html#L163'>to_string</a><span class="Delimiter">(</span>payload<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot; (old value &quot;</span> &lt;&lt; <a href='028call_return.cc.html#L163'>to_string</a><span class="Delimiter">(</span>old_data<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot; new value &quot;</span> &lt;&lt; <a href='028call_return.cc.html#L163'>to_string</a><span class="Delimiter">(</span>data<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;)&quot;</span> &lt;&lt; <a href='003trace.cc.html#L203'>end</a><span class="Delimiter">();</span> <span id="L274" class="LineNr">274 </span> write_memory<span class="Delimiter">(</span>payload<span class="Delimiter">,</span> data<span class="Delimiter">);</span> <span id="L275" class="LineNr">275 </span> <a href='003trace.cc.html#L167'>trace</a><span class="Delimiter">(</span><span class="Constant">9991</span><span class="Delimiter">,</span> <span class="Constant">&quot;run&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;deep-copy: output is &quot;</span> &lt;&lt; <a href='028call_return.cc.html#L163'>to_string</a><span class="Delimiter">(</span>data<span class="Delimiter">)</span> &lt;&lt; <a href='003trace.cc.html#L203'>end</a><span class="Delimiter">();</span> <span id="L276" class="LineNr">276 </span> <span class="Identifier">return</span> out<span class="Delimiter">;</span> <span id="L277" class="LineNr">277 </span><span class="Delimiter">}</span> <span id="L278" class="LineNr">278 </span> <span id="L279" class="LineNr">279 </span><span class="Comment">// deep-copy a non-address and return a vector of locations</span> <span id="L280" class="LineNr">280 </span><span class="Normal">void</span> deep_copy<span class="Delimiter">(</span><span class="Normal">const</span> reagent&amp; canonized_in<span class="Delimiter">,</span> map&lt;<span class="Normal">int</span><span class="Delimiter">,</span> <span class="Normal">int</span>&gt;&amp; addresses_copied<span class="Delimiter">,</span> <span class="Normal">const</span> reagent&amp; tmp<span class="Delimiter">,</span> vector&lt;<span class="Normal">double</span>&gt;&amp; out<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L281" class="LineNr">281 </span> assert<span class="Delimiter">(</span>!is_mu_address<span class="Delimiter">(</span>canonized_in<span class="Delimiter">));</span> <span id="L282" class="LineNr">282 </span> vector&lt;<span class="Normal">double</span>&gt; data = read_memory<span class="Delimiter">(</span>canonized_in<span class="Delimiter">);</span> <span id="L283" class="LineNr">283 </span> out<span class="Delimiter">.</span>insert<span class="Delimiter">(</span>out<span class="Delimiter">.</span><a href='003trace.cc.html#L203'>end</a><span class="Delimiter">(),</span> data<span class="Delimiter">.</span>begin<span class="Delimiter">(),</span> data<span class="Delimiter">.</span><a href='003trace.cc.html#L203'>end</a><span class="Delimiter">());</span> <span id="L284" class="LineNr">284 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>!contains_key<span class="Delimiter">(</span>Container_metadata<span class="Delimiter">,</span> canonized_in<span class="Delimiter">.</span>type<span class="Delimiter">))</span> <span class="Identifier">return</span><span class="Delimiter">;</span> <span id="L285" class="LineNr">285 </span> <a href='003trace.cc.html#L167'>trace</a><span class="Delimiter">(</span><span class="Constant">9991</span><span class="Delimiter">,</span> <span class="Constant">&quot;run&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;deep-copy: scanning for addresses in &quot;</span> &lt;&lt; <a href='028call_return.cc.html#L163'>to_string</a><span class="Delimiter">(</span>data<span class="Delimiter">)</span> &lt;&lt; <a href='003trace.cc.html#L203'>end</a><span class="Delimiter">();</span> <span id="L286" class="LineNr">286 </span> <span class="Normal">const</span> container_metadata&amp; metadata = get<span class="Delimiter">(</span>Container_metadata<span class="Delimiter">,</span> canonized_in<span class="Delimiter">.</span>type<span class="Delimiter">);</span> <span id="L287" class="LineNr">287 </span> <span class="Normal">for</span> <span class="Delimiter">(</span>map&lt;set&lt;tag_condition_info&gt;<span class="Delimiter">,</span> set&lt;address_element_info&gt; &gt;::const_iterator p = metadata<span class="Delimiter">.</span><a href='043space.cc.html#L80'>address</a><span class="Delimiter">.</span>begin<span class="Delimiter">();</span> p != metadata<span class="Delimiter">.</span><a href='043space.cc.html#L80'>address</a><span class="Delimiter">.</span><a href='003trace.cc.html#L203'>end</a><span class="Delimiter">();</span> ++p<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L288" class="LineNr">288 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>!all_match<span class="Delimiter">(</span>data<span class="Delimiter">,</span> p<span class="Delimiter">-&gt;</span>first<span class="Delimiter">))</span> <span class="Identifier">continue</span><span class="Delimiter">;</span> <span id="L289" class="LineNr">289 </span> <span class="Normal">for</span> <span class="Delimiter">(</span>set&lt;address_element_info&gt;::const_iterator info = p<span class="Delimiter">-&gt;</span>second<span class="Delimiter">.</span>begin<span class="Delimiter">();</span> info != p<span class="Delimiter">-&gt;</span>second<span class="Delimiter">.</span><a href='003trace.cc.html#L203'>end</a><span class="Delimiter">();</span> ++info<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L290" class="LineNr">290 </span> <span class="Comment">// hack: skip primitive containers that do their own locking; they're designed to be shared between routines</span> <span id="L291" class="LineNr">291 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>!info<span class="Delimiter">-&gt;</span><a href='030container.cc.html#L238'>payload_type</a><span class="Delimiter">-&gt;</span>atom &amp;&amp; info<span class="Delimiter">-&gt;</span><a href='030container.cc.html#L238'>payload_type</a><span class="Delimiter">-&gt;</span>left<span class="Delimiter">-&gt;</span>name == <span class="Constant">&quot;channel&quot;</span><span class="Delimiter">)</span> <span id="L292" class="LineNr">292 </span> <span class="Identifier">continue</span><span class="Delimiter">;</span> <span id="L293" class="LineNr">293 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>info<span class="Delimiter">-&gt;</span><a href='030container.cc.html#L238'>payload_type</a><span class="Delimiter">-&gt;</span>name == <span class="Constant">&quot;screen&quot;</span> || info<span class="Delimiter">-&gt;</span><a href='030container.cc.html#L238'>payload_type</a><span class="Delimiter">-&gt;</span>name == <span class="Constant">&quot;console&quot;</span> || info<span class="Delimiter">-&gt;</span><a href='030container.cc.html#L238'>payload_type</a><span class="Delimiter">-&gt;</span>name == <span class="Constant">&quot;resources&quot;</span><span class="Delimiter">)</span> <span id="L294" class="LineNr">294 </span> <span class="Identifier">continue</span><span class="Delimiter">;</span> <span id="L295" class="LineNr">295 </span> <span class="Comment">// construct a fake reagent that reads directly from the appropriate</span> <span id="L296" class="LineNr">296 </span> <span class="Comment">// field of the container</span> <span id="L297" class="LineNr">297 </span> reagent curr<span class="Delimiter">;</span> <span id="L298" class="LineNr">298 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>info<span class="Delimiter">-&gt;</span><a href='030container.cc.html#L238'>payload_type</a><span class="Delimiter">-&gt;</span>atom<span class="Delimiter">)</span> <span id="L299" class="LineNr">299 </span> curr<span class="Delimiter">.</span>type = <span class="Normal">new</span> type_tree<span class="Delimiter">(</span><span class="Normal">new</span> type_tree<span class="Delimiter">(</span><span class="Constant">&quot;address&quot;</span><span class="Delimiter">),</span> <span class="Normal">new</span> type_tree<span class="Delimiter">(</span><span class="Normal">new</span> type_tree<span class="Delimiter">(</span>info<span class="Delimiter">-&gt;</span><a href='030container.cc.html#L238'>payload_type</a><span class="Delimiter">-&gt;</span>name<span class="Delimiter">),</span> <span class="Constant">NULL</span><span class="Delimiter">));</span> <span id="L300" class="LineNr">300 </span> <span class="Normal">else</span> <span id="L301" class="LineNr">301 </span> curr<span class="Delimiter">.</span>type = <span class="Normal">new</span> type_tree<span class="Delimiter">(</span><span class="Normal">new</span> type_tree<span class="Delimiter">(</span><span class="Constant">&quot;address&quot;</span><span class="Delimiter">),</span> <span class="Normal">new</span> type_tree<span class="Delimiter">(</span>*info<span class="Delimiter">-&gt;</span><a href='030container.cc.html#L238'>payload_type</a><span class="Delimiter">));</span> <span id="L302" class="LineNr">302 </span> curr<span class="Delimiter">.</span><a href='010vm.cc.html#L66'>set_value</a><span class="Delimiter">(</span>canonized_in<span class="Delimiter">.</span>value + info<span class="Delimiter">-&gt;</span>offset<span class="Delimiter">);</span> <span id="L303" class="LineNr">303 </span> curr<span class="Delimiter">.</span>properties<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>pair&lt;string<span class="Delimiter">,</span> string_tree*&gt;<span class="Delimiter">(</span><span class="Constant">&quot;raw&quot;</span><span class="Delimiter">,</span> <span class="Constant">NULL</span><span class="Delimiter">));</span> <span id="L304" class="LineNr">304 </span> <a href='003trace.cc.html#L167'>trace</a><span class="Delimiter">(</span><span class="Constant">9991</span><span class="Delimiter">,</span> <span class="Constant">&quot;run&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;deep-copy: copying <a href='043space.cc.html#L80'>address</a> &quot;</span> &lt;&lt; curr<span class="Delimiter">.</span>value &lt;&lt; <a href='003trace.cc.html#L203'>end</a><span class="Delimiter">();</span> <span id="L305" class="LineNr">305 </span> out<span class="Delimiter">.</span>at<span class="Delimiter">(</span>info<span class="Delimiter">-&gt;</span>offset<span class="Delimiter">)</span> = <a href='071deep_copy.cc.html#L250'>deep_copy_address</a><span class="Delimiter">(</span>curr<span class="Delimiter">,</span> addresses_copied<span class="Delimiter">,</span> tmp<span class="Delimiter">);</span> <span id="L306" class="LineNr">306 </span> <span class="Delimiter">}</span> <span id="L307" class="LineNr">307 </span> <span class="Delimiter">}</span> <span id="L308" class="LineNr">308 </span><span class="Delimiter">}</span> <span id="L309" class="LineNr">309 </span> <span id="L310" class="LineNr">310 </span><span class="Normal">int</span> <a href='071deep_copy.cc.html#L310'>payload_address</a><span class="Delimiter">(</span>reagent<span class="Comment">/*</span><span class="Comment">copy</span><span class="Comment">*/</span> x<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L311" class="LineNr">311 </span> x<span class="Delimiter">.</span>properties<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>pair&lt;string<span class="Delimiter">,</span> string_tree*&gt;<span class="Delimiter">(</span><span class="Constant">&quot;lookup&quot;</span><span class="Delimiter">,</span> <span class="Constant">NULL</span><span class="Delimiter">));</span> <span id="L312" class="LineNr">312 </span> canonize<span class="Delimiter">(</span>x<span class="Delimiter">);</span> <span id="L313" class="LineNr">313 </span> <span class="Identifier">return</span> x<span class="Delimiter">.</span>value<span class="Delimiter">;</span> <span id="L314" class="LineNr">314 </span><span class="Delimiter">}</span> <span id="L315" class="LineNr">315 </span> <span id="L316" class="LineNr">316 </span><span class="Normal">int</span> <a href='071deep_copy.cc.html#L316'>address_value</a><span class="Delimiter">(</span><span class="Normal">const</span> reagent&amp; x<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L317" class="LineNr">317 </span> assert<span class="Delimiter">(</span>is_mu_address<span class="Delimiter">(</span>x<span class="Delimiter">));</span> <span id="L318" class="LineNr">318 </span> vector&lt;<span class="Normal">double</span>&gt; result = read_memory<span class="Delimiter">(</span>x<span class="Delimiter">);</span> <span id="L319" class="LineNr">319 </span> assert<span class="Delimiter">(</span><a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>result<span class="Delimiter">)</span> == <span class="Constant">1</span><span class="Delimiter">);</span> <span id="L320" class="LineNr">320 </span> <span class="Identifier">return</span> <span class="Normal">static_cast</span>&lt;<span class="Normal">int</span>&gt;<span class="Delimiter">(</span>result<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">));</span> <span id="L321" class="LineNr">321 </span><span class="Delimiter">}</span> <span id="L322" class="LineNr">322 </span> <span id="L323" class="LineNr">323 </span><span class="Delimiter">:(scenario deep_copy_stress_test_1)</span> <span id="L324" class="LineNr">324 </span><span class="muData">container</span> foo1 [ <span id="L325" class="LineNr">325 </span> <span class="Normal">p</span>:&amp;:num <span id="L326" class="LineNr">326 </span>] <span id="L327" class="LineNr">327 </span><span class="muData">container</span> foo2 [ <span id="L328" class="LineNr">328 </span> <span class="Normal">p</span>:&amp;:foo1 <span id="L329" class="LineNr">329 </span>] <span id="L330" class="LineNr">330 </span><span class="muData">exclusive-container</span> foo3 [ <span id="L331" class="LineNr">331 </span> <span class="Normal">p</span>:&amp;:foo1 <span id="L332" class="LineNr">332 </span> <span class="Normal">q</span>:&amp;:foo2 <span id="L333" class="LineNr">333 </span>] <span id="L334" class="LineNr">334 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [ <span id="L335" class="LineNr">335 </span> local-scope <span id="L336" class="LineNr">336 </span> <span class="Normal">x</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span> <span id="L337" class="LineNr">337 </span> *x<span class="Special"> &lt;- </span>copy <span class="Constant">34</span> <span id="L338" class="LineNr">338 </span> <span class="Normal">a</span>:&amp;:foo1<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">foo1:type</span> <span id="L339" class="LineNr">339 </span> *a<span class="Special"> &lt;- </span>merge x <span id="L340" class="LineNr">340 </span> <span class="Normal">b</span>:&amp;:foo2<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">foo2:type</span> <span id="L341" class="LineNr">341 </span> *b<span class="Special"> &lt;- </span>merge a <span id="L342" class="LineNr">342 </span> <span class="Normal">c</span>:foo3<span class="Special"> &lt;- </span>merge <span class="Constant">1</span>/q<span class="Delimiter">,</span> b <span id="L343" class="LineNr">343 </span> <span class="Normal">d</span>:foo3<span class="Special"> &lt;- </span>deep-copy c <span id="L344" class="LineNr">344 </span> <span class="Normal">e</span>:&amp;:foo2<span class="Delimiter">,</span> z:<span class="Normal">bool</span><span class="Special"> &lt;- </span>maybe-convert d<span class="Delimiter">,</span> <span class="Constant">q:variant</span> <span id="L345" class="LineNr">345 </span> <span class="Normal">f</span>:&amp;:foo1<span class="Special"> &lt;- </span>get *e<span class="Delimiter">,</span> <span class="Constant">p:offset</span> <span id="L346" class="LineNr">346 </span> <span class="Normal">g</span>:&amp;:num<span class="Special"> &lt;- </span>get *f<span class="Delimiter">,</span> <span class="Constant">p:offset</span> <span id="L347" class="LineNr">347 </span> <span class="Constant">1</span>:num/<span class="Special">raw &lt;- </span>copy *g <span id="L348" class="LineNr">348 </span>] <span id="L349" class="LineNr">349 </span><span class="traceContains">+mem: storing 34 in location 1</span> <span id="L350" class="LineNr">350 </span> <span id="L351" class="LineNr">351 </span><span class="Delimiter">:(scenario deep_copy_stress_test_2)</span> <span id="L352" class="LineNr">352 </span><span class="muData">container</span> foo1 [ <span id="L353" class="LineNr">353 </span> <span class="Normal">p</span>:&amp;:num <span id="L354" class="LineNr">354 </span>] <span id="L355" class="LineNr">355 </span><span class="muData">container</span> foo2 [ <span id="L356" class="LineNr">356 </span> <span class="Normal">p</span>:&amp;:foo1 <span id="L357" class="LineNr">357 </span>] <span id="L358" class="LineNr">358 </span><span class="muData">exclusive-container</span> foo3 [ <span id="L359" class="LineNr">359 </span> <span class="Normal">p</span>:&amp;:foo1 <span id="L360" class="LineNr">360 </span> <span class="Normal">q</span>:&amp;:foo2 <span id="L361" class="LineNr">361 </span>] <span id="L362" class="LineNr">362 </span><span class="muData">container</span> foo4 [ <span id="L363" class="LineNr">363 </span> <span class="Normal">p</span>:num <span id="L364" class="LineNr">364 </span> <span class="Normal">q</span>:&amp;:foo3 <span id="L365" class="LineNr">365 </span>] <span id="L366" class="LineNr">366 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [ <span id="L367" class="LineNr">367 </span> local-scope <span id="L368" class="LineNr">368 </span> <span class="Normal">x</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span> <span id="L369" class="LineNr">369 </span> *x<span class="Special"> &lt;- </span>copy <span class="Constant">34</span> <span id="L370" class="LineNr">370 </span> <span class="Normal">a</span>:&amp;:foo1<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">foo1:type</span> <span id="L371" class="LineNr">371 </span> *a<span class="Special"> &lt;- </span>merge x <span id="L372" class="LineNr">372 </span> <span class="Normal">b</span>:&amp;:foo2<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">foo2:type</span> <span id="L373" class="LineNr">373 </span> *b<span class="Special"> &lt;- </span>merge a <span id="L374" class="LineNr">374 </span> <span class="Normal">c</span>:&amp;:foo3<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">foo3:type</span> <span id="L375" class="LineNr">375 </span> *c<span class="Special"> &lt;- </span>merge <span class="Constant">1</span>/q<span class="Delimiter">,</span> b <span id="L376" class="LineNr">376 </span> <span class="Normal">d</span>:foo4<span class="Special"> &lt;- </span>merge <span class="Constant">35</span><span class="Delimiter">,</span> c <span id="L377" class="LineNr">377 </span> <span class="Normal">e</span>:foo4<span class="Special"> &lt;- </span>deep-copy d <span id="L378" class="LineNr">378 </span> <span class="Normal">f</span>:&amp;:foo3<span class="Special"> &lt;- </span>get e<span class="Delimiter">,</span> <span class="Constant">q:offset</span> <span id="L379" class="LineNr">379 </span> <span class="Normal">g</span>:&amp;:foo2<span class="Delimiter">,</span> z:<span class="Normal">bool</span><span class="Special"> &lt;- </span>maybe-convert *f<span class="Delimiter">,</span> <span class="Constant">q:variant</span> <span id="L380" class="LineNr">380 </span> <span class="Normal">h</span>:&amp;:foo1<span class="Special"> &lt;- </span>get *g<span class="Delimiter">,</span> <span class="Constant">p:offset</span> <span id="L381" class="LineNr">381 </span> <span class="Normal">y</span>:&amp;:num<span class="Special"> &lt;- </span>get *h<span class="Delimiter">,</span> <span class="Constant">p:offset</span> <span id="L382" class="LineNr">382 </span> <span class="Constant">1</span>:num/<span class="Special">raw &lt;- </span>copy *y <span id="L383" class="LineNr">383 </span>] <span id="L384" class="LineNr">384 </span><span class="traceContains">+mem: storing 34 in location 1</span> <span id="L385" class="LineNr">385 </span> <span id="L386" class="LineNr">386 </span><span class="Delimiter">:(scenario deep_copy_cycles)</span> <span id="L387" class="LineNr">387 </span><span class="muData">container</span> foo [ <span id="L388" class="LineNr">388 </span> <span class="Normal">p</span>:num <span id="L389" class="LineNr">389 </span> <span class="Normal">q</span>:&amp;:foo <span id="L390" class="LineNr">390 </span>] <span id="L391" class="LineNr">391 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [ <span id="L392" class="LineNr">392 </span> local-scope <span id="L393" class="LineNr">393 </span> <span class="Normal">x</span>:&amp;:foo<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">foo:type</span> <span id="L394" class="LineNr">394 </span> *x<span class="Special"> &lt;- </span><a href='001help.cc.html#L221'>put</a> *x<span class="Delimiter">,</span> <span class="Constant">p:offset</span><span class="Delimiter">,</span> <span class="Constant">34</span> <span id="L395" class="LineNr">395 </span> *x<span class="Special"> &lt;- </span><a href='001help.cc.html#L221'>put</a> *x<span class="Delimiter">,</span> <span class="Constant">q:offset</span><span class="Delimiter">,</span> x <span class="Comment"># create a cycle</span> <span id="L396" class="LineNr">396 </span> <span class="Normal">y</span>:&amp;:foo<span class="Special"> &lt;- </span>deep-copy x <span id="L397" class="LineNr">397 </span> <span class="Constant">1</span>:num/<span class="Special">raw &lt;- </span>get *y<span class="Delimiter">,</span> <span class="Constant">p:offset</span> <span id="L398" class="LineNr">398 </span> <span class="Normal">y2</span>:&amp;:foo<span class="Special"> &lt;- </span>get *y<span class="Delimiter">,</span> <span class="Constant">q:offset</span> <span id="L399" class="LineNr">399 </span> <span class="Constant">2</span>:<span class="Normal">bool</span>/<span class="Special">raw &lt;- </span>equal y<span class="Delimiter">,</span> y2 <span class="Comment"># is it still a cycle?</span> <span id="L400" class="LineNr">400 </span> <span class="Constant">3</span>:<span class="Normal">bool</span>/<span class="Special">raw &lt;- </span>equal x<span class="Delimiter">,</span> y <span class="Comment"># is it the same cycle?</span> <span id="L401" class="LineNr">401 </span> <span class="Comment"># not bothering cleaning up; both cycles leak memory</span> <span id="L402" class="LineNr">402 </span>] <span id="L403" class="LineNr">403 </span><span class="traceContains">+mem: storing 34 in location 1</span> <span id="L404" class="LineNr">404 </span><span class="Comment"># deep copy also contains a cycle</span> <span id="L405" class="LineNr">405 </span><span class="traceContains">+mem: storing 1 in location 2</span> <span id="L406" class="LineNr">406 </span><span class="Comment"># but it's a completely different (disjoint) cycle</span> <span id="L407" class="LineNr">407 </span><span class="traceContains">+mem: storing 0 in location 3</span> <span id="L408" class="LineNr">408 </span> <span id="L409" class="LineNr">409 </span><span class="Comment">//: todo: version of deep_copy_cycles that breaks cycles at end and verifies no memory leaks</span> <span id="L410" class="LineNr">410 </span><span class="Comment">//: needs approximate matching over scenario traces</span> <span id="L411" class="LineNr">411 </span> <span id="L412" class="LineNr">412 </span><span class="Delimiter">:(scenario deep_copy_skips_channel)</span> <span id="L413" class="LineNr">413 </span><span class="Comment"># ugly! dummy 'channel' type if we happen to be building without that layer</span> <span id="L414" class="LineNr">414 </span><span class="Special">% if (!contains_key(Type_ordinal, &quot;channel&quot;)) get_or_insert(Type, put(Type_ordinal, &quot;channel&quot;, Next_type_ordinal++)).name = &quot;channel&quot;;</span> <span id="L415" class="LineNr">415 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [ <span id="L416" class="LineNr">416 </span> local-scope <span id="L417" class="LineNr">417 </span> <span class="Normal">x</span>:&amp;:channel:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Delimiter">{(</span>channel num<span class="Delimiter">)</span>: type<span class="Delimiter">}</span> <span id="L418" class="LineNr">418 </span> <span class="Normal">y</span>:&amp;:channel:num<span class="Special"> &lt;- </span>deep-copy x <span id="L419" class="LineNr">419 </span> <span class="Constant">10</span>:<span class="Normal">bool</span>/<span class="Special">raw &lt;- </span>equal x<span class="Delimiter">,</span> y <span id="L420" class="LineNr">420 </span>] <span id="L421" class="LineNr">421 </span><span class="Comment"># channels are never deep-copied</span> <span id="L422" class="LineNr">422 </span><span class="traceContains">+mem: storing 1 in location 10</span> <span id="L423" class="LineNr">423 </span> <span id="L424" class="LineNr">424 </span><span class="Delimiter">:(scenario deep_copy_skips_nested_channel)</span> <span id="L425" class="LineNr">425 </span><span class="Comment"># ugly! dummy 'channel' type if we happen to be building without that layer</span> <span id="L426" class="LineNr">426 </span><span class="Special">% if (!contains_key(Type_ordinal, &quot;channel&quot;)) get_or_insert(Type, put(Type_ordinal, &quot;channel&quot;, Next_type_ordinal++)).name = &quot;channel&quot;;</span> <span id="L427" class="LineNr">427 </span><span class="muData">container</span> foo [ <span id="L428" class="LineNr">428 </span> <span class="Normal">c</span>:&amp;:channel:num <span id="L429" class="LineNr">429 </span>] <span id="L430" class="LineNr">430 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [ <span id="L431" class="LineNr">431 </span> local-scope <span id="L432" class="LineNr">432 </span> <span class="Normal">x</span>:&amp;:foo<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">foo:type</span> <span id="L433" class="LineNr">433 </span> <span class="Normal">y</span>:&amp;:foo<span class="Special"> &lt;- </span>deep-copy x <span id="L434" class="LineNr">434 </span> <span class="Normal">xc</span>:&amp;:channel:num<span class="Special"> &lt;- </span>get *x<span class="Delimiter">,</span> <span class="Constant">c:offset</span> <span id="L435" class="LineNr">435 </span> <span class="Normal">yc</span>:&amp;:channel:num<span class="Special"> &lt;- </span>get *y<span class="Delimiter">,</span> <span class="Constant">c:offset</span> <span id="L436" class="LineNr">436 </span> <span class="Constant">10</span>:<span class="Normal">bool</span>/<span class="Special">raw &lt;- </span>equal xc<span class="Delimiter">,</span> yc <span id="L437" class="LineNr">437 </span>] <span id="L438" class="LineNr">438 </span><span class="Comment"># channels are never deep-copied</span> <span id="L439" class="LineNr">439 </span><span class="traceContains">+mem: storing 1 in location 10</span> <span id="L440" class="LineNr">440 </span> <span id="L441" class="LineNr">441 </span><span class="Delimiter">:(scenario deep_copy_skips_resources)</span> <span id="L442" class="LineNr">442 </span><span class="Comment"># ugly! dummy 'resources' type if we happen to be building without that layer</span> <span id="L443" class="LineNr">443 </span><span class="Special">% if (!contains_key(Type_ordinal, &quot;resources&quot;)) get_or_insert(Type, put(Type_ordinal, &quot;resources&quot;, Next_type_ordinal++)).name = &quot;resources&quot;;</span> <span id="L444" class="LineNr">444 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [ <span id="L445" class="LineNr">445 </span> local-scope <span id="L446" class="LineNr">446 </span> <span class="Normal">x</span>:&amp;:resources<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">resources:type</span> <span id="L447" class="LineNr">447 </span> <span class="Normal">y</span>:&amp;:resources<span class="Special"> &lt;- </span>deep-copy x <span id="L448" class="LineNr">448 </span> <span class="Constant">10</span>:<span class="Normal">bool</span>/<span class="Special">raw &lt;- </span>equal x<span class="Delimiter">,</span> y <span id="L449" class="LineNr">449 </span>] <span id="L450" class="LineNr">450 </span><span class="Comment"># resources are never deep-copied</span> <span id="L451" class="LineNr">451 </span><span class="traceContains">+mem: storing 1 in location 10</span> <span id="L452" class="LineNr">452 </span> <span id="L453" class="LineNr">453 </span><span class="Delimiter">:(scenario deep_copy_skips_nested_resources)</span> <span id="L454" class="LineNr">454 </span><span class="Comment"># ugly! dummy 'resources' type if we happen to be building without that layer</span> <span id="L455" class="LineNr">455 </span><span class="Special">% if (!contains_key(Type_ordinal, &quot;resources&quot;)) get_or_insert(Type, put(Type_ordinal, &quot;resources&quot;, Next_type_ordinal++)).name = &quot;resources&quot;;</span> <span id="L456" class="LineNr">456 </span><span class="muData">container</span> foo [ <span id="L457" class="LineNr">457 </span> <span class="Normal">c</span>:&amp;:resources <span id="L458" class="LineNr">458 </span>] <span id="L459" class="LineNr">459 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [ <span id="L460" class="LineNr">460 </span> local-scope <span id="L461" class="LineNr">461 </span> <span class="Normal">x</span>:&amp;:foo<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">foo:type</span> <span id="L462" class="LineNr">462 </span> <span class="Normal">y</span>:&amp;:foo<span class="Special"> &lt;- </span>deep-copy x <span id="L463" class="LineNr">463 </span> <span class="Normal">xc</span>:&amp;:resources<span class="Special"> &lt;- </span>get *x<span class="Delimiter">,</span> <span class="Constant">c:offset</span> <span id="L464" class="LineNr">464 </span> <span class="Normal">yc</span>:&amp;:resources<span class="Special"> &lt;- </span>get *y<span class="Delimiter">,</span> <span class="Constant">c:offset</span> <span id="L465" class="LineNr">465 </span> <span class="Constant">10</span>:<span class="Normal">bool</span>/<span class="Special">raw &lt;- </span>equal xc<span class="Delimiter">,</span> yc <span id="L466" class="LineNr">466 </span>] <span id="L467" class="LineNr">467 </span><span class="Comment"># resources are never deep-copied</span> <span id="L468" class="LineNr">468 </span><span class="traceContains">+mem: storing 1 in location 10</span> </pre> </body> </html> <!-- vim: set foldmethod=manual : -->