mode code cleanup (100c / l, comments)

experimental/PdfViewer/SkPdfFont.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 "SkPdfFont.h"
 
+#include "SkPdfNativeTokenizer.h"
 #include "SkStream.h"
 #include "SkTypeface.h"
-#include "SkPdfNativeTokenizer.h"
 
 SkTDict<SkPdfStandardFontEntry>& getStandardFonts() {
     static SkTDict<SkPdfStandardFontEntry> gPdfStandardFonts(100);
 
     // TODO (edisonn): , vs - ? what does it mean?
     // TODO (edisonn): MT, PS, Oblique=italic?, ... what does it mean?
     if (gPdfStandardFonts.count() == 0) {
         gPdfStandardFonts.set("Arial", SkPdfStandardFontEntry("Arial", false, false));
         gPdfStandardFonts.set("Arial,Bold", SkPdfStandardFontEntry("Arial", true, false));
         gPdfStandardFonts.set("Arial,BoldItalic", SkPdfStandardFontEntry("Arial", true, true));
@@ skipping 65 matching lines @@
         gPdfStandardFonts.set("DejaVuSansMono-Bold", SkPdfStandardFontEntry("DejaVuSans Mono", true, false));
         gPdfStandardFonts.set("DejaVuSansMono-Oblique", SkPdfStandardFontEntry("DejaVuSans Mono", false, true));
         gPdfStandardFonts.set("Georgia-Bold", SkPdfStandardFontEntry("Georgia", true, false));
         gPdfStandardFonts.set("Georgia-BoldItalic", SkPdfStandardFontEntry("Georgia", true, true));
         gPdfStandardFonts.set("Georgia-Italic", SkPdfStandardFontEntry("Georgia", false, true));
         gPdfStandardFonts.set("TrebuchetMS", SkPdfStandardFontEntry("Trebuchet MS", false, false));
         gPdfStandardFonts.set("TrebuchetMS-Bold", SkPdfStandardFontEntry("Trebuchet MS", true, false));
         gPdfStandardFonts.set("Verdana-Bold", SkPdfStandardFontEntry("Verdana", true, false));
         gPdfStandardFonts.set("WenQuanYiMicroHei", SkPdfStandardFontEntry("WenQuanYi Micro Hei", false, false));
 
-        // TODO(edisonn): list all phonts available, builf post script name as in pdf spec
+        // TODO(edisonn): list all fonts available, buil post script name as in pdf spec
+        // TODO(edisonn): Does it work in all OSs ?
         /*
          * The PostScript name for the value of BaseFontis determined in one of two ways:
 • Use the PostScript name that is an optional entry in the “name” table of the
 TrueType font itself.
 • In the absence of such an entry in the “name” table, derive a PostScript name
 from the name by which the font is known in the host operating system: on a
 Windows system, it is based on the lfFaceName field in a LOGFONT structure; in
 the Mac OS, it is based on the name of the FONDresource. If the name contains
 any spaces, the spaces are removed.
 If the font in a source document uses a bold or italic style, but there is no font
 data for that style, the host operating system will synthesize the style. In this case,
 a comma and the style name (one of Bold, Italic, or BoldItalic) are appended to the
 font name. For example, for a TrueType font that is a bold variant of the New
          */
 
         /*
          * If the value of Subtype is MMType1.
 • If the PostScript name of the instance contains spaces, the spaces are replaced
 by underscores in the value of BaseFont. For instance, as illustrated in Example
 5.7, the name “MinionMM 366 465 11 ” (which ends with a space character)
 becomes /MinionMM_366_465_11_.
          */
-
-        // might not work on all oses ?
-        //
-
     }
 
     return gPdfStandardFonts;
 }
 
 SkTypeface* SkTypefaceFromPdfStandardFont(const char* fontName, bool bold, bool italic) {
     SkTDict<SkPdfStandardFontEntry>& standardFontMap = getStandardFonts();
 
     SkTypeface* typeface = NULL;
     SkPdfStandardFontEntry fontData;
@@ skipping 13 matching lines @@
             fontName,
             SkTypeface::kNormal);
     }
 
     if (typeface) {
         typeface->ref();
     }
     return typeface;
 }
 
