rpc.hh revision 1.1
1 /* RPC call and callback templates 2 Copyright (C) 2014 Free Software Foundation, Inc. 3 4 This file is part of GCC. 5 6 GCC is free software; you can redistribute it and/or modify it under 7 the terms of the GNU General Public License as published by the Free 8 Software Foundation; either version 3, or (at your option) any later 9 version. 10 11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 12 WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with GCC; see the file COPYING3. If not see 18 <http://www.gnu.org/licenses/>. */ 19 20 #ifndef CC1_PLUGIN_RPC_HH 21 #define CC1_PLUGIN_RPC_HH 22 23 #include "status.hh" 24 #include "marshall.hh" 25 #include "connection.hh" 26 27 namespace cc1_plugin 28 { 29 // The plugin API may contain some "const" method parameters. 30 // However, when unmarshalling we cannot unmarshall into a const 31 // object; and furthermore we want to be able to deallocate pointers 32 // when finished with them. This wrapper class lets us properly 33 // remove the "const" and handle deallocation from pointer types. 34 35 template<typename T> 36 class argument_wrapper 37 { 38 public: 39 40 argument_wrapper () { } 41 ~argument_wrapper () { } 42 43 operator T () const { return m_object; } 44 45 status unmarshall (connection *conn) 46 { 47 return ::cc1_plugin::unmarshall (conn, &m_object); 48 } 49 50 private: 51 52 T m_object; 53 54 // No copying or assignment allowed. 55 argument_wrapper (const argument_wrapper &); 56 argument_wrapper &operator= (const argument_wrapper &); 57 }; 58 59 // Specialization for any kind of pointer. This is declared but not 60 // defined to avoid bugs if a new pointer type is introduced into 61 // the API. Instead you will just get a compilation error. 62 template<typename T> 63 class argument_wrapper<const T *>; 64 65 // Specialization for string types. 66 template<> 67 class argument_wrapper<const char *> 68 { 69 public: 70 argument_wrapper () : m_object (NULL) { } 71 ~argument_wrapper () 72 { 73 delete[] m_object; 74 } 75 76 operator const char * () const 77 { 78 return m_object; 79 } 80 81 status unmarshall (connection *conn) 82 { 83 return ::cc1_plugin::unmarshall (conn, &m_object); 84 } 85 86 private: 87 88 char *m_object; 89 90 // No copying or assignment allowed. 91 argument_wrapper (const argument_wrapper &); 92 argument_wrapper &operator= (const argument_wrapper &); 93 }; 94 95 // Specialization for gcc_type_array. 96 template<> 97 class argument_wrapper<const gcc_type_array *> 98 { 99 public: 100 argument_wrapper () : m_object (NULL) { } 101 ~argument_wrapper () 102 { 103 // It would be nicer if gcc_type_array could have a destructor. 104 // But, it is in code shared with gdb and cannot. 105 if (m_object != NULL) 106 delete[] m_object->elements; 107 delete m_object; 108 } 109 110 operator const gcc_type_array * () const 111 { 112 return m_object; 113 } 114 115 status unmarshall (connection *conn) 116 { 117 return ::cc1_plugin::unmarshall (conn, &m_object); 118 } 119 120 private: 121 122 gcc_type_array *m_object; 123 124 // No copying or assignment allowed. 125 argument_wrapper (const argument_wrapper &); 126 argument_wrapper &operator= (const argument_wrapper &); 127 }; 128 129 // There are two kinds of template functions here: "call" and 130 // "callback". They are each repeated multiple times to handle 131 // different numbers of arguments. (This would be improved with 132 // C++11, though applying a call is still tricky until C++14 can be 133 // used.) 134 135 // The "call" template is used for making a remote procedure call. 136 // It starts a query ('Q') packet, marshalls its arguments, waits 137 // for a result, and finally reads and returns the result via an 138 // "out" parameter. 139 140 // The "callback" template is used when receiving a remote procedure 141 // call. This template function is suitable for use with the 142 // "callbacks" and "connection" classes. It decodes incoming 143 // arguments, passes them to the wrapped function, and finally 144 // marshalls a reply packet. 145 146 template<typename R> 147 status 148 call (connection *conn, const char *method, R *result) 149 { 150 if (!conn->send ('Q')) 151 return FAIL; 152 if (!marshall (conn, method)) 153 return FAIL; 154 if (!marshall (conn, 0)) 155 return FAIL; 156 if (!conn->wait_for_result ()) 157 return FAIL; 158 if (!unmarshall (conn, result)) 159 return FAIL; 160 return OK; 161 } 162 163 template<typename R, R (*func) (connection *)> 164 status 165 callback (connection *conn) 166 { 167 R result; 168 169 if (!unmarshall_check (conn, 0)) 170 return FAIL; 171 result = func (conn); 172 if (!conn->send ('R')) 173 return FAIL; 174 return marshall (conn, result); 175 } 176 177 template<typename R, typename A> 178 status 179 call (connection *conn, const char *method, R *result, A arg) 180 { 181 if (!conn->send ('Q')) 182 return FAIL; 183 if (!marshall (conn, method)) 184 return FAIL; 185 if (!marshall (conn, 1)) 186 return FAIL; 187 if (!marshall (conn, arg)) 188 return FAIL; 189 if (!conn->wait_for_result ()) 190 return FAIL; 191 if (!unmarshall (conn, result)) 192 return FAIL; 193 return OK; 194 } 195 196 template<typename R, typename A, R (*func) (connection *, A)> 197 status 198 callback (connection *conn) 199 { 200 argument_wrapper<A> arg; 201 R result; 202 203 if (!unmarshall_check (conn, 1)) 204 return FAIL; 205 if (!arg.unmarshall (conn)) 206 return FAIL; 207 result = func (conn, arg); 208 if (!conn->send ('R')) 209 return FAIL; 210 return marshall (conn, result); 211 } 212 213 template<typename R, typename A1, typename A2> 214 status 215 call (connection *conn, const char *method, R *result, A1 arg1, A2 arg2) 216 { 217 if (!conn->send ('Q')) 218 return FAIL; 219 if (!marshall (conn, method)) 220 return FAIL; 221 if (!marshall (conn, 2)) 222 return FAIL; 223 if (!marshall (conn, arg1)) 224 return FAIL; 225 if (!marshall (conn, arg2)) 226 return FAIL; 227 if (!conn->wait_for_result ()) 228 return FAIL; 229 if (!unmarshall (conn, result)) 230 return FAIL; 231 return OK; 232 } 233 234 template<typename R, typename A1, typename A2, R (*func) (connection *, 235 A1, A2)> 236 status 237 callback (connection *conn) 238 { 239 argument_wrapper<A1> arg1; 240 argument_wrapper<A2> arg2; 241 R result; 242 243 if (!unmarshall_check (conn, 2)) 244 return FAIL; 245 if (!arg1.unmarshall (conn)) 246 return FAIL; 247 if (!arg2.unmarshall (conn)) 248 return FAIL; 249 result = func (conn, arg1, arg2); 250 if (!conn->send ('R')) 251 return FAIL; 252 return marshall (conn, result); 253 } 254 255 template<typename R, typename A1, typename A2, typename A3> 256 status 257 call (connection *conn, const char *method, R *result, A1 arg1, A2 arg2, 258 A3 arg3) 259 { 260 if (!conn->send ('Q')) 261 return FAIL; 262 if (!marshall (conn, method)) 263 return FAIL; 264 if (!marshall (conn, 3)) 265 return FAIL; 266 if (!marshall (conn, arg1)) 267 return FAIL; 268 if (!marshall (conn, arg2)) 269 return FAIL; 270 if (!marshall (conn, arg3)) 271 return FAIL; 272 if (!conn->wait_for_result ()) 273 return FAIL; 274 if (!unmarshall (conn, result)) 275 return FAIL; 276 return OK; 277 } 278 279 template<typename R, typename A1, typename A2, typename A3, 280 R (*func) (connection *, A1, A2, A3)> 281 status 282 callback (connection *conn) 283 { 284 argument_wrapper<A1> arg1; 285 argument_wrapper<A2> arg2; 286 argument_wrapper<A3> arg3; 287 R result; 288 289 if (!unmarshall_check (conn, 3)) 290 return FAIL; 291 if (!arg1.unmarshall (conn)) 292 return FAIL; 293 if (!arg2.unmarshall (conn)) 294 return FAIL; 295 if (!arg3.unmarshall (conn)) 296 return FAIL; 297 result = func (conn, arg1, arg2, arg3); 298 if (!conn->send ('R')) 299 return FAIL; 300 return marshall (conn, result); 301 } 302 303 template<typename R, typename A1, typename A2, typename A3, typename A4> 304 status 305 call (connection *conn, const char *method, R *result, A1 arg1, A2 arg2, 306 A3 arg3, A4 arg4) 307 { 308 if (!conn->send ('Q')) 309 return FAIL; 310 if (!marshall (conn, method)) 311 return FAIL; 312 if (!marshall (conn, 4)) 313 return FAIL; 314 if (!marshall (conn, arg1)) 315 return FAIL; 316 if (!marshall (conn, arg2)) 317 return FAIL; 318 if (!marshall (conn, arg3)) 319 return FAIL; 320 if (!marshall (conn, arg4)) 321 return FAIL; 322 if (!conn->wait_for_result ()) 323 return FAIL; 324 if (!unmarshall (conn, result)) 325 return FAIL; 326 return OK; 327 } 328 329 template<typename R, typename A1, typename A2, typename A3, typename A4, 330 R (*func) (connection *, A1, A2, A3, A4)> 331 status 332 callback (connection *conn) 333 { 334 argument_wrapper<A1> arg1; 335 argument_wrapper<A2> arg2; 336 argument_wrapper<A3> arg3; 337 argument_wrapper<A4> arg4; 338 R result; 339 340 if (!unmarshall_check (conn, 4)) 341 return FAIL; 342 if (!arg1.unmarshall (conn)) 343 return FAIL; 344 if (!arg2.unmarshall (conn)) 345 return FAIL; 346 if (!arg3.unmarshall (conn)) 347 return FAIL; 348 if (!arg4.unmarshall (conn)) 349 return FAIL; 350 result = func (conn, arg1, arg2, arg3, arg4); 351 if (!conn->send ('R')) 352 return FAIL; 353 return marshall (conn, result); 354 } 355 356 template<typename R, typename A1, typename A2, typename A3, typename A4, 357 typename A5> 358 status 359 call (connection *conn, const char *method, R *result, A1 arg1, A2 arg2, 360 A3 arg3, A4 arg4, A5 arg5) 361 { 362 if (!conn->send ('Q')) 363 return FAIL; 364 if (!marshall (conn, method)) 365 return FAIL; 366 if (!marshall (conn, 5)) 367 return FAIL; 368 if (!marshall (conn, arg1)) 369 return FAIL; 370 if (!marshall (conn, arg2)) 371 return FAIL; 372 if (!marshall (conn, arg3)) 373 return FAIL; 374 if (!marshall (conn, arg4)) 375 return FAIL; 376 if (!marshall (conn, arg5)) 377 return FAIL; 378 if (!conn->wait_for_result ()) 379 return FAIL; 380 if (!unmarshall (conn, result)) 381 return FAIL; 382 return OK; 383 } 384 385 template<typename R, typename A1, typename A2, typename A3, typename A4, 386 typename A5, R (*func) (connection *, A1, A2, A3, A4, A5)> 387 status 388 callback (connection *conn) 389 { 390 argument_wrapper<A1> arg1; 391 argument_wrapper<A2> arg2; 392 argument_wrapper<A3> arg3; 393 argument_wrapper<A4> arg4; 394 argument_wrapper<A5> arg5; 395 R result; 396 397 if (!unmarshall_check (conn, 5)) 398 return FAIL; 399 if (!arg1.unmarshall (conn)) 400 return FAIL; 401 if (!arg2.unmarshall (conn)) 402 return FAIL; 403 if (!arg3.unmarshall (conn)) 404 return FAIL; 405 if (!arg4.unmarshall (conn)) 406 return FAIL; 407 if (!arg5.unmarshall (conn)) 408 return FAIL; 409 result = func (conn, arg1, arg2, arg3, arg4, arg5); 410 if (!conn->send ('R')) 411 return FAIL; 412 return marshall (conn, result); 413 } 414 415 template<typename R, typename A1, typename A2, typename A3, typename A4, 416 typename A5, typename A6, typename A7> 417 status 418 call (connection *conn, const char *method, R *result, A1 arg1, A2 arg2, 419 A3 arg3, A4 arg4, A5 arg5, A6 arg6, A7 arg7) 420 { 421 if (!conn->send ('Q')) 422 return FAIL; 423 if (!marshall (conn, method)) 424 return FAIL; 425 if (!marshall (conn, 7)) 426 return FAIL; 427 if (!marshall (conn, arg1)) 428 return FAIL; 429 if (!marshall (conn, arg2)) 430 return FAIL; 431 if (!marshall (conn, arg3)) 432 return FAIL; 433 if (!marshall (conn, arg4)) 434 return FAIL; 435 if (!marshall (conn, arg5)) 436 return FAIL; 437 if (!marshall (conn, arg6)) 438 return FAIL; 439 if (!marshall (conn, arg7)) 440 return FAIL; 441 if (!conn->wait_for_result ()) 442 return FAIL; 443 if (!unmarshall (conn, result)) 444 return FAIL; 445 return OK; 446 } 447 448 template<typename R, typename A1, typename A2, typename A3, typename A4, 449 typename A5, typename A6, typename A7, 450 R (*func) (connection *, A1, A2, A3, A4, A5, A6, A7)> 451 status 452 callback (connection *conn) 453 { 454 argument_wrapper<A1> arg1; 455 argument_wrapper<A2> arg2; 456 argument_wrapper<A3> arg3; 457 argument_wrapper<A4> arg4; 458 argument_wrapper<A5> arg5; 459 argument_wrapper<A6> arg6; 460 argument_wrapper<A7> arg7; 461 R result; 462 463 if (!unmarshall_check (conn, 7)) 464 return FAIL; 465 if (!arg1.unmarshall (conn)) 466 return FAIL; 467 if (!arg2.unmarshall (conn)) 468 return FAIL; 469 if (!arg3.unmarshall (conn)) 470 return FAIL; 471 if (!arg4.unmarshall (conn)) 472 return FAIL; 473 if (!arg5.unmarshall (conn)) 474 return FAIL; 475 if (!arg6.unmarshall (conn)) 476 return FAIL; 477 if (!arg7.unmarshall (conn)) 478 return FAIL; 479 result = func (conn, arg1, arg2, arg3, arg4, arg5, arg6, arg7); 480 if (!conn->send ('R')) 481 return FAIL; 482 return marshall (conn, result); 483 } 484 }; 485 486 #endif // CC1_PLUGIN_RPC_HH 487
Indexes created Wed May 06 00:24:28 UTC 2026