jack2 codebase
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

609 lines
18KB

  1. /* -*- Mode: C ; c-basic-offset: 4 -*- */
  2. /*
  3. Copyright (C) 2007-2008 Nedko Arnaudov
  4. Copyright (C) 2007-2008 Juuso Alasuutari
  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 2 of the License.
  8. This program is distributed in the hope that it will be useful,
  9. but WITHOUT ANY WARRANTY; without even the implied warranty of
  10. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11. GNU General Public License for more details.
  12. You should have received a copy of the GNU General Public License
  13. along with this program; if not, write to the Free Software
  14. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  15. */
  16. #include <stdint.h>
  17. #include <string.h>
  18. #include <stdio.h>
  19. #include <assert.h>
  20. #include <dbus/dbus.h>
  21. #include "jackdbus.h"
  22. static char g_xml_data[102400];
  23. static
  24. void
  25. jack_controller_dbus_introspect(
  26. struct jack_dbus_method_call * call)
  27. {
  28. jack_dbus_construct_method_return_single(
  29. call,
  30. DBUS_TYPE_STRING,
  31. (message_arg_t)(const char *)g_xml_data);
  32. }
  33. JACK_DBUS_METHOD_ARGUMENTS_BEGIN(Introspect)
  34. JACK_DBUS_METHOD_ARGUMENT("xml_data", "s", true)
  35. JACK_DBUS_METHOD_ARGUMENTS_END
  36. JACK_DBUS_METHODS_BEGIN
  37. JACK_DBUS_METHOD_DESCRIBE(Introspect, jack_controller_dbus_introspect)
  38. JACK_DBUS_METHODS_END
  39. JACK_DBUS_IFACE_BEGIN(g_jack_controller_iface_introspectable, "org.freedesktop.DBus.Introspectable")
  40. JACK_DBUS_IFACE_EXPOSE_METHODS
  41. JACK_DBUS_IFACE_END
  42. static char * g_buffer_ptr;
  43. static
  44. void
  45. write_line_format(const char * format, ...)
  46. {
  47. va_list ap;
  48. va_start(ap, format);
  49. g_buffer_ptr += vsprintf(g_buffer_ptr, format, ap);
  50. va_end(ap);
  51. }
  52. static
  53. void
  54. write_line(const char * line)
  55. {
  56. write_line_format("%s\n", line);
  57. }
  58. void jack_controller_introspect_init() __attribute__((constructor));
  59. void
  60. jack_controller_introspect_init()
  61. {
  62. struct jack_dbus_interface_descriptor ** interface_ptr_ptr;
  63. const struct jack_dbus_interface_method_descriptor * method_ptr;
  64. const struct jack_dbus_interface_method_argument_descriptor * method_argument_ptr;
  65. const struct jack_dbus_interface_signal_descriptor * signal_ptr;
  66. const struct jack_dbus_interface_signal_argument_descriptor * signal_argument_ptr;
  67. g_buffer_ptr = g_xml_data;
  68. write_line("<!DOCTYPE node PUBLIC \"-//freedesktop//DTD D-BUS Object Introspection 1.0//EN\"");
  69. write_line("\"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd\">");
  70. write_line("<node name=\"" JACK_CONTROLLER_OBJECT_PATH "\">");
  71. interface_ptr_ptr = g_jackcontroller_interfaces;
  72. while (*interface_ptr_ptr != NULL)
  73. {
  74. write_line_format(" <interface name=\"%s\">\n", (*interface_ptr_ptr)->name);
  75. if ((*interface_ptr_ptr)->methods != NULL)
  76. {
  77. method_ptr = (*interface_ptr_ptr)->methods;
  78. while (method_ptr->name != NULL)
  79. {
  80. write_line_format(" <method name=\"%s\">\n", method_ptr->name);
  81. method_argument_ptr = method_ptr->arguments;
  82. while (method_argument_ptr->name != NULL)
  83. {
  84. write_line_format(
  85. " <arg name=\"%s\" type=\"%s\" direction=\"%s\" />\n",
  86. method_argument_ptr->name,
  87. method_argument_ptr->type,
  88. method_argument_ptr->direction_out ? "out" : "in");
  89. method_argument_ptr++;
  90. }
  91. write_line(" </method>");
  92. method_ptr++;
  93. }
  94. }
  95. if ((*interface_ptr_ptr)->signals != NULL)
  96. {
  97. signal_ptr = (*interface_ptr_ptr)->signals;
  98. while (signal_ptr->name != NULL)
  99. {
  100. write_line_format(" <signal name=\"%s\">\n", signal_ptr->name);
  101. signal_argument_ptr = signal_ptr->arguments;
  102. while (signal_argument_ptr->name != NULL)
  103. {
  104. write_line_format(
  105. " <arg name=\"%s\" type=\"%s\" />\n",
  106. signal_argument_ptr->name,
  107. signal_argument_ptr->type);
  108. signal_argument_ptr++;
  109. }
  110. write_line(" </signal>");
  111. signal_ptr++;
  112. }
  113. }
  114. write_line(" </interface>");
  115. interface_ptr_ptr++;
  116. }
  117. write_line("</node>");
  118. *g_buffer_ptr = 0;
  119. }
  120. /* -*- Mode: C ; c-basic-offset: 4 -*- */
  121. /*
  122. Copyright (C) 2007-2008 Nedko Arnaudov
  123. Copyright (C) 2007-2008 Juuso Alasuutari
  124. This program is free software; you can redistribute it and/or modify
  125. it under the terms of the GNU General Public License as published by
  126. the Free Software Foundation; either version 2 of the License.
  127. This program is distributed in the hope that it will be useful,
  128. but WITHOUT ANY WARRANTY; without even the implied warranty of
  129. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  130. GNU General Public License for more details.
  131. You should have received a copy of the GNU General Public License
  132. along with this program; if not, write to the Free Software
  133. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  134. */
  135. #include <stdint.h>
  136. #include <string.h>
  137. #include <stdio.h>
  138. #include <assert.h>
  139. #include <dbus/dbus.h>
  140. #include "jackdbus.h"
  141. static char g_xml_data[102400];
  142. static
  143. void
  144. jack_controller_dbus_introspect(
  145. struct jack_dbus_method_call * call)
  146. {
  147. jack_dbus_construct_method_return_single(
  148. call,
  149. DBUS_TYPE_STRING,
  150. (message_arg_t)(const char *)g_xml_data);
  151. }
  152. JACK_DBUS_METHOD_ARGUMENTS_BEGIN(Introspect)
  153. JACK_DBUS_METHOD_ARGUMENT("xml_data", "s", true)
  154. JACK_DBUS_METHOD_ARGUMENTS_END
  155. JACK_DBUS_METHODS_BEGIN
  156. JACK_DBUS_METHOD_DESCRIBE(Introspect, jack_controller_dbus_introspect)
  157. JACK_DBUS_METHODS_END
  158. JACK_DBUS_IFACE_BEGIN(g_jack_controller_iface_introspectable, "org.freedesktop.DBus.Introspectable")
  159. JACK_DBUS_IFACE_EXPOSE_METHODS
  160. JACK_DBUS_IFACE_END
  161. static char * g_buffer_ptr;
  162. static
  163. void
  164. write_line_format(const char * format, ...)
  165. {
  166. va_list ap;
  167. va_start(ap, format);
  168. g_buffer_ptr += vsprintf(g_buffer_ptr, format, ap);
  169. va_end(ap);
  170. }
  171. static
  172. void
  173. write_line(const char * line)
  174. {
  175. write_line_format("%s\n", line);
  176. }
  177. void jack_controller_introspect_init() __attribute__((constructor));
  178. void
  179. jack_controller_introspect_init()
  180. {
  181. struct jack_dbus_interface_descriptor ** interface_ptr_ptr;
  182. const struct jack_dbus_interface_method_descriptor * method_ptr;
  183. const struct jack_dbus_interface_method_argument_descriptor * method_argument_ptr;
  184. const struct jack_dbus_interface_signal_descriptor * signal_ptr;
  185. const struct jack_dbus_interface_signal_argument_descriptor * signal_argument_ptr;
  186. g_buffer_ptr = g_xml_data;
  187. write_line("<!DOCTYPE node PUBLIC \"-//freedesktop//DTD D-BUS Object Introspection 1.0//EN\"");
  188. write_line("\"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd\">");
  189. write_line("<node name=\"" JACK_CONTROLLER_OBJECT_PATH "\">");
  190. interface_ptr_ptr = g_jackcontroller_interfaces;
  191. while (*interface_ptr_ptr != NULL)
  192. {
  193. write_line_format(" <interface name=\"%s\">\n", (*interface_ptr_ptr)->name);
  194. if ((*interface_ptr_ptr)->methods != NULL)
  195. {
  196. method_ptr = (*interface_ptr_ptr)->methods;
  197. while (method_ptr->name != NULL)
  198. {
  199. write_line_format(" <method name=\"%s\">\n", method_ptr->name);
  200. method_argument_ptr = method_ptr->arguments;
  201. while (method_argument_ptr->name != NULL)
  202. {
  203. write_line_format(
  204. " <arg name=\"%s\" type=\"%s\" direction=\"%s\" />\n",
  205. method_argument_ptr->name,
  206. method_argument_ptr->type,
  207. method_argument_ptr->direction_out ? "out" : "in");
  208. method_argument_ptr++;
  209. }
  210. write_line(" </method>");
  211. method_ptr++;
  212. }
  213. }
  214. if ((*interface_ptr_ptr)->signals != NULL)
  215. {
  216. signal_ptr = (*interface_ptr_ptr)->signals;
  217. while (signal_ptr->name != NULL)
  218. {
  219. write_line_format(" <signal name=\"%s\">\n", signal_ptr->name);
  220. signal_argument_ptr = signal_ptr->arguments;
  221. while (signal_argument_ptr->name != NULL)
  222. {
  223. write_line_format(
  224. " <arg name=\"%s\" type=\"%s\" />\n",
  225. signal_argument_ptr->name,
  226. signal_argument_ptr->type);
  227. signal_argument_ptr++;
  228. }
  229. write_line(" </signal>");
  230. signal_ptr++;
  231. }
  232. }
  233. write_line(" </interface>");
  234. interface_ptr_ptr++;
  235. }
  236. write_line("</node>");
  237. *g_buffer_ptr = 0;
  238. }
  239. /* -*- Mode: C ; c-basic-offset: 4 -*- */
  240. /*
  241. Copyright (C) 2007-2008 Nedko Arnaudov
  242. Copyright (C) 2007-2008 Juuso Alasuutari
  243. This program is free software; you can redistribute it and/or modify
  244. it under the terms of the GNU General Public License as published by
  245. the Free Software Foundation; either version 2 of the License.
  246. This program is distributed in the hope that it will be useful,
  247. but WITHOUT ANY WARRANTY; without even the implied warranty of
  248. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  249. GNU General Public License for more details.
  250. You should have received a copy of the GNU General Public License
  251. along with this program; if not, write to the Free Software
  252. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  253. */
  254. #include <stdint.h>
  255. #include <string.h>
  256. #include <stdio.h>
  257. #include <assert.h>
  258. #include <dbus/dbus.h>
  259. #include "jackdbus.h"
  260. static char g_xml_data[102400];
  261. static
  262. void
  263. jack_controller_dbus_introspect(
  264. struct jack_dbus_method_call * call)
  265. {
  266. jack_dbus_construct_method_return_single(
  267. call,
  268. DBUS_TYPE_STRING,
  269. (message_arg_t)(const char *)g_xml_data);
  270. }
  271. JACK_DBUS_METHOD_ARGUMENTS_BEGIN(Introspect)
  272. JACK_DBUS_METHOD_ARGUMENT("xml_data", "s", true)
  273. JACK_DBUS_METHOD_ARGUMENTS_END
  274. JACK_DBUS_METHODS_BEGIN
  275. JACK_DBUS_METHOD_DESCRIBE(Introspect, jack_controller_dbus_introspect)
  276. JACK_DBUS_METHODS_END
  277. JACK_DBUS_IFACE_BEGIN(g_jack_controller_iface_introspectable, "org.freedesktop.DBus.Introspectable")
  278. JACK_DBUS_IFACE_EXPOSE_METHODS
  279. JACK_DBUS_IFACE_END
  280. static char * g_buffer_ptr;
  281. static
  282. void
  283. write_line_format(const char * format, ...)
  284. {
  285. va_list ap;
  286. va_start(ap, format);
  287. g_buffer_ptr += vsprintf(g_buffer_ptr, format, ap);
  288. va_end(ap);
  289. }
  290. static
  291. void
  292. write_line(const char * line)
  293. {
  294. write_line_format("%s\n", line);
  295. }
  296. void jack_controller_introspect_init() __attribute__((constructor));
  297. void
  298. jack_controller_introspect_init()
  299. {
  300. struct jack_dbus_interface_descriptor ** interface_ptr_ptr;
  301. const struct jack_dbus_interface_method_descriptor * method_ptr;
  302. const struct jack_dbus_interface_method_argument_descriptor * method_argument_ptr;
  303. const struct jack_dbus_interface_signal_descriptor * signal_ptr;
  304. const struct jack_dbus_interface_signal_argument_descriptor * signal_argument_ptr;
  305. g_buffer_ptr = g_xml_data;
  306. write_line("<!DOCTYPE node PUBLIC \"-//freedesktop//DTD D-BUS Object Introspection 1.0//EN\"");
  307. write_line("\"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd\">");
  308. write_line("<node name=\"" JACK_CONTROLLER_OBJECT_PATH "\">");
  309. interface_ptr_ptr = g_jackcontroller_interfaces;
  310. while (*interface_ptr_ptr != NULL)
  311. {
  312. write_line_format(" <interface name=\"%s\">\n", (*interface_ptr_ptr)->name);
  313. if ((*interface_ptr_ptr)->methods != NULL)
  314. {
  315. method_ptr = (*interface_ptr_ptr)->methods;
  316. while (method_ptr->name != NULL)
  317. {
  318. write_line_format(" <method name=\"%s\">\n", method_ptr->name);
  319. method_argument_ptr = method_ptr->arguments;
  320. while (method_argument_ptr->name != NULL)
  321. {
  322. write_line_format(
  323. " <arg name=\"%s\" type=\"%s\" direction=\"%s\" />\n",
  324. method_argument_ptr->name,
  325. method_argument_ptr->type,
  326. method_argument_ptr->direction_out ? "out" : "in");
  327. method_argument_ptr++;
  328. }
  329. write_line(" </method>");
  330. method_ptr++;
  331. }
  332. }
  333. if ((*interface_ptr_ptr)->signals != NULL)
  334. {
  335. signal_ptr = (*interface_ptr_ptr)->signals;
  336. while (signal_ptr->name != NULL)
  337. {
  338. write_line_format(" <signal name=\"%s\">\n", signal_ptr->name);
  339. signal_argument_ptr = signal_ptr->arguments;
  340. while (signal_argument_ptr->name != NULL)
  341. {
  342. write_line_format(
  343. " <arg name=\"%s\" type=\"%s\" />\n",
  344. signal_argument_ptr->name,
  345. signal_argument_ptr->type);
  346. signal_argument_ptr++;
  347. }
  348. write_line(" </signal>");
  349. signal_ptr++;
  350. }
  351. }
  352. write_line(" </interface>");
  353. interface_ptr_ptr++;
  354. }
  355. write_line("</node>");
  356. *g_buffer_ptr = 0;
  357. }
  358. /* -*- Mode: C ; c-basic-offset: 4 -*- */
  359. /*
  360. Copyright (C) 2007-2008 Nedko Arnaudov
  361. Copyright (C) 2007-2008 Juuso Alasuutari
  362. This program is free software; you can redistribute it and/or modify
  363. it under the terms of the GNU General Public License as published by
  364. the Free Software Foundation; either version 2 of the License.
  365. This program is distributed in the hope that it will be useful,
  366. but WITHOUT ANY WARRANTY; without even the implied warranty of
  367. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  368. GNU General Public License for more details.
  369. You should have received a copy of the GNU General Public License
  370. along with this program; if not, write to the Free Software
  371. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  372. */
  373. #include <stdint.h>
  374. #include <string.h>
  375. #include <stdio.h>
  376. #include <assert.h>
  377. #include <dbus/dbus.h>
  378. #include "jackdbus.h"
  379. static char g_xml_data[102400];
  380. static
  381. void
  382. jack_controller_dbus_introspect(
  383. struct jack_dbus_method_call * call)
  384. {
  385. jack_dbus_construct_method_return_single(
  386. call,
  387. DBUS_TYPE_STRING,
  388. (message_arg_t)(const char *)g_xml_data);
  389. }
  390. JACK_DBUS_METHOD_ARGUMENTS_BEGIN(Introspect)
  391. JACK_DBUS_METHOD_ARGUMENT("xml_data", "s", true)
  392. JACK_DBUS_METHOD_ARGUMENTS_END
  393. JACK_DBUS_METHODS_BEGIN
  394. JACK_DBUS_METHOD_DESCRIBE(Introspect, jack_controller_dbus_introspect)
  395. JACK_DBUS_METHODS_END
  396. JACK_DBUS_IFACE_BEGIN(g_jack_controller_iface_introspectable, "org.freedesktop.DBus.Introspectable")
  397. JACK_DBUS_IFACE_EXPOSE_METHODS
  398. JACK_DBUS_IFACE_END
  399. static char * g_buffer_ptr;
  400. static
  401. void
  402. write_line_format(const char * format, ...)
  403. {
  404. va_list ap;
  405. va_start(ap, format);
  406. g_buffer_ptr += vsprintf(g_buffer_ptr, format, ap);
  407. va_end(ap);
  408. }
  409. static
  410. void
  411. write_line(const char * line)
  412. {
  413. write_line_format("%s\n", line);
  414. }
  415. void jack_controller_introspect_init() __attribute__((constructor));
  416. void
  417. jack_controller_introspect_init()
  418. {
  419. struct jack_dbus_interface_descriptor ** interface_ptr_ptr;
  420. const struct jack_dbus_interface_method_descriptor * method_ptr;
  421. const struct jack_dbus_interface_method_argument_descriptor * method_argument_ptr;
  422. const struct jack_dbus_interface_signal_descriptor * signal_ptr;
  423. const struct jack_dbus_interface_signal_argument_descriptor * signal_argument_ptr;
  424. g_buffer_ptr = g_xml_data;
  425. write_line("<!DOCTYPE node PUBLIC \"-//freedesktop//DTD D-BUS Object Introspection 1.0//EN\"");
  426. write_line("\"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd\">");
  427. write_line("<node name=\"" JACK_CONTROLLER_OBJECT_PATH "\">");
  428. interface_ptr_ptr = g_jackcontroller_interfaces;
  429. while (*interface_ptr_ptr != NULL)
  430. {
  431. write_line_format(" <interface name=\"%s\">\n", (*interface_ptr_ptr)->name);
  432. if ((*interface_ptr_ptr)->methods != NULL)
  433. {
  434. method_ptr = (*interface_ptr_ptr)->methods;
  435. while (method_ptr->name != NULL)
  436. {
  437. write_line_format(" <method name=\"%s\">\n", method_ptr->name);
  438. method_argument_ptr = method_ptr->arguments;
  439. while (method_argument_ptr->name != NULL)
  440. {
  441. write_line_format(
  442. " <arg name=\"%s\" type=\"%s\" direction=\"%s\" />\n",
  443. method_argument_ptr->name,
  444. method_argument_ptr->type,
  445. method_argument_ptr->direction_out ? "out" : "in");
  446. method_argument_ptr++;
  447. }
  448. write_line(" </method>");
  449. method_ptr++;
  450. }
  451. }
  452. if ((*interface_ptr_ptr)->signals != NULL)
  453. {
  454. signal_ptr = (*interface_ptr_ptr)->signals;
  455. while (signal_ptr->name != NULL)
  456. {
  457. write_line_format(" <signal name=\"%s\">\n", signal_ptr->name);
  458. signal_argument_ptr = signal_ptr->arguments;
  459. while (signal_argument_ptr->name != NULL)
  460. {
  461. write_line_format(
  462. " <arg name=\"%s\" type=\"%s\" />\n",
  463. signal_argument_ptr->name,
  464. signal_argument_ptr->type);
  465. signal_argument_ptr++;
  466. }
  467. write_line(" </signal>");
  468. signal_ptr++;
  469. }
  470. }
  471. write_line(" </interface>");
  472. interface_ptr_ptr++;
  473. }
  474. write_line("</node>");
  475. *g_buffer_ptr = 0;
  476. }