fix last warnings on w64 and turn on w.a.e.

experimental/PdfViewer/pdfparser/native/SkPdfNativeTokenizer.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkPdfConfig.h"
 #include "SkPdfDiffEncoder.h"
 #include "SkPdfNativeObject.h"
 #include "SkPdfNativeTokenizer.h"
 #include "SkPdfUtils.h"
 
 // TODO(edisonn): mac builder does not find the header ... but from headers is ok
 //#include "SkPdfStreamCommonDictionary_autogen.h"
 //#include "SkPdfImageDictionary_autogen.h"
 #include "SkPdfHeaders_autogen.h"
 
 
 // TODO(edisonn): Perf, Make this function run faster.
 // There could be 0s between start and end.
 // needle will not contain 0s.
 static char* strrstrk(char* hayStart, char* hayEnd, const char* needle) {
-    int needleLen = strlen(needle);
+    size_t needleLen = strlen(needle);
     if ((isPdfWhiteSpaceOrPdfDelimiter(*(hayStart+needleLen)) || (hayStart+needleLen == hayEnd)) &&
             strncmp(hayStart, needle, needleLen) == 0) {
         return hayStart;
     }
 
     hayStart++;
 
     while (hayStart < hayEnd) {
         if (isPdfWhiteSpaceOrPdfDelimiter(*(hayStart-1)) &&
                 (isPdfWhiteSpaceOrPdfDelimiter(*(hayStart+needleLen)) ||
@@ skipping 63 matching lines @@
 
         if (endOfToken == start + 1 && *start == kClosedSquareBracket_PdfDelimiter) {
             return endOfToken;
         }
 
         SkPdfNativeObject* newObj = allocator->allocObject();
         start = nextObject(start, end, newObj, allocator, doc);
         // TODO(edisonn): perf/memory: put the variables on the stack, and flush them on the array
         // only when we are sure they are not references!
         if (newObj->isKeywordReference() && array->size() >= 2 &&
-                array->objAtAIndex(array->size() - 1)->isInteger() &&
-                array->objAtAIndex(array->size() - 2)->isInteger()) {
+                array->objAtAIndex(SkToInt(array->size() - 1))->isInteger() &&
+                array->objAtAIndex(SkToInt(array->size() - 2))->isInteger()) {
             SkPdfNativeObject* gen = array->removeLastInArray();
             SkPdfNativeObject* id = array->removeLastInArray();
 
             SkPdfNativeObject::resetAndMakeReference((unsigned int)id->intValue(),
                                                      (unsigned int)gen->intValue(), newObj);
             // newObj  PUT_TRACK_PARAMETERS_OBJ2(id, newObj) - store end, as now
         }
         array->appendInArray(newObj);
     }
     // TODO(edisonn): report not reached, we should never get here
@@ skipping 114 matching lines @@
     }
 
     if (hasOut) {
         return in;  // consumed already ) at the end of the string
     } else {
         // return where the string would end if we reuse the string
         return start + (out - (const unsigned char*)NULL);
     }
 }
 
-static int readStringLength(const unsigned char* start, const unsigned char* end) {
+static size_t readStringLength(const unsigned char* start, const unsigned char* end) {
     return readString(start, end, NULL) - start;
 }
 
 static const unsigned char* readString(const unsigned char* start, const unsigned char* end,
                                        SkPdfNativeObject* str, SkPdfAllocator* allocator) {
     if (!allocator) {
         // TODO(edisonn): report error/warn/assert
         return end;
     }
 
-    int outLength = readStringLength(start, end);
+    size_t outLength = readStringLength(start, end);
     unsigned char* out = (unsigned char*)allocator->alloc(outLength);
     const unsigned char* now = readString(start, end, out);
     SkPdfNativeObject::makeString(out, out + outLength, str);
     //  PUT_TRACK_STREAM(str, start, now)
     TRACE_STRING(out, out + outLength);
     return now;  // consumed already ) at the end of the string
 }
 
 static const unsigned char* readHexString(const unsigned char* start, const unsigned char* end,
                                           unsigned char* out) {
@@ skipping 118 matching lines @@
     }
 
     if (hasOut) {
         return in;  // consumed already ) at the end of the string
     } else {
         // return where the string would end if we reuse the string
         return start + (out - (const unsigned char*)NULL);
     }
 }
 
-static int readHexStringLength(const unsigned char* start, const unsigned char* end) {
+static size_t readHexStringLength(const unsigned char* start, const unsigned char* end) {
     return readHexString(start, end, NULL) - start;
 }
 
 static const unsigned char* readHexString(const unsigned char* start, const unsigned char* end, SkPdfNativeObject* str, SkPdfAllocator* allocator) {
     if (!allocator) {
         // TODO(edisonn): report error/warn/assert
         return end;
     }
-    int outLength = readHexStringLength(start, end);
+    size_t outLength = readHexStringLength(start, end);
     unsigned char* out = (unsigned char*)allocator->alloc(outLength);
     const unsigned char* now = readHexString(start, end, out);
     SkPdfNativeObject::makeHexString(out, out + outLength, str);
     // str PUT_TRACK_STREAM(start, now)
     TRACE_HEXSTRING(out, out + outLength);
     return now;  // consumed already > at the end of the string
 }
 
 // TODO(edisonn): add version parameter, before PDF 1.2 name could not have special characters.
 static const unsigned char* readName(const unsigned char* start, const unsigned char* end,
@@ skipping 97 matching lines @@
     }
 
     if (hasOut) {
         return in;  // consumed already ) at the end of the string
     } else {
         // return where the string would end if we reuse the string
         return start + (out - (const unsigned char*)NULL);
     }
 }
 
-static int readNameLength(const unsigned char* start, const unsigned char* end) {
+static size_t readNameLength(const unsigned char* start, const unsigned char* end) {
     return readName(start, end, NULL) - start;
 }
 
 static const unsigned char* readName(const unsigned char* start, const unsigned char* end,
                                      SkPdfNativeObject* name, SkPdfAllocator* allocator) {
     if (!allocator) {
         // TODO(edisonn): report error/warn/assert
         return end;
     }
-    int outLength = readNameLength(start, end);
+    size_t outLength = readNameLength(start, end);
     unsigned char* out = (unsigned char*)allocator->alloc(outLength);
     const unsigned char* now = readName(start, end, out);
     SkPdfNativeObject::makeName(out, out + outLength, name);
     //PUT_TRACK_STREAM(start, now)
     TRACE_NAME(out, out + outLength);
     return now;
 }
 
 // TODO(edisonn): pdf spec let Length to be an indirect object define after the stream
 // that makes for an interesting scenario, where the stream itself contains endstream, together
@@ skipping 122 matching lines @@
         start += 1;
     } else {
         SkASSERT(isPdfDelimiter(start[0]));
         // TODO(edisonn): warning?
     }
 
     const unsigned char* endstream = (const unsigned char*)strrstrk((char*)start, (char*)end, "EI");
     const unsigned char* endEI = endstream ? endstream + 2 : NULL;  // 2 == strlen("EI")
 
     if (endstream) {
-        int length = endstream - start;
+        size_t length = endstream - start;
         if (*(endstream-1) == kLF_PdfWhiteSpace) length--;
         if (*(endstream-2) == kCR_PdfWhiteSpace) length--;
         inlineImage->addStream(start, (size_t)length);
     } else {
         // TODO(edisonn): report error in inline image stream (ID-EI) section
         // TODO(edisonn): based on filter, try to ignore a missing EI, and read data properly
         return end;
     }
     return endEI;
 }
