about summary refs log tree commit diff stats
path: root/html/045space_surround.cc.html
blob: a01f4094605362a2319634680c9a58fc3ce15587 (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

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Mu - 045space_surround.cc</title>
<meta name="Generator" content="Vim/7.4">
<meta name="plugin-version" content="vim7.4_v1">
<meta name="syntax" content="cpp">
<meta name="settings" content="use_css,pre_wrap,no_foldcolumn,expand_tabs,prevent_copy=">
<meta name="colorscheme" content="minimal">
<style type="text/css">
<!--
pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
body { font-family: monospace; color: #eeeeee; background-color: #080808; }
* { font-size: 1.05em; }
.traceContains { color: #008000; }
.Constant { color: #00a0a0; }
.Comment { color: #9090ff; }
.Delimiter { color: #a04060; }
.Special { color: #ff6060; }
.Identifier { color: #804000; }
-->
</style>

<script type='text/javascript'>
<!--

-->
</script>
</head>
<body>
<pre id='vimCodeElement'>
<span class="Comment">//: So far you can have global variables by not setting default-space, and</span>
<span class="Comment">//: local variables by setting default-space. You can isolate variables</span>
<span class="Comment">//: between those extremes by creating 'surrounding' spaces.</span>
<span class="Comment">//:</span>
<span class="Comment">//: (Surrounding spaces are like lexical scopes in other languages.)</span>

<span class="Delimiter">:(scenario surrounding_space)</span>
<span class="Comment"># location 1 in space 1 refers to the space surrounding the default space, here 20.</span>
recipe main [
  <span class="Constant">10</span>:number<span class="Special"> &lt;- </span>copy <span class="Constant">5</span>:literal  <span class="Comment"># pretend array</span>
  <span class="Constant">20</span>:number<span class="Special"> &lt;- </span>copy <span class="Constant">5</span>:literal  <span class="Comment"># pretend array</span>
  default-space:address:array:location<span class="Special"> &lt;- </span>copy <span class="Constant">10</span>:literal
  <span class="Constant">0</span>:address:array:location/names:dummy<span class="Special"> &lt;- </span>copy <span class="Constant">20</span>:literal  <span class="Comment"># later layers will explain the /names: property</span>
  <span class="Constant">1</span>:number<span class="Special"> &lt;- </span>copy <span class="Constant">32</span>:literal
  <span class="Constant">1</span>:number/space:<span class="Constant">1</span><span class="Special"> &lt;- </span>copy <span class="Constant">33</span>:literal
]
<span class="Comment"># chain space</span>
<span class="traceContains">+mem: storing 20 in location 11</span>
<span class="Comment"># store to default-space</span>
<span class="traceContains">+mem: storing 32 in location 12</span>
<span class="Comment"># store to chained space</span>
<span class="traceContains">+mem: storing 33 in location 22</span>

<span class="Comment">//: If you think of a space as a collection of variables with a common</span>
<span class="Comment">//: lifetime, surrounding allows managing shorter lifetimes inside a longer</span>
<span class="Comment">//: one.</span>

<span class="Delimiter">:(replace{} &quot;long long int space_base(const reagent&amp; x)&quot;)</span>
long long int space_base<span class="Delimiter">(</span>const reagent&amp; x<span class="Delimiter">)</span> <span class="Delimiter">{</span>
  <span class="Identifier">return</span> space_base<span class="Delimiter">(</span>x<span class="Delimiter">,</span> space_index<span class="Delimiter">(</span>x<span class="Delimiter">),</span> Current_routine<span class="Delimiter">-&gt;</span>calls<span class="Delimiter">.</span>front<span class="Delimiter">().</span>default_space<span class="Delimiter">);</span>
<span class="Delimiter">}</span>

long long int space_base<span class="Delimiter">(</span>const reagent&amp; x<span class="Delimiter">,</span> long long int space_index<span class="Delimiter">,</span> long long int base<span class="Delimiter">)</span> <span class="Delimiter">{</span>
  if <span class="Delimiter">(</span>space_index == <span class="Constant">0</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
    <span class="Identifier">return</span> base<span class="Delimiter">;</span>
  <span class="Delimiter">}</span>
  long long int result = space_base<span class="Delimiter">(</span>x<span class="Delimiter">,</span> space_index-<span class="Constant">1</span><span class="Delimiter">,</span> Memory[base+<span class="Constant">1</span>]<span class="Delimiter">);</span>
  <span class="Identifier">return</span> result<span class="Delimiter">;</span>
<span class="Delimiter">}</span>

long long int space_index<span class="Delimiter">(</span>const reagent&amp; x<span class="Delimiter">)</span> <span class="Delimiter">{</span>
  for <span class="Delimiter">(</span>long long int i = <span class="Comment">/*</span><span class="Comment">skip name:type</span><span class="Comment">*/</span><span class="Constant">1</span><span class="Delimiter">;</span> i &lt; SIZE<span class="Delimiter">(</span>x<span class="Delimiter">.</span>properties<span class="Delimiter">);</span> ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span>
    if <span class="Delimiter">(</span>x<span class="Delimiter">.</span>properties<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>first == <span class="Constant">&quot;space&quot;</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
      assert<span class="Delimiter">(</span>SIZE<span class="Delimiter">(</span>x<span class="Delimiter">.</span>properties<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>second<span class="Delimiter">)</span> == <span class="Constant">1</span><span class="Delimiter">);</span>
      <span class="Identifier">return</span> to_integer<span class="Delimiter">(</span>x<span class="Delimiter">.</span>properties<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>second<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">));</span>
    <span class="Delimiter">}</span>
  <span class="Delimiter">}</span>
  <span class="Identifier">return</span> <span class="Constant">0</span><span class="Delimiter">;</span>
<span class="Delimiter">}</span>

<span class="Delimiter">:(scenario permit_space_as_variable_name)</span>
recipe main [
  space:number<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>:literal
]
</pre>
</body>
</html>
<!-- vim: set foldmethod=manual : -->
generated by cgit-pink 1.4.1-2-gfad0 (git 2.36.2.497.gbbea4dcf42) at 2024-12-03 13:51:54 +0000
ss="n">path.isdir(fname): stack.extend([join(fname, item) for item in os.listdir(fname)]) else: try: fstat = os.stat(fname) except: continue size += max(step, math.ceil(fstat.st_size / step) * step) return size def generate(self): from ranger.ext import shutil_generatorized as shutil_g if self.copy_buffer: # TODO: Don't calculate size when renaming (needs detection) bytes_per_tick = shutil_g.BLOCK_SIZE size = max(1, self._calculate_size(bytes_per_tick)) bar_tick = 100.0 / (float(size) / bytes_per_tick) if self.do_cut: self.original_copy_buffer.clear() if len(self.copy_buffer) == 1: self.description = "moving: " + self.one_file.path else: self.description = "moving files from: " + self.one_file.dirname for f in self.copy_buffer: for _ in shutil_g.move(src=f.path, dst=self.original_path, overwrite=self.overwrite): self.percent += bar_tick yield else: if len(self.copy_buffer) == 1: self.description = "copying: " + self.one_file.path else: self.description = "copying files from: " + self.one_file.dirname for f in self.copy_buffer: if os.path.isdir(f.path): for _ in shutil_g.copytree(src=f.path, dst=os.path.join(self.original_path, f.basename), symlinks=True, overwrite=self.overwrite): self.percent += bar_tick yield else: for _ in shutil_g.copy2(f.path, self.original_path, symlinks=True, overwrite=self.overwrite): self.percent += bar_tick yield cwd = self.fm.get_directory(self.original_path) cwd.load_content() class CommandLoader(Loadable, SignalDispatcher, FileManagerAware): """ Run an external command with the loader. Output from stderr will be reported. Ensure that the process doesn't ever ask for input, otherwise the loader will be blocked until this object is removed from the queue (type ^C in ranger) """ finished = False process = None def __init__(self, args, descr, silent=False, read=False): SignalDispatcher.__init__(self) Loadable.__init__(self, self.generate(), descr) self.args = args self.silent = silent self.read = read self.stdout_buffer = "" def generate(self): null = open(os.devnull, 'r') self.process = process = Popen(self.args, stdout=PIPE, stderr=PIPE, stdin=null) self.signal_emit('before', process=process, loader=self) if self.silent and not self.read: while process.poll() is None: yield sleep(0.03) else: py3 = sys.version >= '3' selectlist = [] if self.read: selectlist.append(process.stdout) if not self.silent: selectlist.append(process.stderr) while process.poll() is None: yield try: rd, _, __ = select.select(selectlist, [], [], 0.03) if rd: rd = rd[0] if rd == process.stderr: read = rd.readline() if py3: read = safeDecode(read) if read: self.fm.notify(read, bad=True) elif rd == process.stdout: read = rd.read(512) if py3: read = safeDecode(read) if read: self.stdout_buffer += read except select.error: sleep(0.03) if not self.silent: for l in process.stderr.readlines(): if py3: l = safeDecode(l) self.fm.notify(l, bad=True) if self.read: read = process.stdout.read() if py3: read = safeDecode(read) self.stdout_buffer += read null.close() self.finished = True self.signal_emit('after', process=process, loader=self) def pause(self): if not self.finished and not self.paused: try: self.process.send_signal(20) except: pass Loadable.pause(self) self.signal_emit('pause', process=self.process, loader=self) def unpause(self): if not self.finished and self.paused: try: self.process.send_signal(18) except: pass Loadable.unpause(self) self.signal_emit('unpause', process=self.process, loader=self) def destroy(self): self.signal_emit('destroy', process=self.process, loader=self) if self.process: self.process.kill() def safeDecode(string): try: return string.decode("utf-8") except (UnicodeDecodeError): if HAVE_CHARDET: return string.decode(chardet.detect(string)["encoding"]) else: return "" class Loader(FileManagerAware): seconds_of_work_time = 0.03 throbber_chars = r'/-\|' throbber_paused = '#' paused = False def __init__(self): self.queue = deque() self.item = None self.load_generator = None self.throbber_status = 0 self.rotate() self.old_item = None def rotate(self): """Rotate the throbber""" # TODO: move all throbber logic to UI self.throbber_status = \ (self.throbber_status + 1) % len(self.throbber_chars) self.status = self.throbber_chars[self.throbber_status] def add(self, obj): """ Add an object to the queue. It should have a load_generator method. """ while obj in self.queue: self.queue.remove(obj) self.queue.appendleft(obj) if self.paused: obj.pause() else: obj.unpause() def move(self, _from, to): try: item = self.queue[_from] except IndexError: return del self.queue[_from] if to == 0: self.queue.appendleft(item) if _from != 0: self.queue[1].pause() elif to == -1: self.queue.append(item) else: raise NotImplementedError def remove(self, item=None, index=None): if item is not None and index is None: for i, test in enumerate(self.queue): if test == item: index = i break else: return if index is not None: if item is None: item = self.queue[index] if hasattr(item, 'unload'): item.unload() item.destroy() del self.queue[index] if item.progressbar_supported: self.fm.ui.status.request_redraw() def pause(self, state): """ Change the pause-state to 1 (pause), 0 (no pause) or -1 (toggle) """ if state == -1: state = not self.paused elif state == self.paused: return self.paused = state if not self.queue: return if state: self.queue[0].pause() else: self.queue[0].unpause() def work(self): """ Load items from the queue if there are any. Stop after approximately self.seconds_of_work_time. """ if self.paused: self.status = self.throbber_paused return while True: # get the first item with a proper load_generator try: item = self.queue[0] if item.load_generator is None: self.queue.popleft() else: break except IndexError: return item.unpause() self.rotate() if item != self.old_item: if self.old_item: self.old_item.pause() self.old_item = item item.unpause() end_time = time() + self.seconds_of_work_time try: while time() < end_time: next(item.load_generator) if item.progressbar_supported: self.fm.ui.status.request_redraw() except StopIteration: self._remove_current_process(item) except Exception as err: self.fm.notify(err) self._remove_current_process(item) def _remove_current_process(self, item): item.load_generator = None self.queue.remove(item) if item.progressbar_supported: self.fm.ui.status.request_redraw() def has_work(self): """Is there anything to load?""" return bool(self.queue) def destroy(self): while self.queue: self.queue.pop().destroy()
generated by cgit-pink 1.4.1-2-gfad0 (git 2.36.2.497.gbbea4dcf42) at 2024-12-03 13:51:53 +0000