Grcov report - trace.c

1

/* cairo-trace - a utility to record and replay calls to the Cairo library.

2

3

 * Copyright © 2008 Chris Wilson

4

5

 * This program is free software: you can redistribute it and/or modify

6

 * it under the terms of the GNU General Public License as published by

7

 * the Free Software Foundation, either version 3 of the License, or

8

 * (at your option) any later version.

9

10

 * This program is distributed in the hope that it will be useful,

11

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

12

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

13

 * GNU General Public License for more details.

14

15

 * You should have received a copy of the GNU General Public License

16

 * along with this program.  If not, see <http://www.gnu.org/licenses/>.

17

*/

18

19

#include "config.h"

20

21

/* The autoconf on OpenBSD 4.5 produces the malformed constant name

22

 * SIZEOF_VOID__ rather than SIZEOF_VOID_P.  Work around that here. */

23

#if !defined(SIZEOF_VOID_P) && defined(SIZEOF_VOID__)

24

# define SIZEOF_VOID_P SIZEOF_VOID__

25

#endif

26

27

#include <dlfcn.h>

28

#include <stdint.h>

29

#include <stdbool.h>

30

#include <stdio.h>

31

#include <string.h>

32

#include <sys/types.h>

33

#include <unistd.h>

34

#include <errno.h>

35

#include <pthread.h>

36

#include <zlib.h>

37

#include <math.h>

38

#include <locale.h> /* for locale independent %f printing */

39

#include <ctype.h>

40

#include <assert.h>

41

#include <stdlib.h>

42

#include <limits.h>

43

#include <stdarg.h>

44

45

#include <cairo.h>

46

#if CAIRO_HAS_FT_FONT

47

# include <cairo-ft.h>

48

#endif

49

50

#include "cairo-ctype-inline.h"

51

52

#ifndef TRUE

53

#define TRUE 1

54

#define FALSE 0

55

#endif

56

57

#ifndef CAIRO_TRACE_OUTDIR

58

#define CAIRO_TRACE_OUTDIR "."

59

#endif

60

61

#define DEBUG_STACK 0

62

63

#if HAVE_BYTESWAP_H

64

# include <byteswap.h>

65

#endif

66

#ifndef bswap_16

67

# define bswap_16(p) \

68

	(((((uint16_t)(p)) & 0x00ff) << 8) | \

69

	  (((uint16_t)(p))           >> 8))

70

#endif

71

#ifndef bswap_32

72

# define bswap_32(p) \

73

         (((((uint32_t)(p)) & 0x000000ff) << 24) | \

74

	  ((((uint32_t)(p)) & 0x0000ff00) << 8)  | \

75

	  ((((uint32_t)(p)) & 0x00ff0000) >> 8)  | \

76

	  ((((uint32_t)(p)))              >> 24))

77

#endif

78

79

#if WORDS_BIGENDIAN

80

#define le16(x) bswap_16 (x)

81

#define le32(x) bswap_32 (x)

82

#define be16(x) x

83

#define be32(x) x

84

#define to_be32(x) x

85

#else

86

#define le16(x) x

87

#define le32(x) x

88

#define be16(x) bswap_16 (x)

89

#define be32(x) bswap_32 (x)

90

#define to_be32(x) bswap_32 (x)

91

#endif

92

93

#if CAIRO_HAS_SYMBOL_LOOKUP

94

#include "lookup-symbol.h"

95

#endif

96

97

/* Reverse the bits in a byte with 7 operations (no 64-bit):

98

 * Devised by Sean Anderson, July 13, 2001.

99

 * Source: http://graphics.stanford.edu/~seander/bithacks.html#ReverseByteWith32Bits

100

*/

101

#define CAIRO_BITSWAP8(c) ((((c) * 0x0802LU & 0x22110LU) | ((c) * 0x8020LU & 0x88440LU)) * 0x10101LU >> 16)

102

103

#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ > 4)

104

#ifdef __MINGW32__

105

#define CAIRO_PRINTF_FORMAT(fmt_index, va_index)                        \

106

	__attribute__((__format__(__MINGW_PRINTF_FORMAT, fmt_index, va_index)))

107

#else

108

#define CAIRO_PRINTF_FORMAT(fmt_index, va_index)                        \

109

	__attribute__((__format__(__printf__, fmt_index, va_index)))

110

#endif

111

#else

112

#define CAIRO_PRINTF_FORMAT(fmt_index, va_index)

113

#endif

114

115

/* XXX implement manual vprintf so that the user can control precision of

116

 * printed numbers.

117

*/

118

119

static void *_dlhandle = RTLD_NEXT;

120

#define DLCALL(name, args...) ({ \

121

    static typeof (&name) name##_real; \

122

    if (name##_real == NULL) { \

123

	name##_real = (typeof (&name))(dlsym (_dlhandle, #name));	\

124

	if (name##_real == NULL && _dlhandle == RTLD_NEXT) { \

125

	    _dlhandle = dlopen ("libcairo." SHARED_LIB_EXT, RTLD_LAZY); \

126

	    name##_real = (typeof (&name))(dlsym (_dlhandle, #name));	\

127

	    assert (name##_real != NULL); \

128

} \

129

} \

130

    (*name##_real) (args);  \

131

})

132

133

#ifndef ARRAY_LENGTH

134

#define ARRAY_LENGTH(__array) ((int) (sizeof (__array) / sizeof (__array[0])))

135

#endif

136

137

#if SIZEOF_VOID_P == 4

138

#define PTR_SHIFT 2

139

#elif SIZEOF_VOID_P == 8

140

#define PTR_SHIFT 3

141

#else

142

#error Unexpected pointer size

143

#endif

144

#define BUCKET(b, ptr) (((uintptr_t) (ptr) >> PTR_SHIFT) % ARRAY_LENGTH (b))

145

146

#if defined(__GNUC__) && (__GNUC__ > 2) && defined(__OPTIMIZE__)

147

#define _BOOLEAN_EXPR(expr)                   \

148

 __extension__ ({                             \

149

   int _boolean_var_;                         \

150

   if (expr)                                  \

151

      _boolean_var_ = 1;                      \

152

   else                                       \

153

      _boolean_var_ = 0;                      \

154

   _boolean_var_;                             \

155

})

156

#define LIKELY(expr) (__builtin_expect (_BOOLEAN_EXPR(expr), 1))

157

#define UNLIKELY(expr) (__builtin_expect (_BOOLEAN_EXPR(expr), 0))

158

#else

159

#define LIKELY(expr) (expr)

160

#define UNLIKELY(expr) (expr)

161

#endif

162

163

typedef struct _object Object;

164

typedef struct _type Type;

165

166

struct _object {

167

    const void *addr;

168

    Type *type;

169

    unsigned long int token;

170

    int width, height;

171

    cairo_bool_t foreign;

172

    cairo_bool_t defined;

173

    cairo_bool_t unknown;

174

    int operand;

175

    void *data;

176

    void (*destroy)(void *);

177

    Object *next, *prev;

178

};

179

180

struct _type {

181

    const char *name;

182

183

    enum operand_type {

184

	NONE,

185

	SURFACE,

186

	CONTEXT,

187

	FONT_FACE,

188

	PATTERN,

189

	SCALED_FONT,

190

	_N_OP_TYPES

191

    } op_type;

192

    const char *op_code;

193

194

    pthread_mutex_t mutex;

195

    struct _bitmap {

196

	unsigned long int min;

197

	unsigned long int count;

198

	unsigned int map[64];

199

	struct _bitmap *next;

200

    } map;

201

    Object *objects[607];

202

    Type *next;

203

};

204

205

static struct _type_table {

206

    pthread_mutex_t mutex;

207

    Type *op_types[_N_OP_TYPES];

208

} Types;

209

210

static FILE *logfile;

211

static cairo_bool_t _flush;

212

static cairo_bool_t _error;

213

static cairo_bool_t _line_info;

214

static cairo_bool_t _mark_dirty;

215

static const cairo_user_data_key_t destroy_key;

216

static pthread_once_t once_control = PTHREAD_ONCE_INIT;

217

static pthread_key_t counter_key;

218

219

static void _init_trace (void);

220

221

#define INIT_TRACE_ONCE() pthread_once (&once_control, _init_trace)

222

223

#if __GNUC__ >= 3 && defined(__ELF__) && !defined(__sun)

224

# define _enter_trace() INIT_TRACE_ONCE ()

225

# define _exit_trace()  do { } while (0)

226

# define _should_trace() 1

227

# define USE_ENTER_EXIT 0

228

#else

229

static void _enter_trace (void);

230

static void _exit_trace (void);

231

static cairo_bool_t _should_trace (void);

232

# define USE_ENTER_EXIT 1

233

#endif

234

235

#if HAVE_BUILTIN_RETURN_ADDRESS && CAIRO_HAS_SYMBOL_LOOKUP

236

#define _emit_line_info() do { \

237

    if (_line_info && _write_lock ()) {	\

238

	void *addr = __builtin_return_address(0); \

239

	char caller[1024]; \

240

	_trace_printf ("%% %s() called by %s\n", __FUNCTION__, \

241

		       lookup_symbol (caller, sizeof (caller), addr)); \

242

	_write_unlock (); \

243

} \

244

} while (0)

245

#else

246

#define _emit_line_info()

247

#endif

248

249

static void

250

_type_release_token (Type *t, unsigned long int token)

251

252

    struct _bitmap *b, **prev = NULL;

253

254

    b = &t->map;

