about summary refs log blame commit diff stats
path: root/src/chat_log.h
blob: e0aac551419300c74d849f1f5eace6809375381d (plain) (tree) 
6bad38c2 ^

83ef1d56 ^



6bad38c2 ^

83ef1d56 ^




















c343ff41 ^


cb27c4ab ^





83ef1d56 ^

6bad38c2 ^

76149e1f ^

83ef1d56 ^

6bad38c2 ^

da302d92 ^

83ef1d56 ^


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

  


                                                     
  



















                                                                       

                 




                       
                         
                                                           
                                                                                 
                          
                                                         
                                                    

      
/*
 * chat_log.h
 *
 * Copyright (C) 2012 James Booth <boothj5@gmail.com>
 *
 * This file is part of Profanity.
 *
 * Profanity is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Profanity is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Profanity.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef CHAT_LOG_H
#define CHAT_LOG_H

#include <glib.h>

typedef enum {
    IN,
    OUT
} chat_log_direction_t;

void chat_log_init(void);
void chat_log_chat(const gchar * const login, gchar *other,
    const gchar * const msg, chat_log_direction_t direction, GTimeVal *tv_stamp);
void chat_log_close(void);
GSList * chat_log_get_previous(const gchar * const login,
    const gchar * const recipient, GSList *history);

#endif
generated by cgit-pink 1.4.1-2-gfad0 (git 2.36.2.497.gbbea4dcf42) at 2024-11-18 14:57:33 +0000
89b84470569e4df3fd'>^ 
b24eb476 ^

1e38eee5 ^

58eb6ee2 ^

b24eb476 ^

58eb6ee2 ^


aae198a9 ^



58eb6ee2 ^





619bd33e ^

58eb6ee2 ^

43b866d1 ^

3473c63a ^

23d3a022 ^

0f2781f8 ^

23d3a022 ^



3473c63a ^


af023b32 ^

aae198a9 ^







af023b32 ^

58eb6ee2 ^

4a943d4e ^

















58eb6ee2 ^

43b866d1 ^

3473c63a ^


23d3a022 ^

3473c63a ^



58eb6ee2 ^

7284d503 ^


4a943d4e ^






















b38e5819 ^

fb1fcbc9 ^


b38e5819 ^

7284d503 ^


4a943d4e ^























b38e5819 ^

fb1fcbc9 ^


b38e5819 ^

514f0e34 ^

7d07cd1d ^

a2d8c713 ^

4a943d4e ^














a2d8c713 ^

1211a3ab ^

a2d8c713 ^


1211a3ab ^

a2d8c713 ^


70f70118 ^

514f0e34 ^

7d07cd1d ^




514f0e34 ^

77d5b5d6 ^

a2d8c713 ^

619bd33e ^








c81fde0c ^

619bd33e ^


43b866d1 ^

3473c63a ^







43b866d1 ^

3473c63a ^




a2d8c713 ^

0d3f30c2 ^



05331766 ^

0d3f30c2 ^




9a81d746 ^

0d3f30c2 ^

49620728 ^

0d3f30c2 ^


c442a5ad ^

0d3f30c2 ^

514f0e34 ^

e06ff621 ^

0d3f30c2 ^

acce384b ^






9a81d746 ^

05331766 ^

0d3f30c2 ^

05331766 ^

0d3f30c2 ^

05331766 ^

0d3f30c2 ^



6c96a437 ^

0d3f30c2 ^

e4b03c6f ^

d0e29245 ^

0d3f30c2 ^

0d3f30c2 ^



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
163
164
165
166

167

168

169
170

171

172
173
174

175

176
177

178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199

200

201
202

203

204
205

206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228

229

230
231

232

233

234

235

236
237
238
239
240
241
242
243
244
245
246
247
248
249

250

251

252
253

254

255
256

257

258

259
260
261
262

263

264

265

266
267
268
269
270
271
272
273

274

275
276

277

278
279
280
281
282
283
284

285

286
287
288
289

290

291
292
293

294

295
296
297
298

299

300

301

302
303

304

305

306

307

308

309
310
311
312
313
314

315

316

317

318

319

320

321
322
323

324

325

326

327

328

329
330
331

                                                                             

                                                                              


                                                                           
   

                                                                              



                                                                             
 
                                                               

                                                                          
 














































                                                                                           
 

                                                             













                                                             
 
                                             

                              
                                             

                                      

                       
                           
                  

                                
 
                                     
              
       


                                        
                     
                                                                                                                                
                                               
                                                                  
                    

 
                                  
                                  
                                                                                                

 
                                   
                      
                                       
                                         

                       


                                                                                                                                 




                                          
                                                                          
 
                                                 
                                
                      
                                                                                                                                                       


                                                                                                        

         
       






                                                                       
 
 
















                                                      
 
                                          

                                
                                  


                                                 
 

              





















                                                                       
 

                                                                      
 

                






















                                                                                                       
 

                                                                      
 
                                                                     
                                                                  
 













                                                                                    
 
                                             

                                 
                                             

                                         
                                                        
                           



                                                                       
                                 
                                          
 







                                                                                          
                                                             

                                                          
                                          






                                                                                                                               
                                                 



                                                                                                       
 


                                                          
                                              



                                                        
                                                                                                       
                                        
                                          

                                                                                       
                                                                                                       
                                   
                                               
                                                                                                       
 





                                                              
                          
                                          
                    
                                         
                       
                                          


                                                        
                                                                                   
                                   
                                                                                                      
                                   
                  


               
//: Spaces help isolate recipes from each other. You can create them at will,
//: and all addresses in arguments are implicitly based on the 'default-space'
//: (unless they have the /raw property)
//:
//: Spaces are often called 'scopes' in other languages. Stack frames are a
//: limited form of space that can't outlive callers.
//:
//: Warning: messing with 'default-space' can corrupt memory. Don't share
//: default-space between recipes. Later we'll see how to chain spaces safely.
//:
//: Tests in this layer can write to a location as part of one type, and read
//: it as part of another. This is unsafe and insecure, and we'll stop doing
//: this once we switch to variable names.

//: Under the hood, a space is an array of locations in memory.
:(before "End Mu Types Initialization")
put(Type_abbreviations, "space", new_type_tree("address:array:location"));

:(code)
void test_set_default_space() {
  run(
      "def main [\n"
         // prepare default-space address
      "  10:num/alloc-id, 11:num <- copy 0, 1000\n"
         // prepare default-space payload
      "  1000:num <- copy 0\n"  // alloc id of payload
      "  1001:num <- copy 5\n"  // length
         // actual start of this recipe
      "  default-space:space <- copy 10:&:@:location\n"
         // if default-space is 1000, then:
         //   1000: alloc id
         //   1001: array size
         //   1002: location 0 (space for the chaining slot; described later; often unused)
         //   1003: location 1 (space for the chaining slot; described later; often unused)
         //   1004: local 2 (assuming it is a scalar)
      "  2:num <- copy 93\n"
      "]\n"
  );
  CHECK_TRACE_CONTENTS(
      "mem: storing 93 in location 1004\n"
  );
}

void test_lookup_sidesteps_default_space() {
  run(
      "def main [\n"
         // prepare default-space address
      "  10:num/alloc-id, 11:num <- copy 0, 1000\n"
         // prepare default-space payload
      "  1000:num <- copy 0\n"  // alloc id of payload
      "  1001:num <- copy 5\n"  // length
         // prepare payload outside the local scope
      "  2000:num/alloc-id, 2001:num <- copy 0, 34\n"
         // actual start of this recipe
      "  default-space:space <- copy 10:&:@:location\n"
         // a local address
      "  2:num, 3:num <- copy 0, 2000\n"
      "  20:num/raw <- copy *2:&:num\n"
      "]\n"
  );
  CHECK_TRACE_CONTENTS(
      "mem: storing 2000 in location 1005\n"
      "mem: storing 34 in location 20\n"
  );
}

//: precondition: disable name conversion for 'default-space'

void test_convert_names_passes_default_space() {
  Hide_errors = true;
  transform(
      "def main [\n"
      "  default-space:num <- copy 0\n"
      "  x:num <- copy 1\n"
      "]\n"
  );
  CHECK_TRACE_CONTENTS(
      "name: assign x 2\n"
  );
  CHECK_TRACE_DOESNT_CONTAIN("name: assign default-space 1");
  CHECK_TRACE_DOESNT_CONTAIN("name: assign default-space 2");
}

:(before "End is_disqualified Special-cases")
if (x.name == "default-space")
  x.initialized = true;
:(before "End is_special_name Special-cases")
if (s == "default-space") return true;

//: core implementation

:(before "End call Fields")
int default_space;
:(before "End call Constructor")
default_space = 0;

:(before "Begin canonize(x) Lookups")
absolutize(x);
:(code)
void absolutize(reagent& x) {
  if (is_raw(x) || is_dummy(x)) return;
  if (x.name == "default-space") return;
  if (!x.initialized)
    raise << to_original_string(current_instruction()) << ": reagent not initialized: '" << x.original_string << "'\n" << end();
  x.set_value(address(x.value, space_base(x)));
  x.properties.push_back(pair<string, string_tree*>("raw", NULL));
  assert(is_raw(x));
}

//: hook replaced in a later layer
int space_base(const reagent& x) {
  return current_call().default_space ? (current_call().default_space + /*skip alloc id*/1) : 0;
}

