Github User Fetcher 1.0.0
C Application with Server and GUI
Loading...
Searching...
No Matches
Data Structures | Macros | Typedefs | Functions
duk_trans_dvalue.h File Reference
#include "duktape.h"

Go to the source code of this file.

Data Structures

struct  duk_dvalue
 
struct  duk_trans_buffer
 
struct  duk_trans_dvalue_ctx
 

Macros

#define DUK_DVALUE_EOM   1 /* no fields */
 
#define DUK_DVALUE_REQ   2 /* no fields */
 
#define DUK_DVALUE_REP   3 /* no fields */
 
#define DUK_DVALUE_ERR   4 /* no fields */
 
#define DUK_DVALUE_NFY   5 /* no fields */
 
#define DUK_DVALUE_INTEGER   6 /* i: 32-bit signed integer */
 
#define DUK_DVALUE_STRING   7 /* buf: string data, len: string length */
 
#define DUK_DVALUE_BUFFER   8 /* buf: buffer data, len: buffer length */
 
#define DUK_DVALUE_UNUSED   9 /* no fields */
 
#define DUK_DVALUE_UNDEFINED   10 /* no fields */
 
#define DUK_DVALUE_NULL   11 /* no fields */
 
#define DUK_DVALUE_TRUE   12 /* no fields */
 
#define DUK_DVALUE_FALSE   13 /* no fields */
 
#define DUK_DVALUE_NUMBER   14 /* d: ieee double */
 
#define DUK_DVALUE_OBJECT   15 /* i: class number, buf: pointer data, len: pointer length */
 
#define DUK_DVALUE_POINTER   16 /* buf: pointer data, len: pointer length */
 
#define DUK_DVALUE_LIGHTFUNC   17 /* i: lightfunc flags, buf: pointer data, len: pointer length */
 
#define DUK_DVALUE_HEAPPTR   18 /* buf: pointer data, len: pointer length */
 
#define DUK_DVALUE_TOSTRING_BUFLEN   256
 

Typedefs

typedef struct duk_dvalue duk_dvalue
 
typedef struct duk_trans_buffer duk_trans_buffer
 
typedef struct duk_trans_dvalue_ctx duk_trans_dvalue_ctx
 
typedef void(* duk_trans_dvalue_received_function) (duk_trans_dvalue_ctx *ctx, duk_dvalue *dv)
 
typedef void(* duk_trans_dvalue_cooperate_function) (duk_trans_dvalue_ctx *ctx, int block)
 
typedef void(* duk_trans_dvalue_handshake_function) (duk_trans_dvalue_ctx *ctx, const char *handshake_line)
 
typedef void(* duk_trans_dvalue_detached_function) (duk_trans_dvalue_ctx *ctx)
 

Functions

duk_dvalue * duk_dvalue_alloc (void)
 
void duk_dvalue_free (duk_dvalue *dv)
 
void duk_dvalue_to_string (duk_dvalue *dv, char *buf)
 
duk_dvalue * duk_dvalue_make_tag (int tag)
 
duk_dvalue * duk_dvalue_make_tag_int (int tag, int intval)
 
duk_dvalue * duk_dvalue_make_tag_double (int tag, double dblval)
 
duk_dvalue * duk_dvalue_make_tag_data (int tag, const char *buf, size_t len)
 
duk_dvalue * duk_dvalue_make_tag_int_data (int tag, int intval, const char *buf, size_t len)
 
duk_trans_dvalue_ctx * duk_trans_dvalue_init (void)
 
void duk_trans_dvalue_free (duk_trans_dvalue_ctx *ctx)
 
void duk_trans_dvalue_send (duk_trans_dvalue_ctx *ctx, duk_dvalue *dv)
 
void duk_trans_dvalue_send_eom (duk_trans_dvalue_ctx *ctx)
 
void duk_trans_dvalue_send_req (duk_trans_dvalue_ctx *ctx)
 
void duk_trans_dvalue_send_rep (duk_trans_dvalue_ctx *ctx)
 
void duk_trans_dvalue_send_err (duk_trans_dvalue_ctx *ctx)
 
void duk_trans_dvalue_send_nfy (duk_trans_dvalue_ctx *ctx)
 
void duk_trans_dvalue_send_integer (duk_trans_dvalue_ctx *ctx, int val)
 
void duk_trans_dvalue_send_string (duk_trans_dvalue_ctx *ctx, const char *str)
 
void duk_trans_dvalue_send_lstring (duk_trans_dvalue_ctx *ctx, const char *str, size_t len)
 
void duk_trans_dvalue_send_buffer (duk_trans_dvalue_ctx *ctx, const char *buf, size_t len)
 
void duk_trans_dvalue_send_unused (duk_trans_dvalue_ctx *ctx)
 
void duk_trans_dvalue_send_undefined (duk_trans_dvalue_ctx *ctx)
 
void duk_trans_dvalue_send_null (duk_trans_dvalue_ctx *ctx)
 
void duk_trans_dvalue_send_true (duk_trans_dvalue_ctx *ctx)
 
void duk_trans_dvalue_send_false (duk_trans_dvalue_ctx *ctx)
 
void duk_trans_dvalue_send_number (duk_trans_dvalue_ctx *ctx, double val)
 
void duk_trans_dvalue_send_object (duk_trans_dvalue_ctx *ctx, int classnum, const char *ptr_data, size_t ptr_len)
 
void duk_trans_dvalue_send_pointer (duk_trans_dvalue_ctx *ctx, const char *ptr_data, size_t ptr_len)
 
void duk_trans_dvalue_send_lightfunc (duk_trans_dvalue_ctx *ctx, int lf_flags, const char *ptr_data, size_t ptr_len)
 
void duk_trans_dvalue_send_heapptr (duk_trans_dvalue_ctx *ctx, const char *ptr_data, size_t ptr_len)
 
void duk_trans_dvalue_send_req_cmd (duk_trans_dvalue_ctx *ctx, int cmd)
 
duk_size_t duk_trans_dvalue_read_cb (void *udata, char *buffer, duk_size_t length)
 
duk_size_t duk_trans_dvalue_write_cb (void *udata, const char *buffer, duk_size_t length)
 
duk_size_t duk_trans_dvalue_peek_cb (void *udata)
 
void duk_trans_dvalue_read_flush_cb (void *udata)
 
void duk_trans_dvalue_write_flush_cb (void *udata)
 
void duk_trans_dvalue_detached_cb (void *udata)
 

Macro Definition Documentation

◆ DUK_DVALUE_BUFFER

#define DUK_DVALUE_BUFFER   8 /* buf: buffer data, len: buffer length */

Definition at line 26 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h.

Referenced by duk__trans_trial_parse_dvalue(), duk__trans_trial_parse_dvalue(), duk_dvalue_to_string(), duk_trans_dvalue_send(), and duk_trans_dvalue_send_buffer().