@@ skipping 94 matching lines @@
         return end;
     }
 
     current = endOfPdfToken(start, end);
 
     // no token, len would be 0
     if (current == start || current == end) {
         return end;
     }
 
-    int tokenLen = current - start;
+    size_t tokenLen = current - start;
 
     if (tokenLen == 1) {
         // start array
         switch (*start) {
             case kOpenedSquareBracket_PdfDelimiter:
                 return readArray(current, end, token, allocator, doc);
 
             case kOpenedRoundBracket_PdfDelimiter:
                 return readString(start + 1, end, token, allocator);
 
@@ skipping 115 matching lines @@
                                            SkPdfAllocator* allocator,
                                            SkPdfNativeDoc* doc) : fDoc(doc)
                                                                 , fAllocator(allocator)
                                                                 , fEmpty(false)
                                                                 , fHasPutBack(false) {
     // TODO(edisonn): really bad hack, find end of object (endobj might be in a comment!)
     // we need to do now for perf, and our generated pdfs do not have comments,
     // but we need to remove this hack for pdfs in the wild
     char* endobj = strrstrk((char*)buffer, (char*)buffer + len, "endobj");
     if (endobj) {
-        len = endobj - (char*)buffer + strlen("endobj");
+        len = SkToInt(endobj - (char*)buffer + strlen("endobj"));
     }
     fUncompressedStreamStart = fUncompressedStream = buffer;
     fUncompressedStreamEnd = fUncompressedStream + len;
 }
 
 SkPdfNativeTokenizer::~SkPdfNativeTokenizer() {
 }
 
 bool SkPdfNativeTokenizer::readTokenCore(PdfToken* token) {
 #ifdef PDF_TRACE_READ_TOKEN
@@ skipping 180 matching lines @@
                                              fAllocator, fDoc);
             //  PUT_TRACK_STREAM_ARGS_EXPL2(fStreamId, fUncompressedStreamStart)s
             // TODO(edisonn): perf maybe we should not expand abBreviation like this
             inlineImage->set(inlineImageKeyAbbreviationExpand(key),
                              inlineImageValueAbbreviationExpand(obj));
         }
     }
     // TODO(edisonn): report end of data with inline image without an EI
     return inlineImage;
 }