1 /*
2 * Copyright © 2018 Adobe Inc.
3 *
4 * This is part of HarfBuzz, a text shaping library.
5 *
6 * Permission is hereby granted, without written agreement and without
7 * license or royalty fees, to use, copy, modify, and distribute this
8 * software and its documentation for any purpose, provided that the
9 * above copyright notice and the following two paragraphs appear in
10 * all copies of this software.
11 *
12 * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
13 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
14 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
15 * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
16 * DAMAGE.
17 *
18 * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
19 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
20 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
21 * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
22 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
23 *
24 * Adobe Author(s): Michiharu Ariza
25 */
26 #ifndef HB_CFF_INTERP_CS_COMMON_HH
27 #define HB_CFF_INTERP_CS_COMMON_HH
28
29 #include "hb.hh"
30 #include "hb-cff-interp-common.hh"
31
32 namespace CFF {
33
34 using namespace OT;
35
36 enum cs_type_t {
37 CSType_CharString,
38 CSType_GlobalSubr,
39 CSType_LocalSubr
40 };
41
42 struct call_context_t
43 {
44 void init (const byte_str_ref_t substr_=byte_str_ref_t (), cs_type_t type_=CSType_CharString, unsigned int subr_num_=0)
45 {
46 str_ref = substr_;
47 type = type_;
48 subr_num = subr_num_;
49 }
50
51 void fini () {}
52
53 byte_str_ref_t str_ref;
54 cs_type_t type;
55 unsigned int subr_num;
56 };
57
58 /* call stack */
59 const unsigned int kMaxCallLimit = 10;
60 struct call_stack_t : stack_t<call_context_t, kMaxCallLimit> {};
61
62 template <typename SUBRS>
63 struct biased_subrs_t
64 {
65 void init (const SUBRS &subrs_)
66 {
67 subrs = &subrs_;
68 unsigned int nSubrs = get_count ();
69 if (nSubrs < 1240)
70 bias = 107;
71 else if (nSubrs < 33900)
72 bias = 1131;
73 else
74 bias = 32768;
75 }
76
77 void fini () {}
78
79 unsigned int get_count () const { return (subrs == nullptr)? 0: subrs->count; }
80 unsigned int get_bias () const { return bias; }
81
82 byte_str_t operator [] (unsigned int index) const
83 {
84 if (unlikely ((subrs == nullptr) || index >= subrs->count))
85 return Null(byte_str_t);
86 else
87 return (*subrs)[index];
88 }
89
90 protected:
91 unsigned int bias;
92 const SUBRS *subrs;
93 };
94
95 struct point_t
96 {
97 void init ()
98 {
99 x.init ();
100 y.init ();
101 }
102
103 void set_int (int _x, int _y)
104 {
105 x.set_int (_x);
106 y.set_int (_y);
107 }
108
109 void move_x (const number_t &dx) { x += dx; }
110 void move_y (const number_t &dy) { y += dy; }
111 void move (const number_t &dx, const number_t &dy) { move_x (dx); move_y (dy); }
112 void move (const point_t &d) { move_x (d.x); move_y (d.y); }
113
114 number_t x;
115 number_t y;
116 };
117
118 template <typename ARG, typename SUBRS>
119 struct cs_interp_env_t : interp_env_t<ARG>
120 {
121 void init (const byte_str_t &str, const SUBRS &globalSubrs_, const SUBRS &localSubrs_)
122 {
123 interp_env_t<ARG>::init (str);
124
125 context.init (str, CSType_CharString);
126 seen_moveto = true;
127 seen_hintmask = false;
128 hstem_count = 0;
129 vstem_count = 0;
130 hintmask_size = 0;
131 pt.init ();
132 callStack.init ();
133 globalSubrs.init (globalSubrs_);
134 localSubrs.init (localSubrs_);
135 }
136 void fini ()
137 {
138 interp_env_t<ARG>::fini ();
139
140 callStack.fini ();
141 globalSubrs.fini ();
142 localSubrs.fini ();
143 }
144
145 bool in_error () const
146 {
147 return callStack.in_error () || SUPER::in_error ();
148 }
149
150 bool popSubrNum (const biased_subrs_t<SUBRS>& biasedSubrs, unsigned int &subr_num)
151 {
152 int n = SUPER::argStack.pop_int ();
153 n += biasedSubrs.get_bias ();
154 if (unlikely ((n < 0) || ((unsigned int)n >= biasedSubrs.get_count ())))
155 return false;
156
157 subr_num = (unsigned int)n;
158 return true;
159 }
160
161 void callSubr (const biased_subrs_t<SUBRS>& biasedSubrs, cs_type_t type)
162 {
163 unsigned int subr_num;
164
165 if (unlikely (!popSubrNum (biasedSubrs, subr_num)
166 || callStack.get_count () >= kMaxCallLimit))
167 {
168 SUPER::set_error ();
169 return;
170 }
171 context.str_ref = SUPER::str_ref;
172 callStack.push (context);
173
174 context.init ( biasedSubrs[subr_num], type, subr_num);
175 SUPER::str_ref = context.str_ref;
176 }
177
178 void returnFromSubr ()
179 {
180 if (unlikely (SUPER::str_ref.in_error ()))
181 SUPER::set_error ();
182 context = callStack.pop ();
183 SUPER::str_ref = context.str_ref;
184 }
185
186 void determine_hintmask_size ()
187 {
188 if (!seen_hintmask)
189 {
190 vstem_count += SUPER::argStack.get_count() / 2;
191 hintmask_size = (hstem_count + vstem_count + 7) >> 3;
192 seen_hintmask = true;
193 }
194 }
195
196 void set_endchar (bool endchar_flag_) { endchar_flag = endchar_flag_; }
197 bool is_endchar () const { return endchar_flag; }
198
199 const number_t &get_x () const { return pt.x; }
200 const number_t &get_y () const { return pt.y; }
201 const point_t &get_pt () const { return pt; }
202
203 void moveto (const point_t &pt_ ) { pt = pt_; }
204
205 public:
206 call_context_t context;
207 bool endchar_flag;
208 bool seen_moveto;
209 bool seen_hintmask;
210
211 unsigned int hstem_count;
212 unsigned int vstem_count;
213 unsigned int hintmask_size;
214 call_stack_t callStack;
215 biased_subrs_t<SUBRS> globalSubrs;
216 biased_subrs_t<SUBRS> localSubrs;
217
218 private:
219 point_t pt;
220
221 typedef interp_env_t<ARG> SUPER;
222 };
223
224 template <typename ENV, typename PARAM>
225 struct path_procs_null_t
226 {
227 static void rmoveto (ENV &env, PARAM& param) {}
228 static void hmoveto (ENV &env, PARAM& param) {}
229 static void vmoveto (ENV &env, PARAM& param) {}
230 static void rlineto (ENV &env, PARAM& param) {}
231 static void hlineto (ENV &env, PARAM& param) {}
232 static void vlineto (ENV &env, PARAM& param) {}
233 static void rrcurveto (ENV &env, PARAM& param) {}
234 static void rcurveline (ENV &env, PARAM& param) {}
235 static void rlinecurve (ENV &env, PARAM& param) {}
236 static void vvcurveto (ENV &env, PARAM& param) {}
237 static void hhcurveto (ENV &env, PARAM& param) {}
238 static void vhcurveto (ENV &env, PARAM& param) {}
239 static void hvcurveto (ENV &env, PARAM& param) {}
240 static void moveto (ENV &env, PARAM& param, const point_t &pt) {}
241 static void line (ENV &env, PARAM& param, const point_t &pt1) {}
242 static void curve (ENV &env, PARAM& param, const point_t &pt1, const point_t &pt2, const point_t &pt3) {}
243 static void hflex (ENV &env, PARAM& param) {}
244 static void flex (ENV &env, PARAM& param) {}
245 static void hflex1 (ENV &env, PARAM& param) {}
246 static void flex1 (ENV &env, PARAM& param) {}
247 };
248
249 template <typename ARG, typename OPSET, typename ENV, typename PARAM, typename PATH=path_procs_null_t<ENV, PARAM> >
250 struct cs_opset_t : opset_t<ARG>
251 {
252 static void process_op (op_code_t op, ENV &env, PARAM& param)
253 {
254 switch (op) {
255
256 case OpCode_return:
257 env.returnFromSubr ();
258 break;
259 case OpCode_endchar:
260 OPSET::check_width (op, env, param);
261 env.set_endchar (true);
262 OPSET::flush_args_and_op (op, env, param);
263 break;
264
265 case OpCode_fixedcs:
266 env.argStack.push_fixed_from_substr (env.str_ref);
267 break;
268
269 case OpCode_callsubr:
270 env.callSubr (env.localSubrs, CSType_LocalSubr);
271 break;
272
273 case OpCode_callgsubr:
274 env.callSubr (env.globalSubrs, CSType_GlobalSubr);
275 break;
276
277 case OpCode_hstem:
278 case OpCode_hstemhm:
279 OPSET::check_width (op, env, param);
280 OPSET::process_hstem (op, env, param);
281 break;
282 case OpCode_vstem:
283 case OpCode_vstemhm:
284 OPSET::check_width (op, env, param);
285 OPSET::process_vstem (op, env, param);
286 break;
287 case OpCode_hintmask:
288 case OpCode_cntrmask:
289 OPSET::check_width (op, env, param);
290 OPSET::process_hintmask (op, env, param);
291 break;
292 case OpCode_rmoveto:
293 OPSET::check_width (op, env, param);
294 PATH::rmoveto (env, param);
295 OPSET::process_post_move (op, env, param);
296 break;
297 case OpCode_hmoveto:
298 OPSET::check_width (op, env, param);
299 PATH::hmoveto (env, param);
300 OPSET::process_post_move (op, env, param);
301 break;
302 case OpCode_vmoveto:
303 OPSET::check_width (op, env, param);
304 PATH::vmoveto (env, param);
305 OPSET::process_post_move (op, env, param);
306 break;
307 case OpCode_rlineto:
308 PATH::rlineto (env, param);
309 process_post_path (op, env, param);
310 break;
311 case OpCode_hlineto:
312 PATH::hlineto (env, param);
313 process_post_path (op, env, param);
314 break;
315 case OpCode_vlineto:
316 PATH::vlineto (env, param);
317 process_post_path (op, env, param);
318 break;
319 case OpCode_rrcurveto:
320 PATH::rrcurveto (env, param);
321 process_post_path (op, env, param);
322 break;
323 case OpCode_rcurveline:
324 PATH::rcurveline (env, param);
325 process_post_path (op, env, param);
326 break;
327 case OpCode_rlinecurve:
328 PATH::rlinecurve (env, param);
329 process_post_path (op, env, param);
330 break;
331 case OpCode_vvcurveto:
332 PATH::vvcurveto (env, param);
333 process_post_path (op, env, param);
334 break;
335 case OpCode_hhcurveto:
336 PATH::hhcurveto (env, param);
337 process_post_path (op, env, param);
338 break;
339 case OpCode_vhcurveto:
340 PATH::vhcurveto (env, param);
341 process_post_path (op, env, param);
342 break;
343 case OpCode_hvcurveto:
344 PATH::hvcurveto (env, param);
345 process_post_path (op, env, param);
346 break;
347
348 case OpCode_hflex:
349 PATH::hflex (env, param);
350 OPSET::process_post_flex (op, env, param);
351 break;
352
353 case OpCode_flex:
354 PATH::flex (env, param);
355 OPSET::process_post_flex (op, env, param);
356 break;
357
358 case OpCode_hflex1:
359 PATH::hflex1 (env, param);
360 OPSET::process_post_flex (op, env, param);
361 break;
362
363 case OpCode_flex1:
364 PATH::flex1 (env, param);
365 OPSET::process_post_flex (op, env, param);
366 break;
367
368 default:
369 SUPER::process_op (op, env);
370 break;
371 }
372 }
373
374 static void process_hstem (op_code_t op, ENV &env, PARAM& param)
375 {
376 env.hstem_count += env.argStack.get_count () / 2;
377 OPSET::flush_args_and_op (op, env, param);
378 }
379
380 static void process_vstem (op_code_t op, ENV &env, PARAM& param)
381 {
382 env.vstem_count += env.argStack.get_count () / 2;
383 OPSET::flush_args_and_op (op, env, param);
384 }
385
386 static void process_hintmask (op_code_t op, ENV &env, PARAM& param)
387 {
388 env.determine_hintmask_size ();
389 if (likely (env.str_ref.avail (env.hintmask_size)))
390 {
391 OPSET::flush_hintmask (op, env, param);
392 env.str_ref.inc (env.hintmask_size);
393 }
394 }
395
396 static void process_post_flex (op_code_t op, ENV &env, PARAM& param)
397 {
398 OPSET::flush_args_and_op (op, env, param);
399 }
400
401 static void check_width (op_code_t op, ENV &env, PARAM& param)
402 {}
403
404 static void process_post_move (op_code_t op, ENV &env, PARAM& param)
405 {
406 if (!env.seen_moveto)
407 {
408 env.determine_hintmask_size ();
409 env.seen_moveto = true;
410 }
411 OPSET::flush_args_and_op (op, env, param);
412 }
413
414 static void process_post_path (op_code_t op, ENV &env, PARAM& param)
415 {
416 OPSET::flush_args_and_op (op, env, param);
417 }
418
419 static void flush_args_and_op (op_code_t op, ENV &env, PARAM& param)
420 {
421 OPSET::flush_args (env, param);
422 OPSET::flush_op (op, env, param);
423 }
424
425 static void flush_args (ENV &env, PARAM& param)
426 {
427 env.pop_n_args (env.argStack.get_count ());
428 }
429
430 static void flush_op (op_code_t op, ENV &env, PARAM& param)
431 {
432 }
433
434 static void flush_hintmask (op_code_t op, ENV &env, PARAM& param)
435 {
436 OPSET::flush_args_and_op (op, env, param);
437 }
438
439 static bool is_number_op (op_code_t op)
440 {
441 switch (op)
442 {
443 case OpCode_shortint:
444 case OpCode_fixedcs:
445 case OpCode_TwoBytePosInt0: case OpCode_TwoBytePosInt1:
446 case OpCode_TwoBytePosInt2: case OpCode_TwoBytePosInt3:
447 case OpCode_TwoByteNegInt0: case OpCode_TwoByteNegInt1:
448 case OpCode_TwoByteNegInt2: case OpCode_TwoByteNegInt3:
449 return true;
450
451 default:
452 /* 1-byte integer */
453 return (OpCode_OneByteIntFirst <= op) && (op <= OpCode_OneByteIntLast);
454 }
455 }
456
457 protected:
458 typedef opset_t<ARG> SUPER;
459 };
460
461 template <typename PATH, typename ENV, typename PARAM>
462 struct path_procs_t
463 {
464 static void rmoveto (ENV &env, PARAM& param)
465 {
466 point_t pt1 = env.get_pt ();
467 const number_t &dy = env.pop_arg ();
468 const number_t &dx = env.pop_arg ();
469 pt1.move (dx, dy);
470 PATH::moveto (env, param, pt1);
471 }
472
473 static void hmoveto (ENV &env, PARAM& param)
474 {
475 point_t pt1 = env.get_pt ();
476 pt1.move_x (env.pop_arg ());
477 PATH::moveto (env, param, pt1);
478 }
479
480 static void vmoveto (ENV &env, PARAM& param)
481 {
482 point_t pt1 = env.get_pt ();
483 pt1.move_y (env.pop_arg ());
484 PATH::moveto (env, param, pt1);
485 }
486
487 static void rlineto (ENV &env, PARAM& param)
488 {
489 for (unsigned int i = 0; i + 2 <= env.argStack.get_count (); i += 2)
490 {
491 point_t pt1 = env.get_pt ();
492 pt1.move (env.eval_arg (i), env.eval_arg (i+1));
493 PATH::line (env, param, pt1);
494 }
495 }
496
497 static void hlineto (ENV &env, PARAM& param)
498 {
499 point_t pt1;
500 unsigned int i = 0;
501 for (; i + 2 <= env.argStack.get_count (); i += 2)
502 {
503 pt1 = env.get_pt ();
504 pt1.move_x (env.eval_arg (i));
505 PATH::line (env, param, pt1);
506 pt1.move_y (env.eval_arg (i+1));
507 PATH::line (env, param, pt1);
508 }
509 if (i < env.argStack.get_count ())
510 {
511 pt1 = env.get_pt ();
512 pt1.move_x (env.eval_arg (i));
513 PATH::line (env, param, pt1);
514 }
515 }
516
517 static void vlineto (ENV &env, PARAM& param)
518 {
519 point_t pt1;
520 unsigned int i = 0;
521 for (; i + 2 <= env.argStack.get_count (); i += 2)
522 {
523 pt1 = env.get_pt ();
524 pt1.move_y (env.eval_arg (i));
525 PATH::line (env, param, pt1);
526 pt1.move_x (env.eval_arg (i+1));
527 PATH::line (env, param, pt1);
528 }
529 if (i < env.argStack.get_count ())
530 {
531 pt1 = env.get_pt ();
532 pt1.move_y (env.eval_arg (i));
533 PATH::line (env, param, pt1);
534 }
535 }
536
537 static void rrcurveto (ENV &env, PARAM& param)
538 {
539 for (unsigned int i = 0; i + 6 <= env.argStack.get_count (); i += 6)
540 {
541 point_t pt1 = env.get_pt ();
542 pt1.move (env.eval_arg (i), env.eval_arg (i+1));
543 point_t pt2 = pt1;
544 pt2.move (env.eval_arg (i+2), env.eval_arg (i+3));
545 point_t pt3 = pt2;
546 pt3.move (env.eval_arg (i+4), env.eval_arg (i+5));
547 PATH::curve (env, param, pt1, pt2, pt3);
548 }
549 }
550
551 static void rcurveline (ENV &env, PARAM& param)
552 {
553 unsigned int i = 0;
554 for (; i + 6 <= env.argStack.get_count (); i += 6)
555 {
556 point_t pt1 = env.get_pt ();
557 pt1.move (env.eval_arg (i), env.eval_arg (i+1));
558 point_t pt2 = pt1;
559 pt2.move (env.eval_arg (i+2), env.eval_arg (i+3));
560 point_t pt3 = pt2;
561 pt3.move (env.eval_arg (i+4), env.eval_arg (i+5));
562 PATH::curve (env, param, pt1, pt2, pt3);
563 }
564 for (; i + 2 <= env.argStack.get_count (); i += 2)
565 {
566 point_t pt1 = env.get_pt ();
567 pt1.move (env.eval_arg (i), env.eval_arg (i+1));
568 PATH::line (env, param, pt1);
569 }
570 }
571
572 static void rlinecurve (ENV &env, PARAM& param)
573 {
574 unsigned int i = 0;
575 unsigned int line_limit = (env.argStack.get_count () % 6);
576 for (; i + 2 <= line_limit; i += 2)
577 {
578 point_t pt1 = env.get_pt ();
579 pt1.move (env.eval_arg (i), env.eval_arg (i+1));
580 PATH::line (env, param, pt1);
581 }
582 for (; i + 6 <= env.argStack.get_count (); i += 6)
583 {
584 point_t pt1 = env.get_pt ();
585 pt1.move (env.eval_arg (i), env.eval_arg (i+1));
586 point_t pt2 = pt1;
587 pt2.move (env.eval_arg (i+2), env.eval_arg (i+3));
588 point_t pt3 = pt2;
589 pt3.move (env.eval_arg (i+4), env.eval_arg (i+5));
590 PATH::curve (env, param, pt1, pt2, pt3);
591 }
592 }
593
594 static void vvcurveto (ENV &env, PARAM& param)
595 {
596 unsigned int i = 0;
597 point_t pt1 = env.get_pt ();
598 if ((env.argStack.get_count () & 1) != 0)
599 pt1.move_x (env.eval_arg (i++));
600 for (; i + 4 <= env.argStack.get_count (); i += 4)
601 {
602 pt1.move_y (env.eval_arg (i));
603 point_t pt2 = pt1;
604 pt2.move (env.eval_arg (i+1), env.eval_arg (i+2));
605 point_t pt3 = pt2;
606 pt3.move_y (env.eval_arg (i+3));
607 PATH::curve (env, param, pt1, pt2, pt3);
608 pt1 = env.get_pt ();
609 }
610 }
611
612 static void hhcurveto (ENV &env, PARAM& param)
613 {
614 unsigned int i = 0;
615 point_t pt1 = env.get_pt ();
616 if ((env.argStack.get_count () & 1) != 0)
617 pt1.move_y (env.eval_arg (i++));
618 for (; i + 4 <= env.argStack.get_count (); i += 4)
619 {
620 pt1.move_x (env.eval_arg (i));
621 point_t pt2 = pt1;
622 pt2.move (env.eval_arg (i+1), env.eval_arg (i+2));
623 point_t pt3 = pt2;
624 pt3.move_x (env.eval_arg (i+3));
625 PATH::curve (env, param, pt1, pt2, pt3);
626 pt1 = env.get_pt ();
627 }
628 }
629
630 static void vhcurveto (ENV &env, PARAM& param)
631 {
632 point_t pt1, pt2, pt3;
633 unsigned int i = 0;
634 if ((env.argStack.get_count () % 8) >= 4)
635 {
636 point_t pt1 = env.get_pt ();
637 pt1.move_y (env.eval_arg (i));
638 point_t pt2 = pt1;
639 pt2.move (env.eval_arg (i+1), env.eval_arg (i+2));
640 point_t pt3 = pt2;
641 pt3.move_x (env.eval_arg (i+3));
642 i += 4;
643
644 for (; i + 8 <= env.argStack.get_count (); i += 8)
645 {
646 PATH::curve (env, param, pt1, pt2, pt3);
647 pt1 = env.get_pt ();
648 pt1.move_x (env.eval_arg (i));
649 pt2 = pt1;
650 pt2.move (env.eval_arg (i+1), env.eval_arg (i+2));
651 pt3 = pt2;
652 pt3.move_y (env.eval_arg (i+3));
653 PATH::curve (env, param, pt1, pt2, pt3);
654
655 pt1 = pt3;
656 pt1.move_y (env.eval_arg (i+4));
657 pt2 = pt1;
658 pt2.move (env.eval_arg (i+5), env.eval_arg (i+6));
659 pt3 = pt2;
660 pt3.move_x (env.eval_arg (i+7));
661 }
662 if (i < env.argStack.get_count ())
663 pt3.move_y (env.eval_arg (i));
664 PATH::curve (env, param, pt1, pt2, pt3);
665 }
666 else
667 {
668 for (; i + 8 <= env.argStack.get_count (); i += 8)
669 {
670 pt1 = env.get_pt ();
671 pt1.move_y (env.eval_arg (i));
672 pt2 = pt1;
673 pt2.move (env.eval_arg (i+1), env.eval_arg (i+2));
674 pt3 = pt2;
675 pt3.move_x (env.eval_arg (i+3));
676 PATH::curve (env, param, pt1, pt2, pt3);
677
678 pt1 = pt3;
679 pt1.move_x (env.eval_arg (i+4));
680 pt2 = pt1;
681 pt2.move (env.eval_arg (i+5), env.eval_arg (i+6));
682 pt3 = pt2;
683 pt3.move_y (env.eval_arg (i+7));
684 if ((env.argStack.get_count () - i < 16) && ((env.argStack.get_count () & 1) != 0))
685 pt3.move_x (env.eval_arg (i+8));
686 PATH::curve (env, param, pt1, pt2, pt3);
687 }
688 }
689 }
690
691 static void hvcurveto (ENV &env, PARAM& param)
692 {
693 point_t pt1, pt2, pt3;
694 unsigned int i = 0;
695 if ((env.argStack.get_count () % 8) >= 4)
696 {
697 point_t pt1 = env.get_pt ();
698 pt1.move_x (env.eval_arg (i));
699 point_t pt2 = pt1;
700 pt2.move (env.eval_arg (i+1), env.eval_arg (i+2));
701 point_t pt3 = pt2;
702 pt3.move_y (env.eval_arg (i+3));
703 i += 4;
704
705 for (; i + 8 <= env.argStack.get_count (); i += 8)
706 {
707 PATH::curve (env, param, pt1, pt2, pt3);
708 pt1 = env.get_pt ();
709 pt1.move_y (env.eval_arg (i));
710 pt2 = pt1;
711 pt2.move (env.eval_arg (i+1), env.eval_arg (i+2));
712 pt3 = pt2;
713 pt3.move_x (env.eval_arg (i+3));
714 PATH::curve (env, param, pt1, pt2, pt3);
715
716 pt1 = pt3;
717 pt1.move_x (env.eval_arg (i+4));
718 pt2 = pt1;
719 pt2.move (env.eval_arg (i+5), env.eval_arg (i+6));
720 pt3 = pt2;
721 pt3.move_y (env.eval_arg (i+7));
722 }
723 if (i < env.argStack.get_count ())
724 pt3.move_x (env.eval_arg (i));
725 PATH::curve (env, param, pt1, pt2, pt3);
726 }
727 else
728 {
729 for (; i + 8 <= env.argStack.get_count (); i += 8)
730 {
731 pt1 = env.get_pt ();
732 pt1.move_x (env.eval_arg (i));
733 pt2 = pt1;
734 pt2.move (env.eval_arg (i+1), env.eval_arg (i+2));
735 pt3 = pt2;
736 pt3.move_y (env.eval_arg (i+3));
737 PATH::curve (env, param, pt1, pt2, pt3);
738
739 pt1 = pt3;
740 pt1.move_y (env.eval_arg (i+4));
741 pt2 = pt1;
742 pt2.move (env.eval_arg (i+5), env.eval_arg (i+6));
743 pt3 = pt2;
744 pt3.move_x (env.eval_arg (i+7));
745 if ((env.argStack.get_count () - i < 16) && ((env.argStack.get_count () & 1) != 0))
746 pt3.move_y (env.eval_arg (i+8));
747 PATH::curve (env, param, pt1, pt2, pt3);
748 }
749 }
750 }
751
752 /* default actions to be overridden */
753 static void moveto (ENV &env, PARAM& param, const point_t &pt)
754 { env.moveto (pt); }
755
756 static void line (ENV &env, PARAM& param, const point_t &pt1)
757 { PATH::moveto (env, param, pt1); }
758
759 static void curve (ENV &env, PARAM& param, const point_t &pt1, const point_t &pt2, const point_t &pt3)
760 { PATH::moveto (env, param, pt3); }
761
762 static void hflex (ENV &env, PARAM& param)
763 {
764 if (likely (env.argStack.get_count () == 7))
765 {
766 point_t pt1 = env.get_pt ();
767 pt1.move_x (env.eval_arg (0));
768 point_t pt2 = pt1;
769 pt2.move (env.eval_arg (1), env.eval_arg (2));
770 point_t pt3 = pt2;
771 pt3.move_x (env.eval_arg (3));
772 point_t pt4 = pt3;
773 pt4.move_x (env.eval_arg (4));
774 point_t pt5 = pt4;
775 pt5.move_x (env.eval_arg (5));
776 pt5.y = pt1.y;
777 point_t pt6 = pt5;
778 pt6.move_x (env.eval_arg (6));
779
780 curve2 (env, param, pt1, pt2, pt3, pt4, pt5, pt6);
781 }
782 else
783 env.set_error ();
784 }
785
786 static void flex (ENV &env, PARAM& param)
787 {
788 if (likely (env.argStack.get_count () == 13))
789 {
790 point_t pt1 = env.get_pt ();
791 pt1.move (env.eval_arg (0), env.eval_arg (1));
792 point_t pt2 = pt1;
793 pt2.move (env.eval_arg (2), env.eval_arg (3));
794 point_t pt3 = pt2;
795 pt3.move (env.eval_arg (4), env.eval_arg (5));
796 point_t pt4 = pt3;
797 pt4.move (env.eval_arg (6), env.eval_arg (7));
798 point_t pt5 = pt4;
799 pt5.move (env.eval_arg (8), env.eval_arg (9));
800 point_t pt6 = pt5;
801 pt6.move (env.eval_arg (10), env.eval_arg (11));
802
803 curve2 (env, param, pt1, pt2, pt3, pt4, pt5, pt6);
804 }
805 else
806 env.set_error ();
807 }
808
809 static void hflex1 (ENV &env, PARAM& param)
810 {
811 if (likely (env.argStack.get_count () == 9))
812 {
813 point_t pt1 = env.get_pt ();
814 pt1.move (env.eval_arg (0), env.eval_arg (1));
815 point_t pt2 = pt1;
816 pt2.move (env.eval_arg (2), env.eval_arg (3));
817 point_t pt3 = pt2;
818 pt3.move_x (env.eval_arg (4));
819 point_t pt4 = pt3;
820 pt4.move_x (env.eval_arg (5));
821 point_t pt5 = pt4;
822 pt5.move (env.eval_arg (6), env.eval_arg (7));
823 point_t pt6 = pt5;
824 pt6.move_x (env.eval_arg (8));
825 pt6.y = env.get_pt ().y;
826
827 curve2 (env, param, pt1, pt2, pt3, pt4, pt5, pt6);
828 }
829 else
830 env.set_error ();
831 }
832
833 static void flex1 (ENV &env, PARAM& param)
834 {
835 if (likely (env.argStack.get_count () == 11))
836 {
837 point_t d;
838 d.init ();
839 for (unsigned int i = 0; i < 10; i += 2)
840 d.move (env.eval_arg (i), env.eval_arg (i+1));
841
842 point_t pt1 = env.get_pt ();
843 pt1.move (env.eval_arg (0), env.eval_arg (1));
844 point_t pt2 = pt1;
845 pt2.move (env.eval_arg (2), env.eval_arg (3));
846 point_t pt3 = pt2;
847 pt3.move (env.eval_arg (4), env.eval_arg (5));
848 point_t pt4 = pt3;
849 pt4.move (env.eval_arg (6), env.eval_arg (7));
850 point_t pt5 = pt4;
851 pt5.move (env.eval_arg (8), env.eval_arg (9));
852 point_t pt6 = pt5;
853
854 if (fabs (d.x.to_real ()) > fabs (d.y.to_real ()))
855 {
856 pt6.move_x (env.eval_arg (10));
857 pt6.y = env.get_pt ().y;
858 }
859 else
860 {
861 pt6.x = env.get_pt ().x;
862 pt6.move_y (env.eval_arg (10));
863 }
864
865 curve2 (env, param, pt1, pt2, pt3, pt4, pt5, pt6);
866 }
867 else
868 env.set_error ();
869 }
870
871 protected:
872 static void curve2 (ENV &env, PARAM& param,
873 const point_t &pt1, const point_t &pt2, const point_t &pt3,
874 const point_t &pt4, const point_t &pt5, const point_t &pt6)
875 {
876 PATH::curve (env, param, pt1, pt2, pt3);
877 PATH::curve (env, param, pt4, pt5, pt6);
878 }
879 };
880
881 template <typename ENV, typename OPSET, typename PARAM>
882 struct cs_interpreter_t : interpreter_t<ENV>
883 {
884 bool interpret (PARAM& param)
885 {
886 SUPER::env.set_endchar (false);
887
888 for (;;) {
889 OPSET::process_op (SUPER::env.fetch_op (), SUPER::env, param);
890 if (unlikely (SUPER::env.in_error ()))
891 return false;
892 if (SUPER::env.is_endchar ())
893 break;
894 }
895
896 return true;
897 }
898
899 private:
900 typedef interpreter_t<ENV> SUPER;
901 };
902
903 } /* namespace CFF */
904
905 #endif /* HB_CFF_INTERP_CS_COMMON_HH */