◆ DUK_DVALUE_EOM

#define DUK_DVALUE_EOM   1 /* no fields */

Definition at line 19 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h.

Referenced by duk__trans_trial_parse_dvalue(), duk__trans_trial_parse_dvalue(), duk_dvalue_to_string(), duk_trans_dvalue_send(), and duk_trans_dvalue_send_eom().

◆ DUK_DVALUE_ERR

#define DUK_DVALUE_ERR   4 /* no fields */

Definition at line 22 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h.

Referenced by duk__trans_trial_parse_dvalue(), duk__trans_trial_parse_dvalue(), duk_dvalue_to_string(), duk_trans_dvalue_send(), and duk_trans_dvalue_send_err().

◆ DUK_DVALUE_FALSE

#define DUK_DVALUE_FALSE   13 /* no fields */

Definition at line 31 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h.

Referenced by duk__trans_trial_parse_dvalue(), duk__trans_trial_parse_dvalue(), duk_dvalue_to_string(), duk_trans_dvalue_send(), and duk_trans_dvalue_send_false().

◆ DUK_DVALUE_HEAPPTR

#define DUK_DVALUE_HEAPPTR   18 /* buf: pointer data, len: pointer length */

Definition at line 36 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h.

Referenced by duk__trans_trial_parse_dvalue(), duk__trans_trial_parse_dvalue(), duk_dvalue_to_string(), duk_trans_dvalue_send(), and duk_trans_dvalue_send_heapptr().

◆ DUK_DVALUE_INTEGER

#define DUK_DVALUE_INTEGER   6 /* i: 32-bit signed integer */

Definition at line 24 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h.

Referenced by duk__trans_trial_parse_dvalue(), duk__trans_trial_parse_dvalue(), duk_dvalue_to_string(), duk_trans_dvalue_send(), and duk_trans_dvalue_send_integer().

◆ DUK_DVALUE_LIGHTFUNC

#define DUK_DVALUE_LIGHTFUNC   17 /* i: lightfunc flags, buf: pointer data, len: pointer length */

Definition at line 35 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h.

Referenced by duk__trans_trial_parse_dvalue(), duk__trans_trial_parse_dvalue(), duk_dvalue_to_string(), duk_trans_dvalue_send(), and duk_trans_dvalue_send_lightfunc().

◆ DUK_DVALUE_NFY

#define DUK_DVALUE_NFY   5 /* no fields */

Definition at line 23 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h.

Referenced by duk__trans_trial_parse_dvalue(), duk__trans_trial_parse_dvalue(), duk_dvalue_to_string(), duk_trans_dvalue_send(), and duk_trans_dvalue_send_nfy().

◆ DUK_DVALUE_NULL

#define DUK_DVALUE_NULL   11 /* no fields */

Definition at line 29 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h.

Referenced by duk__trans_trial_parse_dvalue(), duk__trans_trial_parse_dvalue(), duk_dvalue_to_string(), duk_trans_dvalue_send(), and duk_trans_dvalue_send_null().

◆ DUK_DVALUE_NUMBER

#define DUK_DVALUE_NUMBER   14 /* d: ieee double */

Definition at line 32 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h.

Referenced by duk__trans_trial_parse_dvalue(), duk__trans_trial_parse_dvalue(), duk_dvalue_to_string(), duk_trans_dvalue_send(), and duk_trans_dvalue_send_number().

◆ DUK_DVALUE_OBJECT

#define DUK_DVALUE_OBJECT   15 /* i: class number, buf: pointer data, len: pointer length */

Definition at line 33 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h.

Referenced by duk__trans_trial_parse_dvalue(), duk__trans_trial_parse_dvalue(), duk_dvalue_to_string(), duk_trans_dvalue_send(), and duk_trans_dvalue_send_object().

◆ DUK_DVALUE_POINTER

#define DUK_DVALUE_POINTER   16 /* buf: pointer data, len: pointer length */

Definition at line 34 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h.

Referenced by duk__trans_trial_parse_dvalue(), duk__trans_trial_parse_dvalue(), duk_dvalue_to_string(), duk_trans_dvalue_send(), and duk_trans_dvalue_send_pointer().

◆ DUK_DVALUE_REP

#define DUK_DVALUE_REP   3 /* no fields */

Definition at line 21 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h.

Referenced by duk__trans_trial_parse_dvalue(), duk__trans_trial_parse_dvalue(), duk_dvalue_to_string(), duk_trans_dvalue_send(), and duk_trans_dvalue_send_rep().

◆ DUK_DVALUE_REQ

#define DUK_DVALUE_REQ   2 /* no fields */

Definition at line 20 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h.

Referenced by duk__trans_trial_parse_dvalue(), duk__trans_trial_parse_dvalue(), duk_dvalue_to_string(), duk_trans_dvalue_send(), and duk_trans_dvalue_send_req().

◆ DUK_DVALUE_STRING

#define DUK_DVALUE_STRING   7 /* buf: string data, len: string length */

Definition at line 25 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h.

Referenced by duk__trans_trial_parse_dvalue(), duk__trans_trial_parse_dvalue(), duk__trans_trial_parse_handshake(), duk__trans_trial_parse_handshake(), duk_dvalue_to_string(), duk_trans_dvalue_send(), duk_trans_dvalue_send_lstring(), and duk_trans_dvalue_send_string().

◆ DUK_DVALUE_TOSTRING_BUFLEN

#define DUK_DVALUE_TOSTRING_BUFLEN   256

Definition at line 66 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h.

Referenced by duk_trans_dvalue_send(), duk_trans_dvalue_write_cb(), and my_received().

◆ DUK_DVALUE_TRUE

#define DUK_DVALUE_TRUE   12 /* no fields */

Definition at line 30 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h.

Referenced by duk__trans_trial_parse_dvalue(), duk__trans_trial_parse_dvalue(), duk_dvalue_to_string(), duk_trans_dvalue_send(), and duk_trans_dvalue_send_true().

◆ DUK_DVALUE_UNDEFINED

#define DUK_DVALUE_UNDEFINED   10 /* no fields */

Definition at line 28 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h.

Referenced by duk__trans_trial_parse_dvalue(), duk__trans_trial_parse_dvalue(), duk_dvalue_to_string(), duk_trans_dvalue_send(), and duk_trans_dvalue_send_undefined().

◆ DUK_DVALUE_UNUSED

#define DUK_DVALUE_UNUSED   9 /* no fields */

Definition at line 27 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h.

Referenced by duk__trans_trial_parse_dvalue(), duk__trans_trial_parse_dvalue(), duk_dvalue_to_string(), duk_trans_dvalue_send(), and duk_trans_dvalue_send_unused().

Typedef Documentation

◆ duk_dvalue

typedef struct duk_dvalue duk_dvalue

