Add logical shift left (<<) and logical shift right (>>) to faustine.
[Faustine.git] / interpretor / preprocessor / faust-0.9.47mr3 / compiler / normalize / privatise.cpp
1 /************************************************************************
2 ************************************************************************
3 FAUST compiler
4 Copyright (C) 2003-2004 GRAME, Centre National de Creation Musicale
5 ---------------------------------------------------------------------
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 ************************************************************************
20 ************************************************************************/
21
22
23
24 #include "sigtype.hh"
25 #include "compatibility.hh"
26 #include <stdio.h>
27
28 #include "sigprint.hh"
29 #include "sigtyperules.hh"
30 #include "privatise.hh"
31
32
33 /*****************************************************************************
34 privatise : compile a list of signals
35 *****************************************************************************/
36
37 static Tree makePrivatisationKey(const Tree& t);
38 static Tree makePrivatisationLabel(const Tree& exp);
39
40 static Tree privatisation (const Tree& k, const Tree& t);
41 static Tree computePrivatisation (const Tree& k, const Tree& t);
42 static Tree labelize(const Tree& label, const Tree& exp);
43
44
45 Tree privatise(const Tree& t)
46 {
47
48 return privatisation(makePrivatisationKey(t), t);
49 }
50
51
52 // -- implementation -----------------
53
54 static Tree makePrivatisationKey(const Tree& t)
55 {
56 char name[256];
57 snprintf(name, 256, "PRIVATISE %p : ", (CTree*)t);
58 return tree(unique(name));
59 }
60
61 static Tree makePrivatisationLabel(const Tree& t)
62 {
63 char name[256];
64 snprintf(name, 256, "OWNER IS %p : ", (CTree*)t);
65 return tree(unique(name));
66 }
67
68
69 // -- implementation -----------------
70
71 static Tree privatisation (const Tree& k, const Tree& t)
72 {
73 Tree v;
74
75 if (t->arity() == 0) {
76 return t;
77
78 } else if (getProperty(t, k, v)) {
79 /* Terme deja visité. La propriété nous indique
80 la version privatisée ou nil si elle est identique
81 au terme initial.
82 */
83 return isNil(v) ? t : v;
84
85 } else {
86 /* Calcul du terme privatisé et mis à jour
87 de la propriété. Nil indique que le terme
88 privatisé est identique à celui de depart
89 (pour eviter les boucles avec les compteurs
90 de references)
91 */
92 v = computePrivatisation(k,t);
93 if (v != t) {
94 setProperty(t, k, v );
95 } else {
96 setProperty(t, k, nil);
97 }
98 return v;
99 }
100 }
101
102 static Tree computePrivatisation(const Tree& k, const Tree& exp)
103 {
104 Tree tbl, size, idx, wrt, content, id, var, body;
105
106 if ( isSigWRTbl(exp, id, tbl, idx, wrt) ) {
107 /* Ce qui ne peut pas être partagé, ce sont les
108 tables dans lesquelles on ecrit. Pour cela
109 on leur donne un label unique
110 */
111 return sigWRTbl(
112 id,
113 labelize( makePrivatisationLabel(exp), privatisation(k, tbl) ),
114 privatisation(k, idx),
115 privatisation(k, wrt) );
116
117 } else if ( isSigTable(exp, id, size, content) ) {
118 /* Rien à privatiser dans une table (car size est
119 censée etre une expression entiere)
120 */
121 return exp;
122
123 } else if ( isSigGen(exp, content) ) {
124 /* On ne visite pas les contenus des tables
125 */
126 printf("erreur 1 dans computePrivatisation\n");
127 exit(1);
128
129 } else if ( isRec(exp, var, body) ) {
130 /* On ne visite pas les contenus des tables
131 */
132 setProperty(exp, k, nil);
133 return rec(var, privatisation(k,body));
134
135 } else {
136 /* On parcours les autres arbres en privatisant les branches
137 */
138 int n = exp->arity();
139
140 switch (n) {
141
142 case 1 :
143 return tree(
144 exp->node(),
145 privatisation(k, exp->branch(0)) );
146 case 2 :
147 return tree(
148 exp->node(),
149 privatisation(k, exp->branch(0)),
150 privatisation(k, exp->branch(1)) );
151 case 3 :
152 return tree (
153 exp->node(),
154 privatisation(k, exp->branch(0)),
155 privatisation(k, exp->branch(1)),
156 privatisation(k, exp->branch(2)) );
157 case 4 :
158 return tree (
159 exp->node(),
160 privatisation(k, exp->branch(0)),
161 privatisation(k, exp->branch(1)),
162 privatisation(k, exp->branch(2)),
163 privatisation(k, exp->branch(3)) );
164 }
165 printf("erreur 2 dans computePrivatisation\n");
166 exit(1);
167 }
168 printf("situation anormale dans computePrivatisation\n");
169 return exp;
170 }
171
172 static Tree labelize(const Tree& newid, const Tree& exp)
173 {
174 Tree tbl, size, idx, wrt, content, oldid;
175
176 if ( isSigWRTbl(exp, oldid, tbl, idx, wrt) ) {
177 /* Ce qui ne peut pas être partagé, ce sont les
178 tables dans lesquelles on ecrit. Pour cela
179 on leur donne un label unique
180 */
181 return sigWRTbl(newid, tbl, idx, wrt);
182
183 } else if ( isSigTable(exp, oldid, size, content) ) {
184 /* Rien à privatiser dans une table (car size est
185 censée etre une expression entiere)
186 */
187 return sigTable(newid, size, content);
188
189 } else {
190
191 printf("erreur labelize\n");
192 exit(1);
193 }
194
195 return exp;
196 }
197