MinitScript  0.9.31 PRE-BETA
ByteArrayMethods.cpp
Go to the documentation of this file.
1 #include <span>
2 
3 #include <minitscript/minitscript.h>
4 #include <minitscript/minitscript/ByteArrayMethods.h>
5 #include <minitscript/minitscript/MinitScript.h>
6 #include <minitscript/utilities/Console.h>
7 
8 using std::span;
9 
10 using minitscript::minitscript::ByteArrayMethods;
11 
12 using minitscript::minitscript::MinitScript;
13 
14 using _Console = minitscript::utilities::Console;
15 
16 void ByteArrayMethods::registerConstants(MinitScript* minitScript) {
17 }
18 
19 void ByteArrayMethods::registerMethods(MinitScript* minitScript) {
20  // byte array methods
21  {
22  //
23  class MethodByteArray: public MinitScript::Method {
24  private:
25  MinitScript* minitScript { nullptr };
26  public:
27  MethodByteArray(MinitScript* minitScript):
28  MinitScript::Method(
29  {},
30  MinitScript::TYPE_BYTEARRAY
31  ),
32  minitScript(minitScript) {}
33  const string getMethodName() override {
34  return "ByteArray";
35  }
36  void executeMethod(span<MinitScript::Variable>& arguments, MinitScript::Variable& returnValue, const MinitScript::SubStatement& subStatement) override {
37  if (arguments.size() == 0) {
38  returnValue.setType(MinitScript::TYPE_BYTEARRAY);
39  } else {
40  MINITSCRIPT_METHODUSAGE_COMPLAIN(getMethodName());
41  }
42  }
43  };
44  minitScript->registerMethod(new MethodByteArray(minitScript));
45  }
46  //
47  {
48  //
49  class MethodByteArrayGetSize: public MinitScript::Method {
50  private:
51  MinitScript* minitScript { nullptr };
52  public:
53  MethodByteArrayGetSize(MinitScript* minitScript):
54  MinitScript::Method(
55  {
56  { .type = MinitScript::TYPE_BYTEARRAY, .name = "bytearray", .optional = false, .reference = true, .nullable = false }
57  },
58  MinitScript::TYPE_INTEGER
59  ),
60  minitScript(minitScript) {}
61  const string getMethodName() override {
62  return "ByteArray::getSize";
63  }
64  void executeMethod(span<MinitScript::Variable>& arguments, MinitScript::Variable& returnValue, const MinitScript::SubStatement& subStatement) override {
65  if (arguments.size() == 1 &&
66  arguments[0].getType() == MinitScript::TYPE_BYTEARRAY) {
67  returnValue.setValue(static_cast<int64_t>(arguments[0].getByteArraySize()));
68  } else {
69  MINITSCRIPT_METHODUSAGE_COMPLAIN(getMethodName());
70  }
71  }
72  };
73  minitScript->registerMethod(new MethodByteArrayGetSize(minitScript));
74  }
75  //
76  {
77  //
78  class MethodByteArrayGetReadPosition: public MinitScript::Method {
79  private:
80  MinitScript* minitScript { nullptr };
81  public:
82  MethodByteArrayGetReadPosition(MinitScript* minitScript):
83  MinitScript::Method(
84  {
85  { .type = MinitScript::TYPE_BYTEARRAY, .name = "bytearray", .optional = false, .reference = true, .nullable = false }
86  },
87  MinitScript::TYPE_INTEGER
88  ),
89  minitScript(minitScript) {}
90  const string getMethodName() override {
91  return "ByteArray::getReadPosition";
92  }
93  void executeMethod(span<MinitScript::Variable>& arguments, MinitScript::Variable& returnValue, const MinitScript::SubStatement& subStatement) override {
94  if (arguments.size() == 1 &&
95  arguments[0].getType() == MinitScript::TYPE_BYTEARRAY) {
96  returnValue.setValue(*arguments[0].getByteArrayReadPointer());
97  } else {
98  MINITSCRIPT_METHODUSAGE_COMPLAIN(getMethodName());
99  }
100  }
101  };
102  minitScript->registerMethod(new MethodByteArrayGetReadPosition(minitScript));
103  }
104  //
105  {
106  //
107  class MethodByteArraySetReadPosition: public MinitScript::Method {
108  private:
109  MinitScript* minitScript { nullptr };
110  public:
111  MethodByteArraySetReadPosition(MinitScript* minitScript):
112  MinitScript::Method(
113  {
114  { .type = MinitScript::TYPE_BYTEARRAY, .name = "bytearray", .optional = false, .reference = true, .nullable = false },
115  { .type = MinitScript::TYPE_INTEGER, .name = "position", .optional = false, .reference = false, .nullable = false }
116  },
117  MinitScript::TYPE_NULL
118  ),
119  minitScript(minitScript) {}
120  const string getMethodName() override {
121  return "ByteArray::setReadPosition";
122  }
123  void executeMethod(span<MinitScript::Variable>& arguments, MinitScript::Variable& returnValue, const MinitScript::SubStatement& subStatement) override {
124  int64_t position;
125  if (arguments.size() == 2 &&
126  arguments[0].getType() == MinitScript::TYPE_BYTEARRAY &&
127  MinitScript::getIntegerValue(arguments, 1, position) == true) {
128  const auto byteArrayReadPtr = arguments[0].getByteArrayReadPointer();
129  if (position < 0ll) {
130  minitScript->complain(getMethodName(), subStatement, "Byte array read position must not be lesser than 0");
131  } else
132  if (position >= arguments[0].getByteArraySize()) {
133  minitScript->complain(getMethodName(), subStatement, "Byte array read position exceeding byte array size: " + to_string(*byteArrayReadPtr) + " >= " + to_string(arguments[0].getByteArraySize()));
134  } else {
135  *byteArrayReadPtr = position;
136  }
137  } else {
138  MINITSCRIPT_METHODUSAGE_COMPLAIN(getMethodName());
139  }
140  }
141  };
142  minitScript->registerMethod(new MethodByteArraySetReadPosition(minitScript));
143  }
144  //
145  {
146  //
147  class MethodByteArrayGetWritePosition: public MinitScript::Method {
148  private:
149  MinitScript* minitScript { nullptr };
150  public:
151  MethodByteArrayGetWritePosition(MinitScript* minitScript):
152  MinitScript::Method(
153  {
154  { .type = MinitScript::TYPE_BYTEARRAY, .name = "bytearray", .optional = false, .reference = true, .nullable = false }
155  },
156  MinitScript::TYPE_INTEGER
157  ),
158  minitScript(minitScript) {}
159  const string getMethodName() override {
160  return "ByteArray::getWritePosition";
161  }
162  void executeMethod(span<MinitScript::Variable>& arguments, MinitScript::Variable& returnValue, const MinitScript::SubStatement& subStatement) override {
163  if (arguments.size() == 1 &&
164  arguments[0].getType() == MinitScript::TYPE_BYTEARRAY) {
165  returnValue.setValue(*arguments[0].getByteArrayWritePointer());
166  } else {
167  MINITSCRIPT_METHODUSAGE_COMPLAIN(getMethodName());
168  }
169  }
170  };
171  minitScript->registerMethod(new MethodByteArrayGetWritePosition(minitScript));
172  }
173  //
174  {
175  //
176  class MethodByteArraySetWritePosition: public MinitScript::Method {
177  private:
178  MinitScript* minitScript { nullptr };
179  public:
180  MethodByteArraySetWritePosition(MinitScript* minitScript):
181  MinitScript::Method(
182  {
183  { .type = MinitScript::TYPE_BYTEARRAY, .name = "bytearray", .optional = false, .reference = true, .nullable = false },
184  { .type = MinitScript::TYPE_INTEGER, .name = "position", .optional = false, .reference = false, .nullable = false }
185  },
186  MinitScript::TYPE_NULL
187  ),
188  minitScript(minitScript) {}
189  const string getMethodName() override {
190  return "ByteArray::setWritePosition";
191  }
192  void executeMethod(span<MinitScript::Variable>& arguments, MinitScript::Variable& returnValue, const MinitScript::SubStatement& subStatement) override {
193  int64_t position;
194  if (arguments.size() == 2 &&
195  arguments[0].getType() == MinitScript::TYPE_BYTEARRAY &&
196  MinitScript::getIntegerValue(arguments, 1, position) == true) {
197  const auto byteArrayWritePtr = arguments[0].getByteArrayWritePointer();
198  if (position < 0ll) {
199  minitScript->complain(getMethodName(), subStatement, "Byte array write position must not be lesser than 0");
200  } else
201  if (position > arguments[0].getByteArraySize()) {
202  minitScript->complain(getMethodName(), subStatement, "Byte array write position exceeding byte array size: " + to_string(*byteArrayWritePtr) + " >= " + to_string(arguments[0].getByteArraySize()));
203  } else {
204  *byteArrayWritePtr = position;
205  }
206  } else {
207  MINITSCRIPT_METHODUSAGE_COMPLAIN(getMethodName());
208  }
209  }
210  };
211  minitScript->registerMethod(new MethodByteArraySetWritePosition(minitScript));
212  }
213  //
214  {
215  //
216  class MethodByteArrayReadBool: public MinitScript::Method {
217  private:
218  MinitScript* minitScript { nullptr };
219  public:
220  MethodByteArrayReadBool(MinitScript* minitScript):
221  MinitScript::Method(
222  {
223  { .type = MinitScript::TYPE_BYTEARRAY, .name = "bytearray", .optional = false, .reference = true, .nullable = false },
224  },
225  MinitScript::TYPE_BOOLEAN,
226  true
227  ),
228  minitScript(minitScript) {}
229  const string getMethodName() override {
230  return "ByteArray::readBool";
231  }
232  void executeMethod(span<MinitScript::Variable>& arguments, MinitScript::Variable& returnValue, const MinitScript::SubStatement& subStatement) override {
233  if (arguments.size() == 1 &&
234  arguments[0].getType() == MinitScript::TYPE_BYTEARRAY) {
235  const auto byteArrayReadPtr = arguments[0].getByteArrayReadPointer();
236  if ((*byteArrayReadPtr) + 1 > arguments[0].getByteArraySize()) {
237  minitScript->complain(getMethodName(), subStatement, "Exceeding byte array size while reading boolean value, because of read position " + to_string(*byteArrayReadPtr) + " + 1 >= " + to_string(arguments[0].getByteArraySize()));
238  } else {
239  returnValue.setValue(arguments[0].getByteArrayEntry((*byteArrayReadPtr)++) != 0);
240  }
241  } else {
242  MINITSCRIPT_METHODUSAGE_COMPLAIN(getMethodName());
243  }
244  }
245  };
246  minitScript->registerMethod(new MethodByteArrayReadBool(minitScript));
247  }
248  //
249  {
250  //
251  class MethodByteArrayReadInt8: public MinitScript::Method {
252  private:
253  MinitScript* minitScript { nullptr };
254  public:
255  MethodByteArrayReadInt8(MinitScript* minitScript):
256  MinitScript::Method(
257  {
258  { .type = MinitScript::TYPE_BYTEARRAY, .name = "bytearray", .optional = false, .reference = true, .nullable = false }
259  },
260  MinitScript::TYPE_INTEGER,
261  true
262  ),
263  minitScript(minitScript) {}
264  const string getMethodName() override {
265  return "ByteArray::readInt8";
266  }
267  void executeMethod(span<MinitScript::Variable>& arguments, MinitScript::Variable& returnValue, const MinitScript::SubStatement& subStatement) override {
268  if (arguments.size() == 1 &&
269  arguments[0].getType() == MinitScript::TYPE_BYTEARRAY) {
270  const auto byteArrayReadPtr = arguments[0].getByteArrayReadPointer();
271  if ((*byteArrayReadPtr) + 1 > arguments[0].getByteArraySize()) {
272  minitScript->complain(getMethodName(), subStatement, "Exceeding byte array size while reading 8 bit integer value, because of read position " + to_string(*byteArrayReadPtr) + " + 1 >= " + to_string(arguments[0].getByteArraySize()));
273  } else {
274  returnValue.setValue(static_cast<int64_t>(arguments[0].getByteArrayEntry((*byteArrayReadPtr)++)));
275  }
276  } else {
277  MINITSCRIPT_METHODUSAGE_COMPLAIN(getMethodName());
278  }
279  }
280  };
281  minitScript->registerMethod(new MethodByteArrayReadInt8(minitScript));
282  }
283  //
284  {
285  //
286  class MethodByteArrayReadInt16: public MinitScript::Method {
287  private:
288  MinitScript* minitScript { nullptr };
289  public:
290  MethodByteArrayReadInt16(MinitScript* minitScript):
291  MinitScript::Method(
292  {
293  { .type = MinitScript::TYPE_BYTEARRAY, .name = "bytearray", .optional = false, .reference = true, .nullable = false },
294  },
295  MinitScript::TYPE_INTEGER,
296  true
297  ),
298  minitScript(minitScript) {}
299  const string getMethodName() override {
300  return "ByteArray::readInt16";
301  }
302  void executeMethod(span<MinitScript::Variable>& arguments, MinitScript::Variable& returnValue, const MinitScript::SubStatement& subStatement) override {
303  if (arguments.size() == 1 &&
304  arguments[0].getType() == MinitScript::TYPE_BYTEARRAY) {
305  const auto byteArrayReadPtr = arguments[0].getByteArrayReadPointer();
306  if ((*byteArrayReadPtr) + 2 > arguments[0].getByteArraySize()) {
307  minitScript->complain(getMethodName(), subStatement, "Exceeding byte array size while reading 16 bit integer value, because of read position " + to_string(*byteArrayReadPtr) + " + 2 >= " + to_string(arguments[0].getByteArraySize()));
308  } else {
309  returnValue.setValue(
310  static_cast<int64_t>(arguments[0].getByteArrayEntry((*byteArrayReadPtr)++)) +
311  (static_cast<int64_t>(arguments[0].getByteArrayEntry((*byteArrayReadPtr)++)) << 8)
312  );
313  }
314  } else {
315  MINITSCRIPT_METHODUSAGE_COMPLAIN(getMethodName());
316  }
317  }
318  };
319  minitScript->registerMethod(new MethodByteArrayReadInt16(minitScript));
320  }
321  //
322  {
323  //
324  class MethodByteArrayReadInt32: public MinitScript::Method {
325  private:
326  MinitScript* minitScript { nullptr };
327  public:
328  MethodByteArrayReadInt32(MinitScript* minitScript):
329  MinitScript::Method(
330  {
331  { .type = MinitScript::TYPE_BYTEARRAY, .name = "bytearray", .optional = false, .reference = true, .nullable = false },
332  },
333  MinitScript::TYPE_INTEGER,
334  true
335  ),
336  minitScript(minitScript) {}
337  const string getMethodName() override {
338  return "ByteArray::readInt32";
339  }
340  void executeMethod(span<MinitScript::Variable>& arguments, MinitScript::Variable& returnValue, const MinitScript::SubStatement& subStatement) override {
341  if (arguments.size() == 1 &&
342  arguments[0].getType() == MinitScript::TYPE_BYTEARRAY) {
343  const auto byteArrayReadPtr = arguments[0].getByteArrayReadPointer();
344  if ((*byteArrayReadPtr) + 4 > arguments[0].getByteArraySize()) {
345  minitScript->complain(getMethodName(), subStatement, "Exceeding byte array size while reading 32 bit integer value, because of read position " + to_string(*byteArrayReadPtr) + " + 4 >= " + to_string(arguments[0].getByteArraySize()));
346  } else {
347  returnValue.setValue(
348  static_cast<int64_t>(arguments[0].getByteArrayEntry((*byteArrayReadPtr)++)) +
349  (static_cast<int64_t>(arguments[0].getByteArrayEntry((*byteArrayReadPtr)++)) << 8) +
350  (static_cast<int64_t>(arguments[0].getByteArrayEntry((*byteArrayReadPtr)++)) << 16) +
351  (static_cast<int64_t>(arguments[0].getByteArrayEntry((*byteArrayReadPtr)++)) << 24)
352  );
353  }
354  } else {
355  MINITSCRIPT_METHODUSAGE_COMPLAIN(getMethodName());
356  }
357  }
358  };
359  minitScript->registerMethod(new MethodByteArrayReadInt32(minitScript));
360  }
361  //
362  {
363  //
364  class MethodByteArrayReadInt64: public MinitScript::Method {
365  private:
366  MinitScript* minitScript { nullptr };
367  public:
368  MethodByteArrayReadInt64(MinitScript* minitScript):
369  MinitScript::Method(
370  {
371  { .type = MinitScript::TYPE_BYTEARRAY, .name = "bytearray", .optional = false, .reference = true, .nullable = false },
372  },
373  MinitScript::TYPE_INTEGER,
374  true
375  ),
376  minitScript(minitScript) {}
377  const string getMethodName() override {
378  return "ByteArray::readInt64";
379  }
380  void executeMethod(span<MinitScript::Variable>& arguments, MinitScript::Variable& returnValue, const MinitScript::SubStatement& subStatement) override {
381  if (arguments.size() == 1 &&
382  arguments[0].getType() == MinitScript::TYPE_BYTEARRAY) {
383  const auto byteArrayReadPtr = arguments[0].getByteArrayReadPointer();
384  if ((*byteArrayReadPtr) + 8 > arguments[0].getByteArraySize()) {
385  minitScript->complain(getMethodName(), subStatement, "Exceeding byte array size while reading 64 bit integer value, because of read position " + to_string(*byteArrayReadPtr) + " + 8 >= " + to_string(arguments[0].getByteArraySize()));
386  } else {
387  returnValue.setValue(
388  static_cast<int64_t>(arguments[0].getByteArrayEntry((*byteArrayReadPtr)++)) +
389  (static_cast<int64_t>(arguments[0].getByteArrayEntry((*byteArrayReadPtr)++)) << 8) +
390  (static_cast<int64_t>(arguments[0].getByteArrayEntry((*byteArrayReadPtr)++)) << 16) +
391  (static_cast<int64_t>(arguments[0].getByteArrayEntry((*byteArrayReadPtr)++)) << 24) +
392  (static_cast<int64_t>(arguments[0].getByteArrayEntry((*byteArrayReadPtr)++)) << 32) +
393  (static_cast<int64_t>(arguments[0].getByteArrayEntry((*byteArrayReadPtr)++)) << 40) +
394  (static_cast<int64_t>(arguments[0].getByteArrayEntry((*byteArrayReadPtr)++)) << 48) +
395  (static_cast<int64_t>(arguments[0].getByteArrayEntry((*byteArrayReadPtr)++)) << 56)
396 
397  );
398  }
399  } else {
400  MINITSCRIPT_METHODUSAGE_COMPLAIN(getMethodName());
401  }
402  }
403  };
404  minitScript->registerMethod(new MethodByteArrayReadInt64(minitScript));
405  }
406  //
407  {
408  //
409  class MethodByteArrayReadFloat: public MinitScript::Method {
410  private:
411  MinitScript* minitScript { nullptr };
412  public:
413  MethodByteArrayReadFloat(MinitScript* minitScript):
414  MinitScript::Method(
415  {
416  { .type = MinitScript::TYPE_BYTEARRAY, .name = "bytearray", .optional = false, .reference = true, .nullable = false },
417  },
418  MinitScript::TYPE_FLOAT,
419  true
420  ),
421  minitScript(minitScript) {}
422  const string getMethodName() override {
423  return "ByteArray::readFloat";
424  }
425  void executeMethod(span<MinitScript::Variable>& arguments, MinitScript::Variable& returnValue, const MinitScript::SubStatement& subStatement) override {
426  if (arguments.size() == 1 &&
427  arguments[0].getType() == MinitScript::TYPE_BYTEARRAY) {
428  const auto byteArrayReadPtr = arguments[0].getByteArrayReadPointer();
429  if ((*byteArrayReadPtr) + 4 > arguments[0].getByteArraySize()) {
430  minitScript->complain(getMethodName(), subStatement, "Exceeding byte array size while reading 32 bit float value, because of read position " + to_string(*byteArrayReadPtr) + " + 4 >= " + to_string(arguments[0].getByteArraySize()));
431  } else {
432  uint32_t floatAsInt =
433  static_cast<int64_t>(arguments[0].getByteArrayEntry((*byteArrayReadPtr)++)) +
434  (static_cast<int64_t>(arguments[0].getByteArrayEntry((*byteArrayReadPtr)++)) << 8) +
435  (static_cast<int64_t>(arguments[0].getByteArrayEntry((*byteArrayReadPtr)++)) << 16) +
436  (static_cast<int64_t>(arguments[0].getByteArrayEntry((*byteArrayReadPtr)++)) << 24);
437  returnValue.setValue(*((float*)&floatAsInt));
438  }
439  } else {
440  MINITSCRIPT_METHODUSAGE_COMPLAIN(getMethodName());
441  }
442  }
443  };
444  minitScript->registerMethod(new MethodByteArrayReadFloat(minitScript));
445  }
446  //
447  {
448  //
449  class MethodByteArrayReadSmallString: public MinitScript::Method {
450  private:
451  MinitScript* minitScript { nullptr };
452  public:
453  MethodByteArrayReadSmallString(MinitScript* minitScript):
454  MinitScript::Method(
455  {
456  { .type = MinitScript::TYPE_BYTEARRAY, .name = "bytearray", .optional = false, .reference = true, .nullable = false },
457  },
458  MinitScript::TYPE_STRING,
459  true
460  ),
461  minitScript(minitScript) {}
462  const string getMethodName() override {
463  return "ByteArray::readSmallString";
464  }
465  void executeMethod(span<MinitScript::Variable>& arguments, MinitScript::Variable& returnValue, const MinitScript::SubStatement& subStatement) override {
466  if (arguments.size() == 1 &&
467  arguments[0].getType() == MinitScript::TYPE_BYTEARRAY) {
468  const auto byteArrayReadPtr = arguments[0].getByteArrayReadPointer();
469  if ((*byteArrayReadPtr) + 1 > arguments[0].getByteArraySize()) {
470  minitScript->complain(getMethodName(), subStatement, "Exceeding byte array size while reading 8 bit string size, because of read position " + to_string(*byteArrayReadPtr) + " + 1 >= " + to_string(arguments[0].getByteArraySize()));
471  } else {
472  string value;
473  auto size = static_cast<int64_t>(arguments[0].getByteArrayEntry((*byteArrayReadPtr)++));
474  if ((*byteArrayReadPtr) + size > arguments[0].getByteArraySize()) {
475  minitScript->complain(getMethodName(), subStatement, "Exceeding byte array size while reading string bytes, because of read position " + to_string(*byteArrayReadPtr) + " + " + to_string(size) + " >= " + to_string(arguments[0].getByteArraySize()));
476  } else {
477  value.resize(size);
478  for (auto i = 0; i < size; i++) value.data()[i] = arguments[0].getByteArrayEntry((*byteArrayReadPtr)++);
479  returnValue.setValue(value);
480  }
481  }
482  } else {
483  MINITSCRIPT_METHODUSAGE_COMPLAIN(getMethodName());
484  }
485  }
486  };
487  minitScript->registerMethod(new MethodByteArrayReadSmallString(minitScript));
488  }
489  //
490  {
491  //
492  class MethodByteArrayReadMediumString: public MinitScript::Method {
493  private:
494  MinitScript* minitScript { nullptr };
495  public:
496  MethodByteArrayReadMediumString(MinitScript* minitScript):
497  MinitScript::Method(
498  {
499  { .type = MinitScript::TYPE_BYTEARRAY, .name = "bytearray", .optional = false, .reference = true, .nullable = false },
500  },
501  MinitScript::TYPE_STRING,
502  true
503  ),
504  minitScript(minitScript) {}
505  const string getMethodName() override {
506  return "ByteArray::readMediumString";
507  }
508  void executeMethod(span<MinitScript::Variable>& arguments, MinitScript::Variable& returnValue, const MinitScript::SubStatement& subStatement) override {
509  if (arguments.size() == 1 &&
510  arguments[0].getType() == MinitScript::TYPE_BYTEARRAY) {
511  const auto byteArrayReadPtr = arguments[0].getByteArrayReadPointer();
512  if ((*byteArrayReadPtr) + 2 > arguments[0].getByteArraySize()) {
513  minitScript->complain(getMethodName(), subStatement, "Exceeding byte array size while reading 16 bit string size, because of read position " + to_string(*byteArrayReadPtr) + " + 2 >= " + to_string(arguments[0].getByteArraySize()));
514  } else {
515  string value;
516  auto size =
517  static_cast<int64_t>(arguments[0].getByteArrayEntry((*byteArrayReadPtr)++)) +
518  (static_cast<int64_t>(arguments[0].getByteArrayEntry((*byteArrayReadPtr)++)) << 8);
519  if ((*byteArrayReadPtr) + size > arguments[0].getByteArraySize()) {
520  minitScript->complain(getMethodName(), subStatement, "Exceeding byte array size while reading string bytes, because of read position " + to_string(*byteArrayReadPtr) + " + " + to_string(size) + " >= " + to_string(arguments[0].getByteArraySize()));
521  } else {
522  value.resize(size);
523  for (auto i = 0; i < size; i++) value.data()[i] = arguments[0].getByteArrayEntry((*byteArrayReadPtr)++);
524  returnValue.setValue(value);
525  }
526  }
527  } else {
528  MINITSCRIPT_METHODUSAGE_COMPLAIN(getMethodName());
529  }
530  }
531  };
532  minitScript->registerMethod(new MethodByteArrayReadMediumString(minitScript));
533  }
534  //
535  {
536  //
537  class MethodByteArrayReadLargeString: public MinitScript::Method {
538  private:
539  MinitScript* minitScript { nullptr };
540  public:
541  MethodByteArrayReadLargeString(MinitScript* minitScript):
542  MinitScript::Method(
543  {
544  { .type = MinitScript::TYPE_BYTEARRAY, .name = "bytearray", .optional = false, .reference = true, .nullable = false },
545  },
546  MinitScript::TYPE_STRING,
547  true
548  ),
549  minitScript(minitScript) {}
550  const string getMethodName() override {
551  return "ByteArray::readLargeString";
552  }
553  void executeMethod(span<MinitScript::Variable>& arguments, MinitScript::Variable& returnValue, const MinitScript::SubStatement& subStatement) override {
554  if (arguments.size() == 1 &&
555  arguments[0].getType() == MinitScript::TYPE_BYTEARRAY) {
556  const auto byteArrayReadPtr = arguments[0].getByteArrayReadPointer();
557  if ((*byteArrayReadPtr) + 4 > arguments[0].getByteArraySize()) {
558  minitScript->complain(getMethodName(), subStatement, "Exceeding byte array size while reading 32 bit string size, because of read position " + to_string(*byteArrayReadPtr) + " + 4 >= " + to_string(arguments[0].getByteArraySize()));
559  } else {
560  string value;
561  auto size =
562  static_cast<int64_t>(arguments[0].getByteArrayEntry((*byteArrayReadPtr)++)) +
563  (static_cast<int64_t>(arguments[0].getByteArrayEntry((*byteArrayReadPtr)++)) << 8) +
564  (static_cast<int64_t>(arguments[0].getByteArrayEntry((*byteArrayReadPtr)++)) << 16) +
565  (static_cast<int64_t>(arguments[0].getByteArrayEntry((*byteArrayReadPtr)++)) << 24);
566  if ((*byteArrayReadPtr) + size > arguments[0].getByteArraySize()) {
567  minitScript->complain(getMethodName(), subStatement, "Exceeding byte array size while reading string bytes, because of read position " + to_string(*byteArrayReadPtr) + " + " + to_string(size) + " >= " + to_string(arguments[0].getByteArraySize()));
568  } else {
569  value.resize(size);
570  for (auto i = 0; i < size; i++) value.data()[i] = arguments[0].getByteArrayEntry((*byteArrayReadPtr)++);
571  returnValue.setValue(value);
572  }
573  }
574  } else {
575  MINITSCRIPT_METHODUSAGE_COMPLAIN(getMethodName());
576  }
577  }
578  };
579  minitScript->registerMethod(new MethodByteArrayReadLargeString(minitScript));
580  }
581  //
582  {
583  //
584  class MethodByteArrayWriteBool: public MinitScript::Method {
585  private:
586  MinitScript* minitScript { nullptr };
587  public:
588  MethodByteArrayWriteBool(MinitScript* minitScript):
589  MinitScript::Method(
590  {
591  { .type = MinitScript::TYPE_BYTEARRAY, .name = "bytearray", .optional = false, .reference = true, .nullable = false },
592  { .type = MinitScript::TYPE_BOOLEAN, .name = "value", .optional = false, .reference = false, .nullable = false }
593  },
594  MinitScript::TYPE_NULL
595  ),
596  minitScript(minitScript) {}
597  const string getMethodName() override {
598  return "ByteArray::writeBool";
599  }
600  void executeMethod(span<MinitScript::Variable>& arguments, MinitScript::Variable& returnValue, const MinitScript::SubStatement& subStatement) override {
601  bool value;
602  if (arguments.size() == 2 &&
603  arguments[0].getType() == MinitScript::TYPE_BYTEARRAY &&
604  MinitScript::getBooleanValue(arguments, 1, value) == true) {
605  const auto byteArrayWritePtr = arguments[0].getByteArrayWritePointer();
606  arguments[0].setByteArrayEntry((*byteArrayWritePtr)++, value);
607  } else {
608  MINITSCRIPT_METHODUSAGE_COMPLAIN(getMethodName());
609  }
610  }
611  };
612  minitScript->registerMethod(new MethodByteArrayWriteBool(minitScript));
613  }
614  //
615  {
616  //
617  class MethodByteArrayWriteInt8: public MinitScript::Method {
618  private:
619  MinitScript* minitScript { nullptr };
620  public:
621  MethodByteArrayWriteInt8(MinitScript* minitScript):
622  MinitScript::Method(
623  {
624  { .type = MinitScript::TYPE_BYTEARRAY, .name = "bytearray", .optional = false, .reference = true, .nullable = false },
625  { .type = MinitScript::TYPE_INTEGER, .name = "value", .optional = false, .reference = false, .nullable = false }
626  },
627  MinitScript::TYPE_NULL
628  ),
629  minitScript(minitScript) {}
630  const string getMethodName() override {
631  return "ByteArray::writeInt8";
632  }
633  void executeMethod(span<MinitScript::Variable>& arguments, MinitScript::Variable& returnValue, const MinitScript::SubStatement& subStatement) override {
634  int64_t value;
635  if (arguments.size() == 2 &&
636  arguments[0].getType() == MinitScript::TYPE_BYTEARRAY &&
637  MinitScript::getIntegerValue(arguments, 1, value) == true) {
638  const auto byteArrayWritePtr = arguments[0].getByteArrayWritePointer();
639  arguments[0].setByteArrayEntry((*byteArrayWritePtr)++, value);
640  } else {
641  MINITSCRIPT_METHODUSAGE_COMPLAIN(getMethodName());
642  }
643  }
644  };
645  minitScript->registerMethod(new MethodByteArrayWriteInt8(minitScript));
646  }
647  //
648  {
649  //
650  class MethodByteArrayWriteInt16: public MinitScript::Method {
651  private:
652  MinitScript* minitScript { nullptr };
653  public:
654  MethodByteArrayWriteInt16(MinitScript* minitScript):
655  MinitScript::Method(
656  {
657  { .type = MinitScript::TYPE_BYTEARRAY, .name = "bytearray", .optional = false, .reference = true, .nullable = false },
658  { .type = MinitScript::TYPE_INTEGER, .name = "value", .optional = false, .reference = false, .nullable = false }
659  },
660  MinitScript::TYPE_NULL
661  ),
662  minitScript(minitScript) {}
663  const string getMethodName() override {
664  return "ByteArray::writeInt16";
665  }
666  void executeMethod(span<MinitScript::Variable>& arguments, MinitScript::Variable& returnValue, const MinitScript::SubStatement& subStatement) override {
667  int64_t value;
668  if (arguments.size() == 2 &&
669  arguments[0].getType() == MinitScript::TYPE_BYTEARRAY &&
670  MinitScript::getIntegerValue(arguments, 1, value) == true) {
671  const auto byteArrayWritePtr = arguments[0].getByteArrayWritePointer();
672  arguments[0].setByteArrayEntry((*byteArrayWritePtr)++, value & 0xff);
673  arguments[0].setByteArrayEntry((*byteArrayWritePtr)++, (value >> 8) & 0xff);
674  } else {
675  MINITSCRIPT_METHODUSAGE_COMPLAIN(getMethodName());
676  }
677  }
678  };
679  minitScript->registerMethod(new MethodByteArrayWriteInt16(minitScript));
680  }
681  //
682  {
683  //
684  class MethodByteArrayWriteInt32: public MinitScript::Method {
685  private:
686  MinitScript* minitScript { nullptr };
687  public:
688  MethodByteArrayWriteInt32(MinitScript* minitScript):
689  MinitScript::Method(
690  {
691  { .type = MinitScript::TYPE_BYTEARRAY, .name = "bytearray", .optional = false, .reference = true, .nullable = false },
692  { .type = MinitScript::TYPE_INTEGER, .name = "value", .optional = false, .reference = false, .nullable = false }
693  },
694  MinitScript::TYPE_NULL
695  ),
696  minitScript(minitScript) {}
697  const string getMethodName() override {
698  return "ByteArray::writeInt32";
699  }
700  void executeMethod(span<MinitScript::Variable>& arguments, MinitScript::Variable& returnValue, const MinitScript::SubStatement& subStatement) override {
701  int64_t value;
702  if (arguments.size() == 2 &&
703  arguments[0].getType() == MinitScript::TYPE_BYTEARRAY &&
704  MinitScript::getIntegerValue(arguments, 1, value) == true) {
705  const auto byteArrayWritePtr = arguments[0].getByteArrayWritePointer();
706  arguments[0].setByteArrayEntry((*byteArrayWritePtr)++, value & 0xff);
707  arguments[0].setByteArrayEntry((*byteArrayWritePtr)++, (value >> 8) & 0xff);
708  arguments[0].setByteArrayEntry((*byteArrayWritePtr)++, (value >> 16) & 0xff);
709  arguments[0].setByteArrayEntry((*byteArrayWritePtr)++, (value >> 24) & 0xff);
710  } else {
711  MINITSCRIPT_METHODUSAGE_COMPLAIN(getMethodName());
712  }
713  }
714  };
715  minitScript->registerMethod(new MethodByteArrayWriteInt32(minitScript));
716  }
717  //
718  {
719  //
720  class MethodByteArrayWriteInt64: public MinitScript::Method {
721  private:
722  MinitScript* minitScript { nullptr };
723  public:
724  MethodByteArrayWriteInt64(MinitScript* minitScript):
725  MinitScript::Method(
726  {
727  { .type = MinitScript::TYPE_BYTEARRAY, .name = "bytearray", .optional = false, .reference = true, .nullable = false },
728  { .type = MinitScript::TYPE_INTEGER, .name = "value", .optional = false, .reference = false, .nullable = false }
729  },
730  MinitScript::TYPE_NULL
731  ),
732  minitScript(minitScript) {}
733  const string getMethodName() override {
734  return "ByteArray::writeInt64";
735  }
736  void executeMethod(span<MinitScript::Variable>& arguments, MinitScript::Variable& returnValue, const MinitScript::SubStatement& subStatement) override {
737  int64_t value;
738  if (arguments.size() == 2 &&
739  arguments[0].getType() == MinitScript::TYPE_BYTEARRAY &&
740  MinitScript::getIntegerValue(arguments, 1, value) == true) {
741  const auto byteArrayWritePtr = arguments[0].getByteArrayWritePointer();
742  arguments[0].setByteArrayEntry((*byteArrayWritePtr)++, value & 0xff);
743  arguments[0].setByteArrayEntry((*byteArrayWritePtr)++, (value >> 8) & 0xff);
744  arguments[0].setByteArrayEntry((*byteArrayWritePtr)++, (value >> 16) & 0xff);
745  arguments[0].setByteArrayEntry((*byteArrayWritePtr)++, (value >> 24) & 0xff);
746  arguments[0].setByteArrayEntry((*byteArrayWritePtr)++, (value >> 32) & 0xff);
747  arguments[0].setByteArrayEntry((*byteArrayWritePtr)++, (value >> 40) & 0xff);
748  arguments[0].setByteArrayEntry((*byteArrayWritePtr)++, (value >> 48) & 0xff);
749  arguments[0].setByteArrayEntry((*byteArrayWritePtr)++, (value >> 56) & 0xff);
750  } else {
751  MINITSCRIPT_METHODUSAGE_COMPLAIN(getMethodName());
752  }
753  }
754  };
755  minitScript->registerMethod(new MethodByteArrayWriteInt64(minitScript));
756  }
757  //
758  {
759  //
760  class MethodByteArrayWriteFloat: public MinitScript::Method {
761  private:
762  MinitScript* minitScript { nullptr };
763  public:
764  MethodByteArrayWriteFloat(MinitScript* minitScript):
765  MinitScript::Method(
766  {
767  { .type = MinitScript::TYPE_BYTEARRAY, .name = "bytearray", .optional = false, .reference = true, .nullable = false },
768  { .type = MinitScript::TYPE_INTEGER, .name = "value", .optional = false, .reference = false, .nullable = false }
769  },
770  MinitScript::TYPE_NULL
771  ),
772  minitScript(minitScript) {}
773  const string getMethodName() override {
774  return "ByteArray::writeFloat";
775  }
776  void executeMethod(span<MinitScript::Variable>& arguments, MinitScript::Variable& returnValue, const MinitScript::SubStatement& subStatement) override {
777  float value;
778  if (arguments.size() == 2 &&
779  arguments[0].getType() == MinitScript::TYPE_BYTEARRAY &&
780  MinitScript::getFloatValue(arguments, 1, value) == true) {
781  const auto byteArrayWritePtr = arguments[0].getByteArrayWritePointer();
782  uint32_t intValue = *((uint32_t*)&value);
783  arguments[0].setByteArrayEntry((*byteArrayWritePtr)++, intValue & 0xff);
784  arguments[0].setByteArrayEntry((*byteArrayWritePtr)++, (intValue >> 8) & 0xff);
785  arguments[0].setByteArrayEntry((*byteArrayWritePtr)++, (intValue >> 16) & 0xff);
786  arguments[0].setByteArrayEntry((*byteArrayWritePtr)++, (intValue >> 24) & 0xff);
787  } else {
788  MINITSCRIPT_METHODUSAGE_COMPLAIN(getMethodName());
789  }
790  }
791  };
792  minitScript->registerMethod(new MethodByteArrayWriteFloat(minitScript));
793  }
794  //
795  {
796  //
797  class MethodByteArrayWriteSmallString: public MinitScript::Method {
798  private:
799  MinitScript* minitScript { nullptr };
800  public:
801  MethodByteArrayWriteSmallString(MinitScript* minitScript):
802  MinitScript::Method(
803  {
804  { .type = MinitScript::TYPE_BYTEARRAY, .name = "bytearray", .optional = false, .reference = true, .nullable = false },
805  { .type = MinitScript::TYPE_STRING, .name = "value", .optional = false, .reference = false, .nullable = false }
806  },
807  MinitScript::TYPE_NULL
808  ),
809  minitScript(minitScript) {}
810  const string getMethodName() override {
811  return "ByteArray::writeSmallString";
812  }
813  void executeMethod(span<MinitScript::Variable>& arguments, MinitScript::Variable& returnValue, const MinitScript::SubStatement& subStatement) override {
814  string value;
815  if (arguments.size() == 2 &&
816  arguments[0].getType() == MinitScript::TYPE_BYTEARRAY &&
817  MinitScript::getStringValue(arguments, 1, value) == true) {
818  if (value.size() > 255) {
819  minitScript->complain(getMethodName(), subStatement, "Exceeding small string size of 255 bytes: " + to_string(value.size()) + " > 255");
820  } else {
821  const auto byteArrayWritePtr = arguments[0].getByteArrayWritePointer();
822  arguments[0].setByteArrayEntry((*byteArrayWritePtr)++, value.size());
823  for (auto i = 0; i < value.size(); i++) {
824  arguments[0].setByteArrayEntry((*byteArrayWritePtr)++, value[i]);
825  }
826  }
827  } else {
828  MINITSCRIPT_METHODUSAGE_COMPLAIN(getMethodName());
829  }
830  }
831  };
832  minitScript->registerMethod(new MethodByteArrayWriteSmallString(minitScript));
833  }
834  //
835  {
836  //
837  class MethodByteArrayWriteMediumString: public MinitScript::Method {
838  private:
839  MinitScript* minitScript { nullptr };
840  public:
841  MethodByteArrayWriteMediumString(MinitScript* minitScript):
842  MinitScript::Method(
843  {
844  { .type = MinitScript::TYPE_BYTEARRAY, .name = "bytearray", .optional = false, .reference = true, .nullable = false },
845  { .type = MinitScript::TYPE_STRING, .name = "value", .optional = false, .reference = false, .nullable = false }
846  },
847  MinitScript::TYPE_NULL
848  ),
849  minitScript(minitScript) {}
850  const string getMethodName() override {
851  return "ByteArray::writeMediumString";
852  }
853  void executeMethod(span<MinitScript::Variable>& arguments, MinitScript::Variable& returnValue, const MinitScript::SubStatement& subStatement) override {
854  string value;
855  if (arguments.size() == 2 &&
856  arguments[0].getType() == MinitScript::TYPE_BYTEARRAY &&
857  MinitScript::getStringValue(arguments, 1, value) == true) {
858  if (value.size() > 65535) {
859  minitScript->complain(getMethodName(), subStatement, "Exceeding medium string size of 65535 bytes: " + to_string(value.size()) + " > 65535");
860  } else {
861  const auto byteArrayWritePtr = arguments[0].getByteArrayWritePointer();
862  arguments[0].setByteArrayEntry((*byteArrayWritePtr)++, value.size() & 0xff);
863  arguments[0].setByteArrayEntry((*byteArrayWritePtr)++, (value.size() >> 8) & 0xff);
864  for (auto i = 0; i < value.size(); i++) {
865  arguments[0].setByteArrayEntry((*byteArrayWritePtr)++, value[i]);
866  }
867  }
868  } else {
869  MINITSCRIPT_METHODUSAGE_COMPLAIN(getMethodName());
870  }
871  }
872  };
873  minitScript->registerMethod(new MethodByteArrayWriteMediumString(minitScript));
874  }
875  //
876  {
877  //
878  class MethodByteArrayWriteLargeString: public MinitScript::Method {
879  private:
880  MinitScript* minitScript { nullptr };
881  public:
882  MethodByteArrayWriteLargeString(MinitScript* minitScript):
883  MinitScript::Method(
884  {
885  { .type = MinitScript::TYPE_BYTEARRAY, .name = "bytearray", .optional = false, .reference = true, .nullable = false },
886  { .type = MinitScript::TYPE_STRING, .name = "value", .optional = false, .reference = false, .nullable = false }
887  },
888  MinitScript::TYPE_NULL
889  ),
890  minitScript(minitScript) {}
891  const string getMethodName() override {
892  return "ByteArray::writeLargeString";
893  }
894  void executeMethod(span<MinitScript::Variable>& arguments, MinitScript::Variable& returnValue, const MinitScript::SubStatement& subStatement) override {
895  string value;
896  if (arguments.size() == 2 &&
897  arguments[0].getType() == MinitScript::TYPE_BYTEARRAY &&
898  MinitScript::getStringValue(arguments, 1, value) == true) {
899  if (value.size() > 4294967295) {
900  minitScript->complain(getMethodName(), subStatement, "Exceeding medium string size of 4294967295 bytes: " + to_string(value.size()) + " > 4294967295");
901  } else {
902  const auto byteArrayWritePtr = arguments[0].getByteArrayWritePointer();
903  arguments[0].setByteArrayEntry((*byteArrayWritePtr)++, value.size() & 0xff);
904  arguments[0].setByteArrayEntry((*byteArrayWritePtr)++, (value.size() >> 8) & 0xff);
905  arguments[0].setByteArrayEntry((*byteArrayWritePtr)++, (value.size() >> 16) & 0xff);
906  arguments[0].setByteArrayEntry((*byteArrayWritePtr)++, (value.size() >> 24) & 0xff);
907  for (auto i = 0; i < value.size(); i++) {
908  arguments[0].setByteArrayEntry((*byteArrayWritePtr)++, value[i]);
909  }
910  }
911  } else {
912  MINITSCRIPT_METHODUSAGE_COMPLAIN(getMethodName());
913  }
914  }
915  };
916  minitScript->registerMethod(new MethodByteArrayWriteLargeString(minitScript));
917  }
918  //
919  {
920  //
921  class MethodByteArrayRemove: public MinitScript::Method {
922  private:
923  MinitScript* minitScript { nullptr };
924  public:
925  MethodByteArrayRemove(MinitScript* minitScript):
926  MinitScript::Method(
927  {
928  { .type = MinitScript::TYPE_BYTEARRAY, .name = "bytearray", .optional = false, .reference = true, .nullable = false },
929  { .type = MinitScript::TYPE_INTEGER, .name = "index", .optional = false, .reference = false, .nullable = false },
930  { .type = MinitScript::TYPE_INTEGER, .name = "size", .optional = false, .reference = false, .nullable = false }
931  },
932  MinitScript::TYPE_NULL
933  ),
934  minitScript(minitScript) {}
935  const string getMethodName() override {
936  return "ByteArray::remove";
937  }
938  void executeMethod(span<MinitScript::Variable>& arguments, MinitScript::Variable& returnValue, const MinitScript::SubStatement& subStatement) override {
939  int64_t index;
940  int64_t size;
941  if ((arguments.size() == 3 && arguments[0].getType() == MinitScript::TYPE_BYTEARRAY) &&
942  MinitScript::getIntegerValue(arguments, 1, index) == true &&
943  MinitScript::getIntegerValue(arguments, 2, size) == true) {
944  arguments[0].removeByteArray(index, size);
945  } else {
946  MINITSCRIPT_METHODUSAGE_COMPLAIN(getMethodName());
947  }
948  }
949  };
950  minitScript->registerMethod(new MethodByteArrayRemove(minitScript));
951  }
952  {
953  //
954  class MethodByteArrayClear: public MinitScript::Method {
955  private:
956  MinitScript* minitScript { nullptr };
957  public:
958  MethodByteArrayClear(MinitScript* minitScript):
959  MinitScript::Method(
960  {
961  { .type = MinitScript::TYPE_BYTEARRAY, .name = "bytearray", .optional = false, .reference = true, .nullable = false }
962  },
963  MinitScript::TYPE_NULL
964  ),
965  minitScript(minitScript) {}
966  const string getMethodName() override {
967  return "ByteArray::clear";
968  }
969  void executeMethod(span<MinitScript::Variable>& arguments, MinitScript::Variable& returnValue, const MinitScript::SubStatement& subStatement) override {
970  if (arguments.size() == 1 && arguments[0].getType() == MinitScript::TYPE_BYTEARRAY) {
971  arguments[0].clearByteArray();
972  } else {
973  MINITSCRIPT_METHODUSAGE_COMPLAIN(getMethodName());
974  }
975  }
976  };
977  minitScript->registerMethod(new MethodByteArrayClear(minitScript));
978  }
979 }
MINITSCRIPT_METHODUSAGE_COMPLAIN
#define MINITSCRIPT_METHODUSAGE_COMPLAIN(methodName)
Definition: MinitScript.h:59
minitscript::minitscript::ByteArrayMethods
MinitScript script byte array methods.
Definition: ByteArrayMethods.h:12
minitscript::minitscript::MinitScript::Variable::setType
void setType(VariableType newType)
Set type.
Definition: MinitScript.h:1253
minitscript::minitscript::MinitScript::Variable::setValue
void setValue(const Variable &variable)
Set value from given variable into variable.
Definition: MinitScript.h:1618
minitscript::minitscript::MinitScript::registerMethod
void registerMethod(Method *method)
Register method.
Definition: MinitScript.cpp:272
minitscript::minitscript::MinitScript::complain
void complain(const string &methodName, const SubStatement &subStatement)
Complain about method usage.
Definition: MinitScript.cpp:214
Generated by doxygen 1.9.1