Definition at line 6 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h.

◆ duk_trans_buffer

typedef struct duk_trans_buffer duk_trans_buffer

Definition at line 7 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h.

◆ duk_trans_dvalue_cooperate_function

typedef void(* duk_trans_dvalue_cooperate_function) (duk_trans_dvalue_ctx *ctx, int block)

Definition at line 11 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h.

◆ duk_trans_dvalue_ctx

typedef struct duk_trans_dvalue_ctx duk_trans_dvalue_ctx

Definition at line 8 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h.

◆ duk_trans_dvalue_detached_function

typedef void(* duk_trans_dvalue_detached_function) (duk_trans_dvalue_ctx *ctx)

Definition at line 13 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h.

◆ duk_trans_dvalue_handshake_function

typedef void(* duk_trans_dvalue_handshake_function) (duk_trans_dvalue_ctx *ctx, const char *handshake_line)

Definition at line 12 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h.

◆ duk_trans_dvalue_received_function

typedef void(* duk_trans_dvalue_received_function) (duk_trans_dvalue_ctx *ctx, duk_dvalue *dv)

Definition at line 10 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h.

Function Documentation

◆ duk_dvalue_alloc()

duk_dvalue * duk_dvalue_alloc ( void )

Definition at line 51 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c.

51 {
52 duk_dvalue *dv = (duk_dvalue *) malloc(sizeof(duk_dvalue));
53 if (dv) {
54 memset((void *) dv, 0, sizeof(duk_dvalue));
55 dv->buf = NULL;
56 }
57 return dv;
58}
malloc
#define malloc
Definition civetweb.c:1539
NULL
#define NULL
Definition gmacros.h:924
duk_dvalue
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h:38

◆ duk_dvalue_free()

void duk_dvalue_free ( duk_dvalue * dv)

Definition at line 60 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c.

60 {
61 if (dv) {
62 free(dv->buf); /* tolerates NULL */
63 dv->buf = NULL;
64 free(dv);
65 }
66}
free
#define free
Definition civetweb.c:1542
duk_dvalue::buf
unsigned char * buf
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h:44

◆ duk_dvalue_make_tag()

duk_dvalue * duk_dvalue_make_tag ( int tag)

Definition at line 177 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c.

177 {
178 duk_dvalue *dv = duk_dvalue_alloc();
179 if (!dv) { return NULL; }
180 dv->tag = tag;
181 return dv;
182}
duk_dvalue_alloc
duk_dvalue * duk_dvalue_alloc(void)
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c:51
duk_dvalue::tag
int tag
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h:40

◆ duk_dvalue_make_tag_data()

duk_dvalue * duk_dvalue_make_tag_data ( int tag,
const char * buf,
size_t len )

Definition at line 200 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c.

200 {
201 unsigned char *p;
202 duk_dvalue *dv = duk_dvalue_alloc();
203 if (!dv) { return NULL; }
204 /* Alloc size is len + 1 so that a NUL terminator is always
205 * guaranteed which is convenient, e.g. you can printf() the
206 * value safely.
207 */
208 p = (unsigned char *) malloc(len + 1);
209 if (!p) {
210 free(dv);
211 return NULL;
212 }
213 memcpy((void *) p, (const void *) buf, len);
214 p[len] = (unsigned char) 0;
215 dv->tag = tag;
216 dv->buf = p;
217 dv->len = len;
218 return dv;
219}
duk_dvalue::len
size_t len
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h:43

◆ duk_dvalue_make_tag_double()

duk_dvalue * duk_dvalue_make_tag_double ( int tag,
double dblval )

Definition at line 192 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c.

192 {
193 duk_dvalue *dv = duk_dvalue_alloc();
194 if (!dv) { return NULL; }
195 dv->tag = tag;
196 dv->d = dblval;
197 return dv;
198}
duk_dvalue::d
double d
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h:42

◆ duk_dvalue_make_tag_int()

duk_dvalue * duk_dvalue_make_tag_int ( int tag,
int intval )

Definition at line 184 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c.

184 {
185 duk_dvalue *dv = duk_dvalue_alloc();
186 if (!dv) { return NULL; }
187 dv->tag = tag;
188 dv->i = intval;
189 return dv;
190}
duk_dvalue::i
int i
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h:41

◆ duk_dvalue_make_tag_int_data()

duk_dvalue * duk_dvalue_make_tag_int_data ( int tag,
int intval,
const char * buf,
size_t len )

Definition at line 221 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c.

221 {
222 duk_dvalue *dv = duk_dvalue_make_tag_data(tag, buf, len);
223 if (!dv) { return NULL; }
224 dv->i = intval;
225 return dv;
226}
duk_dvalue_make_tag_data
duk_dvalue * duk_dvalue_make_tag_data(int tag, const char *buf, size_t len)
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c:200

◆ duk_dvalue_to_string()

void duk_dvalue_to_string ( duk_dvalue * dv,
char * buf )

Definition at line 95 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c.

