home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 1 / 1972 < prev    next >
Encoding:
Internet Message Format  |  1990-12-28  |  32.6 KB
  1. From: loic@adesign.uucp (Loic Dachary)
  2. Newsgroups: alt.sources
  3. Subject: gas-1.36 patches for COFF generation
  4. Message-ID: <LOIC.90Oct16093516@adesign.uucp>
  5. Date: 16 Oct 90 08:35:16 GMT
  6.  
  7. *** m68k.c    Wed May 16 16:47:44 1990
  8. --- /lasvegas/spare/usenet/port/gas-1.36/m68k.c    Sat Oct 13 09:21:00 1990
  9. ***************
  10. *** 22,27 ****
  11. --- 22,28 ----
  12.   #include <ctype.h>
  13.   
  14.   #include "m68k-opcode.h"
  15. + #include "oformat.h"
  16.   #include "as.h"
  17.   #include "obstack.h"
  18.   #include "frags.h"
  19. ***************
  20. *** 2669,2675 ****
  21.     know(fragP->fr_symbol);
  22.   
  23.     /* The displacement of the address, from current location.  */
  24. !   disp = (fragP->fr_symbol->sy_value + fragP->fr_offset) - object_address;
  25.   
  26.     switch(fragP->fr_subtype) {
  27.     case TAB(BCC68000,BYTE):
  28. --- 2670,2676 ----
  29.     know(fragP->fr_symbol);
  30.   
  31.     /* The displacement of the address, from current location.  */
  32. !   disp = (S_GET_VALUE(fragP->fr_symbol) + fragP->fr_offset) - object_address;
  33.   
  34.     switch(fragP->fr_subtype) {
  35.     case TAB(BCC68000,BYTE):
  36. ***************
  37. *** 2798,2804 ****
  38.       /* handle SZ_UNDEF first, it can be changed to BYTE or SHORT */
  39.       switch(fragP->fr_subtype) {
  40.       case TAB(DBCC,SZ_UNDEF):
  41. !         if((fragP->fr_symbol->sy_type&N_TYPE)==segtype) {
  42.               fragP->fr_subtype=TAB(DBCC,SHORT);
  43.               fragP->fr_var+=2;
  44.               break;
  45. --- 2799,2805 ----
  46.       /* handle SZ_UNDEF first, it can be changed to BYTE or SHORT */
  47.       switch(fragP->fr_subtype) {
  48.       case TAB(DBCC,SZ_UNDEF):
  49. !                 if(S_GET_SEGMENT(fragP->fr_symbol)==segtype) {
  50.               fragP->fr_subtype=TAB(DBCC,SHORT);
  51.               fragP->fr_var+=2;
  52.               break;
  53. ***************
  54. *** 2820,2826 ****
  55.           break;
  56.   
  57.       case TAB(BCC68000,SZ_UNDEF):
  58. !         if((fragP->fr_symbol->sy_type&N_TYPE)==segtype) {
  59.               fragP->fr_subtype=TAB(BCC68000,BYTE);
  60.               break;
  61.           }
  62. --- 2821,2827 ----
  63.           break;
  64.   
  65.       case TAB(BCC68000,SZ_UNDEF):
  66. !                 if(S_GET_SEGMENT(fragP->fr_symbol)==segtype) {
  67.               fragP->fr_subtype=TAB(BCC68000,BYTE);
  68.               break;
  69.           }
  70. ***************
  71. *** 2839,2845 ****
  72.           break;
  73.   
  74.       case TAB(BRANCH,SZ_UNDEF):
  75. !         if((fragP->fr_symbol->sy_type&N_TYPE)==segtype) {
  76.               fragP->fr_subtype=TAB(TABTYPE(fragP->fr_subtype),BYTE);
  77.               break;
  78.           } else if(flagseen['m']) {
  79. --- 2840,2846 ----
  80.           break;
  81.   
  82.       case TAB(BRANCH,SZ_UNDEF):
  83. !         if(S_GET_SEGMENT(fragP->fr_symbol)==segtype) {
  84.               fragP->fr_subtype=TAB(TABTYPE(fragP->fr_subtype),BYTE);
  85.               break;
  86.           } else if(flagseen['m']) {
  87. ***************
  88. *** 2880,2886 ****
  89.       case TAB(BRANCH,BYTE):
  90.               /* We can't do a short jump to the next instruction,
  91.                  so we force word mode.  */
  92. !         if(fragP->fr_symbol && fragP->fr_symbol->sy_value==0 &&
  93.    fragP->fr_symbol->sy_frag==fragP->fr_next) {
  94.               fragP->fr_subtype=TAB(TABTYPE(fragP->fr_subtype),SHORT);
  95.               fragP->fr_var+=2;
  96. --- 2881,2887 ----
  97.       case TAB(BRANCH,BYTE):
  98.               /* We can't do a short jump to the next instruction,
  99.                  so we force word mode.  */
  100. !         if(fragP->fr_symbol && S_GET_VALUE(fragP->fr_symbol)==0 &&
  101.    fragP->fr_symbol->sy_frag==fragP->fr_next) {
  102.               fragP->fr_subtype=TAB(TABTYPE(fragP->fr_subtype),SHORT);
  103.               fragP->fr_var+=2;
  104. ***************
  105. *** 2887,2893 ****
  106.           }
  107.           break;
  108.       case TAB(FBRANCH,SZ_UNDEF):
  109. !         if((fragP->fr_symbol->sy_type&N_TYPE)==segtype) {
  110.               fragP->fr_subtype=TAB(FBRANCH,SHORT);
  111.               fragP->fr_var+=2;
  112.           } else {
  113. --- 2888,2894 ----
  114.           }
  115.           break;
  116.       case TAB(FBRANCH,SZ_UNDEF):
  117. !         if(S_GET_SEGMENT(fragP->fr_symbol)==segtype) {
  118.               fragP->fr_subtype=TAB(FBRANCH,SHORT);
  119.               fragP->fr_var+=2;
  120.           } else {
  121. ***************
  122. *** 2896,2902 ****
  123.           }
  124.           break;
  125.       case TAB(PCREL,SZ_UNDEF):
  126. !         if((fragP->fr_symbol->sy_type&N_TYPE)==segtype) {
  127.               fragP->fr_subtype=TAB(PCREL,SHORT);
  128.               fragP->fr_var+=2;
  129.           } else {
  130. --- 2897,2903 ----
  131.           }
  132.           break;
  133.       case TAB(PCREL,SZ_UNDEF):
  134. !         if(S_GET_SEGMENT(fragP->fr_symbol)==segtype) {
  135.               fragP->fr_subtype=TAB(PCREL,SHORT);
  136.               fragP->fr_var+=2;
  137.           } else {
  138. ***************
  139. *** 2910,2915 ****
  140. --- 2911,2917 ----
  141.       return fragP->fr_var + fragP->fr_fix - old_fix;
  142.   }
  143.   
  144. + #ifdef aout
  145.   /* the bit-field entries in the relocation_info struct plays hell 
  146.      with the byte-order problems of cross-assembly.  So as a hack,
  147.      I added this mach. dependent ri twiddler.  Ugly, but it gets
  148. ***************
  149. *** 2935,2940 ****
  150. --- 2937,2943 ----
  151.     /* now put it back where you found it */
  152.     bcopy (the_bytes, (char *)ri_p, sizeof(struct relocation_info));
  153.   }
  154. + #endif /* aout */
  155.   
  156.   #ifndef WORKING_DOT_WORD
  157.   int md_short_jump_size = 4;
  158. *** read.c    Tue Mar  6 22:08:29 1990
  159. --- /lasvegas/spare/usenet/port/gas-1.36/read.c    Mon Oct 15 11:31:29 1990
  160. ***************
  161. *** 35,40 ****
  162. --- 35,41 ----
  163.   #include <ctype.h>
  164.   #include <sys/types.h>
  165.   #include <sys/stat.h>
  166. + #include "oformat.h"
  167.   #include "as.h"
  168.   #include "read.h"
  169.   #include "md.h"
  170. ***************
  171. *** 115,121 ****
  172. --- 116,127 ----
  173.   static int        is_it_end_of_statement();
  174.   static void        pobegin();
  175.   static void        pseudo_set();
  176. + #ifdef coff
  177. + static void        def();
  178. + static void        line();
  179. + #else /* coff */
  180.   static void        stab();
  181. + #endif /* coff */
  182.   static void        stringer();
  183.   
  184.   extern char line_comment_chars[];
  185. ***************
  186. *** 131,136 ****
  187. --- 137,149 ----
  188.   static char *old_input;
  189.   static char *old_limit;
  190.   
  191. + #ifdef coff
  192. + static struct hash_control* tag_hash;
  193. + static void            tag_init();
  194. + static void            tag_insert();
  195. + static symbolS*            tag_find();
  196. + #endif /* coff */
  197. + 
  198.   #ifndef WORKING_DOT_WORD
  199.   struct broken_word *broken_words;
  200.   int new_broken_words = 0;
  201. ***************
  202. *** 143,148 ****
  203. --- 156,164 ----
  204.   read_begin()
  205.   {
  206.     pobegin();
  207. + #ifdef coff
  208. +   tag_init();
  209. + #endif /* coff */
  210.     obstack_begin( ¬es, 5000 );
  211.   #define BIGNUM_BEGIN_SIZE (16)
  212.     bignum_low = xmalloc((long)BIGNUM_BEGIN_SIZE);
  213. ***************
  214. *** 155,162 ****
  215.   po_hash = NULL;            /* use before set up: NULL-> address error */
  216.   
  217.   
  218.   void    s_abort(),    s_align(),    s_comm(),    s_data();
  219. ! void    s_desc(),    s_even(),    s_file(),    s_fill();
  220.   void    s_globl(),    s_lcomm(),    s_line(),    s_lsym();
  221.   void    s_org(),    s_set(),    s_space(),    s_text();
  222.   
  223. --- 171,181 ----
  224.   po_hash = NULL;            /* use before set up: NULL-> address error */
  225.   
  226.   
  227. + #ifdef aout
  228. + void s_desc();
  229. + #endif /* aout */
  230.   void    s_abort(),    s_align(),    s_comm(),    s_data();
  231. ! void    s_even(),    s_file(),    s_fill();
  232.   void    s_globl(),    s_lcomm(),    s_line(),    s_lsym();
  233.   void    s_org(),    s_set(),    s_space(),    s_text();
  234.   
  235. ***************
  236. *** 181,187 ****
  237. --- 200,208 ----
  238.     { "byte",    cons,        1    },
  239.     { "comm",    s_comm,        0    },
  240.     { "data",    s_data,        0    },
  241. + #ifdef aout
  242.     { "desc",    s_desc,        0    },
  243. + #endif /* aout */
  244.     { "double",    float_cons,    'd'    },
  245.     { "file",    s_file,        0    },
  246.     { "fill",    s_fill,        0    },
  247. ***************
  248. *** 207,215 ****
  249. --- 228,241 ----
  250.     { "short",    cons,        2    },
  251.     { "single",    float_cons,    'f'    },
  252.     { "space",    s_space,    0    },
  253. + #ifdef coff
  254. +   { "def",    def,        0    },
  255. +   { "ln",    line,        0    },
  256. + #else /* coff */
  257.     { "stabd",    stab,        'd'    },
  258.     { "stabn",    stab,        'n'    },
  259.     { "stabs",    stab,        's'    },
  260. + #endif /* coff */
  261.     { "text",    s_text,        0    },
  262.   #ifndef SPARC
  263.     { "word",    cons,        2    },
  264. ***************
  265. *** 570,588 ****
  266.       *p = 0;
  267.       symbolP = symbol_find_or_make (name);
  268.       *p = c;
  269. !     if (   (symbolP -> sy_type & N_TYPE) != N_UNDF ||
  270. !  symbolP -> sy_other != 0 || symbolP -> sy_desc != 0) {
  271.           as_warn( "Ignoring attempt to re-define symbol");
  272.           ignore_rest_of_line();
  273.           return;
  274.       }
  275. !     if (symbolP -> sy_value) {
  276. !         if (symbolP -> sy_value != temp)
  277.               as_warn( "Length of .comm \"%s\" is already %d. Not changed to %d.",
  278. !  symbolP -> sy_name, symbolP -> sy_value, temp);
  279.       } else {
  280. !         symbolP -> sy_value = temp;
  281. !         symbolP -> sy_type |= N_EXT;
  282.       }
  283.       know( symbolP -> sy_frag == &zero_address_frag );
  284.       demand_empty_rest_of_line();
  285. --- 596,619 ----
  286.       *p = 0;
  287.       symbolP = symbol_find_or_make (name);
  288.       *p = c;
  289. !     if (S_IS_DEFINED(symbolP) 
  290. ! #ifdef aout
  291. !         || S_GET_OTHER(symbolP) != 0 || S_GET_DESC(symbolP) != 0
  292. ! #endif /* aout */
  293. !         ) {
  294.           as_warn( "Ignoring attempt to re-define symbol");
  295.           ignore_rest_of_line();
  296.           return;
  297.       }
  298. !     if (S_GET_VALUE(symbolP)) {
  299. !         if (S_GET_VALUE(symbolP) != temp)
  300.               as_warn( "Length of .comm \"%s\" is already %d. Not changed to %d.",
  301. !                 S_GET_NAME(symbolP),
  302. !                 S_GET_VALUE(symbolP),
  303. !                 temp);
  304.       } else {
  305. !         S_SET_VALUE(symbolP, temp);
  306. !         S_SET_EXTERNAL(symbolP);
  307.       }
  308.       know( symbolP -> sy_frag == &zero_address_frag );
  309.       demand_empty_rest_of_line();
  310. ***************
  311. *** 598,603 ****
  312. --- 629,635 ----
  313.       demand_empty_rest_of_line();
  314.   }
  315.   
  316. + #ifdef aout
  317.   void
  318.   s_desc()
  319.   {
  320. ***************
  321. *** 627,648 ****
  322.           *p = 0;
  323.           symbolP = symbol_find_or_make (name);
  324.           *p = c;
  325. !         symbolP -> sy_desc = temp;
  326.       }
  327.       demand_empty_rest_of_line();
  328.   }
  329.   
  330.   void
  331.   s_file()
  332.   {
  333. !     register char *s;
  334. !     int    length;
  335. ! 
  336. !     /* Some assemblers tolerate immediately following '"' */
  337. !     if ( s = demand_copy_string( & length ) ) {
  338. !         new_logical_line (s, -1);
  339. !         demand_empty_rest_of_line();
  340. !     }
  341.   }
  342.   
  343.   void
  344. --- 659,684 ----
  345.           *p = 0;
  346.           symbolP = symbol_find_or_make (name);
  347.           *p = c;
  348. !         S_SET_DESC(symbolP,temp);
  349.       }
  350.       demand_empty_rest_of_line();
  351.   }
  352. + #endif /* aout */
  353.   
  354.   void
  355.   s_file()
  356.   {
  357. !     register char *s;
  358. !     int    length;
  359. !     
  360. !     /* Some assemblers tolerate immediately following '"' */
  361. !     if ( s = demand_copy_string( & length ) ) {
  362. !     new_logical_line (s, -1);
  363. !     demand_empty_rest_of_line();
  364. !     }
  365. ! #ifdef coff
  366. !     c_dot_file_symbol(s);
  367. ! #endif /* coff */
  368.   }
  369.   
  370.   void
  371. ***************
  372. *** 825,831 ****
  373.           symbolP = symbol_find_or_make (name);
  374.           * input_line_pointer = c;
  375.           SKIP_WHITESPACE();
  376. !         symbolP -> sy_type |= N_EXT;
  377.           if(c==',') {
  378.               input_line_pointer++;
  379.               SKIP_WHITESPACE();
  380. --- 861,867 ----
  381.           symbolP = symbol_find_or_make (name);
  382.           * input_line_pointer = c;
  383.           SKIP_WHITESPACE();
  384. !         S_SET_EXTERNAL(symbolP);
  385.           if(c==',') {
  386.               input_line_pointer++;
  387.               SKIP_WHITESPACE();
  388. ***************
  389. *** 864,882 ****
  390.       *p = 0;
  391.       symbolP = symbol_find_or_make (name);
  392.       *p = c;
  393. !     if (   symbolP -> sy_other == 0
  394. !         && symbolP -> sy_desc  == 0
  395. !         && (   (   symbolP -> sy_type  == N_BSS
  396. !         && symbolP -> sy_value == local_bss_counter)
  397. !         || (   (symbolP -> sy_type & N_TYPE) == N_UNDF
  398. !         && symbolP -> sy_value == 0))) {
  399. !         symbolP -> sy_value = local_bss_counter;
  400. !         symbolP -> sy_type  = N_BSS;
  401.           symbolP -> sy_frag  = & bss_address_frag;
  402.           local_bss_counter += temp;
  403.       } else
  404.           as_warn( "Ignoring attempt to re-define symbol from %d. to %d.",
  405. !  symbolP -> sy_value, local_bss_counter );
  406.       demand_empty_rest_of_line();
  407.   }
  408.   
  409. --- 900,926 ----
  410.       *p = 0;
  411.       symbolP = symbol_find_or_make (name);
  412.       *p = c;
  413. !     if (
  414. ! #ifdef aout
  415. !         S_GET_OTHER(symbolP) == 0 &&
  416. !         S_GET_DESC(symbolP)  == 0 &&
  417. ! #endif /* aout */  
  418. !         (S_IS_BSS(symbolP) && S_GET_VALUE(symbolP) == local_bss_counter)
  419. ! /* What S_GET_VALUE(symbolP) == 0 is supposed to mean (in aout case) ? 
  420. !    In the coff case it clearly does not mean anything (the only case
  421. !    where a symbol is not defined is from an external declaration (extern a)
  422. !    and this kind of symbol have a 0 value. */
  423. !         || (!S_IS_DEFINED(symbolP) && S_GET_VALUE(symbolP) == 0)) {
  424. !         S_SET_VALUE(symbolP,local_bss_counter);
  425. !         S_SET_BSS(symbolP);
  426. ! #ifdef coff
  427. !         S_SET_STORAGE_CLASS(symbolP, C_STAT);
  428. ! #endif /* coff */
  429.           symbolP -> sy_frag  = & bss_address_frag;
  430.           local_bss_counter += temp;
  431.       } else
  432.           as_warn( "Ignoring attempt to re-define symbol from %d. to %d.",
  433. !  S_GET_VALUE(symbolP), local_bss_counter );
  434.       demand_empty_rest_of_line();
  435.   }
  436.   
  437. ***************
  438. *** 929,942 ****
  439.       segment = expression (& exp);
  440.       if (   segment != SEG_ABSOLUTE && segment != SEG_DATA &&
  441.    segment != SEG_TEXT && segment != SEG_BSS) {
  442. !         as_warn("Bad expression: %s", seg_name [(int)segment]);
  443.           ignore_rest_of_line();
  444.           return;
  445.       }
  446.    know(   segment == SEG_ABSOLUTE || segment == SEG_DATA || segment == SEG_TEXT || segment == SEG_BSS );
  447.       *p = 0;
  448. !     symbolP = symbol_new (name,(unsigned char)(seg_N_TYPE [(int) segment]),
  449.    0, 0, (valueT)(exp . X_add_number), & zero_address_frag);
  450.       *p = c;
  451.       demand_empty_rest_of_line();
  452.   }
  453. --- 973,991 ----
  454.       segment = expression (& exp);
  455.       if (   segment != SEG_ABSOLUTE && segment != SEG_DATA &&
  456.    segment != SEG_TEXT && segment != SEG_BSS) {
  457. !         as_warn("Bad expression: %s", segment_name((int)segment));
  458.           ignore_rest_of_line();
  459.           return;
  460.       }
  461.    know(   segment == SEG_ABSOLUTE || segment == SEG_DATA || segment == SEG_TEXT || segment == SEG_BSS );
  462.       *p = 0;
  463. ! #ifdef coff
  464. !     symbolP = symbol_new(name, segment, (valueT)(exp . X_add_number),
  465. !                  0, &zero_address_frag);
  466. ! #else /* coff */
  467. !     symbolP = symbol_new (name,(unsigned char)(seg_SEG((int) segment)),
  468.    0, 0, (valueT)(exp . X_add_number), & zero_address_frag);
  469. + #endif /* coff */
  470.       *p = c;
  471.       demand_empty_rest_of_line();
  472.   }
  473. ***************
  474. *** 972,978 ****
  475.       if ( ! need_pass_2 ) {
  476.           if (segment != now_seg && segment != SEG_ABSOLUTE)
  477.               as_warn("Illegal segment \"%s\". Segment \"%s\" assumed.",
  478. !  seg_name [(int) segment], seg_name [(int) now_seg]);
  479.           p = frag_var (rs_org, 1, 1, (relax_substateT)0, exp . X_add_symbol,
  480.    exp . X_add_number, (char *)0);
  481.           * p = temp_fill;
  482. --- 1021,1027 ----
  483.       if ( ! need_pass_2 ) {
  484.           if (segment != now_seg && segment != SEG_ABSOLUTE)
  485.               as_warn("Illegal segment \"%s\". Segment \"%s\" assumed.",
  486. !  segment_name((int) segment), segment_name((int) now_seg));
  487.           p = frag_var (rs_org, 1, 1, (relax_substateT)0, exp . X_add_symbol,
  488.    exp . X_add_number, (char *)0);
  489.           * p = temp_fill;
  490. ***************
  491. *** 1017,1023 ****
  492.         if ( ! need_pass_2 ) {
  493.           if (segment != now_seg && segment != SEG_ABSOLUTE)
  494.             as_warn("Illegal segment \"%s\". Segment \"%s\" assumed.",
  495. !               seg_name [(int) segment], seg_name [(int) now_seg]);
  496.           ptr = frag_var (rs_org, 1, 1, (relax_substateT)0, exp.X_add_symbol,
  497.                 exp.X_add_number, (char *)0);
  498.           *ptr= 0;
  499. --- 1066,1073 ----
  500.         if ( ! need_pass_2 ) {
  501.           if (segment != now_seg && segment != SEG_ABSOLUTE)
  502.             as_warn("Illegal segment \"%s\". Segment \"%s\" assumed.",
  503. !               segment_name((int) segment),
  504. !               segment_name((int) now_seg));
  505.           ptr = frag_var (rs_org, 1, 1, (relax_substateT)0, exp.X_add_symbol,
  506.                 exp.X_add_number, (char *)0);
  507.           *ptr= 0;
  508. ***************
  509. *** 1104,1109 ****
  510. --- 1154,1476 ----
  511.     know( is_end_of_line [input_line_pointer [-1]] );
  512.   }
  513.   
  514. + #ifdef coff
  515. + /*
  516. +  * Handle .ln directives.
  517. +  */
  518. + 
  519. + static void
  520. + line(what)
  521. + int what;
  522. + {
  523. +     c_line_new(obstack_next_free(&frags) - frag_now->fr_literal,
  524. +            get_absolute_expression(),
  525. +            frag_now);
  526. +     demand_empty_rest_of_line();
  527. + 
  528. +     return;
  529. + }
  530. + /*
  531. +  *            def()
  532. +  *
  533. +  * Handle .def directives.
  534. +  *
  535. +  * One would say : why can't we symbol_new if the symbol does not
  536. +  * allready exists and fill it with debug information. Because of
  537. +  * the C_EFCN special symbol. It would clobber the value of the
  538. +  * function symbol before we have a chance to notice that it is
  539. +  * a C_EFCN. And a second reason is that the code is more clear this
  540. +  * way. (at least I think it is:-).
  541. +  * 
  542. +  */
  543. + 
  544. + #define SKIP_SEMI_COLON()    while(*input_line_pointer++ != ';')
  545. + #define SKIP_WHITESPACES()    while(*input_line_pointer == ' ' || \
  546. +                       *input_line_pointer == '\t') \
  547. +                                          input_line_pointer++;
  548. + 
  549. + #define NEXT_DEF_DIRECTIVE()     SKIP_SEMI_COLON(); SKIP_WHITESPACES()
  550. + #define equal            !strcmp
  551. + #define MAX_DIRECTIVE        20
  552. + 
  553. + static void
  554. + def(what)
  555. + int what;
  556. + {
  557. +     char    name_end;        /* Char after the end of name */
  558. +     symbolS*    symbolP;        /* Debug symbol just created */
  559. +     symbolS    symbol;            /* Temporary symbol to hold .def */
  560. +     char*    symbol_name;        /* Name of the debug symbol */
  561. +     char*    symbol_name_copy;    /* Temporary copy of the name */
  562. +     unsigned int symbol_name_length;    /* */
  563. +     char*    directiveP;        /* Name of the pseudo opcode */
  564. +     char    directive[MAX_DIRECTIVE]; /* Backup of the directive */
  565. +     char    end = 0;        /* If 1, stop parsing */
  566. +     
  567. +     SKIP_WHITESPACES();
  568. + 
  569. +     symbolP = &symbol;
  570. +     memset((char*)symbolP, '\0', sizeof(symbolS));
  571. + 
  572. +     symbol_name = input_line_pointer;
  573. +     name_end = get_symbol_end();
  574. +     symbol_name_length = strlen(symbol_name);
  575. +     symbol_name_copy = xmalloc(symbol_name_length + 1);
  576. +     strcpy(symbol_name_copy, symbol_name);
  577. +     
  578. +     /* Initialize the new symbol */
  579. + #if STRIP_UNDERSCORE
  580. +     S_SET_NAME(symbolP, *symbol_name_copy == '_' ? symbol_name_copy + 1 :
  581. +                                                symbol_name_copy);
  582. + #else /* STRIP_UNDERSCORE */
  583. +     S_SET_NAME(symbolP, symbol_name_copy);
  584. + #endif /* STRIP_UNDERSCORE */
  585. +     symbolP->sy_name_offset = ~0;
  586. +     symbolP->sy_number = ~0;
  587. +     symbolP->sy_frag = &zero_address_frag;
  588. +     if(S_IS_STRING(symbolP))
  589. +     SF_SET_STRING(symbolP);
  590. + 
  591. +     *input_line_pointer = name_end;
  592. + 
  593. +     while(!end) {
  594. +     NEXT_DEF_DIRECTIVE();
  595. +     directiveP = input_line_pointer;
  596. +     name_end = get_symbol_end();
  597. +     strncpy(directive, directiveP, MAX_DIRECTIVE);
  598. +     *input_line_pointer = name_end;
  599. +     SKIP_WHITESPACES();
  600. +     switch(directive[1]) {
  601. +       case 'd':
  602. +         if(equal(directive, ".dim")) {
  603. +         register int dim_index;
  604. +         register int dimension;
  605. + 
  606. +         S_SET_NUMBER_AUXILIARY(symbolP, 1);
  607. +         for(dim_index = 0; dim_index < DIMNUM; dim_index++) {
  608. +             SKIP_WHITESPACES();
  609. +             SA_SET_SYM_DIMEN(symbolP, dim_index,
  610. +                      get_absolute_expression());
  611. +             switch(*input_line_pointer) {
  612. +               case ',':
  613. +             input_line_pointer++;
  614. +             break;
  615. +               default:
  616. +             as_warn("badly formed .dim directive");
  617. +               case ';':
  618. +             dim_index = DIMNUM;
  619. +             break;
  620. +             }
  621. +         }
  622. +         } else
  623. +         as_warn("unknown debug directive : %s", directive);
  624. +         break;
  625. +       case 'e':
  626. +         if(equal(directive, ".endef"))
  627. +         end = 1;
  628. +         else
  629. +         as_warn("unknown debug directive : %s", directive);
  630. +         break;
  631. +       case 'l':
  632. +         if(equal(directive, ".line")) {
  633. +         S_SET_NUMBER_AUXILIARY(symbolP, 1);
  634. +         SA_SET_SYM_LNNO(symbolP, get_absolute_expression());
  635. +         } else
  636. +         as_warn("unknown debug directive : %s", directive);
  637. +         break;
  638. +       case 's':
  639. +         if(equal(directive, ".size")) {
  640. +         S_SET_NUMBER_AUXILIARY(symbolP, 1);
  641. +         SA_SET_SYM_SIZE(symbolP, get_absolute_expression());
  642. +         } else if(equal(directive, ".scl"))
  643. +         S_SET_STORAGE_CLASS(symbolP, get_absolute_expression());
  644. +         else
  645. +         as_warn("unknown debug directive : %s", directive);
  646. +         break;
  647. +       case 't':
  648. +         if(equal(directive, ".tag")) {
  649. +         symbolS * tag_symbolP;
  650. + 
  651. +         S_SET_NUMBER_AUXILIARY(symbolP, 1);
  652. +         symbol_name = input_line_pointer;
  653. +         name_end = get_symbol_end();
  654. +         /* Assume that the symbol referred to by .tag is 
  655. +            always defined. */
  656. +         SA_SET_SYM_TAGNDX(symbolP, (long)tag_find(symbol_name));
  657. +         if(SA_GET_SYM_TAGNDX(symbolP) == 0L)
  658. +             as_warn("tag not found for .tag %s", symbol_name);
  659. +         SF_SET_TAGGED(symbolP);
  660. +         *input_line_pointer = name_end;
  661. +         } else if(equal(directive, ".type")) {
  662. +         S_SET_DATA_TYPE(symbolP, get_absolute_expression());
  663. +         if(ISFCN(S_GET_DATA_TYPE(symbolP)) &&
  664. +            S_GET_STORAGE_CLASS(symbolP) != C_TPDEF)
  665. +             SF_SET_FUNCTION(symbolP);
  666. +         } else
  667. +         as_warn("unknown debug directive : %s", directive);
  668. +         break;
  669. +       case 'v':
  670. +         if(equal(directive, ".val")) {
  671. +         if(is_name_beginner(*input_line_pointer)) {
  672. +             symbol_name = input_line_pointer;
  673. +             name_end = get_symbol_end();
  674. +             if(equal(symbol_name, ".")) {
  675. +             symbolP->sy_frag = frag_now;
  676. +             S_SET_VALUE(symbolP, obstack_next_free(&frags) -
  677. +                              frag_now->fr_literal);
  678. +             /* If the .val is != from the .def (i.e. statics) */
  679. +             } else if(strcmp(symbol_name_copy, symbol_name)) {
  680. +             register symbolS* forwardP;
  681. +             if(forwardP = symbol_find(symbol_name))
  682. +                 symbolP->sy_forward = forwardP;
  683. +             else
  684. +                 /* Create a new undefined symbol. */
  685. +                 symbolP->sy_forward =
  686. +                 symbol_new (symbol_name, SEG_UNKNOWN,
  687. +                         0, 0, &zero_address_frag);
  688. +             }
  689. +             /* Otherwise, it is the name of a non debug symbol and its
  690. +                value will be calculated later. */
  691. +             *input_line_pointer = name_end;
  692. +         } else
  693. +             S_SET_VALUE(symbolP, get_absolute_expression());
  694. +         } else
  695. +         as_warn("unknown debug directive : %s", directive);
  696. +         break;
  697. +       default:
  698. +         as_warn("unknown debug directive : %s", directive);
  699. +         break;
  700. +     }
  701. +     }
  702. +     demand_empty_rest_of_line();
  703. + 
  704. +     /* Set the section number according to storage class. */
  705. +     switch(S_GET_STORAGE_CLASS(symbolP)) {
  706. +       case C_STRTAG: case C_ENTAG: case C_UNTAG:
  707. +     SF_SET_TAG(symbolP);
  708. +       case C_FILE:
  709. +       case C_TPDEF:
  710. +     SF_SET_DEBUG(symbolP);
  711. +     S_SET_SEGMENT(symbolP, C_DEBUG_SECTION);
  712. +     break;
  713. +       case C_EFCN:
  714. +     SF_SET_LOCAL(symbolP);   /* Do not emit this symbol. */
  715. +       case C_BLOCK:
  716. +     SF_SET_PROCESS(symbolP); /* Will need processing before writing */
  717. +       case C_FCN:
  718. +     S_SET_SEGMENT(symbolP, C_TEXT_SECTION);
  719. +     break;
  720. +       case C_AUTO:
  721. +       case C_REG:
  722. +       case C_MOS: case C_MOE: case C_MOU:
  723. +       case C_ARG:
  724. +       case C_REGPARM:
  725. +       case C_FIELD:
  726. +       case C_EOS:
  727. +     SF_SET_DEBUG(symbolP);
  728. +     S_SET_SEGMENT(symbolP, C_ABS_SECTION);
  729. +     break;
  730. +       case C_EXT:
  731. +       case C_STAT:
  732. +     /* Valid but set somewhere else (s_comm, s_lcomm, colon) */
  733. +     break;
  734. +       case C_USTATIC:
  735. +       case C_EXTDEF:
  736. +       case C_LABEL:
  737. +       case C_ULABEL:
  738. +     as_warn("unexpected storage class %d", S_GET_STORAGE_CLASS(symbolP));
  739. +     break;
  740. +     }
  741. +     /* Now that we have build up a debug symbol, try to find if we should
  742. +        merge with an existing symbol or not. */
  743. +     /* If symbol does not exist, or symbol is a end function mark,
  744. +        or symbol is in debug or abs section,
  745. +        insert it in the list of symbols. */
  746. +     if(S_GET_STORAGE_CLASS(symbolP) == C_EFCN ||
  747. +        S_GET_SEGMENT(symbolP) == C_DEBUG_SECTION ||
  748. +        S_GET_SEGMENT(symbolP) == C_ABS_SECTION ||
  749. +        (symbolP = symbol_find_base(S_GET_NAME(symbolP), DO_NOT_STRIP)) ==
  750. +     (symbolS*)0) {
  751. + 
  752. +     symbolP = (symbolS *)obstack_alloc(¬es, sizeof(symbolS));
  753. +     memcpy((char*)symbolP, &symbol, sizeof(symbolS));
  754. + 
  755. +     symbol_lastP->sy_next = symbolP;
  756. +     symbolP->sy_previous = symbol_lastP;
  757. +     symbol_lastP = symbolP;
  758. + 
  759. +     } else {
  760. +     /* This symbol allready exists, merge the newly created symbol into
  761. +        the old one. This is not mandatory. The linker can handle
  762. +        duplicate symbols correctly. But I guess that it save a *lot*
  763. +        of space if the assembly file defines a lot of symbols. */
  764. +     /* The debug entry (symbol) is merged into symbolP. */
  765. +     c_symbol_merge(&symbol, symbolP);
  766. +     /* For the function, the symbol *must* be were the debug symbol
  767. +        appear. Move the existing symbol to the current place. */
  768. +     /* Do not take in account special cases where symbolP is first 
  769. +        in the list. It is always after a .bf */
  770. +     if(SF_GET_FUNCTION(symbolP)) {
  771. +         /* If it already is at the end of the symbol list, do nothing */
  772. +         if(symbolP != symbol_lastP) {
  773. +         /* Remove from the list */
  774. +         symbolP->sy_next->sy_previous = symbolP->sy_previous;
  775. +         symbolP->sy_previous->sy_next = symbolP->sy_next;
  776. +         /* Append at the end of the list */
  777. +         symbol_lastP->sy_next = symbolP;
  778. +         symbolP->sy_previous = symbol_lastP;
  779. +         symbol_lastP = symbolP;
  780. +         }
  781. +     } else
  782. +         free(symbol_name_copy);
  783. +     }
  784. +     
  785. +     /* If symbol is a {structure,union} tag, associate symbol to its name. */
  786. +     if(SF_GET_TAG(symbolP))
  787. +     tag_insert(S_GET_NAME(symbolP), symbolP);
  788. + 
  789. +     /* Create the line number entry pointing on the function being defined */
  790. +     if(SF_GET_FUNCTION(symbolP)) {
  791. +     c_line_new((long)S_GET_NAME(symbolP), 0, &zero_address_frag);
  792. +     SF_SET_PROCESS(symbolP);
  793. +     }
  794. + }
  795. + 
  796. + /* 
  797. +  *  Maintain a list of the tagnames of the structres.
  798. +  */
  799. + 
  800. + static void
  801. + tag_init()
  802. + {
  803. +     tag_hash = hash_new();
  804. +     return ;
  805. + }
  806. + 
  807. + static void
  808. + tag_insert(name, symbolP)
  809. + char* name;
  810. + symbolS* symbolP;
  811. + {
  812. +     register char *    error_string;
  813. + 
  814. +     if(*(error_string = hash_jam (tag_hash, name, (char *)symbolP))) {
  815. +     as_fatal("Inserting \"%s\" into structure table failed: %s",
  816. +          name, error_string);
  817. +     }
  818. +     return ;
  819. + }
  820. + 
  821. + static symbolS*
  822. + tag_find(name)
  823. + char* name;
  824. + {
  825. + #if STRIP_UNDERSCORE
  826. +     if(*name == '_') name++;
  827. + #endif /* STRIP_UNDERSCORE */
  828. +     return((symbolS*)hash_find(tag_hash, name));
  829. + }
  830. + #else /* coff */
  831.   /*
  832.    *            stab()
  833.    *
  834. ***************
  835. *** 1158,1165 ****
  836.           symbolP = symbol_new (string, 0,0,0,0,(struct frag *)0);
  837.           switch (what) {
  838.           case 'd':
  839. !             symbolP->sy_name = NULL; /* .stabd feature. */
  840. !             symbolP->sy_value = obstack_next_free(& frags) - frag_now->fr_literal;
  841.               symbolP->sy_frag = frag_now;
  842.               break;
  843.   
  844. --- 1525,1533 ----
  845.           symbolP = symbol_new (string, 0,0,0,0,(struct frag *)0);
  846.           switch (what) {
  847.           case 'd':
  848. !             S_SET_NAME(symbolP,NULL); /* .stabd feature. */
  849. !             S_SET_VALUE(symbolP,obstack_next_free(&frags) - 
  850. !                     frag_now->fr_literal);
  851.               symbolP->sy_frag = frag_now;
  852.               break;
  853.   
  854. ***************
  855. *** 1185,1191 ****
  856.       }
  857.       if (! goof) {
  858.           if (get_absolute_expression_and_terminator (& longint) == ',')
  859. !             symbolP->sy_other = longint;
  860.           else {
  861.               as_warn( "I want a comma after the n_other expression" );
  862.               goof = TRUE;
  863. --- 1553,1559 ----
  864.       }
  865.       if (! goof) {
  866.           if (get_absolute_expression_and_terminator (& longint) == ',')
  867. !             S_SET_OTHER(symbolP,longint);
  868.           else {
  869.               as_warn( "I want a comma after the n_other expression" );
  870.               goof = TRUE;
  871. ***************
  872. *** 1193,1199 ****
  873.           }
  874.       }
  875.       if (! goof) {
  876. !         symbolP->sy_desc = get_absolute_expression ();
  877.           if (what == 's' || what == 'n') {
  878.               if (* input_line_pointer != ',') {
  879.                   as_warn( "I want a comma after the n_desc expression" );
  880. --- 1561,1567 ----
  881.           }
  882.       }
  883.       if (! goof) {
  884. !         S_SET_DESC(symbolP, get_absolute_expression ());
  885.           if (what == 's' || what == 'n') {
  886.               if (* input_line_pointer != ',') {
  887.                   as_warn( "I want a comma after the n_desc expression" );
  888. ***************
  889. *** 1212,1217 ****
  890. --- 1580,1586 ----
  891.       else
  892.           demand_empty_rest_of_line ();
  893.   }
  894. + #endif /* coff */
  895.   
  896.   /*
  897.    *            pseudo_set()
  898. ***************
  899. *** 1230,1239 ****
  900.   {
  901.     expressionS    exp;
  902.     register segT    segment;
  903.     int ext;
  904.   
  905.     know( symbolP );        /* NULL pointer is logic error. */
  906. !   ext=(symbolP->sy_type&N_EXT);
  907.     if ((segment = expression( & exp )) == SEG_NONE)
  908.       {
  909.         as_warn( "Missing expression: absolute 0 assumed" );
  910. --- 1599,1612 ----
  911.   {
  912.     expressionS    exp;
  913.     register segT    segment;
  914. + #ifdef aout
  915.     int ext;
  916. + #endif /* aout */
  917.   
  918.     know( symbolP );        /* NULL pointer is logic error. */
  919. ! #ifdef aout
  920. !   ext=S_IS_EXTERNAL(symbolP);
  921. ! #endif /* aout */
  922.     if ((segment = expression( & exp )) == SEG_NONE)
  923.       {
  924.         as_warn( "Missing expression: absolute 0 assumed" );
  925. ***************
  926. *** 1245,1272 ****
  927.       case SEG_BIG:
  928.         as_warn( "%s number illegal. Absolute 0 assumed.",
  929.             exp . X_add_number > 0 ? "Bignum" : "Floating-Point" );
  930. !       symbolP -> sy_type = N_ABS | ext;
  931. !       symbolP -> sy_value = 0;
  932.         symbolP -> sy_frag = & zero_address_frag;
  933.         break;
  934.   
  935.       case SEG_NONE:
  936.         as_warn("No expression:  Using absolute 0");
  937. !       symbolP -> sy_type = N_ABS | ext;
  938. !       symbolP -> sy_value = 0;
  939.         symbolP -> sy_frag = & zero_address_frag;
  940.         break;
  941.   
  942.       case SEG_DIFFERENCE:
  943.         if (exp.X_add_symbol && exp.X_subtract_symbol
  944. !           &&    (exp.X_add_symbol->sy_type & N_TYPE)
  945. !          == (exp.X_subtract_symbol->sy_type & N_TYPE))
  946.       exp.X_add_number+=exp.X_add_symbol->sy_value - exp.X_subtract_symbol->sy_value;
  947.         else
  948.       as_warn( "Complex expression. Absolute segment assumed." );
  949.       case SEG_ABSOLUTE:
  950. !       symbolP -> sy_type = N_ABS | ext;
  951. !       symbolP -> sy_value = exp . X_add_number;
  952.         symbolP -> sy_frag = & zero_address_frag;
  953.         break;
  954.    
  955. --- 1618,1657 ----
  956.       case SEG_BIG:
  957.         as_warn( "%s number illegal. Absolute 0 assumed.",
  958.             exp . X_add_number > 0 ? "Bignum" : "Floating-Point" );
  959. !       S_SET_ABS(symbolP); 
  960. ! #ifdef aout
  961. !       ext ? S_SET_EXTERNAL(symbolP) : 
  962. !         S_CLEAR_EXTERNAL(symbolP);
  963. ! #endif /* aout */
  964. !       S_SET_VALUE(symbolP, 0);
  965.         symbolP -> sy_frag = & zero_address_frag;
  966.         break;
  967.   
  968.       case SEG_NONE:
  969.         as_warn("No expression:  Using absolute 0");
  970. !       S_SET_ABS(symbolP); 
  971. ! #ifdef aout
  972. !       ext ? S_SET_EXTERNAL(symbolP) : 
  973. !         S_CLEAR_EXTERNAL(symbolP);
  974. ! #endif /* aout */
  975. !       S_SET_VALUE(symbolP, 0);
  976.         symbolP -> sy_frag = & zero_address_frag;
  977.         break;
  978.   
  979.       case SEG_DIFFERENCE:
  980.         if (exp.X_add_symbol && exp.X_subtract_symbol
  981. !           && (S_GET_SEGMENT(exp.X_add_symbol) ==
  982. !           S_GET_SEGMENT(exp.X_subtract_symbol)))
  983.       exp.X_add_number+=exp.X_add_symbol->sy_value - exp.X_subtract_symbol->sy_value;
  984.         else
  985.       as_warn( "Complex expression. Absolute segment assumed." );
  986.       case SEG_ABSOLUTE:
  987. !       S_SET_ABS(symbolP); 
  988. ! #ifdef aout
  989. !       ext ? S_SET_EXTERNAL(symbolP) : 
  990. !         S_CLEAR_EXTERNAL(symbolP);
  991. ! #endif /* aout */
  992. !       S_SET_VALUE(symbolP, exp.X_add_number);
  993.         symbolP -> sy_frag = & zero_address_frag;
  994.         break;
  995.    
  996. ***************
  997. *** 1273,1280 ****
  998.       case SEG_DATA:
  999.       case SEG_TEXT:
  1000.       case SEG_BSS:
  1001. !       symbolP -> sy_type = seg_N_TYPE [(int) segment] | ext;
  1002. !       symbolP -> sy_value= exp . X_add_number + exp . X_add_symbol -> sy_value;
  1003.         symbolP -> sy_frag = exp . X_add_symbol -> sy_frag;
  1004.         break;
  1005.         
  1006. --- 1658,1673 ----
  1007.       case SEG_DATA:
  1008.       case SEG_TEXT:
  1009.       case SEG_BSS:
  1010. !       switch(segment) {
  1011. !     case SEG_DATA:      S_SET_DATA(symbolP); break;
  1012. !     case SEG_TEXT:      S_SET_TEXT(symbolP); break;
  1013. !     case SEG_BSS:      S_SET_BSS(symbolP); break;
  1014. !       }
  1015. ! #ifdef aout
  1016. !       ext ? S_SET_EXTERNAL(symbolP) : 
  1017. !         S_CLEAR_EXTERNAL(symbolP);
  1018. ! #endif /* aout */
  1019. !       S_SET_VALUE(symbolP, exp.X_add_number + S_GET_VALUE(exp.X_add_symbol));
  1020.         symbolP -> sy_frag = exp . X_add_symbol -> sy_frag;
  1021.         break;
  1022.         
  1023. ***************
  1024. *** 1371,1378 ****
  1025.         if ( segment == SEG_DIFFERENCE && exp . X_add_symbol == NULL )
  1026.           {
  1027.             as_warn( "Subtracting symbol \"%s\"(segment\"%s\") is too hard. Absolute segment assumed.",
  1028. !               exp . X_subtract_symbol -> sy_name,
  1029. !               seg_name [(int) N_TYPE_seg [exp . X_subtract_symbol -> sy_type & N_TYPE]]);
  1030.             segment = SEG_ABSOLUTE;
  1031.             /* Leave exp . X_add_number alone. */
  1032.           }
  1033. --- 1764,1771 ----
  1034.         if ( segment == SEG_DIFFERENCE && exp . X_add_symbol == NULL )
  1035.           {
  1036.             as_warn( "Subtracting symbol \"%s\"(segment\"%s\") is too hard. Absolute segment assumed.",
  1037. !          S_GET_NAME(exp.X_subtract_symbol),
  1038. !              segment_name((int)SEG_seg(S_GET_SEGMENT(exp.X_subtract_symbol))));
  1039.             segment = SEG_ABSOLUTE;
  1040.             /* Leave exp . X_add_number alone. */
  1041.           }
  1042. ***************
  1043. *** 1853,1860 ****
  1044.     if (   (retval = get_segmented_expression (expP)) == SEG_UNKNOWN
  1045.         )
  1046.       {
  1047. !       name1 = expP -> X_add_symbol ? expP -> X_add_symbol -> sy_name : "";
  1048. !       name2 = expP -> X_subtract_symbol ? expP -> X_subtract_symbol -> sy_name : "";
  1049.         if ( name1 && name2 )
  1050.       {
  1051.         as_warn("Symbols \"%s\" \"%s\" are undefined: absolute 0 assumed.",
  1052. --- 2246,2255 ----
  1053.     if (   (retval = get_segmented_expression (expP)) == SEG_UNKNOWN
  1054.         )
  1055.       {
  1056. !       name1 = expP->X_add_symbol ? S_GET_NAME(expP->X_add_symbol) : "";
  1057. !       name2 = expP->X_subtract_symbol ?
  1058. !           S_GET_NAME(expP->X_subtract_symbol) :
  1059. !           "";
  1060.         if ( name1 && name2 )
  1061.       {
  1062.         as_warn("Symbols \"%s\" \"%s\" are undefined: absolute 0 assumed.",
  1063. ***************
  1064. *** 1988,1994 ****
  1065.   equals(sym_name)
  1066.   char *sym_name;
  1067.   {
  1068. !   register struct symbol * symbolP; /* symbol we are working with */
  1069.   
  1070.     if(sym_name[0]=='.' && sym_name[1]=='\0') {
  1071.       /* Turn '. = mumble' into a .org mumble */
  1072. --- 2383,2389 ----
  1073.   equals(sym_name)
  1074.   char *sym_name;
  1075.   {
  1076. !   register symbolS * symbolP; /* symbol we are working with */
  1077.   
  1078.     if(sym_name[0]=='.' && sym_name[1]=='\0') {
  1079.       /* Turn '. = mumble' into a .org mumble */
  1080. ***************
  1081. *** 2006,2012 ****
  1082.       if ( ! need_pass_2 ) {
  1083.         if (segment != now_seg && segment != SEG_ABSOLUTE)
  1084.           as_warn("Illegal segment \"%s\". Segment \"%s\" assumed.",
  1085. !                 seg_name [(int) segment], seg_name [(int) now_seg]);
  1086.         p = frag_var (rs_org, 1, 1, (relax_substateT)0, exp.X_add_symbol,
  1087.                       exp.X_add_number, (char *)0);
  1088.         * p = 0;
  1089. --- 2401,2408 ----
  1090.       if ( ! need_pass_2 ) {
  1091.         if (segment != now_seg && segment != SEG_ABSOLUTE)
  1092.           as_warn("Illegal segment \"%s\". Segment \"%s\" assumed.",
  1093. !                 segment_name((int) segment),
  1094. !         segment_name((int) now_seg));
  1095.         p = frag_var (rs_org, 1, 1, (relax_substateT)0, exp.X_add_symbol,
  1096.                       exp.X_add_number, (char *)0);
  1097.         * p = 0;
  1098. --
  1099. Loic Dachary     loic@adesign.uucp or loic@afp.uucp 
  1100. Voice        +33 1 40 35 20 20
  1101.