home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / smapp100.zip / sm10.zip / smgfcal.c < prev    next >
C/C++ Source or Header  |  2000-05-14  |  9KB  |  252 lines
  1. /* ------------------------------------------------------------------------
  2.  *
  3.  *        File: smgfcal.c
  4.  *     Project: Source Mapper.
  5.  *     Created: October 6, 1992.
  6.  * Description: Source code to include list of function calls.
  7.  *
  8.  * Copyright (C) 2000 Leif-Erik Larsen.
  9.  * This file is part of the Source Mapper source package.
  10.  * Source Mapper is free software; you can redistribute it and/or modify
  11.  * it under the terms of the GNU General Public License as published
  12.  * by the Free Software Foundation, in version 2 as it comes in the
  13.  * "COPYING" file of the XWorkplace main distribution.
  14.  * This program is distributed in the hope that it will be useful,
  15.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.  * GNU General Public License for more details.
  18.  *
  19.  * ------------------------------------------------------------------------ */
  20.  
  21.  
  22.  
  23.  
  24. #include "smg.h"
  25.  
  26.  
  27.  
  28.  
  29. static char loclinchr;
  30. static char globlinchr;
  31.  
  32.  
  33.  
  34.  
  35. int FCalIncludeToMap ( FILE *mapf )
  36. /*
  37.     Function: Include list of function calls to map file.
  38.         Date: October 6, 1992. By LEL.
  39.    Interface: mapf = Map file to include list of function calls.
  40.      Returns: E/O.
  41. */
  42. {
  43.    int       ret;
  44.    FILE     *objf;                     /* Main object file                   */
  45.    fposTYPE  fpos;                     /* Indexes to blocks of data in file  */
  46.    prjfeTYPE fdata;                    /* Data about source in project       */
  47.  
  48.    if (!prjstat.prjon)                 /* If no active project               */
  49.       return (ERROR);
  50.  
  51.    /* Including list of function calls */
  52.    Display (D_HEIGH, "%s", _StrMSGINCLFUNCALLST);
  53.  
  54.    /* =======================================================================*/
  55.    /* List of function calls:                                                */
  56.  
  57.    WrtStdLinComStart (mapf, stdwidth, linechr2);
  58.    FPrintF (mapf, "%s:\n\n", o_funcall.sel ? _StrMSGSELFUNCALLSTSTR : _StrMSGFUNCALLSTSTR);
  59.  
  60.    loclinchr = LOCLINCHR;              /* Shortening for local line ==> 'L'  */
  61.    globlinchr = GLOBLINCHR;            /* Shortening for global line ==> 'G' */
  62.    if (prjstat.filc == 1)              /* If only one source in project      */
  63.       globlinchr = LOCLINCHR;          /* then all lines are local lines     */
  64.  
  65.    if (prjstat.filc == 1)              /* If only one source in project      */
  66.    {
  67.       if (!GetFDataFromPrj (1, &fdata))/* Get name of normal objectfile */
  68.          RETURN_ERR;
  69.  
  70.       objf = FOpen (fdata.objn, "r+b");/* Use normal objfile if only 1 source */
  71.    }
  72.    else
  73.    {
  74.       objf = FOpen (tmpn.manobj, "r+b"); /* Open main objectfile */
  75.    }
  76.  
  77.    if (objf == NULL)                   /* Any error when open file?          */
  78.       return (ERROR);
  79.  
  80.    if (!GetFPosTYPE (objf, &fpos))     /* Get indexes to blocks of data      */
  81.    {
  82.       FClose (objf);                   /* Close objectfile if error          */
  83.       RETURN_ERR;
  84.    }
  85.  
  86.    if (fpos.funcal == fpos.idlst)      /* Any function calls in project?     */
  87.    {
  88.       FClose (objf);                   /* No, so close objectfile            */
  89.       return (OK);                     /* And return without include list    */
  90.    }
  91.  
  92.    ret = FCalIncludeToMap1 (mapf, objf, &fpos);
  93.  
  94.    FClose (objf);                      /* Close main objectfile              */
  95.  
  96.    return (ret);                       /* OK generate of function call list  */
  97. } /* FCalIncludeToMap (); */
  98.  
  99.  
  100.  
  101.  
  102. int FCalNameInSelList ( const char *funcn )
  103. /*
  104.     Function: Test if specified function name is in list of selective
  105.               function calls.
  106.         Date: December, 17. 1992. By LEL.
  107.    Interface: funcn = Name to test if in selective list.
  108.      Returns: YES if name is in list, else return NO.
  109.      Comment: Allways return YES if user has optioned not to make a
  110.               selective list.
  111. */
  112. {
  113.    int  fcnr = 1;                      /* Count function call number         */
  114.    char fcname [MAXFUNCN + 1];         /* Buffer to store name of function   */
  115.  
  116.    /* Look trough whole selective list to see if name is in selective list */
  117.    while (StrPart (fcnr++, MAXFUNCN, fcname, o_funcall.list, "(), \t\n"))
  118.    {
  119.       if (strcmp (funcn, fcname) == 0)
  120.          return (YES);
  121.    }
  122.  
  123.    return (NO);                        /* Name is not in selective list      */
  124. } /* FCalNameInSelList (); */
  125.  
  126.  
  127.  
  128.  
  129. int FCalIncludeToMap1 ( FILE *mapf, FILE *objf, fposTYPE *fpos )
  130. /*
  131.     Function: Include list of function calls in single source in project.
  132.         Date: April 26, 1993. 17:55. By LEL.
  133.    Interface: mapf = Map file to include list of function calls in single
  134.                      source in project.
  135.               objf = Main objectfile.
  136.               fpos = Indexes to blocks of data in main objectfile.
  137.      Returns: E/O.
  138. */
  139. {
  140.    long fcnr = 0;                      /* Count different function calls */
  141.    long curpos;                        /* Current file position in objectfile*/
  142.    long linenr;                        /* Line number where a call is done */
  143.    char fcname [MAXFUNCN + 1];         /* Name of current function call */
  144.  
  145.    FSeek (objf, fpos->funcal,SEEK_SET);/* Start of function call data */
  146.  
  147.    curpos = FTell (objf);              /* Init file position controll */
  148.    while (curpos < fpos->idlst)        /* Loop trough all function calls */
  149.    {
  150.       /* Read name of function call */
  151.       if (!FGetS0 (fcname, MAXFUNCN + 1, objf))
  152.          return (ERROR);
  153.  
  154.       if (o_funcall.sel == O_YES)      /* If selective list */
  155.       {
  156.          if (FCalNameInSelList (fcname) == NO)
  157.          {
  158.             do                         /* Do a dummy seek over line numbers  */
  159.             {
  160.                /* Read next line number reference */
  161.                if (FRead (&linenr, sizeof (long), 1, objf) != 1)
  162.                   return (ERROR);
  163.             }
  164.             while (linenr != 0L);      /* 0L if end of line number list */
  165.  
  166.             curpos = FTell (objf);     /* Get filpos to test if end of block */
  167.             continue;                  /* Continue without include func.call */
  168.          }
  169.       }
  170.  
  171.       /* Including list of function calls */
  172.       Display (D_LOW, "%s: (%s)", _StrMSGINCLFUNCALLST, fcname);
  173.  
  174.       FPrintF (mapf, "%s ():\n", fcname);
  175.  
  176.       /* Include the references of the call */
  177.       if (!FCalIncludeToMap1_ (mapf, objf))
  178.          RETURN_ERR;
  179.  
  180.       fcnr  += 1;                      /* Count number of function calls */
  181.       curpos = FTell (objf);           /* Get filpos to test if end of block */
  182.    }
  183.  
  184.    WritFLineLn     (mapf, stdwidth, linechr1);
  185.    FPrintF         (mapf, "%s: %ld\n", _StrMSGTOTFUNCCALS, fcnr);
  186.    WrtStdLinComEnd (mapf, stdwidth, linechr2);
  187.    FPrintF         (mapf, "\n\n\n");
  188.  
  189.    if (errno != 0)                     /* Any error in last file I/O? */
  190.       return (ERROR);
  191.  
  192.    return (OK);
  193. } /* FCalIncludeToMap1 (); */
  194.  
  195.  
  196.  
  197.  
  198. int FCalIncludeToMap1_ ( FILE *mapf, FILE *objf )
  199. /*
  200.     Function: Include function names of callers, and do neccesarry
  201.               indents.
  202.         Date: April 26, 1993. 18:45. By LEL.
  203.    Interface: mapf = Map file to include list of function calls.
  204.               objf = Main objectfile of project.
  205.      Returns: E/O.
  206. */
  207. {
  208.    int      first = 1;                 /* 0 when loop passed second and more */
  209.    long     linenr;                    /* Line number where a call is done   */
  210.    char     oldf [MAXFUNCN + 1];       /* Name of previous func. who called  */
  211.    funcTYPE func;                      /* Data of current function who calls */
  212.  
  213.    oldf[0] = '\0';                     /* Reset previous name of function    */
  214.  
  215.    do                                  /* Loop trough all line numbers       */
  216.    {
  217.       /* Read next line number reference */
  218.       if (FRead (&linenr, sizeof (long), 1, objf) != 1)
  219.          return (ERROR);
  220.  
  221.       if (linenr == 0)                 /* 0L if end of line number list      */
  222.          break;                        /* So break loop                      */
  223.  
  224.       /* Find function who own this line */
  225.       if (FuncRBuffLNrGet (linenr, &func) == 0)
  226.          continue;                     /* Warning: No function use this line */
  227.  
  228.       /* Is it a new function who calls? */
  229.       if (strcmp (oldf, func.name) == 0)
  230.          continue;                     /* Don't include same name twice      */
  231.  
  232.       /*---------------------------------------------------------------------*/
  233.       /* NameOfCaller () ... L-nnn                                           */
  234.  
  235.       /* Name of function who calls */
  236.       FPrintF (mapf, "\t%s ()\t%c-%ld\n", func.name, globlinchr, func.blin);
  237.  
  238.       if (errno != 0)                  /* Any error in last file I/O?        */
  239.          return (ERROR);
  240.  
  241.       strcpy (oldf, func.name);        /* Remember name of previous function */
  242.       first = 0;                       /* Now, first loop has been passed */
  243.    }
  244.    while (1);                          /* Only break loop from inside        */
  245.  
  246.    /* Empty line(s) between each block */
  247.    FPrintF (mapf, "\n%s", first ? "\n" : "");
  248.  
  249.    return (OK);                        /* OK include of references           */
  250. } /* FCalIncludeToMap1_ (); */
  251.  
  252.