home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 3: Developer Tools / Linux Cubed Series 3 - Developer Tools.iso / devel / lang / c / c-bat-0.1n / c-bat-0 / c-bat-0.1 / src / clients.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-06-16  |  43.1 KB  |  1,661 lines
  1. /*
  2.     clients.c : Browsing an Analysis Tool for C-source code;
  3.             Client-Application-Library
  4.  
  5.     Copyright (C) 1993  Eckehard Stolz
  6.  
  7.     This program is free software; you can redistribute it and/or modify
  8.     it under the terms of the GNU General Public License as published by
  9.     the Free Software Foundation (version 2 of the License).
  10.  
  11.     This program is distributed in the hope that it will be useful,
  12.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.     GNU General Public License for more details.
  15.  
  16.     You should have received a copy of the GNU General Public License
  17.     along with this program; if not, write to the Free Software
  18.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19.  */
  20.  
  21. #include <stdio.h>
  22. #include <stdlib.h>
  23. #include <string.h>
  24.  
  25. #include "hash.h"
  26. #include "c-bat.h"
  27.  
  28. /*********************************************************
  29.  Short overview:
  30.  
  31.  A Client has first to connect to a server to which it
  32.  can send information requests and get the results.
  33.  
  34.  Normally, the functions defined in this module do
  35.  automatically connect to the master-server, which is
  36.  the first (or only) server started. However, a client
  37.  can connect to an other server if it knows it's server-ID.
  38.  
  39.  This ID can be obtained by the get_server_id function
  40.  which asks the master server for the ID of the server
  41.  which processes a special browser file.
  42.  
  43.  Each client can only be connected to one server at a given
  44.  time. However, you can switch to an other server by first 
  45.  disconnect the old one and then connect to the new
  46.  server.
  47.  
  48.  All functions send the request to the server when they are
  49.  called for the first time. If they can return more than
  50.  one return-value, the have to be called multiple times.
  51.  After the last value has been returned, these functions
  52.  return RET_END instead of 0.
  53.  
  54.  For the documentation of the functions, please look in the
  55.  comments preceeding these functions.
  56.  
  57.  ****************************************/
  58.  
  59. static int connected = 0;
  60.  
  61. /* ID of the server to which this client is connected
  62.  */
  63. static int Server_ID = MASTER_ID;
  64.  
  65. /* Timeout in seconds. Default is set to SECONDS_TIMEOUT
  66.    can be overridden if server recommends higher value
  67.  */
  68. extern int  timeout_value;
  69.  
  70. /* connects to server1;
  71.  
  72.    return:  0    ...  O.K.
  73.             else ...  Return-value from server
  74. */
  75. short brs_connect_server(int server_id)
  76. { char   arg1[STRINGSIZE],
  77.          arg2[STRINGSIZE],
  78.          arg3[STRINGSIZE],
  79.          arg4[STRINGSIZE];
  80.   short  ret, flag;
  81.   int    server, t_out_val;
  82.  
  83.    
  84.   if( connected )
  85.     return( 0 );
  86.    
  87.   /* send command to print all functions in project
  88.    */
  89.   send_brs_cmd( server_id, CMD_CONNECT, 0, "", "" );
  90.   ret = get_brs_ret( CMD_CONNECT, &server, &flag, arg1, arg2, arg3, arg4);
  91.   
  92.    
  93.   if( ret != RET_CONNECT )
  94.    { /* Error */
  95.      /* printf("Connection failed: Code: %hd (%s)\n", ret, arg1); */
  96.      return( ret );
  97.     } 
  98.    
  99.   /* Change timeout if server recommends higher value
  100.    */
  101.   t_out_val = atoi( arg1 ); 
  102.   if( t_out_val > timeout_value )
  103.     timeout_value = t_out_val;
  104.    
  105.   connected = 1;
  106.   Server_ID = server_id;
  107.   return( (flag) ? -1 : 0 );
  108. }
  109.  
  110. /* disconnects actual server
  111.  
  112.    A client may only be connected to one server at a time
  113.  
  114. */
  115. void brs_disconnect_server(void)
  116. { 
  117.    
  118.   if( !connected )
  119.     return;
  120.    
  121.   /* send command to print all functions in project
  122.    */
  123.   send_brs_cmd( Server_ID, CMD_RELEASE, 0, "", "" );
  124.   
  125.   connected = 0;
  126.   return;
  127. }
  128.  
  129. /* sends a browser filename to the master and returns
  130.    the ID of the server processing this file
  131.  
  132.    return-value -1 or -2 : Error
  133.  */
  134. int brs_get_server_id(char *browser_file)
  135. { char arg1[STRINGSIZE],
  136.        arg2[STRINGSIZE],
  137.        arg3[STRINGSIZE],
  138.        arg4[STRINGSIZE];
  139.   short  ret, flag;
  140.   int server; 
  141.    
  142.   send_brs_cmd( MASTER_ID, CMD_SERVER_ID, 0, browser_file, "" );
  143.     
  144.   ret = get_brs_ret( CMD_SERVER_ID, &server, &flag, arg1, arg2, arg3, arg4);
  145.   switch( ret )
  146.    { case RET_SERVER_ID:  return( flag );
  147.       
  148.      case RET_ERROR: return( -1 );
  149.      default:        return( -2 );
  150.     }
  151.  }
  152.   
  153.  
  154.  
  155. /* This function kills server. Return-values like connect_server
  156.    return:  0    ...  O.K.
  157.             else ...  Return-value from server
  158.  */
  159. short brs_kill_server(void)
  160. { short erg;
  161.    
  162.   if( erg = brs_connect_server( Server_ID ) )
  163.    { return( erg );
  164.     }
  165.    
  166.   send_brs_cmd( Server_ID, CMD_TERMINATE, 0, "", "" );
  167.    
  168.   return( 0 );
  169.  }
  170.  
  171.  
  172.  
  173. /* This function returns all functions defined in the project.
  174.    strings should be have a size of at least STRINGSIZE Bytes
  175.  
  176.    funct        ...   holds the name of the function,
  177.    file         ...   the file, where the function is defined (or "" if unknown)
  178.    line         ...   the line in the file, where function is defined (if known)
  179.                       linenumber is the first line after the ')' of the arguments
  180.    module       ...   module to which this file belongs to (or "" if not known)
  181.    static_flag  ...   1 if function is static, 0 else
  182.  
  183.    The first time, this function is called, it issues the 
  184.    CMD_FUNCTIONS-command to the server.
  185.    This function should be called with a NULL-pointer in funct
  186.    to reset internal flags if you want to get all functions a
  187.    second time. However, it does a self-reset, it the RET_END-value 
  188.    is returned by the server.
  189.  
  190.    return:  0        ...  O.K., function-info is stored in arguments
  191.             RET_END  ...  No more functions found
  192.             else     ...  error returned by get_brs_ret
  193.                           error-message in funct/file
  194.  */
  195. short brs_get_all_funct( char *funct, char *file, long *line, char *module, short *static_flag)
  196. { int  server;
  197.   char arg1[STRINGSIZE],
  198.        arg2[STRINGSIZE],
  199.        arg3[STRINGSIZE],
  200.        arg4[STRINGSIZE];
  201.   short  ret, flag;
  202.   static short first = 1;
  203.  
  204.   /* NULL-Pointer in funct used for reset this function
  205.    */
  206.   if( !funct )
  207.    { first = 1;
  208.      return( 0 );
  209.     }
  210.        
  211.  
  212.   if( first )    
  213.     { /* First time this function is called: 
  214.          send command to print all functions in project
  215.        */
  216.       if( (ret = brs_connect_server( Server_ID )) > 0 )
  217.        { return( ret );
  218.         }
  219.       
  220.       send_brs_cmd( Server_ID, CMD_FUNCTIONS, 0, "", "" );
  221.       first = 0;
  222.      }
  223.    
  224.   ret = get_brs_ret( CMD_FUNCTIONS, &server, &flag, arg1, arg2, arg3, arg4);
  225.   switch( ret )
  226.    { case RET_FUNCT:
  227.           strcpy( funct, arg1 );
  228.           strcpy( file , arg2 );
  229.           if( arg2[0] )
  230.             *line = atoi( arg3 );
  231.           strcpy( module, arg4 );
  232.           if( static_flag )
  233.             *static_flag = (flag & 0x04) ? 1 : 0;
  234.           break;
  235.          
  236.      case RET_ERROR:
  237.           strcpy( funct, arg1 );
  238.           strcpy( file, arg2 );
  239.           first = 1;
  240.           return(ret);
  241.           break;
  242.       
  243.      case RET_END:
  244.           first = 1;
  245.           return( ret );
  246.           break;
  247.          
  248.      default:
  249.           first = 1;
  250.           return( ret );
  251.           break;
  252.     }
  253.  
  254.   return( 0 );         
  255.   
  256. }
  257.  
  258. /* This function returns all local variables defined in project.
  259.  
  260.    it works like "get_all_funct" !
  261.  */
  262. short brs_get_all_global_vars( char *funct, char *file, long *line, char *module, short *static_flag)
  263. { int  server;
  264.   char arg1[STRINGSIZE],
  265.        arg2[STRINGSIZE],
  266.        arg3[STRINGSIZE],
  267.        arg4[STRINGSIZE];
  268.   short  ret, flag;
  269.   static short first = 1;
  270.  
  271.   /* NULL-Pointer in funct used for reset this function
  272.    */
  273.   if( !funct )
  274.    { first = 1;
  275.      return( 0 );
  276.     }
  277.        
  278.  
  279.   if( first )    
  280.     { /* First time this function is called: 
  281.          send command to print all functions in project
  282.        */
  283.       if( (ret = brs_connect_server( Server_ID )) > 0 )
  284.        { return( ret );
  285.         }
  286.       
  287.       send_brs_cmd( Server_ID, CMD_VARIABLES, 0, "", "" );
  288.       first = 0;
  289.      }
  290.    
  291.   ret = get_brs_ret( CMD_VARIABLES, &server, &flag, arg1, arg2, arg3, arg4);
  292.   switch( ret )
  293.    { case RET_VAR:
  294.           strcpy( funct, arg1 );
  295.           strcpy( file , arg2 );
  296.           if( arg2[0] )
  297.             *line = atoi( arg3 );
  298.           strcpy( module, arg4 );
  299.           if( static_flag )
  300.             *static_flag = (flag & 0x04) ? 1 : 0;
  301.           break;
  302.          
  303.      case RET_ERROR:
  304.           strcpy( funct, arg1 );
  305.           strcpy( file, arg2 );
  306.           first = 1;
  307.           return(ret);
  308.           break;
  309.       
  310.      case RET_END:
  311.           first = 1;
  312.           return( ret );
  313.           break;
  314.          
  315.      default:
  316.           first = 1;
  317.           return( ret );
  318.           break;
  319.     }
  320.  
  321.   return( 0 );         
  322.   
  323. }
  324.  
  325.  
  326. /* This function returns all functions called by a specific
  327.    function
  328.    strings should be have a size of at least STRINGSIZE Bytes
  329.  
  330.    INPUT:
  331.    funct_in     ...   target-function, (just interesting for the first time)
  332.    file_in      ...   file, where target-function is defined (or called: in this
  333.                       case the one with the right scope (global/static) will be
  334.                       taken)
  335.                       may be "", if function is just defined once
  336.    sym_once     ...   if set to 1, every function is just returned once,
  337.                       otherwise every single call will be returned.
  338.  
  339.    OUTPUT 
  340.    (if ret-value is 0:)
  341.    funct        ...   holds the name of the function,
  342.    file         ...   the file, where the function is called
  343.    line         ...   linenumber, where function is called
  344.    module       ...   always ""
  345.    static_flag  ...   1 if function is static, 0 else
  346.  
  347.    (if ret-value if RET_ERROR)
  348.    funct        ...   Error message 1
  349.    file         ...   Error message 2 (might be "")
  350.  
  351.  
  352.    The first time, this function is called, it issues the 
  353.    CMD_FUNCTIONS-command to the server.
  354.    This function should be called with a NULL-pointer in funct
  355.    to reset internal flags if you want to get all functions a
  356.    second time. However, it does a self-reset, it the RET_END-value 
  357.    is returned by the server.
  358.  
  359.    return:  0        ...  O.K., function-info is stored in arguments
  360.             RET_END  ...  No more functions found
  361.             else     ...  error returned by get_brs_ret
  362.  */
  363. short brs_get_funct_calls( char *funct_in, char *file_in, short sym_once,
  364.                      char *funct, char *file, long *line, 
  365.                      char *module, short *static_flag)
  366. { int  server;
  367.   char arg1[STRINGSIZE],
  368.        arg2[STRINGSIZE],
  369.        arg3[STRINGSIZE],
  370.        arg4[STRINGSIZE];
  371.   short  ret, flag;
  372.   static short first = 1;
  373.  
  374.   /* NULL-Pointer in funct used for reset this function
  375.    */
  376.   if( !funct_in )
  377.    { first = 1;
  378.      return( 0 );
  379.     }
  380.        
  381.  
  382.   if( first )    
  383.     { /* First time this function is called: 
  384.          send command to print all functions in project
  385.        */
  386.       if( (ret = brs_connect_server( Server_ID )) > 0 )
  387.        { return( ret );
  388.         }
  389.       
  390.       send_brs_cmd( Server_ID, (sym_once) ? CMD_CALLS_ONCE : CMD_CALLS, 
  391.                     0, funct_in, file_in );
  392.       first = 0;
  393.      }
  394.    
  395.   ret = get_brs_ret( (sym_once) ? CMD_CALLS_ONCE : CMD_CALLS,
  396.                      &server, &flag, arg1, arg2, arg3, arg4);
  397.   switch( ret )
  398.    { case RET_FUNCT:
  399.           strcpy( funct, arg1 );
  400.           strcpy( file , arg2 );
  401.           if( arg2[0] )
  402.             *line = atoi( arg3 );
  403.           strcpy( module, arg4 );
  404.           if( static_flag )
  405.             *static_flag = (flag & 0x04) ? 1 : 0;
  406.           break;
  407.  
  408.      case RET_ERROR:
  409.           strcpy( funct, arg1 );
  410.           strcpy( file, arg2 );
  411.           first = 1;
  412.           return(ret);
  413.           break;
  414.  
  415.      case RET_END:
  416.           first = 1;
  417.           return( ret );
  418.           break;
  419.          
  420.      default:
  421.           first = 1;
  422.           return( ret );
  423.           break;
  424.     }
  425.  
  426.   return( 0 );         
  427.   
  428. }
  429.  
  430. /* This function gets all global variables that are used
  431.    by the given function.
  432.  
  433.    It works like "get_funct_calls", so see above
  434.    for dokumentation.
  435.  */
  436. short brs_get_var_uses( char *funct_in, char *file_in, short sym_once,
  437.                      char *var, char *file, long *line, 
  438.                      char *module, short *static_flag)
  439. { int  server;
  440.   char arg1[STRINGSIZE],
  441.        arg2[STRINGSIZE],
  442.        arg3[STRINGSIZE],
  443.        arg4[STRINGSIZE];
  444.   short  ret, flag;
  445.   static short first = 1;
  446.  
  447.   /* NULL-Pointer in funct used for reset this function
  448.    */
  449.   if( !funct_in )
  450.    { first = 1;
  451.      return( 0 );
  452.     }
  453.        
  454.  
  455.   if( first )    
  456.     { /* First time this function is called: 
  457.          send command to print all functions in project
  458.        */
  459.       if( (ret = brs_connect_server( Server_ID )) > 0 )
  460.        { return( ret );
  461.         }
  462.       
  463.       send_brs_cmd( Server_ID, (sym_once) ? CMD_USES_ONCE : CMD_USES, 
  464.                     0, funct_in, file_in );
  465.       first = 0;
  466.      }
  467.    
  468.   ret = get_brs_ret( (sym_once) ? CMD_USES_ONCE : CMD_USES, 
  469.                      &server, &flag, arg1, arg2, arg3, arg4);
  470.   switch( ret )
  471.    { case RET_VAR:
  472.           strcpy( var, arg1 );
  473.           strcpy( file , arg2 );
  474.           if( arg2[0] )
  475.             *line = atoi( arg3 );
  476.           strcpy( module, arg4 );
  477.           if( static_flag )
  478.             *static_flag = (flag & 0x04) ? 1 : 0;
  479.           break;
  480.  
  481.      case RET_ERROR:
  482.           strcpy( var, arg1 );
  483.           strcpy( file, arg2 );
  484.           first = 1;
  485.           return(ret);
  486.           break;
  487.  
  488.      case RET_END:
  489.           first = 1;
  490.           return( ret );
  491.           break;
  492.          
  493.      default:
  494.           first = 1;
  495.           return( ret );
  496.           break;
  497.     }
  498.  
  499.   return( 0 );         
  500.   
  501. }
  502.  
  503.  
  504. /* This function returns every function, that calls the specific
  505.    function
  506.    strings should be have a size of at least STRINGSIZE Bytes
  507.  
  508.    INPUT:
  509.    funct_in     ...   target-function, (just interesting for the first time)
  510.    file_in      ...   file, where target-function is defined (or called: in this
  511.                       case the one with the right scope (global/static) will be
  512.                       taken).
  513.                       may be "", if function is just defined once
  514.    sym_once     ...   if set to 1, every function is just returned once,
  515.                       otherwise every single call will be returned.
  516.  
  517.    OUTPUT 
  518.    (if ret-value is 0:)
  519.    funct        ...   holds the name of the function,
  520.    file         ...   the file, where the target-function is called
  521.    line         ...   linenumber, where target-function is called
  522.    module       ...   always ""
  523.    static_flag  ...   1 if function is static, 0 else
  524.  
  525.    (if ret-value if RET_ERROR)
  526.    funct        ...   Error message 1
  527.    file         ...   Error message 2 (might be "")
  528.  
  529.  
  530.    The first time, this function is called, it issues the 
  531.    CMD_...-command to the server.
  532.    This function should be called with a NULL-pointer in funct
  533.    to reset internal flags if you want to get all functions a
  534.    second time. However, it does a self-reset, it the RET_END-value 
  535.    is returned by the server.
  536.  
  537.    return:  0        ...  O.K., function-info is stored in arguments
  538.             RET_END  ...  No more functions found
  539.             else     ...  error returned by get_brs_ret
  540.  */
  541. short brs_get_funct_called_by( char *funct_in, char *file_in, short sym_once,
  542.                      char *funct, char *file, long *line, 
  543.                      char *module, short *static_flag)
  544. { int  server;
  545.   char arg1[STRINGSIZE],
  546.        arg2[STRINGSIZE],
  547.        arg3[STRINGSIZE],
  548.        arg4[STRINGSIZE];
  549.   short  ret, flag;
  550.   static short first = 1;
  551.  
  552.   /* NULL-Pointer in funct used for reset this function
  553.    */
  554.   if( !funct_in )
  555.    { first = 1;
  556.      return( 0 );
  557.     }
  558.        
  559.  
  560.   if( first )    
  561.     { /* First time this function is called: 
  562.          send command to print all functions in project
  563.        */
  564.       if( (ret = brs_connect_server( Server_ID )) > 0 )
  565.        { return( ret );
  566.         }
  567.       
  568.       send_brs_cmd( Server_ID, (sym_once) ? CMD_CALLED_BY_ONCE : CMD_CALLED_BY, 
  569.                     0, funct_in, file_in );
  570.       first = 0;
  571.      }
  572.    
  573.   ret = get_brs_ret( (sym_once) ? CMD_CALLED_BY_ONCE : CMD_CALLED_BY,
  574.                      &server, &flag, arg1, arg2, arg3, arg4);
  575.   switch( ret )
  576.    { case RET_FUNCT:
  577.           strcpy( funct, arg1 );
  578.           strcpy( file , arg2 );
  579.           if( arg2[0] )
  580.             *line = atoi( arg3 );
  581.           strcpy( module, arg4 );
  582.           if( static_flag )
  583.             *static_flag = (flag & 0x04) ? 1 : 0;
  584.           break;
  585.  
  586.      case RET_ERROR:
  587.           strcpy( funct, arg1 );
  588.           strcpy( file, arg2 );
  589.           first = 1;
  590.           return(ret);
  591.           break;
  592.  
  593.      case RET_END:
  594.           first = 1;
  595.           return( ret );
  596.           break;
  597.          
  598.      default:
  599.           first = 1;
  600.           return( ret );
  601.           break;
  602.     }
  603.  
  604.   return( 0 );         
  605.   
  606. }
  607.  
  608. /* This function returns every function, that uses the specific
  609.    variable
  610.    strings should be have a size of at least STRINGSIZE Bytes
  611.  
  612.    INPUT:
  613.    var_in       ...   target-variable, (just interesting for the first time)
  614.    file_in      ...   file, where target-variable is defined (or used: in this
  615.                       case the one with the right scope (global/static) will be
  616.                       taken).
  617.                       may be "", if variable is just defined once
  618.    sym_once     ...   if set to 1, every function is just returned once,
  619.                       otherwise every single usage will be returned.
  620.  
  621.    OUTPUT 
  622.    (if ret-value is 0:)
  623.    funct        ...   holds the name of the function,
  624.    file         ...   the file, where the target-variable is used
  625.    line         ...   linenumber, where target-variable is used
  626.    module       ...   always ""
  627.    static_flag  ...   1 if function is static, 0 else
  628.  
  629.    (if ret-value if RET_ERROR)
  630.    funct        ...   Error message 1
  631.    file         ...   Error message 2 (might be "")
  632.  
  633.  
  634.    The first time, this function is called, it issues the 
  635.    CMD_...-command to the server.
  636.    This function should be called with a NULL-pointer in funct
  637.    to reset internal flags if you want to get all functions a
  638.    second time. However, it does a self-reset, it the RET_END-value 
  639.    is returned by the server.
  640.  
  641.    return:  0        ...  O.K., function-info is stored in arguments
  642.             RET_END  ...  No more functions found
  643.             else     ...  error returned by get_brs_ret
  644.  */
  645. short brs_get_var_used_by( char *var_in, char *file_in, short sym_once,
  646.                      char *funct, char *file, long *line, 
  647.                      char *module, short *static_flag)
  648. { int  server;
  649.   char arg1[STRINGSIZE],
  650.        arg2[STRINGSIZE],
  651.        arg3[STRINGSIZE],
  652.        arg4[STRINGSIZE];
  653.   short  ret, flag;
  654.   static short first = 1;
  655.  
  656.   /* NULL-Pointer in funct used for reset this function
  657.    */
  658.   if( !var_in )
  659.    { first = 1;
  660.      return( 0 );
  661.     }
  662.        
  663.  
  664.   if( first )    
  665.     { /* First time this function is called: 
  666.          send command to print all functions in project
  667.        */
  668.       if( (ret = brs_connect_server( Server_ID )) > 0 )
  669.        { return( ret );
  670.         }
  671.       
  672.       send_brs_cmd( Server_ID, (sym_once) ? CMD_USED_BY_ONCE : CMD_USED_BY, 
  673.                     0, var_in, file_in );
  674.       first = 0;
  675.      }
  676.    
  677.   ret = get_brs_ret( (sym_once) ? CMD_USED_BY_ONCE : CMD_USED_BY,
  678.                      &server, &flag, arg1, arg2, arg3, arg4);
  679.   switch( ret )
  680.    { case RET_FUNCT:
  681.           strcpy( funct, arg1 );
  682.           strcpy( file , arg2 );
  683.           if( arg2[0] )
  684.             *line = atoi( arg3 );
  685.           strcpy( module, arg4 );
  686.           if( static_flag )
  687.             *static_flag = (flag & 0x04) ? 1 : 0;
  688.           break;
  689.  
  690.      case RET_ERROR:
  691.           strcpy( funct, arg1 );
  692.           strcpy( file, arg2 );
  693.           first = 1;
  694.           return(ret);
  695.           break;
  696.  
  697.      case RET_END:
  698.           first = 1;
  699.           return( ret );
  700.           break;
  701.          
  702.      default:
  703.           first = 1;
  704.           return( ret );
  705.           break;
  706.     }
  707.  
  708.   return( 0 );         
  709.   
  710. }
  711.  
  712.  
  713. /* This function returns all include-files of a given file.
  714.  
  715.    Every Include is named just once
  716.  
  717.    INPUT:
  718.    file_in      ...   filename of main-file ( xxx.c ), where the browser
  719.                       should look for includes
  720.  
  721.    OUTPUT 
  722.    (if ret-value is 0:)
  723.    file         ...   include-filename
  724.    inc_file     ...   file, where #include-directive was found
  725.                       (may be mainfile or an other headerfile in 
  726.                       case of nested include-levels)
  727.    sys_flag     ...   1 if include-file is a system-header
  728.  
  729.    (if ret-value if RET_ERROR)
  730.    file         ...   Error message 1
  731.    inc_file     ...   Error message 2
  732.  
  733.  
  734.    The first time, this function is called, it issues the 
  735.    CMD_FUNCTIONS-command to the server.
  736.    This function should be called with a NULL-pointer in funct
  737.    to reset internal flags if you want to get all functions a
  738.    second time. However, it does a self-reset, it the RET_END-value 
  739.    is returned by the server.
  740.  
  741.  
  742.    return:  0        ...  O.K., function-info is stored in arguments
  743.             RET_END  ...  No more functions found
  744.             else     ...  error returned by get_brs_ret
  745.  */
  746. short brs_get_includes(  char *file_in,
  747.                      char *file, char *inc_file, short *sys_flag)
  748. { int  server;
  749.   char arg1[STRINGSIZE],
  750.        arg2[STRINGSIZE],
  751.        arg3[STRINGSIZE],
  752.        arg4[STRINGSIZE];
  753.   short  ret, flag;
  754.   static short first = 1;
  755.  
  756.   /* NULL-Pointer in funct used for reset this function
  757.    */
  758.   if( !file_in )
  759.    { first = 1;
  760.      return( 0 );
  761.     }
  762.        
  763.  
  764.   if( first )    
  765.     { /* First time this function is called: 
  766.          send command to print all functions in project
  767.        */
  768.       if( (ret = brs_connect_server( Server_ID )) > 0 )
  769.        { return( ret );
  770.         }
  771.       
  772.       send_brs_cmd( Server_ID, CMD_INCLUDES, 0, file_in, "" );
  773.       first = 0;
  774.      }
  775.    
  776.   ret = get_brs_ret( CMD_INCLUDES, &server, &flag, arg1, arg2, arg3, arg4);
  777.   
  778.   switch( ret )
  779.    { case RET_FILE:
  780.           strcpy( file , arg1 );
  781.           if( arg2[0] )
  782.              strcpy( inc_file , arg2 );
  783.           if( sys_flag )
  784.             *sys_flag = (flag & 0x02) ? 1 : 0;
  785.           break;
  786.  
  787.      case RET_ERROR:
  788.           strcpy( file, arg1 );
  789.           strcpy( inc_file, arg2 );
  790.           first = 1;
  791.           return(ret);
  792.           break;
  793.  
  794.      case RET_END:
  795.           first = 1;
  796.           return( ret );
  797.           break;
  798.          
  799.      default:
  800.           first = 1;
  801.           return( ret );
  802.           break;
  803.     }
  804.  
  805.   return( 0 );         
  806.   
  807. }
  808.  
  809. /* This function returns the position, where a given function
  810.    is defined
  811.  
  812.    INPUT:
  813.    funct_in     ...   target-function
  814.    file_in      ...   file, where target-function is defined (and defined only !)
  815.                       may be "", if function is just defined once
  816.  
  817.    OUTPUT 
  818.    (if ret-value is 0:)
  819.    file         ...   the file, where the function is defined
  820.    line         ...   linenumber, where function is defined
  821.    end_line     ...   linenumber, where function ends
  822.    module       ...   module where file belongs to or ""
  823.  
  824.    (if ret-value if RET_ERROR)
  825.    file         ...   Error message 1
  826.    module       ...   Error message 2 (might be "")
  827.  
  828.  
  829.    return:  0        ...  O.K., function-info is stored in arguments
  830.             else     ...  error returned by get_brs_ret
  831.  */
  832. short brs_get_funct_pos( char *funct_in, char *file_in,
  833.                      char *file, long *line, long *end_line, char *module)
  834. { int  server;
  835.   char arg1[STRINGSIZE],
  836.        arg2[STRINGSIZE],
  837.        arg3[STRINGSIZE],
  838.        arg4[STRINGSIZE];
  839.   short  ret, flag;
  840.  
  841.   /* send command to retrieve position of function
  842.    */
  843.   if( (ret = brs_connect_server( Server_ID )) > 0 )
  844.    { return( ret );
  845.     }
  846.       
  847.   send_brs_cmd( Server_ID, CMD_FUNCT_POS, 0, funct_in, file_in );
  848.    
  849.   ret = get_brs_ret( CMD_FUNCT_POS, &server, &flag, arg1, arg2, arg3, arg4);
  850.   switch( ret )
  851.    { case RET_FPOS:
  852.           strcpy( file , arg1 );
  853.           if( arg2[0] )
  854.             *line = atoi( arg2 );
  855.           if( arg3[0] )
  856.             *end_line = atoi( arg3 );
  857.           strcpy( module, arg4 );
  858.           break;
  859.  
  860.      case RET_ERROR:
  861.           strcpy( file, arg1 );
  862.           strcpy( module, arg2 );
  863.           return(ret);
  864.           break;
  865.  
  866.      case RET_END:
  867.           return( ret );
  868.           break;
  869.          
  870.      default:
  871.           return( ret );
  872.           break;
  873.     }
  874.  
  875.   return( 0 );         
  876.   
  877. }
  878.  
  879. /* This function returns the position where given global variable
  880.    is defined
  881.  
  882.    INPUT:
  883.    var_in       ...   target-variable
  884.    file_in      ...   file, where target-variable is defined (defined only !)
  885.                       may be "", if variable is just defined once
  886.  
  887.    OUTPUT 
  888.    (if ret-value is 0:)
  889.    file         ...   the file, where the variable is defined
  890.    line         ...   linenumber, where variable is defined
  891.    module       ...   module where file belongs to or ""
  892.  
  893.    (if ret-value if RET_ERROR)
  894.    file         ...   Error message 1
  895.    module       ...   Error message 2 (might be "")
  896.  
  897.  
  898.    return:  0        ...  O.K., variable-info is stored in arguments
  899.             else     ...  error returned by get_brs_ret
  900.  */
  901. short brs_get_var_pos( char *var_in, char *file_in,
  902.                      char *file, long *line, char *module)
  903. { int  server;
  904.   char arg1[STRINGSIZE],
  905.        arg2[STRINGSIZE],
  906.        arg3[STRINGSIZE],
  907.        arg4[STRINGSIZE];
  908.   short  ret, flag;
  909.  
  910.   /* send command to retrieve position of function
  911.    */
  912.   if( (ret = brs_connect_server( Server_ID )) > 0 )
  913.    { return( ret );
  914.     }
  915.       
  916.   send_brs_cmd( Server_ID, CMD_VAR_POS, 0, var_in, file_in );
  917.    
  918.   ret = get_brs_ret( CMD_VAR_POS, &server, &flag, arg1, arg2, arg3, arg4);
  919.   switch( ret )
  920.    { case RET_POS:
  921.           strcpy( file , arg1 );
  922.           if( arg2[0] )
  923.             *line = atoi( arg2 );
  924.           strcpy( module, arg3 );
  925.           break;
  926.  
  927.      case RET_ERROR:
  928.           strcpy( file, arg1 );
  929.           strcpy( module, arg2 );
  930.           return(ret);
  931.           break;
  932.  
  933.      case RET_END:
  934.           return( ret );
  935.           break;
  936.          
  937.      default:
  938.           return( ret );
  939.           break;
  940.     }
  941.  
  942.   return( 0 );         
  943.   
  944. }
  945.  
  946.  
  947.  
  948. /* This function tells the browser-engine (server1) to re-init with
  949.    a new browser-file
  950.  
  951.    return value:
  952.    0     ... O.K.
  953.    else  ... Error, if RET_ERROR, in err_msg1 and err_msg2 errormessages 
  954.              from server
  955.  */
  956. short brs_reinit_browser( char *file, char *err_msg1, char *err_msg2)
  957. { int  server;
  958.   char arg1[STRINGSIZE],
  959.        arg2[STRINGSIZE],
  960.        arg3[STRINGSIZE],
  961.        arg4[STRINGSIZE];
  962.   short  ret,
  963.          flag;
  964.   short  erg;
  965.     
  966.   if( (erg = brs_connect_server( Server_ID )) > 0 )
  967.    { return( erg );
  968.     }
  969.    
  970.   /* send command to print all functions in project
  971.    */
  972.   send_brs_cmd( Server_ID, CMD_INIT, 0, file, "" );
  973.   ret = get_brs_ret( CMD_INIT, &server, &flag, arg1, arg2, arg3, arg4);
  974.   switch( ret )
  975.    { case RET_OK:
  976.           ret = 0;
  977.           break;
  978.       
  979.      case RET_ERROR:
  980.           strcpy( err_msg1, arg1);
  981.           strcpy( err_msg2, arg2);
  982.           break;
  983.          
  984.      default:
  985.           break;
  986.     }
  987.    
  988.   return( ret );
  989. }
  990.  
  991.  
  992. /* This function returns all types (structs, unions, typedefs, enums)
  993.    defined in the project.
  994.    strings should be have a size of at least STRINGSIZE Bytes
  995.  
  996.    INPUT: 
  997.    type_code    ...   0 ... structs
  998.                       1 ... unions
  999.                       2 ... enums
  1000.                       3 ... typedefs
  1001.  
  1002.    OUTPUT:
  1003.    type_name    ...   holds the name of the type,
  1004.    file         ...   the file, where the type is defined (or "" if unknown)
  1005.    line         ...   the line in the file, where type is defined (if known)
  1006.                       linenumber is the first line after the ')' of the arguments
  1007.  
  1008.  
  1009.    return:  0        ...  O.K., function-info is stored in arguments
  1010.             RET_END  ...  No more functions found
  1011.             else     ...  error returned by get_brs_ret
  1012.                           error-message in funct/file
  1013.  */
  1014. short brs_get_all_types( short type_code, char *type_name, char *file, long *line)
  1015. { int  server;
  1016.   char arg1[STRINGSIZE],
  1017.        arg2[STRINGSIZE],
  1018.        arg3[STRINGSIZE],
  1019.        arg4[STRINGSIZE];
  1020.   short  ret, flag, cmd;
  1021.   static short first = 1;
  1022.  
  1023.   /* NULL-Pointer in funct used for reset this function
  1024.    */
  1025.   if( !type_name )
  1026.    { first = 1;
  1027.      return( 0 );
  1028.     }
  1029.  
  1030.   switch( type_code )
  1031.     { case 0: cmd = CMD_STRUCTS;  break;
  1032.       case 1: cmd = CMD_UNIONS;   break;
  1033.       case 2: cmd = CMD_ENUMS;    break;
  1034.       case 3: cmd = CMD_TYPEDEFS; break;      
  1035.       default: cmd = CMD_STRUCTS; break;
  1036.      }
  1037.  
  1038.   if( first )    
  1039.     { /* First time this function is called: 
  1040.          send command to print all functions in project
  1041.        */
  1042.       if( (ret = brs_connect_server( Server_ID )) > 0 )
  1043.        { return( ret );
  1044.         }
  1045.       
  1046.       send_brs_cmd( Server_ID, cmd, 0, "", "" );
  1047.       first = 0;
  1048.      }
  1049.    
  1050.   ret = get_brs_ret( cmd, &server, &flag, arg1, arg2, arg3, arg4);
  1051.   switch( ret )
  1052.    { case RET_STRUCT:
  1053.      case RET_UNION:
  1054.      case RET_ENUM:
  1055.      case RET_TYPEDEF:
  1056.           strcpy( type_name, arg1 );
  1057.           strcpy( file , arg2 );
  1058.           if( arg2[0] )
  1059.             *line = atoi( arg3 );
  1060.           break;
  1061.          
  1062.      case RET_ERROR:
  1063.           strcpy( type_name, arg1 );
  1064.           strcpy( file, arg2 );
  1065.           first = 1;
  1066.           return(ret);
  1067.           break;
  1068.       
  1069.      case RET_END:
  1070.           first = 1;
  1071.           return( ret );
  1072.           break;
  1073.          
  1074.      default:
  1075.           first = 1;
  1076.           return( ret );
  1077.           break;
  1078.     }
  1079.  
  1080.   return( 0 );         
  1081.   
  1082. }
  1083.  
  1084. /* This function returns the usage of components.
  1085.  
  1086.    INPUT: 
  1087.    type      0   Get all components in a file (or global if arg2 == "")
  1088.              1   Get all component references in a function 
  1089.              2   Get all components in same line like variable
  1090.  
  1091.    component_name  ...   name of the target component of a struct/union
  1092.  
  1093.    arg2          depends on type:  0 ... filename or ""
  1094.                                    1 ... function name
  1095.                                    2 ... variable name
  1096.  
  1097.    OUTPUT:
  1098.    file         ...   the file, where component used
  1099.    line         ...   the line in the file, where component used
  1100.    function     ...   ident of function where component used
  1101.  
  1102.    return:  0        ...  O.K.
  1103.             RET_END  ...  No more items found
  1104.             else     ...  error returned by get_brs_ret
  1105.                           error-message in file/function
  1106.  */
  1107. short brs_get_component_use( int type, char *comp_name, char *f_in, 
  1108.                          char *file, long *line, char *function)
  1109. { int  server;
  1110.   char arg1[STRINGSIZE],
  1111.        arg2[STRINGSIZE],
  1112.        arg3[STRINGSIZE],
  1113.        arg4[STRINGSIZE];
  1114.   short  ret, flag, cmd;
  1115.   static short first = 1;
  1116.  
  1117.   /* NULL-Pointer in funct used for reset this function
  1118.    */
  1119.   if( !comp_name )
  1120.    { first = 1;
  1121.      return( 0 );
  1122.     }
  1123.  
  1124.  
  1125.   if( first )    
  1126.     { /* First time this function is called: 
  1127.          send command to print all functions in project
  1128.        */
  1129.       if( (ret = brs_connect_server( Server_ID )) > 0 )
  1130.        { return( ret );
  1131.         }
  1132.       
  1133.       switch( type )
  1134.         { case 0: 
  1135.              send_brs_cmd( Server_ID, CMD_REFERENCE  , 0, comp_name, f_in );
  1136.              cmd = CMD_REFERENCE;
  1137.              break;
  1138.           case 1: 
  1139.              send_brs_cmd( Server_ID, CMD_REFERENCE_F, 0, comp_name, f_in );
  1140.              cmd = CMD_REFERENCE_F;
  1141.              break;
  1142.           case 2: 
  1143.              send_brs_cmd( Server_ID, CMD_REFERENCE_V, 0, comp_name, f_in );
  1144.              cmd = CMD_REFERENCE_V;
  1145.              break;
  1146.           default: 
  1147.              break;
  1148.          }
  1149.       first = 0;
  1150.      }
  1151.    
  1152.   ret = get_brs_ret( cmd, &server, &flag, arg1, arg2, arg3, arg4);
  1153.   switch( ret )
  1154.    { case RET_REFERENCE:
  1155.           strcpy( file, arg1 );
  1156.           *line = atoi( arg2 );
  1157.           strcpy( function , arg3 );
  1158.           break;
  1159.          
  1160.      case RET_ERROR:
  1161.           strcpy( file, arg1 );
  1162.           strcpy( function, arg3 );
  1163.           first = 1;
  1164.           return(ret);
  1165.           break;
  1166.       
  1167.      case RET_END:
  1168.           first = 1;
  1169.           return( ret );
  1170.           break;
  1171.          
  1172.      default:
  1173.           first = 1;
  1174.           return( ret );
  1175.           break;
  1176.     }
  1177.  
  1178.   return( 0 );         
  1179.   
  1180. }
  1181.  
  1182. /* This function returns all files in a project (just main-files, not the
  1183.    includes)
  1184.    strings should be have a size of at least STRINGSIZE Bytes
  1185.  
  1186.    The first time, this function is called, it issues the 
  1187.    CMD_FILES-command to the server.
  1188.  
  1189.    Return-values:
  1190.  
  1191.      file    ...  filename
  1192.      module  ...  module, where file belongs to
  1193.  
  1194.    return:  0        ...  O.K., function-info is stored in arguments
  1195.             RET_END  ...  No more functions found
  1196.             else     ...  error returned by get_brs_ret
  1197.                           error-message in funct/file
  1198.  */
  1199. short brs_get_all_files( char *file, char *module)
  1200. { int  server;
  1201.   char arg1[STRINGSIZE],
  1202.        arg2[STRINGSIZE],
  1203.        arg3[STRINGSIZE],
  1204.        arg4[STRINGSIZE];
  1205.   short  ret, flag;
  1206.   static short first = 1;
  1207.  
  1208.   /* NULL-Pointer in funct used for reset this function
  1209.    */
  1210.   if( !file )
  1211.    { first = 1;
  1212.      return( 0 );
  1213.     }
  1214.        
  1215.  
  1216.   if( first )    
  1217.     { /* First time this function is called: 
  1218.          send command to print all functions in project
  1219.        */
  1220.       if( (ret = brs_connect_server( Server_ID )) > 0 )
  1221.        { return( ret );
  1222.         }
  1223.       
  1224.       send_brs_cmd( Server_ID, CMD_FILES, 0, "", "" );
  1225.       first = 0;
  1226.      }
  1227.    
  1228.   ret = get_brs_ret( CMD_FILES, &server, &flag, arg1, arg2, arg3, arg4);
  1229.   switch( ret )
  1230.    { case RET_FILE:
  1231.           strcpy( file , arg1 );
  1232.           strcpy( module, arg2 );
  1233.           break;
  1234.          
  1235.      case RET_ERROR:
  1236.           strcpy( file, arg1 );
  1237.           strcpy( module, arg2 );
  1238.           first = 1;
  1239.           return(ret);
  1240.           break;
  1241.       
  1242.      case RET_END:
  1243.           first = 1;
  1244.           return( ret );
  1245.           break;
  1246.          
  1247.      default:
  1248.           first = 1;
  1249.           return( ret );
  1250.           break;
  1251.     }
  1252.  
  1253.   return( 0 );         
  1254.   
  1255. }
  1256.  
  1257.  
  1258. /* This function returns the working directory of a given 
  1259.    source-file
  1260.  
  1261.    INPUT:
  1262.    file_in      ...   source-file
  1263.  
  1264.    OUTPUT 
  1265.    (if ret-value is 0:)
  1266.    dir          ...   working-directory
  1267.  
  1268.    (if ret-value if RET_ERROR)
  1269.    dir          ...   Error message 1
  1270.  
  1271.  
  1272.    return:  0        ...  O.K., working-directory stored
  1273.             else     ...  error returned by get_brs_ret
  1274.  */
  1275. short brs_get_file_dir( char *file_in, char *dir)
  1276. { int  server;
  1277.   char arg1[STRINGSIZE],
  1278.        arg2[STRINGSIZE],
  1279.        arg3[STRINGSIZE],
  1280.        arg4[STRINGSIZE];
  1281.   short  ret, flag;
  1282.  
  1283.   /* send command to retrieve position of function
  1284.    */
  1285.   if( (ret = brs_connect_server( Server_ID )) > 0 )
  1286.    { return( ret );
  1287.     }
  1288.       
  1289.   send_brs_cmd( Server_ID, CMD_WORK_DIR, 0, file_in, "" );
  1290.    
  1291.   ret = get_brs_ret( CMD_WORK_DIR, &server, &flag, arg1, arg2, arg3, arg4);
  1292.   switch( ret )
  1293.    { case RET_DIR:
  1294.           strcpy( dir , arg1 );
  1295.           break;
  1296.  
  1297.      case RET_ERROR:
  1298.           strcpy( dir, arg1 );
  1299.           return(ret);
  1300.           break;
  1301.  
  1302.      case RET_END:
  1303.           return( ret );
  1304.           break;
  1305.          
  1306.      default:
  1307.           return( ret );
  1308.           break;
  1309.     }
  1310.  
  1311.   return( 0 );         
  1312.   
  1313. }
  1314.  
  1315. /* This function returns all macros defined in the project.
  1316.    strings should be have a size of at least STRINGSIZE Bytes
  1317.  
  1318.    macro        ...   holds the name of the macro
  1319.    file         ...   the file, where the macro is defined (or "" if unknown)
  1320.    line         ...   the line in the file, where macro is defined (if known)
  1321.  
  1322.  
  1323.    return:  0        ...  O.K., function-info is stored in arguments
  1324.             RET_END  ...  No more functions found
  1325.             else     ...  error returned by get_brs_ret
  1326.                           error-message in macro/file
  1327.  */
  1328. short brs_get_all_macro( char *macro, char *file, long *line )
  1329. { int  server;
  1330.   char arg1[STRINGSIZE],
  1331.        arg2[STRINGSIZE],
  1332.        arg3[STRINGSIZE],
  1333.        arg4[STRINGSIZE];
  1334.   short  ret, flag;
  1335.   static short first = 1;
  1336.  
  1337.   /* NULL-Pointer in funct used for reset this function
  1338.    */
  1339.   if( !macro )
  1340.    { first = 1;
  1341.      return( 0 );
  1342.     }
  1343.        
  1344.  
  1345.   if( first )    
  1346.     { /* First time this function is called: 
  1347.          send command to print all functions in project
  1348.        */
  1349.       if( (ret = brs_connect_server( Server_ID )) > 0 )
  1350.        { return( ret );
  1351.         }
  1352.       
  1353.       send_brs_cmd( Server_ID, CMD_MACROS, 0, "", "" );
  1354.       first = 0;
  1355.      }
  1356.    
  1357.   do
  1358.    { ret = get_brs_ret( CMD_MACROS, &server, &flag, arg1, arg2, arg3, arg4);
  1359.             
  1360.     } while( !ret );
  1361.   switch( ret )
  1362.    { case RET_MACRO:
  1363.           strcpy( macro, arg1 );
  1364.           strcpy( file , arg2 );
  1365.           if( arg2[0] )
  1366.             *line = atoi( arg3 );
  1367.           break;
  1368.          
  1369.      case RET_ERROR:
  1370.           strcpy( macro, arg1 );
  1371.           strcpy( file, arg2 );
  1372.           first = 1;
  1373.           return(ret);
  1374.           break;
  1375.       
  1376.      case RET_END:
  1377.           first = 1;
  1378.           return( ret );
  1379.           break;
  1380.          
  1381.      default:
  1382.           first = 1;
  1383.           return( ret );
  1384.           break;
  1385.     }
  1386.  
  1387.   return( 0 );         
  1388.   
  1389. }
  1390.  
  1391.  
  1392. /* This function returns definition positions of the unknown item. To handle
  1393.    scoping of local items, you can specify the position, where you found that 
  1394.    item.
  1395.    Note: scoping not implemented yet. The line_in is currently ignored
  1396.  
  1397.    item         ...   holds the name of the unknown item
  1398.    file_in      ...   file, where item was found (may be "")
  1399.    line_in      ...   line, where item was found (or -1)
  1400.                       only valid if a filename is specified
  1401.  
  1402.    file         ...   file, where item was defined
  1403.    line         ...   the line in the file, where item is defined
  1404.    module       ...   module, the file belongs to (or "")
  1405.  
  1406.    return:  
  1407.  
  1408.    RET_VAR           Return variable-position
  1409.  
  1410.    RET_FUNCT         Return function-position
  1411.  
  1412.    RET_TYPEDEF       Returns typedef
  1413.  
  1414.    RET_STRUCT        Returns struct-identifier
  1415.  
  1416.    RET_ENUM          Returns enum-type-identifier
  1417.  
  1418.    RET_UNION         Returns union-identifier
  1419.  
  1420.    RET_MACRO         Returns macro definition
  1421.                      Arguments: <macro>,<file>,<line>
  1422.  
  1423.        0        ...  O.K., function-info is stored in arguments
  1424.             RET_END  ...  No more functions found
  1425.             else     ...  error returned by get_brs_ret
  1426.                           error-message in macro/file
  1427.  */
  1428. short brs_what_is( char *item, char *file_in, long line_in,
  1429.                    char *file, long *line, char *module )
  1430. { int  server;
  1431.   char arg1[STRINGSIZE],
  1432.        arg2[STRINGSIZE],
  1433.        arg3[STRINGSIZE],
  1434.        arg4[STRINGSIZE];
  1435.   short  ret, flag;
  1436.   static short first = 1;
  1437.  
  1438.   /* NULL-Pointer in funct used for reset this function
  1439.    */
  1440.   if( !item )
  1441.    { first = 1;
  1442.      return( 0 );
  1443.     }
  1444.        
  1445.  
  1446.   if( first )    
  1447.     { /* First time this function is called: 
  1448.          send command to print all functions in project
  1449.        */
  1450.       if( (ret = brs_connect_server( Server_ID )) > 0 )
  1451.        { return( ret );
  1452.         }
  1453.       
  1454.       send_brs_cmd( Server_ID, CMD_WHAT_IS, 0, item, file_in );
  1455.       first = 0;
  1456.      }
  1457.    
  1458.   do
  1459.    { ret = get_brs_ret( CMD_WHAT_IS, &server, &flag, arg1, arg2, arg3, arg4);
  1460.             
  1461.     } while( !ret );
  1462.   switch( ret )
  1463.    { case RET_MACRO:
  1464.           strcpy( file , arg2 );
  1465.           if( arg2[0] )
  1466.             *line = atoi( arg3 );
  1467.           break;
  1468.          
  1469.      case RET_FUNCT:
  1470.           strcpy( file , arg2 );
  1471.           if( arg2[0] )
  1472.             *line = atoi( arg3 );
  1473.           strcpy( module, arg4 );
  1474.           break;
  1475.       
  1476.      case RET_VAR:
  1477.           strcpy( file , arg2 );
  1478.           if( arg2[0] )
  1479.             *line = atoi( arg3 );
  1480.           strcpy( module, arg4 );
  1481.           break;
  1482.       
  1483.      case RET_STRUCT:
  1484.      case RET_UNION:
  1485.      case RET_ENUM:
  1486.      case RET_TYPEDEF:
  1487.           strcpy( file , arg2 );
  1488.           if( arg2[0] )
  1489.             *line = atoi( arg3 );
  1490.           break;
  1491.       
  1492.      case RET_ERROR:
  1493.           strcpy( file, arg1 );
  1494.           strcpy( module, arg2 );
  1495.           first = 1;
  1496.           return(ret);
  1497.           break;
  1498.       
  1499.      case RET_END:
  1500.           first = 1;
  1501.           return( ret );
  1502.           break;
  1503.          
  1504.      default:
  1505.           first = 1;
  1506.           return( ret );
  1507.           break;
  1508.     }
  1509.  
  1510.   return( ret );         
  1511.   
  1512. }
  1513.  
  1514.  
  1515. /* This function returns the position where the given macro
  1516.    is defined
  1517.  
  1518.    INPUT:
  1519.    macro        ...   target-macro
  1520.    file_in      ...   file, where target-macro is defined
  1521.                       may be "", if macro is just defined once
  1522.  
  1523.    OUTPUT 
  1524.    (if ret-value is 0:)
  1525.    file         ...   the file, where the macro is defined
  1526.    line         ...   linenumber, where macro is defined
  1527.    module       ...   module where file belongs to or ""
  1528.  
  1529.    (if ret-value if RET_ERROR)
  1530.    file         ...   Error message 1
  1531.    module       ...   Error message 2 (might be "")
  1532.  
  1533.    return:  0        ...  O.K., variable-info is stored in arguments
  1534.             else     ...  error returned by get_brs_ret
  1535.  */
  1536. short brs_get_macro_pos( char *macro, char *file_in,
  1537.                      char *file, long *line, char *module)
  1538. { int  server;
  1539.   char arg1[STRINGSIZE],
  1540.        arg2[STRINGSIZE],
  1541.        arg3[STRINGSIZE],
  1542.        arg4[STRINGSIZE];
  1543.   short  ret, flag;
  1544.  
  1545.   /* send command to retrieve position of function
  1546.    */
  1547.   if( (ret = brs_connect_server( Server_ID )) > 0 )
  1548.    { return( ret );
  1549.     }
  1550.       
  1551.   send_brs_cmd( Server_ID, CMD_MACRO_POS, 0, macro, file_in );
  1552.    
  1553.   ret = get_brs_ret( CMD_MACRO_POS, &server, &flag, arg1, arg2, arg3, arg4);
  1554.   switch( ret )
  1555.    { case RET_POS:
  1556.           strcpy( file , arg1 );
  1557.           if( arg2[0] )
  1558.             *line = atoi( arg2 );
  1559.           strcpy( module, arg3 );
  1560.           break;
  1561.  
  1562.      case RET_ERROR:
  1563.           strcpy( file, arg1 );
  1564.           strcpy( module, arg2 );
  1565.           return(ret);
  1566.           break;
  1567.  
  1568.      case RET_END:
  1569.           return( ret );
  1570.           break;
  1571.          
  1572.      default:
  1573.           return( ret );
  1574.           break;
  1575.     }
  1576.  
  1577.   return( 0 );         
  1578.   
  1579. }
  1580.  
  1581. /* This function returns the definition position of a given item
  1582.    which was found at given position (within an expression). It
  1583.    differs from the other brs_get_..._pos functions, because it
  1584.    provides a kind of scoping. It returns the position of the
  1585.    item which is valid in the context of the given position.
  1586.  
  1587.    It is also independend from the type of the item so it can be
  1588.    used for an identifier of an unknown type.
  1589.  
  1590.    INPUT:
  1591.    item         ...   item
  1592.    file_in      ...   file, where item was found
  1593.    line_in      ...   line, where item was found
  1594.  
  1595.    OUTPUT 
  1596.    (if ret-value is 0:)
  1597.    file         ...   the file, where the item is defined
  1598.    line         ...   linenumber, where item is defined
  1599.  
  1600.    (if ret-value if RET_ERROR)
  1601.    file         ...   Error message 1
  1602.  
  1603.    return:  0        ...  O.K., variable-info is stored in arguments
  1604.             else     ...  error returned by get_brs_ret
  1605.  */
  1606. short brs_get_item_pos( char *item, char *file_in, long line_in,
  1607.                         char *file, long *line)
  1608. { int  server;
  1609.   char arg1[STRINGSIZE],
  1610.        arg2[STRINGSIZE],
  1611.        arg3[STRINGSIZE],
  1612.        arg4[STRINGSIZE];
  1613.   short  ret, flag;
  1614.  
  1615.   /* send command to retrieve position of function
  1616.    */
  1617.   if( (ret = brs_connect_server( Server_ID )) > 0 )
  1618.    { return( ret );
  1619.     }
  1620.  
  1621.   if( strlen(item) + strlen(file_in) + 1 < STRINGSIZE )      
  1622.     { strcpy(arg1, file_in);
  1623.       strcat(arg1, "*"); /* seperator: '.' */
  1624.       strcat(arg1, item );
  1625.      }
  1626.   else
  1627.     { strcpy(file, "Arguments too long !");
  1628.       return(RET_ERROR);
  1629.      }
  1630.    
  1631.   sprintf(arg2, "%ld", line_in );
  1632.   send_brs_cmd( Server_ID, CMD_DEF_POS, 0, arg1, arg2 );
  1633.    
  1634.   ret = get_brs_ret( CMD_DEF_POS, &server, &flag, arg1, arg2, arg3, arg4);
  1635.   switch( ret )
  1636.    { case RET_POS:
  1637.           strcpy( file , arg1 );
  1638.           if( arg2[0] )
  1639.             *line = atoi( arg2 );
  1640.           break;
  1641.  
  1642.      case RET_ERROR:
  1643.           strcpy( file, arg1 );
  1644.           return(ret);
  1645.           break;
  1646.  
  1647.      case RET_END:
  1648.           strcpy( file, "" );
  1649.           return( ret );
  1650.           break;
  1651.          
  1652.      default:
  1653.           strcpy( file, "" );
  1654.           return( ret );
  1655.           break;
  1656.     }
  1657.  
  1658.   return( 0 );         
  1659.   
  1660. }
  1661.