pdfviewer: fix warnings on mac

experimental/PdfViewer/pdfparser/native/SkPdfNativeTokenizer.cpp

 
 #include "SkPdfNativeTokenizer.h"
 #include "SkPdfObject.h"
 #include "SkPdfConfig.h"
 
 #include "SkPdfStreamCommonDictionary_autogen.h"
 
-unsigned char* skipPdfWhiteSpaces(unsigned char* start, unsigned char* end) {
+static unsigned char* skipPdfWhiteSpaces(unsigned char* start, unsigned char* end) {
     while (start < end && isPdfWhiteSpace(*start)) {
         if (*start == kComment_PdfDelimiter) {
             // skip the comment until end of line
             while (start < end && !isPdfEOL(*start)) {
                 *start = '\0';
                 start++;
             }
         } else {
             *start = '\0';
             start++;
         }
     }
     return start;
 }
 
 // TODO(edisonn) '(' can be used, will it break the string a delimiter or space inside () ?
-unsigned char* endOfPdfToken(unsigned char* start, unsigned char* end) {
+static unsigned char* endOfPdfToken(unsigned char* start, unsigned char* end) {
     //int opened brackets
     //TODO(edisonn): what out for special chars, like \n, \032
 
     SkASSERT(!isPdfWhiteSpace(*start));
 
     if (start < end && isPdfDelimiter(*start)) {
         start++;
         return start;
     }
 
     while (start < end && !isPdfWhiteSpaceOrPdfDelimiter(*start)) {
         start++;
     }
     return start;
 }
 
-unsigned char* skipPdfComment(unsigned char* start, unsigned char* end) {
-    SkASSERT(start == end || *start == kComment_PdfDelimiter);
-    while (start < end && isPdfEOL(*start)) {
-        *start = '\0';
-        start++;
-    }
-    return start;
-}
-
 // last elem has to be ]
-unsigned char* readArray(unsigned char* start, unsigned char* end, SkPdfObject* array, SkPdfAllocator* allocator) {
+static unsigned char* readArray(unsigned char* start, unsigned char* end, SkPdfObject* array, SkPdfAllocator* allocator) {
     while (start < end) {
         // skip white spaces
         start = skipPdfWhiteSpaces(start, end);
 
         unsigned char* endOfToken = endOfPdfToken(start, end);
 
         if (endOfToken == start) {
             // TODO(edisonn): report error in pdf file (end of stream with ] for end of aray
             return start;
         }
 
         if (endOfToken == start + 1 && *start == kClosedSquareBracket_PdfDelimiter) {
             return endOfToken;
         }
 
         SkPdfObject* newObj = allocator->allocObject();
         start = nextObject(start, end, newObj, allocator);
         // 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()) {
             SkPdfObject* gen = array->removeLastInArray();
             SkPdfObject* id = array->removeLastInArray();
             newObj->reset();
-            SkPdfObject::makeReference(id->intValue(), gen->intValue(), newObj);
+            SkPdfObject::makeReference((unsigned int)id->intValue(), (unsigned int)gen->intValue(), newObj);
         }
         array->appendInArray(newObj);
     }
     // TODO(edisonn): report not reached, we should never get here
     SkASSERT(false);
     return start;
 }
 
 // When we read strings we will rewrite the string so we will reuse the memory
 // when we start to read the string, we already consumed the opened bracket
-unsigned char* readString(unsigned char* start, unsigned char* end, SkPdfObject* str) {
+static unsigned char* readString(unsigned char* start, unsigned char* end, SkPdfObject* str) {
     unsigned char* out = start;
     unsigned char* in = start;
 
     int openRoundBrackets = 0;
     while (in < end && (*in != kClosedRoundBracket_PdfDelimiter || openRoundBrackets > 0)) {
         openRoundBrackets += ((*in) == kOpenedRoundBracket_PdfDelimiter);
         openRoundBrackets -= ((*in) == kClosedRoundBracket_PdfDelimiter);
         if (*in == kEscape_PdfSpecial) {
             if (in + 1 < end) {
                 switch (in[1]) {
@@ skipping 90 matching lines @@
             in++;
             out++;
         }
     }
 
 
     SkPdfObject::makeString(start, out, str);
     return in + 1;  // consume ) at the end of the string
 }
 
-unsigned char* readHexString(unsigned char* start, unsigned char* end, SkPdfObject* str) {
+static unsigned char* readHexString(unsigned char* start, unsigned char* end, SkPdfObject* str) {
     unsigned char* out = start;
     unsigned char* in = start;
 
     unsigned char code = 0;
 
     while (in < end) {
         while (in < end && isPdfWhiteSpace(*in)) {
             in++;
         }
 
@@ skipping 109 matching lines @@
 
     if (out < in) {
         *out = '\0';
     }
 
     SkPdfObject::makeHexString(start, out, str);
     return in;  // consume > at the end of the string
 }
 
 // TODO(edisonn): before PDF 1.2 name could not have special characters, add version parameter
-unsigned char* readName(unsigned char* start, unsigned char* end, SkPdfObject* name) {
+static unsigned char* readName(unsigned char* start, unsigned char* end, SkPdfObject* name) {
     unsigned char* out = start;
     unsigned char* in = start;
 
     unsigned char code = 0;
 
     while (in < end) {
         if (isPdfWhiteSpaceOrPdfDelimiter(*in)) {
             break;
         }
 
@@ skipping 106 matching lines @@
 endstream
 8 0 obj #real obj
 << 100 >> #real obj
 endobj
 and it could get worse, with multiple object like this
 */
 
 // right now implement the silly algorithm that assumes endstream is finishing the stream
 
 
-unsigned char* readStream(unsigned char* start, unsigned char* end, SkPdfObject* dict) {
+static unsigned char* readStream(unsigned char* start, unsigned char* end, SkPdfObject* dict) {
     start = skipPdfWhiteSpaces(start, end);
     if (!(start[0] == 's' && start[1] == 't' && start[2] == 'r' && start[3] == 'e' && start[4] == 'a' && start[5] == 'm')) {
         // no stream. return.
         return start;
     }
 
     start += 6; // strlen("stream")
     if (start[0] == kCR_PdfWhiteSpace && start[1] == kLF_PdfWhiteSpace) {
         start += 2;
     } else if (start[0] == kLF_PdfWhiteSpace) {
         start += 1;
     }
 
     SkPdfStreamCommonDictionary* stream = (SkPdfStreamCommonDictionary*) dict;
     // TODO(edisonn): load Length
-    int length = -1;
+    int64_t length = -1;
 
     // TODO(edisonn): very basic implementation
     if (stream->has_Length() && stream->Length(NULL) > 0) {
         length = stream->Length(NULL);
     }
 
     // TODO(edisonn): laod external streams
     // TODO(edisonn): look at the last filter, to determione how to deal with possible issue
 
     if (length < 0) {
@@ skipping 18 matching lines @@
         if (endstream[0] == kCR_PdfWhiteSpace && endstream[1] == kLF_PdfWhiteSpace) {
             endstream += 2;
         } else if (endstream[0] == kLF_PdfWhiteSpace) {
             endstream += 1;
         }
 
         // TODO(edisonn): verify the next bytes are "endstream"
 
         endstream += strlen("endstream");
         // TODO(edisonn): Assert? report error/warning?
-        dict->addStream(start, length);
+        dict->addStream(start, (size_t)length);
         return endstream;
     }
     return start;
 }
 
-unsigned char* readDictionary(unsigned char* start, unsigned char* end, SkPdfObject* dict, SkPdfAllocator* allocator) {
+static unsigned char* readDictionary(unsigned char* start, unsigned char* end, SkPdfObject* dict, SkPdfAllocator* allocator) {
     SkPdfObject::makeEmptyDictionary(dict);
 
     start = skipPdfWhiteSpaces(start, end);
 
     while (start < end && *start == kNamed_PdfDelimiter) {
         SkPdfObject key;
         *start = '\0';
         start++;
         start = readName(start, end, &key);
         start = skipPdfWhiteSpaces(start, end);
 
         if (start < end) {
             SkPdfObject* value = allocator->allocObject();
             start = nextObject(start, end, value, allocator);
 
             start = skipPdfWhiteSpaces(start, end);
 
             if (start < end) {
                 // seems we have an indirect reference
                 if (isPdfDigit(*start)) {
                     SkPdfObject generation;
                     start = nextObject(start, end, &generation, allocator);
 
                     SkPdfObject keywordR;
                     start = nextObject(start, end, &keywordR, allocator);
 
                     if (value->isInteger() && generation.isInteger() && keywordR.isKeywordReference()) {
                         int64_t id = value->intValue();
                         value->reset();
-                        SkPdfObject::makeReference(id, generation.intValue(), value);
+                        SkPdfObject::makeReference((unsigned int)id, (unsigned int)generation.intValue(), value);
                         dict->set(&key, value);
                     } else {
                         // error, ignore
                         dict->set(&key, value);
                     }
                 } else {
                     // next elem is not a digit, but it might not be / either!
                     dict->set(&key, value);
                 }
             } else {
@@ skipping 208 matching lines @@
 
     if (fEmpty) {
 #ifdef PDF_TRACE
     printf("EMPTY TOKENIZER\n");
 #endif
         return false;
     }
 
     return readTokenCore(token);
 }