1 /* GRAPHITE2 LICENSING
2
3 Copyright 2010, SIL International
4 All rights reserved.
5
6 This library is free software; you can redistribute it and/or modify
7 it under the terms of the GNU Lesser General Public License as published
8 by the Free Software Foundation; either version 2.1 of License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
15
16 You should also have received a copy of the GNU Lesser General Public
17 License along with this library in the file named "LICENSE".
18 If not, write to the Free Software Foundation, 51 Franklin Street,
19 Suite 500, Boston, MA 02110-1335, USA or visit their web page on the
20 internet at http://www.fsf.org/licenses/lgpl.html.
21
22 Alternatively, the contents of this file may be used under the terms of the
23 Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public
24 License, as published by the Free Software Foundation, either version 2
25 of the License or (at your option) any later version.
26 */
27 // This class represents loaded graphite stack machine code. It performs
28 // basic sanity checks, on the incoming code to prevent more obvious problems
29 // from crashing graphite.
30 // Author: Tim Eves
31
32 #pragma once
33
34 #include <cassert>
35 #include <graphite2/Types.h>
36 #include "inc/Main.h"
37 #include "inc/Machine.h"
38
39 namespace graphite2 {
40
41 class Silf;
42 class Face;
43
44 enum passtype {
45 PASS_TYPE_UNKNOWN = 0,
46 PASS_TYPE_LINEBREAK,
47 PASS_TYPE_SUBSTITUTE,
48 PASS_TYPE_POSITIONING,
49 PASS_TYPE_JUSTIFICATION
50 };
51
52 namespace vm {
53
54 class Machine::Code
55 {
56 public:
57 enum status_t
58 {
59 loaded,
60 alloc_failed,
61 invalid_opcode,
62 unimplemented_opcode_used,
63 out_of_range_data,
64 jump_past_end,
65 arguments_exhausted,
66 missing_return,
67 nested_context_item,
68 underfull_stack
69 };
70
71 private:
72 class decoder;
73
74 instr * _code;
75 byte * _data;
76 size_t _data_size,
77 _instr_count;
78 byte _max_ref;
79 mutable status_t _status;
80 bool _constraint,
81 _modify,
82 _delete;
83 mutable bool _own;
84
85 void release_buffers() throw ();
86 void failure(const status_t) throw();
87
88 public:
89 static size_t estimateCodeDataOut(size_t num_bytecodes, int nRules, int nSlots);
90
91 Code() throw();
92 Code(bool is_constraint, const byte * bytecode_begin, const byte * const bytecode_end,
93 uint8 pre_context, uint16 rule_length, const Silf &, const Face &,
94 enum passtype pt, byte * * const _out = 0);
95 Code(const Machine::Code &) throw();
96 ~Code() throw();
97
98 Code & operator=(const Code &rhs) throw();
throw()99 operator bool () const throw() { return _code && status() == loaded; }
status()100 status_t status() const throw() { return _status; }
constraint()101 bool constraint() const throw() { return _constraint; }
dataSize()102 size_t dataSize() const throw() { return _data_size; }
instructionCount()103 size_t instructionCount() const throw() { return _instr_count; }
immutable()104 bool immutable() const throw() { return !(_delete || _modify); }
deletes()105 bool deletes() const throw() { return _delete; }
maxRef()106 size_t maxRef() const throw() { return _max_ref; }
107 void externalProgramMoved(ptrdiff_t) throw();
108
109 int32 run(Machine &m, slotref * & map) const;
110
111 CLASS_NEW_DELETE;
112 };
113
114 inline
estimateCodeDataOut(size_t n_bc,int nRules,int nSlots)115 size_t Machine::Code::estimateCodeDataOut(size_t n_bc, int nRules, int nSlots)
116 {
117 // max is: all codes are instructions + 1 for each rule + max tempcopies
118 // allocate space for separate maximal code and data then merge them later
119 return (n_bc + nRules + nSlots) * sizeof(instr) + n_bc * sizeof(byte);
120 }
121
122
Code()123 inline Machine::Code::Code() throw()
124 : _code(0), _data(0), _data_size(0), _instr_count(0), _max_ref(0),
125 _status(loaded), _constraint(false), _modify(false), _delete(false),
126 _own(false)
127 {
128 }
129
Code(const Machine::Code & obj)130 inline Machine::Code::Code(const Machine::Code &obj) throw ()
131 : _code(obj._code),
132 _data(obj._data),
133 _data_size(obj._data_size),
134 _instr_count(obj._instr_count),
135 _max_ref(obj._max_ref),
136 _status(obj._status),
137 _constraint(obj._constraint),
138 _modify(obj._modify),
139 _delete(obj._delete),
140 _own(obj._own)
141 {
142 obj._own = false;
143 }
144
throw()145 inline Machine::Code & Machine::Code::operator=(const Machine::Code &rhs) throw() {
146 if (_instr_count > 0)
147 release_buffers();
148 _code = rhs._code;
149 _data = rhs._data;
150 _data_size = rhs._data_size;
151 _instr_count = rhs._instr_count;
152 _status = rhs._status;
153 _constraint = rhs._constraint;
154 _modify = rhs._modify;
155 _delete = rhs._delete;
156 _own = rhs._own;
157 rhs._own = false;
158 return *this;
159 }
160
externalProgramMoved(ptrdiff_t dist)161 inline void Machine::Code::externalProgramMoved(ptrdiff_t dist) throw()
162 {
163 if (_code && !_own)
164 {
165 _code += dist / signed(sizeof(instr));
166 _data += dist;
167 }
168 }
169
170 } // namespace vm
171 } // namespace graphite2
172