From: mquinson Date: Mon, 4 Oct 2004 12:01:19 +0000 (+0000) Subject: Interface revolution: do not try to survive to malloc failure X-Git-Tag: v3.3~4909 X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/commitdiff_plain/3d0d626e19a7b79320e7d922c9c1dcf122076cea Interface revolution: do not try to survive to malloc failure git-svn-id: svn+ssh://scm.gforge.inria.fr/svn/simgrid/simgrid/trunk@441 48e7efb5-ca39-0410-a469-dd3cf9ba447f --- diff --git a/cruft/doc/tmpl/comm_datadesc.sgml b/cruft/doc/tmpl/comm_datadesc.sgml index 76bbeb36b5..f5f60bd140 100644 --- a/cruft/doc/tmpl/comm_datadesc.sgml +++ b/cruft/doc/tmpl/comm_datadesc.sgml @@ -14,276 +14,3 @@ Describing data to be exchanged - - - - - -@vars: -@data: -@Returns: - -@p_type: - - - - - - - -@vars: -@data: - -@p_type: - - - - - - - -@name: -@Returns: - -@type: - - - - - - - -@name: -@def: - - - - - - - -@name: - - - - - - - -@name: -@element_type: -@fixed_size: -@dst: -@Returns: - - - - - - - -@name: -@element_type: -@dynamic_size: -@dst: -@Returns: - - - - - - - -@name: -@referenced_type: -@dst: -@Returns: - - - - - - - -@name: -@selector: -@dst: -@Returns: - -@discriminant: - - - - - - - -@name: -@dst: -@Returns: - - - - - - - -@struct_type: -@name: -@field_type: -@Returns: - - - - - - - -@struct_type: - - - - - - - -@name: -@selector: -@dst: -@Returns: - - - - - - - -@union_type: -@name: -@field_type: -@Returns: - - - - - - - -@union_type: - - - - - - - -@element_type: -@dst: -@Returns: - - - - - - - -@type: -@pre: - - - - - - - -@type: -@post: - - - - - - - -@ps: -@Returns: - - - - - - - -@ps: -@val: - - - - - - - -@ps: -@name: -@ddt: -@res: -@Returns: - - - - - - - -@ps: -@name: -@data: -@ddt: -@Returns: - - - - - - - -@ps: -@name: -@data: -@ddt: - - - - - - - -@ps: -@name: -@ddt: - - - - - - - -@ps: - - - - - - - -@ps: - - - - - - - -@Returns: - - diff --git a/cruft/doc/tmpl/comm_messages.sgml b/cruft/doc/tmpl/comm_messages.sgml index a11ecdc53d..feffbd08d1 100644 --- a/cruft/doc/tmpl/comm_messages.sgml +++ b/cruft/doc/tmpl/comm_messages.sgml @@ -14,126 +14,3 @@ Defining messages and callbacks, and sending/receiving messages. - - - - - -@name: -@payload: -@Returns: - -@dst: - - - - - - - -@name: -@version: -@payload: -@Returns: - -@dst: - - - - - - - -@name: -@Returns: - -@dst: - - - - - - - -@name: -@version: -@Returns: - -@dst: - - - - - - - -@expeditor: -@payload: -@Returns: - -@payload_type: -@payload_data: -@msg: - - - - - - - -@msgtype: -@cb: -@Returns: - -@message: -@TTL: - - - - - - - -@msgtype: -@cb: - - - - - - - -@sock: -@msgtype: -@payload: -@Returns: - -@sd: -@msg: -@freeDirective: - - - - - - - -@timeout: -@msgt_want: -@expeditor: -@payload: -@Returns: - -@id: -@message: - - - - - - - -@timeOut: -@Returns: - - diff --git a/cruft/doc/tmpl/comm_socks.sgml b/cruft/doc/tmpl/comm_socks.sgml index 807770c55c..2123296f13 100644 --- a/cruft/doc/tmpl/comm_socks.sgml +++ b/cruft/doc/tmpl/comm_socks.sgml @@ -14,69 +14,3 @@ Open/close sockets, and get info on peer. - - - - - -@host: -@Param2: -@dst: -@Returns: - -@bufSize: -@sock: - - - - - - - -@Param1: -@dst: -@Returns: - -@bufSize: - - - - - - - -@sd: - -@sock: -@Returns: - - - - - - - -@sock: -@Returns: - -@sd: - - - - - - - -@sock: -@Returns: - - - - - - - -@sock: -@Returns: - - diff --git a/cruft/doc/tmpl/gras-unused.sgml b/cruft/doc/tmpl/gras-unused.sgml index ccac7da15d..c26a9bf998 100644 --- a/cruft/doc/tmpl/gras-unused.sgml +++ b/cruft/doc/tmpl/gras-unused.sgml @@ -676,6 +676,20 @@ Sockets @a4: @a5: + + + + + +@c: +@f: +@a1: +@a2: +@a3: +@a4: +@a5: +@a6: + @@ -739,6 +753,20 @@ Sockets @a4: @a5: + + + + + +@c: +@f: +@a1: +@a2: +@a3: +@a4: +@a5: +@a6: + @@ -802,6 +830,20 @@ Sockets @a4: @a5: + + + + + +@c: +@f: +@a1: +@a2: +@a3: +@a4: +@a5: +@a6: + @@ -865,6 +907,20 @@ Sockets @a4: @a5: + + + + + +@c: +@f: +@a1: +@a2: +@a3: +@a4: +@a5: +@a6: + @@ -1006,6 +1062,47 @@ Sockets @a4: @a5: + + + + + +@f: +@a1: +@a2: +@a3: +@a4: +@a5: +@a6: + + + + + + +@c: +@f: +@a1: +@a2: +@a3: +@a4: +@a5: +@a6: + + + + + + +@c: +@f: +@a1: +@a2: +@a3: +@a4: +@a5: +@a6: + @@ -1061,6 +1158,19 @@ Sockets @childToParent: @Returns: + + + + + +@f: +@a1: +@a2: +@a3: +@a4: +@a5: +@a6: + @@ -1131,6 +1241,19 @@ Sockets + + + + + +@f: +@a1: +@a2: +@a3: +@a4: +@a5: +@a6: + @@ -1150,18 +1273,84 @@ Sockets @HOST_FORMAT: @NETWORK_FORMAT: + + + + + +@name: +@def: + + + + + + +@cname: + + + + + + +@cname: + + + + + + +@catName: +@priority: + + + + + + +@catName: + + + + + + +@cname: + + + + + + +@cname: +@parent: + + + + + + +@catName: +@parent: + + + + + + + @@ -1249,6 +1438,19 @@ Sockets @format: @Returns: + + + + + +@f: +@a1: +@a2: +@a3: +@a4: +@a5: +@a6: + @@ -1548,12 +1750,38 @@ Sockets @sd: @Returns: + + + + + +@f: +@a1: +@a2: +@a3: +@a4: +@a5: +@a6: + + + + + + +@f: +@a1: +@a2: +@a3: +@a4: +@a5: +@a6: + @@ -1871,700 +2099,1816 @@ Sockets @ud: - + -@type: -@post: +@Returns: - + -@type: -@pre: +@msgtype: +@cb: +@Returns: +@message: +@TTL: - + -@d1: -@d2: +@expeditor: +@payload: @Returns: -@dd1: -@c1: -@dd2: -@c2: +@payload_type: +@payload_data: +@msg: - + -@dd: -@c: -@data: +@msgtype: +@cb: - + -@name: -@elm_type: -@size: -@code: +@ps: - + -@name: -@element_type: -@fixed_size: -@dynamic_size: -@post: -@code: -@Returns: +@ps: - + -@name: -@element_type: -@dynamic_size: -@dst: +@ps: @Returns: -@elm_type: -@code: - + -@name: -@element_type: -@fixed_size: -@dst: -@Returns: +@ps: +@val: - + +@ps: @name: -@referenced_type: -@dst: +@ddt: + + + + + + +@ps: +@name: +@ddt: +@res: @Returns: -@ref_type: -@code: - + +@ps: @name: -@referenced_type: -@discriminant: -@post: -@code: +@data: +@ddt: @Returns: - + +@ps: @name: -@discriminant: -@code: +@data: +@ddt: - + + + + + +@cfg: +@Returns: + + + + + + +@whereto: +@tocopy: +@Returns: + + @name: -@discriminant: -@dst: +@indent: +@cfg: + + + + + + +@cfg: +@name: @Returns: - + + + + + +@cfg: + + +@cfg: @name: -@dst: +@val: @Returns: -@code: - + -@struct_code: -@field_name: -@field_type_code: +@cfg: +@name: +@dynar: +@Returns: - + -@struct_code: -@field_name: -@field_code: -@pre_cb: -@post_cb: +@cfg: +@name: +@host: +@port: @Returns: - + -@struct_code: -@field_name: -@field_type_name: +@cfg: +@name: +@val: +@Returns: - + -@struct_code: -@field_name: -@field_type_name: -@pre_cb: -@post_cb: +@cfg: +@name: +@val: @Returns: - + -@struct_type: +@whereto: +@Returns: + + + + + + +@cfg: @name: -@field_type: +@type: +@min: +@max: @Returns: - + -@struct_type: +@cfg: +@entry: +@Returns: + + + + + + +@cfg: @name: -@field_type_name: +@val: @Returns: - + +@cfg: @name: -@pre_cb: -@post_cb: -@code: +@host: +@port: @Returns: - + -@struct_type: +@cfg: +@name: +@val: +@Returns: - + +@cfg: @name: -@selector: -@dst: +@val: @Returns: -@code: - + -@union_code: -@field_name: -@field_type_code: +@cfg: +@Varargs: +@Returns: - + -@union_code: -@field_name: -@field_code: -@pre_cb: -@post_cb: +@cfg: +@name: +@val: @Returns: - + -@union_code: -@field_name: -@field_type_name: +@cfg: +@name: +@host: +@port: +@Returns: - + -@union_code: -@field_name: -@field_type_name: -@pre_cb: -@post_cb: +@cfg: +@name: +@val: @Returns: - + -@union_type: +@cfg: +@options: +@Returns: + + + + + + +@cfg: @name: -@field_type: +@val: @Returns: - + + + + + +@cfg: +@pa: +@Returns: + + -@union_type: @name: -@field_type_name: +@element_type: +@dynamic_size: +@dst: @Returns: - + @name: -@field_count: +@element_type: +@fixed_size: +@dst: +@Returns: + + + + + + +@name: +@Returns: +@type: + + + + + + +@name: + + + + + + +@type: @post: -@code: + + + + + + +@type: +@pre: + + + + + + +@type: +@post: + + + + + + +@type: +@pre: + + + + + + +@d1: +@d2: @Returns: +@dd1: +@c1: +@dd2: +@c2: - + -@union_type: +@dd: +@c: +@data: + + + + + + +@name: +@elm_type: +@size: +@code: + + + + + + +@name: +@element_type: +@fixed_size: +@dynamic_size: +@post: +@code: +@Returns: + + + + + + +@name: +@element_type: +@dynamic_size: +@dst: +@Returns: +@elm_type: +@code: + + + + + + +@name: +@element_type: +@fixed_size: +@dst: +@Returns: + + + + + + +@name: +@referenced_type: +@dst: +@Returns: +@ref_type: +@code: + + + + + + +@name: +@referenced_type: +@discriminant: +@post: +@code: +@Returns: + + + + + + +@name: +@discriminant: +@code: + + + + + + +@name: +@discriminant: +@dst: +@Returns: + + + + + + +@name: +@dst: +@Returns: +@code: + + + + + + +@struct_code: +@field_name: +@field_type_code: + + + + + + +@struct_code: +@field_name: +@field_code: +@pre_cb: +@post_cb: +@Returns: + + + + + + +@struct_code: +@field_name: +@field_type_name: + + + + + + +@struct_code: +@field_name: +@field_type_name: +@pre_cb: +@post_cb: +@Returns: + + + + + + +@struct_type: +@name: +@field_type: +@Returns: + + + + + + +@struct_type: +@name: +@field_type_name: +@Returns: + + + + + + +@name: +@pre_cb: +@post_cb: +@code: +@Returns: + + + + + + +@struct_type: + + + + + + +@name: +@selector: +@dst: +@Returns: +@code: + + + + + + +@union_code: +@field_name: +@field_type_code: + + + + + + +@union_code: +@field_name: +@field_code: +@pre_cb: +@post_cb: +@Returns: + + + + + + +@union_code: +@field_name: +@field_type_name: + + + + + + +@union_code: +@field_name: +@field_type_name: +@pre_cb: +@post_cb: +@Returns: + + + + + + +@union_type: +@name: +@field_type: +@Returns: + + + + + + +@union_type: +@name: +@field_type_name: +@Returns: + + + + + + +@name: +@field_count: +@post: +@code: +@Returns: + + + + + + +@union_type: + + + + + + +@name: +@desc: +@howmany: +@code: +@Returns: +@dst: + + + + + + +@name: +@desc: +@howmany: +@dst: +@Returns: + + + + + + +@name: +@Cdefinition: +@dst: +@Returns: +@code: +@def: + + + + + + +@name: +@referenced_type: +@dst: +@Returns: + + + + + + +@name: +@selector: +@dst: +@Returns: +@discriminant: + + + + + + +@element_type: +@dst: +@Returns: + + + + + + +@name: +@dst: +@Returns: + + + + + + +@struct_type: +@name: +@field_type: +@Returns: + + + + + + +@struct_type: + + + + + + +@vars: +@data: +@Returns: +@p_type: + + + + + + +@vars: +@data: +@p_type: + + + + + + +@name: +@selector: +@dst: +@Returns: + + + + + + +@union_type: +@name: +@field_type: +@Returns: + + + + + + +@union_type: + + + + + + +@ps: + + + + + + +@ps: + + + + + + +@ps: +@name: +@ddt: + + + + + + +@ps: +@name: +@ddt: + + + + + + +@ps: +@name: +@data: +@ddt: + + + + + + +@ps: +@name: +@data: +@ddt: + + + + + + +@type: + + + + + + +@code: +@type: +@Returns: + + + + + + +@name: +@type: +@Returns: + + + + + + +@name: +@element_type: +@fixed_size: +@dynamic_size: +@post: +@dst: +@Returns: + + + + + + +@name: +@desc: +@howmany: +@dst: +@Returns: + + + + + + +@name: +@default_value: +@free_func: +@size: +@alignment: +@post: +@dst: +@Returns: + + + + + + +@name: +@C_definition: +@dst: +@Returns: + + + + + + +@name: +@referenced_type: +@discriminant: +@post: +@dst: +@Returns: + + + + + + +@name: +@type: +@Returns: + + + + + + +@name: +@pre: +@post: +@dst: +@Returns: + + + + + + +@struct_type: +@name: +@field_type: +@pre: +@post: +@Returns: + + + + + + +@name: +@field_count: +@post: +@dst: +@Returns: + + + + + + +@union_type: +@name: +@field_type: +@pre: +@post: +@Returns: + + + + + + +@type: +@Returns: + + + + + + +@cursor: +@Returns: + + + + + + +@cursor: +@data: +@Returns: + + + + + + +@cursor: +@key: +@Returns: + + + + + + +@head: +@cursor: +@Returns: + + + + + + +@cursor: +@Returns: + + + + + + +@cursor: +@Returns: + + + + + + +@head: +@output: +@Returns: + + + + + + +@dict: +@cursor: +@key: +@data: + + + + + + +@dict: +@Returns: + + + + + + +@head: +@key: +@data: +@Returns: + + + + + + +@head: +@key: +@key_len: +@data: +@Returns: + + + + + + +@head: +@key: +@data: +@free_ctn: +@Returns: + + + + + + +@head: +@key: +@key_len: +@data: +@free_ctn: +@Returns: + + + + + + +@dict: +@Returns: + + + + + + +@data: + + + + + + +@data: + + + + + + +@head: +@key: +@Returns: + + + + + + +@head: +@key: +@key_len: +@Returns: + + + + + + +@head: +@key: +@data: +@Returns: + + + + + + +@head: +@key: +@key_len: +@data: +@Returns: + + + + + + +@head: +@key: +@data: +@free_ctn: +@Returns: + + + + + + +@head: +@key: +@key_len: +@data: +@free_ctn: +@Returns: + + + + + + +@dynar: +@cursor: + + + + + + +@dynar: +@cursor: +@whereto: +@Returns: + + + + + + +@dynar: +@cursor: + + + + + + +@dynar: +@cursor: + + + + + + +@dynar: +@cursor: +@Returns: + + + + + + +@_dynar: +@_cursor: +@_data: +@_whereto: + + + + + + +@dynar: +@Returns: + + + + + + +@dynar: +@Returns: + + + + + + +@dynar: +@idx: +@dst: +@whereto: +@Returns: + + + + + + +@dynar: +@idx: +@src: +@Returns: +@object: + + + + + + +@dynar: +@Returns: + + + + + + +@dynar: +@operator: +@Returns: + + + + + + +@whereto: +@elm_size: +@free_func: +@Returns: + + + + + + +@dynar: +@cursor: +@whereto: +@Returns: + + + + + + +@dynar: +@dst: +@whereto: + + + + + + +@dynar: +@src: +@Returns: +@object: + + + + + + +@dynar: +@idx: +@object: +@Returns: + + + + + + +@dynar: +@idx: +@object: +@Returns: + + + + + + +@dynar: +@Returns: + + + + + + +@dynar: +@idx: +@src: +@Returns: +@object: + + + + + + +@dynar: +@dst: +@whereto: +@Returns: - + -@name: -@desc: -@howmany: -@code: +@dynar: +@src: @Returns: -@dst: +@object: - + -@name: -@desc: -@howmany: -@dst: -@Returns: +@no_error: no error +@malloc_error: Well known error +@mismatch_error: Not found +@system_error: a syscall did fail +@network_error: error while sending/receiving data +@timeout_error: not quick enough, dude +@thread_error: error while [un]locking +@unknown_error: no idea - + -@name: -@Cdefinition: -@dst: @Returns: -@code: -@def: - + -@ps: +@cat: +@app: - + -@ps: +@cs: +@Returns: - + -@ps: -@name: -@ddt: - + -@ps: -@name: -@ddt: +@cat: +@parent: - + -@ps: -@name: -@data: -@ddt: +@gras_log_priority_none: +@gras_log_priority_trace: +@gras_log_priority_debug: +@gras_log_priority_verbose: +@gras_log_priority_info: +@gras_log_priority_warning: +@gras_log_priority_error: +@gras_log_priority_critical: +@gras_log_priority_infinite: +@gras_log_priority_uninitialized: - + -@ps: -@name: -@data: -@ddt: +@cat: +@thresholdPriority: - + -@type: +@sd: +@size: - + -@code: -@type: -@Returns: +@msg: - + -@name: -@type: +@timeOut: @Returns: - + -@name: -@element_type: -@fixed_size: -@dynamic_size: -@post: -@dst: +@msgId: +@free_data_on_free: +@seqCount: +@Varargs: @Returns: - + -@name: -@desc: -@howmany: -@dst: +@sock: +@msgtype: +@payload: @Returns: +@sd: +@msg: +@freeDirective: - + -@name: -@default_value: -@free_func: -@size: -@alignment: -@post: -@dst: +@timeout: +@msgt_want: +@expeditor: +@payload: @Returns: +@id: +@message: - + @name: -@C_definition: -@dst: @Returns: +@dst: - + @name: -@referenced_type: -@discriminant: -@post: -@dst: +@version: @Returns: +@dst: - + @name: -@type: +@payload: @Returns: +@dst: - + @name: -@pre: -@post: -@dst: +@version: +@payload: @Returns: +@dst: - + -@struct_type: +@msgId: @name: -@field_type: -@pre: -@post: +@sequence_count: +@Varargs: @Returns: - + -@name: -@field_count: -@post: -@dst: -@Returns: +@Param1: +@Param2: - + -@union_type: -@name: -@field_type: -@pre: -@post: @Returns: - + -@type: +@set: +@elm: +@free_func: @Returns: - + +@set: @cursor: -@Returns: +@elm: - + -@head: -@key: -@data: -@free_ctn: -@Returns: +@set: - + -@head: -@key: -@key_len: -@data: -@free_ctn: +@set: +@id: +@dst: @Returns: - + -@head: +@set: @key: -@data: +@dst: @Returns: - + -@head: -@key: -@key_len: -@data: +@set: +@name: +@name_len: +@dst: @Returns: - + -@dynar: -@cursor: +@dst: @Returns: - + -@dynar: -@cursor: -@whereto: -@Returns: +@Param1: +@Param2: - + +@host: +@Param2: +@sock: @Returns: - + -@cat: -@parent: +@sock: +@Returns: - + -@cat: -@thresholdPriority: +@sd: +@Returns: - + @sd: -@size: +@Returns: - + -@msg: +@Param1: +@Param2: +@sock: +@Returns: - + -@msgId: -@free_data_on_free: -@seqCount: -@Varargs: +@host: +@Param2: +@dst: @Returns: +@bufSize: +@sock: - + -@msgId: -@name: -@sequence_count: -@Varargs: +@sd: +@sock: @Returns: - + -@Param1: -@Param2: +@sock: +@Returns: - + -@host: -@Param2: @sock: @Returns: +@sd: - + @@ -2572,43 +3916,47 @@ Sockets @sock: @Returns: - + -@sd: +@Param1: +@dst: @Returns: +@bufSize: - + -@sd: @Returns: - + -@Param1: -@Param2: -@sock: @Returns: - + -@Returns: - + -@Returns: +@type: + + + + + + +@ud: diff --git a/cruft/doc/tmpl/tbx_cfg.sgml b/cruft/doc/tmpl/tbx_cfg.sgml index 5a41ba9061..d6d7834d6a 100644 --- a/cruft/doc/tmpl/tbx_cfg.sgml +++ b/cruft/doc/tmpl/tbx_cfg.sgml @@ -14,258 +14,3 @@ Configuration facilities. - - - - - -@whereto: -@Returns: - - - - - - - -@whereto: -@tocopy: -@Returns: - - - - - - - -@cfg: - - - - - - - -@name: -@indent: -@cfg: - - - - - - - -@cfg: -@name: -@type: -@min: -@max: -@Returns: - - - - - - - -@cfg: -@entry: -@Returns: - - - - - - - -@cfg: -@Returns: - - - - - - - -@cfg: -@options: -@Returns: - - - - - - - -@cfg: -@Varargs: -@Returns: - - - - - - - -@cfg: -@pa: -@Returns: - - - - - - - -@cfg: -@name: -@val: -@Returns: - - - - - - - -@cfg: -@name: -@val: -@Returns: - - - - - - - -@cfg: -@name: -@val: -@Returns: - - - - - - - -@cfg: -@name: -@host: -@port: -@Returns: - - - - - - - -@cfg: -@name: -@val: -@Returns: - - - - - - - -@cfg: -@name: -@val: -@Returns: - - - - - - - -@cfg: -@name: -@val: -@Returns: - - - - - - - -@cfg: -@name: -@host: -@port: -@Returns: - - - - - - - -@cfg: -@name: -@Returns: - - - - - - - -@cfg: -@name: -@val: -@Returns: - - - - - - - -@cfg: -@name: -@val: -@Returns: - - - - - - - -@cfg: -@name: -@val: -@Returns: - - - - - - - -@cfg: -@name: -@host: -@port: -@Returns: - - - - - - - -@cfg: -@name: -@dynar: -@Returns: - - diff --git a/cruft/doc/tmpl/tbx_dico.sgml b/cruft/doc/tmpl/tbx_dico.sgml index 48cdd0cedb..0e59b654fa 100644 --- a/cruft/doc/tmpl/tbx_dico.sgml +++ b/cruft/doc/tmpl/tbx_dico.sgml @@ -14,177 +14,3 @@ Data container associating data to a string key. - - - - - -@dict: -@Returns: - - - - - - - -@dict: - -@Returns: - - - - - - - -@head: -@key: -@data: -@free_ctn: -@Returns: - - - - - - - -@head: -@key: -@key_len: -@data: -@free_ctn: -@Returns: - - - - - - - -@head: -@key: -@data: -@Returns: - - - - - - - -@head: -@key: -@key_len: -@data: -@Returns: - - - - - - - -@head: -@key: -@Returns: - - - - - - - -@head: -@key: -@key_len: -@Returns: - - - - - - - -@head: -@output: -@Returns: - - - - - - - -@data: - - - - - - - -@data: - - - - - - - -@cursor: -@data: -@Returns: - - - - - - - -@cursor: -@key: -@Returns: - - - - - - - -@dict: -@cursor: -@key: -@data: - - - - - - - -@head: -@cursor: -@Returns: - - - - - - - -@cursor: - -@Returns: - - - - - - - -@cursor: -@Returns: - - diff --git a/cruft/doc/tmpl/tbx_dynar.sgml b/cruft/doc/tmpl/tbx_dynar.sgml index f45ffd16dd..e02316ee69 100644 --- a/cruft/doc/tmpl/tbx_dynar.sgml +++ b/cruft/doc/tmpl/tbx_dynar.sgml @@ -14,223 +14,3 @@ This module provide the quite usual dynamic array facility. - - - - - -@whereto: -@elm_size: -@free_func: -@Returns: - - - - - - - -@dynar: - -@Returns: - - - - - - - -@dynar: - -@Returns: - - - - - - - -@dynar: -@Returns: - - - - - - - -@dynar: - -@Returns: - - - - - - - -@dynar: -@idx: -@dst: - -@whereto: -@Returns: - - - - - - - -@dynar: -@idx: -@src: -@Returns: - -@object: - - - - - - - -@dynar: -@idx: -@object: -@Returns: - - - - - - - -@dynar: -@idx: -@src: -@Returns: - -@object: - - - - - - - -@dynar: -@idx: -@object: - -@Returns: - - - - - - - -@dynar: -@operator: - -@Returns: - - - - - - - -@dynar: -@src: -@Returns: - -@object: - - - - - - - -@dynar: -@dst: - -@whereto: - - - - - - - -@dynar: -@dst: - -@whereto: -@Returns: - - - - - - - -@dynar: -@src: -@Returns: - -@object: - - - - - - - -@_dynar: -@_cursor: -@_data: - -@_whereto: - - - - - - - -@dynar: -@cursor: - - - - - - - -@dynar: -@cursor: - - - - - - - -@dynar: -@cursor: -@whereto: -@Returns: - - - - - - - -@dynar: -@cursor: - - diff --git a/cruft/doc/tmpl/tbx_err.sgml b/cruft/doc/tmpl/tbx_err.sgml index 7fb18f428c..e283b6a340 100644 --- a/cruft/doc/tmpl/tbx_err.sgml +++ b/cruft/doc/tmpl/tbx_err.sgml @@ -14,17 +14,3 @@ Error reporting - - - - - -@no_error: no error -@malloc_error: Well known error -@mismatch_error: Not found -@system_error: a syscall did fail -@network_error: error while sending/receiving data -@timeout_error: not quick enough, dude -@thread_error: error while [un]locking -@unknown_error: no idea - diff --git a/cruft/doc/tmpl/tbx_log.sgml b/cruft/doc/tmpl/tbx_log.sgml index 6661b96ec4..c698697ffa 100644 --- a/cruft/doc/tmpl/tbx_log.sgml +++ b/cruft/doc/tmpl/tbx_log.sgml @@ -290,283 +290,3 @@ An easy-to-use, fast and flexible message logging architecture. - - - - - -@gras_log_priority_none: -@gras_log_priority_trace: -@gras_log_priority_debug: -@gras_log_priority_verbose: -@gras_log_priority_info: -@gras_log_priority_warning: -@gras_log_priority_error: -@gras_log_priority_critical: -@gras_log_priority_infinite: -@gras_log_priority_uninitialized: - - - - - - -@cs: -@Returns: - - - - - - - -@catName: - - - - - - - -@catName: -@parent: - - - - - - - -@cname: - - - - - - - -@cname: -@parent: - - - - - - - -@cname: - - - - - - - -@cname: - - - - - - - -@catName: -@priority: - - - - - - - - - - - - - - -@cat: -@app: - - - - - - - - - - - - - -@c: -@f: -@a1: -@a2: -@a3: -@a4: -@a5: -@a6: - - - - - - - -@c: -@f: -@a1: -@a2: -@a3: -@a4: -@a5: -@a6: - - - - - - - -@c: -@f: -@a1: -@a2: -@a3: -@a4: -@a5: -@a6: - - - - - - - -@c: -@f: -@a1: -@a2: -@a3: -@a4: -@a5: -@a6: - - - - - - - -@c: -@f: -@a1: -@a2: -@a3: -@a4: -@a5: -@a6: - - - - - - - -@c: -@f: -@a1: -@a2: -@a3: -@a4: -@a5: -@a6: - - - - - - - -@f: -@a1: -@a2: -@a3: -@a4: -@a5: -@a6: - - - - - - - -@f: -@a1: -@a2: -@a3: -@a4: -@a5: -@a6: - - - - - - - -@f: -@a1: -@a2: -@a3: -@a4: -@a5: -@a6: - - - - - - - -@f: -@a1: -@a2: -@a3: -@a4: -@a5: -@a6: - - - - - - - -@f: -@a1: -@a2: -@a3: -@a4: -@a5: -@a6: - - - - - - - -@f: -@a1: -@a2: -@a3: -@a4: -@a5: -@a6: - - diff --git a/cruft/doc/tmpl/tbx_set.sgml b/cruft/doc/tmpl/tbx_set.sgml index 0047538b89..ddb5d3598e 100644 --- a/cruft/doc/tmpl/tbx_set.sgml +++ b/cruft/doc/tmpl/tbx_set.sgml @@ -14,75 +14,3 @@ Data storage for very quick retrieve - - - - - -@dst: -@Returns: - - - - - - - -@set: - - - - - - - -@set: -@elm: -@free_func: -@Returns: - - - - - - - -@set: -@key: -@dst: -@Returns: - - - - - - - -@set: -@name: -@name_len: -@dst: -@Returns: - - - - - - - -@set: -@id: -@dst: -@Returns: - - - - - - - -@set: -@cursor: -@elm: - - diff --git a/cruft/doc/tmpl/virtu_globals.sgml b/cruft/doc/tmpl/virtu_globals.sgml index 1a63025bfc..79ab31d06f 100644 --- a/cruft/doc/tmpl/virtu_globals.sgml +++ b/cruft/doc/tmpl/virtu_globals.sgml @@ -18,26 +18,3 @@ retrive a reference to it. - - - - - - - - - - - - -@ud: - - - - - - - -@type: - - diff --git a/cruft/doc/tmpl/virtu_syscall.sgml b/cruft/doc/tmpl/virtu_syscall.sgml index 03f4b4aec2..3b13a68203 100644 --- a/cruft/doc/tmpl/virtu_syscall.sgml +++ b/cruft/doc/tmpl/virtu_syscall.sgml @@ -14,20 +14,3 @@ System call abstraction layer. - - - - - -@Returns: - - - - - - - -@Param1: -@Param2: - - diff --git a/examples/ping/ping.c b/examples/ping/ping.c index 4c4b186fb3..800df8b20d 100644 --- a/examples/ping/ping.c +++ b/examples/ping/ping.c @@ -25,16 +25,13 @@ typedef struct { } msg_ping_t; /* Function prototypes */ -gras_error_t register_messages(void); +void register_messages(void); /* Code */ -gras_error_t register_messages(void) { - gras_error_t errcode; - - TRY(gras_msgtype_declare("ping", gras_datadesc_by_name("int"))); - TRY(gras_msgtype_declare("pong", gras_datadesc_by_name("int"))); +void register_messages(void) { - return no_error; + gras_msgtype_declare("ping", gras_datadesc_by_name("int")); + gras_msgtype_declare("pong", gras_datadesc_by_name("int")); } /* ********************************************************************** @@ -105,9 +102,9 @@ int server (int argc,char *argv[]) { return 1; } - TRYFAIL(register_messages()); - TRYFAIL(register_messages()); - TRYFAIL(gras_cb_register(gras_msgtype_by_name("ping"),&server_cb_ping_handler)); + register_messages(); + register_messages(); + gras_cb_register(gras_msgtype_by_name("ping"),&server_cb_ping_handler); INFO1("SERVER: >>>>>>>> Listening on port %d <<<<<<<<", gras_socket_my_port(g->sock)); @@ -167,7 +164,7 @@ int client(int argc,char *argv[]) { INFO2("Client: Connected to %s:%d.",host,port); - TRY(register_messages()); + register_messages(); INFO2("Client: >>>>>>>> Connected to server which is on %s:%d <<<<<<<<", gras_socket_peer_name(g->sock),gras_socket_peer_port(g->sock)); diff --git a/include/gras/datadesc.h b/include/gras/datadesc.h index 9fe894a899..597686b28f 100644 --- a/include/gras/datadesc.h +++ b/include/gras/datadesc.h @@ -61,46 +61,44 @@ gras_datadesc_type_t *gras_datadesc_by_name(const char *name); **** Declare datadescription yourself **** ******************************************/ -gras_error_t -gras_datadesc_struct(const char *name, - gras_datadesc_type_t **dst); -gras_error_t -gras_datadesc_struct_append(gras_datadesc_type_t *struct_type, - const char *name, - gras_datadesc_type_t *field_type); +gras_datadesc_type_t * + gras_datadesc_struct(const char *name); + void -gras_datadesc_struct_close(gras_datadesc_type_t *struct_type); -gras_error_t -gras_datadesc_union(const char *name, - gras_datadesc_type_cb_int_t selector, - gras_datadesc_type_t **dst); -gras_error_t -gras_datadesc_union_append(gras_datadesc_type_t *union_type, - const char *name, - gras_datadesc_type_t *field_type); + gras_datadesc_struct_append(gras_datadesc_type_t *struct_type, + const char *name, + gras_datadesc_type_t *field_type); void -gras_datadesc_union_close(gras_datadesc_type_t *union_type); -gras_error_t -gras_datadesc_ref(const char *name, - gras_datadesc_type_t *referenced_type, - gras_datadesc_type_t **dst); -gras_error_t -gras_datadesc_ref_generic(const char *name, - gras_datadesc_selector_t selector, - gras_datadesc_type_t **dst); -gras_error_t -gras_datadesc_array_fixed(const char *name, - gras_datadesc_type_t *element_type, - long int fixed_size, - gras_datadesc_type_t **dst); -gras_error_t -gras_datadesc_array_dyn(const char *name, - gras_datadesc_type_t *element_type, - gras_datadesc_type_cb_int_t dynamic_size, - gras_datadesc_type_t **dst); -gras_error_t -gras_datadesc_ref_pop_arr(gras_datadesc_type_t *element_type, - gras_datadesc_type_t **dst); + gras_datadesc_struct_close(gras_datadesc_type_t *struct_type); + +gras_datadesc_type_t * + gras_datadesc_union(const char *name, + gras_datadesc_type_cb_int_t selector); +void + gras_datadesc_union_append(gras_datadesc_type_t *union_type, + const char *name, + gras_datadesc_type_t *field_type); +void + gras_datadesc_union_close(gras_datadesc_type_t *union_type); + +gras_datadesc_type_t * + gras_datadesc_ref(const char *name, + gras_datadesc_type_t *referenced_type); +gras_datadesc_type_t * + gras_datadesc_ref_generic(const char *name, + gras_datadesc_selector_t selector); + +gras_datadesc_type_t * + gras_datadesc_array_fixed(const char *name, + gras_datadesc_type_t *element_type, + long int fixed_size); +gras_datadesc_type_t * + gras_datadesc_array_dyn(const char *name, + gras_datadesc_type_t *element_type, + gras_datadesc_type_cb_int_t dynamic_size); + +gras_datadesc_type_t * + gras_datadesc_ref_pop_arr(gras_datadesc_type_t *element_type); /********************************* * Change stuff within datadescs * diff --git a/include/gras/messages.h b/include/gras/messages.h index ebe905999d..b794e142c3 100644 --- a/include/gras/messages.h +++ b/include/gras/messages.h @@ -38,11 +38,11 @@ BEGIN_DECL /* msgtype declaration and retrival */ typedef struct s_gras_msgtype gras_msgtype_t; -gras_error_t gras_msgtype_declare (const char *name, - gras_datadesc_type_t *payload); -gras_error_t gras_msgtype_declare_v(const char *name, - short int version, - gras_datadesc_type_t *payload); +void gras_msgtype_declare (const char *name, + gras_datadesc_type_t *payload); +void gras_msgtype_declare_v(const char *name, + short int version, + gras_datadesc_type_t *payload); gras_msgtype_t *gras_msgtype_by_name (const char *name); gras_msgtype_t *gras_msgtype_by_namev(const char *name, @@ -61,10 +61,10 @@ gras_msgtype_t *gras_msgtype_by_namev(const char *name, */ typedef int (*gras_cb_t)(gras_socket_t *expeditor, void *payload); -gras_error_t gras_cb_register (gras_msgtype_t *msgtype, - gras_cb_t cb); -void gras_cb_unregister(gras_msgtype_t *msgtype, - gras_cb_t cb); +void gras_cb_register (gras_msgtype_t *msgtype, + gras_cb_t cb); +void gras_cb_unregister(gras_msgtype_t *msgtype, + gras_cb_t cb); gras_error_t gras_msg_send(gras_socket_t *sock, gras_msgtype_t *msgtype, diff --git a/include/xbt/config.h b/include/xbt/config.h index e57ebeb9ec..db1fa61b4d 100644 --- a/include/xbt/config.h +++ b/include/xbt/config.h @@ -29,16 +29,16 @@ typedef enum { } gras_cfgelm_type_t; /*----[ Memory management ]-----------------------------------------------*/ -gras_error_t gras_cfg_new (gras_cfg_t **whereto); /* (whereto == NULL) is ok */ -gras_error_t gras_cfg_cpy(gras_cfg_t **whereto, gras_cfg_t *tocopy); +void gras_cfg_new (gras_cfg_t **whereto); /* (whereto == NULL) is ok */ +void gras_cfg_cpy(gras_cfg_t **whereto, gras_cfg_t *tocopy); void gras_cfg_free(gras_cfg_t **cfg); void gras_cfg_dump(const char *name,const char*indent,gras_cfg_t *cfg); /*----[ Registering stuff ]-----------------------------------------------*/ /* Register a possible cell */ -gras_error_t gras_cfg_register(gras_cfg_t *cfg, - const char *name, gras_cfgelm_type_t type, - int min, int max); +void gras_cfg_register(gras_cfg_t *cfg, + const char *name, gras_cfgelm_type_t type, + int min, int max); /* Unregister a possible cell */ gras_error_t gras_cfg_unregister(gras_cfg_t *cfg, const char *name); diff --git a/include/xbt/dict.h b/include/xbt/dict.h index ad95cc9004..3ec4711410 100644 --- a/include/xbt/dict.h +++ b/include/xbt/dict.h @@ -21,19 +21,19 @@ typedef struct gras_dict_ gras_dict_t; /*####[ Simple dict functions ]#############################################*/ -gras_error_t gras_dict_new(gras_dict_t **dict); -void gras_dict_free(gras_dict_t **dict); +void gras_dict_new(gras_dict_t **dict); +void gras_dict_free(gras_dict_t **dict); -gras_error_t gras_dict_set (gras_dict_t *head, - const char *key, - void *data, - void_f_pvoid_t *free_ctn); -gras_error_t gras_dict_set_ext(gras_dict_t *head, - const char *key, - int key_len, - void *data, - void_f_pvoid_t *free_ctn); +void gras_dict_set (gras_dict_t *head, + const char *key, + void *data, + void_f_pvoid_t *free_ctn); +void gras_dict_set_ext(gras_dict_t *head, + const char *key, + int key_len, + void *data, + void_f_pvoid_t *free_ctn); /*----[ gras_dict_get ]------------------------------------------------------*/ /* Search the given #key#. data=NULL when not found. */ @@ -56,10 +56,9 @@ gras_error_t gras_dict_remove_ext(gras_dict_t *head,const char *key, /*----[ gras_dict_dump ]-----------------------------------------------------*/ /* Outputs the content of the structure. (for debuging purpose) */ /* #output# is a function to output the data.If NULL, data won't be displayed*/ -/* Returns if it was ok or not */ /*---------------------------------------------------------------------------*/ -gras_error_t gras_dict_dump(gras_dict_t *head, - void (*output)(void*)); +void gras_dict_dump(gras_dict_t *head, + void (*output)(void*)); /*----[ gras_dict_print ]----------------------------------------------------*/ /* To dump multicache, this function dump a cache */ /*---------------------------------------------------------------------------*/ @@ -118,13 +117,13 @@ gras_error_t gras_multidict_remove_ext(gras_dict_t *head, /*###########################################################################*/ typedef struct gras_dict_cursor_ gras_dict_cursor_t; /* creator/destructor */ -gras_error_t gras_dict_cursor_new(const gras_dict_t *head, - /*OUT*/gras_dict_cursor_t **cursor); +void gras_dict_cursor_new(const gras_dict_t *head, + /*OUT*/gras_dict_cursor_t **cursor); void gras_dict_cursor_free(gras_dict_cursor_t *cursor); /* back to first element it is not enough to reinit the cache after an add/remove in cache*/ -gras_error_t gras_dict_cursor_rewind(gras_dict_cursor_t *cursor); +void gras_dict_cursor_rewind(gras_dict_cursor_t *cursor); gras_error_t gras_dict_cursor_get_key (gras_dict_cursor_t *cursor, diff --git a/include/xbt/dynar.h b/include/xbt/dynar.h index 3180b700b7..0e120b3eb5 100644 --- a/include/xbt/dynar.h +++ b/include/xbt/dynar.h @@ -17,7 +17,7 @@ typedef struct gras_dynar_s gras_dynar_t; typedef void (void_f_ppvoid_t)(void**); typedef void (void_f_pvoid_t) (void*); -gras_error_t gras_dynar_new(gras_dynar_t **whereto, +void gras_dynar_new(gras_dynar_t **whereto, size_t elm_size, void_f_pvoid_t *free_func); void gras_dynar_free(gras_dynar_t *dynar); @@ -28,30 +28,30 @@ void gras_dynar_reset(gras_dynar_t *dynar); /* regular array functions */ -void gras_dynar_get(const gras_dynar_t *dynar, - int idx, void *dst); -gras_error_t gras_dynar_set(gras_dynar_t *dynar, - int idx, const void *src); -gras_error_t gras_dynar_remplace(gras_dynar_t *dynar, - int idx, const void *object); +void gras_dynar_get(const gras_dynar_t *dynar, + int idx, void *dst); +void gras_dynar_set(gras_dynar_t *dynar, + int idx, const void *src); +void gras_dynar_remplace(gras_dynar_t *dynar, + int idx, const void *object); /* perl array function */ -gras_error_t gras_dynar_insert_at(gras_dynar_t *dynar, - int idx, const void *src); -void gras_dynar_remove_at(gras_dynar_t *dynar, - int idx, void *object); -gras_error_t gras_dynar_push (gras_dynar_t *dynar, const void *src); -void gras_dynar_pop (gras_dynar_t *dynar, void *dst); -gras_error_t gras_dynar_unshift (gras_dynar_t *dynar, const void *src); -void gras_dynar_shift (gras_dynar_t *dynar, void *dst); -void gras_dynar_map(const gras_dynar_t *dynar, void_f_pvoid_t *operator); +void gras_dynar_insert_at(gras_dynar_t *dynar, + int idx, const void *src); +void gras_dynar_remove_at(gras_dynar_t *dynar, + int idx, void *object); +void gras_dynar_push (gras_dynar_t *dynar, const void *src); +void gras_dynar_pop (gras_dynar_t *dynar, void *dst); +void gras_dynar_unshift (gras_dynar_t *dynar, const void *src); +void gras_dynar_shift (gras_dynar_t *dynar, void *dst); +void gras_dynar_map (const gras_dynar_t *dynar, void_f_pvoid_t *operator); /* cursor functions */ -void gras_dynar_cursor_first (const gras_dynar_t *dynar, int *cursor); -void gras_dynar_cursor_step (const gras_dynar_t *dynar, - int *cursor); -int gras_dynar_cursor_get (const gras_dynar_t *dynar, - int *cursor, void *whereto); +void gras_dynar_cursor_first (const gras_dynar_t *dynar, int *cursor); +void gras_dynar_cursor_step (const gras_dynar_t *dynar, + int *cursor); +int gras_dynar_cursor_get (const gras_dynar_t *dynar, + int *cursor, void *whereto); /** * gras_dynar_foreach: diff --git a/include/xbt/error.h b/include/xbt/error.h index 46ada38cbf..4c283f7b79 100644 --- a/include/xbt/error.h +++ b/include/xbt/error.h @@ -45,7 +45,7 @@ BEGIN_DECL typedef enum { no_error=0, /* succes */ - malloc_error, /* Well known error */ +// malloc_error, /* Well known error */ mismatch_error, /* The provided ID does not match */ system_error, /* a syscall did fail */ network_error, /* error while sending/receiving data */ @@ -142,7 +142,7 @@ typedef enum { __FILE__,__LINE__,__FUNCTION__,a1,a2,a3,a4,a5,a6); \ _GRAS_ERR_POST(code) -#define RAISE_MALLOC RAISE0(malloc_error,"Malloc error") +//#define RAISE_MALLOC RAISE0(malloc_error,"Malloc error") #define RAISE_IMPOSSIBLE RAISE0(unknown_error,"The Impossible did happen") #define RAISE_UNIMPLEMENTED RAISE1(unknown_error,"Function %s unimplemented",__FUNCTION__) @@ -165,6 +165,10 @@ typedef enum { #define gras_assert5(cond,msg,a,b,c,d,e) if (!(cond)) { CRITICAL5(msg,a,b,c,d,e); gras_abort(); } #define gras_assert6(cond,msg,a,b,c,d,e,f) if (!(cond)) { CRITICAL6(msg,a,b,c,d,e,f); gras_abort(); } #endif + +#define DIE_IMPOSSIBLE gras_assert0(0,"The Impossible did happen (yet again)") +#define gras_assert_error(a) gras_assert1(errcode == (a), "Error %s unexpected",gras_error_name(errcode)) + END_DECL #endif /* GRAS_ERROR_H */ diff --git a/include/xbt/log.h b/include/xbt/log.h index 81aa6b215e..c36e08481c 100644 --- a/include/xbt/log.h +++ b/include/xbt/log.h @@ -160,7 +160,7 @@ typedef enum { /* Functions you may call */ -extern gras_error_t gras_log_control_set(const char* cs); +extern void gras_log_control_set(const char* cs); /* Forward declarations */ typedef struct gras_log_appender_s gras_log_appender_t; diff --git a/include/xbt/set.h b/include/xbt/set.h index efe493b7ab..8fb2e2c84a 100644 --- a/include/xbt/set.h +++ b/include/xbt/set.h @@ -26,13 +26,13 @@ typedef struct gras_set_elm_ { /*####[ Functions ]##########################################################*/ -gras_error_t gras_set_new (gras_set_t **dst); -void gras_set_free(gras_set_t **set); +void gras_set_new (gras_set_t **dst); +void gras_set_free(gras_set_t **set); -gras_error_t gras_set_add (gras_set_t *set, - gras_set_elm_t *elm, - void_f_pvoid_t *free_func); +void gras_set_add (gras_set_t *set, + gras_set_elm_t *elm, + void_f_pvoid_t *free_func); /*----[ gras_set_retrieve ]-------------------------------------------------*/ /* Search the given #key#. data=NULL when not found. */ diff --git a/include/xbt/sysdep.h b/include/xbt/sysdep.h index e012812d8e..852c4665f7 100644 --- a/include/xbt/sysdep.h +++ b/include/xbt/sysdep.h @@ -23,6 +23,7 @@ extern "C" #endif +char* gras_strdup (const char *str); void* gras_malloc (long int bytes); void* gras_malloc0 (long int bytes); void* gras_realloc (void *memory, long int bytes); diff --git a/src/gras/DataDesc/cbps.c b/src/gras/DataDesc/cbps.c index 623902a27c..cfbb4af274 100644 --- a/src/gras/DataDesc/cbps.c +++ b/src/gras/DataDesc/cbps.c @@ -31,28 +31,24 @@ static void free_string(void *d){ gras_free(*(void**)d); } -gras_error_t -gras_cbps_new(gras_cbps_t **dst) { +gras_cbps_t * gras_cbps_new(void) { gras_error_t errcode; gras_cbps_t *res; - if (!(res=gras_new(gras_cbps_t,1))) - RAISE_MALLOC; - - TRY(gras_dynar_new(&(res->lints), sizeof(int), NULL)); + res=gras_new(gras_cbps_t,1); - TRY(gras_dict_new(&(res->space))); + gras_dynar_new(&(res->lints), sizeof(int), NULL); + gras_dict_new(&(res->space)); /* no leak, the content is freed manually on block_end */ - TRY(gras_dynar_new(&(res->frames), sizeof(gras_dynar_t*), NULL)); - TRY(gras_dynar_new(&(res->globals), sizeof(char*), NULL)); + gras_dynar_new(&(res->frames), sizeof(gras_dynar_t*), NULL); + gras_dynar_new(&(res->globals), sizeof(char*), NULL); gras_cbps_block_begin(res); - *dst = res; - return no_error; + + return res; } -void -gras_cbps_free(gras_cbps_t **state) { +void gras_cbps_free(gras_cbps_t **state) { gras_dynar_free( (*state)->lints ); @@ -74,9 +70,9 @@ gras_cbps_free(gras_cbps_t **state) { */ gras_error_t gras_cbps_v_push(gras_cbps_t *ps, - const char *name, - void *data, - gras_datadesc_type_t *ddt) { + const char *name, + void *data, + gras_datadesc_type_t *ddt) { gras_dynar_t *varstack,*frame; gras_cbps_elm_t *p_var; @@ -312,7 +308,7 @@ gras_cbps_i_push(gras_cbps_t *ps, int val) { gras_error_t errcode; DEBUG1("push %d as a size",val); - TRYFAIL(gras_dynar_push(ps->lints,&val)); + gras_dynar_push(ps->lints,&val); } /** * gras_cbps_i_pop: diff --git a/src/gras/DataDesc/datadesc.c b/src/gras/DataDesc/datadesc.c index c2e538822e..729e301572 100644 --- a/src/gras/DataDesc/datadesc.c +++ b/src/gras/DataDesc/datadesc.c @@ -41,97 +41,76 @@ gras_datadesc_init(void) { VERB0("Initializing DataDesc"); - TRYFAIL(gras_set_new(&gras_datadesc_set_local)); + gras_set_new(&gras_datadesc_set_local); - TRYFAIL(gras_datadesc_scalar("signed char", - gras_ddt_scalar_char, - e_gras_dd_scalar_encoding_sint, - &ddt)); - TRYFAIL(gras_datadesc_scalar("char", - gras_ddt_scalar_char, - e_gras_dd_scalar_encoding_sint, - &ddt)); - TRYFAIL(gras_datadesc_scalar("unsigned char", - gras_ddt_scalar_char, - e_gras_dd_scalar_encoding_uint, - &ddt)); + ddt = gras_datadesc_scalar("signed char", + gras_ddt_scalar_char, + e_gras_dd_scalar_encoding_sint); + ddt = gras_datadesc_scalar("char", + gras_ddt_scalar_char, + e_gras_dd_scalar_encoding_sint); + ddt = gras_datadesc_scalar("unsigned char", + gras_ddt_scalar_char, + e_gras_dd_scalar_encoding_uint); - TRYFAIL(gras_datadesc_scalar("signed short int", - gras_ddt_scalar_short, - e_gras_dd_scalar_encoding_sint, - &ddt)); - TRYFAIL(gras_datadesc_scalar("short int", - gras_ddt_scalar_short, - e_gras_dd_scalar_encoding_sint, - &ddt)); - TRYFAIL(gras_datadesc_scalar("unsigned short int", - gras_ddt_scalar_short, - e_gras_dd_scalar_encoding_uint, - &ddt)); + ddt = gras_datadesc_scalar("signed short int", + gras_ddt_scalar_short, + e_gras_dd_scalar_encoding_sint); + ddt = gras_datadesc_scalar("short int", + gras_ddt_scalar_short, + e_gras_dd_scalar_encoding_sint); + ddt = gras_datadesc_scalar("unsigned short int", + gras_ddt_scalar_short, + e_gras_dd_scalar_encoding_uint); - TRYFAIL(gras_datadesc_scalar("signed int", - gras_ddt_scalar_int, - e_gras_dd_scalar_encoding_sint, - &ddt)); - TRYFAIL(gras_datadesc_scalar("int", - gras_ddt_scalar_int, - e_gras_dd_scalar_encoding_sint, - &ddt)); - TRYFAIL(gras_datadesc_scalar("unsigned int", - gras_ddt_scalar_int, - e_gras_dd_scalar_encoding_uint, - &ddt)); + ddt = gras_datadesc_scalar("signed int", + gras_ddt_scalar_int, + e_gras_dd_scalar_encoding_sint); + ddt = gras_datadesc_scalar("int", + gras_ddt_scalar_int, + e_gras_dd_scalar_encoding_sint); + ddt = gras_datadesc_scalar("unsigned int", + gras_ddt_scalar_int, + e_gras_dd_scalar_encoding_uint); - TRYFAIL(gras_datadesc_scalar("signed long int", - gras_ddt_scalar_long, - e_gras_dd_scalar_encoding_sint, - &ddt)); - TRYFAIL(gras_datadesc_scalar("long int", - gras_ddt_scalar_long, - e_gras_dd_scalar_encoding_sint, - &ddt)); - TRYFAIL(gras_datadesc_scalar("unsigned long int", - gras_ddt_scalar_long, - e_gras_dd_scalar_encoding_uint, - &ddt)); + ddt = gras_datadesc_scalar("signed long int", + gras_ddt_scalar_long, + e_gras_dd_scalar_encoding_sint); + ddt = gras_datadesc_scalar("long int", + gras_ddt_scalar_long, + e_gras_dd_scalar_encoding_sint); + ddt = gras_datadesc_scalar("unsigned long int", + gras_ddt_scalar_long, + e_gras_dd_scalar_encoding_uint); - TRYFAIL(gras_datadesc_scalar("signed long long int", - gras_ddt_scalar_long_long, - e_gras_dd_scalar_encoding_sint, - &ddt)); - TRYFAIL(gras_datadesc_scalar("long long int", - gras_ddt_scalar_long_long, - e_gras_dd_scalar_encoding_sint, - &ddt)); - TRYFAIL(gras_datadesc_scalar("unsigned long long int", - gras_ddt_scalar_long_long, - e_gras_dd_scalar_encoding_uint, - &ddt)); + ddt = gras_datadesc_scalar("signed long long int", + gras_ddt_scalar_long_long, + e_gras_dd_scalar_encoding_sint); + ddt = gras_datadesc_scalar("long long int", + gras_ddt_scalar_long_long, + e_gras_dd_scalar_encoding_sint); + ddt = gras_datadesc_scalar("unsigned long long int", + gras_ddt_scalar_long_long, + e_gras_dd_scalar_encoding_uint); - TRYFAIL(gras_datadesc_scalar("data pointer", - gras_ddt_scalar_pdata, - e_gras_dd_scalar_encoding_uint, - &ddt)); - TRYFAIL(gras_datadesc_scalar("function pointer", - gras_ddt_scalar_pfunc, - e_gras_dd_scalar_encoding_uint, - &ddt)); + ddt = gras_datadesc_scalar("data pointer", + gras_ddt_scalar_pdata, + e_gras_dd_scalar_encoding_uint); + ddt = gras_datadesc_scalar("function pointer", + gras_ddt_scalar_pfunc, + e_gras_dd_scalar_encoding_uint); - TRYFAIL(gras_datadesc_scalar("float", - gras_ddt_scalar_float, - e_gras_dd_scalar_encoding_float, - &ddt)); - TRYFAIL(gras_datadesc_scalar("double", - gras_ddt_scalar_double, - e_gras_dd_scalar_encoding_float, - &ddt)); - - TRYFAIL(gras_datadesc_array_dyn("char[]", - gras_datadesc_by_name("char"), - _strlen_cb,&ddt)); - TRYFAIL(gras_datadesc_ref("string", - gras_datadesc_by_name("char[]"), - &ddt)); + ddt = gras_datadesc_scalar("float", + gras_ddt_scalar_float, + e_gras_dd_scalar_encoding_float); + ddt = gras_datadesc_scalar("double", + gras_ddt_scalar_double, + e_gras_dd_scalar_encoding_float); + + ddt = gras_datadesc_array_dyn("char[]", + gras_datadesc_by_name("char"), + _strlen_cb); + ddt = gras_datadesc_ref("string",ddt); } diff --git a/src/gras/DataDesc/datadesc_private.h b/src/gras/DataDesc/datadesc_private.h index b0581760bc..2d21aadbe8 100644 --- a/src/gras/DataDesc/datadesc_private.h +++ b/src/gras/DataDesc/datadesc_private.h @@ -232,19 +232,16 @@ struct s_gras_datadesc_type { ***************************/ void gras_datadesc_free(gras_datadesc_type_t *type); -gras_error_t -gras_datadesc_scalar(const char *name, - gras_ddt_scalar_type_t type, - enum e_gras_dd_scalar_encoding encoding, - gras_datadesc_type_t **dst); +gras_datadesc_type_t * + gras_datadesc_scalar(const char *name, + gras_ddt_scalar_type_t type, + enum e_gras_dd_scalar_encoding encoding); /**************************************************** * Callback persistant state constructor/destructor * ****************************************************/ -gras_error_t -gras_cbps_new(gras_cbps_t **dst); -void -gras_cbps_free(gras_cbps_t **state); +gras_cbps_t *gras_cbps_new(void); +void gras_cbps_free(gras_cbps_t **state); /*************** * Convertions * diff --git a/src/gras/DataDesc/ddt_create.c b/src/gras/DataDesc/ddt_create.c index 7bc27bcdfc..757b6cf21d 100644 --- a/src/gras/DataDesc/ddt_create.c +++ b/src/gras/DataDesc/ddt_create.c @@ -25,7 +25,7 @@ void gras_ddt_freev(void *ddt) { } } -static gras_error_t +static void gras_ddt_new(const char *name, gras_datadesc_type_t **dst) { gras_error_t errcode; @@ -33,17 +33,14 @@ gras_ddt_new(const char *name, GRAS_IN1("(%s)",name); res=gras_new0(gras_datadesc_type_t,1); - if (!res) - RAISE_MALLOC; res->name = (char*)strdup(name); res->name_len = strlen(name); *dst=res; - TRY(gras_set_add(gras_datadesc_set_local, - (gras_set_elm_t*)res,&gras_ddt_freev)); + gras_set_add(gras_datadesc_set_local, + (gras_set_elm_t*)res,&gras_ddt_freev); GRAS_OUT; - return no_error; } /** @@ -83,13 +80,11 @@ gras_error_t gras_datadesc_by_id(long int code, * * Create a new scalar and give a pointer to it */ -gras_error_t -gras_datadesc_scalar(const char *name, - gras_ddt_scalar_type_t type, - enum e_gras_dd_scalar_encoding encoding, - gras_datadesc_type_t **dst) { +gras_datadesc_type_t * + gras_datadesc_scalar(const char *name, + gras_ddt_scalar_type_t type, + enum e_gras_dd_scalar_encoding encoding) { - gras_error_t errcode; gras_datadesc_type_t *res; long int arch; @@ -103,11 +98,9 @@ gras_datadesc_scalar(const char *name, gras_assert1(res->category.scalar_data.type == type, "Redefinition of type %s does not match", name); VERB1("Discarding redefinition of %s",name); - *dst=res; - return no_error; + return res; } - TRY(gras_ddt_new(name,dst)); - res=*dst; + gras_ddt_new(name,&res); for (arch = 0; arch < gras_arch_count; arch ++) { long int sz; @@ -115,6 +108,7 @@ gras_datadesc_scalar(const char *name, res->size[arch] = gras_arches[arch].sizeofs[type]; res->alignment[arch] = gras_arches[arch].boundaries[type]; res->aligned_size[arch] = aligned(res->size[arch], res->alignment[arch]); +/* FIXME: kill the following after discution with Oli */ #if 0 sz = res->size[arch]; mask = sz; @@ -151,7 +145,8 @@ gras_datadesc_scalar(const char *name, res->category.scalar_data.encoding = encoding; res->category.scalar_data.type = type; GRAS_OUT; - return no_error; + + return res; } @@ -176,9 +171,8 @@ void gras_dd_cat_field_free(void *f) { * * Create a new struct and give a pointer to it */ -gras_error_t -gras_datadesc_struct(const char *name, - gras_datadesc_type_t **dst) { +gras_datadesc_type_t * + gras_datadesc_struct(const char *name) { gras_error_t errcode; gras_datadesc_type_t *res; @@ -191,11 +185,9 @@ gras_datadesc_struct(const char *name, gras_assert1(res->category_code == e_gras_datadesc_type_cat_struct, "Redefinition of type %s does not match", name); VERB1("Discarding redefinition of %s",name); - *dst=res; - return no_error; + return res; } - TRY(gras_ddt_new(name,dst)); - res=*dst; + gras_ddt_new(name,&res); for (arch=0; archsize[arch] = 0; @@ -203,12 +195,12 @@ gras_datadesc_struct(const char *name, res->aligned_size[arch] = 0; } res->category_code = e_gras_datadesc_type_cat_struct; - TRY(gras_dynar_new(&(res->category.struct_data.fields), - sizeof(gras_dd_cat_field_t*), - &gras_dd_cat_field_free)); + gras_dynar_new(&(res->category.struct_data.fields), + sizeof(gras_dd_cat_field_t*), + &gras_dd_cat_field_free); GRAS_OUT; - return no_error; + return res; } /** @@ -216,7 +208,7 @@ gras_datadesc_struct(const char *name, * * Append a field to the struct */ -gras_error_t +void gras_datadesc_struct_append(gras_datadesc_type_t *struct_type, const char *name, gras_datadesc_type_t *field_type) { @@ -229,7 +221,7 @@ gras_datadesc_struct_append(gras_datadesc_type_t *struct_type, if (struct_type->category.struct_data.closed) { VERB1("Ignoring request to add field to struct %s (closed. Redefinition?)", struct_type->name); - return no_error; + return; } gras_assert1(field_type->size != 0, @@ -237,9 +229,6 @@ gras_datadesc_struct_append(gras_datadesc_type_t *struct_type, struct_type->name); field=gras_new(gras_dd_cat_field_t,1); - if (!field) - RAISE_MALLOC; - field->name = (char*)strdup(name); DEBUG0("----------------"); @@ -263,7 +252,7 @@ gras_datadesc_struct_append(gras_datadesc_type_t *struct_type, field->pre = NULL; field->post = NULL; - TRY(gras_dynar_push(struct_type->category.struct_data.fields, &field)); + gras_dynar_push(struct_type->category.struct_data.fields, &field); DEBUG3("Push a %s into %s at offset %ld.", field_type->name, struct_type->name,field->offset[GRAS_THISARCH]); @@ -276,8 +265,8 @@ gras_datadesc_struct_append(gras_datadesc_type_t *struct_type, struct_type->alignment[GRAS_THISARCH], struct_type->aligned_size[GRAS_THISARCH]); GRAS_OUT; - return no_error; } + void gras_datadesc_struct_close(gras_datadesc_type_t *struct_type) { GRAS_IN; @@ -289,10 +278,9 @@ gras_datadesc_struct_close(gras_datadesc_type_t *struct_type) { * * Create a new union and give a pointer to it */ -gras_error_t +gras_datadesc_type_t * gras_datadesc_union(const char *name, - gras_datadesc_type_cb_int_t selector, - gras_datadesc_type_t **dst) { + gras_datadesc_type_cb_int_t selector) { gras_error_t errcode; gras_datadesc_type_t *res; @@ -310,12 +298,10 @@ gras_datadesc_union(const char *name, gras_assert1(res->category.union_data.selector == selector, "Redefinition of type %s does not match", name); VERB1("Discarding redefinition of %s",name); - *dst=res; - return no_error; + return res; } - TRY(gras_ddt_new(name,dst)); - res=*dst; + gras_ddt_new(name,&res); for (arch=0; archsize[arch] = 0; @@ -324,12 +310,12 @@ gras_datadesc_union(const char *name, } res->category_code = e_gras_datadesc_type_cat_union; - TRY(gras_dynar_new(&(res->category.union_data.fields), - sizeof(gras_dd_cat_field_t*), - &gras_dd_cat_field_free)); + gras_dynar_new(&(res->category.union_data.fields), + sizeof(gras_dd_cat_field_t*), + &gras_dd_cat_field_free); res->category.union_data.selector = selector; - return no_error; + return res; } /** @@ -337,12 +323,11 @@ gras_datadesc_union(const char *name, * * Append a field to the union */ -gras_error_t +void gras_datadesc_union_append(gras_datadesc_type_t *union_type, const char *name, gras_datadesc_type_t *field_type) { - gras_error_t errcode; gras_dd_cat_field_t *field; int arch; @@ -354,18 +339,16 @@ gras_datadesc_union_append(gras_datadesc_type_t *union_type, if (union_type->category.union_data.closed) { VERB1("Ignoring request to add field to union %s (closed)", union_type->name); - return no_error; + return; } field=gras_new0(gras_dd_cat_field_t,1); - if (!field) - RAISE_MALLOC; field->name = (char*)strdup(name); field->type = field_type; /* All offset are left to 0 in an union */ - TRY(gras_dynar_push(union_type->category.union_data.fields, &field)); + gras_dynar_push(union_type->category.union_data.fields, &field); for (arch=0; archsize[arch] = max(union_type->size[arch], @@ -375,7 +358,6 @@ gras_datadesc_union_append(gras_datadesc_type_t *union_type, union_type->aligned_size[arch] = aligned(union_type->size[arch], union_type->alignment[arch]); } - return no_error; } void @@ -387,10 +369,9 @@ gras_datadesc_union_close(gras_datadesc_type_t *union_type) { * * Create a new ref to a fixed type and give a pointer to it */ -gras_error_t -gras_datadesc_ref(const char *name, - gras_datadesc_type_t *referenced_type, - gras_datadesc_type_t **dst) { +gras_datadesc_type_t * + gras_datadesc_ref(const char *name, + gras_datadesc_type_t *referenced_type) { gras_error_t errcode; gras_datadesc_type_t *res; @@ -407,12 +388,10 @@ gras_datadesc_ref(const char *name, gras_assert1(res->category.ref_data.selector == NULL, "Redefinition of %s does not match",name); VERB1("Discarding redefinition of %s",name); - *dst=res; - return no_error; + return res; } - TRY(gras_ddt_new(name,dst)); - res=*dst; + gras_ddt_new(name,&res); gras_assert0(pointer_type, "Cannot get the description of data pointer"); @@ -426,19 +405,17 @@ gras_datadesc_ref(const char *name, res->category.ref_data.type = referenced_type; res->category.ref_data.selector = NULL; - return no_error; + return res; } /** * gras_datadesc_ref_generic: * * Create a new ref to a type given at use time, and give a pointer to it */ -gras_error_t -gras_datadesc_ref_generic(const char *name, - gras_datadesc_selector_t selector, - gras_datadesc_type_t **dst) { +gras_datadesc_type_t * + gras_datadesc_ref_generic(const char *name, + gras_datadesc_selector_t selector) { - gras_error_t errcode; gras_datadesc_type_t *res; gras_datadesc_type_t *pointer_type = gras_datadesc_by_name("data pointer"); int arch; @@ -453,11 +430,9 @@ gras_datadesc_ref_generic(const char *name, gras_assert1(res->category.ref_data.selector == selector, "Redefinition of type %s does not match", name); VERB1("Discarding redefinition of %s",name); - *dst=res; - return no_error; + return res; } - TRY(gras_ddt_new(name,dst)); - res=*dst; + gras_ddt_new(name,&res); gras_assert0(pointer_type, "Cannot get the description of data pointer"); @@ -472,7 +447,7 @@ gras_datadesc_ref_generic(const char *name, res->category.ref_data.type = NULL; res->category.ref_data.selector = selector; - return no_error; + return res; } /** @@ -480,13 +455,11 @@ gras_datadesc_ref_generic(const char *name, * * Create a new array and give a pointer to it */ -gras_error_t -gras_datadesc_array_fixed(const char *name, - gras_datadesc_type_t *element_type, - long int fixed_size, - gras_datadesc_type_t **dst) { +gras_datadesc_type_t * + gras_datadesc_array_fixed(const char *name, + gras_datadesc_type_t *element_type, + long int fixed_size) { - gras_error_t errcode; gras_datadesc_type_t *res; int arch; @@ -503,11 +476,9 @@ gras_datadesc_array_fixed(const char *name, "Redefinition of type %s does not match", name); VERB1("Discarding redefinition of %s",name); - *dst=res; - return no_error; + return res; } - TRY(gras_ddt_new(name,dst)); - res=*dst; + gras_ddt_new(name,&res); gras_assert1(fixed_size > 0, "'%s' is a array of null fixed size",name); for (arch=0; archcategory.array_data.fixed_size = fixed_size; res->category.array_data.dynamic_size = NULL; - return no_error; + return res; } /** * gras_datadesc_array_dyn: * * Create a new array and give a pointer to it */ -gras_error_t -gras_datadesc_array_dyn(const char *name, - gras_datadesc_type_t *element_type, - gras_datadesc_type_cb_int_t dynamic_size, - gras_datadesc_type_t **dst) { +gras_datadesc_type_t * + gras_datadesc_array_dyn(const char *name, + gras_datadesc_type_t *element_type, + gras_datadesc_type_cb_int_t dynamic_size) { - gras_error_t errcode; gras_datadesc_type_t *res; int arch; @@ -556,12 +525,10 @@ gras_datadesc_array_dyn(const char *name, "Redefinition of type %s does not match", name); VERB1("Discarding redefinition of %s",name); - *dst=res; - return no_error; + return res; } - TRY(gras_ddt_new(name,dst)); - res=*dst; + gras_ddt_new(name,&res); for (arch=0; archsize[arch] = 0; /* make sure it indicates "dynamic" */ @@ -575,7 +542,7 @@ gras_datadesc_array_dyn(const char *name, res->category.array_data.fixed_size = 0; res->category.array_data.dynamic_size = dynamic_size; - return no_error; + return res; } /** @@ -601,23 +568,23 @@ gras_datadesc_array_dyn(const char *name, * list when the first field gets transfered. * */ -gras_error_t -gras_datadesc_ref_pop_arr(gras_datadesc_type_t *element_type, - gras_datadesc_type_t **dst) { - gras_error_t errcode; +gras_datadesc_type_t * + gras_datadesc_ref_pop_arr(gras_datadesc_type_t *element_type) { + + gras_datadesc_type_t *res; char *name=(char*)gras_malloc(strlen(element_type->name) + 4); sprintf(name,"%s[]",element_type->name); - TRY(gras_datadesc_array_dyn(name,element_type, - gras_datadesc_cb_pop, dst)); + res = gras_datadesc_array_dyn(name,element_type, + gras_datadesc_cb_pop); sprintf(name,"%s[]*",element_type->name); - TRY(gras_datadesc_ref(name,*dst,dst)); + res = gras_datadesc_ref(name,res); gras_free(name); - return no_error; + return res; } gras_error_t gras_datadesc_import_nws(const char *name, diff --git a/src/gras/DataDesc/ddt_exchange.c b/src/gras/DataDesc/ddt_exchange.c index 2800d4a138..05df6ce52b 100644 --- a/src/gras/DataDesc/ddt_exchange.c +++ b/src/gras/DataDesc/ddt_exchange.c @@ -83,8 +83,7 @@ gras_dd_recv_int(gras_socket_t *sock, int r_arch, int *i) { TRY(gras_dd_convert_elm(int_type,1,r_arch, i,i)); } else { void *ptr = gras_malloc(int_type->size[r_arch]); - if (!ptr) - RAISE_MALLOC; + TRY(gras_trp_chunk_recv(sock, (char*)ptr, int_type->size[r_arch])); if (r_arch != GRAS_THISARCH) TRY(gras_dd_convert_elm(int_type,1,r_arch, ptr,i)); @@ -122,8 +121,7 @@ gras_dd_alloc_ref(gras_dict_t *refs, char *l_data = NULL; gras_assert1(size>0,"Cannot allocate %ld bytes!", size); - if (! (l_data = gras_malloc((size_t)size)) ) - RAISE_MALLOC; + l_data = gras_malloc((size_t)size); *l_ref = l_data; DEBUG2("l_data=%p, &l_data=%p",(void*)l_data,(void*)&l_data); @@ -134,8 +132,6 @@ gras_dd_alloc_ref(gras_dict_t *refs, if (r_ref && !gras_dd_is_r_null( r_ref, r_len)) { gras_error_t errcode; void *ptr = gras_malloc(sizeof(void *)); - if (!ptr) - RAISE_MALLOC; memcpy(ptr,l_ref, sizeof(void *)); @@ -509,8 +505,8 @@ gras_error_t gras_datadesc_send(gras_socket_t *sock, gras_cbps_t *state = NULL; gras_dict_t *refs; /* all references already sent */ - TRY(gras_dict_new(&refs)); - TRY(gras_cbps_new(&state)); + gras_dict_new(&refs); + state = gras_cbps_new(); errcode = gras_datadesc_send_rec(sock,state,refs,type,(char*)src); @@ -558,8 +554,7 @@ gras_datadesc_recv_rec(gras_socket_t *sock, TRY(gras_dd_convert_elm(type,1,r_arch, l_data,l_data)); } else { void *ptr = gras_malloc(type->size[r_arch]); - if (!ptr) - RAISE_MALLOC; + TRY(gras_trp_chunk_recv(sock, (char*)ptr, type->size[r_arch])); if (r_arch != GRAS_THISARCH) TRY(gras_dd_convert_elm(type,1,r_arch, ptr,l_data)); @@ -642,8 +637,8 @@ gras_datadesc_recv_rec(gras_socket_t *sock, gras_assert(pointer_type); } - if (! (r_ref = gras_malloc(pointer_type->size[r_arch])) ) - RAISE_MALLOC; + r_ref = gras_malloc(pointer_type->size[r_arch]); + TRY(gras_trp_chunk_recv(sock, (char*)r_ref, pointer_type->size[r_arch])); @@ -738,8 +733,7 @@ gras_datadesc_recv_rec(gras_socket_t *sock, TRY(gras_dd_convert_elm(sub_type,count,r_arch, l_data,l_data)); } else { ptr = gras_malloc(sub_type->aligned_size[r_arch] * count); - if (!ptr) - RAISE_MALLOC; + TRY(gras_trp_chunk_recv(sock, (char*)ptr, sub_type->size[r_arch] * count)); if (r_arch != GRAS_THISARCH) @@ -788,8 +782,8 @@ gras_datadesc_recv(gras_socket_t *sock, gras_cbps_t *state = NULL; /* callback persistent state */ gras_dict_t *refs; /* all references already sent */ - TRY(gras_dict_new(&refs)); - TRY(gras_cbps_new(&state)); + gras_dict_new(&refs); + state = gras_cbps_new(); errcode = gras_datadesc_recv_rec(sock, state, refs, type, r_arch, NULL, 0, diff --git a/src/gras/DataDesc/ddt_parse.c b/src/gras/DataDesc/ddt_parse.c index b2e9f8a8dc..7599c9c1f5 100644 --- a/src/gras/DataDesc/ddt_parse.c +++ b/src/gras/DataDesc/ddt_parse.c @@ -104,8 +104,7 @@ static void print_type_modifier(type_modifier_t tm) { GRAS_OUT; } -static gras_error_t change_to_fixed_array(gras_dynar_t *dynar, long int size) { - gras_error_t errcode; +static void change_to_fixed_array(gras_dynar_t *dynar, long int size) { identifier_t former,array; memset(&array,0,sizeof(array)); @@ -117,16 +116,13 @@ static gras_error_t change_to_fixed_array(gras_dynar_t *dynar, long int size) { sprintf(array.type_name,"%s[%ld]",former.type_name,size); gras_free(former.type_name); - TRY(gras_datadesc_array_fixed(array.type_name, former.type, size, &array.type)); /* redeclaration are ignored */ - + array.type = gras_datadesc_array_fixed(array.type_name, former.type, size); /* redeclaration are ignored */ array.name = former.name; - TRY(gras_dynar_push(dynar,&array)); + gras_dynar_push(dynar,&array); GRAS_OUT; - return no_error; } -static gras_error_t change_to_ref(gras_dynar_t *dynar) { - gras_error_t errcode; +static void change_to_ref(gras_dynar_t *dynar) { identifier_t former,ref; memset(&ref,0,sizeof(ref)); @@ -137,31 +133,27 @@ static gras_error_t change_to_ref(gras_dynar_t *dynar) { sprintf(ref.type_name,"%s*",former.type_name); gras_free(former.type_name); - TRY(gras_datadesc_ref(ref.type_name, former.type, &ref.type)); /* redeclaration are ignored */ - + ref.type = gras_datadesc_ref(ref.type_name, former.type); /* redeclaration are ignored */ ref.name = former.name; - TRY(gras_dynar_push(dynar,&ref)); + gras_dynar_push(dynar,&ref); GRAS_OUT; - return no_error; } -static gras_error_t change_to_ref_pop_array(gras_dynar_t *dynar) { - gras_error_t errcode; +static void change_to_ref_pop_array(gras_dynar_t *dynar) { identifier_t former,ref; memset(&ref,0,sizeof(ref)); GRAS_IN; gras_dynar_pop(dynar,&former); - TRY(gras_datadesc_ref_pop_arr(former.type,&ref.type)); /* redeclaration are ignored */ + ref.type = gras_datadesc_ref_pop_arr(former.type); /* redeclaration are ignored */ ref.type_name = (char*)strdup(ref.type->name); ref.name = former.name; gras_free(former.type_name); - TRY(gras_dynar_push(dynar,&ref)); + gras_dynar_push(dynar,&ref); GRAS_OUT; - return no_error; } static gras_error_t parse_statement(char *definition, @@ -237,7 +229,7 @@ static gras_error_t parse_statement(char *definition, } else if (identifier.tm.is_struct) { sprintf(buffname,"struct %s",identifier.type_name); - TRY(gras_datadesc_struct(buffname,&identifier.type)); /* Get created when does not exist */ + identifier.type = gras_datadesc_struct(buffname); /* Get created when does not exist */ } else if (identifier.tm.is_unsigned) { if (!strcmp(identifier.type_name,"int")) { @@ -321,7 +313,7 @@ static gras_error_t parse_statement(char *definition, PARSE_ERROR1("Unparsable size of array (found '%c', expected number)",*end); /* replace the previously pushed type to an array of it */ - TRY(change_to_fixed_array(identifiers,size)); + change_to_fixed_array(identifiers,size); /* eat the closing bracket */ gras_ddt_parse_tok_num = gras_ddt_parse_lex_n_dump(); @@ -379,7 +371,7 @@ static gras_error_t parse_statement(char *definition, identifier.tm.is_ref--; if (!strcmp(keyval,"1")) { - TRY(change_to_ref(identifiers)); + change_to_ref(identifiers); gras_free(keyval); continue; } else { @@ -389,14 +381,14 @@ static gras_error_t parse_statement(char *definition, if (! isdigit(*p) ) fixed = 0; if (fixed) { - TRY(change_to_fixed_array(identifiers,atoi(keyval))); - TRY(change_to_ref(identifiers)); + change_to_fixed_array(identifiers,atoi(keyval)); + change_to_ref(identifiers); gras_free(keyval); continue; } else { - TRY(change_to_ref_pop_array(identifiers)); - TRY(gras_dynar_push(fields_to_push,&keyval)); + change_to_ref_pop_array(identifiers); + gras_dynar_push(fields_to_push,&keyval); continue; } } @@ -426,7 +418,7 @@ static gras_error_t parse_statement(char *definition, identifier.name=(char*)strdup(gras_ddt_parse_text); DEBUG1("Found the identifier \"%s\"",identifier.name); - TRY(gras_dynar_push(identifiers, &identifier)); + gras_dynar_push(identifiers, &identifier); DEBUG1("Dynar_len=%lu",gras_dynar_length(identifiers)); expect_id_separator = 1; continue; @@ -455,22 +447,18 @@ static gras_datadesc_type_t *parse_struct(char *definition) { gras_datadesc_type_t *struct_type; GRAS_IN; - errcode=gras_dynar_new(&identifiers,sizeof(identifier_t),NULL); - errcode=gras_dynar_new(&fields_to_push,sizeof(char*),NULL); - if (errcode != no_error) { - GRAS_OUT; - return NULL; - } + gras_dynar_new(&identifiers,sizeof(identifier_t),NULL); + gras_dynar_new(&fields_to_push,sizeof(char*),NULL); /* Create the struct descriptor */ if (gras_ddt_parse_tok_num == GRAS_DDT_PARSE_TOKEN_WORD) { - TRYFAIL(gras_datadesc_struct(gras_ddt_parse_text,&struct_type)); + struct_type = gras_datadesc_struct(gras_ddt_parse_text); VERB1("Parse the struct '%s'", gras_ddt_parse_text); gras_ddt_parse_tok_num = gras_ddt_parse_lex_n_dump(); } else { sprintf(buffname,"anonymous struct %d",anonymous_struct++); VERB1("Parse the anonymous struct nb %d", anonymous_struct); - TRYFAIL(gras_datadesc_struct(buffname,&struct_type)); + struct_type = gras_datadesc_struct(buffname); } if (gras_ddt_parse_tok_num != GRAS_DDT_PARSE_TOKEN_LA) @@ -490,7 +478,7 @@ static gras_datadesc_type_t *parse_struct(char *definition) { field.name,field.tm.is_ref); VERB2("Append field '%s' to %p",field.name, (void*)struct_type); - TRYFAIL(gras_datadesc_struct_append(struct_type, field.name, field.type)); + gras_datadesc_struct_append(struct_type, field.name, field.type); gras_free(field.name); gras_free(field.type_name); diff --git a/src/gras/Msg/msg.c b/src/gras/Msg/msg.c index df0548bb22..ce37d34a1e 100644 --- a/src/gras/Msg/msg.c +++ b/src/gras/Msg/msg.c @@ -33,7 +33,7 @@ void gras_msg_init(void) { VERB0("Initializing Msg"); - TRYFAIL(gras_set_new(&_gras_msgtype_set)); + gras_set_new(&_gras_msgtype_set); memcpy(GRAS_header,"GRAS", 4); GRAS_header[4]=GRAS_PROTOCOL_VERSION; @@ -79,9 +79,9 @@ static char *make_namev(const char *name, short int ver) { namev = (char*)gras_malloc(strlen(name)+2+3+1); - if (namev) { + if (namev) sprintf(namev,"%s_v%d",name,ver); - } + return namev; } @@ -92,10 +92,9 @@ static char *make_namev(const char *name, short int ver) { * * Registers a message to the GRAS mecanism. */ -gras_error_t -gras_msgtype_declare(const char *name, - gras_datadesc_type_t *payload) { - return gras_msgtype_declare_v(name, 0, payload); +void gras_msgtype_declare(const char *name, + gras_datadesc_type_t *payload) { + gras_msgtype_declare_v(name, 0, payload); } /** @@ -110,7 +109,7 @@ gras_msgtype_declare(const char *name, * will be handled as an independent message type, so you can register * differents for each of them. */ -gras_error_t +void gras_msgtype_declare_v(const char *name, short int version, gras_datadesc_type_t *payload) { @@ -119,9 +118,6 @@ gras_msgtype_declare_v(const char *name, gras_msgtype_t *msgtype; char *namev=make_namev(name,version); - if (!namev) - RAISE_MALLOC; - errcode = gras_set_get_by_name(_gras_msgtype_set, namev,(gras_set_elm_t**)&msgtype); @@ -133,27 +129,21 @@ gras_msgtype_declare_v(const char *name, namev,gras_datadesc_get_name(payload), gras_datadesc_get_name(msgtype->ctn_type)); - return no_error; /* do really ignore it */ + return ; /* do really ignore it */ - } else if (errcode == mismatch_error) { - INFO3("Register version %d of message '%s' (payload: %s).", - version, name, gras_datadesc_get_name(payload)); - } else { - return errcode; /* Was expecting for mismatch_error */ } + gras_assert_error(mismatch_error); /* expect this error */ + INFO3("Register version %d of message '%s' (payload: %s).", + version, name, gras_datadesc_get_name(payload)); - if (! (msgtype = gras_new(gras_msgtype_t,1)) ) - RAISE_MALLOC; - + msgtype = gras_new(gras_msgtype_t,1); msgtype->name = (namev == name ? strdup(name) : namev); msgtype->name_len = strlen(namev); msgtype->version = version; msgtype->ctn_type = payload; - TRY(gras_set_add(_gras_msgtype_set, (gras_set_elm_t*)msgtype, - &gras_msgtype_free)); - - return no_error; + gras_set_add(_gras_msgtype_set, (gras_set_elm_t*)msgtype, + &gras_msgtype_free); } /** @@ -336,7 +326,7 @@ gras_msg_wait(double timeout, msg.type = msgt_got; msg.payload = payload; msg.payload_size = payload_size_got; - TRY(gras_dynar_push(pd->msg_queue,&msg)); + gras_dynar_push(pd->msg_queue,&msg); now=gras_os_time(); if (now - start + 0.001 < timeout) { @@ -426,10 +416,9 @@ gras_cbl_free(void *data){ } } -gras_error_t +void gras_cb_register(gras_msgtype_t *msgtype, gras_cb_t cb) { - gras_error_t errcode; gras_procdata_t *pd=gras_procdata_get(); gras_cblist_t *list=NULL; int cpt; @@ -447,18 +436,13 @@ gras_cb_register(gras_msgtype_t *msgtype, if (!list) { /* First cb? Create room */ list = gras_new(gras_cblist_t,1); - if (!list) - RAISE_MALLOC; - list->id = msgtype->code; - TRY(gras_dynar_new(&(list->cbs), sizeof(gras_cb_t), NULL)); - TRY(gras_dynar_push(pd->cbl_list,&list)); + gras_dynar_new(&(list->cbs), sizeof(gras_cb_t), NULL); + gras_dynar_push(pd->cbl_list,&list); } /* Insert the new one into the set */ - TRY(gras_dynar_insert_at(list->cbs,0,&cb)); - - return no_error; + gras_dynar_insert_at(list->cbs,0,&cb); } void diff --git a/src/gras/Transport/rl_transport.c b/src/gras/Transport/rl_transport.c index 0dce317b46..1e584a4364 100644 --- a/src/gras/Transport/rl_transport.c +++ b/src/gras/Transport/rl_transport.c @@ -107,7 +107,7 @@ gras_trp_select(double timeout, RAISE3(system_error,"invalid select: nb fds: %d, timeout: %d.%d", max_fds, (int)tout.tv_sec,(int) tout.tv_usec); case ENOMEM: - RAISE_MALLOC; + gras_assert0(0,"Malloc error during the select"); default: RAISE2(system_error,"Error during select: %s (%d)", strerror(errno),errno); diff --git a/src/gras/Transport/sg_transport.c b/src/gras/Transport/sg_transport.c index b79eafc645..af8fbe9976 100644 --- a/src/gras/Transport/sg_transport.c +++ b/src/gras/Transport/sg_transport.c @@ -70,7 +70,7 @@ gras_trp_select(double timeout, TRY(gras_trp_plugin_get_by_name("buf",&trp)); - TRY(gras_trp_socket_new(1,dst)); + gras_trp_socket_new(1,dst); (*dst)->plugin = trp; (*dst)->incoming = 1; @@ -80,9 +80,7 @@ gras_trp_select(double timeout, (*dst)->port = -1; - if (!(sockdata = gras_new(gras_trp_sg_sock_data_t,1))) - RAISE_MALLOC; - + sockdata = gras_new(gras_trp_sg_sock_data_t,1); sockdata->from_PID = MSG_process_self_PID(); sockdata->to_PID = r_pid; sockdata->to_host = MSG_process_get_host(MSG_process_from_PID(r_pid)); diff --git a/src/gras/Transport/transport.c b/src/gras/Transport/transport.c index d5d62b4d4c..f6014ee413 100644 --- a/src/gras/Transport/transport.c +++ b/src/gras/Transport/transport.c @@ -17,10 +17,7 @@ static void gras_trp_plugin_free(void *p); /* free one of the plugins */ static void gras_trp_socket_free(void *s); /* free one socket */ -gras_error_t -gras_trp_plugin_new(const char *name, gras_trp_setup_t setup); - -gras_error_t +static void gras_trp_plugin_new(const char *name, gras_trp_setup_t setup) { gras_error_t errcode; @@ -28,12 +25,7 @@ gras_trp_plugin_new(const char *name, gras_trp_setup_t setup) { DEBUG1("Create plugin %s",name); - if (!plug) - RAISE_MALLOC; - - plug->name=(char*)strdup(name); - if (!plug->name) - RAISE_MALLOC; + plug->name=gras_strdup(name); errcode = setup(plug); switch (errcode) { @@ -44,33 +36,30 @@ gras_trp_plugin_new(const char *name, gras_trp_setup_t setup) { break; case no_error: - TRY(gras_dict_set(_gras_trp_plugins, - name, plug, gras_trp_plugin_free)); + gras_dict_set(_gras_trp_plugins, + name, plug, gras_trp_plugin_free); break; default: - gras_free(plug); - return errcode; + DIE_IMPOSSIBLE; } - return no_error; + } -gras_error_t +void gras_trp_init(void){ - gras_error_t errcode; /* make room for all plugins */ - TRY(gras_dict_new(&_gras_trp_plugins)); + gras_dict_new(&_gras_trp_plugins); /* Add them */ - TRY(gras_trp_plugin_new("tcp", gras_trp_tcp_setup)); - TRY(gras_trp_plugin_new("file",gras_trp_file_setup)); - TRY(gras_trp_plugin_new("sg",gras_trp_sg_setup)); + gras_trp_plugin_new("tcp", gras_trp_tcp_setup); + gras_trp_plugin_new("file",gras_trp_file_setup); + gras_trp_plugin_new("sg",gras_trp_sg_setup); /* buf is composed, so it must come after the others */ - TRY(gras_trp_plugin_new("buf", gras_trp_buf_setup)); + gras_trp_plugin_new("buf", gras_trp_buf_setup); - return no_error; } void @@ -101,13 +90,11 @@ void gras_trp_plugin_free(void *p) { * * Malloc a new socket, and initialize it with defaults */ -gras_error_t gras_trp_socket_new(int incoming, - gras_socket_t **dst) { +void gras_trp_socket_new(int incoming, + gras_socket_t **dst) { - gras_socket_t *sock; + gras_socket_t *sock=gras_new(gras_socket_t,1); - if (! (sock=gras_new(gras_socket_t,1)) ) - RAISE_MALLOC; DEBUG1("Create a new socket (%p)", (void*)sock); sock->plugin = NULL; @@ -125,7 +112,7 @@ gras_error_t gras_trp_socket_new(int incoming, *dst = sock; - return gras_dynar_push(gras_socketset_get(),dst); + gras_dynar_push(gras_socketset_get(),dst); } @@ -153,7 +140,7 @@ gras_socket_server_ext(unsigned short port, TRY(gras_trp_plugin_get_by_name("buf",&trp)); /* defaults settings */ - TRY(gras_trp_socket_new(1,&sock)); + gras_trp_socket_new(1,&sock); sock->plugin= trp; sock->port=port; sock->bufSize = bufSize; @@ -201,7 +188,7 @@ gras_socket_client_ext(const char *host, DEBUG1("Create a client socket from plugin %s",gras_if_RL() ? "tcp" : "sg"); /* defaults settings */ - TRY(gras_trp_socket_new(0,&sock)); + gras_trp_socket_new(0,&sock); sock->plugin= trp; sock->peer_port = port; sock->peer_name = (char*)strdup(host?host:"localhost"); diff --git a/src/gras/Transport/transport_plugin_buf.c b/src/gras/Transport/transport_plugin_buf.c index 46638bec97..cc11972e22 100644 --- a/src/gras/Transport/transport_plugin_buf.c +++ b/src/gras/Transport/transport_plugin_buf.c @@ -64,24 +64,21 @@ struct gras_trp_bufdata_{ int buffsize; }; -gras_error_t gras_trp_buf_init_sock(gras_socket_t *sock) { +void gras_trp_buf_init_sock(gras_socket_t *sock) { gras_trp_bufdata_t *data=gras_new(gras_trp_bufdata_t,1); GRAS_IN; - if (!data) - RAISE_MALLOC; - data->in.size = 0; data->buffsize = 100 * 1024 ; /* 100k */ - if (!(data->in.data = (char*)gras_malloc(data->buffsize))) - RAISE_MALLOC; + data->in.size = 0; + data->in.data = gras_malloc(data->buffsize); data->in.pos = 0; /* useless, indeed, since size==pos */ + data->out.size = 0; - if (!(data->out.data = (char*)gras_malloc(data->buffsize))) - RAISE_MALLOC; + data->out.data = gras_malloc(data->buffsize); data->out.pos = 0; + sock->bufdata = data; - return no_error; } @@ -92,8 +89,6 @@ gras_error_t gras_trp_buf_setup(gras_trp_plugin_t *plug) { gras_error_t errcode; gras_trp_buf_plug_data_t *data =gras_new(gras_trp_buf_plug_data_t,1); - if (!data) - RAISE_MALLOC; GRAS_IN; TRY(gras_trp_plugin_get_by_name(gras_if_RL() ? "tcp" : "sg", @@ -124,7 +119,7 @@ gras_error_t gras_trp_buf_socket_client(gras_trp_plugin_t *self, GRAS_IN; TRY(super->socket_client(super,sock)); sock->plugin = self; - TRY(gras_trp_buf_init_sock(sock)); + gras_trp_buf_init_sock(sock); return no_error; } @@ -142,7 +137,7 @@ gras_error_t gras_trp_buf_socket_server(gras_trp_plugin_t *self, GRAS_IN; TRY(super->socket_server(super,sock)); sock->plugin = self; - TRY(gras_trp_buf_init_sock(sock)); + gras_trp_buf_init_sock(sock); return no_error; } @@ -155,7 +150,7 @@ gras_trp_buf_socket_accept(gras_socket_t *sock, GRAS_IN; TRY(super->socket_accept(sock,dst)); (*dst)->plugin = sock->plugin; - TRY(gras_trp_buf_init_sock(*dst)); + gras_trp_buf_init_sock(*dst); return no_error; } diff --git a/src/gras/Transport/transport_plugin_file.c b/src/gras/Transport/transport_plugin_file.c index 171a596d61..e542ff7ccb 100644 --- a/src/gras/Transport/transport_plugin_file.c +++ b/src/gras/Transport/transport_plugin_file.c @@ -56,16 +56,12 @@ gras_error_t gras_trp_file_setup(gras_trp_plugin_t *plug) { gras_trp_file_plug_data_t *file = gras_new(gras_trp_file_plug_data_t,1); - if (!file) - RAISE_MALLOC; FD_ZERO(&(file->incoming_socks)); plug->socket_close = gras_trp_file_close; - plug->chunk_send = gras_trp_file_chunk_send; plug->chunk_recv = gras_trp_file_chunk_recv; - plug->data = (void*)file; return no_error; @@ -87,7 +83,7 @@ gras_socket_client_from_file(const char*path, gras_assert0(gras_if_RL(), "Cannot use file as socket in the simulator"); - TRY(gras_trp_socket_new(0,dst)); + gras_trp_socket_new(0,dst); TRY(gras_trp_plugin_get_by_name("file",&trp)); (*dst)->plugin=trp; @@ -130,7 +126,7 @@ gras_socket_server_from_file(const char*path, gras_assert0(gras_if_RL(), "Cannot use file as socket in the simulator"); - TRY(gras_trp_socket_new(1,dst)); + gras_trp_socket_new(1,dst); TRY(gras_trp_plugin_get_by_name("file",&trp)); (*dst)->plugin=trp; diff --git a/src/gras/Transport/transport_plugin_sg.c b/src/gras/Transport/transport_plugin_sg.c index ae0ca84228..173f115491 100644 --- a/src/gras/Transport/transport_plugin_sg.c +++ b/src/gras/Transport/transport_plugin_sg.c @@ -76,9 +76,6 @@ gras_trp_sg_setup(gras_trp_plugin_t *plug) { gras_trp_sg_plug_data_t *data=gras_new(gras_trp_sg_plug_data_t,1); - if (!data) - RAISE_MALLOC; - plug->data = data; plug->socket_client = gras_trp_sg_socket_client; @@ -135,9 +132,7 @@ gras_error_t gras_trp_sg_socket_client(gras_trp_plugin_t *self, } /* create the socket */ - if (!(data = gras_new(gras_trp_sg_sock_data_t,1))) - RAISE_MALLOC; - + data = gras_new(gras_trp_sg_sock_data_t,1); data->from_PID = MSG_process_self_PID(); data->to_PID = hd->proc[ pr.tochan ]; data->to_host = peer; @@ -181,16 +176,14 @@ gras_error_t gras_trp_sg_socket_server(gras_trp_plugin_t *self, pr.tochan = sock->raw ? pd->rawChan : pd->chan; pr.port = sock->port; pr.raw = sock->raw; - TRY(gras_dynar_push(hd->ports,&pr)); + gras_dynar_push(hd->ports,&pr); default: return errcode; } /* Create the socket */ - if (!(data = gras_new(gras_trp_sg_sock_data_t,1))) - RAISE_MALLOC; - + data = gras_new(gras_trp_sg_sock_data_t,1); data->from_PID = -1; data->to_PID = MSG_process_self_PID(); data->to_host = MSG_host_self(); @@ -246,10 +239,8 @@ gras_error_t gras_trp_sg_chunk_send(gras_socket_t *sock, sprintf(name,"Chunk[%d]",count++); - if (!(task_data=gras_new(sg_task_data_t,1))) - RAISE_MALLOC; - if (!(task_data->data=(void*)gras_malloc(size))) - RAISE_MALLOC; + task_data=gras_new(sg_task_data_t,1); + task_data->data=(void*)gras_malloc(size); task_data->size = size; memcpy(task_data->data,data,size); diff --git a/src/gras/Transport/transport_plugin_tcp.c b/src/gras/Transport/transport_plugin_tcp.c index 189c2cfcc6..25ee77fa88 100644 --- a/src/gras/Transport/transport_plugin_tcp.c +++ b/src/gras/Transport/transport_plugin_tcp.c @@ -71,12 +71,9 @@ typedef struct { /*** *** Code ***/ -gras_error_t -gras_trp_tcp_setup(gras_trp_plugin_t *plug) { +gras_error_t gras_trp_tcp_setup(gras_trp_plugin_t *plug) { gras_trp_tcp_plug_data_t *data = gras_new(gras_trp_tcp_plug_data_t,1); - if (!data) - RAISE_MALLOC; FD_ZERO(&(data->msg_socks)); FD_ZERO(&(data->raw_socks)); @@ -216,7 +213,7 @@ gras_trp_tcp_socket_accept(gras_socket_t *sock, int tmp_errno; int size; - TRY(gras_trp_socket_new(1,&res)); + gras_trp_socket_new(1,&res); sd = accept(sock->sd, (struct sockaddr *)&peer_in, &peer_in_len); tmp_errno = errno; @@ -420,8 +417,7 @@ gras_error_t gras_socket_raw_exchange(gras_socket_t *peer, struct timeval timeOut; - if (!(chunk = (char *)gras_malloc(msg_size))) - RAISE_MALLOC; + chunk = gras_malloc(msg_size); for (exp_sofar=0; exp_sofar < exp_size; exp_size += msg_sofar) { for(msg_sofar=0; msg_sofar < msg_size; msg_size += res_last) { diff --git a/src/gras/Transport/transport_private.h b/src/gras/Transport/transport_private.h index 22a8539695..f5f1c3d96e 100644 --- a/src/gras/Transport/transport_private.h +++ b/src/gras/Transport/transport_private.h @@ -45,8 +45,8 @@ struct s_gras_socket { gras_trp_bufdata_t *bufdata; }; -gras_error_t gras_trp_socket_new(int incomming, - gras_socket_t **dst); +void gras_trp_socket_new(int incomming, + gras_socket_t **dst); /* The drivers */ typedef gras_error_t (*gras_trp_setup_t)(gras_trp_plugin_t *dst); @@ -74,7 +74,7 @@ gras_error_t gras_trp_buf_setup(gras_trp_plugin_t *plug); */ -gras_error_t gras_trp_buf_init_sock(gras_socket_t *sock); +void gras_trp_buf_init_sock(gras_socket_t *sock); /* Data exchange over raw sockets */ diff --git a/src/gras/Virtu/process.c b/src/gras/Virtu/process.c index 54b7f0e570..052d5c7dbc 100644 --- a/src/gras/Virtu/process.c +++ b/src/gras/Virtu/process.c @@ -28,15 +28,13 @@ void gras_userdata_set(void *ud) { pd->userdata = ud; } -gras_error_t +void gras_procdata_init() { - gras_error_t errcode; gras_procdata_t *pd=gras_procdata_get(); pd->userdata = NULL; - TRY(gras_dynar_new(&(pd->msg_queue), sizeof(gras_msg_t), NULL)); - TRY(gras_dynar_new(&(pd->cbl_list), sizeof(gras_cblist_t *),gras_cbl_free)); - TRY(gras_dynar_new(&(pd->sockets), sizeof(gras_socket_t*), NULL)); - return no_error; + gras_dynar_new(&(pd->msg_queue), sizeof(gras_msg_t), NULL); + gras_dynar_new(&(pd->cbl_list), sizeof(gras_cblist_t *),gras_cbl_free); + gras_dynar_new(&(pd->sockets), sizeof(gras_socket_t*), NULL); } void diff --git a/src/gras/Virtu/rl_process.c b/src/gras/Virtu/rl_process.c index 7f4846ffa8..3297932d45 100644 --- a/src/gras/Virtu/rl_process.c +++ b/src/gras/Virtu/rl_process.c @@ -17,12 +17,8 @@ GRAS_LOG_DEFAULT_CATEGORY(process); static gras_procdata_t *_gras_procdata = NULL; gras_error_t gras_process_init() { - gras_error_t errcode; - - if (!(_gras_procdata=gras_new(gras_procdata_t,1))) - RAISE_MALLOC; - - TRY(gras_procdata_init()); + _gras_procdata=gras_new(gras_procdata_t,1); + gras_procdata_init(); return no_error; } gras_error_t gras_process_exit() { diff --git a/src/gras/Virtu/sg_process.c b/src/gras/Virtu/sg_process.c index 9fb983d1dd..ea7627c7ab 100644 --- a/src/gras/Virtu/sg_process.c +++ b/src/gras/Virtu/sg_process.c @@ -21,25 +21,20 @@ gras_process_init() { gras_sg_portrec_t prraw,pr; int i; - if (!(pd=gras_new(gras_procdata_t,1))) - RAISE_MALLOC; + pd=gras_new(gras_procdata_t,1); - if (MSG_process_set_data(MSG_process_self(),(void*)pd) != MSG_OK) { + if (MSG_process_set_data(MSG_process_self(),(void*)pd) != MSG_OK) return unknown_error; - } - TRY(gras_procdata_init()); + gras_procdata_init(); if (!hd) { - if (!(hd=gras_new(gras_hostdata_t,1))) - RAISE_MALLOC; - - TRY(gras_dynar_new(&(hd->ports),sizeof(gras_sg_portrec_t),NULL)); + hd=gras_new(gras_hostdata_t,1); + gras_dynar_new(&(hd->ports),sizeof(gras_sg_portrec_t),NULL); memset(hd->proc, 0, sizeof(hd->proc[0]) * GRAS_MAX_CHANNEL); - if (MSG_host_set_data(MSG_host_self(),(void*)hd) != MSG_OK) { + if (MSG_host_set_data(MSG_host_self(),(void*)hd) != MSG_OK) return unknown_error; - } } /* take a free channel for this process */ @@ -56,7 +51,7 @@ gras_process_init() { pr.port = -1; pr.tochan = i; pr.raw = 0; - TRY(gras_dynar_push(hd->ports,&pr)); + gras_dynar_push(hd->ports,&pr); /* take a free RAW channel for this process */ for (i=0; iproc[i]; i++); @@ -73,7 +68,7 @@ gras_process_init() { prraw.port = -1; prraw.tochan = i; prraw.raw = 1; - TRY(gras_dynar_push(hd->ports,&prraw)); + gras_dynar_push(hd->ports,&prraw); VERB2("Creating process '%s' (%d)", MSG_process_get_name(MSG_process_self()), diff --git a/src/gras/Virtu/virtu_interface.h b/src/gras/Virtu/virtu_interface.h index 74ed9f7ce6..10c065db2f 100644 --- a/src/gras/Virtu/virtu_interface.h +++ b/src/gras/Virtu/virtu_interface.h @@ -39,6 +39,6 @@ gras_dynar_t * gras_socketset_get(void); /* FIXME: mv to _private? */ gras_procdata_t *gras_procdata_get(void); -gras_error_t gras_procdata_init(void); +void gras_procdata_init(void); void gras_procdata_exit(void); #endif /* GRAS_VIRTU_INTERFACE_H */ diff --git a/src/gras_private.h b/src/gras_private.h index 5d1e6b5f5c..124c9dfc1c 100644 --- a/src/gras_private.h +++ b/src/gras_private.h @@ -43,8 +43,8 @@ /* modules initialization functions */ void gras_msg_init(void); void gras_msg_exit(void); -gras_error_t gras_trp_init(void); /* FIXME */ -void gras_trp_exit(void); +void gras_trp_init(void); +void gras_trp_exit(void); void gras_datadesc_init(void); void gras_datadesc_exit(void); diff --git a/src/xbt/config.c b/src/xbt/config.c index 694eed8e18..c76008db03 100644 --- a/src/xbt/config.c +++ b/src/xbt/config.c @@ -65,8 +65,8 @@ void gras_cfg_host_free(void *d){ */ -gras_error_t gras_cfg_new(gras_cfg_t **whereto) { - return gras_dict_new((gras_dict_t**)whereto); +void gras_cfg_new(gras_cfg_t **whereto) { + gras_dict_new((gras_dict_t**)whereto); } /** @@ -77,26 +77,18 @@ gras_error_t gras_cfg_new(gras_cfg_t **whereto) { * */ -gras_error_t +void gras_cfg_cpy(gras_cfg_t **whereto, gras_cfg_t *tocopy) { gras_dict_cursor_t *cursor=NULL; gras_cfgelm_t *cell=NULL; char *name=NULL; - int errcode=no_error; *whereto=NULL; gras_assert0(tocopy,"cannot copy NULL config"); gras_dict_foreach((gras_dict_t*)tocopy,cursor,name,cell) { - if ((errcode=gras_cfg_register(*whereto, name, cell->type, - cell->min, cell->max)) != no_error) { - if (cursor) gras_dict_cursor_free(cursor); - if (*whereto) gras_cfg_free(whereto); - return errcode; - } + gras_cfg_register(*whereto, name, cell->type, cell->min, cell->max); } - - return errcode; } void gras_cfg_free(gras_cfg_t **cfg) { @@ -207,7 +199,7 @@ void gras_cfgelm_free(void *data) { * register an element within a config set */ -gras_error_t +void gras_cfg_register(gras_cfg_t *cfg, const char *name, gras_cfgelm_type_t type, int min, int max){ @@ -215,16 +207,15 @@ gras_cfg_register(gras_cfg_t *cfg, gras_error_t errcode; DEBUG4("Register cfg elm %s (%d to %d %s)",name,min,max,gras_cfgelm_type_name[type]); - TRYCATCH(mismatch_error,gras_dict_get((gras_dict_t*)cfg,name,(void**)&res)); + errcode = gras_dict_get((gras_dict_t*)cfg,name,(void**)&res); - if (errcode != mismatch_error) { + if (errcode == no_error) { WARN1("Config elem %s registered twice.",name); /* Will be removed by the insertion of the new one */ } + gras_assert_error(mismatch_error); res=gras_new(gras_cfgelm_t,1); - if (!res) - RAISE_MALLOC; res->type=type; res->min=min; @@ -232,26 +223,26 @@ gras_cfg_register(gras_cfg_t *cfg, switch (type) { case gras_cfgelm_int: - TRY(gras_dynar_new(&(res->content), sizeof(int), NULL)); + gras_dynar_new(&(res->content), sizeof(int), NULL); break; case gras_cfgelm_double: - TRY(gras_dynar_new(&(res->content), sizeof(double), NULL)); + gras_dynar_new(&(res->content), sizeof(double), NULL); break; case gras_cfgelm_string: - TRY(gras_dynar_new(&(res->content),sizeof(char*),&gras_cfg_str_free)); + gras_dynar_new(&(res->content),sizeof(char*),&gras_cfg_str_free); break; case gras_cfgelm_host: - TRY(gras_dynar_new(&(res->content),sizeof(gras_host_t*),&gras_cfg_host_free)); + gras_dynar_new(&(res->content),sizeof(gras_host_t*),&gras_cfg_host_free); break; default: ERROR1("%d is an invalide type code",type); } - return gras_dict_set((gras_dict_t*)cfg,name,res,&gras_cfgelm_free); + gras_dict_set((gras_dict_t*)cfg,name,res,&gras_cfgelm_free); } /** @@ -280,14 +271,12 @@ gras_cfg_unregister(gras_cfg_t *cfg,const char *name) { gras_error_t gras_cfg_register_str(gras_cfg_t *cfg,const char *entry) { - char *entrycpy=(char*)strdup(entry); + char *entrycpy=gras_strdup(entry); char *tok; int min,max; gras_cfgelm_type_t type; - gras_error_t errcode; - tok=strchr(entrycpy, ':'); if (!tok) { ERROR3("%s%s%s", @@ -340,8 +329,7 @@ gras_cfg_register_str(gras_cfg_t *cfg,const char *entry) { gras_abort(); } - TRYCLEAN(gras_cfg_register(cfg,entrycpy,type,min,max), - gras_free(entrycpy)); + gras_cfg_register(cfg,entrycpy,type,min,max); gras_free(entrycpy); /* strdup'ed by dict mechanism, but cannot be const */ return no_error; @@ -548,7 +536,7 @@ gras_cfg_set_parse(gras_cfg_t *cfg, const char *options) { if (!options || !strlen(options)) { /* nothing to do */ return no_error; } - optionlist_cpy=(char*)strdup(options); + optionlist_cpy=gras_strdup(options); DEBUG1("List to parse and set:'%s'",options); option=optionlist_cpy; @@ -697,10 +685,11 @@ gras_cfg_set_int(gras_cfg_t *cfg,const char*name, int val) { TRY (gras_cfgelm_get(cfg,name,gras_cfgelm_int,&cell)); if (cell->max > 1) { - return gras_dynar_push(cell->content,&val); + gras_dynar_push(cell->content,&val); } else { - return gras_dynar_set(cell->content,0,&val); + gras_dynar_set(cell->content,0,&val); } + return no_error; } /** @@ -721,10 +710,11 @@ gras_cfg_set_double(gras_cfg_t *cfg,const char*name, double val) { TRY (gras_cfgelm_get(cfg,name,gras_cfgelm_double,&cell)); if (cell->max > 1) { - return gras_dynar_push(cell->content,&val); + gras_dynar_push(cell->content,&val); } else { - return gras_dynar_set(cell->content,0,&val); + gras_dynar_set(cell->content,0,&val); } + return no_error; } /** @@ -741,16 +731,17 @@ gras_error_t gras_cfg_set_string(gras_cfg_t *cfg,const char*name, const char*val) { gras_cfgelm_t *cell; gras_error_t errcode; - char *newval = (char*)strdup(val); + char *newval = gras_strdup(val); VERB2("Configuration setting: %s=%s",name,val); TRY (gras_cfgelm_get(cfg,name,gras_cfgelm_string,&cell)); if (cell->max > 1) { - return gras_dynar_push(cell->content,&newval); + gras_dynar_push(cell->content,&newval); } else { - return gras_dynar_set(cell->content,0,&newval); + gras_dynar_set(cell->content,0,&newval); } + return no_error; } /** @@ -773,18 +764,18 @@ gras_cfg_set_host(gras_cfg_t *cfg,const char*name, gras_host_t *val=gras_new(gras_host_t,1); VERB3("Configuration setting: %s=%s:%d",name,host,port); - if (!val) - RAISE_MALLOC; - val->name = (char*)strdup(name); + + val->name = gras_strdup(name); val->port = port; TRY (gras_cfgelm_get(cfg,name,gras_cfgelm_host,&cell)); if (cell->max > 1) { - return gras_dynar_push(cell->content,&val); + gras_dynar_push(cell->content,&val); } else { - return gras_dynar_set(cell->content,0,&val); + gras_dynar_set(cell->content,0,&val); } + return no_error; } /* ---- [ Removing ] ---- */ diff --git a/src/xbt/dict.c b/src/xbt/dict.c index 3657cb0b31..3bf65c2836 100644 --- a/src/xbt/dict.c +++ b/src/xbt/dict.c @@ -32,18 +32,12 @@ GRAS_LOG_NEW_DEFAULT_SUBCATEGORY(dict,gros, * * Creates and initialize a new dictionnary */ -gras_error_t +void gras_dict_new(gras_dict_t **whereto) { - gras_dict_t *dict; - - if (!(dict = calloc(1, sizeof(gras_dict_t)))) - RAISE_MALLOC; - dict->head=NULL; + (*whereto) = gras_new(gras_dict_t,1); + (*whereto)->head=NULL; - *whereto = dict; - - return no_error; } /** * gras_dict_free: @@ -74,17 +68,17 @@ gras_dict_free(gras_dict_t **dict) { * set the @data in the structure under the @key, which can be any kind * of data, as long as its length is provided in @key_len. */ -gras_error_t +void gras_dict_set_ext(gras_dict_t *p_dict, - const char *key, - int key_len, - void *data, - void_f_pvoid_t *free_ctn) { + const char *key, + int key_len, + void *data, + void_f_pvoid_t *free_ctn) { gras_assert(p_dict); - return gras_dictelm_set_ext(&(p_dict->head), - key, key_len, data, free_ctn); + gras_dictelm_set_ext(&(p_dict->head), + key, key_len, data, free_ctn); } /** @@ -98,7 +92,7 @@ gras_dict_set_ext(gras_dict_t *p_dict, * set the @data in the structure under the @key, which is a * null terminated string. */ -gras_error_t +void gras_dict_set(gras_dict_t *p_dict, const char *key, void *data, @@ -106,7 +100,7 @@ gras_dict_set(gras_dict_t *p_dict, gras_assert(p_dict); - return gras_dictelm_set(&(p_dict->head), key, data, free_ctn); + gras_dictelm_set(&(p_dict->head), key, data, free_ctn); } /** @@ -198,11 +192,11 @@ gras_dict_remove(gras_dict_t *dict, * function to output the data. If NULL, data won't be displayed. */ -gras_error_t +void gras_dict_dump(gras_dict_t *dict, void_f_pvoid_t *output) { printf("Dict %p:\n", (void*)dict); - return gras_dictelm_dump(dict ? dict->head: NULL, output); + gras_dictelm_dump(dict ? dict->head: NULL, output); } diff --git a/src/xbt/dict_cursor.c b/src/xbt/dict_cursor.c index 4dfb378379..ba7812823a 100644 --- a/src/xbt/dict_cursor.c +++ b/src/xbt/dict_cursor.c @@ -11,7 +11,6 @@ #include "gras_private.h" #include "dict_private.h" -#include /* malloc() */ #include /* strlen() */ GRAS_LOG_EXTERNAL_CATEGORY(dict); @@ -31,8 +30,7 @@ struct gras_dict_cursor_ { gras_dictelm_t *head; }; -static _GRAS_INLINE -gras_error_t +static _GRAS_INLINE void _cursor_push_keys(gras_dict_cursor_t *p_cursor, gras_dictelm_t *p_elm); @@ -47,28 +45,25 @@ _cursor_push_keys(gras_dict_cursor_t *p_cursor, * * Structure creator */ -gras_error_t +void gras_dict_cursor_new(const gras_dict_t *p_head, /*OUT*/gras_dict_cursor_t **pp_cursor) { gras_error_t errcode = no_error; gras_dict_cursor_t *p_cursor = NULL; - p_cursor = malloc(sizeof(gras_dict_cursor_t)); - if (!p_cursor) - RAISE_MALLOC; + p_cursor = gras_new(gras_dict_cursor_t,1); - TRY(gras_dynar_new(&p_cursor->keys, sizeof(char **), NULL)); - TRY(gras_dynar_new(&p_cursor->key_lens, sizeof(int *), NULL)); + gras_dynar_new(&p_cursor->keys, sizeof(char **), NULL); + gras_dynar_new(&p_cursor->key_lens, sizeof(int *), NULL); p_cursor->pos = 0; p_cursor->pos_len = 0; p_cursor->head = p_head ? p_head->head : NULL; - TRY(gras_dict_cursor_rewind(p_cursor)); + gras_dict_cursor_rewind(p_cursor); *pp_cursor = p_cursor; - return errcode; } /** @@ -84,7 +79,7 @@ gras_dict_cursor_free(gras_dict_cursor_t *p_cursor) { gras_dynar_free(p_cursor->keys); gras_dynar_free(p_cursor->key_lens); memset(p_cursor, 0, sizeof(gras_dict_cursor_t)); - free(p_cursor); + gras_free(p_cursor); } } @@ -108,7 +103,7 @@ __cursor_not_null(gras_dict_cursor_t *p_cursor) { static _GRAS_INLINE -gras_error_t +void _cursor_push_keys(gras_dict_cursor_t *p_cursor, gras_dictelm_t *p_elm) { gras_error_t errcode = no_error; @@ -119,19 +114,17 @@ _cursor_push_keys(gras_dict_cursor_t *p_cursor, CDEBUG1(dict_cursor, "Push childs of %p in the cursor", (void*)p_elm); if (p_elm->content) { - TRY(gras_dynar_push(p_cursor->keys, &p_elm->key )); - TRY(gras_dynar_push(p_cursor->key_lens, &p_elm->key_len)); + gras_dynar_push(p_cursor->keys, &p_elm->key ); + gras_dynar_push(p_cursor->key_lens, &p_elm->key_len); count++; } gras_dynar_foreach(p_elm->sub, i, p_child) { if (p_child) - TRY(_cursor_push_keys(p_cursor, p_child)); + _cursor_push_keys(p_cursor, p_child); } CDEBUG1(dict_cursor, "Count = %d", count); - - return errcode; } /** @@ -141,7 +134,7 @@ _cursor_push_keys(gras_dict_cursor_t *p_cursor, * * back to the first element */ -gras_error_t +void gras_dict_cursor_rewind(gras_dict_cursor_t *p_cursor) { gras_error_t errcode = no_error; @@ -152,14 +145,13 @@ gras_dict_cursor_rewind(gras_dict_cursor_t *p_cursor) { gras_dynar_reset(p_cursor->key_lens); if (!p_cursor->head) - return no_error; + return ; - TRY(_cursor_push_keys(p_cursor, p_cursor->head)); + _cursor_push_keys(p_cursor, p_cursor->head); gras_dynar_cursor_first(p_cursor->keys, &p_cursor->pos ); gras_dynar_cursor_first(p_cursor->key_lens, &p_cursor->pos_len); - return errcode; } /** @@ -171,18 +163,13 @@ gras_dict_cursor_rewind(gras_dict_cursor_t *p_cursor) { */ void gras_dict_cursor_first (const gras_dict_t *dict, gras_dict_cursor_t **cursor){ - gras_error_t errcode; if (!*cursor) { DEBUG0("Create the cursor on first use"); - errcode = gras_dict_cursor_new(dict,cursor); - gras_assert1(errcode == no_error, "Unable to create the cursor, got error %s", - gras_error_name(errcode)); + gras_dict_cursor_new(dict,cursor); } - errcode = gras_dict_cursor_rewind(*cursor); - gras_assert1(errcode == no_error, "Unable to rewind the cursor before use, got error %s", - gras_error_name(errcode)); + gras_dict_cursor_rewind(*cursor); } diff --git a/src/xbt/dict_elm.c b/src/xbt/dict_elm.c index 30317df6a8..24f61bcf2b 100644 --- a/src/xbt/dict_elm.c +++ b/src/xbt/dict_elm.c @@ -12,11 +12,6 @@ #include "gras_private.h" #include "dict_private.h" /* prototypes of this module */ -#include /* malloc() */ -#include /* strlen() */ - -#include - GRAS_LOG_EXTERNAL_CATEGORY(dict); GRAS_LOG_NEW_DEFAULT_SUBCATEGORY(dict_elm,dict,"Dictionaries internals"); @@ -28,34 +23,34 @@ GRAS_LOG_NEW_SUBCATEGORY(dict_multi,dict,"Dictionaries internals: dictionaries o /*####[ Private prototypes ]#################################################*/ -static _GRAS_INLINE gras_error_t _gras_dictelm_alloc(char *key, - int offset, - int key_len, - void *data, - void_f_pvoid_t *free_ctn, - /*OUT*/gras_dictelm_t **where); +static _GRAS_INLINE void _gras_dictelm_alloc(char *key, + int offset, + int key_len, + void *data, + void_f_pvoid_t *free_ctn, + /*OUT*/gras_dictelm_t **where); static void _dictelm_wrapper_free(void*); static _GRAS_INLINE void _str_prefix_lgr(const char *key1, - int key_len1, - const char *key2, - int key_len2, - int *offset, - int *match); + int key_len1, + const char *key2, + int key_len2, + int *offset, + int *match); -static gras_error_t _gras_dictelm_dump_rec(gras_dictelm_t *head, - int offset, - void_f_pvoid_t *output); +static void _gras_dictelm_dump_rec(gras_dictelm_t *head, + int offset, + void_f_pvoid_t *output); -static gras_error_t _gras_dictelm_set_rec(gras_dictelm_t *head, - char *key, - int key_len, - int offset, - void *data, - void_f_pvoid_t *free_ctn); +static void _gras_dictelm_set_rec(gras_dictelm_t *head, + char *key, + int key_len, + int offset, + void *data, + void_f_pvoid_t *free_ctn); static gras_error_t _gras_dictelm_get_rec(gras_dictelm_t *head, const char *key, int key_len, @@ -76,16 +71,13 @@ _collapse_if_need(gras_dictelm_t *p_head, static _GRAS_INLINE void * -memdup(const void * const ptr, - const size_t length) { +gras_memdup(const void * const ptr, + const size_t length) { void * new_ptr = NULL; - new_ptr = malloc(length); - - if (new_ptr) { - memcpy(new_ptr, ptr, length); - } - + new_ptr = gras_malloc(length); + memcpy(new_ptr, ptr, length); + return new_ptr; } @@ -133,9 +125,8 @@ _gras_bytes_to_string(char * const ptr, * * Alloc a dict element with no child. */ -static -_GRAS_INLINE -gras_error_t +static _GRAS_INLINE +void _gras_dictelm_alloc(char *key, int key_len, int offset, @@ -145,13 +136,7 @@ _gras_dictelm_alloc(char *key, gras_error_t errcode = no_error; gras_dictelm_t *p_elm = NULL; - if (!(p_elm = calloc(1, sizeof(gras_dictelm_t)))) { - if (free_ctn && data) { - free_ctn(data); - } - - RAISE_MALLOC; - } + p_elm = gras_new(gras_dictelm_t,1); p_elm->key = key; p_elm->key_len = key_len; @@ -159,19 +144,10 @@ _gras_dictelm_alloc(char *key, p_elm->content = data; p_elm->free_ctn = free_ctn; - errcode = gras_dynar_new(&(p_elm->sub), sizeof(gras_dictelm_t*), - _dictelm_wrapper_free); - if (errcode != no_error) { - if (free_ctn && data) { - free_ctn(data); - } - free(p_elm); - return errcode; - } + gras_dynar_new(&(p_elm->sub), sizeof(gras_dictelm_t*), _dictelm_wrapper_free); *pp_elm = p_elm; - return errcode; } /** @@ -189,7 +165,7 @@ gras_dictelm_free(gras_dictelm_t **pp_elm) { gras_dynar_free(p_elm->sub); if (p_elm->key) { - free(p_elm->key); + gras_free(p_elm->key); } if (p_elm->free_ctn && p_elm->content) { @@ -198,7 +174,7 @@ gras_dictelm_free(gras_dictelm_t **pp_elm) { memset(p_elm, 0, sizeof (*p_elm)); - free(p_elm); + gras_free(p_elm); *pp_elm = NULL; } } @@ -432,14 +408,13 @@ _gras_dictelm_change_value(gras_dictelm_t *p_elm, * This is a helper function to gras_dict_set which locks the struct and * strdup the key before action. */ -gras_error_t +void _gras_dictelm_set_rec(gras_dictelm_t *p_head, char *key, int key_len, int offset, void *data, void_f_pvoid_t *free_ctn) { - gras_error_t errcode = no_error; int match = 0; int pos = 0; const int old_offset = offset; @@ -458,9 +433,9 @@ _gras_dictelm_set_rec(gras_dictelm_t *p_head, CDEBUG0(dict_add, "--> Change the value of head"); _gras_dictelm_change_value(p_head, data, free_ctn); - free(key); /* Keep the key used in the tree */ + gras_free(key); /* Keep the key used in the tree */ - return errcode; + return; } /*** Search where to add this child, and how ***/ @@ -475,11 +450,11 @@ _gras_dictelm_set_rec(gras_dictelm_t *p_head, { gras_dictelm_t *p_child = NULL; - TRY(_gras_dictelm_alloc(key, key_len, offset, data, free_ctn, &p_child)); + _gras_dictelm_alloc(key, key_len, offset, data, free_ctn, &p_child); CDEBUG1(dict_add, "-> Add a child %p", (void*)p_child); - TRY(gras_dynar_insert_at(p_head->sub, pos, &p_child)); + gras_dynar_insert_at(p_head->sub, pos, &p_child); - return errcode; + return; } case 1: /* A child have exactly this key => change its value*/ @@ -490,9 +465,9 @@ _gras_dictelm_set_rec(gras_dictelm_t *p_head, CDEBUG1(dict_add, "-> Change the value of the child %p", (void*)p_child); _gras_dictelm_change_value(p_child, data, free_ctn); - free(key); + gras_free(key); - return errcode; + return; } case 2: /* A child constitutes a prefix of the key => recurse */ @@ -502,8 +477,9 @@ _gras_dictelm_set_rec(gras_dictelm_t *p_head, gras_dynar_get(p_head->sub, pos, &p_child); CDEBUG2(dict_add,"-> Recurse on %p (offset=%d)", (void*)p_child, offset); - return _gras_dictelm_set_rec(p_child, key, key_len, - offset, data, free_ctn); + _gras_dictelm_set_rec(p_child, key, key_len, + offset, data, free_ctn); + return; } case 3: /* The key is a prefix of the child => child becomes child of p_new */ @@ -512,16 +488,16 @@ _gras_dictelm_set_rec(gras_dictelm_t *p_head, gras_dictelm_t *p_child = NULL; gras_dynar_get(p_head->sub, pos, &p_child); - TRY(_gras_dictelm_alloc(key, key_len, old_offset, data, free_ctn, &p_new)); + _gras_dictelm_alloc(key, key_len, old_offset, data, free_ctn, &p_new); CDEBUG2(dict_add, "-> The child %p become child of new dict (%p)", (void*)p_child, (void*)p_new); - TRY(gras_dynar_push(p_new->sub, &p_child)); + gras_dynar_push(p_new->sub, &p_child); p_child->offset = offset; - TRY(gras_dynar_set(p_head->sub, pos, &p_new)); + gras_dynar_set(p_head->sub, pos, &p_new); - return errcode; + return; } case 4: /* A child share a common prefix with this key => Common ancestor */ @@ -532,36 +508,34 @@ _gras_dictelm_set_rec(gras_dictelm_t *p_head, char *anc_key = NULL; int anc_key_len = offset; - TRY(_gras_dictelm_alloc(key, key_len, offset, data, free_ctn, &p_new)); + _gras_dictelm_alloc(key, key_len, offset, data, free_ctn, &p_new); gras_dynar_get(p_head->sub, pos, &p_child); - anc_key = memdup(key, anc_key_len); + anc_key = gras_memdup(key, anc_key_len); - TRY(_gras_dictelm_alloc(anc_key, anc_key_len, old_offset, - NULL, NULL, &p_anc)); + _gras_dictelm_alloc(anc_key, anc_key_len, old_offset, NULL, NULL, &p_anc); CDEBUG3(dict_add, "-> Make a common ancestor %p (%.*s)", (void*)p_anc, anc_key_len, anc_key); if (key[offset] < p_child->key[offset]) { - TRY(gras_dynar_push(p_anc->sub, &p_new)); - TRY(gras_dynar_push(p_anc->sub, &p_child)); + gras_dynar_push(p_anc->sub, &p_new); + gras_dynar_push(p_anc->sub, &p_child); } else { - TRY(gras_dynar_push(p_anc->sub, &p_child)); - TRY(gras_dynar_push(p_anc->sub, &p_new)); + gras_dynar_push(p_anc->sub, &p_child); + gras_dynar_push(p_anc->sub, &p_new); } p_child->offset = offset; - TRY(gras_dynar_set(p_head->sub, pos, &p_anc)); + gras_dynar_set(p_head->sub, pos, &p_anc); - return errcode; + return; } default: - RAISE_IMPOSSIBLE; + DIE_IMPOSSIBLE; } - } /** @@ -575,19 +549,16 @@ _gras_dictelm_set_rec(gras_dictelm_t *p_head, * set the @data in the structure under the @key, which can be any kind * of data, as long as its length is provided in @key_len. */ -gras_error_t +void gras_dictelm_set_ext(gras_dictelm_t **pp_head, const char *_key, int key_len, void *data, void_f_pvoid_t *free_ctn) { - gras_error_t errcode = no_error; gras_dictelm_t *p_head = *pp_head; char *key = NULL; - key = memdup(_key, key_len); - if (!key) - RAISE_MALLOC; + key = gras_memdup(_key, key_len); /* there is no head, create it */ if (!p_head) { @@ -596,17 +567,17 @@ gras_dictelm_set_ext(gras_dictelm_t **pp_head, CDEBUG0(dict_add, "Create an head"); /* The head is priviledged by being the only one with a NULL key */ - TRY(_gras_dictelm_alloc(NULL, 0, 0, NULL, NULL, &p_head)); + _gras_dictelm_alloc(NULL, 0, 0, NULL, NULL, &p_head); - TRY(_gras_dictelm_alloc(key, key_len, 0, data, free_ctn, &p_child)); - TRY(gras_dynar_insert_at(p_head->sub, 0, &p_child)); + _gras_dictelm_alloc(key, key_len, 0, data, free_ctn, &p_child); + gras_dynar_insert_at(p_head->sub, 0, &p_child); *pp_head = p_head; - return errcode; + return; } - return _gras_dictelm_set_rec(p_head, key, key_len, 0, data, free_ctn); + _gras_dictelm_set_rec(p_head, key, key_len, 0, data, free_ctn); } /** @@ -620,13 +591,13 @@ gras_dictelm_set_ext(gras_dictelm_t **pp_head, * set the @data in the structure under the @key, which is a * null terminated string. */ -gras_error_t +void gras_dictelm_set(gras_dictelm_t **pp_head, const char *_key, void *data, void_f_pvoid_t *free_ctn) { - return gras_dictelm_set_ext(pp_head, _key, 1+strlen(_key), data, free_ctn); + gras_dictelm_set_ext(pp_head, _key, 1+strlen(_key), data, free_ctn); } /** @@ -789,14 +760,14 @@ _collapse_if_need(gras_dictelm_t *p_head, p_head->content = p_child->content; p_head->free_ctn = p_child->free_ctn; - free(p_head->key); + gras_free(p_head->key); p_head->key = p_child->key; p_head->key_len = p_child->key_len; gras_dynar_free_container(p_head->sub) ; p_head->sub = p_child->sub; - free(p_child); + gras_free(p_child); } /** @@ -916,31 +887,28 @@ gras_dictelm_remove(gras_dictelm_t *p_head, /* private function to do the job of gras_dict_dump recursively */ /*---------------------------------------------------------------------------*/ static -gras_error_t +void _gras_dictelm_dump_rec(gras_dictelm_t *p_head, int offset, void_f_pvoid_t *output) { - gras_error_t errcode = no_error; gras_dictelm_t *p_child = NULL; char *key = NULL; int key_len = 0; int i = 0; if (!p_head) - return no_error; + return; printf("[%p] ", (void*)p_head); key = p_head->key; key_len = p_head->key_len; - if (key_len) { + if (key_len) printf (" "); - } - for (i = 0; i < offset; i++) { + for (i = 0; i < offset; i++) printf("-"); - } fflush(stdout); @@ -951,15 +919,12 @@ _gras_dictelm_dump_rec(gras_dictelm_t *p_head, } else { char *key_string = NULL; - key_string = malloc(key_len*2+1); - if (!key_string) - RAISE_MALLOC; - + key_string = gras_malloc(key_len*2+1); _gras_bytes_to_string(key, key_len, key_string); printf("%.*s|(%d)", key_len-offset, key_string + offset, offset); - free(key_string); + gras_free(key_string); } } @@ -981,9 +946,8 @@ _gras_dictelm_dump_rec(gras_dictelm_t *p_head, printf(" \t\t\t[ %lu child(s) ]\n", gras_dynar_length(p_head->sub)); gras_dynar_foreach(p_head->sub, i, p_child) - TRY(_gras_dictelm_dump_rec(p_child, p_child->offset, output)); + _gras_dictelm_dump_rec(p_child, p_child->offset, output); - return errcode; } /** @@ -997,10 +961,10 @@ _gras_dictelm_dump_rec(gras_dictelm_t *p_head, * function to output the data. If NULL, data won't be displayed. */ -gras_error_t +void gras_dictelm_dump(gras_dictelm_t *p_head, void_f_pvoid_t *output) { - return _gras_dictelm_dump_rec(p_head, 0, output); + _gras_dictelm_dump_rec(p_head, 0, output); } /** diff --git a/src/xbt/dict_private.h b/src/xbt/dict_private.h index 8bdc77360e..3b17689904 100644 --- a/src/xbt/dict_private.h +++ b/src/xbt/dict_private.h @@ -28,17 +28,17 @@ struct gras_dict_ { }; /*####[ Function prototypes ]################################################*/ -void gras_dictelm_free (gras_dictelm_t **pp_elm); - -gras_error_t gras_dictelm_set (gras_dictelm_t **pp_head, - const char *_key, - void *data, - void_f_pvoid_t *free_ctn); -gras_error_t gras_dictelm_set_ext (gras_dictelm_t **pp_head, - const char *_key, - int key_len, - void *data, - void_f_pvoid_t *free_ctn); +void gras_dictelm_free (gras_dictelm_t **pp_elm); + +void gras_dictelm_set (gras_dictelm_t **pp_head, + const char *_key, + void *data, + void_f_pvoid_t *free_ctn); +void gras_dictelm_set_ext (gras_dictelm_t **pp_head, + const char *_key, + int key_len, + void *data, + void_f_pvoid_t *free_ctn); gras_error_t gras_dictelm_get (gras_dictelm_t *p_head, const char *key, @@ -54,7 +54,7 @@ gras_error_t gras_dictelm_remove_ext(gras_dictelm_t *p_head, const char *key, int key_len); -gras_error_t gras_dictelm_dump (gras_dictelm_t *p_head, +void gras_dictelm_dump (gras_dictelm_t *p_head, void_f_pvoid_t *output); void gras_dictelm_print_fct (void *data); diff --git a/src/xbt/dynar.c b/src/xbt/dynar.c index 1010a3754a..a0954b78cb 100644 --- a/src/xbt/dynar.c +++ b/src/xbt/dynar.c @@ -67,8 +67,6 @@ _gras_dynar_expand(gras_dynar_t * const dynar, char * const new_data = gras_malloc0(elmsize*new_size); DEBUG3("expend %p from %lu to %d elements", (void*)dynar, (unsigned long)old_size, nb); - if (!new_data) - RAISE_MALLOC; if (old_data) { memcpy(new_data, old_data, used_length); @@ -122,21 +120,17 @@ _gras_dynar_put_elm(const gras_dynar_t * const dynar, * @whereto: pointer to where the dynar should be created * @elm_size: size of each element in the dynar * @free_func: function to call each time we want to get rid of an element (or NULL if nothing to do). - * @Returns: malloc_error or no_error * * Creates a new dynar. If a free_func is provided, the elements have to be * pointer of pointer. That is to say that dynars can contain either base * types (int, char, double, etc) or pointer of pointers (struct **). */ -gras_error_t +void gras_dynar_new(gras_dynar_t ** const p_dynar, const size_t elmsize, void_f_pvoid_t * const free_func) { - gras_error_t errcode = no_error; - gras_dynar_t *dynar = NULL; - - if (!(dynar = gras_new0(gras_dynar_t,1))) - RAISE_MALLOC; + + gras_dynar_t *dynar = gras_new0(gras_dynar_t,1); dynar->size = 0; dynar->used = 0; @@ -145,8 +139,6 @@ gras_dynar_new(gras_dynar_t ** const p_dynar, dynar->free = free_func; *p_dynar = dynar; - - return errcode; } /** @@ -249,30 +241,26 @@ gras_dynar_get(const gras_dynar_t * const dynar, * @dynar: * @idx: * @src: What will be feeded to the dynar - * @Returns: malloc_error or no_error * * Set the Nth element of a dynar, expanding the dynar if needed, BUT NOT freeing * the previous value at this position. If you want to free the previous content, * use gras_dynar_remplace(). */ -gras_error_t +void gras_dynar_set(gras_dynar_t * const dynar, const int idx, const void * const src) { - gras_error_t errcode = no_error; __sanity_check_dynar(dynar); __sanity_check_idx(idx); - TRY(_gras_dynar_expand(dynar, idx+1)); + _gras_dynar_expand(dynar, idx+1); if (idx >= dynar->used) { dynar->used = idx+1; } _gras_dynar_put_elm(dynar, idx, src); - - return errcode; } /** @@ -280,17 +268,15 @@ gras_dynar_set(gras_dynar_t * const dynar, * @dynar: * @idx: * @object: - * @Returns: malloc_error or no_error * * Set the Nth element of a dynar, expanding the dynar if needed, AND DO * free the previous value at this position. If you don't want to free the * previous content, use gras_dynar_set(). */ -gras_error_t +void gras_dynar_remplace(gras_dynar_t * const dynar, const int idx, const void * const object) { - gras_error_t errcode = no_error; __sanity_check_dynar(dynar); __sanity_check_idx(idx); @@ -301,9 +287,7 @@ gras_dynar_remplace(gras_dynar_t * const dynar, dynar->free(old_object); } - errcode = gras_dynar_set(dynar, idx, object); - - return errcode; + gras_dynar_set(dynar, idx, object); } /** @@ -311,17 +295,15 @@ gras_dynar_remplace(gras_dynar_t * const dynar, * @dynar: * @idx: * @src: What will be feeded to the dynar - * @Returns: malloc_error or no_error * * Set the Nth element of a dynar, expanding the dynar if needed, and * moving the previously existing value and all subsequent ones to one * position right in the dynar. */ -gras_error_t +void gras_dynar_insert_at(gras_dynar_t * const dynar, const int idx, const void * const src) { - gras_error_t errcode = no_error; __sanity_check_dynar(dynar); __sanity_check_idx(idx); @@ -331,7 +313,7 @@ gras_dynar_insert_at(gras_dynar_t * const dynar, const size_t old_used = dynar->used; const size_t new_used = old_used + 1; - TRY(_gras_dynar_expand(dynar, new_used)); + _gras_dynar_expand(dynar, new_used); { const size_t nb_shift = old_used - idx; @@ -348,8 +330,6 @@ gras_dynar_insert_at(gras_dynar_t * const dynar, _gras_dynar_put_elm(dynar, idx, src); dynar->used = new_used; } - - return errcode; } /** @@ -395,15 +375,14 @@ gras_dynar_remove_at(gras_dynar_t * const dynar, * gras_dynar_push: * @dynar: * @src: - * @Returns: malloc_error or no_error * * Add an element at the end of the dynar */ -gras_error_t +void gras_dynar_push(gras_dynar_t * const dynar, const void * const src) { __sanity_check_dynar(dynar); - return gras_dynar_insert_at(dynar, dynar->used, src); + gras_dynar_insert_at(dynar, dynar->used, src); } /** @@ -426,16 +405,15 @@ gras_dynar_pop(gras_dynar_t * const dynar, * gras_dynar_unshift: * @dynar: * @src: - * @Returns: malloc_error or no_error * * Add an element at the begining of the dynar (rather long, Use * gras_dynar_push() when possible) */ -gras_error_t +void gras_dynar_unshift(gras_dynar_t * const dynar, const void * const src) { __sanity_check_dynar(dynar); - return gras_dynar_insert_at(dynar, 0, src); + gras_dynar_insert_at(dynar, 0, src); } /** diff --git a/src/xbt/error.c b/src/xbt/error.c index 6e5e1b846b..af455a84f3 100644 --- a/src/xbt/error.c +++ b/src/xbt/error.c @@ -23,7 +23,6 @@ const char *gras_error_name(gras_error_t errcode) { switch (errcode) { case no_error: return "success"; - case malloc_error: return "malloc"; case mismatch_error: return "mismatch"; case system_error: return "system"; case network_error: return "network"; diff --git a/src/xbt/log.c b/src/xbt/log.c index e054e5541e..eb15e532ef 100644 --- a/src/xbt/log.c +++ b/src/xbt/log.c @@ -9,7 +9,7 @@ under the terms of the license (GNU LGPL) which comes with this package. */ -#include "gros_interface.h" +#include "xbt_interface.h" #include "gras_private.h" #include #include @@ -183,13 +183,13 @@ void gras_log_threshold_set(gras_log_category_t* cat, _set_inherited_thresholds(cat); } -static gras_error_t _gras_log_parse_setting(const char* control_string, - gras_log_setting_t *set) { +static void _gras_log_parse_setting(const char* control_string, + gras_log_setting_t *set) { const char *name, *dot, *eq; set->catname=NULL; if (!*control_string) - return no_error; + return; DEBUG1("Parse log setting '%s'",control_string); control_string += strspn(control_string, " "); @@ -205,7 +205,7 @@ static gras_error_t _gras_log_parse_setting(const char* control_string, if (!strncmp(dot + 1, "thresh", min(eq - dot - 1,strlen("thresh")))) { int i; - char *neweq=(char*)strdup(eq+1); + char *neweq=gras_strdup(eq+1); char *p=neweq-1; while (*(++p) != '\0') { @@ -232,13 +232,11 @@ static gras_error_t _gras_log_parse_setting(const char* control_string, snprintf(buff,min(512,eq - dot - 1),"%s",dot+1); gras_assert1(FALSE,"Unknown setting of the log category: %s",buff); } - if (!(set->catname=(char*)gras_malloc(dot - name+1))) - RAISE_MALLOC; + set->catname=(char*)gras_malloc(dot - name+1); strncpy(set->catname,name,dot-name); set->catname[dot-name]='\0'; /* Just in case */ DEBUG1("This is for cat '%s'", set->catname); - return no_error; } static gras_error_t _gras_log_cat_searchsub(gras_log_category_t *cat,char *name,gras_log_category_t**whereto) { @@ -292,7 +290,6 @@ static void _cleanup_double_spaces(char *s) { /** * gras_log_control_set: * @cs: What to parse - * @Returns: malloc_error or no_error * * Typically passed a command-line argument. The string has the syntax: * @@ -308,7 +305,7 @@ static void _cleanup_double_spaces(char *s) { * This routine may only be called once and that must be before any other * logging command! Typically, this is done from main(). */ -gras_error_t gras_log_control_set(const char* control_string) { +void gras_log_control_set(const char* control_string) { gras_error_t errcode; gras_log_setting_t *set; char *cs; @@ -317,16 +314,14 @@ gras_error_t gras_log_control_set(const char* control_string) { DEBUG1("Parse log settings '%s'",control_string); if (control_string == NULL) - return no_error; + return; if (gras_log_settings == NULL) - TRY(gras_dynar_new(&gras_log_settings,sizeof(gras_log_setting_t*), - _free_setting)); + gras_dynar_new(&gras_log_settings,sizeof(gras_log_setting_t*), + _free_setting); - if (! (set = gras_new(gras_log_setting_t,1)) ) - RAISE_MALLOC; + set = gras_new(gras_log_setting_t,1); + cs=gras_strdup(control_string); - if (!(cs=(char*)strdup(control_string))) - RAISE_MALLOC; _cleanup_double_spaces(cs); while (!done) { @@ -340,23 +335,15 @@ gras_error_t gras_log_control_set(const char* control_string) { p=cs; done = 1; } - errcode = _gras_log_parse_setting(p,set); - if (errcode != no_error) { - gras_free(set); - gras_free(cs); - } + _gras_log_parse_setting(p,set); - TRYCATCH(_gras_log_cat_searchsub(&_GRAS_LOGV(root),set->catname,&cat), - mismatch_error); + errcode = _gras_log_cat_searchsub(&_GRAS_LOGV(root),set->catname,&cat); if (errcode == mismatch_error) { DEBUG0("Store for further application"); DEBUG1("push %p to the settings",(void*)set); - TRY(gras_dynar_push(gras_log_settings,&set)); + gras_dynar_push(gras_log_settings,&set); /* malloc in advance the next slot */ - if (!(set = gras_new(gras_log_setting_t,1))) { - gras_free(cs); - RAISE_MALLOC; - } + set = gras_new(gras_log_setting_t,1); } else { DEBUG0("Apply directly"); gras_free(set->catname); @@ -365,7 +352,6 @@ gras_error_t gras_log_control_set(const char* control_string) { } gras_free(set); gras_free(cs); - return no_error; } void gras_log_appender_set(gras_log_category_t* cat, gras_log_appender_t* app) { diff --git a/src/xbt/module.c b/src/xbt/module.c index 6abd61c3bd..c2c9f85db0 100644 --- a/src/xbt/module.c +++ b/src/xbt/module.c @@ -50,7 +50,7 @@ gras_init_defaultlog(int *argc,char **argv, const char *defaultlog) { found = 1; opt=strchr(argv[i],'='); opt++; - TRYFAIL(gras_log_control_set(opt)); + gras_log_control_set(opt); DEBUG1("Did apply '%s' as log setting",opt); /*remove this from argv*/ for (j=i+1; j<*argc; j++) { @@ -62,7 +62,7 @@ gras_init_defaultlog(int *argc,char **argv, const char *defaultlog) { } } if (!found && defaultlog) { - TRYFAIL(gras_log_control_set(defaultlog)); + gras_log_control_set(defaultlog); } gras_process_init(); /* calls procdata_init, which calls dynar_new */ diff --git a/src/xbt/set.c b/src/xbt/set.c index 8463b7d8c6..974837e57e 100644 --- a/src/xbt/set.c +++ b/src/xbt/set.c @@ -25,18 +25,14 @@ struct gras_set_ { * * Creates a new set. */ -gras_error_t gras_set_new (gras_set_t **dst) { +void gras_set_new (gras_set_t **dst) { gras_set_t *res=gras_new(gras_set_t,1); gras_error_t errcode; - if (!res) - RAISE_MALLOC; - - TRY(gras_dict_new (&(res->dict))); - TRY(gras_dynar_new(&(res->dynar), sizeof(void*),NULL)); + gras_dict_new (&(res->dict)); + gras_dynar_new(&(res->dynar), sizeof(void*),NULL); *dst=res; - return no_error; } /** @@ -66,9 +62,9 @@ void gras_set_free(gras_set_t **set) { * elm->name_len is used as is unless it's <= 0 (in which case it's recomputed); * elm->ID is attributed automatically. */ -gras_error_t gras_set_add (gras_set_t *set, - gras_set_elm_t *elm, - void_f_pvoid_t *free_func) { +void gras_set_add (gras_set_t *set, + gras_set_elm_t *elm, + void_f_pvoid_t *free_func) { gras_error_t errcode; gras_set_elm_t *found_in_dict; @@ -84,24 +80,23 @@ gras_error_t gras_set_add (gras_set_t *set, if (elm == found_in_dict) { DEBUG2("Ignoring request to insert the same element twice (key %s ; id %d)", elm->name, elm->ID); - return no_error; + return; } else { elm->ID=found_in_dict->ID; DEBUG2("Reinsertion of key %s (id %d)", elm->name, elm->ID); - TRY(gras_dict_set_ext(set->dict, elm->name, elm->name_len, elm, free_func)); - TRY(gras_dynar_set(set->dynar, elm->ID, &elm)); - return no_error; + gras_dict_set_ext(set->dict, elm->name, elm->name_len, elm, free_func); + gras_dynar_set(set->dynar, elm->ID, &elm); + return; } - } else if (errcode != mismatch_error) { - return errcode; /* I expected mismatch_error */ + } else { + gras_assert_error(mismatch_error); } elm->ID = gras_dynar_length( set->dynar ); - TRY(gras_dict_set_ext(set->dict, elm->name, elm->name_len, elm, free_func)); - TRY(gras_dynar_set(set->dynar, elm->ID, &elm)); + gras_dict_set_ext(set->dict, elm->name, elm->name_len, elm, free_func); + gras_dynar_set(set->dynar, elm->ID, &elm); DEBUG2("Insertion of key '%s' (id %d)", elm->name, elm->ID); - return no_error; } /** diff --git a/src/xbt/sysdep.c b/src/xbt/sysdep.c index 2ac0871508..2575bf97fb 100644 --- a/src/xbt/sysdep.c +++ b/src/xbt/sysdep.c @@ -21,10 +21,14 @@ GRAS_LOG_NEW_DEFAULT_SUBCATEGORY(sysdep, gros, "System dependency"); ****/ void* gras_malloc (long int bytes) { - return bytes == 0 ? NULL : (void*) malloc ((size_t) bytes); + void *ptr = (bytes == 0 ? NULL : (void*) malloc ((size_t) bytes)); + gras_assert1(ptr, "Malloc of %ld bytes failed",bytes); + return ptr; } void* gras_malloc0 (long int bytes) { - return bytes == 0 ? NULL : (void*) calloc ((size_t) bytes, 1); + void *ptr = (bytes == 0 ? NULL : (void*) calloc ((size_t) bytes, 1)); + gras_assert1(ptr, "Malloc of %ld bytes failed",bytes); + return ptr; } void* gras_realloc (void *memory, long int bytes) { @@ -32,14 +36,20 @@ void* gras_realloc (void *memory, long int bytes) { gras_free(memory); return NULL; } else { - return (void*) realloc (memory, (size_t) bytes); + void *ptr = (void*) realloc (memory, (size_t) bytes); + gras_assert1(ptr, "Realloc of %ld bytes failed",bytes); + return ptr; } } +char* gras_strdup (const char* str) { + char *ret = (char*)strdup(str); + gras_assert0(ret, "String duplication failed"); + return ret; +} void gras_free (void *memory) { - if (memory) { - free (memory); - } + if (memory) + free (memory); } /**** diff --git a/src/xbt/gros_interface.h b/src/xbt/xbt_interface.h similarity index 85% rename from src/xbt/gros_interface.h rename to src/xbt/xbt_interface.h index 4fedcd20f1..efa29e7376 100644 --- a/src/xbt/gros_interface.h +++ b/src/xbt/xbt_interface.h @@ -10,10 +10,10 @@ /* This program is free software; you can redistribute it and/or modify it under the terms of the license (GNU LGPL) which comes with this package. */ -#ifndef GRAS_CORE_INTERFACE_H -#define GRAS_CORE_INTERFACE_H +#ifndef XBT_INTERFACE_H +#define XBT_INTERFACE_H /* Modules definitions */ void gras_log_exit(void); -#endif /* GRAS_CORE_INTERFACE_H */ +#endif /* XBT_INTERFACE_H */ diff --git a/testsuite/gras/datadesc_usage.c b/testsuite/gras/datadesc_usage.c index ea8f45abc4..d22e377b5a 100644 --- a/testsuite/gras/datadesc_usage.c +++ b/testsuite/gras/datadesc_usage.c @@ -118,9 +118,9 @@ gras_error_t test_array(gras_socket_t *sock, int direction) { INFO0("---- Test on fixed array ----"); - TRY(gras_datadesc_array_fixed("fixed int array", - gras_datadesc_by_name("int"), - SIZE, &my_type)); + my_type=gras_datadesc_array_fixed("fixed int array", + gras_datadesc_by_name("int"), + SIZE); TRY(write_read(my_type, &i,&j, sock,direction)); if (direction == READ || direction == RW) { @@ -137,13 +137,12 @@ gras_error_t test_intref(gras_socket_t *sock, int direction) { gras_datadesc_type_t *my_type; int *i,*j; - if (! (i=gras_new(int,1)) ) - RAISE_MALLOC; + i=gras_new(int,1); *i=12345; INFO1("---- Test on a reference to an integer (%p) ----",i); - TRY(gras_datadesc_ref("int*",gras_datadesc_by_name("int"),&my_type)); + my_type = gras_datadesc_ref("int*",gras_datadesc_by_name("int")); TRY(write_read(my_type, &i,&j, sock,direction)); if (direction == READ || direction == RW) { @@ -159,7 +158,7 @@ gras_error_t test_intref(gras_socket_t *sock, int direction) { ***/ gras_error_t test_string(gras_socket_t *sock, int direction) { gras_error_t errcode; - char *i=strdup("Some data"), *j=NULL; + char *i=gras_strdup("Some data"), *j=NULL; int cpt; INFO0("---- Test on string (ref to dynamic array) ----"); @@ -190,23 +189,21 @@ gras_error_t test_homostruct(gras_socket_t *sock, int direction) { INFO0("---- Test on homogeneous structure ----"); /* create descriptor */ - TRY(gras_datadesc_struct("homostruct",&my_type)); - TRY(gras_datadesc_struct_append(my_type,"a", - gras_datadesc_by_name("signed int"))); - TRY(gras_datadesc_struct_append(my_type,"b", - gras_datadesc_by_name("int"))); - TRY(gras_datadesc_struct_append(my_type,"c", - gras_datadesc_by_name("int"))); - TRY(gras_datadesc_struct_append(my_type,"d", - gras_datadesc_by_name("int"))); + my_type=gras_datadesc_struct("homostruct"); + gras_datadesc_struct_append(my_type,"a", + gras_datadesc_by_name("signed int")); + gras_datadesc_struct_append(my_type,"b", + gras_datadesc_by_name("int")); + gras_datadesc_struct_append(my_type,"c", + gras_datadesc_by_name("int")); + gras_datadesc_struct_append(my_type,"d", + gras_datadesc_by_name("int")); gras_datadesc_struct_close(my_type); - TRY(gras_datadesc_ref("homostruct*", - gras_datadesc_by_name("homostruct"), - &my_type)); + my_type=gras_datadesc_ref("homostruct*", + gras_datadesc_by_name("homostruct")); /* init a value, exchange it and check its validity*/ - if (! (i=gras_new(homostruct,1)) ) - RAISE_MALLOC; + i=gras_new(homostruct,1); i->a = 2235; i->b = 433425; i->c = -23423; i->d = -235235; @@ -238,22 +235,21 @@ gras_error_t test_hetestruct(gras_socket_t *sock, int direction) { INFO0("---- Test on heterogeneous structure ----"); /* create descriptor */ - TRY(gras_datadesc_struct("hetestruct",&my_type)); - TRY(gras_datadesc_struct_append(my_type,"c1", - gras_datadesc_by_name("unsigned char"))); - TRY(gras_datadesc_struct_append(my_type,"l1", - gras_datadesc_by_name("unsigned long int"))); - TRY(gras_datadesc_struct_append(my_type,"c2", - gras_datadesc_by_name("unsigned char"))); - TRY(gras_datadesc_struct_append(my_type,"l2", - gras_datadesc_by_name("unsigned long int"))); + my_type=gras_datadesc_struct("hetestruct"); + gras_datadesc_struct_append(my_type,"c1", + gras_datadesc_by_name("unsigned char")); + gras_datadesc_struct_append(my_type,"l1", + gras_datadesc_by_name("unsigned long int")); + gras_datadesc_struct_append(my_type,"c2", + gras_datadesc_by_name("unsigned char")); + gras_datadesc_struct_append(my_type,"l2", + gras_datadesc_by_name("unsigned long int")); gras_datadesc_struct_close(my_type); - TRY(gras_datadesc_ref("hetestruct*", gras_datadesc_by_name("hetestruct"), - &my_type)); + my_type=gras_datadesc_ref("hetestruct*", gras_datadesc_by_name("hetestruct")); + /* init a value, exchange it and check its validity*/ - if (! (i=gras_new(hetestruct,1)) ) - RAISE_MALLOC; + i=gras_new(hetestruct,1); i->c1 = 's'; i->l1 = 123455; i->c2 = 'e'; i->l2 = 774531; @@ -283,19 +279,17 @@ gras_error_t test_nestedstruct(gras_socket_t *sock, int direction) { INFO0("---- Test on nested structures ----"); /* create descriptor */ - TRY(gras_datadesc_struct("nestedstruct",&my_type)); + my_type=gras_datadesc_struct("nestedstruct"); - TRY(gras_datadesc_struct_append(my_type,"hete", - gras_datadesc_by_name("hetestruct"))); - TRY(gras_datadesc_struct_append(my_type,"homo", - gras_datadesc_by_name("homostruct"))); + gras_datadesc_struct_append(my_type,"hete", + gras_datadesc_by_name("hetestruct")); + gras_datadesc_struct_append(my_type,"homo", + gras_datadesc_by_name("homostruct")); gras_datadesc_struct_close(my_type); - TRY(gras_datadesc_ref("nestedstruct*", gras_datadesc_by_name("nestedstruct"), - &my_type)); + my_type=gras_datadesc_ref("nestedstruct*", gras_datadesc_by_name("nestedstruct")); /* init a value, exchange it and check its validity*/ - if (! (i=gras_new(nestedstruct,1)) ) - RAISE_MALLOC; + i=gras_new(nestedstruct,1); i->homo.a = 235231; i->homo.b = -124151; i->homo.c = 211551; i->homo.d = -664222; i->hete.c1 = 's'; i->hete.l1 = 123455; @@ -334,11 +328,11 @@ gras_error_t declare_chained_list_type(void) { gras_error_t errcode; gras_datadesc_type_t *my_type,*ref_my_type; - TRY(gras_datadesc_struct("chained_list_t",&my_type)); - TRY(gras_datadesc_ref("chained_list_t*",my_type,&ref_my_type)); + my_type=gras_datadesc_struct("chained_list_t"); + ref_my_type=gras_datadesc_ref("chained_list_t*",my_type); - TRY(gras_datadesc_struct_append(my_type,"v", gras_datadesc_by_name("int"))); - TRY(gras_datadesc_struct_append(my_type,"l", ref_my_type)); + gras_datadesc_struct_append(my_type,"v", gras_datadesc_by_name("int")); + gras_datadesc_struct_append(my_type,"l", ref_my_type); gras_datadesc_struct_close(my_type); return no_error; @@ -536,12 +530,10 @@ gras_error_t test_clause(gras_socket_t *sock, int direction) { INFO0("---- Test on struct containing dynamic array and its size (cbps test) ----"); /* create and fill the struct */ - if (! (i=gras_new(Clause,1)) ) - RAISE_MALLOC; + i=gras_new(Clause,1); i->num_lits = 5432; - if (! (i->literals = gras_new(int, i->num_lits)) ) - RAISE_MALLOC; + i->literals = gras_new(int, i->num_lits); for (cpt=0; cptnum_lits; cpt++) i->literals[cpt] = cpt * cpt - ((cpt * cpt) / 2); DEBUG3("created data=%p (within %p @%p)",&(i->num_lits),i,&i); @@ -551,7 +543,7 @@ gras_error_t test_clause(gras_socket_t *sock, int direction) { ddt = gras_datadesc_by_symbol(s_clause); /* gras_datadesc_type_dump(ddt); */ - TRYFAIL(gras_datadesc_ref("Clause*",ddt,&ddt)); + ddt=gras_datadesc_ref("Clause*",ddt); TRY(write_read(ddt, &i,&j, sock,direction)); if (direction == READ || direction == RW) { diff --git a/testsuite/xbt/config_usage.c b/testsuite/xbt/config_usage.c index d0c54883c6..f4ff054c69 100644 --- a/testsuite/xbt/config_usage.c +++ b/testsuite/xbt/config_usage.c @@ -13,7 +13,7 @@ gras_cfg_t *make_set(){ gras_cfg_t *set=NULL; gras_error_t errcode; - TRYFAIL(gras_cfg_new(&set)); + gras_cfg_new(&set); TRYFAIL(gras_cfg_register_str(set,"speed:1_to_2_int")); TRYFAIL(gras_cfg_register_str(set,"hostname:1_to_1_string")); TRYFAIL(gras_cfg_register_str(set,"user:1_to_10_string")); diff --git a/testsuite/xbt/dict_crash.c b/testsuite/xbt/dict_crash.c index 5a3ddef4ab..124f3ee464 100644 --- a/testsuite/xbt/dict_crash.c +++ b/testsuite/xbt/dict_crash.c @@ -64,7 +64,7 @@ int main(int argc,char **argv) { printf(" (a point is a test)\n"); for (i=0;i<20;i++) { - TRYFAIL(gras_dict_new(&head)); + gras_dict_new(&head); if (i%10) printf("."); else printf("%d",i/10); fflush(stdout); nb=0; for (j=0;j<1000;j++) { @@ -77,7 +77,7 @@ int main(int argc,char **argv) { key[k]=rand() % ('z' - 'a') + 'a'; key[k]='\0'; /* printf("[%d %s]\n",j,key); */ - TRYFAIL(gras_dict_set(head,key,key,&free)); + gras_dict_set(head,key,key,&free); } nb=0; /* gras_dict_dump(head,(void (*)(void*))&printf); */ @@ -91,7 +91,7 @@ int main(int argc,char **argv) { } - TRYFAIL(gras_dict_new(&head)); + gras_dict_new(&head); printf("\n Fill 20 000 elements, with keys being the number of element\n"); printf(" (a point is 1 000 elements)\n"); for (j=0;jname=strdup(name); + elm->name=gras_strdup(name); elm->name_len=0; - elm->data=strdup(data); + elm->data=gras_strdup(data); printf(" - Add %s ",name); if (strcmp(name,data)) { printf("(->%s)",data); } printf("\n"); - errcode=gras_set_add(set, - (gras_set_elm_t*)elm, - &my_elem_free); - return errcode; + gras_set_add(set, (gras_set_elm_t*)elm, + &my_elem_free); } -static gras_error_t debuged_add(gras_set_t *set, - const char *name) { - return debuged_add_with_data(set, name, name); +static void debuged_add(gras_set_t *set, + const char *name) { + debuged_add_with_data(set, name, name); } -static gras_error_t fill(gras_set_t **set) { - gras_error_t errcode; +static void fill(gras_set_t **set) { printf("\n Fill in the data set\n"); - TRY(gras_set_new(set)); - TRY(debuged_add(*set,"12")); - TRY(debuged_add(*set,"12a")); - TRY(debuged_add(*set,"12b")); - TRY(debuged_add(*set,"123")); - TRY(debuged_add(*set,"123456")); + gras_set_new(set); + debuged_add(*set,"12"); + debuged_add(*set,"12a"); + debuged_add(*set,"12b"); + debuged_add(*set,"123"); + debuged_add(*set,"123456"); /* Child becomes child of what to add */ - TRY(debuged_add(*set,"1234")); + debuged_add(*set,"1234"); /* Need of common ancestor */ - TRY(debuged_add(*set,"123457")); - - return no_error; + debuged_add(*set,"123457"); } static gras_error_t search_name(gras_set_t *head,const char*key) { @@ -172,30 +166,30 @@ int main(int argc,char **argv) { printf(" Traverse the empty set\n"); TRYFAIL(traverse(set)); - TRYFAIL(fill(&set)); + fill(&set); printf(" Free the data set\n"); gras_set_free(&set); printf(" Free the data set again\n"); gras_set_free(&set); - TRYFAIL(fill(&set)); + fill(&set); printf(" - Change some values\n"); printf(" - Change 123 to 'Changed 123'\n"); - TRYFAIL(debuged_add_with_data(set,"123","Changed 123")); + debuged_add_with_data(set,"123","Changed 123"); printf(" - Change 123 back to '123'\n"); - TRYFAIL(debuged_add_with_data(set,"123","123")); + debuged_add_with_data(set,"123","123"); printf(" - Change 12a to 'Dummy 12a'\n"); - TRYFAIL(debuged_add_with_data(set,"12a","Dummy 12a")); + debuged_add_with_data(set,"12a","Dummy 12a"); printf(" - Change 12a to '12a'\n"); - TRYFAIL(debuged_add_with_data(set,"12a","12a")); + debuged_add_with_data(set,"12a","12a"); /* gras_dict_dump(head,(void (*)(void*))&printf); */ printf(" - Traverse the resulting data set\n"); TRYFAIL(traverse(set)); printf(" - Retrive values\n"); - TRYFAIL(gras_set_get_by_name(set,"123",(gras_set_elm_t**)&elm)); + gras_set_get_by_name(set,"123",(gras_set_elm_t**)&elm); assert(elm); TRYFAIL(strcmp("123",elm->data));