home *** CD-ROM | disk | FTP | other *** search
/ Chip 2001 October / Chip_2001-10_cd1.bin / zkuste / delphi / nastroje / d23456 / NSIS.EXE / Source / build.cpp next >
C/C++ Source or Header  |  2001-05-30  |  32KB  |  1,151 lines
  1. #include <windows.h>
  2. #include <stdio.h>
  3. #include "zlib/zlib.h"
  4. #include "exehead/config.h"
  5. #include "exehead/fileform.h"
  6.  
  7. #include "exedata.h"
  8.  
  9. #include "build.h"
  10. #include "util.h"
  11.  
  12. void CEXEBuild::define(char *p) 
  13. { 
  14.   definedlist.add(p,0); 
  15. }
  16.  
  17.  
  18. CEXEBuild::~CEXEBuild()
  19. {
  20.   free(header_data_new);
  21. }
  22.  
  23. CEXEBuild::CEXEBuild()
  24. {
  25.   has_called_write_output=0;
  26.  
  27.   ns_func.add("",0); // make sure offset 0 is special on these (i.e. never used by a label)
  28.   ns_label.add("",0);
  29.  
  30.   header_data_new=(unsigned char*)malloc(exeheader_size);
  31.   exeheader_size_new=exeheader_size;
  32.  
  33.   if (!header_data_new) 
  34.   {
  35.     printf("Internal compiler error #12345: malloc(%d) failed\n",exeheader_size_new);
  36.     extern void quit(); quit();
  37.   }
  38.  
  39.   memcpy(header_data_new,header_data,exeheader_size);
  40.   enabled_bitmap_offset = find_data_offset((char*)header_data_new,exeheader_size_new,(char*)bitmap1_data,BMP_HDRSKIP,sizeof(bitmap1_data));
  41.   disabled_bitmap_offset = find_data_offset((char*)header_data_new,exeheader_size_new,(char*)bitmap2_data,BMP_HDRSKIP,sizeof(bitmap2_data));
  42.   icon_offset = find_data_offset((char*)header_data_new,exeheader_size_new,(char*)icon_data,ICO_HDRSKIP,sizeof(icon_data));
  43.  
  44.   if (enabled_bitmap_offset < 0 || disabled_bitmap_offset < 0 || icon_offset < 0)
  45.   {
  46.     printf("Internal compiler error #12345: icons missing\n"); 
  47.     extern void quit(); quit();
  48.   }
  49.  
  50.   strcpy(cur_out_path,"$INSTDIR");
  51.  
  52. #ifdef NSIS_CONFIG_LOG
  53.   definedlist.add("NSIS_CONFIG_LOG",0);
  54. #endif
  55. #ifdef NSIS_CONFIG_UNINSTALL_SUPPORT
  56.   definedlist.add("NSIS_CONFIG_UNINSTALL_SUPPORT",0);
  57. #endif
  58. #ifdef NSIS_SUPPORT_NETSCAPEPLUGINS
  59.   definedlist.add("NSIS_SUPPORT_NETSCAPEPLUGINS",0);
  60. #endif
  61. #ifdef NSIS_SUPPORT_ACTIVEXREG
  62.   definedlist.add("NSIS_SUPPORT_ACTIVEXREG",0);
  63. #endif
  64. #ifdef NSIS_SUPPORT_BGBG
  65.   definedlist.add("NSIS_SUPPORT_BGBG",0);
  66. #endif
  67.  
  68.   db_opt_save=db_comp_save=db_full_size=db_opt_save_u=db_comp_save_u=db_full_size_u=0;
  69.  
  70.   cur_entries=&build_entries;
  71.   cur_datablock=&build_datablock;
  72.   cur_functions=&build_functions;
  73.   cur_labels=&build_labels;
  74.  
  75.   build_cursection_isfunc=0;
  76.   build_cursection=NULL;
  77.   // init public data.
  78.   build_packname[0]=build_packcmd[0]=build_output_filename[0]=0;
  79.  
  80.   build_overwrite=0;
  81.   build_compress=1;
  82.   build_crcchk=1; 
  83.   build_datesave=1;
  84.   build_optimize_datablock=1;
  85.  
  86.   memset(&build_header,-1,sizeof(build_header));
  87.  
  88.   build_header.install_reg_rootkey=0;
  89.   build_header.no_custom_instmode_flag=0;
  90.   build_header.num_sections=0;
  91.   build_header.num_entries=0;
  92.   build_header.silent_install=0;
  93.   build_header.auto_close=0;
  94.   build_header.show_details=0;
  95.   build_header.no_show_dirpage=0;
  96.   build_header.lb_bg=RGB(0,0,0);
  97.   build_header.lb_fg=RGB(0,255,0);
  98.   uninstall_mode=0;
  99.   uninstall_size_full=0;
  100.   uninstall_size=-1;
  101.   
  102.   memset(&build_uninst,-1,sizeof(build_uninst));
  103.   build_uninst.lb_bg=RGB(0,0,0);
  104.   build_uninst.lb_fg=RGB(0,255,0);
  105.   build_uninst.num_entries=0;
  106.   build_uninst.code[0]=build_uninst.code[1]=0;
  107.  
  108.   memcpy(m_unicon_data,unicon_data,sizeof(m_unicon_data));
  109. }
  110.  
  111. int CEXEBuild::getcurdbsize() { return cur_datablock->getlen(); }
  112.  
  113. int CEXEBuild::add_string(char *string) // returns offset in stringblock
  114. {
  115.   if (uninstall_mode) return add_string_uninst(string);
  116.   return add_string_main(string);
  117. }
  118. int CEXEBuild::add_string_main(char *string) // returns offset (in string block)
  119. {
  120.   if (!*string) return -1;
  121.   if (strstr(string,"$WAVISDIR") || strstr(string,"$WADSPDIR"))
  122.     warning("$WAVISDIR and $WADSPDIR are no longer supported.\n");
  123.   return build_strlist.add(string,2);
  124. }
  125.  
  126. int CEXEBuild::add_string_uninst(char *string) // returns offset (in string block)
  127. {
  128.   if (!*string) return -1;
  129.   if (strstr(string,"$WAVISDIR") || strstr(string,"$WADSPDIR"))
  130.     warning("$WAVISDIR and $WADSPDIR are no longer supported.\n");
  131.   return ubuild_strlist.add(string,2);
  132. }
  133.  
  134. // what it does is, when you pass it the offset of the last item added, it will determine if 
  135. // that data is already present in the datablock, and if so, reference it instead (and shorten
  136. // the datablock as necessary). Reduces overhead if you want to add files to a couple places.
  137. // Woo, an optimizing installer generator, now we're styling.
  138.  
  139. int CEXEBuild::datablock_optimize(int start_offset)
  140. {
  141.   int this_len = cur_datablock->getlen()-start_offset;
  142.   int pos=0;
  143.  
  144.   if (!build_optimize_datablock) return start_offset;
  145.  
  146.   char *db=(char*)cur_datablock->get();
  147.   int first_int=*(int*)(db+start_offset);
  148.   if (this_len >= 4) while (pos < start_offset)
  149.   {
  150.     int this_int = *(int*)(db+pos);
  151.     if (this_int == first_int && !memcmp(db+pos,db+start_offset,this_len))
  152.     {
  153.       db_opt_save+=this_len;
  154.       cur_datablock->resize(max(start_offset,pos+this_len));
  155.       return pos;
  156.     }
  157.     pos += 4 + (this_int&0x7fffffff);
  158.   }
  159.  
  160.   return start_offset;
  161. }
  162.  
  163. int CEXEBuild::add_data(char *data, int length) // returns offset
  164. {
  165.   int done=0;
  166.  
  167.   if (length < 0)
  168.   {
  169.     printf("Error: add_data() called with length=%d\n",length);
  170.     return -1;
  171.   }
  172.  
  173.   int st=cur_datablock->getlen();
  174.  
  175.   if (build_compress)
  176.   {
  177.  
  178.     z_stream stream={0,};
  179.  
  180.     // grow datablock so that there is room to compress into
  181.     int bufferlen=length+1024+length/1000;
  182.     cur_datablock->resize(st+bufferlen+sizeof(int));
  183.  
  184.     if (deflateInit(&stream, 9) != Z_OK) 
  185.     {
  186.       printf("Error: deflateInit() failed in add_data()\n");
  187.       return -1;
  188.     }
  189.  
  190.     stream.next_in = (Bytef*)data;
  191.     stream.avail_in = (uInt)length;
  192.  
  193.     stream.next_out = (unsigned char *)cur_datablock->get() + st + sizeof(int);
  194.     stream.avail_out = bufferlen;
  195.  
  196.     deflate(&stream, Z_SYNC_FLUSH);
  197.  
  198.     int used=bufferlen-stream.avail_out;
  199.  
  200.     deflateEnd(&stream);
  201.  
  202.     
  203.     if (build_compress == 2 || used < length)
  204.     {
  205.       done=1;
  206.       cur_datablock->resize(st+used+sizeof(int));
  207.  
  208.       *((int*)((char *)cur_datablock->get()+st)) = used|0x80000000;
  209.       int nst=datablock_optimize(st);
  210.       if (nst == st) db_comp_save+=length-used;
  211.       else st=nst;
  212.     }
  213.   }
  214.  
  215.   if (!done)
  216.   {
  217.     cur_datablock->resize(st);
  218.     cur_datablock->add(&length,sizeof(int));
  219.     cur_datablock->add(data,length);
  220.     st=datablock_optimize(st);
  221.   }
  222.  
  223.   db_full_size += length + sizeof(int);
  224.  
  225.   return st;
  226. }
  227.  
  228. int CEXEBuild::add_label(char *name)
  229. {
  230.   if (!build_cursection && !uninstall_mode)
  231.   {
  232.     printf("Error: Label declaration not valid outside of function/section\n"); 
  233.     return PS_ERROR;
  234.   }
  235.   if ((name[0] >= '0' && name[0] <= '9') || name[0] == '-' || name[0] == ' ' || name[0] == ':')
  236.   {
  237.     printf("Error: labels must not begin with 0-9, -, :, or a space.\n"); 
  238.     return PS_ERROR;
  239.   }
  240.   int cs;
  241.   int ce;
  242.   if (build_cursection)
  243.   {
  244.     cs=build_cursection->code[0];
  245.     ce=build_cursection->code[1];
  246.   }
  247.   else
  248.   {
  249.     cs=build_uninst.code[0];
  250.     ce=build_uninst.code[1];
  251.   }
  252.  
  253.   char *p=strdup(name);
  254.   if (p[strlen(p)-1] == ':') p[strlen(p)-1]=0;
  255.   int offs=ns_label.add(p,0);
  256.   free(p);
  257.  
  258.   int n=cur_labels->getlen()/sizeof(section);
  259.   if (n)
  260.   {
  261.     section *t=(section*)cur_labels->get();
  262.     while (n--)
  263.     {
  264.       if (t->code[0] >= cs && t->code[0] <= ce && t->name_ptr==offs)
  265.       {
  266.         printf("Error: label \"%s\" already declared in section/function\n",name);
  267.         return PS_ERROR;
  268.       }
  269.       t++;
  270.     }
  271.   }
  272.   
  273.   section s={0,};
  274.   s.name_ptr = offs;
  275.   s.code[0] = ce;
  276.   cur_labels->add(&s,sizeof(s));
  277.  
  278.   return PS_OK;
  279. }
  280.  
  281. int CEXEBuild::add_function(char *funname)
  282. {
  283.   if (build_cursection_isfunc)
  284.   {
  285.     printf("Error: Function open when creating function (use FunctionEnd first)\n");
  286.     return PS_ERROR;
  287.   }
  288.   if (build_cursection)
  289.   {
  290.     printf("Error: Section open when creating function (use SectionEnd first)\n");
  291.     return PS_ERROR;
  292.   }
  293.   if (!funname[0])
  294.   {
  295.     printf("Error: Function must have a name\n");
  296.     return PS_ERROR;
  297.   }
  298.  
  299.   if (!strnicmp(funname,"un.",3))
  300.   {
  301.     set_uninstall_mode(1);
  302.   }
  303.  
  304.   int addr=ns_func.add(funname,0);
  305.   int x;
  306.   int n=cur_functions->getlen()/sizeof(section);
  307.   section *tmp=(section*)cur_functions->get();
  308.   for (x = 0; x < n; x ++)
  309.   {
  310.     if (tmp[x].name_ptr == addr)
  311.     {
  312.       printf("Error: Function named \"%s\" already exists.\n",funname);
  313.       return PS_ERROR;
  314.     }
  315.   }
  316.  
  317.   cur_functions->resize((n+1)*sizeof(section));
  318.   build_cursection=((section*)cur_functions->get())+n;
  319.   build_cursection_isfunc=1;
  320.   build_cursection->name_ptr=addr;
  321.   build_cursection->code[0]=cur_entries->getlen()/sizeof(entry);
  322.   build_cursection->code[1]=build_cursection->code[0];
  323.   build_cursection->default_state=0;
  324.   build_cursection->size_kb=0;
  325.   return PS_OK;
  326. }
  327.  
  328. int CEXEBuild::function_end()
  329. {
  330.   if (!build_cursection_isfunc)
  331.   {
  332.     printf("Error: No function open, FunctionEnd called\n");
  333.     return PS_ERROR;
  334.   }
  335.   build_cursection_isfunc=0;
  336.   build_cursection=NULL;
  337.  
  338.   // add invalid opcode, useful for error checking, and
  339.   // makes sure that labels at end of functions work properly.
  340.   entry ent={0,};
  341.   cur_entries->add(&ent,sizeof(entry));
  342.   if (!uninstall_mode) build_header.num_entries++;
  343.   else build_uninst.num_entries++;
  344.  
  345.   set_uninstall_mode(0);
  346.   return PS_OK;
  347. }
  348.  
  349.  
  350. int CEXEBuild::section_add_flags(int flags)
  351. {
  352.   if (uninstall_mode)
  353.   {
  354.     printf("Error: can't modify flags of uninstall section\n");
  355.     return PS_ERROR;
  356.   }
  357.   if (!build_cursection || build_cursection_isfunc)
  358.   {
  359.     printf("Error: can't modify flags when no section is open\n");
  360.     return PS_ERROR;
  361.   }
  362.   build_cursection->default_state|=flags;
  363.   return PS_OK;
  364. }
  365.  
  366. void CEXEBuild::section_add_size_kb(int kb)
  367. {
  368.   if (build_cursection)
  369.   {
  370.     build_cursection->size_kb+=kb;
  371.   }
  372. }
  373.  
  374. int CEXEBuild::section_end()
  375. {
  376.   if (build_cursection_isfunc)
  377.   {
  378.     printf("Error: SectionEnd specified in function (not section)\n");
  379.     return PS_ERROR;
  380.   }
  381.   else if (uninstall_mode)
  382.   {
  383.     set_uninstall_mode(0);
  384.   }
  385.   else if (!build_cursection)
  386.   {
  387.     printf("Error: SectionEnd specified and no sections open\n");
  388.     return PS_ERROR;
  389.   }
  390.   else 
  391.   {
  392.     // add invalid opcode, useful for error checking, and
  393.     // makes sure that labels at end of inst sections work properly.
  394.     entry ent={0,};
  395.     cur_entries->add(&ent,sizeof(entry));
  396.     build_header.num_entries++;
  397.   }
  398.   build_cursection=NULL;
  399.   return PS_OK;
  400. }
  401.  
  402. int CEXEBuild::add_section(char *secname, char *file, int line)
  403. {
  404.   if (build_cursection_isfunc)
  405.   {
  406.     printf("Error: Section can't create section (already in function, use FunctionEnd first)\n");
  407.     return PS_ERROR;
  408.   }
  409.   if (build_cursection || uninstall_mode)
  410.   {
  411.     printf("Error: Section already open, call SectionEnd first\n");
  412.     return PS_ERROR;
  413.   }
  414.   if (!stricmp(secname,"uninstall"))
  415.   {
  416.     if (build_uninst.code[0] != build_uninst.code[1])
  417.     {
  418.       printf("Error: Uninstall section already specified\n");
  419.       return PS_ERROR;
  420.     }
  421.     build_uninst.code[0]=ubuild_entries.getlen()/sizeof(entry);
  422.     build_uninst.code[1]=build_uninst.code[0];
  423.     set_uninstall_mode(1);
  424.     build_cursection=NULL;
  425.     return PS_OK;
  426.   }
  427.   else if (uninstall_mode)
  428.   {
  429.     set_uninstall_mode(0);
  430.   }
  431.   int n=(build_sections.getlen()/sizeof(section));
  432.   build_sections.resize(build_sections.getlen()+sizeof(section));
  433.   build_cursection=((section*)build_sections.get()) + n;
  434.   build_cursection->default_state=(!n||!secname[0])?0x80000000:0;
  435.   build_cursection->name_ptr=add_string(secname);
  436.   build_cursection->code[0]=cur_entries->getlen()/sizeof(entry);
  437.   build_cursection->code[1]=build_cursection->code[0];
  438.   build_cursection->size_kb=0;
  439.  
  440.   if (secname[0]=='-')
  441.   {
  442.     if (!n)
  443.     {
  444.       printf("Error: SectionDivider cannot be first section\n");
  445.       return PS_ERROR;
  446.     }
  447.     build_cursection=NULL;
  448.   }
  449.   
  450.   build_header.num_sections++;
  451.  
  452.   return PS_OK;
  453. }
  454.  
  455. int CEXEBuild::make_sure_not_in_secorfunc(char *str)
  456. {
  457.   if (build_cursection || uninstall_mode)
  458.   {
  459.     printf("Error: command %s not valid in %s\n",str,build_cursection_isfunc?"function":"section");
  460.     return PS_ERROR;
  461.   }
  462.   return PS_OK;
  463. }
  464.  
  465. int CEXEBuild::add_entry(entry *ent)
  466. {
  467.   if (!build_cursection && !uninstall_mode) 
  468.   {
  469.     printf("Error: Can't add entry, no section or function is open!\n");
  470.     return PS_ERROR;
  471.   }
  472.  
  473.   cur_entries->add(ent,sizeof(entry));
  474.  
  475.   if (!uninstall_mode)
  476.   {
  477.     if (!build_cursection_isfunc && build_cursection->name_ptr >=0 && build_strlist.get()[build_cursection->name_ptr] == '-')
  478.     {
  479.       printf("Error: cannot add entry to divider section\n");
  480.       return PS_ERROR;
  481.     }
  482.     build_cursection->code[1]=++build_header.num_entries;
  483.   }
  484.   else
  485.   {
  486.     build_uninst.num_entries++;
  487.     if (build_cursection) build_cursection->code[1]=build_uninst.num_entries;
  488.     else build_uninst.code[1]=build_uninst.num_entries;
  489.   }
  490.  
  491.   return PS_OK;
  492. }
  493.  
  494. void CEXEBuild::printline(int l)
  495. {
  496.   while (l > 2) 
  497.   {
  498.     printf("-=");
  499.     l-=2;
  500.   }
  501.   if (l) printf("-");
  502.   printf("\n");
  503. }
  504.  
  505.  
  506. int CEXEBuild::resolve_jump_int(int *a, int offs, int start, int end)
  507. {
  508.   if (*a != 0)
  509.   {
  510.     section *s = (section*)cur_labels->get();
  511.     int n=cur_labels->getlen()/sizeof(section);
  512.     while (n-->0)
  513.     {
  514.       if (s->code[0] >= start && s->code[0] <= end && s->name_ptr == *a)
  515.       {
  516. //        printf("Resolved jump label \"%s\" to %d\n",(char*)ns_label.get()+*a,s->code_start-offs-1);
  517.         *a = s->code[0]-offs - 1;
  518.         s->default_state++;
  519.         return 0;
  520.       }
  521.       s++;
  522.     }
  523.  
  524.     printf("Error: resolve_jump_int: could not resolve jump \"%s\"\n",(char*)ns_label.get()+*a);
  525.     return 1;
  526.   }
  527.   return 0;
  528. }
  529.  
  530. int CEXEBuild::resolve_instruction(entry *w, int offs, int start, int end)
  531. {
  532.   if (w->which == EW_NOP)
  533.   {
  534.     if (resolve_jump_int(&w->offsets[0],offs,start,end)) return 1;
  535.   }
  536.   else if (w->which == EW_FINDWINDOW)
  537.   {
  538.     if (resolve_jump_int(&w->offsets[4],offs,start,end)) return 1;
  539.   }
  540.   else if (w->which == EW_MESSAGEBOX)
  541.   {
  542.     if (resolve_jump_int(&w->offsets[3],offs,start,end)) return 1;
  543.   }
  544.   else if (w->which == EW_IFFILEEXISTS)
  545.   {
  546.     if (resolve_jump_int(&w->offsets[1],offs,start,end)) return 1;
  547.     if (resolve_jump_int(&w->offsets[2],offs,start,end)) return 1;
  548.   }
  549.   else if (w->which == EW_IFERRORS)
  550.   {
  551.     if (resolve_jump_int(&w->offsets[0],offs,start,end)) return 1;
  552.     if (resolve_jump_int(&w->offsets[1],offs,start,end)) return 1;
  553.   }
  554.   else if (w->which == EW_STRCMP)
  555.   {
  556.     if (resolve_jump_int(&w->offsets[2],offs,start,end)) return 1;
  557.     if (resolve_jump_int(&w->offsets[3],offs,start,end)) return 1;
  558.   }
  559.   else if (w->which == EW_COMPAREDLLS || w->which == EW_COMPAREFILETIMES)
  560.   {
  561.     if (resolve_jump_int(&w->offsets[2],offs,start,end)) return 1;
  562.     if (resolve_jump_int(&w->offsets[3],offs,start,end)) return 1;
  563.   }
  564.   return 0;
  565. }
  566.  
  567. int CEXEBuild::resolve_function(char *str, int fptr, int *ofs)
  568. {
  569.   if (fptr < 0) return 0;
  570.   int nf=cur_functions->getlen()/sizeof(section);
  571.   section *sec=(section *)cur_functions->get();
  572.   while (nf-- > 0)
  573.   {
  574.     if (sec->name_ptr && sec->name_ptr == fptr)
  575.     {
  576. //      printf("Resolved %s function: \"%s\" to (%d,%d)\n",str,
  577.   //      (char*)ns_func.get()+fptr,sec->code_start,sec->code_end);
  578.       ofs[0]=sec->code[0];
  579.       ofs[1]=sec->code[1];
  580.       sec->default_state++;
  581.       return 0;
  582.     }
  583.     sec++;
  584.   }
  585.   printf("Error resolving %s function \"%s\"\n",str,(char*)ns_func.get()+fptr);
  586.   printf("Note: uninstall functions must begin with \"un.\", and install functions must not\n");
  587.   return 1;
  588. }
  589.  
  590.  
  591. int CEXEBuild::resolve_functions(char *str)
  592. {
  593.   // resolve calls
  594.   {
  595.     int l=cur_entries->getlen()/sizeof(entry);
  596.     if (l)
  597.     {
  598.       int x;
  599.       entry *w=(entry*)cur_entries->get();
  600.       for (x = 0; x < l; x ++)
  601.       {
  602.         if (w[x].which == EW_CALL) // call, that needs resolve
  603.         {
  604.           if (resolve_function(str,w[x].offsets[0],w[x].offsets)) return 1;
  605.         }
  606.       }
  607.     }
  608.   }
  609.  
  610.   // resolve jumps
  611.   {
  612.     section *sec=(section *)cur_functions->get();    
  613.     int l=cur_functions->getlen()/sizeof(section);
  614.     entry *w=(entry*)cur_entries->get();
  615.     while (l-- > 0)
  616.     {
  617.       int x;
  618.       for (x = sec->code[0]; x < sec->code[1]; x ++)
  619.         if (resolve_instruction(w+x,x,sec->code[0],sec->code[1])) return 1;
  620.  
  621.       sec++;
  622.     }
  623.     if (uninstall_mode)
  624.     {
  625.       int x;
  626.       for (x = build_uninst.code[0]; x < build_uninst.code[1]; x ++)
  627.         if (resolve_instruction(w+x,x,build_uninst.code[0],build_uninst.code[1])) return 1;
  628.     }
  629.     else
  630.     {
  631.       sec=(section *)build_sections.get();
  632.       l=build_sections.getlen()/sizeof(section);
  633.       while (l-- > 0)
  634.       {
  635.         int x;
  636.         for (x = sec->code[0]; x < sec->code[1]; x ++)
  637.           if (resolve_instruction(w+x,x,sec->code[0],sec->code[1])) return 1;
  638.         sec++;
  639.       }
  640.     }
  641.   }
  642.  
  643.   // optimize unused functions
  644.   {
  645.     section *sec=(section *)cur_functions->get();    
  646.     int l=cur_functions->getlen()/sizeof(section);
  647.     entry *w=(entry*)cur_entries->get();
  648.     while (l-- > 0)
  649.     {
  650.       if (sec->name_ptr)
  651.       {
  652.         if (!sec->default_state)
  653.         {
  654.           if (sec->code[1]>sec->code[0])
  655.           {
  656.             printf("%s function \"%s\" not referenced - zeroing code (%d-%d) out\n",str,
  657.               ns_func.get()+sec->name_ptr,
  658.               sec->code[0],sec->code[1]);
  659.             memset(w+sec->code[0],0,(sec->code[1]-sec->code[0])*sizeof(entry));
  660.           }
  661.         }
  662.       }
  663.       sec++;
  664.     }
  665.   }
  666.  
  667.   // give warnings on unused labels
  668.   {
  669.     section *t=(section*)cur_labels->get();
  670.     int n=cur_labels->getlen()/sizeof(section);
  671.     while (n-->0)
  672.     {
  673.       if (!t->default_state)
  674.       {
  675.         warning("label \"%s\" not used",(char*)ns_label.get()+t->name_ptr);
  676.       }
  677.       t++;
  678.     }
  679.   }
  680.   
  681.   return 0;
  682. }
  683.  
  684. int CEXEBuild::write_output(void)
  685. {
  686.   if (has_called_write_output)
  687.   {
  688.     printf("Error (write_output): write_output already called, can't continue\n");
  689.     return PS_ERROR;
  690.   }
  691.   has_called_write_output++;
  692.   if (!build_output_filename[0])
  693.   {
  694.     printf("Error: invalid script: never had OutFile command\n");
  695.     return PS_ERROR;
  696.   }
  697.  
  698.   {
  699.     int ns=build_sections.getlen()/sizeof(section);
  700.     if (!ns)
  701.     {
  702.       printf("Error: invalid script: no sections specified\n");
  703.       return PS_ERROR;
  704.     }
  705.  
  706.     if ((build_header.componenttext_ptr < 0 ||
  707.         !build_strlist.get()[build_header.componenttext_ptr]) &&
  708.         ns > 1 &&
  709.         !build_header.silent_install
  710.         )
  711.     {
  712.       section *s=(section*)build_sections.get();
  713.       while (ns--)
  714.       {
  715.         s->default_state|=0x80000000;
  716.         s++;
  717.       }
  718.       printf("Component Page disabled, making all sections enabled by default\n");
  719.     }
  720.   }
  721.   if (!build_entries.getlen())
  722.   {
  723.     printf("Error: invalid script: no entries specified\n");
  724.     return PS_ERROR;
  725.   }
  726.  
  727.   if (build_header.name_ptr < 0)
  728.   {
  729.     warning("Name command not specified. Assuming default.");
  730.     build_header.name_ptr=add_string_main("Name");
  731.     build_uninst.name_ptr=add_string_uninst("Name");
  732.   }
  733.  
  734. #ifdef NSIS_CONFIG_UNINSTALL_SUPPORT
  735.   if (ubuild_entries.getlen() && build_header.uninstall_exe_name_ptr < 0)
  736.   {
  737.     warning("Uninstall turned on but UninstallExeName command not specified. Assuming default.");
  738.     build_header.uninstall_exe_name_ptr=add_string_main("nsuninst.exe");
  739.   }
  740. #endif
  741.  
  742.   if (build_cursection || uninstall_mode)
  743.   {
  744.     printf("Error: Section left open at EOF\n");
  745.     return PS_ERROR;
  746.   }
  747.   
  748.   // deal with functions, for both install and uninstall modes.
  749.   if (build_cursection_isfunc)
  750.   {
  751.     printf("Error: Function still open at EOF, cannot proceed\n");
  752.     return 1;
  753.   }
  754.   set_uninstall_mode(1);
  755.   if (resolve_functions("uninstall")) return PS_ERROR;
  756.   set_uninstall_mode(0);
  757.  
  758.   if (resolve_function("install callback",ns_func.find(".onInit",0),build_header.code_onInit)) return PS_ERROR;
  759.   if (resolve_function("install callback",ns_func.find(".onInstSuccess",0),build_header.code_onInstSuccess)) return PS_ERROR;
  760.   if (resolve_function("install callback",ns_func.find(".onInstFailed",0),build_header.code_onInstFailed)) return PS_ERROR;
  761.   if (resolve_function("install callback",ns_func.find(".onUserAbort",0),build_header.code_onUserAbort)) return PS_ERROR;
  762.   if (resolve_function("install callback",ns_func.find(".onVerifyInstDir",0),build_header.code_onVerifyInstDir)) return PS_ERROR;
  763.   
  764.   if (resolve_functions("install")) return PS_ERROR;
  765.  
  766.  
  767.   if (build_header.caption_ptr < 0)
  768.   {
  769.     char buf[1024];
  770.     wsprintf(buf,"%s Setup",build_strlist.get()+build_header.name_ptr);
  771.     build_header.caption_ptr=add_string_main(buf);
  772.   }
  773.  
  774.   if (build_packname[0] && build_packcmd[0])
  775.   {
  776.     FILE *tmpfile=fopen(build_packname,"wb");
  777.     if (!tmpfile)
  778.     {
  779.       printf("Error: writing temporary file \"%s\" for pack\n",build_packname);
  780.       return PS_ERROR;
  781.     }
  782.     fwrite(header_data_new,1,exeheader_size_new,tmpfile);
  783.     fclose(tmpfile);
  784.     if (system(build_packcmd) == -1)
  785.     {
  786.       remove(build_packname);
  787.       printf("Error: calling packer on \"%s\"\n",build_packname);
  788.       return PS_ERROR;
  789.     }
  790.     tmpfile=fopen(build_packname,"rb");
  791.     if (!tmpfile)
  792.     {
  793.       remove(build_packname);
  794.       printf("Error: reading temporary file \"%s\" after pack\n",build_packname);
  795.       return PS_ERROR;
  796.     }
  797.     fseek(tmpfile,0,SEEK_END);
  798.     exeheader_size_new=ftell(tmpfile);
  799.     exeheader_size_new+=511;
  800.     exeheader_size_new&=~511; // align to 512.
  801.     fseek(tmpfile,0,SEEK_SET);
  802.     unsigned char *header_data_older=header_data_new;
  803.     header_data_new=(unsigned char *)malloc(exeheader_size_new);
  804.     if (!header_data_new)
  805.     {
  806.       free(header_data_older);
  807.       fclose(tmpfile);
  808.       printf("Error: malloc(%d) failed (exepack)\n",exeheader_size_new);
  809.       return PS_ERROR;
  810.     }
  811.     memset(header_data_new,0,exeheader_size_new);
  812.     fread(header_data_new,1,exeheader_size_new,tmpfile);
  813.     fclose(tmpfile);
  814.     remove(build_packname);
  815.  
  816.     printf("Locating install icon after compress: ");
  817.     icon_offset = find_data_offset((char*)header_data_new,exeheader_size_new,
  818.                      (char*)header_data_older+icon_offset,ICO_HDRSKIP,sizeof(icon_data));
  819.     free(header_data_older);
  820.     if (icon_offset < 0)
  821.     {
  822.       return PS_ERROR;
  823.     }
  824.     printf("found at offset %d\n",icon_offset);
  825.     // write out exe header, pack, read back in, align to 512, and
  826.     // update the header info
  827.   }
  828.  
  829.   build_optimize_datablock=0;
  830.  
  831.   if (uninstall_generate() != PS_OK) 
  832.   {
  833.     return PS_ERROR;
  834.   }
  835.  
  836.   int crc=0;
  837.  
  838.   printf("\n");
  839.   printline(79);
  840.  
  841.   printf("Output: \"%s\"\n",build_output_filename);
  842.   FILE *fp = fopen(build_output_filename,"wb");
  843.   if (!fp) 
  844.   {
  845.     perror("Can't open output file");
  846.     return PS_ERROR;
  847.   }
  848.  
  849.   if ((int)fwrite(header_data_new,1,exeheader_size_new,fp) != exeheader_size_new)
  850.   {
  851.     printf("Error: can't write %d bytes to output\n",exeheader_size_new);
  852.     fclose(fp);
  853.     return PS_ERROR;
  854.   }
  855.   crc=adler32(crc,header_data_new,exeheader_size_new);
  856.  
  857.   firstheader fh={0,};
  858.   fh.nsinst[0]=FH_INT1;
  859.   fh.nsinst[1]=FH_INT2;
  860.   fh.nsinst[2]=FH_INT3;
  861.   fh.flags=(build_crcchk?FH_FLAGS_CRC:0);
  862.   if (build_header.silent_install) fh.flags |= FH_FLAGS_SILENT;
  863.   fh.siginfo=FH_SIG;
  864.  
  865.   int installinfo_compressed;
  866.   {
  867.     GrowBuf hdrcomp;
  868.     hdrcomp.add(&build_header,sizeof(build_header)); 
  869.     hdrcomp.add(build_sections.get(),build_sections.getlen()); 
  870.     hdrcomp.add(build_entries.get(),build_entries.getlen());
  871.     hdrcomp.add(build_strlist.get(),build_strlist.getlen());
  872.  
  873.     installinfo_compressed=-build_datablock.getlen();
  874.     fh.header_ptr = add_data((char*)hdrcomp.get(),hdrcomp.getlen());
  875.     installinfo_compressed+=build_datablock.getlen()-sizeof(int);
  876.  
  877.  
  878.     fh.length_of_header=hdrcomp.getlen();
  879.     if (fh.header_ptr < 0) return PS_ERROR;
  880.   }
  881.  
  882.   fh.length_of_all_following_data=build_datablock.getlen()+(int)sizeof(firstheader)+(build_crcchk?sizeof(int):0);
  883.  
  884.   int do_padding=0;
  885.   if (build_crcchk && fh.length_of_all_following_data < 516)
  886.   {
  887.     do_padding=516-fh.length_of_all_following_data;
  888.     fh.length_of_all_following_data=516;
  889.   }
  890.  
  891.   if (fwrite(&fh,1,sizeof(fh),fp) != sizeof(fh))
  892.   {
  893.     printf("Error: can't write %d bytes to output\n",sizeof(fh));
  894.     fclose(fp);
  895.     return PS_ERROR;
  896.   }
  897.   crc=adler32(crc,(unsigned char*)&fh,sizeof(fh));
  898.  
  899.   {
  900.     int ns=build_sections.getlen()/sizeof(section);
  901.     section *s=(section*)build_sections.get();
  902.     int x;
  903.     int req=1;
  904.     int div=0;
  905.     int divptr=build_strlist.find("-",2);
  906.     for (x = 1; x < ns; x ++)
  907.     {
  908.       if (s[x].name_ptr == divptr) div++;
  909.       if (s[x].name_ptr == -1)  req++;
  910.     }
  911.     printf("Install: %d section%s",ns,ns==1?"":"s");
  912.     if (req||div) 
  913.     {
  914.       printf(" (");
  915.       if (req) 
  916.       {
  917.         printf("%d required",req);
  918.         if (div) printf(", ");
  919.       }
  920.       if (div) printf("%d divider%s",div,div==1?"":"s");
  921.       printf(")");
  922.     }
  923.     printf(".\n");
  924.   }
  925.   int ne=build_entries.getlen()/sizeof(entry);
  926.   printf("Install: %d instruction%s, ",ne,ne==1?"":"s");
  927.   printf("%d byte string table.\n",build_strlist.getlen());
  928.   if (ubuild_entries.getlen()) 
  929.   {
  930.     int tmp=ubuild_entries.getlen()/sizeof(entry);
  931.     printf("Uninstall: ");
  932.     printf("%d instruction%s, ",tmp,tmp==1?"":"s");
  933.     printf("%d byte string table.\n",ubuild_strlist.getlen());
  934.   }
  935.  
  936.  
  937.   if (db_opt_save) 
  938.   {
  939.     int total_out_size_estimate=
  940.       exeheader_size_new+sizeof(fh)+build_datablock.getlen()+(build_crcchk?4:0);
  941.     int pc=MulDiv(db_opt_save,1000,db_opt_save+total_out_size_estimate);
  942.     printf("Datablock optimizer saved %d bytes (~%d.%d%%).\n",db_opt_save,
  943.       pc/10,pc%10);
  944.   }
  945.  
  946.   printf("\n");
  947.   int total_usize=exeheader_size;
  948.  
  949.   printf("EXE header size:        %10d / %d bytes\n",exeheader_size_new,exeheader_size);
  950.  
  951.   printf("Install code+strings:   %10d / %d bytes\n",
  952.     sizeof(fh)+installinfo_compressed+sizeof(int),
  953.     sizeof(fh)+fh.length_of_header+sizeof(int)); 
  954.  
  955.   total_usize+=sizeof(fh)+fh.length_of_header+sizeof(int);
  956.  
  957.   {
  958.     int dbsize, dbsizeu;
  959.     dbsize = build_datablock.getlen()-installinfo_compressed - sizeof(int);
  960.     if (uninstall_size>0) dbsize-=uninstall_size;
  961.  
  962.     dbsizeu = db_full_size-fh.length_of_header - sizeof(int) - uninstall_size_full;
  963.  
  964.     printf("Install data:           %10d / %d bytes\n",dbsize,dbsizeu);
  965.     total_usize+=dbsizeu;
  966.   }
  967.  
  968.  
  969.   if (build_datablock.getlen())
  970.   {
  971.     char *dbptr=(char *)build_datablock.get();
  972.     int dbl=build_datablock.getlen();
  973.     while (dbl > 0)
  974.     {
  975.       int l=dbl;
  976.       if (l > 32768) l=32768;
  977.       crc=adler32(crc,(unsigned char *)dbptr,l);
  978.       if ((int)fwrite(dbptr,1,l,fp) != l)
  979.       {
  980.         printf("Error: can't write %d bytes to output\n",l);
  981.         fclose(fp);
  982.         return PS_ERROR;
  983.       }
  984.       dbptr+=l;
  985.       dbl-=l;
  986.     }
  987.   }
  988.  
  989.   if (uninstall_size>=0) 
  990.   {
  991.     printf("Uninstall code+data+strings:%6d / %d bytes\n",uninstall_size,uninstall_size_full);
  992.     total_usize+=uninstall_size_full;
  993.   }
  994.   if (do_padding)
  995.   {
  996.     unsigned char buf[516];
  997.     memset(buf,0,sizeof(buf));
  998.     if ((int)fwrite(buf,1,do_padding,fp) != do_padding)
  999.     {
  1000.       printf("Error: can't write %d bytes to output\n",do_padding);
  1001.       fclose(fp);
  1002.       return PS_ERROR;
  1003.     }
  1004.     crc=adler32(crc,buf,do_padding);
  1005.     printf("Padding:                  %8d / %d bytes\n",do_padding,do_padding);
  1006.     total_usize+=do_padding;
  1007.   }
  1008.  
  1009.   if (build_crcchk) 
  1010.   {
  1011.     total_usize+=sizeof(int);
  1012.     if (fwrite(&crc,1,sizeof(int),fp) != sizeof(int))
  1013.     {
  1014.       printf("Error: can't write %d bytes to output\n",sizeof(int));
  1015.       fclose(fp);
  1016.       return PS_ERROR;
  1017.     }
  1018.     printf("CRC (0x%08X):                4 / 4 bytes\n",crc);
  1019.   }
  1020.   printline(57);
  1021.   {
  1022.     int pc=MulDiv(ftell(fp),1000,total_usize);
  1023.     printf("Total size:             %10d / %d bytes (%d.%d%%)\n",ftell(fp),total_usize,pc/10,pc%10);
  1024.   }
  1025.   fclose(fp);
  1026.   print_warnings();
  1027.   return PS_OK;
  1028. }
  1029.  
  1030.  
  1031. int CEXEBuild::uninstall_generate()
  1032. {
  1033. #ifdef NSIS_CONFIG_UNINSTALL_SUPPORT
  1034.   if (ubuild_entries.getlen()) 
  1035.   {
  1036.     firstheader fh={0,};
  1037.  
  1038.     // add one more bit (the code+strtabs) to the uninstall datablock
  1039.     {
  1040.       GrowBuf udata;
  1041.  
  1042.       udata.add(&build_uninst,sizeof(build_uninst));
  1043.       udata.add(ubuild_entries.get(),ubuild_entries.getlen());
  1044.       udata.add(ubuild_strlist.get(),ubuild_strlist.getlen()); 
  1045.     
  1046.       set_uninstall_mode(1);
  1047.       fh.length_of_header=udata.getlen();
  1048.       fh.header_ptr=add_data((char*)udata.get(),udata.getlen());      
  1049.       set_uninstall_mode(0);
  1050.       if (fh.header_ptr < 0) return PS_ERROR;
  1051.     }
  1052.         
  1053.     int crc=0;
  1054.  
  1055.     build_header.uninstdata_offset=build_datablock.getlen();
  1056.     build_header.uninstexehead_iconoffset = icon_offset+ICO_HDRSKIP;
  1057.  
  1058.     if (add_data((char *)m_unicon_data+ICO_HDRSKIP,766-ICO_HDRSKIP) < 0)
  1059.       return PS_ERROR;
  1060.     crc=adler32(crc,header_data_new,icon_offset+ICO_HDRSKIP);
  1061.     crc=adler32(crc,m_unicon_data+ICO_HDRSKIP,766-ICO_HDRSKIP);
  1062.     crc=adler32(crc,header_data_new+icon_offset+766,exeheader_size_new-766-icon_offset);
  1063.  
  1064.     fh.nsinst[0]=FH_INT1;
  1065.     fh.nsinst[1]=FH_INT2;
  1066.     fh.nsinst[2]=FH_INT3;
  1067.     fh.flags = FH_FLAGS_UNINSTALL | (build_crcchk?FH_FLAGS_CRC:0);
  1068.     fh.siginfo=FH_SIG;
  1069.     fh.length_of_all_following_data=
  1070.       ubuild_datablock.getlen()+(int)sizeof(firstheader)+(build_crcchk?sizeof(int):0);
  1071.  
  1072.     if (build_crcchk && fh.length_of_all_following_data < 516)
  1073.     {
  1074.       fh.length_of_all_following_data=516;
  1075.     }
  1076.  
  1077.     GrowBuf udata;
  1078.     udata.add(&fh,sizeof(fh));
  1079.     udata.add(ubuild_datablock.get(),ubuild_datablock.getlen());
  1080.  
  1081.     if (build_crcchk)
  1082.     {
  1083.       if (udata.getlen() < 512)
  1084.       {
  1085.         char buf[512];
  1086.         memset(buf,0,512);
  1087.         udata.add(buf,512-udata.getlen());
  1088.       }
  1089.       int s=adler32(crc,(unsigned char*)udata.get(),udata.getlen());
  1090.       udata.add(&s,sizeof(int));
  1091.     }
  1092.  
  1093.     if (add_data((char*)udata.get(),fh.length_of_all_following_data) < 0) 
  1094.       return PS_ERROR;
  1095.  
  1096.     uninstall_size_full=fh.length_of_all_following_data + sizeof(int) + 766 - 32 + sizeof(int);
  1097.  
  1098.     // compressed size
  1099.     uninstall_size=build_datablock.getlen()-build_header.uninstdata_offset;
  1100.   }
  1101. #endif
  1102.   return PS_OK;
  1103. }
  1104.  
  1105.  
  1106. #define SWAP(x,y,i) { i _ii; _ii=x; x=y; y=_ii; }
  1107.  
  1108. void CEXEBuild::set_uninstall_mode(int un)
  1109. {
  1110.   if (un != uninstall_mode)
  1111.   {
  1112.     uninstall_mode=un;
  1113.     if (un) cur_datablock=&ubuild_datablock;
  1114.     else cur_datablock=&build_datablock;
  1115.     if (un) cur_entries=&ubuild_entries;
  1116.     else cur_entries=&build_entries;
  1117.     if (un) cur_functions=&ubuild_functions;
  1118.     else cur_functions=&build_functions;
  1119.     if (un) cur_labels=&ubuild_labels;
  1120.     else cur_labels=&build_labels;
  1121.  
  1122.     SWAP(db_opt_save_u,db_opt_save,int);
  1123.     SWAP(db_comp_save_u,db_comp_save,int);
  1124.     SWAP(db_full_size_u,db_full_size,int);
  1125.   }
  1126. }
  1127.  
  1128. void CEXEBuild::warning(char *s, ...)
  1129. {
  1130.   char buf[4096];
  1131.   va_list val;
  1132.   va_start(val,s);
  1133.   vsprintf(buf,s,val);
  1134.   va_end(val);
  1135.   m_warnings.add(buf,-1);
  1136.   printf("warning: %s\n",buf);
  1137. }
  1138.  
  1139. void CEXEBuild::print_warnings()
  1140. {
  1141.   int nw=0,x=m_warnings.getlen();
  1142.   if (!x) return;
  1143.   char *p=m_warnings.get();
  1144.   while (x>0) if (!p[--x]) nw++;
  1145.   printf("\n%d warning%s:\n",nw,nw==1?"":"s");
  1146.   for (x = 0; x < nw; x ++)
  1147.   {
  1148.     printf("  %s\n",p);
  1149.     p+=strlen(p)+1;
  1150.   }
  1151. }