megaco_flex_scanner_drv.flex.src

OTP是开放电信平台的简称

static void mfs_dbg_buf_print(char* func, char* bufName, char* buf, int len)
{
  FILE *f;
  f = fopen(MFS_LOG_FILE_NAME, MFS_LOG_FILE_MODE);
  fprintf(f, "%s -> %s (%d):\n", func, bufName, len);
  hexdump(f, (unsigned char*) buf, len);
  fclose(f);
}


#endif /* if defined(MFS_DEBUG) */


static void mfs_alloc_failed(char* msg, int sz)
{
  /*
   * Make sure we are not allready in error state
   */
  if (!mfs_error) {

    /* 
     * Make sure that there is room in the buffer:
     * length of msg + 10 chars for the ' of %d bytes'
     * + 10 chars for the size value...
     * This is really overkill since the msg string is never
     * longer then 50 chars, but sinze this function is 
     * called when we have run out of memory...
     */

    int msg_len = strlen(msg);
    if ((10 + 10 + msg_len) < sizeof(mfs_error_msg)) {
      if (0 >= sprintf(mfs_error_msg, "%s of %d bytes", msg, sz)) {
	mfs_fatal_error(msg);
      }
    } else {
      mfs_fatal_error(msg);
    }
    mfs_error = TRUE;
  }
}


static void mfs_ensure_term_spec(int size)
{
  /*
  DBG( ("mfs_ensure_term_spec -> entry with"
	"\n   size:       %d"
	"\nwhen"
	"\n   spec_index: %d"
	"\n   spec_size:  %d"
	"\n", size, mfs_term_spec_index, mfs_term_spec_size) );
  */

  /* OTP-4236 - BEGIN */
  if ((mfs_term_spec_index + size) >= mfs_term_spec_size) {
    void *tmp;

    DBG( ("mfs_ensure_term_spec -> allocate more memory when"
	  "\n   term_spec_index: %d"
	  "\n   term_spec_size:  %d\n", 
	  mfs_term_spec_index, mfs_term_spec_size) );

    mfs_term_spec_size = (mfs_term_spec_size * 2) + size;

    DBG( ("mfs_ensure_term_spec -> "
	  "term_spec is at 0x%X, new term_spec_size is %d\n", 
	  mfs_term_spec, mfs_term_spec_size) );

    tmp = REALLOC(mfs_term_spec, mfs_term_spec_size * sizeof(ErlDrvTermData));

    if (tmp == NULL) {
      /*
       * Ouch, we did'nt get any new memory.
       * Just give ut. I.e. free the memory we have (note that
       * the assign macro tests the buffer before assigning).
       */
      driver_free(mfs_term_spec);
      mfs_term_spec = NULL;

      mfs_alloc_failed("failed reallocating term spec buffer", 
		       mfs_term_spec_size * sizeof(ErlDrvTermData));

    } else {
      mfs_term_spec = tmp;
    }

    DBG( ("mfs_ensure_term_spec -> new term_spec is at 0x%X\n", 
	  mfs_term_spec) );
  }
  /* OTP-4236 - END */
}

static void mfs_short_load_token(ErlDrvTermData TokenTag)
{
  /* Build a {TokenTag, LineNumber} tuple */

  /*
  DBG( ("mfs_short_load_token -> entry with"
	"\n   TokenTag: %ld\n", TokenTag) );
  */

  mfs_ensure_term_spec(6); 
  mfs_token_counter++; 
  ASSIGN_TERM_SPEC(ERL_DRV_ATOM);
  ASSIGN_TERM_SPEC(TokenTag);
  ASSIGN_TERM_SPEC(ERL_DRV_INT);
  ASSIGN_TERM_SPEC(LINENO_OR_TOKENCNT);
  ASSIGN_TERM_SPEC(ERL_DRV_TUPLE);
  ASSIGN_TERM_SPEC(2);
}