95 {
96 char hexbuf[32 * 4 + 4]; /* 32 hex encoded or \xXX escaped bytes, possible "...", NUL */
97
98 if (!dv) {
99 sprintf(buf, "NULL");
100 return;
101 }
102
103 switch (dv->tag) {
104 case DUK_DVALUE_EOM:
105 sprintf(buf, "EOM");
106 break;
107 case DUK_DVALUE_REQ:
108 sprintf(buf, "REQ");
109 break;
110 case DUK_DVALUE_REP:
111 sprintf(buf, "REP");
112 break;
113 case DUK_DVALUE_ERR:
114 sprintf(buf, "ERR");
115 break;
116 case DUK_DVALUE_NFY:
117 sprintf(buf, "NFY");
118 break;
119 case DUK_DVALUE_INTEGER:
120 sprintf(buf, "%d", dv->i);
121 break;
122 case DUK_DVALUE_STRING:
123 duk__dvalue_bufesc(dv, hexbuf, 32, 1);
124 sprintf(buf, "str:%ld:\"%s\"", (long) dv->len, hexbuf);
125 break;
126 case DUK_DVALUE_BUFFER:
127 duk__dvalue_bufesc(dv, hexbuf, 32, 0);
128 sprintf(buf, "buf:%ld:%s", (long) dv->len, hexbuf);
129 break;
130 case DUK_DVALUE_UNUSED:
131 sprintf(buf, "undefined");
132 break;
133 case DUK_DVALUE_UNDEFINED:
134 sprintf(buf, "undefined");
135 break;
136 case DUK_DVALUE_NULL:
137 sprintf(buf, "null");
138 break;
139 case DUK_DVALUE_TRUE:
140 sprintf(buf, "true");
141 break;
142 case DUK_DVALUE_FALSE:
143 sprintf(buf, "false");
144 break;
145 case DUK_DVALUE_NUMBER:
146 if (fpclassify(dv->d) == FP_ZERO) {
147 if (signbit(dv->d)) {
148 sprintf(buf, "-0");
149 } else {
150 sprintf(buf, "0");
151 }
152 } else {
153 sprintf(buf, "%lg", dv->d);
154 }
155 break;
156 case DUK_DVALUE_OBJECT:
157 duk__dvalue_bufesc(dv, hexbuf, 32, 0);
158 sprintf(buf, "obj:%d:%s", (int) dv->i, hexbuf);
159 break;
160 case DUK_DVALUE_POINTER:
161 duk__dvalue_bufesc(dv, hexbuf, 32, 0);
162 sprintf(buf, "ptr:%s", hexbuf);
163 break;
164 case DUK_DVALUE_LIGHTFUNC:
165 duk__dvalue_bufesc(dv, hexbuf, 32, 0);
166 sprintf(buf, "lfunc:%04x:%s", (unsigned int) dv->i, hexbuf);
167 break;
168 case DUK_DVALUE_HEAPPTR:
169 duk__dvalue_bufesc(dv, hexbuf, 32, 0);
170 sprintf(buf, "heapptr:%s", hexbuf);
171 break;
172 default:
173 sprintf(buf, "unknown:%d", (int) dv->tag);
174 }
175}
duk__dvalue_bufesc
static void duk__dvalue_bufesc(duk_dvalue *dv, char *buf, size_t maxbytes, int stresc)
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c:68
DUK_DVALUE_EOM
#define DUK_DVALUE_EOM
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h:19
DUK_DVALUE_UNUSED
#define DUK_DVALUE_UNUSED
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h:27
DUK_DVALUE_TRUE
#define DUK_DVALUE_TRUE
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h:30
DUK_DVALUE_STRING
#define DUK_DVALUE_STRING
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h:25
DUK_DVALUE_NFY
#define DUK_DVALUE_NFY
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h:23
DUK_DVALUE_REP
#define DUK_DVALUE_REP
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h:21
DUK_DVALUE_ERR
#define DUK_DVALUE_ERR
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h:22
DUK_DVALUE_NULL
#define DUK_DVALUE_NULL
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h:29
DUK_DVALUE_POINTER
#define DUK_DVALUE_POINTER
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h:34
DUK_DVALUE_BUFFER
#define DUK_DVALUE_BUFFER
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h:26
DUK_DVALUE_UNDEFINED
#define DUK_DVALUE_UNDEFINED
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h:28
DUK_DVALUE_INTEGER
#define DUK_DVALUE_INTEGER
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h:24
DUK_DVALUE_OBJECT
#define DUK_DVALUE_OBJECT
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h:33
DUK_DVALUE_LIGHTFUNC
#define DUK_DVALUE_LIGHTFUNC
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h:35
DUK_DVALUE_NUMBER
#define DUK_DVALUE_NUMBER
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h:32
DUK_DVALUE_FALSE
#define DUK_DVALUE_FALSE
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h:31
DUK_DVALUE_HEAPPTR
#define DUK_DVALUE_HEAPPTR
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h:36
DUK_DVALUE_REQ
#define DUK_DVALUE_REQ
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h:20

◆ duk_trans_dvalue_detached_cb()

void duk_trans_dvalue_detached_cb ( void * udata)

Definition at line 1230 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c.

1230 {
1231 duk_trans_dvalue_ctx *ctx = (duk_trans_dvalue_ctx *) udata;
1232
1233#if defined(DEBUG_PRINTS)
1234 fprintf(stderr, "%s: %p\n", __func__, udata);
1235 fflush(stderr);
1236#endif
1237
1238 duk__trans_call_detached(ctx);
1239}
duk__trans_call_detached
static void duk__trans_call_detached(duk_trans_dvalue_ctx *ctx)
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c:1093
duk_trans_dvalue_ctx
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h:54

◆ duk_trans_dvalue_free()

void duk_trans_dvalue_free ( duk_trans_dvalue_ctx * ctx)

Definition at line 452 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c.

452 {
453 if (ctx) {
454 free(ctx->send_buf.base); /* tolerates NULL */
455 free(ctx->recv_buf.base); /* tolerates NULL */
456 free(ctx);
457 }
458}
duk_trans_buffer::base
unsigned char * base
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h:48
duk_trans_dvalue_ctx::send_buf
duk_trans_buffer send_buf
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h:59
duk_trans_dvalue_ctx::recv_buf
duk_trans_buffer recv_buf
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h:60

◆ duk_trans_dvalue_init()

duk_trans_dvalue_ctx * duk_trans_dvalue_init ( void )

Definition at line 391 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c.

391 {
392 volatile union {
393 double d;
394 unsigned char b[8];
395 } u;
396 duk_trans_dvalue_ctx *ctx = NULL;
397
398 ctx = (duk_trans_dvalue_ctx *) malloc(sizeof(duk_trans_dvalue_ctx));
399 if (!ctx) { goto fail; }
400 memset((void *) ctx, 0, sizeof(duk_trans_dvalue_ctx));
401 ctx->received = NULL;
402 ctx->cooperate = NULL;
403 ctx->handshake = NULL;
404 ctx->detached = NULL;
405 ctx->send_buf.base = NULL;
406 ctx->recv_buf.base = NULL;
407
408 ctx->send_buf.base = malloc(256);
409 if (!ctx->send_buf.base) { goto fail; }
410 ctx->send_buf.alloc_size = 256;
411
412 ctx->recv_buf.base = malloc(256);
413 if (!ctx->recv_buf.base) { goto fail; }
414 ctx->recv_buf.alloc_size = 256;
415
416 /* IEEE double byte order, detect at run time (could also use
417 * preprocessor defines but that's verbose to make portable).
418 *
419 * >>> struct.unpack('>d', '1122334455667788'.decode('hex'))
420 * (3.841412024471731e-226,)
421 * >>> struct.unpack('>d', '8877665544332211'.decode('hex'))
422 * (-7.086876636573014e-268,)
423 * >>> struct.unpack('>d', '4433221188776655'.decode('hex'))
424 * (3.5294303071877444e+20,)
425 */
426 u.b[0] = 0x11; u.b[1] = 0x22; u.b[2] = 0x33; u.b[3] = 0x44;
427 u.b[4] = 0x55; u.b[5] = 0x66; u.b[6] = 0x77; u.b[7] = 0x88;
428 if (u.d < 0.0) {
429 ctx->double_byteorder = 0; /* little endian */
430 } else if (u.d < 1.0) {
431 ctx->double_byteorder = 1; /* big endian */
432 } else {
433 ctx->double_byteorder = 2; /* mixed endian (arm) */
434 }
435#if defined(DEBUG_PRINTS)
436 fprintf(stderr, "double endianness test value is %lg -> byteorder %d\n",
437 u.d, ctx->double_byteorder);
438 fflush(stderr);
439#endif
440
441 return ctx;
442
443 fail:
444 if (ctx) {
445 free(ctx->recv_buf.base); /* tolerates NULL */
446 free(ctx->send_buf.base); /* tolerates NULL */
447 free(ctx);
448 }
449 return NULL;
450}