int address(int offset, int base) {
  assert(offset >= 0);
  if (base == 0) return offset;  // raw
  int size = get_or_insert(Memory, base);
  if (offset >= size) {
    // todo: test
    raise << current_recipe_name() << ": location " << offset << " is out of bounds " << size << " at " << base << '\n' << end();
    DUMP("");
    exit(1);
    return 0;
  }
  return base + /*skip length*/1 + offset;
}

//: reads and writes to the 'default-space' variable have special behavior

:(after "Begin Preprocess write_memory(x, data)")
if (x.name == "default-space") {
  if (!is_mu_space(x))
    raise << maybe(current_recipe_name()) << "'default-space' should be of type address:array:location, but is " << to_string(x.type) << '\n' << end();
  if (SIZE(data) != 2)
    raise << maybe(current_recipe_name()) << "'default-space' getting data from non-address\n" << end();
  current_call().default_space = data.at(/*skip alloc id*/1);
  return;
}
:(code)
bool is_mu_space(reagent/*copy*/ x) {
  canonize_type(x);
  if (!is_compound_type_starting_with(x.type, "address")) return false;
  drop_from_type(x, "address");
  if (!is_compound_type_starting_with(x.type, "array")) return false;
  drop_from_type(x, "array");
  return x.type && x.type->atom && x.type->name == "location";
}

