Replaced calls to functions that msvc consider deprecated. Used...

src/disassembler.cc

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 45 matching lines @@
   explicit V8NameConverter(Code* code) : code_(code) {}
   virtual const char* NameOfAddress(byte* pc) const;
   virtual const char* NameInCode(byte* addr) const;
   Code* code() const { return code_; }
  private:
   Code* code_;
 };
 
 
 const char* V8NameConverter::NameOfAddress(byte* pc) const {
-  static char buffer[128];
+  static v8::internal::EmbeddedVector<char, 128> buffer;
 
   const char* name = Builtins::Lookup(pc);
   if (name != NULL) {
-    OS::SNPrintF(buffer, sizeof buffer, "%s  (%p)", name, pc);
-    return buffer;
+    OS::SNPrintF(buffer, "%s  (%p)", name, pc);
+    return buffer.start();
   }
 
   if (code_ != NULL) {
     int offs = pc - code_->instruction_start();
     // print as code offset, if it seems reasonable
     if (0 <= offs && offs < code_->instruction_size()) {
-      OS::SNPrintF(buffer, sizeof buffer, "%d  (%p)", offs, pc);
-      return buffer;
+      OS::SNPrintF(buffer, "%d  (%p)", offs, pc);
+      return buffer.start();
     }
   }
 
   return disasm::NameConverter::NameOfAddress(pc);
 }
 
 
 const char* V8NameConverter::NameInCode(byte* addr) const {
   // The V8NameConverter is used for well known code, so we can "safely"
   // dereference pointers in generated code.
@@ skipping 13 matching lines @@
 static const int kRelocInfoPosition = 57;
 
 static int DecodeIt(FILE* f,
                     const V8NameConverter& converter,
                     byte* begin,
                     byte* end) {
   NoHandleAllocation ha;
   AssertNoAllocation no_alloc;
   ExternalReferenceEncoder ref_encoder;
 
-  char decode_buffer[128];
-  char out_buffer[kOutBufferSize];
+  v8::internal::EmbeddedVector<char, 128> decode_buffer;
+  v8::internal::EmbeddedVector<char, kOutBufferSize> out_buffer;
   byte* pc = begin;
   disasm::Disassembler d(converter);
   RelocIterator* it = NULL;
   if (converter.code() != NULL) {
     it = new RelocIterator(converter.code());
   } else {
     // No relocation information when printing code stubs.
   }
   int constants = -1;  // no constants being decoded at the start
 
   while (pc < end) {
     // First decode instruction so that we know its length.
     byte* prev_pc = pc;
     if (constants > 0) {
       OS::SNPrintF(decode_buffer,
-                   sizeof(decode_buffer),
                    "%08x       constant",
                    *reinterpret_cast<int32_t*>(pc));
       constants--;
       pc += 4;
     } else {
       int num_const = d.ConstantPoolSizeAt(pc);
       if (num_const >= 0) {
         OS::SNPrintF(decode_buffer,
-                     sizeof(decode_buffer),
                      "%08x       constant pool begin",
                      *reinterpret_cast<int32_t*>(pc));
         constants = num_const;
         pc += 4;
       } else {
         decode_buffer[0] = '\0';
-        pc += d.InstructionDecode(decode_buffer, sizeof decode_buffer, pc);
+        pc += d.InstructionDecode(decode_buffer, pc);
       }
     }
 
     // Collect RelocInfo for this instruction (prev_pc .. pc-1)
     List<const char*> comments(4);
     List<byte*> pcs(1);
     List<RelocMode> rmodes(1);
     List<intptr_t> datas(1);
     if (it != NULL) {
       while (!it->done() && it->rinfo()->pc() < pc) {
         if (is_comment(it->rinfo()->rmode())) {
           // For comments just collect the text.
           comments.Add(reinterpret_cast<const char*>(it->rinfo()->data()));
         } else {
           // For other reloc info collect all data.
           pcs.Add(it->rinfo()->pc());
           rmodes.Add(it->rinfo()->rmode());
           datas.Add(it->rinfo()->data());
         }
         it->next();
       }
     }
 
-    StringBuilder out(out_buffer, sizeof(out_buffer));
+    StringBuilder out(out_buffer.start(), out_buffer.length());
 
     // Comments.
     for (int i = 0; i < comments.length(); i++) {
       out.AddFormatted("                  %s\n", comments[i]);
     }
 
     // Write out comments, resets outp so that we can format the next line.
     DumpBuffer(f, out.Finalize());
     out.Reset();
 
     // Instruction address and instruction offset.
     out.AddFormatted("%p  %4d  ", prev_pc, prev_pc - begin);
 
     // Instruction.
-    out.AddFormatted("%s", decode_buffer);
+    out.AddFormatted("%s", decode_buffer.start());
 
     // Print all the reloc info for this instruction which are not comments.
     for (int i = 0; i < pcs.length(); i++) {
       // Put together the reloc info
       RelocInfo relocinfo(pcs[i], rmodes[i], datas[i]);
 
       // Indent the printing of the reloc info.
       if (i == 0) {
         // The first reloc info is printed after the disassembled instruction.
         out.AddPadding(' ', kRelocInfoPosition - out.position());
@@ skipping 80 matching lines @@
 
 #else  // ENABLE_DISASSEMBLER
 
 void Disassembler::Dump(FILE* f, byte* begin, byte* end) {}
 int Disassembler::Decode(FILE* f, byte* begin, byte* end) { return 0; }
 void Disassembler::Decode(FILE* f, Code* code) {}
 
 #endif  // ENABLE_DISASSEMBLER
 
 } }  // namespace v8::internal