libavcodec/eval.c:200: error: Null Dereference
  pointer `d` last assigned on line 195 could be null and is dereferenced at line 200, column 5.

libavcodec/eval.c:194:1: start of procedure parse_primary()
192. }
193. 
194. static AVEvalExpr * parse_primary(Parser *p) {
     ^
195.     AVEvalExpr * d = av_mallocz(sizeof(AVEvalExpr));
196.     char *next= p->s;

libavcodec/eval.c:195:5: 
193. 
194. static AVEvalExpr * parse_primary(Parser *p) {
195.     AVEvalExpr * d = av_mallocz(sizeof(AVEvalExpr));
         ^
196.     char *next= p->s;
197.     int i;

libavutil/mem.c:132:1: start of procedure av_mallocz()
  130. }
  131. 
  132. void *av_mallocz(unsigned int size)
       ^
  133. {
  134.     void *ptr = av_malloc(size);

libavutil/mem.c:134:5: 
  132. void *av_mallocz(unsigned int size)
  133. {
  134.     void *ptr = av_malloc(size);
           ^
  135.     if (ptr)
  136.         memset(ptr, 0, size);

libavutil/mem.c:42:1: start of procedure av_malloc()
    40.    linker will do it automatically */
    41. 
    42. void *av_malloc(unsigned int size)
        ^
    43. {
    44.     void *ptr;

libavutil/mem.c:50:8: Taking false branch
    48. 
    49.     /* let's disallow possible ambiguous cases */
    50.     if(size > (INT_MAX-16) )
               ^
    51.         return NULL;
    52. 

libavutil/mem.c:61:5: Skipping memalign(): method has no implementation
    59.     ((char*)ptr)[-1]= diff;
    60. #elif defined (HAVE_MEMALIGN)
    61.     ptr = memalign(16,size);
            ^
    62.     /* Why 64?
    63.        Indeed, we should align it:

libavutil/mem.c:91:5: 
    89.     ptr = malloc(size);
    90. #endif
    91.     return ptr;
            ^
    92. }
    93. 

libavutil/mem.c:92:1: return from a call to av_malloc
    90. #endif
    91.     return ptr;
    92. }
        ^
    93. 
    94. void *av_realloc(void *ptr, unsigned int size)

libavutil/mem.c:135:9: Taking false branch
  133. {
  134.     void *ptr = av_malloc(size);
  135.     if (ptr)
               ^
  136.         memset(ptr, 0, size);
  137.     return ptr;

libavutil/mem.c:137:5: 
  135.     if (ptr)
  136.         memset(ptr, 0, size);
  137.     return ptr;
           ^
  138. }
  139. 

libavutil/mem.c:138:1: return from a call to av_mallocz
  136.         memset(ptr, 0, size);
  137.     return ptr;
  138. }
       ^
  139. 
  140. char *av_strdup(const char *s)

libavcodec/eval.c:196:5: 
194. static AVEvalExpr * parse_primary(Parser *p) {
195.     AVEvalExpr * d = av_mallocz(sizeof(AVEvalExpr));
196.     char *next= p->s;
         ^
197.     int i;
198. 

libavcodec/eval.c:200:5: 
198. 
199.     /* number */
200.     d->value = av_strtod(p->s, &next);
         ^
201.     if(next != p->s){
202.         d->type = e_value;

libavcodec/eval.c:89:1: start of procedure av_strtod()
  87.  * function assumes that the unit of numbers is bits not bytes.
  88.  */
  89. static double av_strtod(const char *name, char **tail) {
      ^
  90.     double d;
  91.     char *next;

libavcodec/eval.c:92:5: 
  90.     double d;
  91.     char *next;
  92.     d = strtod(name, &next);
          ^
  93.     /* if parsing succeeded, check for and interpret postfixes */
  94.     if (next!=name) {

libavcodec/eval.c:94:9: Taking true branch
  92.     d = strtod(name, &next);
  93.     /* if parsing succeeded, check for and interpret postfixes */
  94.     if (next!=name) {
              ^
  95. 
  96.         if(*next >= 'E' && *next <= 'z'){

libavcodec/eval.c:96:12: Taking true branch
  94.     if (next!=name) {
  95. 
  96.         if(*next >= 'E' && *next <= 'z'){
                 ^
  97.             int e= si_prefixes[*next - 'E'];
  98.             if(e){

libavcodec/eval.c:96:28: Taking true branch
  94.     if (next!=name) {
  95. 
  96.         if(*next >= 'E' && *next <= 'z'){
                                 ^
  97.             int e= si_prefixes[*next - 'E'];
  98.             if(e){

libavcodec/eval.c:97:13: 
  95. 
  96.         if(*next >= 'E' && *next <= 'z'){
  97.             int e= si_prefixes[*next - 'E'];
                  ^
  98.             if(e){
  99.                 if(next[1] == 'i'){

libavcodec/eval.c:98:16: Taking true branch
   96.         if(*next >= 'E' && *next <= 'z'){
   97.             int e= si_prefixes[*next - 'E'];
   98.             if(e){
                      ^
   99.                 if(next[1] == 'i'){
  100.                     d*= pow( 2, e/0.3);

libavcodec/eval.c:99:20: Taking true branch
   97.             int e= si_prefixes[*next - 'E'];
   98.             if(e){
   99.                 if(next[1] == 'i'){
                          ^
  100.                     d*= pow( 2, e/0.3);
  101.                     next+=2;

libavcodec/eval.c:100:21: 
   98.             if(e){
   99.                 if(next[1] == 'i'){
  100.                     d*= pow( 2, e/0.3);
                           ^
  101.                     next+=2;
  102.                 }else{

libavcodec/eval.c:101:21: 
   99.                 if(next[1] == 'i'){
  100.                     d*= pow( 2, e/0.3);
  101.                     next+=2;
                           ^
  102.                 }else{
  103.                     d*= pow(10, e);

libavcodec/eval.c:109:12: Taking false branch
  107.         }
  108. 
  109.         if(*next=='B') {
                  ^
  110.             d*=8;
  111.             next++;

libavcodec/eval.c:116:9: Taking true branch
  114.     /* if requested, fill in tail with the position after the last parsed
  115.        character */
  116.     if (tail)
               ^
  117.         *tail = next;
  118.     return d;

libavcodec/eval.c:117:9: 
  115.        character */
  116.     if (tail)
  117.         *tail = next;
               ^
  118.     return d;
  119. }

libavcodec/eval.c:118:5: 
  116.     if (tail)
  117.         *tail = next;
  118.     return d;
           ^
  119. }
  120. 

libavcodec/eval.c:119:1: return from a call to av_strtod
  117.         *tail = next;
  118.     return d;
  119. }
       ^
  120. 
  121. static int strmatch(const char *s, const char *prefix){