void test_get_default_space() {
  run(
      "def main [\n"
         // prepare default-space address
      "  10:num/alloc-id, 11:num <- copy 0, 1000\n"
         // prepare default-space payload
      "  1000:num <- copy 0\n"  // alloc id of payload
      "  1001:num <- copy 5\n"  // length
         // actual start of this recipe
      "  default-space:space <- copy 10:space\n"
      "  2:space/raw <- copy default-space:space\n"
      "]\n"
  );
  CHECK_TRACE_CONTENTS(
      "mem: storing 1000 in location 3\n"
  );
}

:(after "Begin Preprocess read_memory(x)")
if (x.name == "default-space") {
  vector<double> result;
  result.push_back(/*alloc id*/0);
  result.push_back(current_call().default_space);
  return result;
}

//:: fix 'get'

:(code)
void test_lookup_sidesteps_default_space_in_get() {
  run(
      "def main [\n"
         // prepare default-space address
      "  10:num/alloc-id, 11:num <- copy 0, 1000\n"
         // prepare default-space payload
      "  1000:num <- copy 0\n"  // alloc id of payload
      "  1001:num <- copy 5\n"  // length
         // prepare payload outside the local scope
      "  2000:num/alloc-id, 2001:num/x, 2002:num/y <- copy 0, 34, 35\n"
         // actual start of this recipe
      "  default-space:space <- copy 10:space\n"
         // a local address
      "  2:num, 3:num <- copy 0, 2000\n"
      "  3000:num/raw <- get *2:&:point, 1:offset\n"
      "]\n"
  );
  CHECK_TRACE_CONTENTS(
      "mem: storing 35 in location 3000\n"
  );
}

:(before "Read element" following "case GET:")
element.properties.push_back(pair<string, string_tree*>("raw", NULL));

//:: fix 'index'

:(code)
void test_lookup_sidesteps_default_space_in_index() {
  run(
      "def main [\n"
         // prepare default-space address
      "  10:num/alloc-id, 11:num <- copy 0, 1000\n"
         // prepare default-space payload
      "  1000:num <- copy 0\n"  // alloc id of payload
      "  1001:num <- copy 5\n"  // length
         // prepare an array address
      "  20:num/alloc-id, 21:num <- copy 0, 2000\n"
         // prepare an array payload
      "  2000:num/alloc-id, 2001:num/length, 2002:num/index:0, 2003:num/index:1 <- copy 0, 2, 34, 35\n"
         // actual start of this recipe
      "  default-space:space <- copy 10:&:@:location\n"
      "  1:&:@:num <- copy 20:&:@:num/raw\n"
      "  3000:num/raw <- index *1:&:@:num, 1\n"
      "]\n"
  );
  CHECK_TRACE_CONTENTS(
      "mem: storing 35 in location 3000\n"
  );
}