◆ duk_trans_dvalue_peek_cb()

duk_size_t duk_trans_dvalue_peek_cb ( void * udata)

Definition at line 1194 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c.

1194 {
1195 duk_trans_dvalue_ctx *ctx = (duk_trans_dvalue_ctx *) udata;
1196 size_t avail;
1197
1198#if defined(DEBUG_PRINTS)
1199 fprintf(stderr, "%s: %p\n", __func__, udata);
1200 fflush(stderr);
1201#endif
1202
1203 duk__trans_call_cooperate(ctx, 0);
1204 avail = (size_t) (ctx->send_buf.write_offset - ctx->send_buf.read_offset);
1205 return (duk_size_t) avail;
1206}
duk__trans_call_cooperate
static void duk__trans_call_cooperate(duk_trans_dvalue_ctx *ctx, int block)
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c:1075
duk_size_t
size_t duk_size_t
Definition duktape-1.5.2/src-noline/duk_config.h:1770
duk_trans_buffer::write_offset
size_t write_offset
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h:49
duk_trans_buffer::read_offset
size_t read_offset
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h:50

◆ duk_trans_dvalue_read_cb()

duk_size_t duk_trans_dvalue_read_cb ( void * udata,
char * buffer,
duk_size_t length )

Definition at line 1103 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c.

1103 {
1104 duk_trans_dvalue_ctx *ctx = (duk_trans_dvalue_ctx *) udata;
1105
1106#if defined(DEBUG_PRINTS)
1107 fprintf(stderr, "%s: %p %p %ld\n", __func__, udata, (void *) buffer, (long) length);
1108 fflush(stderr);
1109#endif
1110
1111 duk__trans_call_cooperate(ctx, 0);
1112
1113 for (;;) {
1114 size_t avail, now;
1115
1116 avail = (size_t) (ctx->send_buf.write_offset - ctx->send_buf.read_offset);
1117 if (avail == 0) {
1118 /* Must cooperate until user callback provides data. From
1119 * Duktape's perspective we MUST block until data is received.
1120 */
1121 duk__trans_call_cooperate(ctx, 1);
1122 } else {
1123 now = avail;
1124 if (now > length) {
1125 now = length;
1126 }
1127 memcpy((void *) buffer, (const void *) (ctx->send_buf.base + ctx->send_buf.read_offset), now);
1128 duk__trans_buffer_rebase(&ctx->send_buf);
1129 ctx->send_buf.read_offset += now;
1130 return now;
1131 }
1132 }
1133}
duk__trans_buffer_rebase
static void duk__trans_buffer_rebase(duk_trans_buffer *dbuf)
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c:376

◆ duk_trans_dvalue_read_flush_cb()

void duk_trans_dvalue_read_flush_cb ( void * udata)

Definition at line 1208 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c.

1208 {
1209 duk_trans_dvalue_ctx *ctx = (duk_trans_dvalue_ctx *) udata;
1210
1211#if defined(DEBUG_PRINTS)
1212 fprintf(stderr, "%s: %p\n", __func__, udata);
1213 fflush(stderr);
1214#endif
1215
1216 duk__trans_call_cooperate(ctx, 0);
1217}

◆ duk_trans_dvalue_send()

void duk_trans_dvalue_send ( duk_trans_dvalue_ctx * ctx,
duk_dvalue * dv )

Definition at line 460 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c.

