From 8ec9956bdfc173132de52acf1aa03746fabca287 Mon Sep 17 00:00:00 2001 From: "bungeman@google.com" Date: Tue, 7 Feb 2012 21:30:21 +0000 Subject: [PATCH] Add more TT table definitions and create fake enum typedef. git-svn-id: http://skia.googlecode.com/svn/trunk@3150 2bbb7eff-a529-9590-31e7-b0007b416f81 --- gyp/sfnt.gyp | 5 + src/sfnt/SkOTTable_head.h | 3 +- src/sfnt/SkOTTable_name.h | 504 ++++++++++++++++++++++++ src/sfnt/SkOTUtils.cpp | 18 + src/sfnt/SkOTUtils.h | 17 + src/sfnt/SkPreprocessorSeq.h | 717 +++++++++++++++++++++++++++++++++++ src/sfnt/SkSFNTHeader.h | 45 +++ src/sfnt/SkTypedEnum.h | 1 + 8 files changed, 1309 insertions(+), 1 deletion(-) create mode 100644 src/sfnt/SkOTTable_name.h create mode 100644 src/sfnt/SkOTUtils.cpp create mode 100644 src/sfnt/SkOTUtils.h create mode 100644 src/sfnt/SkSFNTHeader.h diff --git a/gyp/sfnt.gyp b/gyp/sfnt.gyp index 5068108663..2f2fc76360 100644 --- a/gyp/sfnt.gyp +++ b/gyp/sfnt.gyp @@ -17,6 +17,7 @@ '../src/sfnt/SkOTTableTypes.h', '../src/sfnt/SkOTTable_head.h', '../src/sfnt/SkOTTable_hhea.h', + '../src/sfnt/SkOTTable_name.h', '../src/sfnt/SkOTTable_OS_2.h', '../src/sfnt/SkOTTable_OS_2_V0.h', '../src/sfnt/SkOTTable_OS_2_V1.h', @@ -26,8 +27,12 @@ '../src/sfnt/SkOTTable_OS_2_VA.h', '../src/sfnt/SkOTTable_post.h', '../src/sfnt/SkPanose.h', + '../src/sfnt/SkOTUtils.h', '../src/sfnt/SkPreprocessorSeq.h', + '../src/sfnt/SkSFNTHeader.h', '../src/sfnt/SkTypedEnum.h', + + '../src/sfnt/SkOTUtils.cpp', ], 'direct_dependent_settings': { 'include_dirs': [ diff --git a/src/sfnt/SkOTTable_head.h b/src/sfnt/SkOTTable_head.h index 2f1d69c82e..627e9f067f 100644 --- a/src/sfnt/SkOTTable_head.h +++ b/src/sfnt/SkOTTable_head.h @@ -18,7 +18,8 @@ struct SkOTTableHead { SK_OT_Fixed version; static const SK_OT_Fixed version1 = SkTEndian_SwapBE32(0x00010000); SK_OT_Fixed fontRevision; - SK_OT_ULONG checkSumAdjustment; + static const uint32_t fontChecksum = 0xB1B0AFBA; //checksum of all TT fonts + SK_OT_ULONG checksumAdjustment; SK_OT_ULONG magicNumber; static const SK_OT_ULONG magicNumberConst = SkTEndian_SwapBE32(0x5F0F3CF5); union Flags { diff --git a/src/sfnt/SkOTTable_name.h b/src/sfnt/SkOTTable_name.h new file mode 100644 index 0000000000..67620865d9 --- /dev/null +++ b/src/sfnt/SkOTTable_name.h @@ -0,0 +1,504 @@ +/* + * Copyright 2012 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ + +#ifndef SkOTTable_name_DEFINED +#define SkOTTable_name_DEFINED + +#include "SkEndian.h" +#include "SkOTTableTypes.h" +#include "SkTypedEnum.h" + +#pragma pack(push, 1) + +struct SkOTTableName { + SK_OT_USHORT format; + static const SK_OT_USHORT format_0 = SkTEndian_SwapBE16(0); + static const SK_OT_USHORT format_1 = SkTEndian_SwapBE16(1); + SK_OT_USHORT count; + SK_OT_USHORT stringOffset; //Offset to start of storage area (from start of table). + //SkOTTableNameRecord nameRecord[count]; +}; +struct SkOTTableNameF1 { + SK_OT_USHORT langTagCount; + //SkOTTableNameLangTagRecord langTagRecord[langTagCount]; +}; + +struct SkOTTableNameLangTagRecord { + SK_OT_USHORT length; + SK_OT_USHORT offset; //From start of storage area. + //The string is always UTF-16BE from IETF specification BCP 47. +}; + +struct SkOTTableNameRecord { + //The platform ID specifies how to interpret the encoding and language ID. + struct PlatformID { + SK_TYPED_ENUM(Value, SK_OT_USHORT, + ((Unicode, SkTEndian_SwapBE16(0))) + ((Macintosh, SkTEndian_SwapBE16(1))) + ((ISO, SkTEndian_SwapBE16(2))) //deprecated, use Unicode instead + ((Windows, SkTEndian_SwapBE16(3))) + ((Custom, SkTEndian_SwapBE16(4))) + SK_SEQ_END, + (value)SK_SEQ_END) + } platformID; + union EncodingID { + //Always UTF-16BE + struct Unicode { + SK_TYPED_ENUM(Value, SK_OT_USHORT, + ((Unicode10, SkTEndian_SwapBE16(0))) + ((Unicode11, SkTEndian_SwapBE16(1))) + ((ISO10646, SkTEndian_SwapBE16(2))) //deprecated, use Unicode11 + ((Unicode20BMP, SkTEndian_SwapBE16(3))) + ((Unicode20, SkTEndian_SwapBE16(4))) + ((UnicodeVariationSequences, SkTEndian_SwapBE16(5))) + ((UnicodeFull, SkTEndian_SwapBE16(6))) + SK_SEQ_END, + (value)SK_SEQ_END) + } unicode; + struct Macintosh { + SK_TYPED_ENUM(Value, SK_OT_USHORT, + ((Roman, SkTEndian_SwapBE16(0))) + ((Japanese, SkTEndian_SwapBE16(1))) + ((ChineseTraditional, SkTEndian_SwapBE16(2))) + ((Korean, SkTEndian_SwapBE16(3))) + ((Arabic, SkTEndian_SwapBE16(4))) + ((Hebrew, SkTEndian_SwapBE16(5))) + ((Greek, SkTEndian_SwapBE16(6))) + ((Russian, SkTEndian_SwapBE16(7))) + ((RSymbol, SkTEndian_SwapBE16(8))) + ((Devanagari, SkTEndian_SwapBE16(9))) + ((Gurmukhi, SkTEndian_SwapBE16(10))) + ((Gujarati, SkTEndian_SwapBE16(11))) + ((Oriya, SkTEndian_SwapBE16(12))) + ((Bengali, SkTEndian_SwapBE16(13))) + ((Tamil, SkTEndian_SwapBE16(14))) + ((Telugu, SkTEndian_SwapBE16(15))) + ((Kannada, SkTEndian_SwapBE16(16))) + ((Malayalam, SkTEndian_SwapBE16(17))) + ((Sinhalese, SkTEndian_SwapBE16(18))) + ((Burmese, SkTEndian_SwapBE16(19))) + ((Khmer, SkTEndian_SwapBE16(20))) + ((Thai, SkTEndian_SwapBE16(21))) + ((Laotian, SkTEndian_SwapBE16(22))) + ((Georgian, SkTEndian_SwapBE16(23))) + ((Armenian, SkTEndian_SwapBE16(24))) + ((ChineseSimplified, SkTEndian_SwapBE16(25))) + ((Tibetan, SkTEndian_SwapBE16(26))) + ((Mongolian, SkTEndian_SwapBE16(27))) + ((Geez, SkTEndian_SwapBE16(28))) + ((Slavic, SkTEndian_SwapBE16(29))) + ((Vietnamese, SkTEndian_SwapBE16(30))) + ((Sindhi, SkTEndian_SwapBE16(31))) + ((Uninterpreted, SkTEndian_SwapBE16(32))) + SK_SEQ_END, + (value)SK_SEQ_END) + } macintosh; + //deprecated, use Unicode instead + struct ISO { + SK_TYPED_ENUM(Value, SK_OT_USHORT, + ((ASCII7, SkTEndian_SwapBE16(0))) + ((ISO10646, SkTEndian_SwapBE16(1))) + ((ISO88591, SkTEndian_SwapBE16(2))) + SK_SEQ_END, + (value)SK_SEQ_END) + } iso; + struct Windows { + SK_TYPED_ENUM(Value, SK_OT_USHORT, + ((Symbol, SkTEndian_SwapBE16(0))) + ((UnicodeBMPUCS2, SkTEndian_SwapBE16(1))) //Windows default + ((ShiftJIS, SkTEndian_SwapBE16(2))) + ((PRC, SkTEndian_SwapBE16(3))) + ((Big5, SkTEndian_SwapBE16(4))) + ((Wansung, SkTEndian_SwapBE16(5))) + ((Johab, SkTEndian_SwapBE16(6))) + ((UnicodeUCS4, SkTEndian_SwapBE16(10))) + SK_SEQ_END, + (value)SK_SEQ_END) + } windows; + SK_OT_USHORT custom; + } encodingID; + union LanguageID { + struct Macintosh { + SK_TYPED_ENUM(Value, SK_OT_USHORT, + ((English, SkTEndian_SwapBE16(0))) + ((French, SkTEndian_SwapBE16(1))) + ((German, SkTEndian_SwapBE16(2))) + ((Italian, SkTEndian_SwapBE16(3))) + ((Dutch, SkTEndian_SwapBE16(4))) + ((Swedish, SkTEndian_SwapBE16(5))) + ((Spanish, SkTEndian_SwapBE16(6))) + ((Danish, SkTEndian_SwapBE16(7))) + ((Portuguese, SkTEndian_SwapBE16(8))) + ((Norwegian, SkTEndian_SwapBE16(9))) + ((Hebrew, SkTEndian_SwapBE16(10))) + ((Japanese, SkTEndian_SwapBE16(11))) + ((Arabic, SkTEndian_SwapBE16(12))) + ((Finnish, SkTEndian_SwapBE16(13))) + ((Greek, SkTEndian_SwapBE16(14))) + ((Icelandic, SkTEndian_SwapBE16(15))) + ((Maltese, SkTEndian_SwapBE16(16))) + ((Turkish, SkTEndian_SwapBE16(17))) + ((Croatian, SkTEndian_SwapBE16(18))) + ((ChineseTraditional, SkTEndian_SwapBE16(19))) + ((Urdu, SkTEndian_SwapBE16(20))) + ((Hindi, SkTEndian_SwapBE16(21))) + ((Thai, SkTEndian_SwapBE16(22))) + ((Korean, SkTEndian_SwapBE16(23))) + ((Lithuanian, SkTEndian_SwapBE16(24))) + ((Polish, SkTEndian_SwapBE16(25))) + ((Hungarian, SkTEndian_SwapBE16(26))) + ((Estonian, SkTEndian_SwapBE16(27))) + ((Latvian, SkTEndian_SwapBE16(28))) + ((Sami, SkTEndian_SwapBE16(29))) + ((Faroese, SkTEndian_SwapBE16(30))) + ((Farsi_Persian, SkTEndian_SwapBE16(31))) + ((Russian, SkTEndian_SwapBE16(32))) + ((ChineseSimplified, SkTEndian_SwapBE16(33))) + ((Flemish, SkTEndian_SwapBE16(34))) + ((IrishGaelic, SkTEndian_SwapBE16(35))) + ((Albanian, SkTEndian_SwapBE16(36))) + ((Romanian, SkTEndian_SwapBE16(37))) + ((Czech, SkTEndian_SwapBE16(38))) + ((Slovak, SkTEndian_SwapBE16(39))) + ((Slovenian, SkTEndian_SwapBE16(40))) + ((Yiddish, SkTEndian_SwapBE16(41))) + ((Serbian, SkTEndian_SwapBE16(42))) + ((Macedonian, SkTEndian_SwapBE16(43))) + ((Bulgarian, SkTEndian_SwapBE16(44))) + ((Ukrainian, SkTEndian_SwapBE16(45))) + ((Byelorussian, SkTEndian_SwapBE16(46))) + ((Uzbek, SkTEndian_SwapBE16(47))) + ((Kazakh, SkTEndian_SwapBE16(48))) + ((AzerbaijaniCyrillic, SkTEndian_SwapBE16(49))) + ((AzerbaijaniArabic, SkTEndian_SwapBE16(50))) + ((Armenian, SkTEndian_SwapBE16(51))) + ((Georgian, SkTEndian_SwapBE16(52))) + ((Moldavian, SkTEndian_SwapBE16(53))) + ((Kirghiz, SkTEndian_SwapBE16(54))) + ((Tajiki, SkTEndian_SwapBE16(55))) + ((Turkmen, SkTEndian_SwapBE16(56))) + ((MongolianTraditional, SkTEndian_SwapBE16(57))) + ((MongolianCyrillic, SkTEndian_SwapBE16(58))) + ((Pashto, SkTEndian_SwapBE16(59))) + ((Kurdish, SkTEndian_SwapBE16(60))) + ((Kashmiri, SkTEndian_SwapBE16(61))) + ((Sindhi, SkTEndian_SwapBE16(62))) + ((Tibetan, SkTEndian_SwapBE16(63))) + ((Nepali, SkTEndian_SwapBE16(64))) + ((Sanskrit, SkTEndian_SwapBE16(65))) + ((Marathi, SkTEndian_SwapBE16(66))) + ((Bengali, SkTEndian_SwapBE16(67))) + ((Assamese, SkTEndian_SwapBE16(68))) + ((Gujarati, SkTEndian_SwapBE16(69))) + ((Punjabi, SkTEndian_SwapBE16(70))) + ((Oriya, SkTEndian_SwapBE16(71))) + ((Malayalam, SkTEndian_SwapBE16(72))) + ((Kannada, SkTEndian_SwapBE16(73))) + ((Tamil, SkTEndian_SwapBE16(74))) + ((Telugu, SkTEndian_SwapBE16(75))) + ((Sinhalese, SkTEndian_SwapBE16(76))) + ((Burmese, SkTEndian_SwapBE16(77))) + ((Khmer, SkTEndian_SwapBE16(78))) + ((Lao, SkTEndian_SwapBE16(79))) + ((Vietnamese, SkTEndian_SwapBE16(80))) + ((Indonesian, SkTEndian_SwapBE16(81))) + ((Tagalong, SkTEndian_SwapBE16(82))) + ((MalayRoman, SkTEndian_SwapBE16(83))) + ((MalayArabic, SkTEndian_SwapBE16(84))) + ((Amharic, SkTEndian_SwapBE16(85))) + ((Tigrinya, SkTEndian_SwapBE16(86))) + ((Galla, SkTEndian_SwapBE16(87))) + ((Somali, SkTEndian_SwapBE16(88))) + ((Swahili, SkTEndian_SwapBE16(89))) + ((Kinyarwanda_Ruanda, SkTEndian_SwapBE16(90))) + ((Rundi, SkTEndian_SwapBE16(91))) + ((Nyanja_Chewa, SkTEndian_SwapBE16(92))) + ((Malagasy, SkTEndian_SwapBE16(93))) + ((Esperanto, SkTEndian_SwapBE16(94))) + ((Welsh, SkTEndian_SwapBE16(128))) + ((Basque, SkTEndian_SwapBE16(129))) + ((Catalan, SkTEndian_SwapBE16(130))) + ((Latin, SkTEndian_SwapBE16(131))) + ((Quenchua, SkTEndian_SwapBE16(132))) + ((Guarani, SkTEndian_SwapBE16(133))) + ((Aymara, SkTEndian_SwapBE16(134))) + ((Tatar, SkTEndian_SwapBE16(135))) + ((Uighur, SkTEndian_SwapBE16(136))) + ((Dzongkha, SkTEndian_SwapBE16(137))) + ((JavaneseRoman, SkTEndian_SwapBE16(138))) + ((SundaneseRoman, SkTEndian_SwapBE16(139))) + ((Galician, SkTEndian_SwapBE16(140))) + ((Afrikaans, SkTEndian_SwapBE16(141))) + ((Breton, SkTEndian_SwapBE16(142))) + ((Inuktitut, SkTEndian_SwapBE16(143))) + ((ScottishGaelic, SkTEndian_SwapBE16(144))) + ((ManxGaelic, SkTEndian_SwapBE16(145))) + ((IrishGaelicWithLenition, SkTEndian_SwapBE16(146))) + ((Tongan, SkTEndian_SwapBE16(147))) + ((GreekPolytonic, SkTEndian_SwapBE16(148))) + ((Greenlandic, SkTEndian_SwapBE16(149))) + ((AzerbaijaniRoman, SkTEndian_SwapBE16(150))) + SK_SEQ_END, + (value)SK_SEQ_END) + } macintosh; + struct Windows { + SK_TYPED_ENUM(Value, SK_OT_USHORT, + ((Afrikaans_SouthAfrica, SkTEndian_SwapBE16(0x0436))) + ((Albanian_Albania, SkTEndian_SwapBE16(0x041C))) + ((Alsatian_France, SkTEndian_SwapBE16(0x0484))) + ((Amharic_Ethiopia, SkTEndian_SwapBE16(0x045E))) + ((Arabic_Algeria, SkTEndian_SwapBE16(0x1401))) + ((Arabic_Bahrain, SkTEndian_SwapBE16(0x3C01))) + ((Arabic_Egypt, SkTEndian_SwapBE16(0x0C01))) + ((Arabic_Iraq, SkTEndian_SwapBE16(0x0801))) + ((Arabic_Jordan, SkTEndian_SwapBE16(0x2C01))) + ((Arabic_Kuwait, SkTEndian_SwapBE16(0x3401))) + ((Arabic_Lebanon, SkTEndian_SwapBE16(0x3001))) + ((Arabic_Libya, SkTEndian_SwapBE16(0x1001))) + ((Arabic_Morocco, SkTEndian_SwapBE16(0x1801))) + ((Arabic_Oman, SkTEndian_SwapBE16(0x2001))) + ((Arabic_Qatar, SkTEndian_SwapBE16(0x4001))) + ((Arabic_SaudiArabia, SkTEndian_SwapBE16(0x0401))) + ((Arabic_Syria, SkTEndian_SwapBE16(0x2801))) + ((Arabic_Tunisia, SkTEndian_SwapBE16(0x1C01))) + ((Arabic_UAE, SkTEndian_SwapBE16(0x3801))) + ((Arabic_Yemen, SkTEndian_SwapBE16(0x2401))) + ((Armenian_Armenia, SkTEndian_SwapBE16(0x042B))) + ((Assamese_India, SkTEndian_SwapBE16(0x044D))) + ((AzeriCyrillic_Azerbaijan, SkTEndian_SwapBE16(0x082C))) + ((AzeriLatin_Azerbaijan, SkTEndian_SwapBE16(0x042C))) + ((Bashkir_Russia, SkTEndian_SwapBE16(0x046D))) + ((Basque_Basque, SkTEndian_SwapBE16(0x042D))) + ((Belarusian_Belarus, SkTEndian_SwapBE16(0x0423))) + ((Bengali_Bangladesh, SkTEndian_SwapBE16(0x0845))) + ((Bengali_India, SkTEndian_SwapBE16(0x0445))) + ((BosnianCyrillic_BosniaAndHerzegovina, SkTEndian_SwapBE16(0x201A))) + ((BosnianLatin_BosniaAndHerzegovina, SkTEndian_SwapBE16(0x141A))) + ((Breton_France, SkTEndian_SwapBE16(0x047E))) + ((Bulgarian_Bulgaria, SkTEndian_SwapBE16(0x0402))) + ((Catalan_Catalan, SkTEndian_SwapBE16(0x0403))) + ((Chinese_HongKongSAR, SkTEndian_SwapBE16(0x0C04))) + ((Chinese_MacaoSAR, SkTEndian_SwapBE16(0x1404))) + ((Chinese_PeoplesRepublicOfChina, SkTEndian_SwapBE16(0x0804))) + ((Chinese_Singapore, SkTEndian_SwapBE16(0x1004))) + ((Chinese_Taiwan, SkTEndian_SwapBE16(0x0404))) + ((Corsican_France, SkTEndian_SwapBE16(0x0483))) + ((Croatian_Croatia, SkTEndian_SwapBE16(0x041A))) + ((CroatianLatin_BosniaAndHerzegovina, SkTEndian_SwapBE16(0x101A))) + ((Czech_CzechRepublic, SkTEndian_SwapBE16(0x0405))) + ((Danish_Denmark, SkTEndian_SwapBE16(0x0406))) + ((Dari_Afghanistan, SkTEndian_SwapBE16(0x048C))) + ((Divehi_Maldives, SkTEndian_SwapBE16(0x0465))) + ((Dutch_Belgium, SkTEndian_SwapBE16(0x0813))) + ((Dutch_Netherlands, SkTEndian_SwapBE16(0x0413))) + ((English_Australia, SkTEndian_SwapBE16(0x0C09))) + ((English_Belize, SkTEndian_SwapBE16(0x2809))) + ((English_Canada, SkTEndian_SwapBE16(0x1009))) + ((English_Caribbean, SkTEndian_SwapBE16(0x2409))) + ((English_India, SkTEndian_SwapBE16(0x4009))) + ((English_Ireland, SkTEndian_SwapBE16(0x1809))) + ((English_Jamaica, SkTEndian_SwapBE16(0x2009))) + ((English_Malaysia, SkTEndian_SwapBE16(0x4409))) + ((English_NewZealand, SkTEndian_SwapBE16(0x1409))) + ((English_RepublicOfThePhilippines, SkTEndian_SwapBE16(0x3409))) + ((English_Singapore, SkTEndian_SwapBE16(0x4809))) + ((English_SouthAfrica, SkTEndian_SwapBE16(0x1C09))) + ((English_TrinidadAndTobago, SkTEndian_SwapBE16(0x2C09))) + ((English_UnitedKingdom, SkTEndian_SwapBE16(0x0809))) + ((English_UnitedStates, SkTEndian_SwapBE16(0x0409))) + ((English_Zimbabwe, SkTEndian_SwapBE16(0x3009))) + ((Estonian_Estonia, SkTEndian_SwapBE16(0x0425))) + ((Faroese_FaroeIslands, SkTEndian_SwapBE16(0x0438))) + ((Filipino_Philippines, SkTEndian_SwapBE16(0x0464))) + ((Finnish_Finland, SkTEndian_SwapBE16(0x040B))) + ((French_Belgium, SkTEndian_SwapBE16(0x080C))) + ((French_Canada, SkTEndian_SwapBE16(0x0C0C))) + ((French_France, SkTEndian_SwapBE16(0x040C))) + ((French_Luxembourg, SkTEndian_SwapBE16(0x140c))) + ((French_PrincipalityOfMonoco, SkTEndian_SwapBE16(0x180C))) + ((French_Switzerland, SkTEndian_SwapBE16(0x100C))) + ((Frisian_Netherlands, SkTEndian_SwapBE16(0x0462))) + ((Galician_Galician, SkTEndian_SwapBE16(0x0456))) + ((Georgian_Georgia, SkTEndian_SwapBE16(0x0437))) + ((German_Austria, SkTEndian_SwapBE16(0x0C07))) + ((German_Germany, SkTEndian_SwapBE16(0x0407))) + ((German_Liechtenstein, SkTEndian_SwapBE16(0x1407))) + ((German_Luxembourg, SkTEndian_SwapBE16(0x1007))) + ((German_Switzerland, SkTEndian_SwapBE16(0x0807))) + ((Greek_Greece, SkTEndian_SwapBE16(0x0408))) + ((Greenlandic_Greenland, SkTEndian_SwapBE16(0x046F))) + ((Gujarati_India, SkTEndian_SwapBE16(0x0447))) + ((HausaLatin_Nigeria, SkTEndian_SwapBE16(0x0468))) + ((Hebrew_Israel, SkTEndian_SwapBE16(0x040D))) + ((Hindi_India, SkTEndian_SwapBE16(0x0439))) + ((Hungarian_Hungary, SkTEndian_SwapBE16(0x040E))) + ((Icelandic_Iceland, SkTEndian_SwapBE16(0x040F))) + ((Igbo_Nigeria, SkTEndian_SwapBE16(0x0470))) + ((Indonesian_Indonesia, SkTEndian_SwapBE16(0x0421))) + ((Inuktitut_Canada, SkTEndian_SwapBE16(0x045D))) + ((InuktitutLatin_Canada, SkTEndian_SwapBE16(0x085D))) + ((Irish_Ireland, SkTEndian_SwapBE16(0x083C))) + ((isiXhosa_SouthAfrica, SkTEndian_SwapBE16(0x0434))) + ((isiZulu_SouthAfrica, SkTEndian_SwapBE16(0x0435))) + ((Italian_Italy, SkTEndian_SwapBE16(0x0410))) + ((Italian_Switzerland, SkTEndian_SwapBE16(0x0810))) + ((Japanese_Japan, SkTEndian_SwapBE16(0x0411))) + ((Kannada_India, SkTEndian_SwapBE16(0x044B))) + ((Kazakh_Kazakhstan, SkTEndian_SwapBE16(0x043F))) + ((Khmer_Cambodia, SkTEndian_SwapBE16(0x0453))) + ((Kiche_Guatemala, SkTEndian_SwapBE16(0x0486))) + ((Kinyarwanda_Rwanda, SkTEndian_SwapBE16(0x0487))) + ((Kiswahili_Kenya, SkTEndian_SwapBE16(0x0441))) + ((Konkani_India, SkTEndian_SwapBE16(0x0457))) + ((Korean_Korea, SkTEndian_SwapBE16(0x0412))) + ((Kyrgyz_Kyrgyzstan, SkTEndian_SwapBE16(0x0440))) + ((Lao_LaoPDR, SkTEndian_SwapBE16(0x0454))) + ((Latvian_Latvia, SkTEndian_SwapBE16(0x0426))) + ((Lithuanian_Lithuania, SkTEndian_SwapBE16(0x0427))) + ((LowerSorbian_Germany, SkTEndian_SwapBE16(0x082E))) + ((Luxembourgish_Luxembourg, SkTEndian_SwapBE16(0x046E))) + ((MacedonianFYROM_FormerYugoslavRepublicOfMacedonia, SkTEndian_SwapBE16(0x042F))) + ((Malay_BruneiDarussalam, SkTEndian_SwapBE16(0x083E))) + ((Malay_Malaysia, SkTEndian_SwapBE16(0x043E))) + ((Malayalam_India, SkTEndian_SwapBE16(0x044C))) + ((Maltese_Malta, SkTEndian_SwapBE16(0x043A))) + ((Maori_NewZealand, SkTEndian_SwapBE16(0x0481))) + ((Mapudungun_Chile, SkTEndian_SwapBE16(0x047A))) + ((Marathi_India, SkTEndian_SwapBE16(0x044E))) + ((Mohawk_Mohawk, SkTEndian_SwapBE16(0x047C))) + ((MongolianCyrillic_Mongolia, SkTEndian_SwapBE16(0x0450))) + ((MongolianTraditional_PeoplesRepublicOfChina, SkTEndian_SwapBE16(0x0850))) + ((Nepali_Nepal, SkTEndian_SwapBE16(0x0461))) + ((NorwegianBokmal_Norway, SkTEndian_SwapBE16(0x0414))) + ((NorwegianNynorsk_Norway, SkTEndian_SwapBE16(0x0814))) + ((Occitan_France, SkTEndian_SwapBE16(0x0482))) + ((Odia_India, SkTEndian_SwapBE16(0x0448))) + ((Pashto_Afghanistan, SkTEndian_SwapBE16(0x0463))) + ((Polish_Poland, SkTEndian_SwapBE16(0x0415))) + ((Portuguese_Brazil, SkTEndian_SwapBE16(0x0416))) + ((Portuguese_Portugal, SkTEndian_SwapBE16(0x0816))) + ((Punjabi_India, SkTEndian_SwapBE16(0x0446))) + ((Quechua_Bolivia, SkTEndian_SwapBE16(0x046B))) + ((Quechua_Ecuador, SkTEndian_SwapBE16(0x086B))) + ((Quechua_Peru, SkTEndian_SwapBE16(0x0C6B))) + ((Romanian_Romania, SkTEndian_SwapBE16(0x0418))) + ((Romansh_Switzerland, SkTEndian_SwapBE16(0x0417))) + ((Russian_Russia, SkTEndian_SwapBE16(0x0419))) + ((SamiInari_Finland, SkTEndian_SwapBE16(0x243B))) + ((SamiLule_Norway, SkTEndian_SwapBE16(0x103B))) + ((SamiLule_Sweden, SkTEndian_SwapBE16(0x143B))) + ((SamiNorthern_Finland, SkTEndian_SwapBE16(0x0C3B))) + ((SamiNorthern_Norway, SkTEndian_SwapBE16(0x043B))) + ((SamiNorthern_Sweden, SkTEndian_SwapBE16(0x083B))) + ((SamiSkolt_Finland, SkTEndian_SwapBE16(0x203B))) + ((SamiSouthern_Norway, SkTEndian_SwapBE16(0x183B))) + ((SamiSouthern_Sweden, SkTEndian_SwapBE16(0x1C3B))) + ((Sanskrit_India, SkTEndian_SwapBE16(0x044F))) + ((SerbianCyrillic_BosniaAndHerzegovina, SkTEndian_SwapBE16(0x1C1A))) + ((SerbianCyrillic_Serbia, SkTEndian_SwapBE16(0x0C1A))) + ((SerbianLatin_BosniaAndHerzegovina, SkTEndian_SwapBE16(0x181A))) + ((SerbianLatin_Serbia, SkTEndian_SwapBE16(0x081A))) + ((SesothoSaLeboa_SouthAfrica, SkTEndian_SwapBE16(0x046C))) + ((Setswana_SouthAfrica, SkTEndian_SwapBE16(0x0432))) + ((Sinhala_SriLanka, SkTEndian_SwapBE16(0x045B))) + ((Slovak_Slovakia, SkTEndian_SwapBE16(0x041B))) + ((Slovenian_Slovenia, SkTEndian_SwapBE16(0x0424))) + ((Spanish_Argentina, SkTEndian_SwapBE16(0x2C0A))) + ((Spanish_Bolivia, SkTEndian_SwapBE16(0x400A))) + ((Spanish_Chile, SkTEndian_SwapBE16(0x340A))) + ((Spanish_Colombia, SkTEndian_SwapBE16(0x240A))) + ((Spanish_CostaRica, SkTEndian_SwapBE16(0x140A))) + ((Spanish_DominicanRepublic, SkTEndian_SwapBE16(0x1C0A))) + ((Spanish_Ecuador, SkTEndian_SwapBE16(0x300A))) + ((Spanish_ElSalvador, SkTEndian_SwapBE16(0x440A))) + ((Spanish_Guatemala, SkTEndian_SwapBE16(0x100A))) + ((Spanish_Honduras, SkTEndian_SwapBE16(0x480A))) + ((Spanish_Mexico, SkTEndian_SwapBE16(0x080A))) + ((Spanish_Nicaragua, SkTEndian_SwapBE16(0x4C0A))) + ((Spanish_Panama, SkTEndian_SwapBE16(0x180A))) + ((Spanish_Paraguay, SkTEndian_SwapBE16(0x3C0A))) + ((Spanish_Peru, SkTEndian_SwapBE16(0x280A))) + ((Spanish_PuertoRico, SkTEndian_SwapBE16(0x500A))) + ((SpanishModernSort_Spain, SkTEndian_SwapBE16(0x0C0A))) + ((SpanishTraditionalSort_Spain, SkTEndian_SwapBE16(0x040A))) + ((Spanish_UnitedStates, SkTEndian_SwapBE16(0x540A))) + ((Spanish_Uruguay, SkTEndian_SwapBE16(0x380A))) + ((Spanish_Venezuela, SkTEndian_SwapBE16(0x200A))) + ((Sweden_Finland, SkTEndian_SwapBE16(0x081D))) + ((Swedish_Sweden, SkTEndian_SwapBE16(0x041D))) + ((Syriac_Syria, SkTEndian_SwapBE16(0x045A))) + ((TajikCyrillic_Tajikistan, SkTEndian_SwapBE16(0x0428))) + ((TamazightLatin_Algeria, SkTEndian_SwapBE16(0x085F))) + ((Tamil_India, SkTEndian_SwapBE16(0x0449))) + ((Tatar_Russia, SkTEndian_SwapBE16(0x0444))) + ((Telugu_India, SkTEndian_SwapBE16(0x044A))) + ((Thai_Thailand, SkTEndian_SwapBE16(0x041E))) + ((Tibetan_PRC, SkTEndian_SwapBE16(0x0451))) + ((Turkish_Turkey, SkTEndian_SwapBE16(0x041F))) + ((Turkmen_Turkmenistan, SkTEndian_SwapBE16(0x0442))) + ((Uighur_PRC, SkTEndian_SwapBE16(0x0480))) + ((Ukrainian_Ukraine, SkTEndian_SwapBE16(0x0422))) + ((UpperSorbian_Germany, SkTEndian_SwapBE16(0x042E))) + ((Urdu_IslamicRepublicOfPakistan, SkTEndian_SwapBE16(0x0420))) + ((UzbekCyrillic_Uzbekistan, SkTEndian_SwapBE16(0x0843))) + ((UzbekLatin_Uzbekistan, SkTEndian_SwapBE16(0x0443))) + ((Vietnamese_Vietnam, SkTEndian_SwapBE16(0x042A))) + ((Welsh_UnitedKingdom, SkTEndian_SwapBE16(0x0452))) + ((Wolof_Senegal, SkTEndian_SwapBE16(0x0488))) + ((Yakut_Russia, SkTEndian_SwapBE16(0x0485))) + ((Yi_PRC, SkTEndian_SwapBE16(0x0478))) + ((Yoruba_Nigeria, SkTEndian_SwapBE16(0x046A))) + SK_SEQ_END, + (value)SK_SEQ_END) + } windows; + //languageTagID - 0x8000 is an index into the langTagRecord array. + SK_OT_USHORT languageTagID; + } languageID; + union NameID { + struct Predefined { + SK_TYPED_ENUM(Value, SK_OT_USHORT, + ((CopyrightNotice, SkTEndian_SwapBE16(0))) + ((FontFamilyName, SkTEndian_SwapBE16(1))) + ((FontSubfamilyName, SkTEndian_SwapBE16(2))) + ((UniqueFontIdentifier, SkTEndian_SwapBE16(3))) + ((FullFontName, SkTEndian_SwapBE16(4))) + ((VersionString, SkTEndian_SwapBE16(5))) //Version . + ((PostscriptName, SkTEndian_SwapBE16(6))) //See spec for constraints. + ((Trademark, SkTEndian_SwapBE16(7))) + ((ManufacturerName, SkTEndian_SwapBE16(8))) + ((Designer, SkTEndian_SwapBE16(9))) + ((Description, SkTEndian_SwapBE16(10))) + ((URLVendor, SkTEndian_SwapBE16(11))) + ((URLDesigner, SkTEndian_SwapBE16(12))) + ((LicenseDescription, SkTEndian_SwapBE16(13))) + ((LicenseInfoURL, SkTEndian_SwapBE16(14))) + ((PreferredFamily, SkTEndian_SwapBE16(16))) + ((PreferredSubfamily, SkTEndian_SwapBE16(17))) + ((CompatibleFullName, SkTEndian_SwapBE16(18))) + ((SampleText, SkTEndian_SwapBE16(19))) + ((PostscriptCIDFindfontName, SkTEndian_SwapBE16(20))) + ((WWSFamilyName, SkTEndian_SwapBE16(21))) + ((WWSSubfamilyName, SkTEndian_SwapBE16(22))) + SK_SEQ_END, + (value)SK_SEQ_END) + } predefined; + //values > 256 are font specific strings. + SK_OT_USHORT fontSpecific; + } nameID; + SK_OT_USHORT length; + SK_OT_USHORT offset; //From start of storage area. +}; + +#pragma pack(pop) + + +SK_COMPILE_ASSERT(sizeof(SkOTTableName) == 6, sizeof_SkOTTableName_not_6); +SK_COMPILE_ASSERT(sizeof(SkOTTableNameF1) == 2, sizeof_SkOTTableNameF1_not_2); +SK_COMPILE_ASSERT(sizeof(SkOTTableNameLangTagRecord) == 4, sizeof_SkOTTableNameLangTagRecord_not_4); +SK_COMPILE_ASSERT(sizeof(SkOTTableNameRecord) == 12, sizeof_SkOTTableNameRecord_not_12); + +#endif diff --git a/src/sfnt/SkOTUtils.cpp b/src/sfnt/SkOTUtils.cpp new file mode 100644 index 0000000000..1301a06e02 --- /dev/null +++ b/src/sfnt/SkOTUtils.cpp @@ -0,0 +1,18 @@ +/* + * Copyright 2012 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ + +#include "SkOTTableTypes.h" +#include "SkOTUtils.h" + +uint32_t SkOTUtils::CalcTableChecksum(SK_OT_ULONG *data, size_t length) { + uint32_t sum = 0; + SK_OT_ULONG *dataEnd = data + ((length + 3) & ~3) / sizeof(SK_OT_ULONG); + for (; data < dataEnd; ++data) { + sum += SkEndian_SwapBE32(*data); + } + return sum; +} diff --git a/src/sfnt/SkOTUtils.h b/src/sfnt/SkOTUtils.h new file mode 100644 index 0000000000..7a58b4d219 --- /dev/null +++ b/src/sfnt/SkOTUtils.h @@ -0,0 +1,17 @@ +/* + * Copyright 2012 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ + +#ifndef SkOTUtils_DEFINED +#define SkOTUtils_DEFINED + +#include "SkOTTableTypes.h" + +struct SkOTUtils { + static uint32_t CalcTableChecksum(SK_OT_ULONG *data, size_t length); +}; + +#endif diff --git a/src/sfnt/SkPreprocessorSeq.h b/src/sfnt/SkPreprocessorSeq.h index b9a821a5e1..fed24181a9 100644 --- a/src/sfnt/SkPreprocessorSeq.h +++ b/src/sfnt/SkPreprocessorSeq.h @@ -62,6 +62,246 @@ #define SK_SEQ_SIZE_14(_) SK_SEQ_SIZE_15 #define SK_SEQ_SIZE_15(_) SK_SEQ_SIZE_16 #define SK_SEQ_SIZE_16(_) SK_SEQ_SIZE_17 +#define SK_SEQ_SIZE_17(_) SK_SEQ_SIZE_18 +#define SK_SEQ_SIZE_18(_) SK_SEQ_SIZE_19 +#define SK_SEQ_SIZE_19(_) SK_SEQ_SIZE_20 +#define SK_SEQ_SIZE_20(_) SK_SEQ_SIZE_21 +#define SK_SEQ_SIZE_21(_) SK_SEQ_SIZE_22 +#define SK_SEQ_SIZE_22(_) SK_SEQ_SIZE_23 +#define SK_SEQ_SIZE_23(_) SK_SEQ_SIZE_24 +#define SK_SEQ_SIZE_24(_) SK_SEQ_SIZE_25 +#define SK_SEQ_SIZE_25(_) SK_SEQ_SIZE_26 +#define SK_SEQ_SIZE_26(_) SK_SEQ_SIZE_27 +#define SK_SEQ_SIZE_27(_) SK_SEQ_SIZE_28 +#define SK_SEQ_SIZE_28(_) SK_SEQ_SIZE_29 +#define SK_SEQ_SIZE_29(_) SK_SEQ_SIZE_30 +#define SK_SEQ_SIZE_30(_) SK_SEQ_SIZE_31 +#define SK_SEQ_SIZE_31(_) SK_SEQ_SIZE_32 +#define SK_SEQ_SIZE_32(_) SK_SEQ_SIZE_33 +#define SK_SEQ_SIZE_33(_) SK_SEQ_SIZE_34 +#define SK_SEQ_SIZE_34(_) SK_SEQ_SIZE_35 +#define SK_SEQ_SIZE_35(_) SK_SEQ_SIZE_36 +#define SK_SEQ_SIZE_36(_) SK_SEQ_SIZE_37 +#define SK_SEQ_SIZE_37(_) SK_SEQ_SIZE_38 +#define SK_SEQ_SIZE_38(_) SK_SEQ_SIZE_39 +#define SK_SEQ_SIZE_39(_) SK_SEQ_SIZE_40 +#define SK_SEQ_SIZE_40(_) SK_SEQ_SIZE_41 +#define SK_SEQ_SIZE_41(_) SK_SEQ_SIZE_42 +#define SK_SEQ_SIZE_42(_) SK_SEQ_SIZE_43 +#define SK_SEQ_SIZE_43(_) SK_SEQ_SIZE_44 +#define SK_SEQ_SIZE_44(_) SK_SEQ_SIZE_45 +#define SK_SEQ_SIZE_45(_) SK_SEQ_SIZE_46 +#define SK_SEQ_SIZE_46(_) SK_SEQ_SIZE_47 +#define SK_SEQ_SIZE_47(_) SK_SEQ_SIZE_48 +#define SK_SEQ_SIZE_48(_) SK_SEQ_SIZE_49 +#define SK_SEQ_SIZE_49(_) SK_SEQ_SIZE_50 +#define SK_SEQ_SIZE_50(_) SK_SEQ_SIZE_51 +#define SK_SEQ_SIZE_51(_) SK_SEQ_SIZE_52 +#define SK_SEQ_SIZE_52(_) SK_SEQ_SIZE_53 +#define SK_SEQ_SIZE_53(_) SK_SEQ_SIZE_54 +#define SK_SEQ_SIZE_54(_) SK_SEQ_SIZE_55 +#define SK_SEQ_SIZE_55(_) SK_SEQ_SIZE_56 +#define SK_SEQ_SIZE_56(_) SK_SEQ_SIZE_57 +#define SK_SEQ_SIZE_57(_) SK_SEQ_SIZE_58 +#define SK_SEQ_SIZE_58(_) SK_SEQ_SIZE_59 +#define SK_SEQ_SIZE_59(_) SK_SEQ_SIZE_60 +#define SK_SEQ_SIZE_60(_) SK_SEQ_SIZE_61 +#define SK_SEQ_SIZE_61(_) SK_SEQ_SIZE_62 +#define SK_SEQ_SIZE_62(_) SK_SEQ_SIZE_63 +#define SK_SEQ_SIZE_63(_) SK_SEQ_SIZE_64 +#define SK_SEQ_SIZE_64(_) SK_SEQ_SIZE_65 +#define SK_SEQ_SIZE_65(_) SK_SEQ_SIZE_66 +#define SK_SEQ_SIZE_66(_) SK_SEQ_SIZE_67 +#define SK_SEQ_SIZE_67(_) SK_SEQ_SIZE_68 +#define SK_SEQ_SIZE_68(_) SK_SEQ_SIZE_69 +#define SK_SEQ_SIZE_69(_) SK_SEQ_SIZE_70 +#define SK_SEQ_SIZE_70(_) SK_SEQ_SIZE_71 +#define SK_SEQ_SIZE_71(_) SK_SEQ_SIZE_72 +#define SK_SEQ_SIZE_72(_) SK_SEQ_SIZE_73 +#define SK_SEQ_SIZE_73(_) SK_SEQ_SIZE_74 +#define SK_SEQ_SIZE_74(_) SK_SEQ_SIZE_75 +#define SK_SEQ_SIZE_75(_) SK_SEQ_SIZE_76 +#define SK_SEQ_SIZE_76(_) SK_SEQ_SIZE_77 +#define SK_SEQ_SIZE_77(_) SK_SEQ_SIZE_78 +#define SK_SEQ_SIZE_78(_) SK_SEQ_SIZE_79 +#define SK_SEQ_SIZE_79(_) SK_SEQ_SIZE_80 +#define SK_SEQ_SIZE_80(_) SK_SEQ_SIZE_81 +#define SK_SEQ_SIZE_81(_) SK_SEQ_SIZE_82 +#define SK_SEQ_SIZE_82(_) SK_SEQ_SIZE_83 +#define SK_SEQ_SIZE_83(_) SK_SEQ_SIZE_84 +#define SK_SEQ_SIZE_84(_) SK_SEQ_SIZE_85 +#define SK_SEQ_SIZE_85(_) SK_SEQ_SIZE_86 +#define SK_SEQ_SIZE_86(_) SK_SEQ_SIZE_87 +#define SK_SEQ_SIZE_87(_) SK_SEQ_SIZE_88 +#define SK_SEQ_SIZE_88(_) SK_SEQ_SIZE_89 +#define SK_SEQ_SIZE_89(_) SK_SEQ_SIZE_90 +#define SK_SEQ_SIZE_90(_) SK_SEQ_SIZE_91 +#define SK_SEQ_SIZE_91(_) SK_SEQ_SIZE_92 +#define SK_SEQ_SIZE_92(_) SK_SEQ_SIZE_93 +#define SK_SEQ_SIZE_93(_) SK_SEQ_SIZE_94 +#define SK_SEQ_SIZE_94(_) SK_SEQ_SIZE_95 +#define SK_SEQ_SIZE_95(_) SK_SEQ_SIZE_96 +#define SK_SEQ_SIZE_96(_) SK_SEQ_SIZE_97 +#define SK_SEQ_SIZE_97(_) SK_SEQ_SIZE_98 +#define SK_SEQ_SIZE_98(_) SK_SEQ_SIZE_99 +#define SK_SEQ_SIZE_99(_) SK_SEQ_SIZE_100 +#define SK_SEQ_SIZE_100(_) SK_SEQ_SIZE_101 +#define SK_SEQ_SIZE_101(_) SK_SEQ_SIZE_102 +#define SK_SEQ_SIZE_102(_) SK_SEQ_SIZE_103 +#define SK_SEQ_SIZE_103(_) SK_SEQ_SIZE_104 +#define SK_SEQ_SIZE_104(_) SK_SEQ_SIZE_105 +#define SK_SEQ_SIZE_105(_) SK_SEQ_SIZE_106 +#define SK_SEQ_SIZE_106(_) SK_SEQ_SIZE_107 +#define SK_SEQ_SIZE_107(_) SK_SEQ_SIZE_108 +#define SK_SEQ_SIZE_108(_) SK_SEQ_SIZE_109 +#define SK_SEQ_SIZE_109(_) SK_SEQ_SIZE_110 +#define SK_SEQ_SIZE_110(_) SK_SEQ_SIZE_111 +#define SK_SEQ_SIZE_111(_) SK_SEQ_SIZE_112 +#define SK_SEQ_SIZE_112(_) SK_SEQ_SIZE_113 +#define SK_SEQ_SIZE_113(_) SK_SEQ_SIZE_114 +#define SK_SEQ_SIZE_114(_) SK_SEQ_SIZE_115 +#define SK_SEQ_SIZE_115(_) SK_SEQ_SIZE_116 +#define SK_SEQ_SIZE_116(_) SK_SEQ_SIZE_117 +#define SK_SEQ_SIZE_117(_) SK_SEQ_SIZE_118 +#define SK_SEQ_SIZE_118(_) SK_SEQ_SIZE_119 +#define SK_SEQ_SIZE_119(_) SK_SEQ_SIZE_120 +#define SK_SEQ_SIZE_120(_) SK_SEQ_SIZE_121 +#define SK_SEQ_SIZE_121(_) SK_SEQ_SIZE_122 +#define SK_SEQ_SIZE_122(_) SK_SEQ_SIZE_123 +#define SK_SEQ_SIZE_123(_) SK_SEQ_SIZE_124 +#define SK_SEQ_SIZE_124(_) SK_SEQ_SIZE_125 +#define SK_SEQ_SIZE_125(_) SK_SEQ_SIZE_126 +#define SK_SEQ_SIZE_126(_) SK_SEQ_SIZE_127 +#define SK_SEQ_SIZE_127(_) SK_SEQ_SIZE_128 +#define SK_SEQ_SIZE_128(_) SK_SEQ_SIZE_129 +#define SK_SEQ_SIZE_129(_) SK_SEQ_SIZE_130 +#define SK_SEQ_SIZE_130(_) SK_SEQ_SIZE_131 +#define SK_SEQ_SIZE_131(_) SK_SEQ_SIZE_132 +#define SK_SEQ_SIZE_132(_) SK_SEQ_SIZE_133 +#define SK_SEQ_SIZE_133(_) SK_SEQ_SIZE_134 +#define SK_SEQ_SIZE_134(_) SK_SEQ_SIZE_135 +#define SK_SEQ_SIZE_135(_) SK_SEQ_SIZE_136 +#define SK_SEQ_SIZE_136(_) SK_SEQ_SIZE_137 +#define SK_SEQ_SIZE_137(_) SK_SEQ_SIZE_138 +#define SK_SEQ_SIZE_138(_) SK_SEQ_SIZE_139 +#define SK_SEQ_SIZE_139(_) SK_SEQ_SIZE_140 +#define SK_SEQ_SIZE_140(_) SK_SEQ_SIZE_141 +#define SK_SEQ_SIZE_141(_) SK_SEQ_SIZE_142 +#define SK_SEQ_SIZE_142(_) SK_SEQ_SIZE_143 +#define SK_SEQ_SIZE_143(_) SK_SEQ_SIZE_144 +#define SK_SEQ_SIZE_144(_) SK_SEQ_SIZE_145 +#define SK_SEQ_SIZE_145(_) SK_SEQ_SIZE_146 +#define SK_SEQ_SIZE_146(_) SK_SEQ_SIZE_147 +#define SK_SEQ_SIZE_147(_) SK_SEQ_SIZE_148 +#define SK_SEQ_SIZE_148(_) SK_SEQ_SIZE_149 +#define SK_SEQ_SIZE_149(_) SK_SEQ_SIZE_150 +#define SK_SEQ_SIZE_150(_) SK_SEQ_SIZE_151 +#define SK_SEQ_SIZE_151(_) SK_SEQ_SIZE_152 +#define SK_SEQ_SIZE_152(_) SK_SEQ_SIZE_153 +#define SK_SEQ_SIZE_153(_) SK_SEQ_SIZE_154 +#define SK_SEQ_SIZE_154(_) SK_SEQ_SIZE_155 +#define SK_SEQ_SIZE_155(_) SK_SEQ_SIZE_156 +#define SK_SEQ_SIZE_156(_) SK_SEQ_SIZE_157 +#define SK_SEQ_SIZE_157(_) SK_SEQ_SIZE_158 +#define SK_SEQ_SIZE_158(_) SK_SEQ_SIZE_159 +#define SK_SEQ_SIZE_159(_) SK_SEQ_SIZE_160 +#define SK_SEQ_SIZE_160(_) SK_SEQ_SIZE_161 +#define SK_SEQ_SIZE_161(_) SK_SEQ_SIZE_162 +#define SK_SEQ_SIZE_162(_) SK_SEQ_SIZE_163 +#define SK_SEQ_SIZE_163(_) SK_SEQ_SIZE_164 +#define SK_SEQ_SIZE_164(_) SK_SEQ_SIZE_165 +#define SK_SEQ_SIZE_165(_) SK_SEQ_SIZE_166 +#define SK_SEQ_SIZE_166(_) SK_SEQ_SIZE_167 +#define SK_SEQ_SIZE_167(_) SK_SEQ_SIZE_168 +#define SK_SEQ_SIZE_168(_) SK_SEQ_SIZE_169 +#define SK_SEQ_SIZE_169(_) SK_SEQ_SIZE_170 +#define SK_SEQ_SIZE_170(_) SK_SEQ_SIZE_171 +#define SK_SEQ_SIZE_171(_) SK_SEQ_SIZE_172 +#define SK_SEQ_SIZE_172(_) SK_SEQ_SIZE_173 +#define SK_SEQ_SIZE_173(_) SK_SEQ_SIZE_174 +#define SK_SEQ_SIZE_174(_) SK_SEQ_SIZE_175 +#define SK_SEQ_SIZE_175(_) SK_SEQ_SIZE_176 +#define SK_SEQ_SIZE_176(_) SK_SEQ_SIZE_177 +#define SK_SEQ_SIZE_177(_) SK_SEQ_SIZE_178 +#define SK_SEQ_SIZE_178(_) SK_SEQ_SIZE_179 +#define SK_SEQ_SIZE_179(_) SK_SEQ_SIZE_180 +#define SK_SEQ_SIZE_180(_) SK_SEQ_SIZE_181 +#define SK_SEQ_SIZE_181(_) SK_SEQ_SIZE_182 +#define SK_SEQ_SIZE_182(_) SK_SEQ_SIZE_183 +#define SK_SEQ_SIZE_183(_) SK_SEQ_SIZE_184 +#define SK_SEQ_SIZE_184(_) SK_SEQ_SIZE_185 +#define SK_SEQ_SIZE_185(_) SK_SEQ_SIZE_186 +#define SK_SEQ_SIZE_186(_) SK_SEQ_SIZE_187 +#define SK_SEQ_SIZE_187(_) SK_SEQ_SIZE_188 +#define SK_SEQ_SIZE_188(_) SK_SEQ_SIZE_189 +#define SK_SEQ_SIZE_189(_) SK_SEQ_SIZE_190 +#define SK_SEQ_SIZE_190(_) SK_SEQ_SIZE_191 +#define SK_SEQ_SIZE_191(_) SK_SEQ_SIZE_192 +#define SK_SEQ_SIZE_192(_) SK_SEQ_SIZE_193 +#define SK_SEQ_SIZE_193(_) SK_SEQ_SIZE_194 +#define SK_SEQ_SIZE_194(_) SK_SEQ_SIZE_195 +#define SK_SEQ_SIZE_195(_) SK_SEQ_SIZE_196 +#define SK_SEQ_SIZE_196(_) SK_SEQ_SIZE_197 +#define SK_SEQ_SIZE_197(_) SK_SEQ_SIZE_198 +#define SK_SEQ_SIZE_198(_) SK_SEQ_SIZE_199 +#define SK_SEQ_SIZE_199(_) SK_SEQ_SIZE_200 +#define SK_SEQ_SIZE_200(_) SK_SEQ_SIZE_201 +#define SK_SEQ_SIZE_201(_) SK_SEQ_SIZE_202 +#define SK_SEQ_SIZE_202(_) SK_SEQ_SIZE_203 +#define SK_SEQ_SIZE_203(_) SK_SEQ_SIZE_204 +#define SK_SEQ_SIZE_204(_) SK_SEQ_SIZE_205 +#define SK_SEQ_SIZE_205(_) SK_SEQ_SIZE_206 +#define SK_SEQ_SIZE_206(_) SK_SEQ_SIZE_207 +#define SK_SEQ_SIZE_207(_) SK_SEQ_SIZE_208 +#define SK_SEQ_SIZE_208(_) SK_SEQ_SIZE_209 +#define SK_SEQ_SIZE_209(_) SK_SEQ_SIZE_210 +#define SK_SEQ_SIZE_210(_) SK_SEQ_SIZE_211 +#define SK_SEQ_SIZE_211(_) SK_SEQ_SIZE_212 +#define SK_SEQ_SIZE_212(_) SK_SEQ_SIZE_213 +#define SK_SEQ_SIZE_213(_) SK_SEQ_SIZE_214 +#define SK_SEQ_SIZE_214(_) SK_SEQ_SIZE_215 +#define SK_SEQ_SIZE_215(_) SK_SEQ_SIZE_216 +#define SK_SEQ_SIZE_216(_) SK_SEQ_SIZE_217 +#define SK_SEQ_SIZE_217(_) SK_SEQ_SIZE_218 +#define SK_SEQ_SIZE_218(_) SK_SEQ_SIZE_219 +#define SK_SEQ_SIZE_219(_) SK_SEQ_SIZE_220 +#define SK_SEQ_SIZE_220(_) SK_SEQ_SIZE_221 +#define SK_SEQ_SIZE_221(_) SK_SEQ_SIZE_222 +#define SK_SEQ_SIZE_222(_) SK_SEQ_SIZE_223 +#define SK_SEQ_SIZE_223(_) SK_SEQ_SIZE_224 +#define SK_SEQ_SIZE_224(_) SK_SEQ_SIZE_225 +#define SK_SEQ_SIZE_225(_) SK_SEQ_SIZE_226 +#define SK_SEQ_SIZE_226(_) SK_SEQ_SIZE_227 +#define SK_SEQ_SIZE_227(_) SK_SEQ_SIZE_228 +#define SK_SEQ_SIZE_228(_) SK_SEQ_SIZE_229 +#define SK_SEQ_SIZE_229(_) SK_SEQ_SIZE_230 +#define SK_SEQ_SIZE_230(_) SK_SEQ_SIZE_231 +#define SK_SEQ_SIZE_231(_) SK_SEQ_SIZE_232 +#define SK_SEQ_SIZE_232(_) SK_SEQ_SIZE_233 +#define SK_SEQ_SIZE_233(_) SK_SEQ_SIZE_234 +#define SK_SEQ_SIZE_234(_) SK_SEQ_SIZE_235 +#define SK_SEQ_SIZE_235(_) SK_SEQ_SIZE_236 +#define SK_SEQ_SIZE_236(_) SK_SEQ_SIZE_237 +#define SK_SEQ_SIZE_237(_) SK_SEQ_SIZE_238 +#define SK_SEQ_SIZE_238(_) SK_SEQ_SIZE_239 +#define SK_SEQ_SIZE_239(_) SK_SEQ_SIZE_240 +#define SK_SEQ_SIZE_240(_) SK_SEQ_SIZE_241 +#define SK_SEQ_SIZE_241(_) SK_SEQ_SIZE_242 +#define SK_SEQ_SIZE_242(_) SK_SEQ_SIZE_243 +#define SK_SEQ_SIZE_243(_) SK_SEQ_SIZE_244 +#define SK_SEQ_SIZE_244(_) SK_SEQ_SIZE_245 +#define SK_SEQ_SIZE_245(_) SK_SEQ_SIZE_246 +#define SK_SEQ_SIZE_246(_) SK_SEQ_SIZE_247 +#define SK_SEQ_SIZE_247(_) SK_SEQ_SIZE_248 +#define SK_SEQ_SIZE_248(_) SK_SEQ_SIZE_249 +#define SK_SEQ_SIZE_249(_) SK_SEQ_SIZE_250 +#define SK_SEQ_SIZE_250(_) SK_SEQ_SIZE_251 +#define SK_SEQ_SIZE_251(_) SK_SEQ_SIZE_252 +#define SK_SEQ_SIZE_252(_) SK_SEQ_SIZE_253 +#define SK_SEQ_SIZE_253(_) SK_SEQ_SIZE_254 +#define SK_SEQ_SIZE_254(_) SK_SEQ_SIZE_255 +#define SK_SEQ_SIZE_255(_) SK_SEQ_SIZE_256 + #define SK_SEQ_SIZE_SK_SEQ_SIZE_0 0 #define SK_SEQ_SIZE_SK_SEQ_SIZE_1 1 @@ -81,6 +321,245 @@ #define SK_SEQ_SIZE_SK_SEQ_SIZE_15 15 #define SK_SEQ_SIZE_SK_SEQ_SIZE_16 16 #define SK_SEQ_SIZE_SK_SEQ_SIZE_17 17 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_18 18 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_19 19 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_20 20 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_21 21 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_22 22 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_23 23 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_24 24 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_25 25 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_26 26 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_27 27 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_28 28 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_29 29 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_30 30 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_31 31 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_32 32 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_33 33 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_34 34 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_35 35 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_36 36 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_37 37 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_38 38 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_39 39 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_40 40 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_41 41 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_42 42 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_43 43 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_44 44 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_45 45 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_46 46 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_47 47 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_48 48 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_49 49 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_50 50 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_51 51 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_52 52 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_53 53 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_54 54 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_55 55 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_56 56 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_57 57 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_58 58 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_59 59 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_60 60 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_61 61 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_62 62 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_63 63 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_64 64 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_65 65 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_66 66 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_67 67 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_68 68 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_69 69 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_70 70 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_71 71 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_72 72 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_73 73 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_74 74 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_75 75 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_76 76 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_77 77 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_78 78 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_79 79 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_80 80 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_81 81 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_82 82 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_83 83 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_84 84 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_85 85 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_86 86 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_87 87 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_88 88 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_89 89 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_90 90 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_91 91 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_92 92 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_93 93 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_94 94 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_95 95 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_96 96 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_97 97 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_98 98 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_99 99 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_100 100 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_101 101 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_102 102 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_103 103 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_104 104 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_105 105 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_106 106 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_107 107 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_108 108 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_109 109 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_110 110 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_111 111 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_112 112 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_113 113 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_114 114 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_115 115 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_116 116 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_117 117 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_118 118 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_119 119 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_120 120 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_121 121 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_122 122 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_123 123 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_124 124 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_125 125 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_126 126 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_127 127 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_128 128 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_129 129 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_130 130 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_131 131 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_132 132 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_133 133 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_134 134 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_135 135 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_136 136 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_137 137 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_138 138 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_139 139 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_140 140 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_141 141 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_142 142 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_143 143 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_144 144 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_145 145 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_146 146 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_147 147 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_148 148 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_149 149 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_150 150 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_151 151 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_152 152 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_153 153 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_154 154 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_155 155 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_156 156 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_157 157 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_158 158 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_159 159 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_160 160 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_161 161 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_162 162 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_163 163 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_164 164 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_165 165 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_166 166 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_167 167 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_168 168 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_169 169 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_170 170 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_171 171 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_172 172 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_173 173 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_174 174 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_175 175 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_176 176 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_177 177 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_178 178 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_179 179 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_180 180 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_181 181 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_182 182 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_183 183 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_184 184 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_185 185 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_186 186 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_187 187 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_188 188 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_189 189 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_190 190 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_191 191 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_192 192 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_193 193 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_194 194 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_195 195 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_196 196 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_197 197 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_198 198 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_199 199 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_200 200 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_201 201 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_202 202 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_203 203 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_204 204 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_205 205 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_206 206 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_207 207 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_208 208 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_209 209 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_210 210 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_211 211 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_212 212 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_213 213 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_214 214 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_215 215 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_216 216 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_217 217 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_218 218 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_219 219 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_220 220 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_221 221 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_222 222 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_223 223 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_224 224 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_225 225 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_226 226 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_227 227 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_228 228 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_229 229 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_230 230 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_231 231 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_232 232 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_233 233 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_234 234 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_235 235 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_236 236 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_237 237 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_238 238 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_239 239 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_240 240 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_241 241 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_242 242 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_243 243 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_244 244 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_245 245 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_246 246 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_247 247 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_248 248 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_249 249 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_250 250 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_251 251 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_252 252 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_253 253 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_254 254 +#define SK_SEQ_SIZE_SK_SEQ_SIZE_255 255 + #define SK_SEQ_FOREACH(op, data, seq) SK_SEQ_FOREACH_L(op, op, data, seq) #define SK_SEQ_FOREACH_L(op, lop, data, seq) SK_CONCAT(SK_SEQ_FOREACH_, SK_SEQ_SIZE(seq)) (op, lop, data, SK_SEQ_HEAD(seq), SK_SEQ_TAIL(seq)) @@ -103,6 +582,244 @@ #define SK_SEQ_FOREACH_15(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_14(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) #define SK_SEQ_FOREACH_16(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_15(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) #define SK_SEQ_FOREACH_17(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_16(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_18(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_17(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_19(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_18(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_20(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_19(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_21(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_20(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_22(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_21(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_23(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_22(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_24(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_23(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_25(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_24(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_26(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_25(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_27(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_26(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_28(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_27(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_29(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_28(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_30(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_29(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_31(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_30(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_32(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_31(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_33(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_32(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_34(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_33(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_35(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_34(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_36(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_35(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_37(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_36(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_38(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_37(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_39(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_38(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_40(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_39(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_41(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_40(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_42(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_41(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_43(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_42(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_44(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_43(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_45(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_44(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_46(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_45(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_47(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_46(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_48(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_47(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_49(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_48(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_50(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_49(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_51(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_50(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_52(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_51(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_53(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_52(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_54(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_53(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_55(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_54(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_56(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_55(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_57(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_56(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_58(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_57(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_59(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_58(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_60(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_59(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_61(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_60(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_62(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_61(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_63(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_62(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_64(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_63(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_65(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_64(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_66(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_65(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_67(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_66(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_68(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_67(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_69(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_68(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_70(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_69(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_71(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_70(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_72(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_71(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_73(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_72(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_74(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_73(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_75(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_74(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_76(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_75(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_77(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_76(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_78(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_77(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_79(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_78(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_80(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_79(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_81(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_80(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_82(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_81(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_83(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_82(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_84(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_83(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_85(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_84(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_86(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_85(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_87(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_86(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_88(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_87(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_89(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_88(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_90(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_89(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_91(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_90(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_92(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_91(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_93(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_92(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_94(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_93(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_95(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_94(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_96(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_95(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_97(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_96(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_98(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_97(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_99(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_98(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_100(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_99(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_101(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_100(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_102(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_101(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_103(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_102(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_104(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_103(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_105(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_104(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_106(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_105(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_107(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_106(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_108(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_107(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_109(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_108(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_110(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_109(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_111(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_110(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_112(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_111(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_113(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_112(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_114(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_113(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_115(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_114(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_116(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_115(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_117(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_116(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_118(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_117(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_119(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_118(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_120(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_119(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_121(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_120(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_122(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_121(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_123(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_122(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_124(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_123(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_125(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_124(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_126(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_125(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_127(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_126(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_128(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_127(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_129(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_128(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_130(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_129(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_131(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_130(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_132(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_131(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_133(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_132(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_134(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_133(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_135(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_134(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_136(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_135(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_137(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_136(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_138(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_137(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_139(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_138(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_140(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_139(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_141(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_140(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_142(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_141(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_143(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_142(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_144(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_143(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_145(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_144(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_146(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_145(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_147(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_146(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_148(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_147(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_149(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_148(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_150(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_149(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_151(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_150(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_152(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_151(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_153(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_152(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_154(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_153(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_155(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_154(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_156(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_155(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_157(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_156(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_158(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_157(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_159(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_158(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_160(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_159(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_161(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_160(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_162(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_161(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_163(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_162(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_164(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_163(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_165(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_164(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_166(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_165(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_167(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_166(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_168(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_167(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_169(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_168(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_170(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_169(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_171(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_170(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_172(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_171(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_173(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_172(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_174(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_173(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_175(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_174(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_176(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_175(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_177(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_176(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_178(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_177(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_179(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_178(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_180(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_179(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_181(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_180(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_182(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_181(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_183(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_182(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_184(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_183(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_185(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_184(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_186(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_185(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_187(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_186(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_188(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_187(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_189(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_188(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_190(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_189(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_191(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_190(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_192(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_191(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_193(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_192(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_194(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_193(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_195(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_194(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_196(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_195(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_197(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_196(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_198(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_197(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_199(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_198(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_200(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_199(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_201(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_200(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_202(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_201(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_203(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_202(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_204(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_203(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_205(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_204(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_206(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_205(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_207(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_206(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_208(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_207(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_209(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_208(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_210(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_209(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_211(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_210(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_212(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_211(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_213(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_212(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_214(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_213(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_215(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_214(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_216(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_215(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_217(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_216(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_218(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_217(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_219(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_218(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_220(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_219(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_221(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_220(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_222(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_221(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_223(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_222(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_224(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_223(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_225(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_224(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_226(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_225(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_227(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_226(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_228(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_227(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_229(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_228(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_230(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_229(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_231(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_230(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_232(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_231(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_233(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_232(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_234(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_233(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_235(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_234(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_236(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_235(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_237(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_236(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_238(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_237(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_239(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_238(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_240(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_239(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_241(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_240(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_242(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_241(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_243(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_242(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_244(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_243(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_245(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_244(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_246(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_245(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_247(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_246(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_248(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_247(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_249(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_248(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_250(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_249(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_251(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_250(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_252(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_251(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_253(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_252(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_254(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_253(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) +#define SK_SEQ_FOREACH_255(op,lop,d,x,t) op(d,x) SK_SEQ_FOREACH_254(op, lop, d, SK_SEQ_HEAD(t), SK_SEQ_TAIL(t)) #define SK_SEQ_END (SK_NIL) diff --git a/src/sfnt/SkSFNTHeader.h b/src/sfnt/SkSFNTHeader.h new file mode 100644 index 0000000000..a36dfa4e5f --- /dev/null +++ b/src/sfnt/SkSFNTHeader.h @@ -0,0 +1,45 @@ +/* + * Copyright 2012 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ + +#ifndef SkSFNTHeader_DEFINED +#define SkSFNTHeader_DEFINED + +#include "SkEndian.h" + +//All SK_SFNT_ prefixed types should be considered as big endian. +typedef uint16_t SK_SFNT_USHORT; +typedef uint32_t SK_SFNT_ULONG; + +#pragma pack(push, 1) + +struct SkSFNTHeader { + SK_SFNT_ULONG fontType; + static const SK_OT_ULONG fontType_WindowsTrueType = SkTEndian_SwapBE32(0x00010000); + static const SK_OT_ULONG fontType_MacTrueType = SkTEndian_SwapBE32('true'); + static const SK_OT_ULONG fontType_PostScript = SkTEndian_SwapBE32('typ1'); + static const SK_OT_ULONG fontType_OpenTypeCFF = SkTEndian_SwapBE32('OTTO'); + + SK_SFNT_USHORT numTables; + SK_SFNT_USHORT searchRange; + SK_SFNT_USHORT entrySelector; + SK_SFNT_USHORT rangeShift; +}; + +struct SkSFNTTableDirectoryEntry { + SK_SFNT_ULONG tag; + SK_SFNT_ULONG checksum; + SK_SFNT_ULONG offset; //From beginning of header. + SK_SFNT_ULONG logicalLength; +}; + +#pragma pack(pop) + + +SK_COMPILE_ASSERT(sizeof(SkSFNTHeader) == 12, sizeof_SkSFNTHeader_not_12); +SK_COMPILE_ASSERT(sizeof(SkSFNTTableDirectoryEntry) == 16, sizeof_SkSFNTTableDirectoryEntry_not_16); + +#endif diff --git a/src/sfnt/SkTypedEnum.h b/src/sfnt/SkTypedEnum.h index ac2f5e0c23..ce1a93996c 100644 --- a/src/sfnt/SkTypedEnum.h +++ b/src/sfnt/SkTypedEnum.h @@ -59,6 +59,7 @@ enumType elem; #define SK_TYPED_ENUM(enumName, enumType, enumSeq, idSeq) \ + typedef enumType enumName; \ SK_SEQ_FOREACH(SK_TYPED_ENUM_VALUES, enumType, enumSeq) \ SK_SEQ_FOREACH(SK_TYPED_ENUM_IDS, enumType, idSeq) -- 2.34.1