255

    while (b != NULL) {

256

	if (token < b->min + sizeof (b->map) * CHAR_BIT) {

257

	    unsigned int bit, elem;

258

259

	    token -= b->min;

260

	    elem = token / (sizeof (b->map[0]) * CHAR_BIT);

261

	    bit  = token % (sizeof (b->map[0]) * CHAR_BIT);

262

	    b->map[elem] &= ~(1 << bit);

263

	    if (! --b->count && prev) {

264

		*prev = b->next;

265

		free (b);

266

267

	    return;

268

269

	prev = &b->next;

270

	b = b->next;

271

272

273

274

static unsigned long int

275

_type_next_token (Type *t)

276

277

    struct _bitmap *b, *bb, **prev = NULL;

278

    unsigned long int min = 0;

279

280

    b = &t->map;

281

    while (b != NULL) {

282

	if (b->min != min)

283

	    break;

284

285

	if (b->count < sizeof (b->map) * CHAR_BIT) {

286

	    unsigned int n, m, bit;

287

	    for (n = 0; n < ARRAY_LENGTH (b->map); n++) {

288

		if (b->map[n] == (unsigned int) -1)

289

		    continue;

290

291

		for (m=0, bit=1; m<sizeof (b->map[0])*CHAR_BIT; m++, bit<<=1) {

292

		    if ((b->map[n] & bit) == 0) {

293

			b->map[n] |= bit;

294

			b->count++;

295

			return n * sizeof (b->map[0])*CHAR_BIT + m + b->min;

296

297

298

299

300

	min += sizeof (b->map) * CHAR_BIT;

301

302

	prev = &b->next;

303

	b = b->next;

304

305

    assert (prev != NULL);

306

307

    bb = malloc (sizeof (struct _bitmap));

308

309

    *prev = bb;

310

    bb->next = b;

311

    bb->min = min;

312

    bb->count = 1;

313

    bb->map[0] = 0x1;

314

    memset (bb->map + 1, 0, sizeof (bb->map) - sizeof (bb->map[0]));

315

316

    return min;

317

318

319

static void

320

_object_destroy (Object *obj)

321

322

    int bucket;

323

324

    pthread_mutex_lock (&obj->type->mutex);

325

    bucket = BUCKET (obj->type->objects, obj->addr);

326

    _type_release_token (obj->type, obj->token);

327

328

    if (obj->prev != NULL)

329

	obj->prev->next = obj->next;

330

    else

331

	obj->type->objects[bucket] = obj->next;

332

333

    if (obj->next != NULL)

334

	obj->next->prev = obj->prev;

335

    pthread_mutex_unlock (&obj->type->mutex);

336

337

    if (obj->data != NULL && obj->destroy != NULL)

338

	obj->destroy (obj->data);

339

340

    free (obj);

341

342

343

static void

344

_type_create (const char *typename,

345

	      enum operand_type op_type,

346

	      const char *op_code)

347

348

    Type *t;

349

350

    pthread_mutex_lock (&Types.mutex);

351

352

    t = malloc (sizeof (Type));

353

    t->name = typename;

354

    t->op_type = op_type;

355

    t->op_code = op_code;

356

357

    pthread_mutex_init (&t->mutex, NULL);

358

359

    t->map.min = 0;

360

    t->map.count = 0;

361

    memset (t->map.map, 0, sizeof (t->map.map));

362

    t->map.next = NULL;

363

364

    memset (t->objects, 0, sizeof (t->objects));

365

366

    t->next = NULL;

367

368

    Types.op_types[op_type] = t;

369

    pthread_mutex_unlock (&Types.mutex);

370

371

372

static Type *

373

_get_type (enum operand_type type)

374

375

    return Types.op_types[type];

376

377

378

static void

379

_type_destroy (Type *t)

380

381

    int n;

382

    struct _bitmap *b;

383

384

    for (n = 0; n < ARRAY_LENGTH (t->objects); n++) {

385

	Object *obj = t->objects[n];

386

	while (obj != NULL) {

387

	    Object *next = obj->next;

388

	    _object_destroy (obj);

389

	    obj = next;

390

391

392

393

    b = t->map.next;

394

    while (b != NULL) {

395

	struct _bitmap *next = b->next;

396

	free (b);

397

	b = next;

398

399

400

    pthread_mutex_destroy (&t->mutex);

401

    free (t);

402

403

404

static Object *

405

_type_get_object (Type *type, const void *ptr)

406

407

    Object *obj;

408

    int bucket = BUCKET (type->objects, ptr);

409

410

    for (obj = type->objects[bucket]; obj != NULL; obj = obj->next) {

411

	if (obj->addr == ptr) {

412

	    if (obj->prev != NULL) { /* mru */

413

		obj->prev->next = obj->next;

414

		if (obj->next != NULL)

415

		    obj->next->prev = obj->prev;

416

		obj->prev = NULL;

417

		type->objects[bucket]->prev = obj;

418

		obj->next = type->objects[bucket];

419

		type->objects[bucket] = obj;

420

421

	    return obj;

422

423

424

425

    return NULL;

426

427

428

static Object *

429

_object_create (Type *type, const void *ptr)

430

431

    Object *obj;

432

    int bucket = BUCKET (type->objects, ptr);

433

434

    obj = malloc (sizeof (Object));

435

    obj->unknown = TRUE;

436

    obj->defined = FALSE;

437

    obj->foreign = FALSE;

438

    obj->operand = -1;

439

    obj->type = type;

440

    obj->addr = ptr;

441

    obj->token = _type_next_token (type);

442

    obj->data = NULL;

443

    obj->destroy = NULL;

444

    obj->prev = NULL;

445

    obj->next = type->objects[bucket];

446

    if (type->objects[bucket] != NULL)

447

	type->objects[bucket]->prev = obj;

448

    type->objects[bucket] = obj;

449

450

    return obj;

451

452

453

#if USE_ENTER_EXIT

454

static int *

455

_get_counter (void)

456

457

    int *counter = pthread_getspecific (counter_key);

458

    if (counter == NULL) {

459

	counter = calloc(1, sizeof(int));

460

	pthread_setspecific (counter_key, counter);

461

462

    return counter;

463

464

465

static void

466

_enter_trace (void)

467

468

    INIT_TRACE_ONCE ();

469

    _get_counter ()[0]++;

470

471

472

static void

473

_exit_trace (void)

474

475

    _get_counter ()[0]--;

476

477

478

static cairo_bool_t

479

_should_trace (void)

480

481

    return _get_counter ()[0] <= 1;

482

483

#endif /* USE_ENTER_EXIT */

484

485

static void

486

_init_trace (void)

487

488

    pthread_mutex_init (&Types.mutex, NULL);

489

    pthread_key_create (&counter_key, free);

490

491

    _type_create ("unclassed", NONE, "");

492

    _type_create ("cairo_t", CONTEXT, "c");

493

    _type_create ("cairo_font_face_t", FONT_FACE, "f");

494

    _type_create ("cairo_pattern_t", PATTERN, "p");

495

    _type_create ("cairo_scaled_font_t", SCALED_FONT, "sf");

496

    _type_create ("cairo_surface_t", SURFACE, "s");

497

498

499

static void

500

_close_trace (void)

501

502

    if (logfile != NULL) {

503

	fclose (logfile);

504

	logfile = NULL;

505

506

507

508

static void __attribute__ ((destructor))

509

_fini_trace (void)

510

511

    int n;

512

513

    _close_trace ();

514

515

    for (n = 0; n < ARRAY_LENGTH (Types.op_types); n++) {

516

	if (Types.op_types[n]) {

517

	    _type_destroy (Types.op_types[n]);

518

	    Types.op_types[n] = NULL;

519

520

521

522

    pthread_mutex_destroy (&Types.mutex);

523

524

525

/* Format a double in a locale independent way and trim trailing

526

 * zeros.  Based on code from Alex Larson <alexl@redhat.com>.

527

 * https://mail.gnome.org/archives/gtk-devel-list/2001-October/msg00087.html

528

529

 * The code in the patch is copyright Red Hat, Inc under the LGPL.

530

*/

531

#define SIGNIFICANT_DIGITS_AFTER_DECIMAL 6

532

static void

533

_trace_dtostr (char *buffer, size_t size, double d)

534

535

    struct lconv *locale_data;

536

    const char *decimal_point;

537

    int decimal_point_len;

538

    char *p;

539

    int decimal_len;

540

    int num_zeros, decimal_digits;

541

542

    /* Omit the minus sign from negative zero. */

543

    if (d == 0.0)

544

	d = 0.0;

545

546

    locale_data = localeconv ();

547

    decimal_point = locale_data->decimal_point;

548

    decimal_point_len = strlen (decimal_point);

549

550

    /* Using "%f" to print numbers less than 0.1 will result in

551

     * reduced precision due to the default 6 digits after the

552

     * decimal point.

553

554

     * For numbers is < 0.1, we print with maximum precision and count

555

     * the number of zeros between the decimal point and the first

556

     * significant digit. We then print the number again with the

557

     * number of decimal places that gives us the required number of

558

     * significant digits. This ensures the number is correctly

559

     * rounded.

560

*/

561

    if (fabs (d) >= 0.1) {

562

	snprintf (buffer, size, "%f", d);

563

    } else {

564

	snprintf (buffer, size, "%.18f", d);

565

	p = buffer;

566

567

	if (*p == '+' || *p == '-')

568

	    p++;

569

570

	while (_cairo_isdigit (*p))

571

	    p++;

572

573

	if (strncmp (p, decimal_point, decimal_point_len) == 0)

574

	    p += decimal_point_len;

575

576

	num_zeros = 0;

577

	while (*p++ == '0')

578

	    num_zeros++;

579

580

	decimal_digits = num_zeros + SIGNIFICANT_DIGITS_AFTER_DECIMAL;

581

582

	if (decimal_digits < 18)

583

	    snprintf (buffer, size, "%.*f", decimal_digits, d);

584

585

    p = buffer;

586

587

    if (*p == '+' || *p == '-')

588

	p++;

589

590

    while (_cairo_isdigit (*p))

591

	p++;

592

593

    if (strncmp (p, decimal_point, decimal_point_len) == 0) {

594

	*p = '.';

595

	decimal_len = strlen (p + decimal_point_len);

596

	memmove (p + 1, p + decimal_point_len, decimal_len);

597

	p[1 + decimal_len] = 0;

598

599

	/* Remove trailing zeros and decimal point if possible. */

600

	for (p = p + decimal_len; *p == '0'; p--)

601

	    *p = 0;

602

603

	if (*p == '.') {

604

	    *p = 0;

605

	    p--;

606

607

608

609

610

enum {

611

    LENGTH_MODIFIER_LONG = 0x100

612

};

613

614

/* Here's a limited reimplementation of printf.  The reason for doing

615

 * this is primarily to special case handling of doubles.  We want

616

 * locale independent formatting of doubles and we want to trim

617

 * trailing zeros.  This is handled by dtostr() above, and the code

618

 * below handles everything else by calling snprintf() to do the

619

 * formatting.  This functionality is only for internal use and we

620

 * only implement the formats we actually use.

621

*/

622

static void CAIRO_PRINTF_FORMAT(1, 0)

623

_trace_vprintf (const char *fmt, va_list ap)

624

625

#define SINGLE_FMT_BUFFER_SIZE 32

626

    char buffer[512], single_fmt[SINGLE_FMT_BUFFER_SIZE];

627

    int single_fmt_length;

628

    char *p;

629

    const char *f, *start;

630

    int length_modifier, width;

631

    cairo_bool_t var_width;

632

    int ret_ignored;

633

634

    assert (_should_trace ());

635

636

    f = fmt;

637

    p = buffer;

638

    while (*f != '\0') {

639

	if (*f != '%') {

640

	    *p++ = *f++;

641

	    continue;

642

643

644

	start = f;

645

	f++;

646

647

	if (*f == '0')

648

	    f++;

649

650

        var_width = 0;

651

        if (*f == '*') {

652

            var_width = 1;

653

	    f++;

654

655

656

	while (_cairo_isdigit (*f))

657

	    f++;

658

659

	length_modifier = 0;

660

	if (*f == 'l') {

661

	    length_modifier = LENGTH_MODIFIER_LONG;

662

	    f++;

663

664

665

	/* The only format strings exist in the cairo implementation

666

	 * itself. So there's an internal consistency problem if any

667

	 * of them is larger than our format buffer size. */

668

	single_fmt_length = f - start + 1;

669

670

	/* Reuse the format string for this conversion. */

671

	memcpy (single_fmt, start, single_fmt_length);

672

	single_fmt[single_fmt_length] = '\0';

673

674

	/* Flush contents of buffer before snprintf()'ing into it. */

675

	ret_ignored = fwrite (buffer, 1, p-buffer, logfile);

676

677

	/* We group signed and unsigned together in this switch, the

678

	 * only thing that matters here is the size of the arguments,

679

	 * since we're just passing the data through to sprintf(). */

680

	switch (*f | length_modifier) {

681

	case '%':

682

	    buffer[0] = *f;

683

	    buffer[1] = 0;

684

	    break;

685

	case 'd':

686

	case 'u':

687

	case 'o':

688

	case 'x':

689

	case 'X':

690

            if (var_width) {

691

                width = va_arg (ap, int);

692

                snprintf (buffer, sizeof buffer,

693

                          single_fmt, width, va_arg (ap, int));

694

            } else {

695

                snprintf (buffer, sizeof buffer, single_fmt, va_arg (ap, int));

696

697

	    break;

698

	case 'd' | LENGTH_MODIFIER_LONG:

699

	case 'u' | LENGTH_MODIFIER_LONG:

700

	case 'o' | LENGTH_MODIFIER_LONG:

701

	case 'x' | LENGTH_MODIFIER_LONG:

702

	case 'X' | LENGTH_MODIFIER_LONG:

703

            if (var_width) {

704

                width = va_arg (ap, int);

705

                snprintf (buffer, sizeof buffer,

706

                          single_fmt, width, va_arg (ap, long int));

707

            } else {

708

                snprintf (buffer, sizeof buffer,

709

                          single_fmt, va_arg (ap, long int));

710

711

	    break;

712

	case 's':

713

	    snprintf (buffer, sizeof buffer,

714

		      single_fmt, va_arg (ap, const char *));

715

	    break;

716

	case 'f':

717

	case 'g':

718

	    _trace_dtostr (buffer, sizeof buffer, va_arg (ap, double));

719

	    break;

720

	case 'c':

721

	    buffer[0] = va_arg (ap, int);

722

	    buffer[1] = 0;

723

	    break;

724

	default:

725

	    break;

726

727

	p = buffer + strlen (buffer);

728

	f++;

729

730

731

    ret_ignored = fwrite (buffer, 1, p-buffer, logfile);

732

    (void)ret_ignored;

733

734

735

static void CAIRO_PRINTF_FORMAT(1, 2)

736

_trace_printf (const char *fmt, ...)

737

738

    va_list ap;

739

740

    va_start (ap, fmt);

741

    _trace_vprintf (fmt, ap);

742

    va_end (ap);

743

744

745

static void

746

get_prog_name (char *buf, int length)

747

748

    char *slash;

749

    FILE *file;

750

751

    memset (buf, 0, length);

752

    if (length == 0)

753

	return;

754

755

    file = fopen ("/proc/self/cmdline", "rb");

756

    if (file != NULL) {

757

	slash = fgets (buf, length, file);

758

	fclose (file);

759

760

	if (slash == NULL)

761

	    return;

762

    } else {

763

	char const *name = getenv ("CAIRO_TRACE_PROG_NAME");

764

	if (name != NULL) {

765

	    strncpy (buf, name, length-1);

766

767

768

769

    slash = strrchr (buf, '/');

770

    if (slash != NULL) {

771

	size_t len = strlen (slash+1);

772

	memmove (buf, slash+1, len+1);

773

774

775

776

static void

777

_emit_header (void)

778

779

    char name[4096] = "";

780

781

    get_prog_name (name, sizeof (name));

782

783

    _trace_printf ("%%!CairoScript - %s\n", name);

784

785

786

static cairo_bool_t

787

_init_logfile (void)

788

789

    static cairo_bool_t initialized;

790

    char buf[4096];

791

    const char *filename;

792

    const char *env;

793

794

    if (initialized)

795

	return logfile != NULL;

796

797

    initialized = TRUE;

798

799

    env = getenv ("CAIRO_TRACE_FLUSH");

800

    if (env != NULL)

801

	_flush = atoi (env);

802

803

    _line_info = TRUE;

804

    env = getenv ("CAIRO_TRACE_LINE_INFO");

805

    if (env != NULL)

806

	_line_info = atoi (env);

807

808

    _mark_dirty = TRUE;

809

    env = getenv ("CAIRO_TRACE_MARK_DIRTY");

810

    if (env != NULL)

811

	_mark_dirty = atoi (env);

812

813

    filename = getenv ("CAIRO_TRACE_FD");

814

    if (filename != NULL) {

815

	int fd = atoi (filename);

816

	if (fd == -1)

817

	    return FALSE;

818

819

	logfile = fdopen (fd, "w");

820

	if (logfile == NULL) {

821

	    fprintf (stderr, "Failed to open trace file descriptor '%s': %s\n",

822

		       filename, strerror (errno));

823

	    return FALSE;

824

825

826

	setenv ("CAIRO_TRACE_FD", "-1", 1);

827

	goto done;

828

829

830

    filename = getenv ("CAIRO_TRACE_OUTFILE_EXACT");

831

    if (filename == NULL) {

832

	char name[4096] = "";

833

834

	filename = getenv ("CAIRO_TRACE_OUTDIR");

835

	if (filename == NULL)

836

	    filename = CAIRO_TRACE_OUTDIR;

837

838

	get_prog_name (name, sizeof (name));

839

	if (*name == '\0')

840

	    strcpy (name, "cairo-trace.dat");

841

842

	if (snprintf (buf, sizeof (buf), "%s/%s.%d.trace",

843

		      filename, name, getpid()) >= (int) sizeof (buf))

844

845

	    fprintf (stderr, "cairo-trace: Trace file name too long\n");

846

	    return FALSE;

847

848

849

	filename = buf;

850

    } else {

851

	setenv ("CAIRO_TRACE_FD", "-1", 1);

852

853

854

    logfile = fopen (filename, "wb");

855

    if (logfile == NULL) {

856

	fprintf (stderr, "Failed to open trace file '%s': %s\n",

857

		   filename, strerror (errno));

858

	return FALSE;

859

860

861

    fprintf (stderr, "cairo-trace: Recording cairo trace data to %s\n",

862

	     filename);

863

864

done:

865

    atexit (_close_trace);

866

    _emit_header ();

867

    return TRUE;

868

869

870

static cairo_bool_t

871

_write_lock (void)

872

873

    if (_error)

874

	return FALSE;

875

876

    if (! _should_trace ())

877

	return FALSE;

878

879

    if (! _init_logfile ())

880

	return FALSE;

881

882

#if HAVE_FLOCKFILE && HAVE_FUNLOCKFILE

883

    flockfile (logfile);

884

#endif

885

    return TRUE;

886

887

888

static void

889

_write_unlock (void)

890

891

    if (logfile == NULL)

892

	return;

893

894

#if HAVE_FLOCKFILE && HAVE_FUNLOCKFILE

895

    funlockfile (logfile);

896

#endif

897

898

    if (_flush)

899

	fflush (logfile);

900

901

902

903

static Object *

904

_type_object_create (enum operand_type op_type, const void *ptr)

905

906

    Type *type;

907

    Object *obj;

908

909

    type = _get_type (op_type);

910

911

    pthread_mutex_lock (&type->mutex);

912

    obj = _object_create (type, ptr);

913

    pthread_mutex_unlock (&type->mutex);

914

915

    return obj;

916

917

918

static Object *

919

_get_object (enum operand_type op_type, const void *ptr)

920

921

    Type *type;

922

    Object *obj;

923

924

    type = _get_type (op_type);

925

    pthread_mutex_lock (&type->mutex);

926

    obj = _type_get_object (type, ptr);

927

    pthread_mutex_unlock (&type->mutex);

928

929

    return obj;

930

931

932

static Object *current_object[2048]; /* XXX limit operand stack */

933

static int current_stack_depth;

934

935

static void

936

dump_stack(const char *func)

937

938

#if DEBUG_STACK

939

	int n;

940

941

	_trace_printf ("%% %s: stack[%d] = [", func, current_stack_depth);

942

	fflush (logfile);

943

	for (n = 0; n < current_stack_depth; n++) {

944

		Object *obj = current_object[n];

945

		assert(obj && obj->type);

946

		_trace_printf (" %s%s%ld",

947

			       obj->defined ? "" : "*",

948

			       obj->type->op_code, obj->token);

949

	fflush (logfile);

950

951

	_trace_printf (" ]\n");

952

	fflush (logfile);

953

#endif

954

955

956

static void

957

ensure_operands (int num_operands)

958

959

    if (current_stack_depth < num_operands) {

960

	int n;

961

962

	fprintf (stderr, "Operand stack underflow!\n");

963

	for (n = 0; n < current_stack_depth; n++) {

964

	    Object *obj = current_object[n];

965

966

	    fprintf (stderr, "  [%3d] = %s%ld\n",

967

		     n, obj->type->op_code, obj->token);

968

969

970

	abort ();

971

972

973

974

static void

975

_consume_operand (bool discard)

976

977

    Object *obj;

978

979

    ensure_operands (1);

980

    obj = current_object[--current_stack_depth];

981

    if (!discard && ! obj->defined) {

982

	_trace_printf ("dup /%s%ld exch def\n",

983

		       obj->type->op_code,

984

		       obj->token);

985

	obj->defined = TRUE;

986

987

    obj->operand = -1;

988

989

990

static void

991

_exch_operands (void)

992

993

    Object *tmp;

994

995

    ensure_operands (2);

996

    tmp = current_object[current_stack_depth-1];

997

    tmp->operand--;

998

    current_object[current_stack_depth-1] = current_object[current_stack_depth-2];

999

    current_object[current_stack_depth-2] = tmp;

1000

    tmp = current_object[current_stack_depth-1];

1001

    tmp->operand++;

1002

1003

1004

static cairo_bool_t

1005

_pop_operands_to_depth (int depth)

1006

1007

    if (depth < 0)

1008

	return FALSE;

1009

1010

    assert(current_stack_depth >= depth);

1011

    if (current_stack_depth == depth)

1012

	return TRUE;

1013

1014

    while (current_stack_depth > depth + 1) {

1015

	Object *c_obj;

1016

1017

	ensure_operands (1);

1018

	c_obj = current_object[--current_stack_depth];

1019

1020

	assert(c_obj);

1021

	assert(c_obj->type);

1022

1023

	if (! c_obj->defined) {

1024

	    current_stack_depth++;

1025

	    return FALSE;

1026

1027

1028

	_trace_printf ("pop %% %s%ld\n",

1029

		       c_obj->type->op_code, c_obj->token);

1030

	c_obj->operand = -1;

1031

1032

1033

    _exch_operands ();

1034

    _trace_printf ("exch\n");

1035

1036

    dump_stack(__func__);

1037

    return TRUE;

1038

1039

1040

static cairo_bool_t

1041

_pop_operands_to_object (Object *obj)

1042

1043

    if (!obj)

1044

	return FALSE;

1045

1046

    if (obj->operand == -1)

1047

	return FALSE;

1048

1049

    if (obj->operand == current_stack_depth - 1)

1050

	return TRUE;

1051

1052

    if (obj->operand == current_stack_depth - 2) {

1053

	_exch_operands ();

1054

	_trace_printf ("exch ");

1055

	return TRUE;

1056

1057

1058

    return _pop_operands_to_depth (obj->operand + 1);

1059

1060

1061

static cairo_bool_t

1062

_pop_operands_to (enum operand_type t, const void *ptr)

1063

1064

    return _pop_operands_to_object (_get_object (t, ptr));

1065

1066

1067

static cairo_bool_t

1068

_is_current_object (Object *obj, int depth)

1069

1070

    if (current_stack_depth <= depth)

1071

	return FALSE;

1072

    return current_object[current_stack_depth-depth-1] == obj;

1073

1074

1075

static cairo_bool_t

1076

_is_current (enum operand_type type, const void *ptr, int depth)

1077

1078

    return _is_current_object (_get_object (type, ptr), depth);

1079

1080

1081

static void

1082

_push_object(Object *obj)

1083

1084

    assert(obj->operand == -1);

1085

1086

    if (current_stack_depth == ARRAY_LENGTH (current_object)) {

1087

	int n;

1088

1089

	fprintf (stderr, "Operand stack overflow!\n");

1090

	for (n = 0; n < current_stack_depth; n++) {

1091

	    obj = current_object[n];

1092

1093

	    fprintf (stderr, "  [%3d] = %s%ld\n",

1094

		     n, obj->type->op_code, obj->token);

1095

1096

1097

	abort ();

1098

1099

1100

    obj->operand = current_stack_depth;

1101

    current_object[current_stack_depth++] = obj;

1102

1103

1104

static void

1105

_push_operand (enum operand_type t, const void *ptr)

1106

1107

    _push_object(_get_object(t, ptr));

1108

1109

1110

static void

1111

_object_remove (Object *obj)

1112

1113

    if (obj->operand != -1) {

1114

	ensure_operands (1);

1115

	if (obj->operand == current_stack_depth - 1) {

1116

	    _trace_printf ("pop %% %s%ld destroyed\n",

1117

			   obj->type->op_code, obj->token);

1118

	} else if (obj->operand == current_stack_depth - 2) {

1119

	    _exch_operands ();

1120

	    _trace_printf ("exch pop %% %s%ld destroyed\n",

1121

			   obj->type->op_code, obj->token);

1122

	} else {

1123

	    int n;

1124

1125

	    _trace_printf ("%d -1 roll pop %% %s%ld destroyed\n",

1126

			   current_stack_depth - obj->operand,

1127

			   obj->type->op_code, obj->token);

1128

1129

	    for (n = obj->operand; n < current_stack_depth - 1; n++) {

1130

		current_object[n] = current_object[n+1];

1131

		current_object[n]->operand = n;

1132

1133

1134

	obj->operand = -1;

1135

1136

	current_stack_depth--;

1137

	dump_stack(__func__);

1138

1139

1140

1141

static void

1142

_object_undef (void *ptr)

1143

1144

    Object *obj = ptr;

1145

1146

    if (_write_lock ()) {

1147

	_object_remove (obj);

1148

1149

	if (obj->defined) {

1150

	    _trace_printf ("/%s%ld undef\n",

1151

			   obj->type->op_code, obj->token);

1152

1153

1154

	_write_unlock ();

1155

1156

1157

    _object_destroy (obj);

1158

1159

1160

static long

1161

_create_context_id (cairo_t *cr)

1162

1163

    Object *obj;

1164

1165

    obj = _get_object (CONTEXT, cr);

1166

    if (obj == NULL) {

1167

	obj = _type_object_create (CONTEXT, cr);

1168

	DLCALL (cairo_set_user_data,

1169

		cr, &destroy_key, obj, _object_undef);

1170

1171

1172

    return obj->token;

1173

1174

1175

static long

1176

_get_id (enum operand_type op_type, const void *ptr)

1177

1178

    Object *obj;

1179

1180

    obj = _get_object (op_type, ptr);

1181

    if (obj == NULL) {

1182

	if (logfile != NULL) {

1183

	    _trace_printf ("%% Unknown object of type %s, trace is incomplete.",

1184

			   _get_type (op_type)->name);

1185

1186

	_error = TRUE;

1187

	return -1;

1188

1189

1190

    return obj->token;

1191

1192

1193

static cairo_bool_t

1194

_has_id (enum operand_type op_type, const void *ptr)

1195

1196

    return _get_object (op_type, ptr) != NULL;

1197

1198

1199

static long

1200

_create_font_face_id (cairo_font_face_t *font_face)

1201

1202

    Object *obj;

1203

1204

    obj = _get_object (FONT_FACE, font_face);

1205

    if (obj == NULL) {

1206

	obj = _type_object_create (FONT_FACE, font_face);

1207

	DLCALL (cairo_font_face_set_user_data,

1208

		font_face, &destroy_key, obj, _object_undef);

1209

1210

1211

    return obj->token;

1212

1213

1214

static long

1215

_get_font_face_id (cairo_font_face_t *font_face)

1216

1217

    return _get_id (FONT_FACE, font_face);

1218

1219

1220

static void

1221

_emit_font_face_id (cairo_font_face_t *font_face)

1222

1223

    Object *obj = _get_object (FONT_FACE, font_face);

1224

    if (obj == NULL) {

1225

	_trace_printf ("null ");

1226

    } else {

1227

	if (obj->defined) {

1228

	    _trace_printf ("f%ld ", obj->token);

1229

	} else {

1230

	    _trace_printf ("%d index ", current_stack_depth - obj->operand - 1);

1231

1232

1233

1234

1235

static cairo_bool_t

1236

_has_pattern_id (cairo_pattern_t *pattern)

1237

1238

    return _has_id (PATTERN, pattern);

1239

1240

1241

static long

1242

_create_pattern_id (cairo_pattern_t *pattern)

1243

1244

    Object *obj;

1245

1246

    obj = _get_object (PATTERN, pattern);

1247

    if (obj == NULL) {

1248

	obj = _type_object_create (PATTERN, pattern);

1249

	DLCALL (cairo_pattern_set_user_data,

1250

		pattern, &destroy_key, obj, _object_undef);

1251

1252

1253

    return obj->token;

1254

1255

1256

static void

1257

_emit_pattern_id (cairo_pattern_t *pattern)

1258

1259

    Object *obj = _get_object (PATTERN, pattern);

1260

    if (obj == NULL) {

1261

	_trace_printf ("null ");

1262

    } else {

1263

	if (obj->defined) {

1264

	    _trace_printf ("p%ld ", obj->token);

1265

	} else {

1266

	    _trace_printf ("%d index ",

1267

			   current_stack_depth - obj->operand - 1);

1268

1269

1270

1271

1272

static void

1273

_emit_scaled_font_id (const cairo_scaled_font_t *scaled_font)

1274

1275

    Object *obj = _get_object (SCALED_FONT, scaled_font);

1276

    if (obj == NULL) {

1277

	_trace_printf ("null ");

1278

    } else {

1279

	if (obj->defined) {

1280

	    _trace_printf ("sf%ld ", obj->token);

1281

	} else {

1282

	    _trace_printf ("%d index ",

1283

		     current_stack_depth - obj->operand - 1);

1284

1285

1286

1287

1288

static long

1289

_create_scaled_font_id (cairo_scaled_font_t *font)

1290

1291

    Object *obj;

1292

1293

    assert(_get_object (SCALED_FONT, font) == NULL);

1294

    obj = _type_object_create (SCALED_FONT, font);

1295

    DLCALL (cairo_scaled_font_set_user_data,

1296

	    font, &destroy_key, obj, _object_undef);

1297

1298

    return obj->token;

1299

1300

1301

static cairo_bool_t

1302

_has_scaled_font_id (const cairo_scaled_font_t *font)

1303

1304

    return _has_id (SCALED_FONT, font);

1305

1306

1307

static Object *

1308

_create_surface (cairo_surface_t *surface)

1309

1310

    Object *obj;

1311

1312

    obj = _get_object (SURFACE, surface);

1313

    if (obj == NULL) {

1314

	obj = _type_object_create (SURFACE, surface);

1315

	DLCALL (cairo_surface_set_user_data,

1316

		surface, &destroy_key, obj, _object_undef);

1317

1318

1319

    return obj;

1320

1321

1322

static long

1323

_get_surface_id (cairo_surface_t *surface)

1324

1325

    return _get_id (SURFACE, surface);

1326

1327

1328

static cairo_bool_t

1329

_matrix_is_identity (const cairo_matrix_t *m)

1330

1331

    return m->xx == 1. && m->yx == 0. &&

1332

	   m->xy == 0. && m->yy == 1. &&

1333

	   m->x0 == 0. && m->y0 == 0.;

1334

1335

1336

#define BUFFER_SIZE 16384

1337

struct _data_stream {

1338

    z_stream zlib_stream;

1339

    unsigned char zin_buf[BUFFER_SIZE];

1340

    unsigned char zout_buf[BUFFER_SIZE];

1341

    unsigned char four_tuple[4];

1342

    int base85_pending;

1343

};

1344

1345

static void

1346

_write_zlib_data_start (struct _data_stream *stream)

1347

1348

    stream->zlib_stream.zalloc = Z_NULL;

1349

    stream->zlib_stream.zfree  = Z_NULL;

1350

    stream->zlib_stream.opaque  = Z_NULL;

1351

1352

    deflateInit (&stream->zlib_stream, Z_DEFAULT_COMPRESSION);

1353

1354

    stream->zlib_stream.next_in = stream->zin_buf;

1355

    stream->zlib_stream.avail_in = 0;

1356

    stream->zlib_stream.next_out = stream->zout_buf;

1357

    stream->zlib_stream.avail_out = BUFFER_SIZE;

1358

1359

1360

static void

1361

_write_base85_data_start (struct _data_stream *stream)

1362

1363

    stream->base85_pending = 0;

1364

1365

1366

static cairo_bool_t

1367

_expand_four_tuple_to_five (unsigned char four_tuple[4],

1368

			    unsigned char five_tuple[5])

1369

1370

    uint32_t value;

1371

    int digit, i;

1372

    cairo_bool_t all_zero = TRUE;

1373

1374

    value = four_tuple[0] << 24 |

1375

	    four_tuple[1] << 16 |

1376

	    four_tuple[2] << 8  |

1377

	    four_tuple[3] << 0;

1378

    for (i = 0; i < 5; i++) {

1379

	digit = value % 85;

1380

	if (digit != 0 && all_zero)

1381

	    all_zero = FALSE;

1382

	five_tuple[4-i] = digit + 33;

1383

	value = value / 85;

1384

1385

1386

    return all_zero;

1387

1388

1389

static void

1390

_write_base85_data (struct _data_stream *stream,

1391

		    const unsigned char	  *data,

1392

		    unsigned long	   length)

1393

1394

    unsigned char five_tuple[5];

1395

    int ret;

1396

1397

    assert (_should_trace ());

1398

1399

    while (length--) {

1400

	stream->four_tuple[stream->base85_pending++] = *data++;

1401

	if (stream->base85_pending == 4) {

1402

	    if (_expand_four_tuple_to_five (stream->four_tuple, five_tuple))

1403

		ret = fwrite ("z", 1, 1, logfile);

1404

	    else

1405

		ret = fwrite (five_tuple, 5, 1, logfile);

1406

	    (void)ret;

1407

	    stream->base85_pending = 0;

1408

1409

1410

1411

1412

static void

1413

_write_zlib_data (struct _data_stream *stream, cairo_bool_t flush)

1414

1415

    cairo_bool_t finished;

1416

1417

    do {

1418

	int ret = deflate (&stream->zlib_stream, flush ? Z_FINISH : Z_NO_FLUSH);

1419

	if (flush || stream->zlib_stream.avail_out == 0) {

1420

	    _write_base85_data (stream,

1421

				stream->zout_buf,

1422

				BUFFER_SIZE - stream->zlib_stream.avail_out);

1423

	    stream->zlib_stream.next_out = stream->zout_buf;

1424

	    stream->zlib_stream.avail_out = BUFFER_SIZE;

1425

1426

1427

	finished = TRUE;

1428

	if (stream->zlib_stream.avail_in != 0)

1429

	    finished = FALSE;

1430

	if (flush && ret != Z_STREAM_END)

1431

	    finished = FALSE;

1432

    } while (! finished);

1433

1434

    stream->zlib_stream.next_in = stream->zin_buf;

1435

1436

1437

static void

1438

_write_data_start (struct _data_stream *stream, uint32_t len)

1439

1440

    _write_zlib_data_start (stream);

1441

    _write_base85_data_start (stream);

1442

1443

    _trace_printf ("<|");

1444

    len = to_be32 (len);

1445

    _write_base85_data (stream, (unsigned char *) &len, sizeof (len));

1446

1447

1448

static void

1449

_write_data (struct _data_stream *stream,

1450

	     const void *data,

1451

	     unsigned int length)

1452

1453

    unsigned int count;

1454

    const unsigned char *p = data;

1455

1456

    while (length) {

1457

	count = length;

1458

	if (count > BUFFER_SIZE - stream->zlib_stream.avail_in)

1459

	    count = BUFFER_SIZE - stream->zlib_stream.avail_in;

1460

	memcpy (stream->zin_buf + stream->zlib_stream.avail_in, p, count);

1461

	p += count;

1462

	stream->zlib_stream.avail_in += count;

1463

	length -= count;

1464

1465

	if (stream->zlib_stream.avail_in == BUFFER_SIZE)

1466

	    _write_zlib_data (stream, FALSE);

1467

1468

1469

1470

static void

1471

_write_zlib_data_end (struct _data_stream *stream)

1472

1473

    _write_zlib_data (stream, TRUE);

1474

    deflateEnd (&stream->zlib_stream);

1475

1476

1477

1478

static void

1479

_write_base85_data_end (struct _data_stream *stream)

1480

1481

    unsigned char five_tuple[5];

1482

    int ret;

1483

1484

    assert (_should_trace ());

1485

1486

    if (stream->base85_pending) {

1487

	memset (stream->four_tuple + stream->base85_pending,

1488

		0, 4 - stream->base85_pending);

1489

	_expand_four_tuple_to_five (stream->four_tuple, five_tuple);

1490

	ret = fwrite (five_tuple, stream->base85_pending+1, 1, logfile);

1491

	(void) ret;

1492

1493

1494

1495

static void

1496

_write_data_end (struct _data_stream *stream)

1497

1498

    _write_zlib_data_end (stream);

1499

    _write_base85_data_end (stream);

1500

1501

    _trace_printf ("~>");

1502

1503

1504

static void

1505

_emit_data (const void *data, unsigned int length)

1506

1507

    struct _data_stream stream;

1508

1509

    _write_data_start (&stream, length);

1510

    _write_data (&stream, data, length);

1511

    _write_data_end (&stream);

1512

1513

1514

static const char *

1515

_format_to_string (cairo_format_t format)

1516

1517

#define f(name) case CAIRO_FORMAT_ ## name: return #name

1518

    switch (format) {

1519

	f(INVALID);

1520

	f(RGBA128F);

1521

	f(RGB96F);

1522

	f(ARGB32);

1523

	f(RGB30);

1524

	f(RGB24);

1525

	f(RGB16_565);

1526

	f(A8);

1527

	f(A1);

1528

1529

#undef f

1530

    return "UNKNOWN_FORMAT";

1531

1532

1533

static const char *

1534

_format_to_content_string (cairo_format_t format)

1535

1536

    switch (format) {

1537

    case CAIRO_FORMAT_INVALID:

1538

	return "INVALID";

1539

    case CAIRO_FORMAT_RGBA128F:

1540

    case CAIRO_FORMAT_ARGB32:

1541

	return "COLOR_ALPHA";

1542

    case CAIRO_FORMAT_RGB96F:

1543

    case CAIRO_FORMAT_RGB30:

1544

    case CAIRO_FORMAT_RGB24:

1545

    case CAIRO_FORMAT_RGB16_565:

1546

	return "COLOR";

1547

    case CAIRO_FORMAT_A8:

1548

    case CAIRO_FORMAT_A1:

1549

	return "ALPHA";

1550

1551

    return "UNKNOWN";

1552

1553

1554

static const char *

1555

_status_to_string (cairo_status_t status)

1556

1557

#define f(name) case CAIRO_STATUS_ ## name: return "STATUS_" #name

1558

    switch (status) {

1559

	f(SUCCESS);

1560

	f(NO_MEMORY);

1561

	f(INVALID_RESTORE);

1562

	f(INVALID_POP_GROUP);

1563

	f(NO_CURRENT_POINT);

1564

	f(INVALID_MATRIX);

1565

	f(INVALID_STATUS);

1566

	f(NULL_POINTER);

1567

	f(INVALID_STRING);

1568

	f(INVALID_PATH_DATA);

1569

	f(READ_ERROR);

1570

	f(WRITE_ERROR);

1571

	f(SURFACE_FINISHED);

1572

	f(SURFACE_TYPE_MISMATCH);

1573

	f(PATTERN_TYPE_MISMATCH);

1574

	f(INVALID_CONTENT);

1575

	f(INVALID_FORMAT);

1576

	f(INVALID_VISUAL);

1577

	f(FILE_NOT_FOUND);

1578

	f(INVALID_DASH);

1579

	f(INVALID_DSC_COMMENT);

1580

	f(INVALID_INDEX);

1581

	f(CLIP_NOT_REPRESENTABLE);

1582

	f(TEMP_FILE_ERROR);

1583

	f(INVALID_STRIDE);

1584

	f(FONT_TYPE_MISMATCH);

1585

	f(USER_FONT_IMMUTABLE);

1586

	f(USER_FONT_ERROR);

1587

	f(NEGATIVE_COUNT);

1588

	f(INVALID_CLUSTERS);

1589

	f(INVALID_SLANT);

1590

	f(INVALID_WEIGHT);

1591

	f(INVALID_SIZE);

1592

	f(USER_FONT_NOT_IMPLEMENTED);

1593

	f(DEVICE_TYPE_MISMATCH);

1594

	f(DEVICE_ERROR);

1595

	f(INVALID_MESH_CONSTRUCTION);

1596

	f(DEVICE_FINISHED);

1597

	f(JBIG2_GLOBAL_MISSING);

1598

	f(PNG_ERROR);

1599

	f(FREETYPE_ERROR);

1600

	f(WIN32_GDI_ERROR);

1601

	f(TAG_ERROR);

1602

	f(DWRITE_ERROR);

1603

	f(SVG_FONT_ERROR);

1604

    case CAIRO_STATUS_LAST_STATUS:

1605

	break;

1606

1607

    return "UNKNOWN_STATUS";

1608

#undef f

1609

1610

1611

static void CAIRO_PRINTF_FORMAT(2, 3)

1612

_emit_image (cairo_surface_t *image,

1613

	     const char *info,

1614

	     ...)

1615

1616

    int stride, row, width, height;

1617

    uint32_t len;

1618

    cairo_format_t format;

1619

    uint8_t row_stack[BUFFER_SIZE];

1620

    uint8_t *rowdata;

1621

    uint8_t *data;

1622

    struct _data_stream stream;

1623

    cairo_status_t status;

1624

1625

    status = DLCALL (cairo_surface_status, image);

1626

    if (status) {

1627

	_trace_printf ("<< /status //%s >> image",

1628

		       _status_to_string (status));

1629

	return;

1630

1631

1632

    width = DLCALL (cairo_image_surface_get_width, image);

1633

    height = DLCALL (cairo_image_surface_get_height, image);

1634

    stride = DLCALL (cairo_image_surface_get_stride, image);

1635

    format = DLCALL (cairo_image_surface_get_format, image);

1636

    data = DLCALL (cairo_image_surface_get_data, image);

1637

1638

    _trace_printf ("dict\n"

1639

		   "  /width %d set\n"

1640

		   "  /height %d set\n"

1641

		   "  /format //%s set\n",

1642

		   width, height,

1643

		   _format_to_string (format));

1644

    if (info != NULL) {

1645

	va_list ap;

1646

1647

	va_start (ap, info);

1648

	_trace_vprintf (info, ap);

1649

	va_end (ap);

1650

1651

1652

    if (DLCALL (cairo_version) >= CAIRO_VERSION_ENCODE (1, 9, 0)) {

1653

	const char *mime_types[] = {

1654

	    CAIRO_MIME_TYPE_JPEG,

1655

	    CAIRO_MIME_TYPE_JP2,

1656

	    CAIRO_MIME_TYPE_PNG,

1657

	    NULL

1658

	}, **mime_type;

1659

1660

	for (mime_type = mime_types; *mime_type; mime_type++) {

1661

	    const unsigned char *mime_data;

1662

	    unsigned long mime_length;

1663

1664

	    DLCALL (cairo_surface_get_mime_data,

1665

		    image, *mime_type, &mime_data, &mime_length);

1666

	    if (mime_data != NULL) {

1667

		_trace_printf ("  /mime-type (%s) set\n"

1668

			       "  /source <~",

1669

			       *mime_type);

1670

		_write_base85_data_start (&stream);

1671

		_write_base85_data (&stream, mime_data, mime_length);

1672

		_write_base85_data_end (&stream);

1673

		_trace_printf ("~> set\n"

1674

			       "  image");

1675

		return;

1676

1677

1678

1679

1680

    switch (format) {

1681

    case CAIRO_FORMAT_A1:        len = (width + 7)/8; break;

1682

    case CAIRO_FORMAT_A8:        len =  width; break;

1683

    case CAIRO_FORMAT_RGB16_565: len = 2*width; break;

1684

    case CAIRO_FORMAT_RGB24:     len = 3*width; break;

1685

    default:

1686

    case CAIRO_FORMAT_RGB30:

1687

    case CAIRO_FORMAT_INVALID:

1688

    case CAIRO_FORMAT_ARGB32: len = 4*width; break;

1689

    case CAIRO_FORMAT_RGB96F: len = 12*width; break;

1690

    case CAIRO_FORMAT_RGBA128F: len = 16*width; break;

1691

1692

1693

    _trace_printf ("  /source ");

1694

    _write_data_start (&stream, len * height);

1695

1696

#ifdef WORDS_BIGENDIAN

1697

    switch (format) {

1698

    case CAIRO_FORMAT_RGB24:

1699

	for (row = height; row--; ) {

1700

	    int col;

1701

	    rowdata = data;

1702

	    for (col = width; col--; ) {

1703

		_write_data (&stream, rowdata, 3);

1704

		rowdata+=4;

1705

1706

	    data += stride;

1707

1708

	break;

1709

    case CAIRO_FORMAT_A1:

1710

    case CAIRO_FORMAT_A8:

1711

    case CAIRO_FORMAT_RGB16_565:

1712

    case CAIRO_FORMAT_RGB30:

1713

    case CAIRO_FORMAT_ARGB32:

1714

    case CAIRO_FORMAT_RGB96F:

1715

    case CAIRO_FORMAT_RGBA128F:

1716

	for (row = height; row--; ) {

1717

	    _write_data (&stream, data, len);

1718

	    data += stride;

1719

1720

	break;

1721

    case CAIRO_FORMAT_INVALID:

1722

    default:

1723

	break;

1724

1725

#else

1726

    if (stride > ARRAY_LENGTH (row_stack)) {

1727

	rowdata = malloc (stride);

1728

	if (rowdata == NULL)

1729

	    goto BAIL;

1730

    } else

1731

	rowdata = row_stack;

1732

1733

    switch (format) {

1734

    case CAIRO_FORMAT_A1:

1735

	for (row = height; row--; ) {

1736

	    int col;

1737

	    for (col = 0; col < (width + 7)/8; col++)

1738

		rowdata[col] = CAIRO_BITSWAP8 (data[col]);

1739

	    _write_data (&stream, rowdata, (width+7)/8);

1740

	    data += stride;

1741

1742

	break;

1743

    case CAIRO_FORMAT_A8:

1744

	for (row = height; row--; ) {

1745

	    _write_data (&stream, data, width);

1746

	    data += stride;

1747

1748

	break;

1749

    case CAIRO_FORMAT_RGB16_565: /* XXX endianness */

1750

	for (row = height; row--; ) {

1751

	    uint16_t *src = (uint16_t *) data;

1752

	    uint16_t *dst = (uint16_t *)rowdata;

1753

	    int col;

1754

	    for (col = 0; col < width; col++)

1755

		dst[col] = bswap_16 (src[col]);

1756

	    _write_data (&stream, rowdata, 2*width);

1757

	    data += stride;

1758

1759

	break;

1760

    case CAIRO_FORMAT_RGB24:

1761

	for (row = height; row--; ) {

1762

	    uint8_t *src = data;

1763

	    int col;

1764

	    for (col = 0; col < width; col++) {

1765

		rowdata[3*col+2] = *src++;

1766

		rowdata[3*col+1] = *src++;

1767

		rowdata[3*col+0] = *src++;

1768

		src++;

1769

1770

	    _write_data (&stream, rowdata, 3*width);

1771

	    data += stride;

1772

1773

	break;

1774

    case CAIRO_FORMAT_RGB96F:

1775

    case CAIRO_FORMAT_RGBA128F:

1776

    case CAIRO_FORMAT_RGB30:

1777

    case CAIRO_FORMAT_ARGB32:

1778

	for (row = height; row--; ) {

1779

	    uint32_t *src = (uint32_t *) data;

1780

	    uint32_t *dst = (uint32_t *) rowdata;

1781

	    int col;

1782

	    for (col = 0; col < width; col++)

1783

		dst[col] = bswap_32 (src[col]);

1784

	    _write_data (&stream, rowdata, len);

1785

	    data += stride;

1786

1787

	break;

1788

   case CAIRO_FORMAT_INVALID:

1789

    default:

1790

	break;

1791

1792

    if (rowdata != row_stack)

1793

	free (rowdata);

1794

1795

BAIL:

1796

    _write_data_end (&stream);

1797

#endif

1798

    _trace_printf (" set\n  image");

1799

1800

1801

static void

1802

_encode_string_literal (char *out, int max,

1803

			const char *utf8, int len)

1804

1805

    char c;

1806

    const char *end;

1807

1808

    *out++ = '(';

1809

    max--;

1810

1811

    if (utf8 == NULL)

1812

	goto DONE;

1813

1814

    if (len < 0)

1815

	len = strlen (utf8);

1816

    end = utf8 + len;

1817

1818

    while (utf8 < end) {

1819

	if (max < 5)

1820

	    break;

1821

1822

	switch ((c = *utf8++)) {

1823

	case '\n':

1824

	    *out++ = '\\';

1825

	    *out++ = 'n';

1826

	    max -= 2;

1827

	    break;

1828

	case '\r':

1829

	    *out++ = '\\';

1830

	    *out++ = 'r';

1831

	    max -= 2;

1832

	    break;

1833

	case '\t':

1834

	    *out++ = '\\';

1835

	    *out++ = 't';

1836

	    max -= 2;

1837

	    break;

1838

	case '\b':

1839

	    *out++ = '\\';

1840

	    *out++ = 'b';

1841

	    max -= 2;

1842

	    break;

1843

	case '\f':

1844

	    *out++ = '\\';

1845

	    *out++ = 'f';

1846

	    max -= 2;

1847

	    break;

1848

	case '\\':

1849

	case '(':

1850

	case ')':

1851

	    *out++ = '\\';

1852

	    *out++ = c;

1853

	    max -= 2;

1854

	    break;

1855

	default:

1856

	    if (_cairo_isprint (c)) {

1857

		*out++ = c;

1858

	    } else {

1859

		int octal = 0;

1860

		while (c) {

1861

		    octal *= 10;

1862

		    octal += c&7;

1863

		    c /= 8;

1864

1865

		octal = snprintf (out, max, "\\%03d", octal);

1866

		out += octal;

1867

		max -= octal;

1868

1869

	    break;

1870

1871

1872

DONE:

1873

    *out++ = ')';

1874

    *out = '\0';

1875

1876

1877

static void

1878

to_octal (int value, char *buf, size_t size)

1879

1880

    do {

1881

	buf[--size] = '0' + (value & 7);

1882

	value >>= 3;

1883

    } while (size);

1884

1885

1886

static void

1887

_emit_string_literal (const char *utf8, int len)

1888

1889

    char c;

1890

    const char *end;

1891

1892

    if (utf8 == NULL) {

1893

	_trace_printf ("()");

1894

	return;

1895

1896

1897

    if (len < 0)

1898

	len = strlen (utf8);

1899

    end = utf8 + len;

1900

1901

    _trace_printf ("(");

1902

    while (utf8 < end) {

1903

	switch ((c = *utf8++)) {

1904

	case '\n':

1905

	    c = 'n';

1906

	    goto ESCAPED_CHAR;

1907

	case '\r':

1908

	    c = 'r';

1909

	    goto ESCAPED_CHAR;

1910

	case '\t':

1911

	    c = 't';

1912

	    goto ESCAPED_CHAR;

1913

	case '\b':

1914

	    c = 'b';

1915

	    goto ESCAPED_CHAR;

1916

	case '\f':

1917

	    c = 'f';

1918

	    goto ESCAPED_CHAR;

1919

	case '\\':

1920

	case '(':

1921

	case ')':

1922

ESCAPED_CHAR:

1923

	    _trace_printf ("\\%c", c);

1924

	    break;

1925

	default:

1926

	    if (_cairo_isprint (c)) {

1927

		_trace_printf ("%c", c);

1928

	    } else {

1929

		char buf[4] = { '\\' };

1930

		int ret_ignored;

1931

1932

		to_octal (c, buf+1, 3);

1933

		ret_ignored = fwrite (buf, 4, 1, logfile);

1934

		(void)ret_ignored;

1935

1936

	    break;

1937

1938

1939

    _trace_printf (")");

1940

1941

1942

static void

1943

_emit_current (Object *obj)

1944

1945

    if (obj != NULL && ! _pop_operands_to_object (obj)) {

1946

	if (obj->operand != -1) {

1947

	    int n;

1948

1949

	    _trace_printf ("%d -1 roll %% %s%ld\n",

1950

			   current_stack_depth - obj->operand,

1951

			   obj->type->op_code, obj->token);

1952

1953

	    for (n = obj->operand; n < current_stack_depth - 1; n++) {

1954

		current_object[n] = current_object[n+1];

1955

		current_object[n]->operand = n;

1956

1957

	    obj->operand = -1;

1958

	    current_stack_depth--;

1959

	} else {

1960

	    assert(obj->defined);

1961

	    _trace_printf ("%s%ld\n", obj->type->op_code, obj->token);

1962

1963

1964

	_push_object (obj);

1965

	dump_stack(__func__);

1966

1967

1968

1969

static void

1970

_emit_context (cairo_t *cr)

1971

1972

    _emit_current (_get_object (CONTEXT, cr));

1973

1974

1975

static void

1976

_emit_pattern (cairo_pattern_t *pattern)

1977

1978

    _emit_current (_get_object (PATTERN, pattern));

1979

1980

1981

static void

1982

_emit_surface (cairo_surface_t *surface)

1983

1984

    _emit_current (_get_object (SURFACE, surface));

1985

1986

1987

static void CAIRO_PRINTF_FORMAT(2, 3)

1988

_emit_cairo_op (cairo_t *cr, const char *fmt, ...)

1989

1990

    va_list ap;

1991

1992

    if (cr == NULL || ! _write_lock ())

1993

	return;

1994

1995

    _emit_context (cr);

1996

1997

    va_start (ap, fmt);

1998

    _trace_vprintf ( fmt, ap);

1999

    va_end (ap);

2000

2001

    _write_unlock ();

2002

2003

2004

cairo_t *

2005

cairo_create (cairo_surface_t *target)

2006

2007

    cairo_t *ret;

2008

    long surface_id;

2009

    long context_id;

2010

2011

    _enter_trace ();

2012

2013

    ret = DLCALL (cairo_create, target);

2014

    context_id = _create_context_id (ret);

2015

2016

    _emit_line_info ();

2017

    if (target != NULL && _write_lock ()) {

2018

	surface_id = _get_surface_id (target);

2019

	if (surface_id != -1) {

2020

	    _get_object (SURFACE, target)->foreign = FALSE;

2021

2022

	    /* we presume that we will continue to use the context */

2023

	    if (_pop_operands_to (SURFACE, target)){

2024

		_consume_operand (false);

2025

	    } else {

2026

		_trace_printf ("s%ld ", surface_id);

2027

2028

	    _trace_printf ("context %% c%ld\n", context_id);

2029

	    _push_operand (CONTEXT, ret);

2030

	    dump_stack(__func__);

2031

2032

	_write_unlock ();

2033

2034

2035

    _exit_trace ();

2036

    return ret;

2037

2038

2039

void

2040

cairo_save (cairo_t *cr)

2041

2042

    _enter_trace ();

2043

    _emit_line_info ();

2044

    _emit_cairo_op (cr, "save\n");

2045

    DLCALL (cairo_save, cr);

2046

    _exit_trace ();

2047

2048

2049

void

2050

cairo_restore (cairo_t *cr)

2051

2052

    _enter_trace ();

2053

    _emit_line_info ();

2054

    _emit_cairo_op (cr, "restore\n");

2055

    DLCALL (cairo_restore, cr);

2056

    _exit_trace ();

2057

2058

2059

void

2060

cairo_push_group (cairo_t *cr)

2061

2062

    _enter_trace ();

2063

    _emit_line_info ();

2064

    _emit_cairo_op (cr, "//COLOR_ALPHA push-group\n");

2065

    DLCALL (cairo_push_group, cr);

2066

    _exit_trace ();

2067

2068

2069

static const char *

2070

_content_to_string (cairo_content_t content)

2071

2072

    switch (content) {

2073

    case CAIRO_CONTENT_ALPHA: return "ALPHA";

2074

    case CAIRO_CONTENT_COLOR: return "COLOR";

2075

    default:

2076

    case CAIRO_CONTENT_COLOR_ALPHA: return "COLOR_ALPHA";

2077

2078

2079

2080

void

2081

cairo_push_group_with_content (cairo_t *cr, cairo_content_t content)

2082

2083

    _enter_trace ();

2084

    _emit_line_info ();

2085

    _emit_cairo_op (cr, "//%s push-group\n", _content_to_string (content));

2086

    DLCALL (cairo_push_group_with_content, cr, content);

2087

    _exit_trace ();

2088

2089

2090

cairo_pattern_t *

2091

cairo_pop_group (cairo_t *cr)

2092

2093

    cairo_pattern_t *ret;

2094

2095

    _enter_trace ();

2096

2097

    ret = DLCALL (cairo_pop_group, cr);

2098

2099

    _emit_line_info ();

2100

    _emit_cairo_op (cr, "pop-group %% p%ld\n", _create_pattern_id (ret));

2101

    _push_operand (PATTERN, ret);

2102

    dump_stack(__func__);

2103

2104

    _exit_trace ();

2105

    return ret;

2106

2107

2108

void

2109

cairo_pop_group_to_source (cairo_t *cr)

2110

2111

    _enter_trace ();

2112

    _emit_line_info ();

2113

    _emit_cairo_op (cr, "pop-group set-source\n");

2114

    DLCALL (cairo_pop_group_to_source, cr);

2115

    _exit_trace ();

2116

2117

2118

static const char *

2119

_operator_to_string (cairo_operator_t op)

2120

2121

#define f(name) case CAIRO_OPERATOR_ ## name: return #name

2122

    switch (op) {

2123

	f(OVER);

2124

	f(SOURCE);

2125

	f(CLEAR);

2126

	f(IN);

2127

	f(OUT);

2128

	f(ATOP);

2129

	f(DEST);

2130

	f(DEST_OVER);

2131

	f(DEST_IN);

2132

	f(DEST_OUT);

2133

	f(DEST_ATOP);

2134

	f(XOR);

2135

	f(ADD);

2136

	f(SATURATE);

2137

	f(MULTIPLY);

2138

	f(SCREEN);

2139

	f(OVERLAY);

2140

	f(DARKEN);

2141

	f(LIGHTEN);

2142

        case CAIRO_OPERATOR_COLOR_DODGE: return "DODGE";

2143

        case CAIRO_OPERATOR_COLOR_BURN: return "BURN";

2144

	f(HARD_LIGHT);

2145

	f(SOFT_LIGHT);

2146

	f(DIFFERENCE);

2147

	f(EXCLUSION);

2148

	f(HSL_HUE);

2149

	f(HSL_SATURATION);

2150

	f(HSL_COLOR);

2151

	f(HSL_LUMINOSITY);

2152

2153

#undef f

2154

    return "UNKNOWN_OPERATOR";

2155

2156

2157

void

2158

cairo_set_operator (cairo_t *cr, cairo_operator_t op)

2159

2160

    _enter_trace ();

2161

    _emit_line_info ();

2162

    _emit_cairo_op (cr, "//%s set-operator\n", _operator_to_string (op));

2163

    DLCALL (cairo_set_operator, cr, op);

2164

    _exit_trace ();

2165

2166

2167

void

2168

cairo_set_source_rgb (cairo_t *cr, double red, double green, double blue)

2169

2170

    _enter_trace ();

2171

    _emit_line_info ();

2172

    _emit_cairo_op (cr, "%g %g %g set-source-rgb\n", red, green, blue);

2173

    DLCALL (cairo_set_source_rgb, cr, red, green, blue);

2174

    _exit_trace ();

2175

2176

2177

void

2178

cairo_set_source_rgba (cairo_t *cr, double red, double green, double blue, double alpha)

2179

2180

    _enter_trace ();

2181

    _emit_line_info ();

2182

    _emit_cairo_op (cr, "%g %g %g %g set-source-rgba\n",

2183

		    red, green, blue, alpha);

2184

    DLCALL (cairo_set_source_rgba, cr, red, green, blue, alpha);

2185

    _exit_trace ();

2186

2187

2188

static void

2189

_emit_source_image (cairo_surface_t *surface)

2190

2191

    Object *obj;

2192

    cairo_surface_t *image;

2193

    cairo_t *cr;

2194

2195

    obj = _get_object (SURFACE, surface);

2196

    if (obj == NULL)

2197

	return;

2198

2199

    image = DLCALL (cairo_image_surface_create,

2200

		    CAIRO_FORMAT_ARGB32,

2201

		    obj->width,

2202

		    obj->height);

2203

    cr = DLCALL (cairo_create, image);

2204

    DLCALL (cairo_set_source_surface, cr, surface, 0, 0);

2205

    DLCALL (cairo_paint, cr);

2206

    DLCALL (cairo_destroy, cr);

2207

2208

    _emit_image (image, NULL);

2209

    _trace_printf (" set-source-image ");

2210

    DLCALL (cairo_surface_destroy, image);

2211

2212

    obj->foreign = FALSE;

2213

2214

2215

static void

2216

_emit_source_image_rectangle (cairo_surface_t *surface,

2217

			      int x, int y,

2218

			      int width, int height)

2219

2220

    Object *obj;

2221

    cairo_surface_t *image;

2222

    cairo_t *cr;

2223

2224

    obj = _get_object (SURFACE, surface);

2225

    if (obj == NULL)

2226

	return;

2227

2228

    if (obj->foreign) {

2229

	_emit_source_image (surface);

2230

	return;

2231

2232

2233

    image = DLCALL (cairo_image_surface_create,

2234

		    CAIRO_FORMAT_ARGB32,

2235

		    width,

2236

		    height);

2237

    cr = DLCALL (cairo_create, image);

2238

    DLCALL (cairo_set_source_surface, cr, surface, x, y);

2239

    DLCALL (cairo_paint, cr);

2240

    DLCALL (cairo_destroy, cr);

2241

2242

    _emit_image (image, NULL);

2243

    _trace_printf (" %d %d set-device-offset set-source-image ",

2244

	     x, y);

2245

    DLCALL (cairo_surface_destroy, image);

2246

2247

2248

void

2249

cairo_set_source_surface (cairo_t *cr, cairo_surface_t *surface, double x, double y)

2250

2251

    _enter_trace ();

2252

    _emit_line_info ();

2253

    if (cr != NULL && surface != NULL && _write_lock ()) {

2254

	Object *obj = _get_object (SURFACE, surface);

2255

2256

	if (_is_current (SURFACE, surface, 0) &&

2257

	    _is_current (CONTEXT, cr, 1))

2258

2259

	    _consume_operand (false);

2260

2261

	else if (_is_current (SURFACE, surface, 1) &&

2262

		 _is_current (CONTEXT, cr, 0) &&

2263

		 obj->defined)

2264

2265

	    _trace_printf ("exch ");

2266

	    _exch_operands ();

2267

	    _consume_operand (false);

2268

	} else if (obj->defined) {

2269

	    _emit_context (cr);

2270

	    _trace_printf ("s%ld ", obj->token);

2271

	} else {

2272

	    _emit_context (cr);

2273

	    _trace_printf ("%d index ",

2274

			   current_stack_depth - obj->operand - 1);

2275

2276

2277

	if (obj->foreign)

2278

	    _emit_source_image (surface);

2279

2280

	_trace_printf ("pattern");

2281

	if (x != 0. || y != 0.)

2282

	    _trace_printf (" %g %g translate", -x, -y);

2283

2284

	_trace_printf (" set-source\n");

2285

	_write_unlock ();

2286

2287

2288

    DLCALL (cairo_set_source_surface, cr, surface, x, y);

2289

    _exit_trace ();

2290

2291

2292

void

2293

cairo_set_source (cairo_t *cr, cairo_pattern_t *source)

2294

2295

    _enter_trace ();

2296

    _emit_line_info ();

2297

    if (cr != NULL && source != NULL && _write_lock ()) {

2298

	Object *obj = _get_object (PATTERN, source);

2299

	cairo_bool_t need_context_and_pattern = TRUE;

2300

2301

	if (_is_current (PATTERN, source, 0) &&

2302

	    _is_current (CONTEXT, cr, 1))

2303

2304

	    if (obj->defined) {

2305

		_consume_operand (false);

2306

	    } else {

2307

		_trace_printf ("exch 1 index ");

2308

		_exch_operands ();

2309

2310

	    need_context_and_pattern = FALSE;

2311

2312

	else if (_is_current (PATTERN, source, 1) &&

2313

		 _is_current (CONTEXT, cr, 0))

2314

2315

	    if (obj->defined) {

2316

		_trace_printf ("exch ");

2317

		_exch_operands ();

2318

		_consume_operand (false);

2319

		need_context_and_pattern = FALSE;

2320

2321

2322

2323

	if (need_context_and_pattern) {

2324

	    _emit_context (cr);

2325

	    _emit_pattern_id (source);

2326

2327

2328

	_trace_printf ("set-source %% p%ld\n", obj->token);

2329

	_write_unlock ();

2330

2331

2332

    DLCALL (cairo_set_source, cr, source);

2333

    _exit_trace ();

2334

2335

2336

cairo_pattern_t *

2337

cairo_get_source (cairo_t *cr)

2338

2339

    cairo_pattern_t *ret;

2340

2341

    _enter_trace ();

2342

2343

    ret = DLCALL (cairo_get_source, cr);

2344

2345

    if (! _has_pattern_id (ret)) {

2346

	_emit_cairo_op (cr, "/source get /p%ld exch def\n",

2347

			_create_pattern_id (ret));

2348

	_get_object (PATTERN, ret)->defined = TRUE;

2349

2350

2351

    _exit_trace ();

2352

    return ret;

2353

2354

2355

void

2356

cairo_set_tolerance (cairo_t *cr, double tolerance)

2357

2358

    _enter_trace ();

2359

    _emit_line_info ();

2360

    _emit_cairo_op (cr, "%g set-tolerance\n", tolerance);

2361

    DLCALL (cairo_set_tolerance, cr, tolerance);

2362

    _exit_trace ();

2363

2364

2365

static const char *

2366

_antialias_to_string (cairo_antialias_t antialias)

2367

2368

#define f(name) case CAIRO_ANTIALIAS_ ## name: return "ANTIALIAS_" #name

2369

    switch (antialias) {

2370

	f(DEFAULT);

2371

2372

	f(NONE);

2373

	f(GRAY);

2374

	f(SUBPIXEL);

2375

2376

	f(FAST);

2377

	f(GOOD);

2378

	f(BEST);

2379

};

2380

#undef f

2381

    return "UNKNOWN_ANTIALIAS";

2382

2383

2384

void

2385

cairo_set_antialias (cairo_t *cr, cairo_antialias_t antialias)

2386

2387

    _enter_trace ();

2388

    _emit_line_info ();

2389

    _emit_cairo_op (cr,

2390

		    "//%s set-antialias\n", _antialias_to_string (antialias));

2391

    DLCALL (cairo_set_antialias, cr, antialias);

2392

    _exit_trace ();

2393

2394

2395

static const char *

2396

_fill_rule_to_string (cairo_fill_rule_t rule)

2397

2398

#define f(name) case CAIRO_FILL_RULE_ ## name: return #name

2399

    switch (rule) {

2400

	f(WINDING);

2401

	f(EVEN_ODD);

2402

};

2403

#undef f

2404

    return "UNKNOWN_FILL_RULE";

2405

2406

2407

void

2408

cairo_set_fill_rule (cairo_t *cr, cairo_fill_rule_t fill_rule)

2409

2410

    _enter_trace ();

2411

    _emit_line_info ();

2412

    _emit_cairo_op (cr,

2413

		    "//%s set-fill-rule\n", _fill_rule_to_string (fill_rule));

2414

    DLCALL (cairo_set_fill_rule, cr, fill_rule);

2415

    _exit_trace ();

2416

2417

2418

void

2419

cairo_set_line_width (cairo_t *cr, double width)

2420

2421

    _enter_trace ();

2422

    _emit_line_info ();

2423

    _emit_cairo_op (cr, "%g set-line-width\n", width);

2424

    DLCALL (cairo_set_line_width, cr, width);

2425

    _exit_trace ();

2426

2427

2428

static const char *

2429

_line_cap_to_string (cairo_line_cap_t line_cap)

2430

2431

#define f(name) case CAIRO_LINE_CAP_ ## name: return "LINE_CAP_" #name

2432

    switch (line_cap) {

2433

	f(BUTT);

2434

	f(ROUND);

2435

	f(SQUARE);

2436

};

2437

#undef f

2438

    return "UNKNOWN_LINE_CAP";

2439

2440

2441

void

2442

cairo_set_line_cap (cairo_t *cr, cairo_line_cap_t line_cap)

2443

2444

    _enter_trace ();

2445

    _emit_line_info ();

2446

    _emit_cairo_op (cr, "//%s set-line-cap\n", _line_cap_to_string (line_cap));

2447

    DLCALL (cairo_set_line_cap, cr, line_cap);

2448

    _exit_trace ();

2449

2450

2451

static const char *

2452

_line_join_to_string (cairo_line_join_t line_join)

2453

2454

#define f(name) case CAIRO_LINE_JOIN_ ## name: return "LINE_JOIN_" #name

2455

    switch (line_join) {

2456

	f(MITER);

2457

	f(ROUND);

2458

	f(BEVEL);

2459

};

2460

#undef f

2461

    return "UNKNOWN_LINE_JOIN";

2462

2463

2464

void

2465

cairo_set_line_join (cairo_t *cr, cairo_line_join_t line_join)

2466

2467

    _enter_trace ();

2468

    _emit_line_info ();

2469

    _emit_cairo_op (cr,

2470

		    "//%s set-line-join\n", _line_join_to_string (line_join));

2471

    DLCALL (cairo_set_line_join, cr, line_join);

2472

    _exit_trace ();

2473

2474

2475

void

2476

cairo_set_dash (cairo_t *cr, const double *dashes, int num_dashes, double offset)

2477

2478

    _enter_trace ();

2479

    _emit_line_info ();

2480

    if (cr != NULL && _write_lock ()) {

2481

	int n;

2482

2483

	_emit_context (cr);

2484

2485

	_trace_printf ("[");

2486

	for (n = 0; n <  num_dashes; n++) {

2487

	    if (n != 0)

2488

		_trace_printf (" ");

2489

	    _trace_printf ("%g", dashes[n]);

2490

2491

	_trace_printf ("] %g set-dash\n", offset);

2492

2493

	_write_unlock ();

2494

2495

2496

    DLCALL (cairo_set_dash, cr, dashes, num_dashes, offset);

2497

    _exit_trace ();

2498

2499

2500

void

2501

cairo_set_miter_limit (cairo_t *cr, double limit)

2502

2503

    _enter_trace ();

2504

    _emit_line_info ();

2505

    _emit_cairo_op (cr, "%g set-miter-limit\n", limit);

2506

    DLCALL (cairo_set_miter_limit, cr, limit);

2507

    _exit_trace ();

2508

2509

2510

void

2511

cairo_translate (cairo_t *cr, double tx, double ty)

2512

2513

    _enter_trace ();

2514

    _emit_line_info ();

2515

    _emit_cairo_op (cr, "%g %g translate\n", tx, ty);

2516

    DLCALL (cairo_translate, cr, tx, ty);

2517

    _exit_trace ();

2518

2519

2520

void

2521

cairo_scale (cairo_t *cr, double sx, double sy)

2522

2523

    _enter_trace ();

2524

    _emit_line_info ();

2525

    _emit_cairo_op (cr, "%g %g scale\n", sx, sy);

2526

    DLCALL (cairo_scale, cr, sx, sy);

2527

    _exit_trace ();

2528

2529

2530

void

2531

cairo_rotate (cairo_t *cr, double angle)

2532

2533

    _enter_trace ();

2534

    _emit_line_info ();

2535

    _emit_cairo_op (cr, "%g rotate\n", angle);

2536

    DLCALL (cairo_rotate, cr, angle);

2537

    _exit_trace ();

2538

2539

2540

void

2541

cairo_transform (cairo_t *cr, const cairo_matrix_t *matrix)

2542

2543

    _enter_trace ();

2544

    _emit_line_info ();

2545

    _emit_cairo_op (cr, "%g %g %g %g %g %g matrix transform\n",

2546

		    matrix->xx, matrix->yx,

2547

		    matrix->xy, matrix->yy,

2548

		    matrix->x0, matrix->y0);

2549

    DLCALL (cairo_transform, cr, matrix);

2550

    _exit_trace ();

2551

2552

2553

void

2554

cairo_set_matrix (cairo_t *cr, const cairo_matrix_t *matrix)

2555

2556

    _enter_trace ();

2557

    _emit_line_info ();

2558

    if (_matrix_is_identity (matrix)) {

2559

	_emit_cairo_op (cr, "identity set-matrix\n");

2560

    } else {

2561

	_emit_cairo_op (cr, "%g %g %g %g %g %g matrix set-matrix\n",

2562

			matrix->xx, matrix->yx,

2563

			matrix->xy, matrix->yy,

2564

			matrix->x0, matrix->y0);

2565

2566

    DLCALL (cairo_set_matrix, cr, matrix);

2567

    _exit_trace ();

2568

2569

2570

cairo_surface_t *

2571

cairo_get_target (cairo_t *cr)

2572

2573

    cairo_surface_t *ret;

2574

2575

    _enter_trace ();

2576

2577

    ret = DLCALL (cairo_get_target, cr);

2578

    if (cr != NULL) {

2579

	Object *obj = _create_surface (ret);

2580

2581

	if (! obj->defined) {

2582

	    _emit_cairo_op (cr,

2583

			    "/target get /s%ld exch def\n",

2584

			    obj->token);

2585

	    obj->defined = TRUE;

2586

2587

2588

2589

    _exit_trace ();

2590

    return ret;

2591

2592

2593

cairo_surface_t *

2594

cairo_get_group_target (cairo_t *cr)

2595

2596

    cairo_surface_t *ret;

2597

2598

    _enter_trace ();

2599

2600

    ret = DLCALL (cairo_get_group_target, cr);

2601

    if (cr != NULL) {

2602

	Object *obj = _create_surface (ret);

2603

2604

	if (! obj->defined) {

2605

	    _emit_cairo_op (cr,

2606

			    "/group-target get /s%ld exch def\n",

2607

			    obj->token);

2608

	    obj->defined = TRUE;

2609

2610

2611

2612

    _exit_trace ();

2613

    return ret;

2614

2615

2616

void

2617

cairo_identity_matrix (cairo_t *cr)

2618

2619

    _enter_trace ();

2620

    _emit_line_info ();

2621

    _emit_cairo_op (cr, "identity set-matrix\n");

2622

    DLCALL (cairo_identity_matrix, cr);

2623

    _exit_trace ();

2624

2625

2626

void

2627

cairo_new_path (cairo_t *cr)

2628

2629

    _enter_trace ();

2630

    _emit_line_info ();

2631

    _emit_cairo_op (cr, "n ");

2632

    DLCALL (cairo_new_path, cr);

2633

    _exit_trace ();

2634

2635

2636

void

2637

cairo_move_to (cairo_t *cr, double x, double y)

2638

2639

    _enter_trace ();

2640

    _emit_cairo_op (cr, "%g %g m ", x, y);

2641

    DLCALL (cairo_move_to, cr, x, y);

2642

    _exit_trace ();

2643

2644

2645

void

2646

cairo_new_sub_path (cairo_t *cr)

2647

2648

    _enter_trace ();

2649

    _emit_cairo_op (cr, "N ");

2650

    DLCALL (cairo_new_sub_path, cr);

2651

    _exit_trace ();

2652

2653

2654

void

2655

cairo_line_to (cairo_t *cr, double x, double y)

2656

2657

    _enter_trace ();

2658

    _emit_cairo_op (cr, "%g %g l ", x, y);

2659

    DLCALL (cairo_line_to, cr, x, y);

2660

    _exit_trace ();

2661

2662

2663

void

2664

cairo_curve_to (cairo_t *cr, double x1, double y1, double x2, double y2, double x3, double y3)

2665

2666

    _enter_trace ();

2667

    _emit_cairo_op (cr, "%g %g %g %g %g %g c ", x1, y1, x2, y2, x3, y3);

2668

    DLCALL (cairo_curve_to, cr, x1, y1, x2, y2, x3, y3);

2669

    _exit_trace ();

2670

2671

2672

void

2673

cairo_arc (cairo_t *cr, double xc, double yc, double radius, double angle1, double angle2)

2674

2675

    _enter_trace ();

2676

    _emit_cairo_op (cr, "%g %g %g %g %g arc\n", xc, yc, radius, angle1, angle2);

2677

    DLCALL (cairo_arc, cr, xc, yc, radius, angle1, angle2);

2678

    _exit_trace ();

2679

2680

2681

void

2682

cairo_arc_negative (cairo_t *cr, double xc, double yc, double radius, double angle1, double angle2)

2683

2684

    _enter_trace ();

2685

    _emit_cairo_op (cr, "%g %g %g %g %g arc-\n",

2686

		    xc, yc, radius, angle1, angle2);

2687

    DLCALL (cairo_arc_negative, cr, xc, yc, radius, angle1, angle2);

2688

    _exit_trace ();

2689

2690

2691

void

2692

cairo_rel_move_to (cairo_t *cr, double dx, double dy)

2693

2694

    _enter_trace ();

2695

    _emit_cairo_op (cr, "%g %g M ", dx, dy);

2696

    DLCALL (cairo_rel_move_to, cr, dx, dy);

2697

    _exit_trace ();

2698

2699

2700

void

2701

cairo_rel_line_to (cairo_t *cr, double dx, double dy)

2702

2703

    _enter_trace ();

2704

    _emit_cairo_op (cr, "%g %g L ", dx, dy);

2705

    DLCALL (cairo_rel_line_to, cr, dx, dy);

2706

    _exit_trace ();

2707

2708

2709

void

2710

cairo_rel_curve_to (cairo_t *cr, double dx1, double dy1, double dx2, double dy2, double dx3, double dy3)

2711

2712

    _enter_trace ();

2713

    _emit_cairo_op (cr, "%g %g %g %g %g %g C ",

2714

		    dx1, dy1, dx2, dy2, dx3, dy3);

2715

    DLCALL (cairo_rel_curve_to, cr, dx1, dy1, dx2, dy2, dx3, dy3);

2716

    _exit_trace ();

2717

2718

2719

void

2720

cairo_rectangle (cairo_t *cr, double x, double y, double width, double height)

2721

2722

    _enter_trace ();

2723

    _emit_cairo_op (cr, "%g %g %g %g rectangle\n", x, y, width, height);

2724

    DLCALL (cairo_rectangle, cr, x, y, width, height);

2725

    _exit_trace ();

2726

2727

2728

void

2729

cairo_close_path (cairo_t *cr)

2730

2731

    _enter_trace ();

2732

    _emit_cairo_op (cr, "h\n");

2733

    DLCALL (cairo_close_path, cr);

2734

    _exit_trace ();

2735

2736

2737

void

2738

cairo_paint (cairo_t *cr)

2739

2740

    _enter_trace ();

2741

    _emit_line_info ();

2742

    _emit_cairo_op (cr, "paint\n");

2743

    DLCALL (cairo_paint, cr);

2744

    _exit_trace ();

2745

2746

2747

void

2748

cairo_paint_with_alpha (cairo_t *cr, double alpha)

2749

2750

    _enter_trace ();

2751

    _emit_line_info ();

2752

    _emit_cairo_op (cr, "%g paint-with-alpha\n", alpha);

2753

    DLCALL (cairo_paint_with_alpha, cr, alpha);

2754

    _exit_trace ();

2755

2756

2757

void

2758

cairo_mask (cairo_t *cr, cairo_pattern_t *pattern)

2759

2760

    _enter_trace ();

2761

    _emit_line_info ();

2762

    if (cr != NULL && pattern != NULL && _write_lock ()) {

2763

	Object *obj = _get_object (PATTERN, pattern);

2764

	cairo_bool_t need_context_and_pattern = TRUE;

2765

2766

	if (_is_current (PATTERN, pattern, 0) &&

2767

	    _is_current (CONTEXT, cr, 1))

2768

2769

	    if (obj->defined) {

2770

		_consume_operand (false);

2771

		need_context_and_pattern = FALSE;

2772

2773

2774

	else if (_is_current (PATTERN, pattern, 1) &&

2775

		 _is_current (CONTEXT, cr, 0))

2776

2777

	    if (obj->defined) {

2778

		_trace_printf ("exch ");

2779

		_exch_operands ();

2780

		_consume_operand (false);

2781

		need_context_and_pattern = FALSE;

2782

2783

2784

2785

	if (need_context_and_pattern) {

2786

	    _emit_context (cr);

2787

	    _emit_pattern_id (pattern);

2788

2789

2790

	_trace_printf (" mask\n");

2791

	_write_unlock ();

2792

2793

    DLCALL (cairo_mask, cr, pattern);

2794

    _exit_trace ();

2795

2796

2797

void

2798

cairo_mask_surface (cairo_t *cr, cairo_surface_t *surface, double x, double y)

2799

2800

    _enter_trace ();

2801

    _emit_line_info ();

2802

    if (cr != NULL && surface != NULL && _write_lock ()) {

2803

	Object *obj = _get_object (SURFACE, surface);

2804

	if (_is_current (SURFACE, surface, 0) &&

2805

	    _is_current (CONTEXT, cr, 1))

2806

2807

	    _consume_operand (false);

2808

2809

	else if (_is_current (SURFACE, surface, 1) &&

2810

		 _is_current (CONTEXT, cr, 0))

2811

2812

	    _trace_printf ("exch ");

2813

	    _exch_operands ();

2814

	    _consume_operand (false);

2815

	} else if (obj->defined){

2816

	    _emit_context (cr);

2817

	    _trace_printf ("s%ld ", obj->token);

2818

	} else {

2819

	    _emit_context (cr);

2820

	    _trace_printf ("%d index ",

2821

			   current_stack_depth - obj->operand - 1);

2822

2823

	_trace_printf ("pattern");

2824

2825

	if (x != 0. || y != 0.)

2826

	    _trace_printf (" %g %g translate", -x, -y);

2827

2828

	_trace_printf (" mask\n");

2829

	_write_unlock ();

2830

2831

2832

    DLCALL (cairo_mask_surface, cr, surface, x, y);

2833

    _exit_trace ();

2834

2835

2836

void

2837

cairo_stroke (cairo_t *cr)

2838

2839

    _enter_trace ();

2840

    _emit_line_info ();

2841

    _emit_cairo_op (cr, "stroke\n");

2842

    DLCALL (cairo_stroke, cr);

2843

    _exit_trace ();

2844

2845

2846

void

2847

cairo_stroke_preserve (cairo_t *cr)

2848

2849

    _enter_trace ();

2850

    _emit_line_info ();

2851

    _emit_cairo_op (cr, "stroke+\n");

2852

    DLCALL (cairo_stroke_preserve, cr);

2853

    _exit_trace ();

2854

2855

2856

void

2857

cairo_fill (cairo_t *cr)

2858

2859

    _enter_trace ();

2860

    _emit_line_info ();

2861

    _emit_cairo_op (cr, "fill\n");

2862

    DLCALL (cairo_fill, cr);

2863

    _exit_trace ();

2864

2865

2866

void

2867

cairo_fill_preserve (cairo_t *cr)

2868

2869

    _enter_trace ();

2870

    _emit_line_info ();

2871

    _emit_cairo_op (cr, "fill+\n");

2872

    DLCALL (cairo_fill_preserve, cr);

2873

    _exit_trace ();

2874

2875

2876

void

2877

cairo_copy_page (cairo_t *cr)

2878

2879

    _enter_trace ();

2880

    _emit_line_info ();

2881

    _emit_cairo_op (cr, "copy-page\n");

2882

    DLCALL (cairo_copy_page, cr);

2883

    _exit_trace ();

2884

2885

2886

void

2887

cairo_show_page (cairo_t *cr)

2888

2889

    _enter_trace ();

2890

    _emit_line_info ();

2891

    _emit_cairo_op (cr, "show-page\n");

2892

    DLCALL (cairo_show_page, cr);

2893

    _exit_trace ();

2894

2895

2896

void

2897

cairo_clip (cairo_t *cr)

2898

2899

    _enter_trace ();

2900

    _emit_line_info ();

2901

    _emit_cairo_op (cr, "clip\n");

2902

    DLCALL (cairo_clip, cr);

2903

    _exit_trace ();

2904

2905

2906

void

2907

cairo_clip_preserve (cairo_t *cr)

2908

2909

    _enter_trace ();

2910

    _emit_line_info ();

2911

    _emit_cairo_op (cr, "clip+\n");

2912

    DLCALL (cairo_clip_preserve, cr);

2913

    _exit_trace ();

2914

2915

2916

void

2917

cairo_reset_clip (cairo_t *cr)

2918

2919

    _enter_trace ();

2920

    _emit_line_info ();

2921

    _emit_cairo_op (cr, "reset-clip\n");

2922

    DLCALL (cairo_reset_clip, cr);

2923

    _exit_trace ();

2924

2925

2926

2927

static const char *

2928

_slant_to_string (cairo_font_slant_t font_slant)

2929

2930

#define f(name) case CAIRO_FONT_SLANT_ ## name: return "SLANT_" #name

2931

    switch (font_slant) {

2932

	f(NORMAL);

2933

	f(ITALIC);

2934

	f(OBLIQUE);

2935

};

2936

#undef f

2937

    return "UNKNOWN_SLANT";

2938

2939

2940

static const char *

2941

_weight_to_string (cairo_font_weight_t font_weight)

2942

2943

#define f(name) case CAIRO_FONT_WEIGHT_ ## name: return "WEIGHT_" #name

2944

    switch (font_weight) {

2945

	f(NORMAL);

2946

	f(BOLD);

2947

};

2948

#undef f

2949

    return "UNKNOWN_WEIGHT";

2950

2951

2952

void

2953

cairo_select_font_face (cairo_t *cr, const char *family, cairo_font_slant_t slant, cairo_font_weight_t weight)

2954

2955

    _enter_trace ();

2956

    _emit_line_info ();

2957

    if (cr != NULL && _write_lock ()) {

2958

	_emit_context (cr);

2959

	_emit_string_literal (family, -1);

2960

	_trace_printf (" //%s //%s select-font-face\n",

2961

		       _slant_to_string (slant),

2962

		       _weight_to_string (weight));

2963

	_write_unlock ();

2964

2965

    DLCALL (cairo_select_font_face, cr, family, slant, weight);

2966

    _exit_trace ();

2967

2968

2969

cairo_font_face_t *

2970

cairo_get_font_face (cairo_t *cr)

2971

2972

    cairo_font_face_t *ret;

2973

    long font_face_id;

2974

2975

    _enter_trace ();

2976

2977

    ret = DLCALL (cairo_get_font_face, cr);

2978

    font_face_id = _create_font_face_id (ret);

2979

2980

    _emit_cairo_op (cr, "/font-face get %% f%ld\n", font_face_id);

2981

    _push_operand (FONT_FACE, ret);

2982

    dump_stack(__func__);

2983

2984

    _exit_trace ();

2985

    return ret;

2986

2987

2988

void

2989

cairo_set_font_face (cairo_t *cr, cairo_font_face_t *font_face)

2990

2991

    _enter_trace ();

2992

    _emit_line_info ();

2993

    if (cr != NULL && font_face != NULL && _write_lock ()) {

2994

	if (_is_current (FONT_FACE, font_face, 0) &&

2995

	    _is_current (CONTEXT, cr, 1))

2996

2997

	    _consume_operand (false);

2998

2999

	else if (_is_current (FONT_FACE, font_face, 1) &&

3000

		 _is_current (CONTEXT, cr, 0))

3001

3002

	    _trace_printf ("exch ");

3003

	    _exch_operands ();

3004

	    _consume_operand (false);

3005

3006

	else

3007

3008

	    _emit_context (cr);

3009

	    _emit_font_face_id (font_face);

3010

3011

3012

	_trace_printf ("set-font-face\n");

3013

	_write_unlock ();

3014

3015

3016

    DLCALL (cairo_set_font_face, cr, font_face);

3017

    _exit_trace ();

3018

3019

3020

void

3021

cairo_set_font_size (cairo_t *cr, double size)

3022

3023

    _enter_trace ();

3024

    _emit_line_info ();

3025

    _emit_cairo_op (cr, "%g set-font-size\n", size);

3026

    DLCALL (cairo_set_font_size, cr, size);

3027

    _exit_trace ();

3028

3029

3030

void

3031

cairo_set_font_matrix (cairo_t *cr, const cairo_matrix_t *matrix)

3032

3033

    _enter_trace ();

3034

    _emit_line_info ();

3035

    _emit_cairo_op (cr, "%g %g %g %g %g %g matrix set-font-matrix\n",

3036

		    matrix->xx, matrix->yx,

3037

		    matrix->xy, matrix->yy,

3038

		    matrix->x0, matrix->y0);

3039

    DLCALL (cairo_set_font_matrix, cr, matrix);

3040

    _exit_trace ();

3041

3042

3043

static const char *

3044

_subpixel_order_to_string (cairo_subpixel_order_t subpixel_order)

3045

3046

#define f(name) case CAIRO_SUBPIXEL_ORDER_ ## name: return "SUBPIXEL_ORDER_" #name

3047

    switch (subpixel_order) {

3048

	f(DEFAULT);

3049

	f(RGB);

3050

	f(BGR);

3051

	f(VRGB);

3052

	f(VBGR);

3053

};

3054

#undef f

3055

    return "UNKNOWN_SUBPIXEL_ORDER";

3056

3057

3058

static const char *

3059

_hint_style_to_string (cairo_hint_style_t hint_style)

3060

3061

#define f(name) case CAIRO_HINT_STYLE_ ## name: return "HINT_STYLE_" #name

3062

    switch (hint_style) {

3063

	f(DEFAULT);

3064

	f(NONE);

3065

	f(SLIGHT);

3066

	f(MEDIUM);

3067

	f(FULL);

3068

};

3069

#undef f

3070

    return "UNKNOWN_HINT_STYLE";

3071

3072

3073

static const char *

3074

_hint_metrics_to_string (cairo_hint_metrics_t hint_metrics)

3075

3076

#define f(name) case CAIRO_HINT_METRICS_ ## name: return "HINT_METRICS_" #name

3077

    switch (hint_metrics) {

3078

	f(DEFAULT);

3079

	f(OFF);

3080

	f(ON);

3081

};

3082

#undef f

3083

    return "UNKNOWN_HINT_METRICS";

3084

3085

3086

static void

3087

_emit_font_options (const cairo_font_options_t *options)

3088

3089

    cairo_antialias_t antialias;

3090

    cairo_subpixel_order_t subpixel_order;

3091

    cairo_hint_style_t hint_style;

3092

    cairo_hint_metrics_t hint_metrics;

3093

3094

    _trace_printf ("<<");

3095

3096

    antialias = DLCALL (cairo_font_options_get_antialias, options);

3097

    if (antialias != CAIRO_ANTIALIAS_DEFAULT) {

3098

	_trace_printf (" /antialias //%s",

3099

		       _antialias_to_string (antialias));

3100

3101

3102

    subpixel_order = DLCALL (cairo_font_options_get_subpixel_order, options);

3103

    if (subpixel_order != CAIRO_SUBPIXEL_ORDER_DEFAULT) {

3104

	_trace_printf (" /subpixel-order //%s",

3105

		       _subpixel_order_to_string (subpixel_order));

3106

3107

3108

    hint_style = DLCALL (cairo_font_options_get_hint_style, options);

3109

    if (hint_style != CAIRO_HINT_STYLE_DEFAULT) {

3110

	_trace_printf (" /hint-style //%s",

3111

		       _hint_style_to_string (hint_style));

3112

3113

3114

    hint_metrics = DLCALL (cairo_font_options_get_hint_metrics, options);

3115

    if (hint_metrics != CAIRO_HINT_METRICS_DEFAULT) {

3116

	_trace_printf (" /hint-metrics //%s",

3117

		       _hint_metrics_to_string (hint_metrics));

3118

3119

3120

    _trace_printf (" >>");

3121

3122

3123

void

3124

cairo_set_font_options (cairo_t *cr, const cairo_font_options_t *options)

3125

3126

    _enter_trace ();

3127

    _emit_line_info ();

3128

    if (cr != NULL && options != NULL && _write_lock ()) {

3129

	_emit_context (cr);

3130

	_emit_font_options (options);

3131

	_trace_printf (" set-font-options\n");

3132

	_write_unlock ();

3133

3134

3135

    DLCALL (cairo_set_font_options, cr, options);

3136

    _exit_trace ();

3137

3138

3139

cairo_scaled_font_t *

3140

cairo_get_scaled_font (cairo_t *cr)

3141

3142

    cairo_scaled_font_t *ret;

3143

3144

    _enter_trace ();

3145

3146

    ret = DLCALL (cairo_get_scaled_font, cr);

3147

3148

    if (cr != NULL && ! _has_scaled_font_id (ret)) {

3149

	_emit_cairo_op (cr, "/scaled-font get /sf%ld exch def\n",

3150

			_create_scaled_font_id (ret));

3151

	_get_object (SCALED_FONT, ret)->defined = TRUE;

3152

3153

3154

    _exit_trace ();

3155

    return ret;

3156

3157

3158

void

3159

cairo_set_scaled_font (cairo_t *cr, const cairo_scaled_font_t *scaled_font)

3160

3161

    _enter_trace ();

3162

    _emit_line_info ();

3163

    if (cr != NULL && scaled_font != NULL && _write_lock ()) {

3164

	Object *obj = _get_object (SCALED_FONT, scaled_font);

3165

	cairo_bool_t need_context_and_font = TRUE;

3166

3167

	if (_is_current (SCALED_FONT, scaled_font, 0) &&

3168

	    _is_current (CONTEXT, cr, 1))

3169

3170

	    if (obj->defined) {

3171

		_consume_operand (false);

3172

	    } else {

3173

		_trace_printf ("exch 1 index ");

3174

		_exch_operands ();

3175

3176

	    need_context_and_font = FALSE;

3177

3178

	else if (_is_current (SCALED_FONT, scaled_font, 1) &&

3179

		 _is_current (CONTEXT, cr, 0))

3180

3181

	    if (obj->defined) {

3182

		_trace_printf ("exch ");

3183

		_exch_operands ();

3184

		_consume_operand (false);

3185

		need_context_and_font = FALSE;

3186

3187

3188

3189

	if (need_context_and_font) {

3190

	    _emit_context (cr);

3191

	    _emit_scaled_font_id (scaled_font);

3192

3193

3194

	_trace_printf ("set-scaled-font\n");

3195

3196

	_write_unlock ();

3197

3198

    DLCALL (cairo_set_scaled_font, cr, scaled_font);

3199

    _exit_trace ();

3200

3201

3202

static void

3203

_emit_matrix (const cairo_matrix_t *m)

3204

3205

    if (_matrix_is_identity(m))

3206

3207

	_trace_printf ("identity");

3208

3209

    else

3210

3211

	_trace_printf ("%g %g %g %g %g %g matrix",

3212

		       m->xx, m->yx,

3213

		       m->xy, m->yy,

3214

		       m->x0, m->y0);

3215

3216

3217

3218

cairo_scaled_font_t *

3219

cairo_scaled_font_create (cairo_font_face_t *font_face,

3220

			  const cairo_matrix_t *font_matrix,

3221

			  const cairo_matrix_t *ctm,

3222

			  const cairo_font_options_t *options)

3223

3224

    cairo_scaled_font_t *ret;

3225

3226

    _enter_trace ();

3227

3228

    ret = DLCALL (cairo_scaled_font_create, font_face, font_matrix, ctm, options);

3229

    if (_has_scaled_font_id (ret))

3230

	    goto out;

3231

3232

    _emit_line_info ();

3233

    if (font_face != NULL &&

3234

	font_matrix != NULL &&

3235

	ctm != NULL &&

3236

	options != NULL

3237

	&& _write_lock ())

3238

3239

	Object *obj;

3240

3241

	obj = _type_object_create (SCALED_FONT, ret);

3242

	DLCALL (cairo_scaled_font_set_user_data,

3243

		ret, &destroy_key, obj, _object_undef);

3244

3245

	if (_pop_operands_to (FONT_FACE, font_face))

3246

	    _consume_operand (false);

3247

	else

3248

	    _trace_printf ("f%ld ", _get_font_face_id (font_face));

3249

3250

	_emit_matrix (font_matrix);

3251

	_trace_printf (" ");

3252

3253

	_emit_matrix (ctm);

3254

	_trace_printf (" ");

3255

3256

	_emit_font_options (options);

3257

3258

	_trace_printf (" scaled-font /sf%ld exch def\n",

3259

		       obj->token);

3260

	obj->defined = TRUE;

3261

3262

	_write_unlock ();

3263

3264

3265

out:

3266

    _exit_trace ();

3267

    return ret;

3268

3269

3270

void

3271

cairo_show_text (cairo_t *cr, const char *utf8)

3272

3273

    _enter_trace ();

3274

    _emit_line_info ();

3275

    if (cr != NULL && _write_lock ()) {

3276

	_emit_context (cr);

3277

	_emit_string_literal (utf8, -1);

3278

	_trace_printf (" show-text\n");

3279

	_write_unlock ();

3280

3281

    DLCALL (cairo_show_text, cr, utf8);

3282

    _exit_trace ();

3283

3284

3285

static void

3286

_glyph_advance (cairo_scaled_font_t *font,

3287

		const cairo_glyph_t *glyph,

3288

		double *x, double *y)

3289

3290

    cairo_text_extents_t extents;

3291

3292

    DLCALL (cairo_scaled_font_glyph_extents, font, glyph, 1, &extents);

3293

    *x += extents.x_advance;

3294

    *y += extents.y_advance;

3295

3296

3297

#define TOLERANCE 1e-5

3298

static void

3299

_emit_glyphs (cairo_scaled_font_t *font,

3300

	      const cairo_glyph_t *glyphs,

3301

	      int num_glyphs)

3302

3303

    double x,y;

3304

    int n;

3305

3306

    if (num_glyphs == 0) {

3307

	_trace_printf ("[]");

3308

	return;

3309

3310

3311

    for (n = 0; n < num_glyphs; n++) {

3312

	if (glyphs[n].index > 255)

3313

	    break;

3314

3315

3316

    x = glyphs->x;

3317

    y = glyphs->y;

3318

    if (n < num_glyphs) { /* need full glyph range */

3319

	cairo_bool_t first;

3320

3321

	_trace_printf ("[%g %g [", x, y);

3322

	first = TRUE;

3323

	while (num_glyphs--) {

3324

	    if (fabs (glyphs->x - x) > TOLERANCE ||

3325

		fabs (glyphs->y - y) > TOLERANCE)

3326

3327

		x = glyphs->x;

3328

		y = glyphs->y;

3329

		_trace_printf ("] %g %g [", x, y);

3330

		first = TRUE;

3331

3332

3333

	    if (! first)

3334

		_trace_printf (" ");

3335

	    _trace_printf ("%lu", glyphs->index);

3336

	    first = FALSE;

3337

3338

	    _glyph_advance (font, glyphs, &x, &y);

3339

	    glyphs++;

3340

3341

	_trace_printf ("]]");

3342

    } else {

3343

	struct _data_stream stream;

3344

3345

	if (num_glyphs == 1) {

3346

	    _trace_printf ("[%g %g <%02lx>]", x, y,  glyphs->index);

3347

	} else {

3348

	    _trace_printf ("[%g %g <~", x, y);

3349

	    _write_base85_data_start (&stream);

3350

	    while (num_glyphs--) {

3351

		unsigned char c;

3352

3353

		if (fabs (glyphs->x - x) > TOLERANCE ||

3354

		    fabs (glyphs->y - y) > TOLERANCE)

3355

3356

		    x = glyphs->x;

3357

		    y = glyphs->y;

3358

		    _write_base85_data_end (&stream);

3359

		    _trace_printf ("~> %g %g <~", x, y);

3360

		    _write_base85_data_start (&stream);

3361

3362

3363

		c = glyphs->index;

3364

		_write_base85_data (&stream, &c, 1);

3365

3366

		_glyph_advance (font, glyphs, &x, &y);

3367

		glyphs++;

3368

3369

	    _write_base85_data_end (&stream);

3370

	    _trace_printf ("~>]");

3371

3372

3373

3374

3375

void

3376

cairo_show_glyphs (cairo_t *cr, const cairo_glyph_t *glyphs, int num_glyphs)

3377

3378

    _enter_trace ();

3379

    _emit_line_info ();

3380

    if (cr != NULL && glyphs != NULL && _write_lock ()) {

3381

	cairo_scaled_font_t *font;

3382

3383

	_emit_context (cr);

3384

	font = DLCALL (cairo_get_scaled_font, cr);

3385

3386

	_emit_glyphs (font, glyphs, num_glyphs);

3387

	_trace_printf (" show-glyphs\n");

3388

	_write_unlock ();

3389

3390

3391

    DLCALL (cairo_show_glyphs, cr, glyphs, num_glyphs);

3392

    _exit_trace ();

3393

3394

3395

static const char *

3396

_direction_to_string (cairo_bool_t backward)

3397

3398

    const char *names[] = {

3399

	"FORWARD",

3400

	"BACKWARD"

3401

};

3402

    return names[!!backward];

3403

3404

3405

void

3406

cairo_show_text_glyphs (cairo_t			   *cr,

3407

			const char		   *utf8,

3408

			int			    utf8_len,

3409

			const cairo_glyph_t	   *glyphs,

3410

			int			    num_glyphs,

3411

			const cairo_text_cluster_t *clusters,

3412

			int			    num_clusters,

3413

			cairo_text_cluster_flags_t  backward)

3414

3415

    cairo_scaled_font_t *font;

3416

3417

    _enter_trace ();

3418

3419

    font = DLCALL (cairo_get_scaled_font, cr);

3420

3421

    _emit_line_info ();

3422

    if (cr != NULL && glyphs != NULL && clusters != NULL && _write_lock ()) {

3423

	int n;

3424

3425

	_emit_context (cr);

3426

3427

	_emit_string_literal (utf8, utf8_len);

3428

3429

	_emit_glyphs (font, glyphs, num_glyphs);

3430

	_trace_printf ("  [");

3431

	for (n = 0; n < num_clusters; n++) {

3432

	    _trace_printf (" %d %d",

3433

			   clusters[n].num_bytes,

3434

			   clusters[n].num_glyphs);

3435

3436

	_trace_printf (" ] //%s show-text-glyphs\n",

3437

		       _direction_to_string (backward));

3438

3439

	_write_unlock ();

3440

3441

3442

    DLCALL (cairo_show_text_glyphs, cr,

3443

	                            utf8, utf8_len,

3444

				    glyphs, num_glyphs,

3445

				    clusters, num_clusters,

3446

				    backward);

3447

    _exit_trace ();

3448

3449

3450

void

3451

cairo_text_path (cairo_t *cr, const char *utf8)

3452

3453

    _enter_trace ();

3454

    _emit_line_info ();

3455

    if (cr != NULL && _write_lock ()) {

3456

	_emit_context (cr);

3457

	_emit_string_literal (utf8, -1);

3458

	_trace_printf (" text-path\n");

3459

	_write_unlock ();

3460

3461

    DLCALL (cairo_text_path, cr, utf8);

3462

    _exit_trace ();

3463

3464

3465

void

3466

cairo_glyph_path (cairo_t *cr, const cairo_glyph_t *glyphs, int num_glyphs)

3467

3468

    cairo_scaled_font_t *font;

3469

3470

    _enter_trace ();

3471

3472

    font = DLCALL (cairo_get_scaled_font, cr);

3473

3474

    _emit_line_info ();

3475

    if (cr != NULL && glyphs != NULL && _write_lock ()) {

3476

	_emit_context (cr);

3477

	_emit_glyphs (font, glyphs, num_glyphs);

3478

	_trace_printf (" glyph-path\n");

3479

3480

	_write_unlock ();

3481

3482

3483

    DLCALL (cairo_glyph_path, cr, glyphs, num_glyphs);

3484

    _exit_trace ();

3485

3486

3487

void

3488

cairo_append_path (cairo_t *cr, const cairo_path_t *path)

3489

3490

    /* XXX no support for named paths, so manually reconstruct */

3491

    int i;

3492

    cairo_path_data_t *p;

3493

3494

    _enter_trace ();

3495

3496

    _emit_line_info ();

3497

    if (cr == NULL || path == NULL) {

3498

	DLCALL (cairo_append_path, cr, path);

3499

	_exit_trace ();

3500

	return;

3501

3502

3503

    for (i=0; i < path->num_data; i += path->data[i].header.length) {

3504

	p = &path->data[i];

3505

	switch (p->header.type) {

3506

	case CAIRO_PATH_MOVE_TO:

3507

	    if (p->header.length >= 2)

3508

		cairo_move_to (cr, p[1].point.x, p[1].point.y);

3509

	    break;

3510

	case CAIRO_PATH_LINE_TO:

3511

	    if (p->header.length >= 2)

3512

		cairo_line_to (cr, p[1].point.x, p[1].point.y);

3513

	    break;

3514

	case CAIRO_PATH_CURVE_TO:

3515

	    if (p->header.length >= 4)

3516

		cairo_curve_to (cr,

3517

				p[1].point.x, p[1].point.y,

3518

				p[2].point.x, p[2].point.y,

3519

				p[3].point.x, p[3].point.y);

3520

	    break;

3521

	case CAIRO_PATH_CLOSE_PATH:

3522

	    if (p->header.length >= 1)

3523

		cairo_close_path (cr);

3524

	    break;

3525

	default:

3526

	    break;

3527

3528

3529

    _exit_trace ();

3530

3531

3532

cairo_surface_t *

3533

cairo_image_surface_create (cairo_format_t format, int width, int height)

3534

3535

    cairo_surface_t *ret;

3536

3537

    _enter_trace ();

3538

3539

    ret = DLCALL (cairo_image_surface_create, format, width, height);

3540

3541

    _emit_line_info ();

3542

    if (_write_lock ()) {

3543

	Object *obj = _create_surface (ret);

3544

	const char *format_str = _format_to_string (format);

3545

	const char *content_str = _format_to_content_string (format);

3546

3547

	_trace_printf ("dict\n"

3548

		       "  /width %d set\n"

3549

		       "  /height %d set\n"

3550

		       "  /format //%s set\n"

3551

		       "  /content //%s set\n"

3552

		       "  image dup /s%ld exch def\n",

3553

		       width, height, format_str, content_str, obj->token);

3554

	obj->width = width;

3555

	obj->height = height;

3556

	obj->defined = TRUE;

3557

	_push_object (obj);

3558

	dump_stack(__func__);

3559

	_write_unlock ();

3560

3561

3562

    _exit_trace ();

3563

    return ret;

3564

3565

3566

cairo_surface_t *

3567

cairo_image_surface_create_for_data (unsigned char *data, cairo_format_t format, int width, int height, int stride)

3568

3569

    cairo_surface_t *ret;

3570

3571

    _enter_trace ();

3572

3573

    ret = DLCALL (cairo_image_surface_create_for_data, data, format, width, height, stride);

3574

3575

    _emit_line_info ();

3576

    if (_write_lock ()) {

3577

	Object *obj = _create_surface (ret);

3578

3579

	/* cairo_image_surface_create_for_data() is both used to supply

3580

	 * foreign pixel data to cairo and in order to read pixels back.

3581

	 * Defer grabbing the pixel contents until we have to, but only for

3582

	 * "large" images, for small images the overhead of embedding pixels

3583

	 * is negligible.

3584

3585

	 * Choose 32x32 as that captures most icons which thanks to GdkPixbuf

3586

	 * are frequently reloaded.

3587

*/

3588

	if (width * height < 32*32) {

3589

	    _emit_image (ret, NULL);

3590

	    _trace_printf (" dup /s%ld exch def\n",

3591

			   obj->token);

3592

	} else {

3593

	    _trace_printf ("dict\n"

3594

			   "  /width %d set\n"

3595

			   "  /height %d set\n"

3596

			   "  /format //%s set\n"

3597

			   "  image dup /s%ld exch def\n",

3598

			   width, height,

3599

			   _format_to_string (format),

3600

			   obj->token);

3601

3602

	    obj->foreign = TRUE;

3603

3604

3605

	obj->width  = width;

3606

	obj->height = height;

3607

	obj->defined = TRUE;

3608

	_push_object (obj);

3609

	dump_stack(__func__);

3610

	_write_unlock ();

3611

3612

3613

    _exit_trace ();

3614

    return ret;

3615

3616

3617

unsigned char *

3618

cairo_image_surface_get_data (cairo_surface_t *surface)

3619

3620

    unsigned char *ptr;

3621

3622

    /* Just leave some breadcrumbs */

3623

    _enter_trace ();

3624

    _emit_line_info ();

3625

    if (surface != NULL && _write_lock ()) {

3626

	_trace_printf ("%% s%ld get-data\n", _get_surface_id (surface));

3627

	_write_unlock ();

3628

3629

    ptr = DLCALL (cairo_image_surface_get_data, surface);

3630

    _exit_trace ();

3631

3632

    return ptr;

3633

3634

3635

cairo_pattern_t *

3636

cairo_pattern_create_raster_source (void *data, cairo_content_t content, int width, int height)

3637

3638

    cairo_pattern_t *ret;

3639

3640

    _enter_trace ();

3641

3642

    ret = DLCALL (cairo_pattern_create_raster_source, data, content, width, height);

3643

3644

    _emit_line_info ();

3645

    if (_write_lock ()) {

3646

	long pattern_id = _create_pattern_id (ret);

3647

	cairo_format_t format;

3648

	cairo_surface_t *image;

3649

	cairo_t *cr;

3650

3651

	/* Impossible to accurately record the interaction with this custom

3652

	 * pattern so just suck all the data into an image upfront */

3653

	switch (content) {

3654

	case CAIRO_CONTENT_ALPHA: format = CAIRO_FORMAT_A8; break;

3655

	case CAIRO_CONTENT_COLOR: format = CAIRO_FORMAT_RGB24; break;

3656

	default:

3657

	case CAIRO_CONTENT_COLOR_ALPHA: format = CAIRO_FORMAT_ARGB32; break;

3658

3659

3660

	_trace_printf ("%% raster-source\n");

3661

3662

	image = DLCALL (cairo_image_surface_create, format, width, height);

3663

	cr = DLCALL (cairo_create, image);

3664

	DLCALL (cairo_set_source, cr, ret);

3665

	DLCALL (cairo_paint, cr);

3666

	DLCALL (cairo_destroy, cr);

3667

3668

	_emit_image (image, NULL);

3669

	DLCALL (cairo_surface_destroy, image);

3670

	_trace_printf (" pattern dup /s%ld exch def\n",

3671

		       pattern_id);

3672

3673

	_push_operand (PATTERN, ret);

3674

	_get_object (PATTERN, ret)->defined = TRUE;

3675

	dump_stack(__func__);

3676

	_write_unlock ();

3677

3678

3679

    _exit_trace ();

3680

    return ret;

3681

3682

3683

cairo_surface_t *

3684

cairo_surface_create_similar (cairo_surface_t *other,

3685

			      cairo_content_t content,

3686

			      int width, int height)

3687

3688

    cairo_surface_t *ret;

3689

3690

    _enter_trace ();

3691

3692

    ret = DLCALL (cairo_surface_create_similar, other, content, width, height);

3693

3694

    _emit_line_info ();

3695

    if (other != NULL && _write_lock ()) {

3696

	Object *other_obj = _get_object(SURFACE, other);

3697

	Object *new_obj = _create_surface (ret);

3698

3699

	if (other_obj->operand != -1) {

3700

	    if (current_stack_depth == other_obj->operand + 1)

3701

		_trace_printf ("dup ");

3702

	    else

3703

		_trace_printf ("%d index ",

3704

			       current_stack_depth - other_obj->operand - 1);

3705

	} else {

3706

	    assert(other_obj->defined);

3707

	    _trace_printf ("s%ld ", other_obj->token);

3708

3709

3710

	_trace_printf ("%d %d //%s similar dup /s%ld exch def\n",

3711

		       width, height,

3712

		       _content_to_string (content),

3713

		       new_obj->token);

3714

3715

	new_obj->width = width;

3716

	new_obj->height = height;

3717

	new_obj->defined = TRUE;

3718

3719

	_push_object (new_obj);

3720

	dump_stack(__func__);

3721

	_write_unlock ();

3722

3723

3724

    _exit_trace ();

3725

    return ret;

3726

3727

3728

cairo_surface_t *

3729

cairo_surface_create_similar_image (cairo_surface_t *other,

3730

				    cairo_format_t format,

3731

				    int width, int height)

3732

3733

    cairo_surface_t *ret;

3734

3735

    _enter_trace ();

3736

3737

    ret = DLCALL (cairo_surface_create_similar_image,

3738

		  other, format, width, height);

3739

3740

    _emit_line_info ();

3741

    if (other != NULL && _write_lock ()) {

3742

	Object *other_obj = _get_object(SURFACE, other);

3743

	Object *new_obj = _create_surface (ret);

3744

3745

	if (other_obj->defined)

3746

	    _trace_printf ("s%ld ", other_obj->token);

3747

	else if (current_stack_depth == other_obj->operand + 1)

3748

	    _trace_printf ("dup ");

3749

	else

3750

	    _trace_printf ("%d index ",

3751

			   current_stack_depth - other_obj->operand - 1);

3752

	_trace_printf ("//%s %d %d similar-image %% s%ld\n",

3753

		       _format_to_string (format),

3754

		       width, height,

3755

		       new_obj->token);

3756

	new_obj->width = width;

3757

	new_obj->height = height;

3758

3759

	_push_object (new_obj);

3760

	dump_stack(__func__);

3761

	_write_unlock ();

3762

3763

3764

    _exit_trace ();

3765

    return ret;

3766

3767

3768

cairo_surface_t *

3769

cairo_surface_map_to_image (cairo_surface_t *surface,

3770

			    const cairo_rectangle_int_t *extents)

3771

3772

    cairo_surface_t *ret;

3773

3774

    _enter_trace ();

3775

3776

    ret = DLCALL (cairo_surface_map_to_image, surface, extents);

3777

3778

    _emit_line_info ();

3779

    if (_write_lock ()) {

3780

	Object *obj = _create_surface (ret);

3781

3782

	_emit_surface (surface);

3783

	if (extents) {

3784

	    _trace_printf ("[%d %d %d %d] map-to-image %% s%ld\n",

3785

			   extents->x, extents->y,

3786

			   extents->width, extents->height,

3787

			   obj->token);

3788

	    obj->width  = extents->width;

3789

	    obj->height = extents->height;

3790

	} else {

3791

	    _trace_printf ("[ ] map-to-image %% s%ld\n", obj->token);

3792

3793

3794

	_push_object (obj);

3795

	dump_stack(__func__);

3796

	_write_unlock ();

3797

3798

3799

    _exit_trace ();

3800

    return ret;

3801

3802

3803

void

3804

cairo_surface_unmap_image (cairo_surface_t *surface,

3805

			   cairo_surface_t *image)

3806

3807

    _enter_trace ();

3808

3809

    _emit_line_info ();

3810

    if (_write_lock ()) {

3811

	Object *s = _get_object (SURFACE, surface);

3812

	Object *i = _get_object (SURFACE, image);

3813

	if (!(s->operand == current_stack_depth - 2 &&

3814

	      i->operand == current_stack_depth - 1)) {

3815

	    if (i->operand != s->operand + 1 || ! _pop_operands_to_depth (i->operand + 1)) {

3816

		_emit_surface (surface);

3817

		_emit_surface (image);

3818

3819

3820

	_trace_printf ("unmap-image\n");

3821

	_consume_operand (true);

3822

	_write_unlock ();

3823

3824

3825

    DLCALL (cairo_surface_unmap_image, surface, image);

3826

3827

    _exit_trace ();

3828

3829

3830

cairo_surface_t *

3831

cairo_surface_create_for_rectangle (cairo_surface_t *target,

3832

                                    double x, double y,

3833

                                    double width, double height)

3834

3835

    cairo_surface_t *ret;

3836

3837

    _enter_trace ();

3838

3839

    ret = DLCALL (cairo_surface_create_for_rectangle, target, x, y, width, height);

3840

3841

    _emit_line_info ();

3842

    if (target != NULL && _write_lock ()) {

3843

	Object *target_obj = _get_object (SURFACE, target);

3844

	Object *child_obj = _create_surface (ret);

3845

3846

	if (target_obj->defined)

3847

	    _trace_printf ("s%ld ", target_obj->token);

3848

	else if (current_stack_depth == target_obj->operand + 1)

3849

	    _trace_printf ("dup ");

3850

	else

3851

	    _trace_printf ("%d index ", current_stack_depth - target_obj->operand - 1);

3852

	_trace_printf ("%f %f %f %f subsurface %% s%ld\n",

3853

		       x, y, width, height,

3854

		       child_obj->token);

3855

3856

	_push_object (child_obj);

3857

	dump_stack(__func__);

3858

	_write_unlock ();

3859

3860

3861

    _exit_trace ();

3862

    return ret;

3863

3864

3865

static void CAIRO_PRINTF_FORMAT(2, 3)

3866

_emit_surface_op (cairo_surface_t *surface, const char *fmt, ...)

3867

3868

    va_list ap;

3869

3870

    if (surface == NULL || ! _write_lock ())

3871

	return;

3872

3873

    _emit_surface (surface);

3874

3875

    va_start (ap, fmt);

3876

    _trace_vprintf ( fmt, ap);

3877

    va_end (ap);

3878

3879

    _write_unlock ();

3880

3881

3882

void

3883

cairo_surface_finish (cairo_surface_t *surface)

3884

3885

    _enter_trace ();

3886

    _emit_line_info ();

3887

    DLCALL (cairo_surface_finish, surface);

3888

    _exit_trace ();

3889

3890

3891

void

3892

cairo_surface_flush (cairo_surface_t *surface)

3893

3894

    _enter_trace ();

3895

    _emit_line_info ();

3896

    if (surface != NULL && _write_lock ()) {

3897

	_trace_printf ("%% s%ld flush\n", _get_surface_id (surface));

3898

	_write_unlock ();

3899

3900

    DLCALL (cairo_surface_flush, surface);

3901

    _exit_trace ();

3902

3903

3904

void

3905

cairo_surface_mark_dirty (cairo_surface_t *surface)

3906

3907

    _enter_trace ();

3908

    _emit_line_info ();

3909

3910

    /* Call cairo before emitting the trace since _emit_surface() might cause

3911

     * snapshots to be creates while mark_dirty assert()s that there are none.

3912

*/

3913

    DLCALL (cairo_surface_mark_dirty, surface);

3914

3915

    if (surface != NULL && _write_lock ()) {

3916

	if (_mark_dirty) {

3917

	    _emit_surface (surface);

3918

	    _trace_printf ("%% mark-dirty\n");

3919

	    _emit_source_image (surface);

3920

	} else

3921

	    _trace_printf ("%% s%ld mark-dirty\n", _get_surface_id (surface));

3922

	_write_unlock ();

3923

3924

    _exit_trace ();

3925

3926

3927

void

3928

cairo_surface_mark_dirty_rectangle (cairo_surface_t *surface,

3929

				    int x, int y, int width, int height)

3930

3931

    _enter_trace ();

3932

3933

    /* Call cairo before emitting the trace since _emit_surface() might cause

3934

     * snapshots to be creates while mark_dirty assert()s that there are none.

3935

*/

3936

    DLCALL (cairo_surface_mark_dirty_rectangle, surface, x, y, width, height);

3937

3938

    _emit_line_info ();

3939

    if (surface != NULL && _write_lock ()) {

3940

	if (_mark_dirty) {

3941

	    _emit_surface (surface);

3942

	    _trace_printf ("%% %d %d %d %d mark-dirty-rectangle\n",

3943

		            x, y, width, height);

3944

	    _emit_source_image_rectangle (surface, x,y, width, height);

3945

	} else

3946

	    _trace_printf ("%% s%ld %d %d %d %d mark-dirty-rectangle\n",

3947

		           _get_surface_id (surface), x, y, width, height);

3948

	_write_unlock ();

3949

3950

    _exit_trace ();

3951

3952

3953

void

3954

cairo_surface_set_device_offset (cairo_surface_t *surface, double x_offset, double y_offset)

3955

3956

    _enter_trace ();

3957

    _emit_line_info ();

3958

    _emit_surface_op (surface, "%g %g set-device-offset\n",

3959

		      x_offset, y_offset);

3960

    DLCALL (cairo_surface_set_device_offset, surface, x_offset, y_offset);

3961

    _exit_trace ();

3962

3963

3964

void

3965

cairo_surface_set_device_scale (cairo_surface_t *surface, double x_offset, double y_offset)

3966

3967

    _enter_trace ();

3968

    _emit_line_info ();

3969

    _emit_surface_op (surface, "%g %g set-device-scale\n",

3970

		      x_offset, y_offset);

3971

    DLCALL (cairo_surface_set_device_scale, surface, x_offset, y_offset);

3972

    _exit_trace ();

3973

3974

3975

3976

void

3977

cairo_surface_set_fallback_resolution (cairo_surface_t *surface, double x_pixels_per_inch, double y_pixels_per_inch)

3978

3979

    _enter_trace ();

3980

    _emit_line_info ();

3981

    _emit_surface_op (surface, "%g %g set-fallback-resolution\n",

3982

		      x_pixels_per_inch, y_pixels_per_inch);

3983

    DLCALL (cairo_surface_set_fallback_resolution, surface, x_pixels_per_inch, y_pixels_per_inch);

3984

    _exit_trace ();

3985

3986

3987

void

3988

cairo_surface_copy_page (cairo_surface_t *surface)

3989

3990

    _enter_trace ();

3991

    _emit_line_info ();

3992

    _emit_surface_op (surface, "copy-page\n");

3993

    DLCALL (cairo_surface_copy_page, surface);

3994

    _exit_trace ();

3995

3996

3997

void

3998

cairo_surface_show_page (cairo_surface_t *surface)

3999

4000

    _enter_trace ();

4001

    _emit_line_info ();

4002

    _emit_surface_op (surface, "show-page\n");

4003

    DLCALL (cairo_surface_show_page, surface);

4004

    _exit_trace ();

4005

4006

4007

cairo_status_t

4008

cairo_surface_set_mime_data (cairo_surface_t		*surface,

4009

                             const char			*mime_type,

4010

                             const unsigned char	*data,

4011

                             unsigned long		 length,

4012

			     cairo_destroy_func_t	 destroy,

4013

			     void			*closure)

4014

4015

    cairo_status_t ret;

4016

    _enter_trace ();

4017

    _emit_line_info ();

4018

    if (surface != NULL && _write_lock ()) {

4019

	_emit_surface (surface);

4020

	_emit_string_literal (mime_type, -1);

4021

	_trace_printf (" ");

4022

	_emit_data (data, length);

4023

	_trace_printf (" /deflate filter set-mime-data\n");

4024

4025

	_write_unlock ();

4026

4027

4028

    ret = DLCALL (cairo_surface_set_mime_data,

4029

		  surface,

4030

		  mime_type,

4031

		  data, length,

4032

		  destroy,

4033

		  closure);

4034

    _exit_trace ();

4035

    return ret;

4036

4037

4038

#if CAIRO_HAS_PNG_FUNCTIONS

4039

cairo_status_t

4040

cairo_surface_write_to_png (cairo_surface_t *surface, const char *filename)

4041

4042

    cairo_status_t ret;

4043

    _enter_trace ();

4044

    _emit_line_info ();

4045

    if (surface != NULL && _write_lock ()) {

4046

	_trace_printf ("%% s%ld ", _get_surface_id (surface));

4047

	_emit_string_literal (filename, -1);

4048

	_trace_printf (" write-to-png pop\n");

4049

	_write_unlock ();

4050

4051

    ret = DLCALL (cairo_surface_write_to_png, surface, filename);

4052

    _exit_trace ();

4053

    return ret;

4054

4055

4056

cairo_status_t

4057

cairo_surface_write_to_png_stream (cairo_surface_t *surface,

4058

				   cairo_write_func_t write_func,

4059

				   void *data)

4060

4061

    cairo_status_t ret;

4062

    _enter_trace ();

4063

    _emit_line_info ();

4064

    if (surface != NULL && _write_lock ()) {

4065

	char symbol[1024];

4066

4067

	_trace_printf ("%% s%ld ", _get_surface_id (surface));

4068

#if CAIRO_HAS_SYMBOL_LOOKUP

4069

	lookup_symbol (symbol, sizeof (symbol), write_func);

4070

#else

4071

	symbol[0] = '\0';

4072

#endif

4073

	_emit_string_literal (symbol, -1);

4074

	_trace_printf (" write-to-png-stream pop\n");

4075

	_write_unlock ();

4076

4077

    ret = DLCALL (cairo_surface_write_to_png_stream,

4078

		  surface, write_func, data);

4079

    _exit_trace ();

4080

    return ret;

4081

4082

#endif

4083

4084

static void CAIRO_PRINTF_FORMAT(2, 3)

4085

_emit_pattern_op (cairo_pattern_t *pattern, const char *fmt, ...)

4086

4087

    va_list ap;

4088

4089

    if (pattern == NULL || ! _write_lock ())

4090

	return;

4091

4092

    _emit_pattern (pattern);

4093

4094

    va_start (ap, fmt);

4095

    _trace_vprintf (fmt, ap);

4096

    va_end (ap);

4097

4098

    _write_unlock ();

4099

4100

4101

cairo_pattern_t *

4102

cairo_pattern_create_rgb (double red, double green, double blue)

4103

4104

    cairo_pattern_t *ret;

4105

    long pattern_id;

4106

4107

    _enter_trace ();

4108

4109

    ret = DLCALL (cairo_pattern_create_rgb, red, green, blue);

4110

    pattern_id = _create_pattern_id (ret);

4111

4112

    _emit_line_info ();

4113

    if (_write_lock ()) {

4114

	_trace_printf ("/p%ld %g %g %g rgb def\n",

4115

		       pattern_id, red, green, blue);

4116

	_get_object (PATTERN, ret)->defined = TRUE;

4117

	_write_unlock ();

4118

4119

4120

    _exit_trace ();

4121

    return ret;

4122

4123

4124

cairo_pattern_t *

4125

cairo_pattern_create_rgba (double red, double green, double blue, double alpha)

4126

4127

    cairo_pattern_t *ret;

4128

    long pattern_id;

4129

4130

    _enter_trace ();

4131

4132

    ret = DLCALL (cairo_pattern_create_rgba, red, green, blue, alpha);

4133

    pattern_id = _create_pattern_id (ret);

4134

4135

    _emit_line_info ();

4136

    if (_write_lock ()) {

4137

	_trace_printf ("/p%ld %g %g %g %g rgba def\n",

4138

		       pattern_id, red, green, blue, alpha);

4139

	_get_object (PATTERN, ret)->defined = TRUE;

4140

	_write_unlock ();

4141

4142

4143

    _exit_trace ();

4144

    return ret;

4145

4146

4147

cairo_pattern_t *

4148

cairo_pattern_create_for_surface (cairo_surface_t *surface)

4149

4150

    cairo_pattern_t *ret;

4151

    long pattern_id;

4152

    long surface_id;

4153

4154

    _enter_trace ();

4155

4156

    ret = DLCALL (cairo_pattern_create_for_surface, surface);

4157

    pattern_id = _create_pattern_id (ret);

4158

4159

    _emit_line_info ();

4160

    if (surface != NULL && _write_lock ()) {

4161

	surface_id = _get_surface_id (surface);

4162

4163

	if (_pop_operands_to (SURFACE, surface)) {

4164

	    _consume_operand (false);

4165

	} else {

4166

	    _trace_printf ("s%ld ", surface_id);

4167

4168

4169

	if (_get_object (SURFACE, surface)->foreign)

4170

	    _emit_source_image (surface);

4171

4172

	_trace_printf ("pattern %% p%ld\n", pattern_id);

4173

	_push_operand (PATTERN, ret);

4174

	dump_stack(__func__);

4175

	_write_unlock ();

4176

4177

4178

    _exit_trace ();

4179

    return ret;

4180

4181

4182

cairo_pattern_t *

4183

cairo_pattern_create_linear (double x0, double y0, double x1, double y1)

4184

4185

    cairo_pattern_t *ret;

4186

    long pattern_id;

4187

4188

    _enter_trace ();

4189

4190

    ret = DLCALL (cairo_pattern_create_linear, x0, y0, x1, y1);

4191

    pattern_id = _create_pattern_id (ret);

4192

4193

    _emit_line_info ();

4194

    if (_write_lock ()) {

4195

	_trace_printf ("%g %g %g %g linear %% p%ld\n",

4196

		       x0, y0, x1, y1, pattern_id);

4197

	_push_operand (PATTERN, ret);

4198

	dump_stack(__func__);

4199

	_write_unlock ();

4200

4201

4202

    _exit_trace ();

4203

    return ret;

4204

4205

4206

cairo_pattern_t *

4207

cairo_pattern_create_radial (double cx0, double cy0, double radius0, double cx1, double cy1, double radius1)

4208

4209

    cairo_pattern_t *ret;

4210

    long pattern_id;

4211

4212

    _enter_trace ();

4213

4214

    ret = DLCALL (cairo_pattern_create_radial,

4215

		  cx0, cy0, radius0,

4216

		  cx1, cy1, radius1);

4217

    pattern_id = _create_pattern_id (ret);

4218

4219

    _emit_line_info ();

4220

    if (_write_lock ()) {

4221

	_trace_printf ("%g %g %g %g %g %g radial %% p%ld\n",

4222

		       cx0, cy0, radius0, cx1, cy1, radius1,

4223

		       pattern_id);

4224

	_push_operand (PATTERN, ret);

4225

	dump_stack(__func__);

4226

	_write_unlock ();

4227

4228

4229

    _exit_trace ();

4230

    return ret;

4231

4232

4233

void

4234

cairo_pattern_add_color_stop_rgb (cairo_pattern_t *pattern, double offset, double red, double green, double blue)

4235

4236

    _enter_trace ();

4237

    _emit_line_info ();

4238

    _emit_pattern_op (pattern,

4239

		      "%g %g %g %g 1 add-color-stop\n",

4240

		      offset, red, green, blue);

4241

    DLCALL (cairo_pattern_add_color_stop_rgb, pattern, offset, red, green, blue);

4242

    _exit_trace ();

4243

4244

4245

void

4246

cairo_pattern_add_color_stop_rgba (cairo_pattern_t *pattern, double offset, double red, double green, double blue, double alpha)

4247

4248

    _enter_trace ();

4249

    _emit_line_info ();

4250

    _emit_pattern_op (pattern,

4251

		      "%g %g %g %g %g add-color-stop\n",

4252

		      offset, red, green, blue, alpha);

4253

    DLCALL (cairo_pattern_add_color_stop_rgba, pattern, offset, red, green, blue, alpha);

4254

    _exit_trace ();

4255

4256

4257

void

4258

cairo_pattern_set_matrix (cairo_pattern_t *pattern, const cairo_matrix_t *matrix)

4259

4260

    _enter_trace ();

4261

    _emit_line_info ();

4262

    if (_matrix_is_identity (matrix)) {

4263

	_emit_pattern_op (pattern, "identity set-matrix\n");

4264

    } else {

4265

	_emit_pattern_op (pattern,

4266

			  "%g %g %g %g %g %g matrix set-matrix\n",

4267

			  matrix->xx, matrix->yx,

4268

			  matrix->xy, matrix->yy,

4269

			  matrix->x0, matrix->y0);

4270

4271

    DLCALL (cairo_pattern_set_matrix, pattern, matrix);

4272

    _exit_trace ();

4273

4274

4275

static const char *

4276

_filter_to_string (cairo_filter_t filter)

4277

4278

#define f(name) case CAIRO_FILTER_ ## name: return "FILTER_" #name

4279

    switch (filter) {

4280

	f(FAST);

4281

	f(GOOD);

4282

	f(BEST);

4283

	f(NEAREST);

4284

	f(BILINEAR);

4285

	f(GAUSSIAN);

4286

};

4287

#undef f

4288

    return "UNKNOWN_FILTER";

4289

4290

4291

void

4292

cairo_pattern_set_filter (cairo_pattern_t *pattern, cairo_filter_t filter)

4293

4294

    _enter_trace ();

4295

    _emit_line_info ();

4296

    _emit_pattern_op (pattern, "//%s set-filter\n", _filter_to_string (filter));

4297

    DLCALL (cairo_pattern_set_filter, pattern, filter);

4298

    _exit_trace ();

4299

4300

4301

static const char *

4302

_extend_to_string (cairo_extend_t extend)

4303

4304

#define f(name) case CAIRO_EXTEND_ ## name: return "EXTEND_" #name

4305

    switch (extend) {

4306

	f(NONE);

4307

	f(REPEAT);

4308

	f(REFLECT);

4309

	f(PAD);

4310

};

4311

#undef f

4312

    return "UNKNOWN_EXTEND";

4313

4314

4315

void

4316

cairo_pattern_set_extend (cairo_pattern_t *pattern, cairo_extend_t extend)

4317

4318

    _enter_trace ();

4319

    _emit_line_info ();

4320

    _emit_pattern_op (pattern, "//%s set-extend\n", _extend_to_string (extend));

4321

    DLCALL (cairo_pattern_set_extend, pattern, extend);

4322

    _exit_trace ();

4323

4324

4325

#if CAIRO_HAS_FT_FONT

4326

#if CAIRO_HAS_FC_FONT

4327

cairo_font_face_t *

4328

cairo_ft_font_face_create_for_pattern (FcPattern *pattern)

4329

4330

    cairo_font_face_t *ret;

4331

    long font_face_id;

4332

4333

    _enter_trace ();

4334

4335

    ret = DLCALL (cairo_ft_font_face_create_for_pattern, pattern);

4336

    font_face_id = _create_font_face_id (ret);

4337

4338

    _emit_line_info ();

4339

    if (pattern != NULL && _write_lock ()) {

4340

	Object *obj;

4341

4342

	obj = _get_object (FONT_FACE, ret);

4343

	if (obj->unknown) {

4344

		FcPattern *copy;

4345

		FcChar8 *unparsed;

4346

4347

		copy = DLCALL (FcPatternDuplicate, pattern);

4348

		if (copy)

4349

4350

			DLCALL (FcPatternDel, copy, FC_LANG);

4351

			DLCALL (FcPatternDel, copy, FC_CHARSET);

4352

			DLCALL (FcPatternDel, copy, FC_CAPABILITY);

4353

4354

		else

4355

			copy = pattern;

4356

4357

		unparsed = DLCALL (FcNameUnparse, copy);

4358

		_trace_printf ("dict\n"

4359

			       "  /type 42 set\n"

4360

			       "  /pattern ");

4361

		_emit_string_literal ((char *) unparsed, -1);

4362

		_trace_printf (" set\n"

4363

			       "  font %% f%ld\n",

4364

			       font_face_id);

4365

		obj->unknown = FALSE;

4366

		_push_operand (FONT_FACE, ret);

4367

		dump_stack(__func__);

4368

4369

		if (copy != pattern)

4370

			DLCALL (FcPatternDestroy, copy);

4371

		free (unparsed);

4372

4373

	_write_unlock ();

4374

4375

4376

    _exit_trace ();

4377

    return ret;

4378

4379

#endif /* CAIRO_HAS_FC_FONT*/

4380

4381

typedef struct _ft_face_data {

4382

    unsigned long index;

4383

    unsigned long size;

4384

    void *data;

4385

} FtFaceData;

4386

4387

static void

4388

_ft_face_data_destroy (void *arg)

4389

4390

    FtFaceData *data = arg;

4391

    free (data->data);

4392

    free (data);

4393

4394

4395

cairo_font_face_t *

4396

cairo_ft_font_face_create_for_ft_face (FT_Face face, int load_flags)

4397

4398

    cairo_font_face_t *ret;

4399

    Object *obj;

4400

    FtFaceData *data;

4401

    long font_face_id;

4402

4403

    _enter_trace ();

4404

4405

    ret = DLCALL (cairo_ft_font_face_create_for_ft_face, face, load_flags);

4406

    font_face_id = _create_font_face_id (ret);

4407

4408

    if (face == NULL) {

4409

	_exit_trace ();

4410

	return ret;

4411

4412

4413

    obj = _get_object (NONE, face);

4414

    data = obj->data;

4415

    if (data == NULL) {

4416

	_exit_trace ();

4417

	return ret;

4418

4419

4420

    _emit_line_info ();

4421

    if (_write_lock ()) {

4422

	obj = _get_object (FONT_FACE, ret);

4423

	if (obj->operand != -1)

4424

	    _object_remove (obj);

4425

4426

	_trace_printf ("<< /type 42 /source ");

4427

	_emit_data (data->data, data->size);

4428

	_trace_printf (" /index %lu /flags %d >> font %% f%ld\n",

4429

		       data->index, load_flags, font_face_id);

4430

	_push_operand (FONT_FACE, ret);

4431

	dump_stack(__func__);

4432

	_write_unlock ();

4433

4434

4435

    _exit_trace ();

4436

    return ret;

4437

4438

4439

static cairo_bool_t

4440

_ft_read_file (FtFaceData *data, const char *path)

4441

4442

    char buf[8192];

4443

    FILE *file;

4444

4445

    file = fopen (path, "rb");

4446

    if (file != NULL) {

4447

	size_t ret;

4448

	unsigned long int allocated = sizeof (buf);

4449

	data->data = malloc (allocated);

4450

	do {

4451

	    ret = fread (buf, 1, sizeof (buf), file);

4452

	    if (ret == 0)

4453

		break;

4454

	    memcpy ((char *) data->data + data->size, buf, ret);

4455

	    data->size += ret;

4456

	    if (ret != sizeof (buf))

4457

		break;

4458

4459

	    if (data->size == allocated) {

4460

		allocated *= 2;

4461

		data->data = realloc (data->data, allocated);

4462

4463

	} while (TRUE);

4464

	fclose (file);

4465

4466

4467

    return file != NULL;

4468

4469

4470

FT_Error

4471

FT_New_Face (FT_Library library, const char *pathname, FT_Long index, FT_Face *face)

4472

4473

    FT_Error ret;

4474

4475

    _enter_trace ();

4476

4477

    ret = DLCALL (FT_New_Face, library, pathname, index, face);

4478

    if (ret == 0) {

4479

	Object *obj = _type_object_create (NONE, *face);

4480

	FtFaceData *data = malloc (sizeof (FtFaceData));

4481

	data->index = index;

4482

	data->size = 0;

4483

	data->data = NULL;

4484

	_ft_read_file (data, pathname);

4485

	obj->data = data;

4486

	obj->destroy = _ft_face_data_destroy;

4487

4488

4489

    _exit_trace ();

4490

    return ret;

4491

4492

4493

FT_Error

4494

FT_New_Memory_Face (FT_Library library, const FT_Byte *mem, FT_Long size, FT_Long index, FT_Face *face)

4495

4496

    FT_Error ret;

4497

4498

    _enter_trace ();

4499

4500

    ret = DLCALL (FT_New_Memory_Face, library, mem, size, index, face);

4501

    if (ret == 0) {

4502

	Object *obj = _type_object_create (NONE, *face);

4503

	FtFaceData *data = malloc (sizeof (FtFaceData));

4504

	data->index = index;

4505

	data->size = size;

4506

	data->data = malloc (size);

4507

	memcpy (data->data, mem, size);

4508

	obj->data = data;

4509

	obj->destroy = _ft_face_data_destroy;

4510

4511

4512

    _exit_trace ();

4513

    return ret;

4514

4515

4516

/* XXX

4517

 * FT_New_Memory_Face() and FT_New_Face() appear to wrap FT_Open_Face() so we

4518

 * get a redundant call to FT_Open_Face() from those paths (no PLT hiding

4519

 * within FT, naughty library!) but we do not intercept a direct call to

4520

 * FT_Open_Face(). So far this has not caused any issues, but it will one

4521

 * day...

4522

*/

4523

FT_Error

4524

FT_Open_Face (FT_Library library, const FT_Open_Args *args, FT_Long index, FT_Face *face)

4525

4526

    FT_Error ret;

4527

4528

    _enter_trace ();

4529

4530

    ret = DLCALL (FT_Open_Face, library, args, index, face);

4531

    if (ret == 0) {

4532

	Object *obj = _get_object (NONE, *face);

4533

	if (obj == NULL) {

4534

	    FtFaceData *data;

4535

4536

	    data = malloc (sizeof (FtFaceData));

4537

	    data->index = index;

4538

	    if (args->flags & FT_OPEN_MEMORY) {

4539

		data->size = args->memory_size;

4540

		data->data = malloc (args->memory_size);

4541

		memcpy (data->data, args->memory_base, args->memory_size);

4542

	    } else if (args->flags & FT_OPEN_STREAM) {

4543

		fprintf (stderr, "FT_Open_Face (stream, %ld) = %p\n",

4544

			 index, *face);

4545

		abort ();

4546

	    } else if (args->flags & FT_OPEN_PATHNAME) {

4547

		data->size = 0;

4548

		data->data = NULL;

4549

		_ft_read_file (data, args->pathname);

4550

4551

4552

	    obj = _type_object_create (NONE, *face);

4553

	    obj->data = data;

4554

	    obj->destroy = _ft_face_data_destroy;

4555

4556

4557

4558

    _exit_trace ();

4559

    return ret;

4560

4561

4562

FT_Error

4563

FT_Done_Face (FT_Face face)

4564

4565

    FT_Error ret;

4566

    _enter_trace ();

4567

4568

    _object_destroy (_get_object (NONE, face));

4569

4570

    ret = DLCALL (FT_Done_Face, face);

4571

    _exit_trace ();

4572

    return ret;

4573

4574

#endif

4575

4576

static void

4577

_surface_object_set_size (cairo_surface_t *surface, int width, int height)

4578

4579

    Object *obj;

4580

4581

    obj = _get_object (SURFACE, surface);

4582

    obj->width = width;

4583

    obj->height = height;

4584

4585

4586

static void

4587

_surface_object_set_size_from_surface (cairo_surface_t *surface)

4588

4589

    _surface_object_set_size (surface,

4590

			      DLCALL (cairo_image_surface_get_width, surface),

4591

			      DLCALL (cairo_image_surface_get_height, surface));

4592

4593

4594

#if CAIRO_HAS_PS_SURFACE

4595

#include<cairo-ps.h>

4596

4597

cairo_surface_t *

4598

cairo_ps_surface_create (const char *filename, double width_in_points, double height_in_points)

4599

4600

    cairo_surface_t *ret;

4601

4602

    _enter_trace ();

4603

4604

    ret = DLCALL (cairo_ps_surface_create, filename, width_in_points, height_in_points);

4605

4606

    _emit_line_info ();

4607

    if (_write_lock ()) {

4608

	Object *obj = _create_surface (ret);

4609

4610

	_trace_printf ("dict\n"

4611

		       "  /type /PS set\n"

4612

		       "  /filename ");

4613

	_emit_string_literal (filename, -1);

4614

	_trace_printf (" set\n"

4615

		       "  /width %g set\n"

4616

		       "  /height %g set\n"

4617

		       "  surface %% s%ld\n",

4618

		       width_in_points,

4619

		       height_in_points,

4620

		       obj->token);

4621

	obj->width = width_in_points;

4622

	obj->height = height_in_points;

4623

	_push_object (obj);

4624

	dump_stack(__func__);

4625

	_write_unlock ();

4626

4627

4628

    _exit_trace ();

4629

    return ret;

4630

4631

4632

cairo_surface_t *

4633

cairo_ps_surface_create_for_stream (cairo_write_func_t write_func, void *closure, double width_in_points, double height_in_points)

4634

4635

    cairo_surface_t *ret;

4636

4637

    _enter_trace ();

4638

4639

    ret = DLCALL (cairo_ps_surface_create_for_stream, write_func, closure, width_in_points, height_in_points);

4640

4641

    _emit_line_info ();

4642

    if (_write_lock ()) {

4643

	Object *obj = _create_surface (ret);

4644

4645

	_trace_printf ("dict\n"

4646

		       "  /type /PS set\n"

4647

		       "  /width %g set\n"

4648

		       "  /height %g set\n"

4649

		       "  surface %% s%ld\n",

4650

		       width_in_points,

4651

		       height_in_points,

4652

		       obj->token);

4653

	obj->width = width_in_points;

4654

	obj->height = height_in_points;

4655

	_push_object (obj);

4656

	dump_stack(__func__);

4657

	_write_unlock ();

4658

4659

4660

    _exit_trace ();

4661

    return ret;

4662

4663

4664

void

4665

cairo_ps_surface_set_size (cairo_surface_t *surface, double width_in_points, double height_in_points)

4666

4667

    _enter_trace ();

4668

    _emit_line_info ();

4669

    DLCALL (cairo_ps_surface_set_size, surface, width_in_points, height_in_points);

4670

    _exit_trace ();

4671

4672

4673

#endif

4674

4675

#if CAIRO_HAS_PDF_SURFACE

4676

#include <cairo-pdf.h>

4677

4678

cairo_surface_t *

4679

cairo_pdf_surface_create (const char *filename, double width_in_points, double height_in_points)

4680

4681

    cairo_surface_t *ret;

4682

4683

    _enter_trace ();

4684

4685

    ret = DLCALL (cairo_pdf_surface_create, filename, width_in_points, height_in_points);

4686

4687

    _emit_line_info ();

4688

    if (_write_lock ()) {

4689

	Object *obj = _create_surface (ret);

4690

4691

	_trace_printf ("dict\n"

4692

		       "  /type /PDF set\n"

4693

		       "  /filename ");

4694

	_emit_string_literal (filename, -1);

4695

	_trace_printf (" set\n"

4696

		       "  /width %g set\n"

4697

		       "  /height %g set\n"

4698

		       "  surface %% s%ld\n",

4699

		       width_in_points,

4700

		       height_in_points,

4701

		       obj->token);

4702

	obj->width = width_in_points;

4703

	obj->height = height_in_points;

4704

	_push_object (obj);

4705

	dump_stack(__func__);

4706

	_write_unlock ();

4707

4708

4709

    _exit_trace ();

4710

    return ret;

4711

4712

4713

cairo_surface_t *

4714

cairo_pdf_surface_create_for_stream (cairo_write_func_t write_func, void *closure, double width_in_points, double height_in_points)

4715

4716

    cairo_surface_t *ret;

4717

4718

    _enter_trace ();

4719

4720

    ret = DLCALL (cairo_pdf_surface_create_for_stream, write_func, closure, width_in_points, height_in_points);

4721

4722

    _emit_line_info ();

4723

    if (_write_lock ()) {

4724

	Object *obj = _create_surface (ret);

4725

4726

	_trace_printf ("dict\n"

4727

		       "  /type /PDF set\n"

4728

		       "  /width %g set\n"

4729

		       "  /height %g set\n"

4730

		       "  surface %% s%ld\n",

4731

		       width_in_points,

4732

		       height_in_points,

4733

		       obj->token);

4734

	obj->width = width_in_points;

4735

	obj->height = height_in_points;

4736

	_push_object (obj);

4737

	dump_stack(__func__);

4738

	_write_unlock ();

4739

4740

    _exit_trace ();

4741

    return ret;

4742

4743

4744

void

4745

cairo_pdf_surface_set_size (cairo_surface_t *surface, double width_in_points, double height_in_points)

4746

4747

    _enter_trace ();

4748

    _emit_line_info ();

4749

    DLCALL (cairo_pdf_surface_set_size, surface, width_in_points, height_in_points);

4750

    _exit_trace ();

4751

4752

#endif

4753

4754

#if CAIRO_HAS_SVG_SURFACE

4755

#include <cairo-svg.h>

4756

4757

cairo_surface_t *

4758

cairo_svg_surface_create (const char *filename, double width, double height)

4759

4760

    cairo_surface_t *ret;

4761

4762

    _enter_trace ();

4763

4764

    ret = DLCALL (cairo_svg_surface_create, filename, width, height);

4765

4766

    _emit_line_info ();

4767

    if (_write_lock ()) {

4768

	Object *obj = _create_surface (ret);

4769

4770

	_trace_printf ("dict\n"

4771

		       "  /type /SVG set\n"

4772

		       "  /filename ");

4773

	_emit_string_literal (filename, -1);

4774

	_trace_printf (" set\n"

4775

		       "  /width %g set\n"

4776

		       "  /height %g set\n"

4777

		       "  surface %% s%ld\n",

4778

		       width,

4779

		       height,

4780

		       obj->token);

4781

	obj->width = width;

4782

	obj->height = height;

4783

	_push_object (obj);

4784

	dump_stack(__func__);

4785

	_write_unlock ();

4786

4787

4788

    _exit_trace ();

4789

    return ret;

4790

4791

4792

cairo_surface_t *

4793

cairo_svg_surface_create_for_stream (cairo_write_func_t write_func, void *closure, double width, double height)

4794

4795

    cairo_surface_t *ret;

4796

4797

    _enter_trace ();

4798

4799

    ret = DLCALL (cairo_svg_surface_create_for_stream, write_func, closure, width, height);

4800

4801

    _emit_line_info ();

4802

    if (_write_lock ()) {

4803

	Object *obj = _create_surface (ret);

4804

4805

	_trace_printf ("dict\n"

4806

		       "  /type /SVG set\n"

4807

		       "  /width %g set\n"

4808

		       "  /height %g set\n"

4809

		       "  surface %% s%ld\n",

4810

		       width,

4811

		       height,

4812

		       obj->token);

4813

	obj->width = width;

4814

	obj->height = height;

4815

	_push_object (obj);

4816

	dump_stack(__func__);

4817

	_write_unlock ();

4818

4819

4820

    _exit_trace ();

4821

    return ret;

4822

4823

4824

#endif

4825

4826

#if CAIRO_HAS_PNG_FUNCTIONS

4827

cairo_surface_t *

4828

cairo_image_surface_create_from_png (const char *filename)

4829

4830

    cairo_surface_t *ret;

4831

4832

    _enter_trace ();

4833

4834

    ret = DLCALL (cairo_image_surface_create_from_png, filename);

4835

4836

    _emit_line_info ();

4837

    if (_write_lock ()) {

4838

	Object *obj = _create_surface (ret);

4839

	char filename_string[4096];

4840

4841

	_encode_string_literal (filename_string, sizeof (filename_string),

4842

				filename, -1);

4843

	_emit_image (ret, "  /filename %s set\n", filename_string);

4844

	_trace_printf (" dup /s%ld exch def\n", obj->token);

4845

	_surface_object_set_size_from_surface (ret);

4846

	obj->defined = TRUE;

4847

	_push_object (obj);

4848

	dump_stack(__func__);

4849

	_write_unlock ();

4850

4851

4852

    _exit_trace ();

4853

    return ret;

4854

4855

4856

cairo_surface_t *

4857

cairo_image_surface_create_from_png_stream (cairo_read_func_t read_func, void *closure)

4858

4859

    cairo_surface_t *ret;

4860

4861

    _enter_trace ();

4862

4863

    ret = DLCALL (cairo_image_surface_create_from_png_stream, read_func, closure);

4864

4865

    _emit_line_info ();

4866

    if (_write_lock ()) {

4867

	Object *obj = _create_surface (ret);

4868

4869

	_emit_image (ret, NULL);

4870

	_trace_printf (" dup /s%ld exch def\n",

4871

		       obj->token);

4872

4873

	_surface_object_set_size_from_surface (ret);

4874

	obj->defined = TRUE;

4875

	_push_object (obj);

4876

	dump_stack(__func__);

4877

	_write_unlock ();

4878

4879

4880

    _exit_trace ();

4881

    return ret;

4882

4883

#endif

4884

4885

#if CAIRO_HAS_TEE_SURFACE

4886

#include <cairo-tee.h>

4887

4888

cairo_surface_t *

4889

cairo_tee_surface_create (cairo_surface_t *master)

4890

4891

    cairo_surface_t *ret;

4892

4893

    _enter_trace ();

4894

4895

    ret = DLCALL (cairo_tee_surface_create, master);

4896

4897

    _emit_line_info ();

4898

    if (_write_lock ()) {

4899

	Object *obj = _create_surface (ret);

4900

4901

	_trace_printf ("dict\n"

4902

		       "  /type /tee set\n"

4903

		       "  /master s%ld set\n"

4904

		       "  surface dup /s%ld exch def\n",

4905

		       _get_object (SURFACE, master)->token,

4906

		       obj->token);

4907

	obj->defined = TRUE;

4908

	_push_object (obj);

4909

	dump_stack(__func__);

4910

	_write_unlock ();

4911

4912

4913

    _exit_trace ();

4914

    return ret;

4915

4916

4917

#endif

4918

4919

#if CAIRO_HAS_XLIB_SURFACE

4920

#include <cairo-xlib.h>

4921

4922

static const char *

4923

_content_from_surface (cairo_surface_t *surface)

4924

4925

    return _content_to_string (DLCALL (cairo_surface_get_content, surface));

4926

4927

4928

cairo_surface_t *

4929

cairo_xlib_surface_create (Display *dpy,

4930

			   Drawable drawable,

4931

			   Visual *visual,

4932

			   int width, int height)

4933

4934

    cairo_surface_t *ret;

4935

4936

    _enter_trace ();

4937

4938

    ret = DLCALL (cairo_xlib_surface_create,

4939

	          dpy, drawable, visual, width, height);

4940

4941

    _emit_line_info ();

4942

    if (_write_lock ()) {

4943

	Object *obj = _create_surface (ret);

4944

4945

	_trace_printf ("dict\n"

4946

		       "  /type /xlib set\n"

4947

		       "  /drawable 16!%lx set\n"

4948

		       "  /content //%s set\n"

4949

		       "  /width %d set\n"

4950

		       "  /height %d set\n"

4951

		       "  surface dup /s%ld exch def\n",

4952

		       drawable,

4953

		       _content_from_surface (ret),

4954

		       width, height,

4955

		       obj->token);

4956

	obj->defined = TRUE;

4957

	obj->width = width;

4958

	obj->height = height;

4959

	obj->foreign = TRUE;

4960

	_push_object (obj);

4961

	dump_stack(__func__);

4962

	_write_unlock ();

4963

4964

4965

    _exit_trace ();

4966

    return ret;

4967

4968

4969

cairo_surface_t *

4970

cairo_xlib_surface_create_for_bitmap (Display *dpy,

4971

				      Pixmap bitmap,

4972

				      Screen *screen,

4973

				      int width, int height)

4974

4975

    cairo_surface_t *ret;

4976

4977

    _enter_trace ();

4978

4979

    ret = DLCALL (cairo_xlib_surface_create_for_bitmap,

4980

	          dpy, bitmap, screen, width, height);

4981

4982

    _emit_line_info ();

4983

    if (_write_lock ()) {

4984

	Object *obj = _create_surface (ret);

4985

4986

	_trace_printf ("dict\n"

4987

		       "  /type /xlib set\n"

4988

		       "  /drawable 16!%lx set\n"

4989

		       "  /content //%s set\n"

4990

		       "  /width %d set\n"

4991

		       "  /height %d set\n"

4992

		       "  /depth 1 set\n"

4993

		       "  surface dup /s%ld exch def\n",

4994

		       bitmap,

4995

		       _content_from_surface (ret),

4996

		       width, height,

4997

		       obj->token);

4998

	obj->defined = TRUE;

4999

	obj->width = width;

5000

	obj->height = height;

5001

	obj->foreign = TRUE;

5002

	_push_object (obj);

5003

	dump_stack(__func__);

5004

	_write_unlock ();

5005

5006

5007

    _exit_trace ();

5008

    return ret;

5009

5010

5011

#if CAIRO_HAS_XLIB_XRENDER_SURFACE

5012

#include <cairo-xlib-xrender.h>

5013

cairo_surface_t *

5014

cairo_xlib_surface_create_with_xrender_format (Display *dpy,

5015

					       Drawable drawable,

5016

					       Screen *screen,

5017

					       XRenderPictFormat *format,

5018

					       int width, int height)

5019

5020

    cairo_surface_t *ret;

5021

5022

    _enter_trace ();

5023

5024

    ret = DLCALL (cairo_xlib_surface_create_with_xrender_format,

5025

	          dpy, drawable, screen, format, width, height);

5026

5027

    _emit_line_info ();

5028

    if (_write_lock ()) {

5029

	Object *obj = _create_surface (ret);

5030

5031

	_trace_printf ("dict\n"

5032

		       "  /type /xrender set\n"

5033

		       "  /drawable 16!%lx set\n"

5034

		       "  /content //%s set\n"

5035

		       "  /width %d set\n"

5036

		       "  /height %d set\n"

5037

		       "  /depth %d set\n"

5038

		       "  surface dup /s%ld exch def\n",

5039

		       drawable,

5040

		       _content_from_surface (ret),

5041

		       width, height,

5042

		       format->depth,

5043

		       obj->token);

5044

	obj->defined = TRUE;

5045

	obj->width = width;

5046

	obj->height = height;

5047

	obj->foreign = TRUE;

5048

	_push_object (obj);

5049

	dump_stack(__func__);

5050

	_write_unlock ();

5051

5052

5053

    _exit_trace ();

5054

    return ret;

5055

5056

#endif

5057

#endif

5058

5059

#if CAIRO_HAS_SCRIPT_SURFACE

5060

#include <cairo-script.h>

5061

cairo_surface_t *

5062

cairo_script_surface_create (cairo_device_t *device,

5063

			     cairo_content_t content,

5064

			     double width,

5065

			     double height)

5066

5067

    cairo_surface_t *ret;

5068

5069

    _enter_trace ();

5070

5071

    ret = DLCALL (cairo_script_surface_create, device, content, width, height);

5072

5073

    _emit_line_info ();

5074

    if (_write_lock ()) {

5075

	Object *obj = _create_surface (ret);

5076

5077

	_trace_printf ("dict\n"

5078

		       "  /type /script set\n"

5079

		       "  /content %s set\n"

5080

		       "  /width %g set\n"

5081

		       "  /height %g set\n"

5082

		       "  surface dup /s%ld exch def\n",

5083

		       _content_to_string (content),

5084

		       width, height,

5085

		       obj->token);

5086

	obj->width = width;

5087

	obj->height = height;

5088

	obj->defined = TRUE;

5089

	_push_object (obj);

5090

	dump_stack(__func__);

5091

	_write_unlock ();

5092

5093

5094

    _exit_trace ();

5095

    return ret;

5096

5097

5098

cairo_surface_t *

5099

cairo_script_surface_create_for_target (cairo_device_t *device,

5100

					cairo_surface_t *target)

5101

5102

    cairo_surface_t *ret;

5103

5104

    _enter_trace ();

5105

5106

    ret = DLCALL (cairo_script_surface_create_for_target, device, target);

5107

5108

    _emit_line_info ();

5109

    if (_write_lock ()) {

5110

	Object *obj = _create_surface (ret);

5111

5112

	_trace_printf ("dict\n"

5113

		       "  /type /script set\n"

5114

		       "  surface dup /s%ld exch def\n",

5115

		       obj->token);

5116

	obj->defined = TRUE;

5117

	_push_object (obj);

5118

	dump_stack(__func__);

5119

	_write_unlock ();

5120

5121

5122

    _exit_trace ();

5123

    return ret;

5124

5125

#endif

5126

5127

#if CAIRO_HAS_TEST_SURFACES

5128

#include <test-paginated-surface.h>

5129

cairo_surface_t *

5130

_cairo_test_paginated_surface_create (cairo_surface_t *surface)

5131

5132

    cairo_surface_t *ret;

5133

5134

    _enter_trace ();

5135

5136

    ret = DLCALL (_cairo_test_paginated_surface_create, surface);

5137

5138

    _emit_line_info ();

5139

    if (_write_lock ()) {

5140

	Object *obj = _create_surface (ret);

5141

5142

	/* XXX store initial data? */

5143

	_trace_printf ("dict\n"

5144

		       "  /type /test-paginated set\n"

5145

		       "  /target s%ld set\n"

5146

		       "  surface dup /s%ld exch def\n",

5147

		       _get_surface_id (surface),

5148

		       obj->token);

5149

	_push_object (obj);

5150

	dump_stack(__func__);

5151

	_write_unlock ();

5152

5153

5154

    _exit_trace ();

5155

    return ret;

5156

5157

5158

#include <test-compositor-surface.h>

5159

5160

cairo_surface_t *

5161

_cairo_test_fallback_compositor_surface_create (cairo_content_t content, int width, int height)

5162

5163

    cairo_surface_t *ret;

5164

5165

    _enter_trace ();

5166

5167

    ret = DLCALL (_cairo_test_fallback_compositor_surface_create, content, width, height);

5168

5169

    _emit_line_info ();

5170

    if (_write_lock ()) {

5171

	Object *obj = _create_surface (ret);

5172

5173

	_trace_printf ("dict\n"

5174

		       "  /type /test-fallback-compositor set\n"

5175

		       "  /content //%s set\n"

5176

		       "  /width %d set\n"

5177

		       "  /height %d set\n"

5178

		       "  surface dup /s%ld exch def\n",

5179

		       _content_to_string (content),

5180

		       width, height,

5181

		       obj->token);

5182

	obj->defined = TRUE;

5183

	_push_object (obj);

5184

	dump_stack(__func__);

5185

	_write_unlock ();

5186

5187

5188

    _exit_trace ();

5189

    return ret;

5190

5191

5192

cairo_surface_t *

5193

_cairo_test_mask_compositor_surface_create (cairo_content_t content, int width, int height)

5194

5195

    cairo_surface_t *ret;

5196

5197

    _enter_trace ();

5198

5199

    ret = DLCALL (_cairo_test_mask_compositor_surface_create, content, width, height);

5200

5201

    _emit_line_info ();

5202

    if (_write_lock ()) {

5203

	Object *obj = _create_surface (ret);

5204

5205

	_trace_printf ("dict\n"

5206

		       "  /type /test-mask-compositor set\n"

5207

		       "  /content //%s set\n"

5208

		       "  /width %d set\n"

5209

		       "  /height %d set\n"

5210

		       "  surface dup /s%ld exch def\n",

5211

		       _content_to_string (content),

5212

		       width, height,

5213

		       obj->token);

5214

	obj->defined = TRUE;

5215

	_push_object (obj);

5216

	dump_stack(__func__);

5217

	_write_unlock ();

5218

5219

5220

    _exit_trace ();

5221

    return ret;

5222

5223

5224

cairo_surface_t *

5225

_cairo_test_spans_compositor_surface_create (cairo_content_t content, int width, int height)

5226

5227

    cairo_surface_t *ret;

5228

5229

    _enter_trace ();

5230

5231

    ret = DLCALL (_cairo_test_spans_compositor_surface_create, content, width, height);

5232

5233

    _emit_line_info ();

5234

    if (_write_lock ()) {

5235

	Object *obj = _create_surface (ret);

5236

5237

	_trace_printf ("dict\n"

5238

		       "  /type /test-spans-compositor set\n"

5239

		       "  /content //%s set\n"

5240

		       "  /width %d set\n"

5241

		       "  /height %d set\n"

5242

		       "  surface dup /s%ld exch def\n",

5243

		       _content_to_string (content),

5244

		       width, height,

5245

		       obj->token);

5246

	obj->defined = TRUE;

5247

	_push_object (obj);

5248

	dump_stack(__func__);

5249

	_write_unlock ();

5250

5251

5252

    _exit_trace ();

5253

    return ret;

5254

5255

5256

cairo_surface_t *

5257

_cairo_test_traps_compositor_surface_create (cairo_content_t content, int width, int height)

5258

5259

    cairo_surface_t *ret;

5260

5261

    _enter_trace ();

5262

5263

    ret = DLCALL (_cairo_test_traps_compositor_surface_create, content, width, height);

5264

5265

    _emit_line_info ();

5266

    if (_write_lock ()) {

5267

	Object *obj = _create_surface (ret);

5268

5269

	_trace_printf ("dict\n"

5270

		       "  /type /test-traps-compositor set\n"

5271

		       "  /content //%s set\n"

5272

		       "  /width %d set\n"

5273

		       "  /height %d set\n"

5274

		       "  surface dup /s%ld exch def\n",

5275

		       _content_to_string (content),

5276

		       width, height,

5277

		       obj->token);

5278

	obj->defined = TRUE;

5279

	_push_object (obj);

5280

	dump_stack(__func__);

5281

	_write_unlock ();

5282

5283

5284

    _exit_trace ();

5285

    return ret;

5286

5287

5288

#endif

5289

5290

cairo_surface_t *

5291

cairo_recording_surface_create (cairo_content_t content,

5292

				const cairo_rectangle_t *extents)

5293

5294

    cairo_surface_t *ret;

5295

5296

    _enter_trace ();

5297

5298

    ret = DLCALL (cairo_recording_surface_create, content, extents);

5299

5300

    _emit_line_info ();

5301

    if (_write_lock ()) {

5302

	Object *obj = _create_surface (ret);

5303

5304

	if (extents) {

5305

	    _trace_printf ("//%s [ %f %f %f %f ] record dup /s%ld exch def\n",

5306

			   _content_to_string (content),

5307

			   extents->x, extents->y,

5308

			   extents->width, extents->height,

5309

			   obj->token);

5310

	    obj->width = extents->width;

5311

	    obj->height = extents->height;

5312

	} else {

5313

	    _trace_printf ("//%s [ ] record dup /s%ld exch def\n",

5314

			   _content_to_string (content),

5315

			   obj->token);

5316

5317

	obj->defined = TRUE;

5318

	_push_object (obj);

5319

	dump_stack(__func__);

5320

	_write_unlock ();

5321

5322

5323

    _exit_trace ();

5324

    return ret;

5325