460 {
461 unsigned char *p;
462
463 /* Convert argument dvalue into Duktape debug protocol format.
464 * Literal constants are used here for the debug protocol,
465 * e.g. initial byte 0x02 is REP, see doc/debugger.rst.
466 */
467
468#if defined(DEBUG_PRINTS)
469 {
470 char buf[DUK_DVALUE_TOSTRING_BUFLEN];
471 duk_dvalue_to_string(dv, buf);
472 fprintf(stderr, "%s: sending dvalue: %s\n", __func__, buf);
473 fflush(stderr);
474 }
475#endif
476
477 switch (dv->tag) {
478 case DUK_DVALUE_EOM: {
479 p = duk__trans_buffer_ensure(&ctx->send_buf, 1);
480 if (!p) { goto alloc_error; }
481 *p++ = 0x00;
482 ctx->send_buf.write_offset += 1;
483 break;
484 }
485 case DUK_DVALUE_REQ: {
486 p = duk__trans_buffer_ensure(&ctx->send_buf, 1);
487 if (!p) { goto alloc_error; }
488 *p++ = 0x01;
489 ctx->send_buf.write_offset += 1;
490 break;
491 }
492 case DUK_DVALUE_REP: {
493 p = duk__trans_buffer_ensure(&ctx->send_buf, 1);
494 if (!p) { goto alloc_error; }
495 *p++ = 0x02;
496 ctx->send_buf.write_offset += 1;
497 break;
498 }
499 case DUK_DVALUE_ERR: {
500 p = duk__trans_buffer_ensure(&ctx->send_buf, 1);
501 if (!p) { goto alloc_error; }
502 *p++ = 0x03;
503 ctx->send_buf.write_offset += 1;
504 break;
505 }
506 case DUK_DVALUE_NFY: {
507 p = duk__trans_buffer_ensure(&ctx->send_buf, 1);
508 if (!p) { goto alloc_error; }
509 *p++ = 0x04;
510 ctx->send_buf.write_offset += 1;
511 break;
512 }
513 case DUK_DVALUE_INTEGER: {
514 int i = dv->i;
515 if (i >= 0 && i <= 63) {
516 p = duk__trans_buffer_ensure(&ctx->send_buf, 1);
517 if (!p) { goto alloc_error; }
518 *p++ = (unsigned char) (0x80 + i);
519 ctx->send_buf.write_offset += 1;
520 } else if (i >= 0 && i <= 16383L) {
521 p = duk__trans_buffer_ensure(&ctx->send_buf, 2);
522 if (!p) { goto alloc_error; }
523 *p++ = (unsigned char) (0xc0 + (i >> 8));
524 *p++ = (unsigned char) (i & 0xff);
525 ctx->send_buf.write_offset += 2;
526 } else if (i >= -0x80000000L && i <= 0x7fffffffL) { /* Harmless warning on some platforms (re: range) */
527 p = duk__trans_buffer_ensure(&ctx->send_buf, 5);
528 if (!p) { goto alloc_error; }
529 *p++ = 0x10;
530 p = duk__trans_dvalue_encode_i32(ctx, p, i);
531 ctx->send_buf.write_offset += 5;
532 } else {
533 goto dvalue_error;
534 }
535 break;
536 }
537 case DUK_DVALUE_STRING: {
538 size_t i = dv->len;
539 if (i <= 0x1fUL) {
540 p = duk__trans_buffer_ensure(&ctx->send_buf, 1 + i);
541 if (!p) { goto alloc_error; }
542 *p++ = (unsigned char) (0x60 + i);
543 memcpy((void *) p, (const void *) dv->buf, i);
544 p += i;
545 ctx->send_buf.write_offset += 1 + i;
546 } else if (i <= 0xffffUL) {
547 p = duk__trans_buffer_ensure(&ctx->send_buf, 3 + i);
548 if (!p) { goto alloc_error; }
549 *p++ = 0x12;
550 p = duk__trans_dvalue_encode_u16(ctx, p, (unsigned int) i);
551 memcpy((void *) p, (const void *) dv->buf, i);
552 p += i;
553 ctx->send_buf.write_offset += 3 + i;
554 } else if (i <= 0xffffffffUL) {
555 p = duk__trans_buffer_ensure(&ctx->send_buf, 5 + i);
556 if (!p) { goto alloc_error; }
557 *p++ = 0x11;
558 p = duk__trans_dvalue_encode_u32(ctx, p, (unsigned int) i);
559 memcpy((void *) p, (const void *) dv->buf, i);
560 p += i;
561 ctx->send_buf.write_offset += 5 + i;
562 } else {
563 goto dvalue_error;
564 }
565 break;
566 }
567 case DUK_DVALUE_BUFFER: {
568 size_t i = dv->len;
569 if (i <= 0xffffUL) {
570 p = duk__trans_buffer_ensure(&ctx->send_buf, 3 + i);
571 if (!p) { goto alloc_error; }
572 *p++ = 0x14;
573 p = duk__trans_dvalue_encode_u16(ctx, p, (unsigned int) i);
574 memcpy((void *) p, (const void *) dv->buf, i);
575 p += i;
576 ctx->send_buf.write_offset += 3 + i;
577 } else if (i <= 0xffffffffUL) {
578 p = duk__trans_buffer_ensure(&ctx->send_buf, 5 + i);
579 if (!p) { goto alloc_error; }
580 *p++ = 0x13;
581 p = duk__trans_dvalue_encode_u32(ctx, p, (unsigned int) i);
582 memcpy((void *) p, (const void *) dv->buf, i);
583 p += i;
584 ctx->send_buf.write_offset += 5 + i;
585 } else {
586 goto dvalue_error;
587 }
588 break;
589 }
590 case DUK_DVALUE_UNUSED: {
591 p = duk__trans_buffer_ensure(&ctx->send_buf, 1);
592 if (!p) { goto alloc_error; }
593 *p++ = 0x15;
594 ctx->send_buf.write_offset += 1;
595 break;
596 }
597 case DUK_DVALUE_UNDEFINED: {
598 p = duk__trans_buffer_ensure(&ctx->send_buf, 1);
599 if (!p) { goto alloc_error; }
600 *p++ = 0x16;
601 ctx->send_buf.write_offset += 1;
602 break;
603 }
604 case DUK_DVALUE_NULL: {
605 p = duk__trans_buffer_ensure(&ctx->send_buf, 1);
606 if (!p) { goto alloc_error; }
607 *p++ = 0x17;
608 ctx->send_buf.write_offset += 1;
609 break;
610 }
611 case DUK_DVALUE_TRUE: {
612 p = duk__trans_buffer_ensure(&ctx->send_buf, 1);
613 if (!p) { goto alloc_error; }
614 *p++ = 0x18;
615 ctx->send_buf.write_offset += 1;
616 break;
617 }
618 case DUK_DVALUE_FALSE: {
619 p = duk__trans_buffer_ensure(&ctx->send_buf, 1);
620 if (!p) { goto alloc_error; }
621 *p++ = 0x19;
622 ctx->send_buf.write_offset += 1;
623 break;
624 }
625 case DUK_DVALUE_NUMBER: {
626 p = duk__trans_buffer_ensure(&ctx->send_buf, 9);
627 if (!p) { goto alloc_error; }
628 *p++ = 0x1a;
629 p = duk__trans_dvalue_encode_double(ctx, p, dv->d);
630 ctx->send_buf.write_offset += 9;
631 break;
632 }
633 case DUK_DVALUE_OBJECT: {
634 size_t i = dv->len;
635 if (i <= 0xffUL && dv->i >= 0 && dv->i <= 0xffL) {
636 p = duk__trans_buffer_ensure(&ctx->send_buf, 3 + i);
637 if (!p) { goto alloc_error; }
638 *p++ = 0x1b;
639 *p++ = (unsigned char) dv->i;
640 *p++ = (unsigned char) i;
641 memcpy((void *) p, (const void *) dv->buf, i);
642 ctx->send_buf.write_offset += 3 + i;
643 } else {
644 goto dvalue_error;
645 }
646 break;
647 }
648 case DUK_DVALUE_POINTER: {
649 size_t i = dv->len;
650 if (i <= 0xffUL) {
651 p = duk__trans_buffer_ensure(&ctx->send_buf, 2 + i);
652 if (!p) { goto alloc_error; }
653 *p++ = 0x1c;
654 *p++ = (unsigned char) i;
655 memcpy((void *) p, (const void *) dv->buf, i);
656 ctx->send_buf.write_offset += 2 + i;
657 } else {
658 goto dvalue_error;
659 }
660 break;
661 }
662 case DUK_DVALUE_LIGHTFUNC: {
663 size_t i = dv->len;
664 if (i <= 0xffUL && dv->i >= 0 && dv->i <= 0xffffL) {
665 p = duk__trans_buffer_ensure(&ctx->send_buf, 4 + i);
666 if (!p) { goto alloc_error; }
667 *p++ = 0x1d;
668 p = duk__trans_dvalue_encode_u16(ctx, p, (unsigned int) dv->i);
669 *p++ = (unsigned char) i;
670 memcpy((void *) p, (const void *) dv->buf, i);
671 ctx->send_buf.write_offset += 4 + i;
672 } else {
673 goto dvalue_error;
674 }
675 break;
676 }
677 case DUK_DVALUE_HEAPPTR: {
678 size_t i = dv->len;
679 if (i <= 0xffUL) {
680 p = duk__trans_buffer_ensure(&ctx->send_buf, 2 + i);
681 if (!p) { goto alloc_error; }
682 *p++ = 0x1e;
683 *p++ = (unsigned char) i;
684 memcpy((void *) p, (const void *) dv->buf, i);
685 ctx->send_buf.write_offset += 2 + i;
686 } else {
687 goto dvalue_error;
688 }
689 break;
690 }
691 default: {
692 goto dvalue_error;
693 }
694 } /* end switch */
695
696 return;
697
698 dvalue_error:
699#if defined(ERROR_PRINTS)
700 fprintf(stderr, "%s: internal error, argument dvalue is invalid\n", __func__);
701 fflush(stdout);
702#endif
703 return;
704
705 alloc_error:
706#if defined(ERROR_PRINTS)
707 fprintf(stderr, "%s: internal error, failed to allocate space for write\n", __func__);
708 fflush(stdout);
709#endif
710 return;
711}
duk__trans_buffer_ensure
static unsigned char * duk__trans_buffer_ensure(duk_trans_buffer *dbuf, size_t space)
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c:333
duk__trans_dvalue_encode_u16
static unsigned char * duk__trans_dvalue_encode_u16(duk_trans_dvalue_ctx *ctx, unsigned char *p, unsigned int val)
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c:312
duk__trans_dvalue_encode_u32
static unsigned char * duk__trans_dvalue_encode_u32(duk_trans_dvalue_ctx *ctx, unsigned char *p, unsigned int val)
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c:298
duk__trans_dvalue_encode_i32
static unsigned char * duk__trans_dvalue_encode_i32(duk_trans_dvalue_ctx *ctx, unsigned char *p, int val)
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c:308
duk_dvalue_to_string
void duk_dvalue_to_string(duk_dvalue *dv, char *buf)
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c:95
duk__trans_dvalue_encode_double
static unsigned char * duk__trans_dvalue_encode_double(duk_trans_dvalue_ctx *ctx, unsigned char *p, double val)
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c:320
DUK_DVALUE_TOSTRING_BUFLEN
#define DUK_DVALUE_TOSTRING_BUFLEN
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h:66