-SkPdfFont* SkPdfFont::fontFromFontDescriptor(SkPdfNativeDoc* doc, SkPdfFontDescriptorDictionary* fd, bool loadFromName) {
-    // TODO(edisonn): partial implementation ... also const handling ...
+SkPdfFont* SkPdfFont::fontFromFontDescriptor(SkPdfNativeDoc* doc, SkPdfFontDescriptorDictionary* fd,
+                                             bool loadFromName) {
+    // TODO(edisonn): partial implementation.
     // Only one, at most be available
     SkPdfStream* pdfStream = NULL;
     if (fd->has_FontFile()) {
         pdfStream = fd->FontFile(doc);
     } else if (fd->has_FontFile2()) {
         pdfStream = fd->FontFile2(doc);
     } if (fd->has_FontFile3()) {
         pdfStream = fd->FontFile3(doc);
     } else {
         if (loadFromName) {
@@ skipping 56 matching lines @@
     }
 
     // TODO(edisonn): warning/report issue
     return SkPdfFont::Default();
 }
 
 SkPdfFont* SkPdfFont::fontFromPdfDictionaryOnce(SkPdfNativeDoc* doc, SkPdfFontDictionary* dict) {
     // TODO(edisonn): keep the type in a smart way in the SkPdfNativeObject
     // 1) flag, isResolved (1bit): reset at reset, add/remove/update (array) and set(dict)
     // in a tree like structure, 3-4 bits for all the datatypes inheriting from obj (int, real, ...)
-    // if is a dict, reserveve a few bytes to encode type of dict, and so on like in a tree
+    // if is a dict, reserve a few bytes to encode type of dict, and so on like in a tree
     // issue: type can be determined from context! atribute night be missing/wrong
     switch (doc->mapper()->mapFontDictionary(dict)) {
         case kType0FontDictionary_SkPdfNativeObjectType:
             return fontFromType0FontDictionary(doc, dict->asType0FontDictionary());
 
         case kTrueTypeFontDictionary_SkPdfNativeObjectType:
             return fontFromTrueTypeFontDictionary(doc, dict->asTrueTypeFontDictionary());
 
         case kType1FontDictionary_SkPdfNativeObjectType:
             return fontFromType1FontDictionary(doc, dict->asType1FontDictionary());
@@ skipping 16 matching lines @@
     }
 
     if (!dict->hasData(SkPdfNativeObject::kFont_Data)) {
         dict->setData(fontFromPdfDictionaryOnce(doc, dict), SkPdfNativeObject::kFont_Data);
     }
     return (SkPdfFont*)dict->data(SkPdfNativeObject::kFont_Data);
 }
 
 
 
-SkPdfType0Font* SkPdfFont::fontFromType0FontDictionary(SkPdfNativeDoc* doc, SkPdfType0FontDictionary* dict) {
+SkPdfType0Font* SkPdfFont::fontFromType0FontDictionary(SkPdfNativeDoc* doc,
+                                                       SkPdfType0FontDictionary* dict) {
     if (dict == NULL) {
         return NULL;  // default one?
     }
 
     return new SkPdfType0Font(doc, dict);
 }
 
-SkPdfType1Font* SkPdfFont:: fontFromType1FontDictionary(SkPdfNativeDoc* doc, SkPdfType1FontDictionary* dict) {
+SkPdfType1Font* SkPdfFont:: fontFromType1FontDictionary(SkPdfNativeDoc* doc,
+                                                        SkPdfType1FontDictionary* dict) {
     if (dict == NULL) {
         return NULL;  // default one?
     }
 
     return new SkPdfType1Font(doc, dict);
 }
 
-SkPdfType3Font* SkPdfFont::fontFromType3FontDictionary(SkPdfNativeDoc* doc, SkPdfType3FontDictionary* dict) {
+SkPdfType3Font* SkPdfFont::fontFromType3FontDictionary(SkPdfNativeDoc* doc,
+                                                       SkPdfType3FontDictionary* dict) {
     if (dict == NULL) {
         return NULL;  // default one?
     }
 
 
 
     return new SkPdfType3Font(doc, dict);
 }
 
-SkPdfTrueTypeFont* SkPdfFont::fontFromTrueTypeFontDictionary(SkPdfNativeDoc* doc, SkPdfTrueTypeFontDictionary* dict) {
+SkPdfTrueTypeFont* SkPdfFont::fontFromTrueTypeFontDictionary(SkPdfNativeDoc* doc,
+                                                             SkPdfTrueTypeFontDictionary* dict) {
     if (dict == NULL) {
         return NULL;  // default one?
     }
 
     return new SkPdfTrueTypeFont(doc, dict);
 }
 
-SkPdfMultiMasterFont* SkPdfFont::fontFromMultiMasterFontDictionary(SkPdfNativeDoc* doc, SkPdfMultiMasterFontDictionary* dict) {
+SkPdfMultiMasterFont* SkPdfFont::fontFromMultiMasterFontDictionary(
+        SkPdfNativeDoc* doc, SkPdfMultiMasterFontDictionary* dict) {
     if (dict == NULL) {
         return NULL;  // default one?
     }
 
     return new SkPdfMultiMasterFont(doc, dict);
 }
 
 static int skstoi(const SkPdfNativeObject* str) {
     // TODO(edisonn): report err of it is not a (hex) string
     int ret = 0;
     for (unsigned int i = 0 ; i < str->lenstr(); i++) {
         ret = (ret << 8) + ((unsigned char*)str->c_str())[i];
     }
     // TODO(edisonn): character larger than 0x0000ffff not supported right now.
     return ret & 0x0000ffff;
 }
 
-#define tokenIsKeyword(token,keyword) (token.fType == kKeyword_TokenType && token.fKeywordLength==sizeof(keyword)-1 && strncmp(token.fKeyword, keyword, sizeof(keyword)-1) == 0)
+#define tokenIsKeyword(token,keyword) (token.fType == kKeyword_TokenType && \
+                                      token.fKeywordLength==sizeof(keyword)-1 && \
+                                      strncmp(token.fKeyword, keyword, sizeof(keyword)-1) == 0)
 
 SkPdfToUnicode::SkPdfToUnicode(SkPdfNativeDoc* parsed, SkPdfStream* stream) : fParsed(parsed) {
     fCMapEncoding = NULL;
     fCMapEncodingFlag = NULL;
 
     if (stream) {
         // Since font will be cached, the font has to sit in the per doc allocator, not to be
         // freed after the page is done drawing.
         SkPdfNativeTokenizer* tokenizer = fParsed->tokenizerOfStream(stream, parsed->allocator());
         PdfToken token;
 
         fCMapEncoding = new unsigned short[256 * 256];
         fCMapEncodingFlag = new unsigned char[256 * 256];
         for (int i = 0 ; i < 256 * 256; i++) {
             fCMapEncoding[i] = i;
             fCMapEncodingFlag[i] = 0;
         }
 
         // TODO(edisonn): deal with multibyte character, or longer strings.
-        // Ritght now we deal with up 2 characters, e.g. <0020> but not longer like <00660066006C>
+        // Right now we deal with up 2 characters, e.g. <0020> but not longer like <00660066006C>
         //2 beginbfrange
         //<0000> <005E> <0020>
         //<005F> <0061> [<00660066> <00660069> <00660066006C>]
 
         while (tokenizer->readToken(&token)) {
 
-            // TODO(edisonn): perf, macro that would make equal first for token.fKeywordLength with sizeof(keyword), instead od strlen, make sure it is keyword, not a char*
             if (tokenIsKeyword(token, "begincodespacerange")) {
-                while (tokenizer->readToken(&token) && !tokenIsKeyword(token, "endcodespacerange")) {
+                while (tokenizer->readToken(&token) &&
+                       !tokenIsKeyword(token, "endcodespacerange")) {
 //                    tokenizer->PutBack(token);
 //                    tokenizer->readToken(&token);
                     // TODO(edisonn): check token type! ignore/report errors.
                     int start = skstoi(token.fObject);
                     tokenizer->readToken(&token);
                     int end = skstoi(token.fObject);
                     for (int i = start; i <= end; i++) {
                         fCMapEncodingFlag[i] |= 1;
                     }
                 }
@@ skipping 15 matching lines @@
             if (tokenIsKeyword(token, "beginbfrange")) {
                 while (tokenizer->readToken(&token) && !tokenIsKeyword(token, "endbfrange")) {
 //                    tokenizer->PutBack(token);
 //                    tokenizer->readToken(&token);
                     int start = skstoi(token.fObject);
                     tokenizer->readToken(&token);
                     int end = skstoi(token.fObject);
 
 
                     tokenizer->readToken(&token); // [ or just an array directly?
+                    // do not putback, we will reuse the read. See next commented read.
 //                    tokenizer->PutBack(token);
 
                     // TODO(edisonn): read spec: any string or only hex string?
                     if (token.fType == kObject_TokenType && token.fObject->isAnyString()) {
 //                        tokenizer->readToken(&token);
                         int value = skstoi(token.fObject);
 
                         for (int i = start; i <= end; i++) {
                             fCMapEncodingFlag[i] |= 2;
                             fCMapEncoding[i] = value;
                             value++;
                             // if i != end, verify last byte id not if, ignore/report error
                         }
 
                         // read one string
                     } else if (token.fType == kObject_TokenType && token.fObject->isArray()) {
 //                        tokenizer->readToken(&token);
+                        // read array
                         for (unsigned int i = 0; i < token.fObject->size(); i++) {
                             fCMapEncodingFlag[start + i] |= 2;
                             fCMapEncoding[start + i] = skstoi((*token.fObject)[i]);
                         }
-                        // read array
+                    } else {
+                        tokenizer->PutBack(token);
                     }
-
-                    //fCMapEncodingFlag[from] = 1;
-                    //fCMapEncoding[from] = to;
                 }
             }
         }
     }
 }
 
-
 SkPdfType0Font::SkPdfType0Font(SkPdfNativeDoc* doc, SkPdfType0FontDictionary* dict) {
     fBaseFont = fontFromName(doc, dict, dict->BaseFont(doc).c_str());
     fEncoding = NULL;
 
     if (dict->has_Encoding()) {
         if (dict->isEncodingAName(doc)) {
             fEncoding = SkPdfEncoding::fromName(dict->getEncodingAsName(doc).c_str());
         } else if (dict->isEncodingAStream(doc)) {
+            // TODO(edisonn): NYI
             //fEncoding = loadEncodingFromStream(dict->getEncodingAsStream());
         } else {
             // TODO(edisonn): error ... warning .. assert?
         }
     }
 
     if (dict->has_ToUnicode()) {
         fToUnicode = new SkPdfToUnicode(doc, dict->ToUnicode(doc));
     }
 }
 
 SkTDict<SkPdfEncoding*>& getStandardEncodings() {
     static SkTDict<SkPdfEncoding*> encodings(10);
     if (encodings.count() == 0) {
         encodings.set("Identity-H", SkPdfIdentityHEncoding::instance());
     }
 
     return encodings;
 }
 
 SkPdfEncoding* SkPdfEncoding::fromName(const char* name) {
     SkPdfEncoding* encoding = NULL;
     if (!getStandardEncodings().find(name, &encoding)) {
-        // TODO(edisonn): if the function return false, and we a guaranteed that the value is not
-        // changed, delete this set to null
         encoding = NULL;
     }
 
 #ifdef PDF_TRACE
     if (encoding == NULL) {
         printf("Encoding not found: %s\n", name);
     }
 #endif
     return encoding;
 }