legacy-libs/protobufjs/src/verifier.js

   1 "use strict";
   2 module.exports = verifier;
   3
   4 var Enum      = require("./enum"),
   5     util      = require("./util");
   6
   7 function invalid(field, expected) {
   8     return field.name + ": " + expected + (field.repeated && expected !== "array" ? "[]" : field.map && expected !== "object" ? "{k:"+field.keyType+"}" : "") + " expected";
   9 }
  10
  11 /**
  12  * Generates a partial value verifier.
  13  * @param {Codegen} gen Codegen instance
  14  * @param {Field} field Reflected field
  15  * @param {number} fieldIndex Field index
  16  * @param {string} ref Variable reference
  17  * @returns {Codegen} Codegen instance
  18  * @ignore
  19  */
  20 function genVerifyValue(gen, field, fieldIndex, ref) {
  21     /* eslint-disable no-unexpected-multiline */
  22     if (field.resolvedType) {
  23         if (field.resolvedType instanceof Enum) { gen
  24             ("switch(%s){", ref)
  25                 ("default:")
  26                     ("return%j", invalid(field, "enum value"));
  27             for (var keys = Object.keys(field.resolvedType.values), j = 0; j < keys.length; ++j) gen
  28                 ("case %i:", field.resolvedType.values[keys[j]]);
  29             gen
  30                     ("break")
  31             ("}");
  32         } else {
  33             gen
  34             ("{")
  35                 ("var e=types[%i].verify(%s);", fieldIndex, ref)
  36                 ("if(e)")
  37                     ("return%j+e", field.name + ".")
  38             ("}");
  39         }
  40     } else {
  41         switch (field.type) {
  42             case "int32":
  43             case "uint32":
  44             case "sint32":
  45             case "fixed32":
  46             case "sfixed32": gen
  47                 ("if(!util.isInteger(%s))", ref)
  48                     ("return%j", invalid(field, "integer"));
  49                 break;
  50             case "int64":
  51             case "uint64":
  52             case "sint64":
  53             case "fixed64":
  54             case "sfixed64": gen
  55                 ("if(!util.isInteger(%s)&&!(%s&&util.isInteger(%s.low)&&util.isInteger(%s.high)))", ref, ref, ref, ref)
  56                     ("return%j", invalid(field, "integer|Long"));
  57                 break;
  58             case "float":
  59             case "double": gen
  60                 ("if(typeof %s!==\"number\")", ref)
  61                     ("return%j", invalid(field, "number"));
  62                 break;
  63             case "bool": gen
  64                 ("if(typeof %s!==\"boolean\")", ref)
  65                     ("return%j", invalid(field, "boolean"));
  66                 break;
  67             case "string": gen
  68                 ("if(!util.isString(%s))", ref)
  69                     ("return%j", invalid(field, "string"));
  70                 break;
  71             case "bytes": gen
  72                 ("if(!(%s&&typeof %s.length===\"number\"||util.isString(%s)))", ref, ref, ref)
  73                     ("return%j", invalid(field, "buffer"));
  74                 break;
  75         }
  76     }
  77     return gen;
  78     /* eslint-enable no-unexpected-multiline */
  79 }
  80
  81 /**
  82  * Generates a partial key verifier.
  83  * @param {Codegen} gen Codegen instance
  84  * @param {Field} field Reflected field
  85  * @param {string} ref Variable reference
  86  * @returns {Codegen} Codegen instance
  87  * @ignore
  88  */
  89 function genVerifyKey(gen, field, ref) {
  90     /* eslint-disable no-unexpected-multiline */
  91     switch (field.keyType) {
  92         case "int32":
  93         case "uint32":
  94         case "sint32":
  95         case "fixed32":
  96         case "sfixed32": gen
  97             ("if(!util.key32Re.test(%s))", ref)
  98                 ("return%j", invalid(field, "integer key"));
  99             break;
 100         case "int64":
 101         case "uint64":
 102         case "sint64":
 103         case "fixed64":
 104         case "sfixed64": gen
 105             ("if(!util.key64Re.test(%s))", ref) // see comment above: x is ok, d is not
 106                 ("return%j", invalid(field, "integer|Long key"));
 107             break;
 108         case "bool": gen
 109             ("if(!util.key2Re.test(%s))", ref)
 110                 ("return%j", invalid(field, "boolean key"));
 111             break;
 112     }
 113     return gen;
 114     /* eslint-enable no-unexpected-multiline */
 115 }
 116
 117 /**
 118  * Generates a verifier specific to the specified message type.
 119  * @param {Type} mtype Message type
 120  * @returns {Codegen} Codegen instance
 121  */
 122 function verifier(mtype) {
 123     /* eslint-disable no-unexpected-multiline */
 124
 125     var gen = util.codegen(["m"], mtype.name + "$verify")
 126     ("if(typeof m!==\"object\"||m===null)")
 127         ("return%j", "object expected");
 128     var oneofs = mtype.oneofsArray,
 129         seenFirstField = {};
 130     if (oneofs.length) gen
 131     ("var p={}");
 132
 133     for (var i = 0; i < /* initializes */ mtype.fieldsArray.length; ++i) {
 134         var field = mtype._fieldsArray[i].resolve(),
 135             ref   = "m" + util.safeProp(field.name);
 136
 137         if (field.optional) gen
 138         ("if(%s!=null&&m.hasOwnProperty(%j)){", ref, field.name); // !== undefined && !== null
 139
 140         // map fields
 141         if (field.map) { gen
 142             ("if(!util.isObject(%s))", ref)
 143                 ("return%j", invalid(field, "object"))
 144             ("var k=Object.keys(%s)", ref)
 145             ("for(var i=0;i<k.length;++i){");
 146                 genVerifyKey(gen, field, "k[i]");
 147                 genVerifyValue(gen, field, i, ref + "[k[i]]")
 148             ("}");
 149
 150         // repeated fields
 151         } else if (field.repeated) { gen
 152             ("if(!Array.isArray(%s))", ref)
 153                 ("return%j", invalid(field, "array"))
 154             ("for(var i=0;i<%s.length;++i){", ref);
 155                 genVerifyValue(gen, field, i, ref + "[i]")
 156             ("}");
 157
 158         // required or present fields
 159         } else {
 160             if (field.partOf) {
 161                 var oneofProp = util.safeProp(field.partOf.name);
 162                 if (seenFirstField[field.partOf.name] === 1) gen
 163             ("if(p%s===1)", oneofProp)
 164                 ("return%j", field.partOf.name + ": multiple values");
 165                 seenFirstField[field.partOf.name] = 1;
 166                 gen
 167             ("p%s=1", oneofProp);
 168             }
 169             genVerifyValue(gen, field, i, ref);
 170         }
 171         if (field.optional) gen
 172         ("}");
 173     }
 174     return gen
 175     ("return null");
 176     /* eslint-enable no-unexpected-multiline */
 177 }