150 {
 151         struct symbol *type;
 152         struct expression *assign;
 153 
 154         type = get_type(left);
 155         if (!type)
 156                 return;
 157         if (type->type == SYM_PTR) {
 158                 left = deref_expression(left);
 159                 if (right)
 160                         right = deref_expression(right);
 161                 else
 162                         right = unknown_value_expression(left);
 163                 assign = assign_expression(left, '=', right);
 164                 split_fake_expr(assign);
 165                 return;
 166         }
 167         if (type->type != SYM_BASETYPE)
 168                 return;
 169         right = strip_expr(right);
 170         if (!right)

 171                 right = unknown_value_expression(left);
 172         assign = assign_expression(left, '=', right);
 173         split_fake_expr(assign);
 174 }
 175 
 176 static void set_inner_struct_members(int mode, struct expression *faked, struct expression *left, struct expression *right, struct symbol *member)
 177 {
 178         struct expression *left_member;
 179         struct expression *right_member = NULL;  /* silence GCC */
 180         struct expression *assign;
 181         struct symbol *base = get_real_base_type(member);
 182         struct symbol *tmp;
 183 
 184         if (member->ident) {
 185                 left = member_expression(left, '.', member->ident);
 186                 if (mode != COPY_MEMSET && right)
 187                         right = member_expression(right, '.', member->ident);
 188         }
 189 
 190         FOR_EACH_PTR(base->symbol_list, tmp) {

 387                 return;
 388         if (param != -1)
 389                 return;
 390         param = atoi(key);
 391         offset = atoi(value);
 392 
 393         arg = get_argument_from_call_expr(call->args, param);
 394         if (!arg)
 395                 return;
 396 
 397         copy_containter_states(expr->left, arg, -offset);
 398 }
 399 
 400 void __fake_struct_member_assignments(struct expression *expr)
 401 {
 402         struct symbol *left_type;
 403 
 404         if (expr->op != '=')
 405                 return;
 406 
 407         if (is_zero(expr->right))
 408                 return;
 409 
 410         left_type = get_type(expr->left);
 411         if (!left_type ||
 412             (left_type->type != SYM_PTR &&
 413              left_type->type != SYM_STRUCT))
 414                 return;
 415 
 416         if (handle_param_offsets(expr))
 417                 return;
 418 
 419         if (returns_zeroed_mem(expr->right))
 420                 __struct_members_copy(COPY_MEMSET, expr, expr->left, zero_expr());
 421         else
 422                 __struct_members_copy(COPY_NORMAL, expr, expr->left, expr->right);
 423 }
 424 
 425 static void match_memset(const char *fn, struct expression *expr, void *_size_arg)
 426 {
 427         struct expression *buf;

 150 {
 151         struct symbol *type;
 152         struct expression *assign;
 153 
 154         type = get_type(left);
 155         if (!type)
 156                 return;
 157         if (type->type == SYM_PTR) {
 158                 left = deref_expression(left);
 159                 if (right)
 160                         right = deref_expression(right);
 161                 else
 162                         right = unknown_value_expression(left);
 163                 assign = assign_expression(left, '=', right);
 164                 split_fake_expr(assign);
 165                 return;
 166         }
 167         if (type->type != SYM_BASETYPE)
 168                 return;
 169         right = strip_expr(right);
 170         type = get_type(right);
 171         if (!right || !type || type->type == SYM_ARRAY)
 172                 right = unknown_value_expression(left);
 173         assign = assign_expression(left, '=', right);
 174         split_fake_expr(assign);
 175 }
 176 
 177 static void set_inner_struct_members(int mode, struct expression *faked, struct expression *left, struct expression *right, struct symbol *member)
 178 {
 179         struct expression *left_member;
 180         struct expression *right_member = NULL;  /* silence GCC */
 181         struct expression *assign;
 182         struct symbol *base = get_real_base_type(member);
 183         struct symbol *tmp;
 184 
 185         if (member->ident) {
 186                 left = member_expression(left, '.', member->ident);
 187                 if (mode != COPY_MEMSET && right)
 188                         right = member_expression(right, '.', member->ident);
 189         }
 190 
 191         FOR_EACH_PTR(base->symbol_list, tmp) {

 388                 return;
 389         if (param != -1)
 390                 return;
 391         param = atoi(key);
 392         offset = atoi(value);
 393 
 394         arg = get_argument_from_call_expr(call->args, param);
 395         if (!arg)
 396                 return;
 397 
 398         copy_containter_states(expr->left, arg, -offset);
 399 }
 400 
 401 void __fake_struct_member_assignments(struct expression *expr)
 402 {
 403         struct symbol *left_type;
 404 
 405         if (expr->op != '=')
 406                 return;
 407 
 408         if (expr_is_zero(expr->right))
 409                 return;
 410 
 411         left_type = get_type(expr->left);
 412         if (!left_type ||
 413             (left_type->type != SYM_PTR &&
 414              left_type->type != SYM_STRUCT))
 415                 return;
 416 
 417         if (handle_param_offsets(expr))
 418                 return;
 419 
 420         if (returns_zeroed_mem(expr->right))
 421                 __struct_members_copy(COPY_MEMSET, expr, expr->left, zero_expr());
 422         else
 423                 __struct_members_copy(COPY_NORMAL, expr, expr->left, expr->right);
 424 }
 425 
 426 static void match_memset(const char *fn, struct expression *expr, void *_size_arg)
 427 {
 428         struct expression *buf;