Ignore:
Timestamp:
Jan 28, 2007, 7:04:41 PM (12 years ago)
Author:
bruno
Message:
  • Fix mindi install messages (reported by Andree Leidenfrost)
  • remove paranoid_free/free for mr_free
  • mr_asprintf used everywhere
  • mr_malloc used everywhere
File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/stable/mondo/src/common/newt-specific.c

    r1075 r1080  
    1919
    2020#include "my-stuff.h"
     21#include "mr_mem.h"
    2122#include "mondostructures.h"
    2223#include "newt-specific.h"
     
    120121        int i;
    121122
    122          tmp = malloc(MAX_NEWT_COMMENT_LEN);
     123         tmp = mr_malloc(MAX_NEWT_COMMENT_LEN);
    123124         assert_string_is_neither_NULL_nor_zerolength(prompt);
    124125
     
    138139                }
    139140                if (strstr("yesYES", tmp)) {
    140                     paranoid_free(tmp);
     141                    mr_free(tmp);
    141142                    return (TRUE);
    142143                } else if (strstr("NOno", tmp)) {
    143                     paranoid_free(tmp);
     144                    mr_free(tmp);
    144145                    return (FALSE);
    145146                } else {
     
    150151            }
    151152        } else {
    152             paranoid_free(tmp);
     153            mr_free(tmp);
    153154            return (popup_with_buttons(prompt, "Yes", "No"));
    154155        }
     
    168169        int i;
    169170
    170         tmp = malloc(MAX_NEWT_COMMENT_LEN);
     171        tmp = mr_malloc(MAX_NEWT_COMMENT_LEN);
    171172        assert_string_is_neither_NULL_nor_zerolength(prompt);
    172173        if (g_text_mode) {
     
    184185            }
    185186            if (strstr("okOKOkYESyes", tmp)) {
    186                 paranoid_free(tmp);
     187                mr_free(tmp);
    187188                return (TRUE);
    188189            } else {
    189                 paranoid_free(tmp);
     190                mr_free(tmp);
    190191                return (FALSE);
    191192            }
    192193        } else {
    193             paranoid_free(tmp);
     194            mr_free(tmp);
    194195            return (popup_with_buttons(prompt, " Okay ", "Cancel"));
    195196        }
     
    259260asprintf(&tmp,"kill `ps %s | grep \" %s \" | awk '{print %s;}' | grep -vx \"\\?\"`", ps_options, str , ps_proc_id);
    260261run_program_and_log_output(tmp, TRUE);
    261 paranoid_free(tmp);
     262mr_free(tmp);
    262263}
    263264
     
    281282
    282283        malloc_string(command);
    283         tmp = malloc(MAX_NEWT_COMMENT_LEN);
     284        tmp = mr_malloc(MAX_NEWT_COMMENT_LEN);
    284285        set_signals(FALSE);     // link to external func
    285286        g_exiting = TRUE;
     
    289290            log_msg(2, "mastermind %d is exiting", (int) getpid());
    290291            kill(g_main_pid, SIGTERM);
    291             paranoid_free(tmp);
     292            mr_free(tmp);
    292293            finish(1);
    293294        }
     
    297298                log_msg(2, "non-m/m %d is exiting", (int) getpid());
    298299                kill(g_main_pid, SIGTERM);
    299                 paranoid_free(tmp);
     300                mr_free(tmp);
    300301                finish(1);
    301302            }
     
    305306        if (already_exiting) {
    306307            log_msg(3, "...I'm already exiting. Give me time, Julian!");
    307             paranoid_free(tmp);
     308            mr_free(tmp);
    308309            finish(1);
    309310        }
     
    360361            log_msg(3, "FYI - g_main_pid is blank");
    361362        }
    362         paranoid_free(tmp);
    363         paranoid_free(command);
     363        mr_free(tmp);
     364        mr_free(command);
    364365        finish(254);
    365366    }
     
    445446
    446447        if (!does_file_exist(filename)) {
    447             paranoid_free(command);
    448             paranoid_free(tmp);
     448            mr_free(command);
     449            mr_free(tmp);
    449450            return;
    450451        }
     
    478479        }
    479480        refresh_log_screen();
    480         paranoid_free(command);
    481         paranoid_free(tmp);
     481        mr_free(command);
     482        mr_free(tmp);
    482483    }
    483484
     
    533534            refresh_log_screen();
    534535        }
    535         paranoid_free(output);
     536        mr_free(output);
    536537    }
    537538
     
    606607        }
    607608        update_evalcall_form(0);
    608         paranoid_free(tmp);
    609         paranoid_free(title);
     609        mr_free(tmp);
     610        mr_free(title);
    610611    }
    611612
     
    680681        }
    681682        update_progress_form_full(blurb1, blurb2, blurb3);
    682         paranoid_free(b1c);
    683         paranoid_free(blurb1);
    684         paranoid_free(blurb2);
    685         paranoid_free(blurb3);
     683        mr_free(b1c);
     684        mr_free(blurb1);
     685        mr_free(blurb2);
     686        mr_free(blurb3);
    686687    }
    687688
     
    733734        char *original_contents;
    734735
    735         blurb = malloc(MAX_NEWT_COMMENT_LEN);
    736         original_contents = malloc(MAX_NEWT_COMMENT_LEN);
     736        blurb = mr_malloc(MAX_NEWT_COMMENT_LEN);
     737        original_contents = mr_malloc(MAX_NEWT_COMMENT_LEN);
    737738        assert_string_is_neither_NULL_nor_zerolength(title);
    738739        assert(b != NULL);
     
    746747            if (output[strlen(output) - 1] == '\n')
    747748                output[strlen(output) - 1] = '\0';
    748             paranoid_free(blurb);
    749             paranoid_free(original_contents);
     749            mr_free(blurb);
     750            mr_free(original_contents);
    750751            return (TRUE);
    751752        }
     
    778779        if (b_res == b_2) {
    779780            strcpy(output, original_contents);
    780             paranoid_free(blurb);
    781             paranoid_free(original_contents);
     781            mr_free(blurb);
     782            mr_free(original_contents);
    782783            return (FALSE);
    783784        } else {
    784             paranoid_free(blurb);
    785             paranoid_free(original_contents);
     785            mr_free(blurb);
     786            mr_free(original_contents);
    786787            return (TRUE);
    787788        }
     
    808809        newtComponent text;
    809810
    810         prompt = malloc(MAX_NEWT_COMMENT_LEN);
    811         tmp = malloc(MAX_NEWT_COMMENT_LEN);
     811        prompt = mr_malloc(MAX_NEWT_COMMENT_LEN);
     812        tmp = mr_malloc(MAX_NEWT_COMMENT_LEN);
    812813        assert_string_is_neither_NULL_nor_zerolength(p);
    813814        assert(button1 != NULL);
     
    826827            }
    827828            if (!strcmp(tmp, button1)) {
    828                 paranoid_free(tmp);
    829                 paranoid_free(prompt);
     829                mr_free(tmp);
     830                mr_free(prompt);
    830831                return (TRUE);
    831832            } else {
    832                 paranoid_free(tmp);
    833                 paranoid_free(prompt);
     833                mr_free(tmp);
     834                mr_free(prompt);
    834835                return (FALSE);
    835836            }
     
    862863        newtPopWindow();
    863864        if (b_res == b_1) {
    864             paranoid_free(tmp);
    865             paranoid_free(prompt);
     865            mr_free(tmp);
     866            mr_free(prompt);
    866867            return (TRUE);
    867868        } else {
    868             paranoid_free(tmp);
    869             paranoid_free(prompt);
     869            mr_free(tmp);
     870            mr_free(prompt);
    870871            return (FALSE);
    871872        }
     
    927928
    928929        err_log_lines =
    929             (char **) malloc(sizeof(char *) * g_noof_log_lines);
     930            (char **) mr_malloc(sizeof(char *) * g_noof_log_lines);
    930931        if (!err_log_lines) {
    931932            fatal_error("Out of memory");
     
    933934
    934935        for (i = 0; i < g_noof_log_lines; i++) {
    935             err_log_lines[i] = (char *) malloc(MAX_NEWT_COMMENT_LEN);
     936            err_log_lines[i] = (char *) mr_malloc(MAX_NEWT_COMMENT_LEN);
    936937            if (!err_log_lines[i]) {
    937938                fatal_error("Out of memory");
     
    10431044            newtRefresh();
    10441045        }
    1045         paranoid_free(timeline_str);
    1046         paranoid_free(pcline_str);
    1047         paranoid_free(taskprogress);
     1046        mr_free(timeline_str);
     1047        mr_free(pcline_str);
     1048        mr_free(taskprogress);
    10481049    }
    10491050
     
    11041105
    11051106//  log_msg(1, "'%s' '%s' '%s'", blurb1, blurb2, blurb3);
    1106         percentline_str = malloc(MAX_NEWT_COMMENT_LEN);
    1107         timeline_str = malloc(MAX_NEWT_COMMENT_LEN);
    1108         taskprogress = malloc(MAX_NEWT_COMMENT_LEN);
     1107        percentline_str = mr_malloc(MAX_NEWT_COMMENT_LEN);
     1108        timeline_str = mr_malloc(MAX_NEWT_COMMENT_LEN);
     1109        taskprogress = mr_malloc(MAX_NEWT_COMMENT_LEN);
    11091110        malloc_string(tmp);
    11101111        if (!g_text_mode) {
     
    11901191            newtRefresh();
    11911192        }
    1192         paranoid_free(percentline_str);
    1193         paranoid_free(timeline_str);
    1194         paranoid_free(taskprogress);
    1195         paranoid_free(tmp);
     1193        mr_free(percentline_str);
     1194        mr_free(timeline_str);
     1195        mr_free(taskprogress);
     1196        mr_free(tmp);
    11961197    }
    11971198
     
    12461247        newtComponent myForm;
    12471248
    1248         title_sz = malloc(MAX_NEWT_COMMENT_LEN);
    1249         minimsg_sz = malloc(MAX_NEWT_COMMENT_LEN);
    1250         outstr = malloc(MAX_NEWT_COMMENT_LEN);
     1249        title_sz = mr_malloc(MAX_NEWT_COMMENT_LEN);
     1250        minimsg_sz = mr_malloc(MAX_NEWT_COMMENT_LEN);
     1251        outstr = mr_malloc(MAX_NEWT_COMMENT_LEN);
    12511252        if (g_text_mode) {
    12521253            for (backup_type = none; backup_type == none;) {
     
    12651266                }
    12661267            }
    1267             paranoid_free(title_sz);
    1268             paranoid_free(minimsg_sz);
    1269             paranoid_free(outstr);
     1268            mr_free(title_sz);
     1269            mr_free(minimsg_sz);
     1270            mr_free(outstr);
    12701271            return (backup_type);
    12711272        }
     
    13151316        }
    13161317        newtPopHelpLine();
    1317         paranoid_free(title_sz);
    1318         paranoid_free(minimsg_sz);
    1319         paranoid_free(outstr);
     1318        mr_free(title_sz);
     1319        mr_free(minimsg_sz);
     1320        mr_free(outstr);
    13201321        return (output);
    13211322    }
     
    14031404            log_msg(2, "Can't open %s; therefore, cannot popup list",
    14041405                    source_file);
    1405             paranoid_free(tmp);
     1406            mr_free(tmp);
    14061407            return (1);
    14071408        }
     
    14371438        if (filelist->entries >= ARBITRARY_MAXIMUM) {
    14381439            log_to_screen("Arbitrary limits suck, man!");
    1439             paranoid_free(tmp);
     1440            mr_free(tmp);
    14401441            return (1);
    14411442        }
     
    14651466            }
    14661467        }
    1467         paranoid_free(tmp);
     1468        mr_free(tmp);
    14681469        iamhere("leaving");
    14691470        return (0);
     
    14981499        tmp[98] = '\0';
    14991500        strcpy(comment, tmp);
    1500         paranoid_free(tmp);
     1501        mr_free(tmp);
    15011502        iamhere("leaving");
    15021503        return (comment);
     
    15391540        struct s_filelist *filelist;
    15401541        malloc_string(reason);
    1541         tmp = malloc(5000);
     1542        tmp = mr_malloc(5000);
    15421543        malloc_string(differ_sz);
    15431544        assert_string_is_neither_NULL_nor_zerolength(source_file);
     
    15511552        if (lng < 1) {
    15521553            log_msg(2, "No lines in file. Therefore, no popup list.");
    1553             paranoid_free(reason);
     1554            mr_free(reason);
    15541555            goto free_to_go;
    15551556        } else if (lng >= ARBITRARY_MAXIMUM) {
     
    15581559        }
    15591560
    1560         filelist = (struct s_filelist *) malloc(sizeof(struct s_filelist));
     1561        filelist = (struct s_filelist *) mr_malloc(sizeof(struct s_filelist));
    15611562        fileListbox =
    15621563            newtListbox(2, 2, 12, NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT);
     
    15661567            log_msg(2, "Can't open %s; therefore, cannot popup list",
    15671568                    source_file);
    1568             paranoid_free(reason);
     1569            mr_free(reason);
    15691570            return;
    15701571        }
     
    16181619        newtPopHelpLine();
    16191620      free_to_go:
    1620         paranoid_free(reason);
    1621         paranoid_free(tmp);
    1622         paranoid_free(differ_sz);
     1621        mr_free(reason);
     1622        mr_free(tmp);
     1623        mr_free(differ_sz);
    16231624        return;
    16241625    }
Note: See TracChangeset for help on using the changeset viewer.