LCOV - code coverage report
Current view: top level - lib - ASN1.y (source / functions) Hit Total Coverage
Test: GNU Libtasn1 Lines: 337 408 82.6 %
Date: 2013-03-24 Functions: 4 5 80.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 108 131 82.4 %

           Branch data     Line data    Source code
       1                 :            : %{
       2                 :            : /*
       3                 :            :  * Copyright (C) 2001-2013 Free Software Foundation, Inc.
       4                 :            :  *
       5                 :            :  * This file is part of LIBTASN1.
       6                 :            :  *
       7                 :            :  * The LIBTASN1 library is free software; you can redistribute it
       8                 :            :  * and/or modify it under the terms of the GNU Lesser General Public
       9                 :            :  * License as published by the Free Software Foundation; either
      10                 :            :  * version 2.1 of the License, or (at your option) any later version.
      11                 :            :  *
      12                 :            :  * This library is distributed in the hope that it will be useful, but
      13                 :            :  * WITHOUT ANY WARRANTY; without even the implied warranty of
      14                 :            :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      15                 :            :  * Lesser General Public License for more details.
      16                 :            :  *
      17                 :            :  * You should have received a copy of the GNU Lesser General Public
      18                 :            :  * License along with this library; if not, write to the Free Software
      19                 :            :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
      20                 :            :  * 02110-1301, USA
      21                 :            :  */
      22                 :            : 
      23                 :            : /*****************************************************/
      24                 :            : /* File: x509_ASN.y                                  */
      25                 :            : /* Description: input file for 'bison' program.      */
      26                 :            : /*   The output file is a parser (in C language) for */
      27                 :            : /*   ASN.1 syntax                                    */
      28                 :            : /*****************************************************/
      29                 :            : 
      30                 :            : #include <int.h>
      31                 :            : #include <parser_aux.h>
      32                 :            : #include <structure.h>
      33                 :            : #include <libtasn1.h>
      34                 :            : 
      35                 :            : static FILE *file_asn1;                 /* Pointer to file to parse */
      36                 :            : static int result_parse = 0;    /* result of the parser
      37                 :            :                                            algorithm */
      38                 :            : static asn1_node p_tree;                /* pointer to the root of the
      39                 :            :                                            structure created by the
      40                 :            :                                            parser*/
      41                 :            : static unsigned int line_number;        /* line number describing the
      42                 :            :                                            parser position inside the
      43                 :            :                                            file */
      44                 :            : static char last_error[ASN1_MAX_ERROR_DESCRIPTION_SIZE] = "";
      45                 :            : static char last_error_token[ASN1_MAX_ERROR_DESCRIPTION_SIZE+1] = ""; /* used when expected errors occur */
      46                 :            : static char last_token[ASN1_MAX_NAME_SIZE+1] = ""; /* last token find in the file
      47                 :            :                                            to parse before the 'parse
      48                 :            :                                            error' */
      49                 :            : extern char _asn1_identifierMissing[];
      50                 :            : static const char *file_name;           /* file to parse */
      51                 :            : 
      52                 :            : static void _asn1_yyerror (const char *);
      53                 :            : static int _asn1_yylex(void);
      54                 :            : 
      55                 :            : %}
      56                 :            : 
      57                 :            : /* Prefix symbols and functions with _asn1_ */
      58                 :            : /* %define parse.lac full */
      59                 :            : %error-verbose
      60                 :            : %name-prefix="_asn1_yy"
      61                 :            : 
      62                 :            : %union {
      63                 :            :   unsigned int constant;
      64                 :            :   char str[ASN1_MAX_NAME_SIZE+1];
      65                 :            :   asn1_node node;
      66                 :            : }
      67                 :            : 
      68                 :            : 
      69                 :            : %token ASSIG "::="
      70                 :            : %token <str> NUM
      71                 :            : %token <str> IDENTIFIER
      72                 :            : %token OPTIONAL
      73                 :            : %token INTEGER
      74                 :            : %token SIZE
      75                 :            : %token OCTET
      76                 :            : %token STRING
      77                 :            : %token SEQUENCE
      78                 :            : %token BIT
      79                 :            : %token UNIVERSAL
      80                 :            : %token PRIVATE
      81                 :            : %token APPLICATION
      82                 :            : %token DEFAULT
      83                 :            : %token CHOICE
      84                 :            : %token OF
      85                 :            : %token OBJECT
      86                 :            : %token STR_IDENTIFIER
      87                 :            : %token BOOLEAN
      88                 :            : %token ASN1_TRUE
      89                 :            : %token ASN1_FALSE
      90                 :            : %token TOKEN_NULL
      91                 :            : %token ANY
      92                 :            : %token DEFINED
      93                 :            : %token BY
      94                 :            : %token SET
      95                 :            : %token EXPLICIT
      96                 :            : %token IMPLICIT
      97                 :            : %token DEFINITIONS
      98                 :            : %token TAGS
      99                 :            : %token BEGIN
     100                 :            : %token END
     101                 :            : %token UTCTime
     102                 :            : %token GeneralizedTime
     103                 :            : %token GeneralString
     104                 :            : %token NumericString
     105                 :            : %token IA5String
     106                 :            : %token TeletexString
     107                 :            : %token PrintableString
     108                 :            : %token UniversalString
     109                 :            : %token BMPString
     110                 :            : %token UTF8String
     111                 :            : %token VisibleString
     112                 :            : 
     113                 :            : %token FROM
     114                 :            : %token IMPORTS
     115                 :            : %token ENUMERATED
     116                 :            : 
     117                 :            : %type <node> octet_string_def constant constant_list type_assig_right
     118                 :            : %type <node> integer_def type_assig type_assig_list sequence_def type_def
     119                 :            : %type <node> bit_string_def default size_def choise_def object_def
     120                 :            : %type <node> boolean_def any_def size_def2 obj_constant obj_constant_list
     121                 :            : %type <node> constant_def type_constant type_constant_list definitions
     122                 :            : %type <node> definitions_id Time bit_element bit_element_list set_def
     123                 :            : %type <node> tag_type tag type_assig_right_tag generalstring_def
     124                 :            : %type <node> numericstring_def ia5string_def printablestring_def universalstring_def
     125                 :            : %type <node> bmpstring_def utf8string_def visiblestring_def teletexstring_def
     126                 :            : %type <node> type_assig_right_tag_default enumerated_def
     127                 :            : %type <str>  pos_num neg_num pos_neg_num pos_neg_identifier pos_neg_list
     128                 :            : %type <str>  num_identifier
     129                 :            : %type <constant> class explicit_implicit
     130                 :            : 
     131                 :            : %%
     132                 :            : 
     133                 :            : 
     134                 :            : definitions:   definitions_id
     135                 :            :                DEFINITIONS explicit_implicit TAGS "::=" BEGIN  /* imports_def */
     136                 :            :                type_constant_list END
     137                 :         30 :                    {$$=_asn1_add_static_node(ASN1_ETYPE_DEFINITIONS|$3);
     138                 :         30 :                     _asn1_set_name($$,_asn1_get_name($1));
     139                 :         30 :                     _asn1_set_name($1,"");
     140                 :         30 :                     _asn1_set_right($1,$7);
     141                 :         30 :                     _asn1_set_down($$,$1);
     142                 :            : 
     143                 :         30 :                     p_tree=$$;
     144                 :            :                     }
     145                 :         30 : ;
     146                 :            : 
     147                 :        223 : pos_num :   NUM       {strcpy($$,$1);}
     148                 :        223 :           | '+' NUM   {strcpy($$,$2);}
     149                 :          0 : ;
     150                 :            : 
     151                 :          3 : neg_num : '-' NUM     {strcpy($$,"-");
     152                 :          3 :                        strcat($$,$2);}
     153                 :          3 : ;
     154                 :            : 
     155                 :        223 : pos_neg_num :  pos_num  {strcpy($$,$1);}
     156                 :        223 :              | neg_num  {strcpy($$,$1);}
     157                 :          3 : ;
     158                 :            : 
     159                 :        521 : num_identifier :  NUM            {strcpy($$,$1);}
     160                 :        521 :                 | IDENTIFIER     {strcpy($$,$1);}
     161                 :        336 : ;
     162                 :            : 
     163                 :          6 : pos_neg_identifier :  pos_neg_num    {strcpy($$,$1);}
     164                 :          6 :                     | IDENTIFIER     {strcpy($$,$1);}
     165                 :         31 : ;
     166                 :            : 
     167                 :          0 : constant: '(' pos_neg_num ')'         {$$=_asn1_add_static_node(ASN1_ETYPE_CONSTANT);
     168                 :          0 :                                        _asn1_set_value($$,$2,strlen($2)+1);}
     169                 :         33 :         | IDENTIFIER'('pos_neg_num')' {$$=_asn1_add_static_node(ASN1_ETYPE_CONSTANT);
     170                 :         33 :                                        _asn1_set_name($$,$1);
     171                 :         33 :                                        _asn1_set_value($$,$3,strlen($3)+1);}
     172                 :         33 : ;
     173                 :            : 
     174                 :         12 : constant_list:  constant                   {$$=$1;}
     175                 :         12 :               | constant_list ',' constant {$$=$1;
     176                 :         21 :                                             _asn1_set_right(_asn1_get_last_right($1),$3);}
     177                 :         21 : ;
     178                 :            : 
     179                 :        464 : obj_constant:  num_identifier     {$$=_asn1_add_static_node(ASN1_ETYPE_CONSTANT);
     180                 :        464 :                                    _asn1_set_value($$,$1,strlen($1)+1);}
     181                 :        798 :              | IDENTIFIER'('NUM')' {$$=_asn1_add_static_node(ASN1_ETYPE_CONSTANT);
     182                 :        334 :                                     _asn1_set_name($$,$1);
     183                 :        334 :                                     _asn1_set_value($$,$3,strlen($3)+1);}
     184                 :        334 : ;
     185                 :            : 
     186                 :        235 : obj_constant_list:  obj_constant                   {$$=$1;}
     187                 :        235 :                   | obj_constant_list obj_constant {$$=$1;
     188                 :        563 :                                                     _asn1_set_right(_asn1_get_last_right($1),$2);}
     189                 :        563 : ;
     190                 :            : 
     191                 :         24 : class :  UNIVERSAL    {$$=CONST_UNIVERSAL;}
     192                 :         24 :        | PRIVATE      {$$=CONST_PRIVATE;}
     193                 :          0 :        | APPLICATION  {$$=CONST_APPLICATION;}
     194                 :          5 : ;
     195                 :            : 
     196                 :        158 : tag_type :  '[' NUM ']'    {$$=_asn1_add_static_node(ASN1_ETYPE_TAG);
     197                 :        158 :                             _asn1_set_value($$,$2,strlen($2)+1);}
     198                 :        187 :           | '[' class NUM ']'  {$$=_asn1_add_static_node(ASN1_ETYPE_TAG | $2);
     199                 :         29 :                                 _asn1_set_value($$,$3,strlen($3)+1);}
     200                 :         29 : ;
     201                 :            : 
     202                 :         86 : tag :  tag_type           {$$=$1;}
     203                 :        150 :      | tag_type EXPLICIT  {$$=_asn1_mod_type($1,CONST_EXPLICIT);}
     204                 :        101 :      | tag_type IMPLICIT  {$$=_asn1_mod_type($1,CONST_IMPLICIT);}
     205                 :         37 : ;
     206                 :            : 
     207                 :         37 : default :  DEFAULT pos_neg_identifier {$$=_asn1_add_static_node(ASN1_ETYPE_DEFAULT);
     208                 :         37 :                                        _asn1_set_value($$,$2,strlen($2)+1);}
     209                 :         38 :          | DEFAULT ASN1_TRUE           {$$=_asn1_add_static_node(ASN1_ETYPE_DEFAULT|CONST_TRUE);}
     210                 :         11 :          | DEFAULT ASN1_FALSE          {$$=_asn1_add_static_node(ASN1_ETYPE_DEFAULT|CONST_FALSE);}
     211                 :         10 : ;
     212                 :            : 
     213                 :            : 
     214                 :            : pos_neg_list:  pos_neg_num
     215                 :            :             |  pos_neg_list '|' pos_neg_num
     216                 :            : ;
     217                 :            : 
     218                 :            : 
     219                 :        112 : integer_def: INTEGER                    {$$=_asn1_add_static_node(ASN1_ETYPE_INTEGER);}
     220                 :        122 :            | INTEGER'{'constant_list'}' {$$=_asn1_add_static_node(ASN1_ETYPE_INTEGER|CONST_LIST);
     221                 :         10 :                                          _asn1_set_down($$,$3);}
     222                 :         53 :            | integer_def'(' pos_neg_list ')' {$$=_asn1_add_static_node(ASN1_ETYPE_INTEGER);}
     223                 :         43 :            | integer_def'('num_identifier'.''.'num_identifier')'
     224                 :         14 :                                         {$$=_asn1_add_static_node(ASN1_ETYPE_INTEGER|CONST_MIN_MAX);
     225                 :         14 :                                          _asn1_set_down($$,_asn1_add_static_node(ASN1_ETYPE_SIZE));
     226                 :         14 :                                          _asn1_set_value(_asn1_get_down($$),$6,strlen($6)+1);
     227                 :         14 :                                          _asn1_set_name(_asn1_get_down($$),$3);}
     228                 :         14 : ;
     229                 :            : 
     230                 :         12 : boolean_def: BOOLEAN   {$$=_asn1_add_static_node(ASN1_ETYPE_BOOLEAN);}
     231                 :         12 : ;
     232                 :            : 
     233                 :          3 : Time:   UTCTime          {$$=_asn1_add_static_node(ASN1_ETYPE_UTC_TIME);}
     234                 :         13 :       | GeneralizedTime  {$$=_asn1_add_static_node(ASN1_ETYPE_GENERALIZED_TIME);}
     235                 :         10 : ;
     236                 :            : 
     237                 :         39 : size_def2: SIZE'('num_identifier')'  {$$=_asn1_add_static_node(ASN1_ETYPE_SIZE|CONST_1_PARAM);
     238                 :         39 :                                       _asn1_set_value($$,$3,strlen($3)+1);}
     239                 :         39 :         | SIZE'('num_identifier'.''.'num_identifier')'
     240                 :        163 :                                      {$$=_asn1_add_static_node(ASN1_ETYPE_SIZE|CONST_MIN_MAX);
     241                 :        163 :                                       _asn1_set_value($$,$3,strlen($3)+1);
     242                 :        163 :                                       _asn1_set_name($$,$6);}
     243                 :        163 : ;
     244                 :            : 
     245                 :         38 : size_def:   size_def2          {$$=$1;}
     246                 :         38 :           | '(' size_def2 ')'  {$$=$2;}
     247                 :        164 : ;
     248                 :            : 
     249                 :         26 : generalstring_def: GeneralString {$$=_asn1_add_static_node(ASN1_ETYPE_GENERALSTRING);}
     250                 :         26 :                 | GeneralString size_def {$$=_asn1_add_static_node(ASN1_ETYPE_GENERALSTRING|CONST_SIZE);
     251                 :          0 :                                           _asn1_set_down($$,$2);}
     252                 :          0 : ;
     253                 :            : 
     254                 :          0 : numericstring_def: NumericString {$$=_asn1_add_static_node(ASN1_ETYPE_NUMERIC_STRING|CONST_UNIVERSAL);}
     255                 :         18 :                 | NumericString size_def {$$=_asn1_add_static_node(ASN1_ETYPE_NUMERIC_STRING|CONST_SIZE);
     256                 :         18 :                                           _asn1_set_down($$,$2);}
     257                 :         18 : ;
     258                 :            : 
     259                 :          9 : ia5string_def: IA5String {$$=_asn1_add_static_node(ASN1_ETYPE_IA5_STRING);}
     260                 :         12 :                 | IA5String size_def {$$=_asn1_add_static_node(ASN1_ETYPE_IA5_STRING|CONST_SIZE);
     261                 :          3 :                                           _asn1_set_down($$,$2);}
     262                 :          3 : ;
     263                 :            : 
     264                 :          1 : teletexstring_def: TeletexString {$$=_asn1_add_static_node(ASN1_ETYPE_TELETEX_STRING);}
     265                 :         32 :                 | TeletexString size_def {$$=_asn1_add_static_node(ASN1_ETYPE_TELETEX_STRING|CONST_SIZE);
     266                 :         31 :                                           _asn1_set_down($$,$2);}
     267                 :         31 : ;
     268                 :            : 
     269                 :          7 : printablestring_def: PrintableString {$$=_asn1_add_static_node(ASN1_ETYPE_PRINTABLE_STRING);}
     270                 :         58 :                 | PrintableString size_def {$$=_asn1_add_static_node(ASN1_ETYPE_PRINTABLE_STRING|CONST_SIZE);
     271                 :         51 :                                           _asn1_set_down($$,$2);}
     272                 :         51 : ;
     273                 :            : 
     274                 :          3 : universalstring_def: UniversalString {$$=_asn1_add_static_node(ASN1_ETYPE_UNIVERSAL_STRING);}
     275                 :         12 :                 | UniversalString size_def {$$=_asn1_add_static_node(ASN1_ETYPE_UNIVERSAL_STRING|CONST_SIZE);
     276                 :          9 :                                           _asn1_set_down($$,$2);}
     277                 :          9 : ;
     278                 :            : 
     279                 :          1 : bmpstring_def: BMPString {$$=_asn1_add_static_node(ASN1_ETYPE_BMP_STRING);}
     280                 :         13 :                 | BMPString size_def {$$=_asn1_add_static_node(ASN1_ETYPE_BMP_STRING|CONST_SIZE);
     281                 :         12 :                                           _asn1_set_down($$,$2);}
     282                 :         12 : ;
     283                 :            : 
     284                 :          2 : utf8string_def: UTF8String {$$=_asn1_add_static_node(ASN1_ETYPE_UTF8_STRING);}
     285                 :         14 :                 | UTF8String size_def {$$=_asn1_add_static_node(ASN1_ETYPE_UTF8_STRING|CONST_SIZE);
     286                 :         12 :                                           _asn1_set_down($$,$2);}
     287                 :         12 : ;
     288                 :            : 
     289                 :          0 : visiblestring_def: VisibleString {$$=_asn1_add_static_node(ASN1_ETYPE_VISIBLE_STRING);}
     290                 :          2 :                 | VisibleString size_def {$$=_asn1_add_static_node(ASN1_ETYPE_VISIBLE_STRING|CONST_SIZE);
     291                 :          2 :                                           _asn1_set_down($$,$2);}
     292                 :          2 : ;
     293                 :            : 
     294                 :         54 : octet_string_def : OCTET STRING           {$$=_asn1_add_static_node(ASN1_ETYPE_OCTET_STRING);}
     295                 :         55 :                  | OCTET STRING size_def  {$$=_asn1_add_static_node(ASN1_ETYPE_OCTET_STRING|CONST_SIZE);
     296                 :          1 :                                            _asn1_set_down($$,$3);}
     297                 :          1 : ;
     298                 :            : 
     299                 :         52 : bit_element :  IDENTIFIER'('NUM')' {$$=_asn1_add_static_node(ASN1_ETYPE_CONSTANT);
     300                 :         52 :                                    _asn1_set_name($$,$1);
     301                 :         52 :                                     _asn1_set_value($$,$3,strlen($3)+1);}
     302                 :         52 : ;
     303                 :            : 
     304                 :          7 : bit_element_list :  bit_element   {$$=$1;}
     305                 :          7 :                   | bit_element_list ',' bit_element  {$$=$1;
     306                 :         45 :                                                        _asn1_set_right(_asn1_get_last_right($1),$3);}
     307                 :         45 : ;
     308                 :            : 
     309                 :         12 : bit_string_def : BIT STRING    {$$=_asn1_add_static_node(ASN1_ETYPE_BIT_STRING);}
     310                 :         37 :                | BIT STRING size_def {$$=_asn1_add_static_node(ASN1_ETYPE_BIT_STRING|CONST_SIZE);}
     311                 :         25 :                | BIT STRING'{'bit_element_list'}'
     312                 :          4 :                                {$$=_asn1_add_static_node(ASN1_ETYPE_BIT_STRING|CONST_LIST);
     313                 :          4 :                                 _asn1_set_down($$,$4);}
     314                 :          4 : ;
     315                 :            : 
     316                 :            : enumerated_def : ENUMERATED'{'bit_element_list'}'
     317                 :          3 :                                {$$=_asn1_add_static_node(ASN1_ETYPE_ENUMERATED|CONST_LIST);
     318                 :          3 :                                 _asn1_set_down($$,$3);}
     319                 :          3 : ;
     320                 :            : 
     321                 :            : 
     322                 :         57 : object_def :  OBJECT STR_IDENTIFIER {$$=_asn1_add_static_node(ASN1_ETYPE_OBJECT_ID);}
     323                 :         57 : ;
     324                 :            : 
     325                 :        299 : type_assig_right: IDENTIFIER          {$$=_asn1_add_static_node(ASN1_ETYPE_IDENTIFIER);
     326                 :        299 :                                        _asn1_set_value($$,$1,strlen($1)+1);}
     327                 :        299 :                 | IDENTIFIER size_def {$$=_asn1_add_static_node(ASN1_ETYPE_IDENTIFIER|CONST_SIZE);
     328                 :          0 :                                        _asn1_set_value($$,$1,strlen($1)+1);
     329                 :          0 :                                        _asn1_set_down($$,$2);}
     330                 :          0 :                 | integer_def         {$$=$1;}
     331                 :        122 :                 | enumerated_def      {$$=$1;}
     332                 :          3 :                 | boolean_def         {$$=$1;}
     333                 :         12 :                 | Time
     334                 :         55 :                 | octet_string_def    {$$=$1;}
     335                 :         55 :                 | bit_string_def      {$$=$1;}
     336                 :         41 :                 | generalstring_def   {$$=$1;}
     337                 :         26 :                 | numericstring_def   {$$=$1;}
     338                 :         18 :                 | ia5string_def       {$$=$1;}
     339                 :         12 :                 | teletexstring_def   {$$=$1;}
     340                 :         32 :                 | printablestring_def {$$=$1;}
     341                 :         58 :                 | universalstring_def {$$=$1;}
     342                 :         12 :                 | bmpstring_def       {$$=$1;}
     343                 :         13 :                 | utf8string_def      {$$=$1;}
     344                 :         14 :                 | visiblestring_def   {$$=$1;}
     345                 :          2 :                 | sequence_def        {$$=$1;}
     346                 :        199 :                 | object_def          {$$=$1;}
     347                 :         57 :                 | choise_def          {$$=$1;}
     348                 :         37 :                 | any_def             {$$=$1;}
     349                 :         20 :                 | set_def             {$$=$1;}
     350                 :         29 :                 | TOKEN_NULL          {$$=_asn1_add_static_node(ASN1_ETYPE_NULL);}
     351                 :          0 : ;
     352                 :            : 
     353                 :        826 : type_assig_right_tag :   type_assig_right     {$$=$1;}
     354                 :       1013 :                        | tag type_assig_right {$$=_asn1_mod_type($2,CONST_TAG);
     355                 :        187 :                                                _asn1_set_right($1,_asn1_get_down($$));
     356                 :        187 :                                                _asn1_set_down($$,$1);}
     357                 :        187 : ;
     358                 :            : 
     359                 :        387 : type_assig_right_tag_default : type_assig_right_tag   {$$=$1;}
     360                 :        435 :                       | type_assig_right_tag default  {$$=_asn1_mod_type($1,CONST_DEFAULT);
     361                 :         48 :                                                        _asn1_set_right($2,_asn1_get_down($$));
     362                 :         48 :                                                        _asn1_set_down($$,$2);}
     363                 :        182 :                       | type_assig_right_tag OPTIONAL {$$=_asn1_mod_type($1,CONST_OPTION);}
     364                 :        134 : ;
     365                 :            : 
     366                 :        569 : type_assig : IDENTIFIER type_assig_right_tag_default  {$$=_asn1_set_name($2,$1);}
     367                 :        569 : ;
     368                 :            : 
     369                 :        204 : type_assig_list : type_assig                   {$$=$1;}
     370                 :        204 :                 | type_assig_list','type_assig {$$=$1;
     371                 :        365 :                                                 _asn1_set_right(_asn1_get_last_right($1),$3);}
     372                 :        365 : ;
     373                 :            : 
     374                 :        159 : sequence_def : SEQUENCE'{'type_assig_list'}' {$$=_asn1_add_static_node(ASN1_ETYPE_SEQUENCE);
     375                 :        159 :                                               _asn1_set_down($$,$3);}
     376                 :        169 :    | SEQUENCE OF type_assig_right            {$$=_asn1_add_static_node(ASN1_ETYPE_SEQUENCE_OF);
     377                 :         10 :                                               _asn1_set_down($$,$3);}
     378                 :         40 :    | SEQUENCE size_def OF type_assig_right {$$=_asn1_add_static_node(ASN1_ETYPE_SEQUENCE_OF|CONST_SIZE);
     379                 :         30 :                                             _asn1_set_right($2,$4);
     380                 :         30 :                                             _asn1_set_down($$,$2);}
     381                 :         30 : ;
     382                 :            : 
     383                 :          8 : set_def :  SET'{'type_assig_list'}' {$$=_asn1_add_static_node(ASN1_ETYPE_SET);
     384                 :          8 :                                      _asn1_set_down($$,$3);}
     385                 :         21 :    | SET OF type_assig_right        {$$=_asn1_add_static_node(ASN1_ETYPE_SET_OF);
     386                 :         13 :                                      _asn1_set_down($$,$3);}
     387                 :         21 :    | SET size_def OF type_assig_right {$$=_asn1_add_static_node(ASN1_ETYPE_SET_OF|CONST_SIZE);
     388                 :          8 :                                        _asn1_set_right($2,$4);
     389                 :          8 :                                        _asn1_set_down($$,$2);}
     390                 :          8 : ;
     391                 :            : 
     392                 :         37 : choise_def :   CHOICE'{'type_assig_list'}'  {$$=_asn1_add_static_node(ASN1_ETYPE_CHOICE);
     393                 :         37 :                                              _asn1_set_down($$,$3);}
     394                 :         37 : ;
     395                 :            : 
     396                 :          6 : any_def :  ANY                         {$$=_asn1_add_static_node(ASN1_ETYPE_ANY);}
     397                 :         20 :          | ANY DEFINED BY IDENTIFIER   {$$=_asn1_add_static_node(ASN1_ETYPE_ANY|CONST_DEFINED_BY);
     398                 :         14 :                                         _asn1_set_down($$,_asn1_add_static_node(ASN1_ETYPE_CONSTANT));
     399                 :         14 :                                         _asn1_set_name(_asn1_get_down($$),$4);}
     400                 :         14 : ;
     401                 :            : 
     402                 :        415 : type_def : IDENTIFIER "::=" type_assig_right_tag  {$$=_asn1_set_name($3,$1);}
     403                 :        415 :               /* below should match: BMPString ::= [UNIVERSAL 30] IMPLICIT OCTET STRING etc*/
     404                 :         28 :               | error "::=" type_assig_right_tag {$$=_asn1_set_name($3, last_error_token);}
     405                 :         28 : ;
     406                 :            : 
     407                 :            : constant_def :  IDENTIFIER OBJECT STR_IDENTIFIER "::=" '{'obj_constant_list'}'
     408                 :        165 :                         {$$=_asn1_add_static_node(ASN1_ETYPE_OBJECT_ID|CONST_ASSIGN);
     409                 :        165 :                          _asn1_set_name($$,$1);
     410                 :        165 :                          _asn1_set_down($$,$6);}
     411                 :        165 :               | IDENTIFIER IDENTIFIER "::=" '{' obj_constant_list '}'
     412                 :         43 :                         {$$=_asn1_add_static_node(ASN1_ETYPE_OBJECT_ID|CONST_ASSIGN|CONST_1_PARAM);
     413                 :         43 :                          _asn1_set_name($$,$1);
     414                 :         43 :                          _asn1_set_value($$,$2,strlen($2)+1);
     415                 :         43 :                          _asn1_set_down($$,$5);}
     416                 :         43 :               | IDENTIFIER INTEGER "::=" pos_neg_num
     417                 :        119 :                         {$$=_asn1_add_static_node(ASN1_ETYPE_INTEGER|CONST_ASSIGN);
     418                 :        119 :                          _asn1_set_name($$,$1);
     419                 :        119 :                          _asn1_set_value($$,$4,strlen($4)+1);}
     420                 :        119 : ;
     421                 :            : 
     422                 :        443 : type_constant:   type_def     {$$=$1;}
     423                 :        443 :                | constant_def {$$=$1;}
     424                 :        327 : ;
     425                 :            : 
     426                 :         30 : type_constant_list :   type_constant    {$$=$1;}
     427                 :         30 :                      | type_constant_list type_constant  {$$=$1;
     428                 :        740 :                                                           _asn1_set_right(_asn1_get_last_right($1),$2);}
     429                 :        740 : ;
     430                 :            : 
     431                 :         27 : definitions_id  :  IDENTIFIER  '{' obj_constant_list '}' {$$=_asn1_add_static_node(ASN1_ETYPE_OBJECT_ID);
     432                 :         27 :                                                           _asn1_set_down($$,$3);
     433                 :         27 :                                                           _asn1_set_name($$,$1);}
     434                 :         31 :                  | IDENTIFIER  '{' '}'                   {$$=_asn1_add_static_node(ASN1_ETYPE_OBJECT_ID);
     435                 :          4 :                                                           _asn1_set_name($$,$1);}
     436                 :          4 :                  | IDENTIFIER                            {$$=_asn1_add_static_node(ASN1_ETYPE_OBJECT_ID);
     437                 :          0 :                                                           _asn1_set_name($$,$1);}
     438                 :          0 : ;
     439                 :            : 
     440                 :            : /*
     441                 :            : identifier_list  :  IDENTIFIER  {$$=_asn1_add_static_node(ASN1_ETYPE_IDENTIFIER);
     442                 :            :                                  _asn1_set_name($$,$1);}
     443                 :            :                   | identifier_list IDENTIFIER
     444                 :            :                                 {$$=$1;
     445                 :            :                                  _asn1_set_right(_asn1_get_last_right($$),_asn1_add_static_node(ASN1_ETYPE_IDENTIFIER));
     446                 :            :                                  _asn1_set_name(_asn1_get_last_right($$),$2);}
     447                 :            : ;
     448                 :            : 
     449                 :            : 
     450                 :            : imports_def :    empty   {$$=NULL;}
     451                 :            :               | IMPORTS identifier_list FROM IDENTIFIER obj_constant_list
     452                 :            :                         {$$=_asn1_add_static_node(ASN1_ETYPE_IMPORTS);
     453                 :            :                          _asn1_set_down($$,_asn1_add_static_node(ASN1_ETYPE_OBJECT_ID));
     454                 :            :                          _asn1_set_name(_asn1_get_down($$),$4);
     455                 :            :                          _asn1_set_down(_asn1_get_down($$),$5);
     456                 :            :                          _asn1_set_right($$,$2);}
     457                 :            : ;
     458                 :            : */
     459                 :            : 
     460                 :          0 : explicit_implicit :  EXPLICIT  {$$=CONST_EXPLICIT;}
     461                 :          0 :                    | IMPLICIT  {$$=CONST_IMPLICIT;}
     462                 :         31 : ;
     463                 :            : 
     464                 :            : 
     465                 :            : %%
     466                 :            : 
     467                 :            : 
     468                 :            : 
     469                 :            : static const char *key_word[] = {
     470                 :            :   "::=","OPTIONAL","INTEGER","SIZE","OCTET","STRING",
     471                 :            :   "SEQUENCE","BIT","UNIVERSAL","PRIVATE","OPTIONAL",
     472                 :            :   "DEFAULT","CHOICE","OF","OBJECT","IDENTIFIER",
     473                 :            :   "BOOLEAN","TRUE","FALSE","APPLICATION","ANY","DEFINED",
     474                 :            :   "SET","BY","EXPLICIT","IMPLICIT","DEFINITIONS","TAGS",
     475                 :            :   "BEGIN","END","UTCTime","GeneralizedTime",
     476                 :            :   "GeneralString","FROM","IMPORTS","NULL","ENUMERATED",
     477                 :            :   "NumericString", "IA5String", "TeletexString", "PrintableString",
     478                 :            :   "UniversalString", "BMPString", "UTF8String", "VisibleString"};
     479                 :            : 
     480                 :            : static const int key_word_token[] = {
     481                 :            :   ASSIG, OPTIONAL, INTEGER, SIZE, OCTET, STRING, SEQUENCE, BIT, UNIVERSAL,
     482                 :            :       PRIVATE, OPTIONAL, DEFAULT, CHOICE, OF, OBJECT, STR_IDENTIFIER,
     483                 :            :       BOOLEAN, ASN1_TRUE, ASN1_FALSE, APPLICATION, ANY, DEFINED, SET, BY,
     484                 :            :       EXPLICIT, IMPLICIT, DEFINITIONS, TAGS, BEGIN, END, UTCTime,
     485                 :            :       GeneralizedTime, GeneralString, FROM, IMPORTS, TOKEN_NULL,
     486                 :            :       ENUMERATED, NumericString, IA5String, TeletexString, PrintableString,
     487                 :            :       UniversalString, BMPString, UTF8String, VisibleString
     488                 :            : };
     489                 :            : 
     490                 :            : /*************************************************************/
     491                 :            : /*  Function: _asn1_yylex                                    */
     492                 :            : /*  Description: looks for tokens in file_asn1 pointer file. */
     493                 :            : /*  Return: int                                              */
     494                 :            : /*    Token identifier or ASCII code or 0(zero: End Of File) */
     495                 :            : /*************************************************************/
     496                 :            : static int
     497                 :      10635 : _asn1_yylex ()
     498                 :            : {
     499                 :      10635 :   int c, counter = 0, k, lastc;
     500                 :            :   char string[ASN1_MAX_NAME_SIZE + 1];  /* will contain the next token */
     501                 :            :   size_t i;
     502                 :            : 
     503                 :            :   while (1)
     504                 :            :     {
     505 [ +  + ][ +  + ]:      29704 :       while ((c = fgetc (file_asn1)) == ' ' || c == '\t' || c == '\n')
                 [ +  + ]
     506         [ +  + ]:      18054 :         if (c == '\n')
     507                 :       2701 :           line_number++;
     508                 :            : 
     509         [ +  + ]:      11650 :       if (c == EOF)
     510                 :            :         {
     511                 :         29 :           strcpy (last_token, "End Of File");
     512                 :         29 :           return 0;
     513                 :            :         }
     514                 :            : 
     515 [ +  + ][ +  + ]:      11621 :       if (c == '(' || c == ')' || c == '[' || c == ']' ||
         [ +  + ][ +  + ]
                 [ +  + ]
     516 [ +  + ][ +  + ]:       9099 :           c == '{' || c == '}' || c == ',' || c == '.' ||
         [ +  + ][ +  - ]
     517         [ +  + ]:       7848 :           c == '+' || c == '|')
     518                 :            :         {
     519                 :       3798 :           last_token[0] = c;
     520                 :       3798 :           last_token[1] = 0;
     521                 :       3798 :           return c;
     522                 :            :         }
     523         [ +  + ]:       7823 :       if (c == '-')
     524                 :            :         {                       /* Maybe the first '-' of a comment */
     525         [ +  + ]:       1018 :           if ((c = fgetc (file_asn1)) != '-')
     526                 :            :             {
     527                 :          3 :               ungetc (c, file_asn1);
     528                 :          3 :               last_token[0] = '-';
     529                 :          3 :               last_token[1] = 0;
     530                 :          3 :               return '-';
     531                 :            :             }
     532                 :            :           else
     533                 :            :             {                   /* Comments */
     534                 :       1015 :               lastc = 0;
     535                 :       1015 :               counter = 0;
     536                 :            :               /* A comment finishes at the next double hypen or the end of line */
     537 [ +  - ][ +  + ]:      33923 :               while ((c = fgetc (file_asn1)) != EOF && c != '\n' &&
                 [ +  + ]
     538 [ +  - ][ +  + ]:        326 :                      (lastc != '-' || (lastc == '-' && c != '-')))
     539                 :      32908 :                 lastc = c;
     540         [ -  + ]:       1015 :               if (c == EOF)
     541                 :            :                 {
     542                 :          0 :                   strcpy (last_token, "End Of File");
     543                 :          0 :                   return 0;
     544                 :            :                 }
     545                 :            :               else
     546                 :            :                 {
     547         [ +  + ]:       1015 :                   if (c == '\n')
     548                 :        838 :                     line_number++;
     549                 :       1015 :                   continue;     /* next char, please! (repeat the search) */
     550                 :            :                 }
     551                 :            :             }
     552                 :            :         }
     553                 :       6805 :       string[counter++] = c;
     554                 :            :       /* Till the end of the token */
     555 [ +  - ][ +  + ]:      97216 :       while (!
     556 [ +  + ][ +  + ]:      51923 :              ((c = fgetc (file_asn1)) == EOF || c == ' ' || c == '\t'
     557 [ +  + ][ +  + ]:      47508 :               || c == '\n' || c == '(' || c == ')' || c == '[' || c == ']'
         [ +  + ][ +  + ]
                 [ +  + ]
     558 [ +  + ][ +  + ]:      45700 :               || c == '{' || c == '}' || c == ',' || c == '.'))
                 [ +  + ]
     559                 :            :         {
     560         [ +  + ]:      45119 :           if (counter >= ASN1_MAX_NAME_SIZE)
     561                 :            :             {
     562                 :          1 :               result_parse = ASN1_NAME_TOO_LONG;
     563                 :          1 :               return 0;
     564                 :            :             }
     565                 :      45118 :           string[counter++] = c;
     566                 :            :         }
     567                 :       6804 :       ungetc (c, file_asn1);
     568                 :       6804 :       string[counter] = 0;
     569                 :       6804 :       strcpy (last_token, string);
     570                 :            : 
     571                 :            :       /* Is STRING a number? */
     572         [ +  + ]:       8544 :       for (k = 0; k < counter; k++)
     573         [ +  + ]:       7219 :         if (!isdigit (string[k]))
     574                 :       5479 :           break;
     575         [ +  + ]:       6804 :       if (k >= counter)
     576                 :            :         {
     577                 :       1325 :           strcpy (yylval.str, string);
     578                 :       1325 :           return NUM;           /* return the number */
     579                 :            :         }
     580                 :            : 
     581                 :            :       /* Is STRING a keyword? */
     582         [ +  + ]:     147179 :       for (i = 0; i < (sizeof (key_word) / sizeof (char *)); i++)
     583         [ +  + ]:     144682 :         if (!strcmp (string, key_word[i]))
     584                 :       2982 :           return key_word_token[i];
     585                 :            : 
     586                 :            :       /* STRING is an IDENTIFIER */
     587                 :       2497 :       strcpy (yylval.str, string);
     588                 :      10635 :       return IDENTIFIER;
     589                 :       1015 :     }
     590                 :            : }
     591                 :            : 
     592                 :            : /*************************************************************/
     593                 :            : /*  Function: _asn1_create_errorDescription                  */
     594                 :            : /*  Description: creates a string with the description of the*/
     595                 :            : /*    error.                                                 */
     596                 :            : /*  Parameters:                                              */
     597                 :            : /*    error : error to describe.                             */
     598                 :            : /*    error_desc: string that will contain the         */
     599                 :            : /*                      description.                         */
     600                 :            : /*************************************************************/
     601                 :            : static void
     602                 :         31 : _asn1_create_errorDescription (int error, char *error_desc)
     603                 :            : {
     604         [ -  + ]:         31 :   if (error_desc == NULL)
     605                 :         31 :     return;
     606                 :            : 
     607                 :            : 
     608   [ -  +  +  +  :         31 :   switch (error)
                      + ]
     609                 :            :     {
     610                 :            :     case ASN1_FILE_NOT_FOUND:
     611                 :          0 :       snprintf(error_desc, ASN1_MAX_ERROR_DESCRIPTION_SIZE, "%s file was not found", file_name);
     612                 :          0 :       break;
     613                 :            :     case ASN1_SYNTAX_ERROR:
     614                 :          5 :       strcpy(error_desc, last_error);
     615                 :          5 :       break;
     616                 :            :     case ASN1_NAME_TOO_LONG:
     617                 :          1 :       snprintf (error_desc, ASN1_MAX_ERROR_DESCRIPTION_SIZE,
     618                 :            :                 "%s:%u: name too long (more than %u characters)", file_name,
     619                 :            :                 line_number, ASN1_MAX_NAME_SIZE);
     620                 :          1 :       break;
     621                 :            :     case ASN1_IDENTIFIER_NOT_FOUND:
     622                 :          5 :       snprintf (error_desc, ASN1_MAX_ERROR_DESCRIPTION_SIZE,
     623                 :            :                 "%s:: identifier '%s' not found", file_name,
     624                 :            :                 _asn1_identifierMissing);
     625                 :          5 :       break;
     626                 :            :     default:
     627                 :         20 :       error_desc[0] = 0;
     628                 :         20 :       break;
     629                 :            :     }
     630                 :            : 
     631                 :            : }
     632                 :            : 
     633                 :            : /**
     634                 :            :  * asn1_parser2tree:
     635                 :            :  * @file: specify the path and the name of file that contains
     636                 :            :  *   ASN.1 declarations.
     637                 :            :  * @definitions: return the pointer to the structure created from
     638                 :            :  *   "file" ASN.1 declarations.
     639                 :            :  * @error_desc: return the error description or an empty
     640                 :            :  * string if success.
     641                 :            :  *
     642                 :            :  * Function used to start the parse algorithm.  Creates the structures
     643                 :            :  * needed to manage the definitions included in @file file.
     644                 :            :  *
     645                 :            :  * Returns: %ASN1_SUCCESS if the file has a correct syntax and every
     646                 :            :  *   identifier is known, %ASN1_ELEMENT_NOT_EMPTY if @definitions not
     647                 :            :  *   %NULL, %ASN1_FILE_NOT_FOUND if an error occured while
     648                 :            :  *   opening @file, %ASN1_SYNTAX_ERROR if the syntax is not
     649                 :            :  *   correct, %ASN1_IDENTIFIER_NOT_FOUND if in the file there is an
     650                 :            :  *   identifier that is not defined, %ASN1_NAME_TOO_LONG if in the
     651                 :            :  *   file there is an identifier whith more than %ASN1_MAX_NAME_SIZE
     652                 :            :  *   characters.
     653                 :            :  **/
     654                 :            : int
     655                 :         31 : asn1_parser2tree (const char *file, asn1_node * definitions,
     656                 :            :                   char *error_desc)
     657                 :            : {
     658                 :            : 
     659                 :         31 :   p_tree = NULL;
     660                 :            : 
     661         [ -  + ]:         31 :   if (*definitions != NULL)
     662                 :          0 :     return ASN1_ELEMENT_NOT_EMPTY;
     663                 :            : 
     664                 :         31 :   *definitions = NULL;
     665                 :            : 
     666                 :         31 :   file_name = file;
     667                 :            : 
     668                 :            :   /* open the file to parse */
     669                 :         31 :   file_asn1 = fopen (file, "r");
     670                 :            : 
     671         [ -  + ]:         31 :   if (file_asn1 == NULL)
     672                 :            :     {
     673                 :          0 :       result_parse = ASN1_FILE_NOT_FOUND;
     674                 :            :     }
     675                 :            :   else
     676                 :            :     {
     677                 :         31 :       result_parse = ASN1_SUCCESS;
     678                 :            : 
     679                 :         31 :       line_number = 1;
     680                 :         31 :       yyparse ();
     681                 :            : 
     682                 :         31 :       fclose (file_asn1);
     683                 :            : 
     684         [ +  + ]:         31 :       if (result_parse == ASN1_SUCCESS)
     685                 :            :         {                       /* syntax OK */
     686                 :            :           /* set IMPLICIT or EXPLICIT property */
     687                 :         25 :           _asn1_set_default_tag (p_tree);
     688                 :            :           /* set CONST_SET and CONST_NOT_USED */
     689                 :         25 :           _asn1_type_set_config (p_tree);
     690                 :            :           /* check the identifier definitions */
     691                 :         25 :           result_parse = _asn1_check_identifier (p_tree);
     692         [ +  + ]:         25 :           if (result_parse == ASN1_SUCCESS)
     693                 :            :             {                   /* all identifier defined */
     694                 :            :               /* Delete the list and keep the ASN1 structure */
     695                 :         20 :               _asn1_delete_list ();
     696                 :            :               /* Convert into DER coding the value assign to INTEGER constants */
     697                 :         20 :               _asn1_change_integer_value (p_tree);
     698                 :            :               /* Expand the IDs of OBJECT IDENTIFIER constants */
     699                 :         20 :               _asn1_expand_object_id (p_tree);
     700                 :            : 
     701                 :         20 :               *definitions = p_tree;
     702                 :            :             }
     703                 :            :           else                  /* some identifiers not defined */
     704                 :            :             /* Delete the list and the ASN1 structure */
     705                 :          5 :             _asn1_delete_list_and_nodes ();
     706                 :            :         }
     707                 :            :       else                      /* syntax error */
     708                 :            :         /* Delete the list and the ASN1 structure */
     709                 :          6 :         _asn1_delete_list_and_nodes ();
     710                 :            :     }
     711                 :            : 
     712                 :         31 :   _asn1_create_errorDescription (result_parse, error_desc);
     713                 :            : 
     714                 :         31 :   return result_parse;
     715                 :            : }
     716                 :            : 
     717                 :            : /**
     718                 :            :  * asn1_parser2array:
     719                 :            :  * @inputFileName: specify the path and the name of file that
     720                 :            :  *   contains ASN.1 declarations.
     721                 :            :  * @outputFileName: specify the path and the name of file that will
     722                 :            :  *   contain the C vector definition.
     723                 :            :  * @vectorName: specify the name of the C vector.
     724                 :            :  * @error_desc : return the error description or an empty
     725                 :            :  *   string if success.
     726                 :            :  *
     727                 :            :  * Function that generates a C structure from an ASN1 file.  Creates a
     728                 :            :  * file containing a C vector to use to manage the definitions
     729                 :            :  * included in @inputFileName file. If @inputFileName is
     730                 :            :  * "/aa/bb/xx.yy" and @outputFileName is %NULL, the file created is
     731                 :            :  * "/aa/bb/xx_asn1_tab.c".  If @vectorName is %NULL the vector name
     732                 :            :  * will be "xx_asn1_tab".
     733                 :            :  *
     734                 :            :  * Returns: %ASN1_SUCCESS if the file has a correct syntax and every
     735                 :            :  *   identifier is known, %ASN1_FILE_NOT_FOUND if an error occured
     736                 :            :  *   while opening @inputFileName, %ASN1_SYNTAX_ERROR if the syntax is
     737                 :            :  *   not correct, %ASN1_IDENTIFIER_NOT_FOUND if in the file there is
     738                 :            :  *   an identifier that is not defined, %ASN1_NAME_TOO_LONG if in the
     739                 :            :  *   file there is an identifier whith more than %ASN1_MAX_NAME_SIZE
     740                 :            :  *   characters.
     741                 :            :  **/
     742                 :            : int
     743                 :          0 : asn1_parser2array (const char *inputFileName, const char *outputFileName,
     744                 :            :                    const char *vectorName, char *error_desc)
     745                 :            : {
     746                 :          0 :   char *file_out_name = NULL;
     747                 :          0 :   char *vector_name = NULL;
     748                 :            :   const char *char_p, *slash_p, *dot_p;
     749                 :            : 
     750                 :          0 :   p_tree = NULL;
     751                 :            : 
     752                 :          0 :   file_name = inputFileName;
     753                 :            : 
     754                 :            :   /* open the file to parse */
     755                 :          0 :   file_asn1 = fopen (inputFileName, "r");
     756                 :            : 
     757         [ #  # ]:          0 :   if (file_asn1 == NULL)
     758                 :          0 :     result_parse = ASN1_FILE_NOT_FOUND;
     759                 :            :   else
     760                 :            :     {
     761                 :          0 :       result_parse = ASN1_SUCCESS;
     762                 :            : 
     763                 :          0 :       line_number = 1;
     764                 :          0 :       yyparse ();
     765                 :            : 
     766                 :          0 :       fclose (file_asn1);
     767                 :            : 
     768         [ #  # ]:          0 :       if (result_parse == ASN1_SUCCESS)
     769                 :            :         {                       /* syntax OK */
     770                 :            :           /* set IMPLICIT or EXPLICIT property */
     771                 :          0 :           _asn1_set_default_tag (p_tree);
     772                 :            :           /* set CONST_SET and CONST_NOT_USED */
     773                 :          0 :           _asn1_type_set_config (p_tree);
     774                 :            :           /* check the identifier definitions */
     775                 :          0 :           result_parse = _asn1_check_identifier (p_tree);
     776                 :            : 
     777         [ #  # ]:          0 :           if (result_parse == ASN1_SUCCESS)
     778                 :            :             {                   /* all identifier defined */
     779                 :            : 
     780                 :            :               /* searching the last '/' and '.' in inputFileName */
     781                 :          0 :               char_p = inputFileName;
     782                 :          0 :               slash_p = inputFileName;
     783         [ #  # ]:          0 :               while ((char_p = strchr (char_p, '/')))
     784                 :            :                 {
     785                 :          0 :                   char_p++;
     786                 :          0 :                   slash_p = char_p;
     787                 :            :                 }
     788                 :            : 
     789                 :          0 :               char_p = slash_p;
     790                 :          0 :               dot_p = inputFileName + strlen (inputFileName);
     791                 :            : 
     792         [ #  # ]:          0 :               while ((char_p = strchr (char_p, '.')))
     793                 :            :                 {
     794                 :          0 :                   dot_p = char_p;
     795                 :          0 :                   char_p++;
     796                 :            :                 }
     797                 :            : 
     798         [ #  # ]:          0 :               if (outputFileName == NULL)
     799                 :            :                 {
     800                 :            :                   /* file_out_name = inputFileName + _asn1_tab.c */
     801                 :          0 :                   file_out_name = malloc (dot_p - inputFileName + 1 +
     802                 :            :                                           strlen ("_asn1_tab.c"));
     803                 :          0 :                   memcpy (file_out_name, inputFileName,
     804                 :          0 :                           dot_p - inputFileName);
     805                 :          0 :                   file_out_name[dot_p - inputFileName] = 0;
     806                 :          0 :                   strcat (file_out_name, "_asn1_tab.c");
     807                 :            :                 }
     808                 :            :               else
     809                 :            :                 {
     810                 :            :                   /* file_out_name = inputFileName */
     811                 :          0 :                   file_out_name =
     812                 :          0 :                       (char *) malloc (strlen (outputFileName) + 1);
     813                 :          0 :                   strcpy (file_out_name, outputFileName);
     814                 :            :                 }
     815                 :            : 
     816         [ #  # ]:          0 :               if (vectorName == NULL)
     817                 :            :                 {
     818                 :            :                   /* vector_name = file name + _asn1_tab */
     819                 :          0 :                   vector_name = malloc (dot_p - slash_p + 1 +
     820                 :            :                                         strlen ("_asn1_tab"));
     821                 :          0 :                   memcpy (vector_name, slash_p, dot_p - slash_p);
     822                 :          0 :                   vector_name[dot_p - slash_p] = 0;
     823                 :          0 :                   strcat (vector_name, "_asn1_tab");
     824                 :            :                 }
     825                 :            :               else
     826                 :            :                 {
     827                 :            :                   /* vector_name = vectorName */
     828                 :          0 :                   vector_name = (char *) malloc (strlen (vectorName) + 1);
     829                 :          0 :                   strcpy (vector_name, vectorName);
     830                 :            :                 }
     831                 :            : 
     832                 :            :               /* Save structure in a file */
     833                 :          0 :               _asn1_create_static_structure (p_tree,
     834                 :            :                                              file_out_name, vector_name);
     835                 :            : 
     836                 :          0 :               free (file_out_name);
     837                 :          0 :               free (vector_name);
     838                 :            :             }                   /* result == OK */
     839                 :            :         }                       /* result == OK */
     840                 :            : 
     841                 :            :       /* Delete the list and the ASN1 structure */
     842                 :          0 :       _asn1_delete_list_and_nodes ();
     843                 :            :     }                           /* inputFile exist */
     844                 :            : 
     845                 :          0 :   _asn1_create_errorDescription (result_parse, error_desc);
     846                 :            : 
     847                 :          0 :   return result_parse;
     848                 :            : }
     849                 :            : 
     850                 :            : /*************************************************************/
     851                 :            : /*  Function: _asn1_yyerror                                  */
     852                 :            : /*  Description: function called when there are syntax errors*/
     853                 :            : /*  Parameters:                                              */
     854                 :            : /*    char *s : error description                            */
     855                 :            : /*  Return: int                                              */
     856                 :            : /*                                                           */
     857                 :            : /*************************************************************/
     858                 :            : static void
     859                 :         30 : _asn1_yyerror (const char *s)
     860                 :            : {
     861                 :            :   /* Sends the error description to the std_out */
     862                 :            : 
     863 [ +  + ][ +  + ]:         30 :   if (strcmp (last_token, "VisibleString") == 0 ||
     864         [ +  + ]:         24 :       strcmp (last_token, "PrintableString") == 0 ||
     865         [ +  + ]:         21 :       strcmp (last_token, "UniversalString") == 0 ||
     866         [ +  + ]:         18 :       strcmp (last_token, "IA5String") == 0 ||
     867         [ +  + ]:         15 :       strcmp (last_token, "UTF8String") == 0 ||
     868         [ +  + ]:         12 :       strcmp (last_token, "NumericString") == 0 ||
     869         [ +  + ]:          9 :       strcmp (last_token, "TeletexString") == 0 ||
     870                 :          9 :       strcmp (last_token, "BMPString") == 0)
     871                 :            :     {
     872                 :         24 :       snprintf (last_error_token, sizeof(last_error_token),
     873                 :            :                 "%s", last_token);
     874                 :         24 :       fprintf(stderr, "%s:%u: Warning: %s is a built-in ASN.1 type.\n",
     875                 :            :                file_name, line_number, last_token);
     876                 :         24 :       return;
     877                 :            :     }
     878                 :          6 :   last_error_token[0] = 0;
     879                 :            : 
     880         [ +  + ]:          6 :   if (result_parse != ASN1_NAME_TOO_LONG)
     881                 :            :     {
     882                 :          5 :       snprintf (last_error, sizeof(last_error),
     883                 :            :                 "%s:%u: Error: %s near '%s'", file_name,
     884                 :            :                 line_number, s, last_token);
     885                 :          5 :       result_parse = ASN1_SYNTAX_ERROR;
     886                 :            :     }
     887                 :            : 
     888                 :         30 :   return;
     889                 :            : }

Generated by: LCOV version 1.9