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
|
class::Interpreter
summary:: The interpreter defines a context in which interactive commands are compiled and executed.
categories:: Core>Kernel
related::Guides/How-to-Use-the-Interpreter
description::
The interpreter is an object that handles the translation and execution of code at runtime. It is that what runs any program code and defines a context for it.
code::
(
a = 5 + 7;
this.cmdLine.postln;
)
::
classMethods::
private::new
instanceMethods::
subsection::Accessing
In the interpreter, code::this:: refers to the interpreter itself, e.g.: code::this.postln::
The interpreter defines global variables (code::a:: … code::z::), that can be used for interactive programming. Except these single letter variables ("interpreter variables"), all variables have to be defined by the keyword code::var:: (see: link::Reference/Assignment::, and link::Reference/Scope::).
code::
// typical usage
a = 4;
b = 3;
b = b + a;
// some sound
a = Synth(\default);
g = fork { loop { 0.1.wait; a.set(\freq, 200 + 20.0.rand2.postln) } };
g.stop; a.free;
// an overview of all the variables
this.inspect;
::
note::Use these variables with a bit of extra care – as they are global, they remain in memory and one piece of code may happen to interfere with another one. The variable code::s:: is by convention bound to the default server (link::Classes/Server::) and should not be changed.::
method::clearAll
set the values of the variables code::a:: through code::z:: to nil.
code::
x = 123;
x.postln;
this.clearAll;
x.postln;
::
subsection::Compile & Interpret
method::interpret
Compile and execute a link::Classes/String::.
code::
this.interpret("(123 + 4000).postln");
::
method::interpretPrint
Compile and execute a link::Classes/String::, printing the result.
code::
this.interpretPrint("123 + 4000");
::
method::compile
Compile a String and return a link::Classes/Function::.
code::
(
z = this.compile("(123 + 4000).postln");
z.postln;
z.value;
)
::
method::compileFile
Reads the file at pathName, compiles it and returns a Function.
The file must contain a valid SuperCollider expression, naturally.
This will not compile class definitions, only expressions.
method::executeFile
Reads the file at pathName, compiles it and executes it, returning the result.
The file must contain a valid SuperCollider expression, naturally.
This will not compile class definitions, only expressions.
method::cmdLine
Returns the previously interpreted code.
code::
1 + 2;
this.cmdLine
::
method::codeDump
this interpreter variable can be set to evaluate a function with any successfully compiled code.
see e.g. the class History.
code::
a = [ ]; // store all the code evaluated in a
this.codeDump = { |code| a = a.add(code) };
1 + 3;
f = { "hallo" };
a.postcs;
codeDump = nil; // reset to nil.
::
method::preProcessor
If this is set to a function, all interactively executed code is piped through it before parsing and
interpreting. This is mostly used for developing domain-specific live coding languages that piggyback
off the SuperCollider editing environment.
This function is called by link::Classes/Interpreter#-interpretPrintCmdLine:: with two arguments:
the code string and the interpreter itself.
code::
// silly but simple: understand a Saw for every SinOsc
this.preProcessor = { |code| code.replace("SinOsc", "Saw") };
{ SinOsc.ar(200) * 0.1 }.play;
preProcessor = nil; // reset to nil.
::
method::a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z
Global variables ("interpreter variables") for interactive programming (see link::#Accessing::).
method::functionCompileContext
The compiler uses this method as a virtual context in which to compile code.
|