static void mfs_octet_load_token(ErlDrvTermData TokenTag, int is_empty)
{
  /* Build a {TokenTag, LineNumber, String} tuple */

  DBG( ("mfs_octet_load_token -> entry with"
	"\n   TokenTag: %ld"
	"\n   is_empty: %ld\n", TokenTag, is_empty) );
  
  mfs_ensure_term_spec(9); 
  mfs_token_counter++; 
  ASSIGN_TERM_SPEC(ERL_DRV_ATOM);
  ASSIGN_TERM_SPEC(TokenTag);
  ASSIGN_TERM_SPEC(ERL_DRV_INT);
  ASSIGN_TERM_SPEC(LINENO_OR_TOKENCNT);
  ASSIGN_TERM_SPEC(ERL_DRV_STRING);

  if (is_empty) {
    *mfs_text_ptr = 0;
    ASSIGN_TERM_SPEC((ErlDrvTermData)mfs_text_ptr);
    mfs_text_ptr++;
    ASSIGN_TERM_SPEC(0);
  } else {
    strncpy(mfs_text_ptr, yytext, yyleng);

    DBG_BUF("mfs_octet_load_token", "mfs_text_ptr", 
	    mfs_text_ptr, yyleng);

    ASSIGN_TERM_SPEC((ErlDrvTermData)mfs_text_ptr);
    mfs_text_ptr += yyleng;
    ASSIGN_TERM_SPEC(yyleng);
  }
  ASSIGN_TERM_SPEC(ERL_DRV_TUPLE);
  ASSIGN_TERM_SPEC(3);
}

static void mfs_lower_load_token(ErlDrvTermData TokenTag)
{
  /* Build a {TokenTag, LineNumber, LowerCaseString} tuple */
  int i;

  /*
  DBG( ("mfs_lower_load_token -> entry with"
	"\n   TokenTag: %ld\n", TokenTag) );
  */

  mfs_ensure_term_spec(9); 
  mfs_token_counter++; 
  ASSIGN_TERM_SPEC(ERL_DRV_ATOM);
  ASSIGN_TERM_SPEC(TokenTag);
  ASSIGN_TERM_SPEC(ERL_DRV_INT);
  ASSIGN_TERM_SPEC(LINENO_OR_TOKENCNT);
  ASSIGN_TERM_SPEC(ERL_DRV_STRING);

  for ( i = 0; i < yyleng; ++i ) {
    mfs_text_ptr[i] = tolower(yytext[i]);
  }

  /*
  DBG_BUF("mfs_lower_load_token", "mfs_text_ptr", 
           mfs_text_ptr, yyleng);
  */

  ASSIGN_TERM_SPEC((ErlDrvTermData)mfs_text_ptr);
  mfs_text_ptr += yyleng;
  ASSIGN_TERM_SPEC(yyleng);
  ASSIGN_TERM_SPEC(ERL_DRV_TUPLE);
  ASSIGN_TERM_SPEC(3);
}

static void mfs_load_map_name()
{
    /* Copy digit map name as lower case */
    int i;

    for ( i = 0; i < yyleng; ++i ) {
      mfs_text_ptr[i] = tolower(yytext[i]);
    }

    mfs_digit_map_name_ptr = mfs_text_ptr;
    mfs_digit_map_name_len = yyleng;
    mfs_text_ptr += yyleng;
}

static void mfs_load_map_value()
{
    /* Copy digit map value as lower case */
    int i;

    for ( i = 0; i < yyleng; ++i ) {
      mfs_text_ptr[i] = tolower(yytext[i]);
    }

    mfs_digit_map_value_ptr = mfs_text_ptr;
    mfs_digit_map_value_len = yyleng;
    mfs_text_ptr += yyleng;
}

static void mfs_load_map_timer()
{
  /* The digit map timer consists of 3 or 4 characters:
   * z and Z are actually version 2 only
   * 0 - the kind of timer (t|T|s|S|l|L|z|Z)
   * 1 - a colon
   * 2 - mandatory digit
   * 3 - optional digit
   */
  
  int timer_len = yyleng - 2;

  /*
  DBG( ("mfs_load_map_timer -> entry when yyleng: %d\n", yyleng) );
  DBG( ("mfs_load_map_timer -> yytext: 0x%x\n", yytext) );

  DBG( ("mfs_load_map_timer -> yytext[0]: %u (%c)\n", yytext[0], yytext[0]) );
  DBG( ("mfs_load_map_timer -> yytext[1]: %u (%c)\n", yytext[1], yytext[1]) );
  DBG( ("mfs_load_map_timer -> yytext[2]: %u (%c)\n", yytext[2], yytext[2]) );
  DBG( ("mfs_load_map_timer -> yytext[3]: %u (%c)\n", yytext[3], yytext[3]) );
  */

  /* Pad with leading zero */

  if (timer_len == 1) {
    mfs_text_ptr[0] = '0';
    mfs_text_ptr[1] = yytext[2];
  } else if (timer_len == 2) {
    mfs_text_ptr[0] = yytext[2];
    mfs_text_ptr[1] = yytext[3];
  }

  /*
  DBG( ("mfs_load_map_timer -> mfs_text_ptr[0]: %u (%c)\n", 
	mfs_text_ptr[0], mfs_text_ptr[0]) );
  DBG( ("mfs_load_map_timer -> mfs_text_ptr[1]: %u (%c)\n", 
	mfs_text_ptr[1], mfs_text_ptr[1]) );

  DBG( ("mfs_load_map_timer -> mfs_text_ptr: 0x%x\n", 
	mfs_text_ptr) );
  */

  switch (yytext[0]) {
  case 't':
  case 'T':
    mfs_digit_map_start_ptr = mfs_text_ptr;
    break;;
  case 's':
  case 'S':
    mfs_digit_map_short_ptr = mfs_text_ptr;
    break;;
  case 'l':
  case 'L':
    mfs_digit_map_long_ptr = mfs_text_ptr;
    break;;
  case 'z':
  case 'Z':
    mfs_digit_map_duration_ptr = mfs_text_ptr;
    break;;
  }

  /* We pad when there is only one digit, so it will always be two */
  mfs_text_ptr += 2; 

}