◆ duk_trans_dvalue_send_buffer()

void duk_trans_dvalue_send_buffer ( duk_trans_dvalue_ctx * ctx,
const char * buf,
size_t len )

Definition at line 751 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c.

751 {
752 duk__trans_dvalue_send_and_free(ctx, duk_dvalue_make_tag_data(DUK_DVALUE_BUFFER, buf, len));
753}
duk__trans_dvalue_send_and_free
static void duk__trans_dvalue_send_and_free(duk_trans_dvalue_ctx *ctx, duk_dvalue *dv)
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c:713

◆ duk_trans_dvalue_send_eom()

void duk_trans_dvalue_send_eom ( duk_trans_dvalue_ctx * ctx)

Definition at line 719 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c.

719 {
720 duk__trans_dvalue_send_and_free(ctx, duk_dvalue_make_tag(DUK_DVALUE_EOM));
721}
duk_dvalue_make_tag
duk_dvalue * duk_dvalue_make_tag(int tag)
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c:177

◆ duk_trans_dvalue_send_err()

void duk_trans_dvalue_send_err ( duk_trans_dvalue_ctx * ctx)

Definition at line 731 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c.

731 {
732 duk__trans_dvalue_send_and_free(ctx, duk_dvalue_make_tag(DUK_DVALUE_ERR));
733}

◆ duk_trans_dvalue_send_false()

void duk_trans_dvalue_send_false ( duk_trans_dvalue_ctx * ctx)

Definition at line 771 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c.

771 {
772 duk__trans_dvalue_send_and_free(ctx, duk_dvalue_make_tag(DUK_DVALUE_FALSE));
773}

◆ duk_trans_dvalue_send_heapptr()

void duk_trans_dvalue_send_heapptr ( duk_trans_dvalue_ctx * ctx,
const char * ptr_data,
size_t ptr_len )

Definition at line 791 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c.

791 {
792 duk__trans_dvalue_send_and_free(ctx, duk_dvalue_make_tag_data(DUK_DVALUE_HEAPPTR, ptr_data, ptr_len));
793}

◆ duk_trans_dvalue_send_integer()

void duk_trans_dvalue_send_integer ( duk_trans_dvalue_ctx * ctx,
int val )

Definition at line 739 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c.

739 {
740 duk__trans_dvalue_send_and_free(ctx, duk_dvalue_make_tag_int(DUK_DVALUE_INTEGER, val));
741}
duk_dvalue_make_tag_int
duk_dvalue * duk_dvalue_make_tag_int(int tag, int intval)
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c:184

◆ duk_trans_dvalue_send_lightfunc()

void duk_trans_dvalue_send_lightfunc ( duk_trans_dvalue_ctx * ctx,
int lf_flags,
const char * ptr_data,
size_t ptr_len )

Definition at line 787 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c.

787 {
788 duk__trans_dvalue_send_and_free(ctx, duk_dvalue_make_tag_int_data(DUK_DVALUE_LIGHTFUNC, lf_flags, ptr_data, ptr_len));
789}
duk_dvalue_make_tag_int_data
duk_dvalue * duk_dvalue_make_tag_int_data(int tag, int intval, const char *buf, size_t len)
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c:221

◆ duk_trans_dvalue_send_lstring()

void duk_trans_dvalue_send_lstring ( duk_trans_dvalue_ctx * ctx,
const char * str,
size_t len )

Definition at line 747 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c.

747 {
748 duk__trans_dvalue_send_and_free(ctx, duk_dvalue_make_tag_data(DUK_DVALUE_STRING, str, len));
749}

◆ duk_trans_dvalue_send_nfy()

void duk_trans_dvalue_send_nfy ( duk_trans_dvalue_ctx * ctx)

Definition at line 735 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c.

735 {
736 duk__trans_dvalue_send_and_free(ctx, duk_dvalue_make_tag(DUK_DVALUE_NFY));
737}

◆ duk_trans_dvalue_send_null()

void duk_trans_dvalue_send_null ( duk_trans_dvalue_ctx * ctx)

Definition at line 763 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c.

763 {
764 duk__trans_dvalue_send_and_free(ctx, duk_dvalue_make_tag(DUK_DVALUE_NULL));
765}

◆ duk_trans_dvalue_send_number()

void duk_trans_dvalue_send_number ( duk_trans_dvalue_ctx * ctx,
double val )

Definition at line 775 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c.

775 {
776 duk__trans_dvalue_send_and_free(ctx, duk_dvalue_make_tag_double(DUK_DVALUE_NUMBER, val));
777}
duk_dvalue_make_tag_double
duk_dvalue * duk_dvalue_make_tag_double(int tag, double dblval)
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c:192

◆ duk_trans_dvalue_send_object()

void duk_trans_dvalue_send_object ( duk_trans_dvalue_ctx * ctx,
int classnum,
const char * ptr_data,
size_t ptr_len )

Definition at line 779 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c.

779 {
780 duk__trans_dvalue_send_and_free(ctx, duk_dvalue_make_tag_int_data(DUK_DVALUE_OBJECT, classnum, ptr_data, ptr_len));
781}

◆ duk_trans_dvalue_send_pointer()