:(before "Read element" following "case INDEX:")
element.properties.push_back(pair<string, string_tree*>("raw", NULL));

//:: 'local-scope' is a convenience operation to automatically deduce
//:: the amount of space to allocate in a default space with names

:(code)
void test_local_scope() {
  run(
      "def main [\n"
      "  local-scope\n"
      "  x:num <- copy 0\n"
      "  y:num <- copy 3\n"
      "]\n"
  );
  CHECK_TRACE_CONTENTS(
      // allocate space for x and y, as well as the chaining slot at indices 0 and 1
      "mem: array length is 4\n"
  );
}

:(before "End is_disqualified Special-cases")
if (x.name == "number-of-locals")
  x.initialized = true;
:(before "End is_special_name Special-cases")
if (s == "number-of-locals") return true;

:(before "End Rewrite Instruction(curr, recipe result)")
// rewrite 'local-scope' to
//   ```
//   default-space:space <- new location:type, number-of-locals:literal
//   ```
// where number-of-locals is Name[recipe][""]
if (curr.name == "local-scope") {
  rewrite_default_space_instruction(curr);
}
:(code)
void rewrite_default_space_instruction(instruction& curr) {
  if (!curr.ingredients.empty())
    raise << "'" << to_original_string(curr) << "' can't take any ingredients\n" << end();
  curr.name = "new";
  curr.ingredients.push_back(reagent("location:type"));
  curr.ingredients.push_back(reagent("number-of-locals:literal"));
  if (!curr.products.empty())
    raise << "local-scope can't take any results\n" << end();
  curr.products.push_back(reagent("default-space:space"));
}
:(after "Begin Preprocess read_memory(x)")
if (x.name == "number-of-locals") {
  vector<double> result;
  result.push_back(Name[get(Recipe_ordinal, current_recipe_name())][""]);
  if (result.back() == 0)
    raise << "no space allocated for default-space in recipe " << current_recipe_name() << "; are you using names?\n" << end();
  return result;
}
:(after "Begin Preprocess write_memory(x, data)")
if (x.name == "number-of-locals") {
  raise << maybe(current_recipe_name()) << "can't write to special name 'number-of-locals'\n" << end();
  return;
}

//:: all recipes must set default-space one way or another

:(before "End Globals")
bool Hide_missing_default_space_errors = true;
:(before "End Checks")
Transform.push_back(check_default_space);  // idempotent
:(code)
void check_default_space(const recipe_ordinal r) {
  if (Hide_missing_default_space_errors) return;  // skip previous core tests; this is only for Mu code
  const recipe& caller = get(Recipe, r);
  // End check_default_space Special-cases
  // assume recipes with only numeric addresses know what they're doing (usually tests)
  if (!contains_non_special_name(r)) return;
  trace(101, "transform") << "--- check that recipe " << caller.name << " sets default-space" << end();
  if (caller.steps.empty()) return;
  if (!starts_by_setting_default_space(caller))
    raise << caller.name << " does not seem to start with 'local-scope' or 'default-space'\n" << end();
}
bool starts_by_setting_default_space(const recipe& r) {
  return !r.steps.empty()
      && !r.steps.at(0).products.empty()
      && r.steps.at(0).products.at(0).name == "default-space";
}

:(after "Load Mu Prelude")
Hide_missing_default_space_errors = false;
:(after "Test Runs")
Hide_missing_default_space_errors = true;
:(after "Running Main")
Hide_missing_default_space_errors = false;

:(code)
bool contains_non_special_name(const recipe_ordinal r) {
  for (map<string, int>::iterator p = Name[r].begin();  p != Name[r].end();  ++p) {
    if (p->first.empty()) continue;
    if (p->first.find("stash_") == 0) continue;  // generated by rewrite_stashes_to_text (cross-layer)
    if (!is_special_name(p->first))
      return true;
  }
  return false;
}
generated by cgit-pink 1.4.1-2-gfad0 (git 2.36.2.497.gbbea4dcf42) at 2024-11-18 14:57:29 +0000