static void load_timer_field(char* text)
{
  mfs_ensure_term_spec(2);    /* OTP-4236 */
  if (text == NULL) {
    ASSIGN_TERM_SPEC(ERL_DRV_ATOM);
    ASSIGN_TERM_SPEC(mfs_asn1_NOVALUE);
  } else {
    ASSIGN_TERM_SPEC(ERL_DRV_INT);
    ASSIGN_TERM_SPEC(((text[0] - '0') * 10) + (text[1] - '0'));
  }
}

static void mfs_load_map_token()
{
  /* 
   * Build a {'DigitMapDescriptorToken', LineNumber, 
   *          {'DigitMapDescriptor', DigitMapName, DigitMapValue}} tuple 
   */

  mfs_ensure_term_spec(20); 
  mfs_token_counter++; 
  ASSIGN_TERM_SPEC(ERL_DRV_ATOM);
  ASSIGN_TERM_SPEC(mfs_DigitMapDescriptorToken);
  ASSIGN_TERM_SPEC(ERL_DRV_INT);
  ASSIGN_TERM_SPEC(LINENO_OR_TOKENCNT);
  
  ASSIGN_TERM_SPEC(ERL_DRV_ATOM);
  ASSIGN_TERM_SPEC(mfs_DigitMapDescriptor);
  
  if (mfs_digit_map_name_ptr == 0) {
    ASSIGN_TERM_SPEC(ERL_DRV_ATOM);
    ASSIGN_TERM_SPEC(mfs_asn1_NOVALUE);
  } else {
    ASSIGN_TERM_SPEC(ERL_DRV_STRING);
    ASSIGN_TERM_SPEC((ErlDrvTermData)mfs_digit_map_name_ptr);
    ASSIGN_TERM_SPEC(mfs_digit_map_name_len);
    mfs_digit_map_name_ptr = NULL; 
  }
  
  if (mfs_digit_map_value_ptr == NULL) {
    ASSIGN_TERM_SPEC(ERL_DRV_ATOM);
    ASSIGN_TERM_SPEC(mfs_asn1_NOVALUE);
  } else {
    ASSIGN_TERM_SPEC(ERL_DRV_ATOM);
    ASSIGN_TERM_SPEC(mfs_DigitMapValue);
    
    /* Take care of timer values */
    load_timer_field(mfs_digit_map_start_ptr);
    mfs_digit_map_start_ptr = NULL;
    
    load_timer_field(mfs_digit_map_short_ptr);
    mfs_digit_map_short_ptr = NULL;
    
    load_timer_field(mfs_digit_map_long_ptr);
    mfs_digit_map_long_ptr = NULL;
    
    load_timer_field(mfs_digit_map_duration_ptr);
    mfs_digit_map_duration_ptr = NULL;
    
    ASSIGN_TERM_SPEC(ERL_DRV_STRING);
    ASSIGN_TERM_SPEC((ErlDrvTermData)mfs_digit_map_value_ptr);
    ASSIGN_TERM_SPEC(mfs_digit_map_value_len);
    mfs_digit_map_value_ptr = NULL; 
    ASSIGN_TERM_SPEC(ERL_DRV_TUPLE);
    ASSIGN_TERM_SPEC(6);
  }
  
  ASSIGN_TERM_SPEC(ERL_DRV_TUPLE);