void duk_trans_dvalue_send_pointer ( duk_trans_dvalue_ctx * ctx,
const char * ptr_data,
size_t ptr_len )

Definition at line 783 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c.

783 {
784 duk__trans_dvalue_send_and_free(ctx, duk_dvalue_make_tag_data(DUK_DVALUE_POINTER, ptr_data, ptr_len));
785}

◆ duk_trans_dvalue_send_rep()

void duk_trans_dvalue_send_rep ( duk_trans_dvalue_ctx * ctx)

Definition at line 727 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c.

727 {
728 duk__trans_dvalue_send_and_free(ctx, duk_dvalue_make_tag(DUK_DVALUE_REP));
729}

◆ duk_trans_dvalue_send_req()

void duk_trans_dvalue_send_req ( duk_trans_dvalue_ctx * ctx)

Definition at line 723 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c.

723 {
724 duk__trans_dvalue_send_and_free(ctx, duk_dvalue_make_tag(DUK_DVALUE_REQ));
725}

◆ duk_trans_dvalue_send_req_cmd()

void duk_trans_dvalue_send_req_cmd ( duk_trans_dvalue_ctx * ctx,
int cmd )

Definition at line 795 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c.

795 {
796 duk_trans_dvalue_send_req(ctx);
797 duk_trans_dvalue_send_integer(ctx, cmd);
798}
duk_trans_dvalue_send_req
void duk_trans_dvalue_send_req(duk_trans_dvalue_ctx *ctx)
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c:723
duk_trans_dvalue_send_integer
void duk_trans_dvalue_send_integer(duk_trans_dvalue_ctx *ctx, int val)
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c:739

◆ duk_trans_dvalue_send_string()

void duk_trans_dvalue_send_string ( duk_trans_dvalue_ctx * ctx,
const char * str )

Definition at line 743 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c.

743 {
744 duk__trans_dvalue_send_and_free(ctx, duk_dvalue_make_tag_data(DUK_DVALUE_STRING, str, strlen(str)));
745}

◆ duk_trans_dvalue_send_true()

void duk_trans_dvalue_send_true ( duk_trans_dvalue_ctx * ctx)

Definition at line 767 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c.

767 {
768 duk__trans_dvalue_send_and_free(ctx, duk_dvalue_make_tag(DUK_DVALUE_TRUE));
769}

◆ duk_trans_dvalue_send_undefined()

void duk_trans_dvalue_send_undefined ( duk_trans_dvalue_ctx * ctx)

Definition at line 759 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c.

759 {
760 duk__trans_dvalue_send_and_free(ctx, duk_dvalue_make_tag(DUK_DVALUE_UNDEFINED));
761}

◆ duk_trans_dvalue_send_unused()

void duk_trans_dvalue_send_unused ( duk_trans_dvalue_ctx * ctx)

Definition at line 755 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c.

755 {
756 duk__trans_dvalue_send_and_free(ctx, duk_dvalue_make_tag(DUK_DVALUE_UNUSED));
757}

◆ duk_trans_dvalue_write_cb()

duk_size_t duk_trans_dvalue_write_cb ( void * udata,
const char * buffer,
duk_size_t length )

Definition at line 1135 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c.

1135 {
1136 duk_trans_dvalue_ctx *ctx = (duk_trans_dvalue_ctx *) udata;
1137 unsigned char *p;
1138
1139#if defined(DEBUG_PRINTS)
1140 fprintf(stderr, "%s: %p %p %ld\n", __func__, udata, (void *) buffer, (long) length);
1141 fflush(stderr);
1142#endif
1143
1144 duk__trans_call_cooperate(ctx, 0);
1145
1146 /* Append data. */
1147 duk__trans_buffer_rebase(&ctx->recv_buf);
1148 p = duk__trans_buffer_ensure(&ctx->recv_buf, length);
1149 memcpy((void *) p, (const void *) buffer, (size_t) length);
1150 ctx->recv_buf.write_offset += length;
1151
1152 /* Trial parse handshake line or dvalue(s). */
1153 if (!ctx->handshake_done) {
1154 duk_dvalue *dv = duk__trans_trial_parse_handshake(ctx);
1155 if (dv) {
1156 /* Handshake line is available for caller for the
1157 * duration of the callback, and must not be freed
1158 * by the caller.
1159 */
1160 duk__trans_call_handshake(ctx, (const char *) dv->buf);
1161#if defined(DEBUG_PRINTS)
1162 fprintf(stderr, "%s: handshake ok\n", __func__);
1163 fflush(stderr);
1164#endif
1165 duk_dvalue_free(dv);
1166 ctx->handshake_done = 1;
1167 }
1168 }
1169 if (ctx->handshake_done) {
1170 for (;;) {
1171 duk_dvalue *dv = duk__trans_trial_parse_dvalue(ctx);
1172 if (dv) {
1173#if defined(DEBUG_PRINTS)
1174 {
1175 char buf[DUK_DVALUE_TOSTRING_BUFLEN];
1176 duk_dvalue_to_string(dv, buf);
1177 fprintf(stderr, "%s: received dvalue: %s\n", __func__, buf);
1178 fflush(stderr);
1179 }
1180#endif
1181
1182 duk__trans_call_received(ctx, dv);
1183 } else {
1184 break;
1185 }
1186 }
1187 }
1188
1189 duk__trans_call_cooperate(ctx, 0); /* just in case, if dvalues changed something */
1190
1191 return length;
1192}
duk__trans_trial_parse_dvalue
static duk_dvalue * duk__trans_trial_parse_dvalue(duk_trans_dvalue_ctx *ctx)
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c:800
duk_dvalue_free
void duk_dvalue_free(duk_dvalue *dv)
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c:60
duk__trans_call_received
static void duk__trans_call_received(duk_trans_dvalue_ctx *ctx, duk_dvalue *dv)
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c:1081
duk__trans_call_handshake
static void duk__trans_call_handshake(duk_trans_dvalue_ctx *ctx, const char *line)
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c:1087
duk__trans_trial_parse_handshake
static duk_dvalue * duk__trans_trial_parse_handshake(duk_trans_dvalue_ctx *ctx)
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c:1044
duk_trans_dvalue_ctx::handshake_done
int handshake_done
Definition duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.h:61

◆ duk_trans_dvalue_write_flush_cb()

void duk_trans_dvalue_write_flush_cb ( void * udata)

Definition at line 1219 of file duktape-1.5.2/examples/debug-trans-dvalue/duk_trans_dvalue.c.

1219 {
1220 duk_trans_dvalue_ctx *ctx = (duk_trans_dvalue_ctx *) udata;
1221
1222#if defined(DEBUG_PRINTS)
1223 fprintf(stderr, "%s: %p\n", __func__, udata);
1224 fflush(stderr);
1225#endif
1226
1227 duk__trans_call_cooperate(ctx, 0);
1228}