1 /*
2  * Copyright 2020 Google LLC
3  *
4  * Use of this source code is governed by a BSD-style license that can be
5  * found in the LICENSE file.
6  */
7 
8 #include "src/sksl/SkSLDehydrator.h"
9 
10 #include <map>
11 
12 #include "include/private/SkSLProgramElement.h"
13 #include "include/private/SkSLStatement.h"
14 #include "include/private/SkSLSymbol.h"
15 #include "src/sksl/SkSLRehydrator.h"
16 #include "src/sksl/ir/SkSLBinaryExpression.h"
17 #include "src/sksl/ir/SkSLBreakStatement.h"
18 #include "src/sksl/ir/SkSLConstructor.h"
19 #include "src/sksl/ir/SkSLConstructorArray.h"
20 #include "src/sksl/ir/SkSLConstructorCompound.h"
21 #include "src/sksl/ir/SkSLConstructorCompoundCast.h"
22 #include "src/sksl/ir/SkSLConstructorDiagonalMatrix.h"
23 #include "src/sksl/ir/SkSLConstructorMatrixResize.h"
24 #include "src/sksl/ir/SkSLConstructorScalarCast.h"
25 #include "src/sksl/ir/SkSLConstructorSplat.h"
26 #include "src/sksl/ir/SkSLConstructorStruct.h"
27 #include "src/sksl/ir/SkSLContinueStatement.h"
28 #include "src/sksl/ir/SkSLDiscardStatement.h"
29 #include "src/sksl/ir/SkSLDoStatement.h"
30 #include "src/sksl/ir/SkSLEnum.h"
31 #include "src/sksl/ir/SkSLExpressionStatement.h"
32 #include "src/sksl/ir/SkSLField.h"
33 #include "src/sksl/ir/SkSLFieldAccess.h"
34 #include "src/sksl/ir/SkSLForStatement.h"
35 #include "src/sksl/ir/SkSLFunctionCall.h"
36 #include "src/sksl/ir/SkSLFunctionDeclaration.h"
37 #include "src/sksl/ir/SkSLFunctionDefinition.h"
38 #include "src/sksl/ir/SkSLIfStatement.h"
39 #include "src/sksl/ir/SkSLIndexExpression.h"
40 #include "src/sksl/ir/SkSLInlineMarker.h"
41 #include "src/sksl/ir/SkSLIntLiteral.h"
42 #include "src/sksl/ir/SkSLInterfaceBlock.h"
43 #include "src/sksl/ir/SkSLPostfixExpression.h"
44 #include "src/sksl/ir/SkSLPrefixExpression.h"
45 #include "src/sksl/ir/SkSLReturnStatement.h"
46 #include "src/sksl/ir/SkSLSetting.h"
47 #include "src/sksl/ir/SkSLStructDefinition.h"
48 #include "src/sksl/ir/SkSLSwitchCase.h"
49 #include "src/sksl/ir/SkSLSwitchStatement.h"
50 #include "src/sksl/ir/SkSLSwizzle.h"
51 #include "src/sksl/ir/SkSLSymbolAlias.h"
52 #include "src/sksl/ir/SkSLSymbolTable.h"
53 #include "src/sksl/ir/SkSLTernaryExpression.h"
54 #include "src/sksl/ir/SkSLUnresolvedFunction.h"
55 #include "src/sksl/ir/SkSLVarDeclarations.h"
56 #include "src/sksl/ir/SkSLVariable.h"
57 
58 #ifdef SKSL_STANDALONE
59 
60 namespace SkSL {
61 
62 static constexpr int HEADER_SIZE = 2;
63 
64 class AutoDehydratorSymbolTable {
65 public:
AutoDehydratorSymbolTable(Dehydrator * dehydrator,const std::shared_ptr<SymbolTable> & symbols)66     AutoDehydratorSymbolTable(Dehydrator* dehydrator, const std::shared_ptr<SymbolTable>& symbols)
67         : fDehydrator(dehydrator) {
68         dehydrator->fSymbolMap.emplace_back();
69         if (symbols) {
70             dehydrator->write(*symbols);
71         } else {
72             dehydrator->writeCommand(Rehydrator::kVoid_Command);
73         }
74     }
75 
~AutoDehydratorSymbolTable()76     ~AutoDehydratorSymbolTable() {
77         fDehydrator->fSymbolMap.pop_back();
78     }
79 
80 private:
81     Dehydrator* fDehydrator;
82 };
83 
write(Layout l)84 void Dehydrator::write(Layout l) {
85     if (l == Layout()) {
86         this->writeCommand(Rehydrator::kDefaultLayout_Command);
87     } else if (l == Layout::builtin(l.fBuiltin)) {
88         this->writeCommand(Rehydrator::kBuiltinLayout_Command);
89         this->writeS16(l.fBuiltin);
90     } else {
91         this->writeCommand(Rehydrator::kLayout_Command);
92         fBody.write32(l.fFlags);
93         this->writeS8(l.fLocation);
94         this->writeS8(l.fOffset);
95         this->writeS8(l.fBinding);
96         this->writeS8(l.fIndex);
97         this->writeS8(l.fSet);
98         this->writeS16(l.fBuiltin);
99         this->writeS8(l.fInputAttachmentIndex);
100         this->writeS8(l.fPrimitive);
101         this->writeS8(l.fMaxVertices);
102         this->writeS8(l.fInvocations);
103         this->write(l.fWhen);
104         this->writeS8((int) l.fCType);
105     }
106 }
107 
write(Modifiers m)108 void Dehydrator::write(Modifiers m) {
109     if (m == Modifiers()) {
110         this->writeCommand(Rehydrator::kDefaultModifiers_Command);
111     } else {
112         if (m.fFlags <= 255) {
113             this->writeCommand(Rehydrator::kModifiers8Bit_Command);
114             this->write(m.fLayout);
115             this->writeU8(m.fFlags);
116         } else {
117             this->writeCommand(Rehydrator::kModifiers_Command);
118             this->write(m.fLayout);
119             this->writeS32(m.fFlags);
120         }
121     }
122 }
123 
write(StringFragment s)124 void Dehydrator::write(StringFragment s) {
125     this->write(String(s));
126 }
127 
write(String s)128 void Dehydrator::write(String s) {
129     auto found = fStrings.find(s);
130     int offset;
131     if (found == fStrings.end()) {
132         offset = fStringBuffer.str().length() + HEADER_SIZE;
133         fStrings.insert({ s, offset });
134         SkASSERT(s.length() <= 255);
135         fStringBreaks.add(fStringBuffer.bytesWritten());
136         fStringBuffer.write8(s.length());
137         fStringBuffer.writeString(s);
138     } else {
139         offset = found->second;
140     }
141     this->writeU16(offset);
142 }
143 
write(const Symbol & s)144 void Dehydrator::write(const Symbol& s) {
145     uint16_t id = this->symbolId(&s, false);
146     if (id) {
147         this->writeCommand(Rehydrator::kSymbolRef_Command);
148         this->writeU16(id);
149         return;
150     }
151     switch (s.kind()) {
152         case Symbol::Kind::kFunctionDeclaration: {
153             const FunctionDeclaration& f = s.as<FunctionDeclaration>();
154             this->writeCommand(Rehydrator::kFunctionDeclaration_Command);
155             this->writeId(&f);
156             this->write(f.modifiers());
157             this->write(f.name());
158             this->writeU8(f.parameters().size());
159             for (const Variable* p : f.parameters()) {
160                 this->writeU16(this->symbolId(p));
161             }
162             this->write(f.returnType());
163             break;
164         }
165         case Symbol::Kind::kSymbolAlias: {
166             const SymbolAlias& alias = s.as<SymbolAlias>();
167             this->writeCommand(Rehydrator::kSymbolAlias_Command);
168             this->writeId(&alias);
169             this->write(alias.name());
170             this->write(*alias.origSymbol());
171             break;
172         }
173         case Symbol::Kind::kUnresolvedFunction: {
174             const UnresolvedFunction& f = s.as<UnresolvedFunction>();
175             this->writeCommand(Rehydrator::kUnresolvedFunction_Command);
176             this->writeId(&f);
177             this->writeU8(f.functions().size());
178             for (const FunctionDeclaration* funcDecl : f.functions()) {
179                 this->write(*funcDecl);
180             }
181             break;
182         }
183         case Symbol::Kind::kType: {
184             const Type& t = s.as<Type>();
185             switch (t.typeKind()) {
186                 case Type::TypeKind::kArray:
187                     this->writeCommand(Rehydrator::kArrayType_Command);
188                     this->writeId(&t);
189                     this->write(t.componentType());
190                     this->writeS8(t.columns());
191                     break;
192                 case Type::TypeKind::kEnum:
193                     this->writeCommand(Rehydrator::kEnumType_Command);
194                     this->writeId(&t);
195                     this->write(t.name());
196                     break;
197                 case Type::TypeKind::kStruct:
198                     this->writeCommand(Rehydrator::kStructType_Command);
199                     this->writeId(&t);
200                     this->write(t.name());
201                     this->writeU8(t.fields().size());
202                     for (const Type::Field& f : t.fields()) {
203                         this->write(f.fModifiers);
204                         this->write(f.fName);
205                         this->write(*f.fType);
206                     }
207                     break;
208                 default:
209                     this->writeCommand(Rehydrator::kSystemType_Command);
210                     this->writeId(&t);
211                     this->write(t.name());
212             }
213             break;
214         }
215         case Symbol::Kind::kVariable: {
216             const Variable& v = s.as<Variable>();
217             this->writeCommand(Rehydrator::kVariable_Command);
218             this->writeId(&v);
219             this->write(v.modifiers());
220             this->write(v.name());
221             this->write(v.type());
222             this->writeU8((int8_t) v.storage());
223             break;
224         }
225         case Symbol::Kind::kField: {
226             const Field& f = s.as<Field>();
227             this->writeCommand(Rehydrator::kField_Command);
228             this->writeU16(this->symbolId(&f.owner()));
229             this->writeU8(f.fieldIndex());
230             break;
231         }
232         case Symbol::Kind::kExternal:
233             SkASSERT(false);
234             break;
235     }
236 }
237 
write(const SymbolTable & symbols)238 void Dehydrator::write(const SymbolTable& symbols) {
239     this->writeCommand(Rehydrator::kSymbolTable_Command);
240     this->writeU16(symbols.fOwnedSymbols.size());
241     for (const std::unique_ptr<const Symbol>& s : symbols.fOwnedSymbols) {
242         this->write(*s);
243     }
244     this->writeU16(symbols.fSymbols.count());
245     std::map<StringFragment, const Symbol*> ordered;
246     symbols.foreach([&](StringFragment name, const Symbol* symbol) {
247         ordered.insert({name, symbol});
248     });
249     for (std::pair<StringFragment, const Symbol*> p : ordered) {
250         bool found = false;
251         for (size_t i = 0; i < symbols.fOwnedSymbols.size(); ++i) {
252             if (symbols.fOwnedSymbols[i].get() == p.second) {
253                 fCommandBreaks.add(fBody.bytesWritten());
254                 this->writeU16(i);
255                 found = true;
256                 break;
257             }
258         }
259         SkASSERT(found);
260     }
261 }
262 
writeExpressionSpan(const SkSpan<const std::unique_ptr<Expression>> & span)263 void Dehydrator::writeExpressionSpan(const SkSpan<const std::unique_ptr<Expression>>& span) {
264     this->writeU8(span.size());
265     for (const auto& expr : span) {
266         this->write(expr.get());
267     }
268 }
269 
write(const Expression * e)270 void Dehydrator::write(const Expression* e) {
271     if (e) {
272         switch (e->kind()) {
273             case Expression::Kind::kBinary: {
274                 const BinaryExpression& b = e->as<BinaryExpression>();
275                 this->writeCommand(Rehydrator::kBinary_Command);
276                 this->write(b.left().get());
277                 this->writeU8((int) b.getOperator().kind());
278                 this->write(b.right().get());
279                 break;
280             }
281             case Expression::Kind::kBoolLiteral: {
282                 const BoolLiteral& b = e->as<BoolLiteral>();
283                 this->writeCommand(Rehydrator::kBoolLiteral_Command);
284                 this->writeU8(b.value());
285                 break;
286             }
287             case Expression::Kind::kCodeString:
288                 SkDEBUGFAIL("shouldn't be able to receive kCodeString here");
289                 break;
290 
291             case Expression::Kind::kConstructorArray:
292                 this->writeCommand(Rehydrator::kConstructorArray_Command);
293                 this->write(e->type());
294                 this->writeExpressionSpan(e->as<ConstructorArray>().argumentSpan());
295                 break;
296 
297             case Expression::Kind::kConstructorCompound:
298                 this->writeCommand(Rehydrator::kConstructorCompound_Command);
299                 this->write(e->type());
300                 this->writeExpressionSpan(e->as<ConstructorCompound>().argumentSpan());
301                 break;
302 
303             case Expression::Kind::kConstructorCompoundCast:
304                 this->writeCommand(Rehydrator::kConstructorCompoundCast_Command);
305                 this->write(e->type());
306                 this->writeExpressionSpan(e->as<ConstructorCompoundCast>().argumentSpan());
307                 break;
308 
309             case Expression::Kind::kConstructorDiagonalMatrix:
310                 this->writeCommand(Rehydrator::kConstructorDiagonalMatrix_Command);
311                 this->write(e->type());
312                 this->writeExpressionSpan(e->as<ConstructorDiagonalMatrix>().argumentSpan());
313                 break;
314 
315             case Expression::Kind::kConstructorMatrixResize:
316                 this->writeCommand(Rehydrator::kConstructorMatrixResize_Command);
317                 this->write(e->type());
318                 this->writeExpressionSpan(e->as<ConstructorMatrixResize>().argumentSpan());
319                 break;
320 
321             case Expression::Kind::kConstructorScalarCast:
322                 this->writeCommand(Rehydrator::kConstructorScalarCast_Command);
323                 this->write(e->type());
324                 this->writeExpressionSpan(e->as<ConstructorScalarCast>().argumentSpan());
325                 break;
326 
327             case Expression::Kind::kConstructorSplat:
328                 this->writeCommand(Rehydrator::kConstructorSplat_Command);
329                 this->write(e->type());
330                 this->writeExpressionSpan(e->as<ConstructorSplat>().argumentSpan());
331                 break;
332 
333             case Expression::Kind::kConstructorStruct:
334                 this->writeCommand(Rehydrator::kConstructorStruct_Command);
335                 this->write(e->type());
336                 this->writeExpressionSpan(e->as<ConstructorStruct>().argumentSpan());
337                 break;
338 
339             case Expression::Kind::kExternalFunctionCall:
340             case Expression::Kind::kExternalFunctionReference:
341                 SkDEBUGFAIL("unimplemented--not expected to be used from within an include file");
342                 break;
343 
344             case Expression::Kind::kFieldAccess: {
345                 const FieldAccess& f = e->as<FieldAccess>();
346                 this->writeCommand(Rehydrator::kFieldAccess_Command);
347                 this->write(f.base().get());
348                 this->writeU8(f.fieldIndex());
349                 this->writeU8((int8_t) f.ownerKind());
350                 break;
351             }
352             case Expression::Kind::kFloatLiteral: {
353                 const FloatLiteral& f = e->as<FloatLiteral>();
354                 this->writeCommand(Rehydrator::kFloatLiteral_Command);
355                 this->write(f.type());
356                 FloatIntUnion u;
357                 u.fFloat = f.value();
358                 this->writeS32(u.fInt);
359                 break;
360             }
361             case Expression::Kind::kFunctionCall: {
362                 const FunctionCall& f = e->as<FunctionCall>();
363                 this->writeCommand(Rehydrator::kFunctionCall_Command);
364                 this->write(f.type());
365                 this->writeId(&f.function());
366                 this->writeU8(f.arguments().size());
367                 for (const auto& a : f.arguments()) {
368                     this->write(a.get());
369                 }
370                 break;
371             }
372             case Expression::Kind::kIndex: {
373                 const IndexExpression& i = e->as<IndexExpression>();
374                 this->writeCommand(Rehydrator::kIndex_Command);
375                 this->write(i.base().get());
376                 this->write(i.index().get());
377                 break;
378             }
379             case Expression::Kind::kIntLiteral: {
380                 const IntLiteral& i = e->as<IntLiteral>();
381                 this->writeCommand(Rehydrator::kIntLiteral_Command);
382                 this->write(i.type());
383                 this->writeS32(i.value());
384                 break;
385             }
386             case Expression::Kind::kPostfix: {
387                 const PostfixExpression& p = e->as<PostfixExpression>();
388                 this->writeCommand(Rehydrator::kPostfix_Command);
389                 this->writeU8((int) p.getOperator().kind());
390                 this->write(p.operand().get());
391                 break;
392             }
393             case Expression::Kind::kPrefix: {
394                 const PrefixExpression& p = e->as<PrefixExpression>();
395                 this->writeCommand(Rehydrator::kPrefix_Command);
396                 this->writeU8((int) p.getOperator().kind());
397                 this->write(p.operand().get());
398                 break;
399             }
400             case Expression::Kind::kSetting: {
401                 const Setting& s = e->as<Setting>();
402                 this->writeCommand(Rehydrator::kSetting_Command);
403                 this->write(s.name());
404                 break;
405             }
406             case Expression::Kind::kSwizzle: {
407                 const Swizzle& s = e->as<Swizzle>();
408                 this->writeCommand(Rehydrator::kSwizzle_Command);
409                 this->write(s.base().get());
410                 this->writeU8(s.components().size());
411                 for (int c : s.components()) {
412                     this->writeU8(c);
413                 }
414                 break;
415             }
416             case Expression::Kind::kTernary: {
417                 const TernaryExpression& t = e->as<TernaryExpression>();
418                 this->writeCommand(Rehydrator::kTernary_Command);
419                 this->write(t.test().get());
420                 this->write(t.ifTrue().get());
421                 this->write(t.ifFalse().get());
422                 break;
423             }
424             case Expression::Kind::kVariableReference: {
425                 const VariableReference& v = e->as<VariableReference>();
426                 this->writeCommand(Rehydrator::kVariableReference_Command);
427                 this->writeId(v.variable());
428                 this->writeU8((int8_t) v.refKind());
429                 break;
430             }
431             case Expression::Kind::kFunctionReference:
432             case Expression::Kind::kTypeReference:
433                 SkDEBUGFAIL("this expression shouldn't appear in finished code");
434                 break;
435         }
436     } else {
437         this->writeCommand(Rehydrator::kVoid_Command);
438     }
439 }
440 
write(const Statement * s)441 void Dehydrator::write(const Statement* s) {
442     if (s) {
443         switch (s->kind()) {
444             case Statement::Kind::kBlock: {
445                 const Block& b = s->as<Block>();
446                 this->writeCommand(Rehydrator::kBlock_Command);
447                 AutoDehydratorSymbolTable symbols(this, b.symbolTable());
448                 this->writeU8(b.children().size());
449                 for (const std::unique_ptr<Statement>& blockStmt : b.children()) {
450                     this->write(blockStmt.get());
451                 }
452                 this->writeU8(b.isScope());
453                 break;
454             }
455             case Statement::Kind::kBreak:
456                 this->writeCommand(Rehydrator::kBreak_Command);
457                 break;
458             case Statement::Kind::kContinue:
459                 this->writeCommand(Rehydrator::kContinue_Command);
460                 break;
461             case Statement::Kind::kDiscard:
462                 this->writeCommand(Rehydrator::kDiscard_Command);
463                 break;
464             case Statement::Kind::kDo: {
465                 const DoStatement& d = s->as<DoStatement>();
466                 this->writeCommand(Rehydrator::kDo_Command);
467                 this->write(d.statement().get());
468                 this->write(d.test().get());
469                 break;
470             }
471             case Statement::Kind::kExpression: {
472                 const ExpressionStatement& e = s->as<ExpressionStatement>();
473                 this->writeCommand(Rehydrator::kExpressionStatement_Command);
474                 this->write(e.expression().get());
475                 break;
476             }
477             case Statement::Kind::kFor: {
478                 const ForStatement& f = s->as<ForStatement>();
479                 this->writeCommand(Rehydrator::kFor_Command);
480                 this->write(f.initializer().get());
481                 this->write(f.test().get());
482                 this->write(f.next().get());
483                 this->write(f.statement().get());
484                 this->write(*f.symbols());
485                 break;
486             }
487             case Statement::Kind::kIf: {
488                 const IfStatement& i = s->as<IfStatement>();
489                 this->writeCommand(Rehydrator::kIf_Command);
490                 this->writeU8(i.isStatic());
491                 this->write(i.test().get());
492                 this->write(i.ifTrue().get());
493                 this->write(i.ifFalse().get());
494                 break;
495             }
496             case Statement::Kind::kInlineMarker: {
497                 const InlineMarker& i = s->as<InlineMarker>();
498                 this->writeCommand(Rehydrator::kInlineMarker_Command);
499                 this->writeId(&i.function());
500                 break;
501             }
502             case Statement::Kind::kNop:
503                 SkDEBUGFAIL("unexpected--nop statement in finished code");
504                 break;
505             case Statement::Kind::kReturn: {
506                 const ReturnStatement& r = s->as<ReturnStatement>();
507                 this->writeCommand(Rehydrator::kReturn_Command);
508                 this->write(r.expression().get());
509                 break;
510             }
511             case Statement::Kind::kSwitch: {
512                 const SwitchStatement& ss = s->as<SwitchStatement>();
513                 this->writeCommand(Rehydrator::kSwitch_Command);
514                 this->writeU8(ss.isStatic());
515                 AutoDehydratorSymbolTable symbols(this, ss.symbols());
516                 this->write(ss.value().get());
517                 this->writeU8(ss.cases().size());
518                 for (const std::unique_ptr<Statement>& stmt : ss.cases()) {
519                     const SwitchCase& sc = stmt->as<SwitchCase>();
520                     this->write(sc.value().get());
521                     this->write(sc.statement().get());
522                 }
523                 break;
524             }
525             case Statement::Kind::kSwitchCase:
526                 SkDEBUGFAIL("SwitchCase statements shouldn't appear here");
527                 break;
528             case Statement::Kind::kVarDeclaration: {
529                 const VarDeclaration& v = s->as<VarDeclaration>();
530                 this->writeCommand(Rehydrator::kVarDeclaration_Command);
531                 this->writeU16(this->symbolId(&v.var()));
532                 this->write(v.baseType());
533                 this->writeS8(v.arraySize());
534                 this->write(v.value().get());
535                 break;
536             }
537         }
538     } else {
539         this->writeCommand(Rehydrator::kVoid_Command);
540     }
541 }
542 
write(const ProgramElement & e)543 void Dehydrator::write(const ProgramElement& e) {
544     switch (e.kind()) {
545         case ProgramElement::Kind::kEnum: {
546             const Enum& en = e.as<Enum>();
547             this->writeCommand(Rehydrator::kEnum_Command);
548             this->write(en.typeName());
549             AutoDehydratorSymbolTable symbols(this, en.symbols());
550             for (const std::unique_ptr<const Symbol>& s : en.symbols()->fOwnedSymbols) {
551                 const Variable& v = s->as<Variable>();
552                 SkASSERT(v.initialValue());
553                 const IntLiteral& i = v.initialValue()->as<IntLiteral>();
554                 this->writeS32(i.value());
555             }
556             break;
557         }
558         case ProgramElement::Kind::kExtension:
559             SkASSERT(false);
560             break;
561         case ProgramElement::Kind::kFunction: {
562             const FunctionDefinition& f = e.as<FunctionDefinition>();
563             this->writeCommand(Rehydrator::kFunctionDefinition_Command);
564             this->writeU16(this->symbolId(&f.declaration()));
565             this->write(f.body().get());
566             this->writeU8(f.referencedIntrinsics().size());
567             std::set<uint16_t> ordered;
568             for (const FunctionDeclaration* ref : f.referencedIntrinsics()) {
569                 ordered.insert(this->symbolId(ref));
570             }
571             for (uint16_t ref : ordered) {
572                 this->writeU16(ref);
573             }
574             break;
575         }
576         case ProgramElement::Kind::kFunctionPrototype: {
577             // We don't need to emit function prototypes into the dehydrated data, because we don't
578             // ever need to re-emit the intrinsics files as raw GLSL/Metal. As long as the symbols
579             // exist in the symbol table, we're in good shape.
580             break;
581         }
582         case ProgramElement::Kind::kInterfaceBlock: {
583             const InterfaceBlock& i = e.as<InterfaceBlock>();
584             this->writeCommand(Rehydrator::kInterfaceBlock_Command);
585             this->write(i.variable());
586             this->write(i.typeName());
587             this->write(i.instanceName());
588             this->writeS8(i.arraySize());
589             break;
590         }
591         case ProgramElement::Kind::kModifiers:
592             SkASSERT(false);
593             break;
594         case ProgramElement::Kind::kSection:
595             SkASSERT(false);
596             break;
597         case ProgramElement::Kind::kStructDefinition: {
598             const StructDefinition& structDef = e.as<StructDefinition>();
599             this->writeCommand(Rehydrator::kStructDefinition_Command);
600             this->write(structDef.type());
601             break;
602         }
603         case ProgramElement::Kind::kGlobalVar: {
604             const GlobalVarDeclaration& v = e.as<GlobalVarDeclaration>();
605             this->writeCommand(Rehydrator::kVarDeclarations_Command);
606             this->write(v.declaration().get());
607             break;
608         }
609     }
610 }
611 
write(const std::vector<std::unique_ptr<ProgramElement>> & elements)612 void Dehydrator::write(const std::vector<std::unique_ptr<ProgramElement>>& elements) {
613     this->writeCommand(Rehydrator::kElements_Command);
614     for (const auto& e : elements) {
615         this->write(*e);
616     }
617     this->writeCommand(Rehydrator::kElementsComplete_Command);
618 }
619 
finish(OutputStream & out)620 void Dehydrator::finish(OutputStream& out) {
621     String stringBuffer = fStringBuffer.str();
622     String commandBuffer = fBody.str();
623 
624     out.write16(fStringBuffer.str().size());
625     fStringBufferStart = 2;
626     out.writeString(stringBuffer);
627     fCommandStart = fStringBufferStart + stringBuffer.size();
628     out.writeString(commandBuffer);
629 }
630 
prefixAtOffset(size_t byte)631 const char* Dehydrator::prefixAtOffset(size_t byte) {
632     if (byte >= fCommandStart) {
633         return fCommandBreaks.contains(byte - fCommandStart) ? "\n" : "";
634     }
635     if (byte >= fStringBufferStart) {
636         return fStringBreaks.contains(byte - fStringBufferStart) ? "\n" : "";
637     }
638     return "";
639 }
640 
641 } // namespace
642 
643 #endif
644