<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1">
<title>tools/javadeps.c Source File</title>
<link href="doxygen.css" rel="stylesheet" type="text/css">
</head><body>
<!-- Generated by Doxygen 1.2.17 -->
<center>
<a class="qindex" href="index.html">Main Page</a> <a class="qindex" href="modules.html">Modules</a> <a class="qindex" href="annotated.html">Data Structures</a> <a class="qindex" href="files.html">File List</a> <a class="qindex" href="functions.html">Data Fields</a> <a class="qindex" href="globals.html">Globals</a> <a class="qindex" href="pages.html">Related Pages</a> </center>
<hr><h1>tools/javadeps.c</h1><a href="javadeps_8c.html">Go to the documentation of this file.</a><div class="fragment"><pre>00001 <span class="comment">/*</span>
00002 <span class="comment">RPM and it's source code are covered under two separate licenses. </span>
00003 <span class="comment"></span>
00004 <span class="comment">The entire code base may be distributed under the terms of the GNU General</span>
00005 <span class="comment">Public License (GPL), which appears immediately below. Alternatively,</span>
00006 <span class="comment">all of the source code in the lib subdirectory of the RPM source code</span>
00007 <span class="comment">distribution as well as any code derived from that code may instead be</span>
00008 <span class="comment">distributed under the GNU Library General Public License (LGPL), at the</span>
00009 <span class="comment">choice of the distributor. The complete text of the LGPL appears</span>
00010 <span class="comment">at the bottom of this file.</span>
00011 <span class="comment"></span>
00012 <span class="comment">This alternatively is allowed to enable applications to be linked against</span>
00013 <span class="comment">the RPM library (commonly called librpm) without forcing such applications</span>
00014 <span class="comment">to be distributed under the GPL. </span>
00015 <span class="comment"></span>
00016 <span class="comment">Any questions regarding the licensing of RPM should be addressed to</span>
00017 <span class="comment">marc@redhat.com and ewt@redhat.com.</span>
00018 <span class="comment">*/</span>
00019
00020 <span class="comment">/* </span>
00021 <span class="comment"> Simple progam for pullng all the referenced java classes out of a</span>
00022 <span class="comment"> class file. Java files are supposed to be platform independent, so</span>
00023 <span class="comment"> this program should work on all platforms. This code is based on </span>
00024 <span class="comment"> the information found in:</span>
00025 <span class="comment"></span>
00026 <span class="comment"> "Java Virtual Machine" by Jon Meyer & Troy Downing.</span>
00027 <span class="comment"> O'Reilly & Associates, INC. (First Edition, March 1997)</span>
00028 <span class="comment"> ISBN: 1-56592-194-1</span>
00029 <span class="comment"></span>
00030 <span class="comment"> Jonathan Ross, Ken Estes</span>
00031 <span class="comment"> Mail.com</span>
00032 <span class="comment"> */</span>
00033
00034
00035 <span class="comment">/* </span>
00036 <span class="comment"> Remember that: </span>
00037 <span class="comment"></span>
00038 <span class="comment"> JAR consists of a zip archive, as defined by PKWARE, containing</span>
00039 <span class="comment"> a manifest file and potentially signature files, as defined in</span>
00040 <span class="comment"> the Manifest and Signature specification. So we use infozip's </span>
00041 <span class="comment"> 'unzip -p' found at http://www.cdrom.com/pub/infozip/.</span>
00042 <span class="comment"></span>
00043 <span class="comment"> Additional documentation, about this fact, at:</span>
00044 <span class="comment"></span>
00045 <span class="comment"> http://java.sun.com/products/jdk/1.1/docs/guide/jar/jarGuide.html</span>
00046 <span class="comment"> http://java.sun.com/products/jdk/1.2/docs/guide/jar/jarGuide.html</span>
00047 <span class="comment"> </span>
00048 <span class="comment"> http://java.sun.com/products/jdk/1.1/docs/guide/jar/manifest.html</span>
00049 <span class="comment"> http://java.sun.com/products/jdk/1.2/docs/guide/jar/manifest.html</span>
00050 <span class="comment"> </span>
00051 <span class="comment">*/</span>
00052
00053 <span class="preprocessor">#include "<a class="code" href="system_8h.html">system.h</a>"</span>
00054
00055 <span class="comment">/*</span>
00056 <span class="comment"> these includes are for my use, rpm will use #include "system.h"*</span>
00057 <span class="comment">*/</span>
00058
00059 <span class="comment">/*</span>
00060 <span class="comment">#include <stdio.h></span>
00061 <span class="comment">#include <stdlib.h></span>
00062 <span class="comment">#include <string.h></span>
00063 <span class="comment">#include <ctype.h></span>
00064 <span class="comment">#include <netinet/in.h></span>
00065 <span class="comment">*/</span>
00066
00067 <span class="preprocessor">#include <stdarg.h></span>
00068 <span class="preprocessor">#include "<a class="code" href="debug_8h.html">debug.h</a>"</span>
00069
00070 <span class="comment">/*---------typedefs---------*/</span>
00071
00072
00073 <span class="comment">/* The symbol table is a waste of memory.. </span>
00074 <span class="comment"> but it's easy to code! */</span>
00075
<a name="l00076"></a><a class="code" href="structsymbolTable__t.html">00076</a> <span class="keyword">typedef</span> <span class="keyword">struct </span>{
<a name="l00077"></a><a class="code" href="structsymbolTable__t.html#m0">00077</a> <span class="keywordtype">short</span> poolSize;
<a name="l00078"></a><a class="code" href="structsymbolTable__t.html#m1">00078</a> <span class="keywordtype">char</span> **stringList;
<a name="l00079"></a><a class="code" href="structsymbolTable__t.html#m2">00079</a> <span class="keywordtype">short</span> *classRef;
<a name="l00080"></a><a class="code" href="structsymbolTable__t.html#m3">00080</a> <span class="keywordtype">short</span> *typeRef;
00081 } <a class="code" href="structsymbolTable__t.html">symbolTable_t</a>;
00082
00083
00084 <span class="comment">/*---------Global Variables, in all caps---------*/</span>
00085
00086 <span class="comment">/*name of this program*/</span>
<a name="l00087"></a><a class="code" href="javadeps_8c.html#a2">00087</a> <span class="keywordtype">char</span> *<a class="code" href="javadeps_8c.html#a2">PROGRAM_NAME</a>=0;
00088
00089 <span class="comment">/*name of the current class file*/</span>
<a name="l00090"></a><a class="code" href="javadeps_8c.html#a3">00090</a> <span class="keywordtype">char</span> *<a class="code" href="javadeps_8c.html#a3">FILE_NAME</a>=0;
00091
00092 <span class="comment">/*the name of the last class file seen*/</span>
<a name="l00093"></a><a class="code" href="javadeps_8c.html#a4">00093</a> <span class="keywordtype">char</span> *<a class="code" href="javadeps_8c.html#a4">CLASS_NAME</a>=0;
00094
00095 <span class="comment">/*The string to put before each line, </span>
00096 <span class="comment"> this is a formatted version of CLASS_NAME */</span>
<a name="l00097"></a><a class="code" href="javadeps_8c.html#a5">00097</a> <span class="keywordtype">char</span> *<a class="code" href="javadeps_8c.html#a5">OUTPUT_PREFIX</a>=0;
00098
00099 <span class="comment">/*arguments chosen*/</span>
<a name="l00100"></a><a class="code" href="javadeps_8c.html#a6">00100</a> <span class="keywordtype">int</span> <a class="code" href="javadeps_8c.html#a6">ARG_PROVIDES</a>=0;
<a name="l00101"></a><a class="code" href="javadeps_8c.html#a7">00101</a> <span class="keywordtype">int</span> <a class="code" href="javadeps_8c.html#a7">ARG_REQUIRES</a>=0;
<a name="l00102"></a><a class="code" href="javadeps_8c.html#a8">00102</a> <span class="keywordtype">int</span> <a class="code" href="javadeps_8c.html#a8">ARG_RPMFORMAT</a>=0;
<a name="l00103"></a><a class="code" href="javadeps_8c.html#a9">00103</a> <span class="keywordtype">int</span> <a class="code" href="javadeps_8c.html#a9">ARG_DEPSFORMAT</a>=0;
<a name="l00104"></a><a class="code" href="javadeps_8c.html#a10">00104</a> <span class="keywordtype">int</span> <a class="code" href="javadeps_8c.html#a10">ARG_KEYWORDS</a>=0;
<a name="l00105"></a><a class="code" href="javadeps_8c.html#a11">00105</a> <span class="keywordtype">int</span> <a class="code" href="javadeps_8c.html#a11">ARG_STARPROV</a>=0;
00106
00107 <span class="comment">/*keywords found in class file*/</span>
<a name="l00108"></a><a class="code" href="javadeps_8c.html#a12">00108</a> <span class="keywordtype">char</span> *<a class="code" href="javadeps_8c.html#a12">KEYWORD_VERSION</a>=0;
<a name="l00109"></a><a class="code" href="javadeps_8c.html#a13">00109</a> <span class="keywordtype">char</span> *<a class="code" href="javadeps_8c.html#a13">KEYWORD_REVISION</a>=0;
<a name="l00110"></a><a class="code" href="javadeps_8c.html#a14">00110</a> <span class="keywordtype">char</span> *<a class="code" href="javadeps_8c.html#a14">KEYWORD_EPOCH</a>=0;
00111
00112 <span class="comment">/* </span>
00113 <span class="comment"></span>
00114 <span class="comment"> Quantify says over 80 percent of the time of the program is spent</span>
00115 <span class="comment"> in printf (and the functions it calls) AND I verified that only</span>
00116 <span class="comment"> about a quarter of the classes found in the dependency analysis are</span>
00117 <span class="comment"> unique. After the change no function used more then 26% of the over</span>
00118 <span class="comment"> all time.</span>
00119 <span class="comment"></span>
00120 <span class="comment"> I implement a simple mechanism to remove most duplicate</span>
00121 <span class="comment"> dependencies. The print_table is a table of string, with</span>
00122 <span class="comment"> duplicates, which are to be printed. Just before the program</span>
00123 <span class="comment"> exists it is sorted and all unique entries are printed. If it</span>
00124 <span class="comment"> fills up during then it is flushed using the same technique as</span>
00125 <span class="comment"> above.</span>
00126 <span class="comment"></span>
00127 <span class="comment"> The functions which manipulate the table are:</span>
00128 <span class="comment"> void print_table_flush(void)</span>
00129 <span class="comment"> void print_table_add(char *str)</span>
00130 <span class="comment"></span>
00131 <span class="comment">*/</span>
00132
00133
<a name="l00134"></a><a class="code" href="javadeps_8c.html#a0">00134</a> <span class="preprocessor">#define MAX_PRINT_TABLE 10000</span>
<a name="l00135"></a><a class="code" href="javadeps_8c.html#a15">00135</a> <span class="preprocessor"></span><span class="keywordtype">char</span> *<a class="code" href="javadeps_8c.html#a15">PRINT_TABLE</a>[<a class="code" href="javadeps_8c.html#a0">MAX_PRINT_TABLE</a>];
<a name="l00136"></a><a class="code" href="javadeps_8c.html#a16">00136</a> <span class="keywordtype">int</span> <a class="code" href="javadeps_8c.html#a16">SIZE_PRINT_TABLE</a>;
00137
00138 <span class="comment">/*--------- declare all functions ---------*/</span>
00139
00140 <span class="keywordtype">void</span> <a class="code" href="javadeps_8c.html#a17">usage</a> (<span class="keywordtype">void</span>);
00141 <span class="keywordtype">void</span> <a class="code" href="javadeps_8c.html#a18">outofmemory</a>(<span class="keywordtype">void</span>);
00142 <span class="keywordtype">void</span> <a class="code" href="javadeps_8c.html#a19">die</a>(<span class="keywordtype">char</span> *format, ...);
00143 size_t <a class="code" href="javadeps_8c.html#a20">my_fread</a>(<span class="keywordtype">void</span> *ptr, size_t size, size_t nitems, FILE *stream);
00144 <span class="keywordtype">void</span> <a class="code" href="javadeps_8c.html#a21">check_range</a>(<span class="keywordtype">short</span> entryNum, <span class="keywordtype">short</span> value, <span class="keywordtype">short</span> poolSize);
00145 <span class="keywordtype">char</span> *<a class="code" href="javadeps_8c.html#a22">is_lower_equal</a> (<span class="keywordtype">char</span> *string, <span class="keywordtype">char</span> *pattern);
00146 <span class="keywordtype">int</span> <a class="code" href="javadeps_8c.html#a23">findJavaMagic</a> (FILE *fileHandle);
00147 <span class="keywordtype">int</span> <a class="code" href="javadeps_8c.html#a24">my_strcmp</a> (<span class="keyword">const</span> <span class="keywordtype">void</span> *a, <span class="keyword">const</span> <span class="keywordtype">void</span> *b);
00148 <span class="keywordtype">void</span> <a class="code" href="javadeps_8c.html#a25">print_table_flush</a>(<span class="keywordtype">void</span>);
00149 <span class="keywordtype">void</span> <a class="code" href="javadeps_8c.html#a26">print_table_add</a>(<span class="keywordtype">char</span> *str);
00150 <span class="keywordtype">char</span> *<a class="code" href="javadeps_8c.html#a27">formatClassName</a>(<span class="keywordtype">char</span> *pSomeString, <span class="keywordtype">char</span> terminator, <span class="keywordtype">char</span> print_star);
00151 <span class="keywordtype">void</span> <a class="code" href="javadeps_8c.html#a28">dumpRefType</a>(<span class="keywordtype">char</span> *pSomeString);
00152 <span class="keywordtype">void</span> <a class="code" href="javadeps_8c.html#a29">genSymbolTable</a> (FILE *fileHandle, <a class="code" href="structsymbolTable__t.html">symbolTable_t</a> *symbolTable);
00153 <span class="keywordtype">void</span> <a class="code" href="javadeps_8c.html#a30">freeSymbolTable</a> (<a class="code" href="structsymbolTable__t.html">symbolTable_t</a> *symbolTable);
00154 <span class="keywordtype">char</span> *<a class="code" href="javadeps_8c.html#a31">findClassName</a> (FILE *fileHandle, <a class="code" href="structsymbolTable__t.html">symbolTable_t</a> *symbolTable);
00155 <span class="keywordtype">void</span> <a class="code" href="javadeps_8c.html#a32">dumpProvides</a>(<span class="keywordtype">char</span> *className);
00156 <span class="keywordtype">void</span> <a class="code" href="javadeps_8c.html#a33">dumpRequires</a>(<a class="code" href="structsymbolTable__t.html">symbolTable_t</a> *symbolTable);
00157 <span class="keywordtype">void</span> <a class="code" href="javadeps_8c.html#a34">processJavaFile</a> (FILE *fileHandle);
00158
00159 <span class="comment">/*--------- functions ---------*/</span>
00160
00161 <span class="keywordtype">void</span>
<a name="l00162"></a><a class="code" href="javadeps_8c.html#a17">00162</a> <a class="code" href="javadeps_8c.html#a17">usage</a> (<span class="keywordtype">void</span>)
00163 {
00164 printf(<span class="stringliteral">"NAME:\n\tjavadeps - Examine Java class files and\n"</span>
00165 <span class="stringliteral">"\t\t\treturn information about their dependencies.\n\n"</span>);
00166 printf(<span class="stringliteral">"USAGE:\n"</span>);
00167 printf(<span class="stringliteral">"\t javadeps { --provides | --requires } \n"</span>
00168 <span class="stringliteral">"\t\t [--rpmformat] [--depsformat] [--keywords] \n"</span>
00169 <span class="stringliteral">"\t\t [--] classfile-name ... \n\n"</span>
00170 <span class="stringliteral">"\t javadeps [--help]\n\n"</span>);
00171 printf(<span class="stringliteral">"\n\n"</span>);
00172 printf(<span class="stringliteral">"DESCRIPTION:\n\n"</span>);
00173 printf(<span class="stringliteral">"List the dependencies or the fully qualified class names, of the \n"</span>
00174 <span class="stringliteral">"classfiles listed on the command line. \n\n"</span>);
00175 printf(<span class="stringliteral">"OPTIONS:\n\n"</span>);
00176 printf(<span class="stringliteral">"--requires For each class files listed in the arguments,\n"</span>
00177 <span class="stringliteral">" -r print the list of class files that would be\n"</span>
00178 <span class="stringliteral">" required to run these java programs. This does not \n"</span>
00179 <span class="stringliteral">" include anyting instantiated by reflection.\n\n"</span>);
00180 printf(<span class="stringliteral">"--provides For each class files listed in the arguments, \n"</span>
00181 <span class="stringliteral">" -p Print the fully qualified java classes,\n"</span>
00182 <span class="stringliteral">" that they provide.\n\n"</span>);
00183 printf(<span class="stringliteral">"--rpmformat Format the output to match that used by RPM's \n"</span>
00184 <span class="stringliteral">" -F (Red Hat Package Manager) dependency analysis \n"</span>
00185 <span class="stringliteral">" database. The default is not --rpmformat.\n\n"</span>);
00186 printf(<span class="stringliteral">"--depsformat print the name of the class which \n"</span>
00187 <span class="stringliteral">" -d This is mostly used in conjunctions with --requires \n"</span>
00188 <span class="stringliteral">" to list the class file dependencies in a format "</span>
00189 <span class="stringliteral">" similar to traditional Makefile dependencies. The "</span>
00190 <span class="stringliteral">" default is not --depsformat.\n\n"</span>);
00191 printf(<span class="stringliteral">"--keywords Make use of any keywords embeded in the classfile.\n"</span>
00192 <span class="stringliteral">" -k The default is not --keyword.\n\n"</span>);
00193 printf(<span class="stringliteral">"--starprov Add the star notation provides to the provides list.\n"</span>
00194 <span class="stringliteral">" -s The default is not --starprov. This is only for use\n"</span>
00195 <span class="stringliteral">" with (Sun) jhtml dependencies, and since jhtml is \n"</span>
00196 <span class="stringliteral">" deprecated so is this option.\n\n"</span>);
00197 printf(<span class="stringliteral">"--help Display this page and exit.\n\n"</span>);
00198 printf(<span class="stringliteral">"-- This stops the processing of arguments, making it \n"</span>
00199 <span class="stringliteral">" easier for users to have filenames like '--keywords',\n"</span>
00200 <span class="stringliteral">" without the command line parser getting confused.\n\n"</span>);
00201 printf(<span class="stringliteral">"\n\n"</span>);
00202 printf(<span class="stringliteral">"If any of the class file names in the argument list is '-' then\n"</span>
00203 <span class="stringliteral">"<stdin> will be read instead of reading from a file. The\n"</span>
00204 <span class="stringliteral">"contents of <stdin> should be the contents of a class file and \n"</span>
00205 <span class="stringliteral">"not a list of class files to read. It is assumed that when run \n"</span>
00206 <span class="stringliteral">"with '-', this program is in a pipeline preceeded by the \n"</span>
00207 <span class="stringliteral">"command 'unzip -p filename.jar' so that <stdin> may contain\n"</span>
00208 <span class="stringliteral">"the contents of several classfiles concatenated together.\n"</span>);
00209 printf(<span class="stringliteral">"\n\n"</span>);
00210 printf(<span class="stringliteral">"If --keywords is specified then the following strings are \n"</span>
00211 <span class="stringliteral">"searched for (case insensitive) in the class file string table\n"</span>
00212 <span class="stringliteral">"and, if a string is found with a prefix matching the keyword then \n"</span>
00213 <span class="stringliteral">"the dependencies are changed accordingly. There may be multiple \n"</span>
00214 <span class="stringliteral">"string tables entries prefixed with RPM_Provides and RPM_Requires. \n"</span>
00215 <span class="stringliteral">"This would indicate that the dependency is the union\n"</span>
00216 <span class="stringliteral">"of all entries.\n"</span>
00217 <span class="stringliteral">"\n\n"</span>
00218 <span class="stringliteral">"Keyword List:\n\n"</span>
00219 <span class="stringliteral">"'$Revision: ' This RCS/CVS compatible keyword is assumed to \n"</span>
00220 <span class="stringliteral">" contain the version number of the class file \n"</span>
00221 <span class="stringliteral">" it is found in. Care should be taken with this\n"</span>
00222 <span class="stringliteral">" option as RPM's notion of which version is later\n"</span>
00223 <span class="stringliteral">" may not corrispond with your own, especially\n"</span>
00224 <span class="stringliteral">" if you use branches. This keyword\n"</span>
00225 <span class="stringliteral">" only effects the output of --provides and only\n"</span>
00226 <span class="stringliteral">" when RPM_Version is not defined.\n\n"</span>
00227 <span class="stringliteral">"'RPM_Version: ' This is an alternative method of specifing the\n"</span>
00228 <span class="stringliteral">" version number of the class. It will override\n"</span>
00229 <span class="stringliteral">" $Revision if set. This keyword only effects\n"</span>
00230 <span class="stringliteral">" the output of --provides \n\n"</span>
00231 <span class="stringliteral">"'RPM_Epoch: ' This string contains the epoch to use with the \n"</span>
00232 <span class="stringliteral">" version number stored in Revision. If not \n"</span>
00233 <span class="stringliteral">" specified, the epoch is assumed to be zero.\n"</span>
00234 <span class="stringliteral">" This keyword only effects the output of\n "</span>
00235 <span class="stringliteral">" --provides and only when $Revision number is\n"</span>
00236 <span class="stringliteral">" used.\n\n"</span>
00237 <span class="stringliteral">"'RPM_Provides: ' This string lists additional capabilites\n"</span>
00238 <span class="stringliteral">" provided by the java class. The string should\n"</span>
00239 <span class="stringliteral">" be a white space ([\\t\\v\\n\\r\\f\\ ])\n"</span>
00240 <span class="stringliteral">" separated list of dependency strings. Each\n"</span>
00241 <span class="stringliteral">" dependency string must be of the same format as\n"</span>
00242 <span class="stringliteral">" would be valid in the Requires or Provides line\n"</span>
00243 <span class="stringliteral">" of the specfile. This keyword only effects the\n"</span>
00244 <span class="stringliteral">" output of --provides.\n\n"</span>
00245 <span class="stringliteral">"'RPM_Requires: ' This string lists additional requirements of\n"</span>
00246 <span class="stringliteral">" the java class. The string should be a white \n"</span>
00247 <span class="stringliteral">" space ([\\t \v\\n\\r\\f\\ ]) separated list of \n"</span>
00248 <span class="stringliteral">" dependency strings. Each dependency string must\n"</span>
00249 <span class="stringliteral">" be of the same format as would be valid in the \n"</span>
00250 <span class="stringliteral">" Requires or Provides line of the specfile. This\n"</span>
00251 <span class="stringliteral">" keyword only effects the output of --requires.\n "</span>
00252 <span class="stringliteral">" \n\n"</span>
00253 <span class="stringliteral">"Note that there is no means of setting the release number. This\n"</span>
00254 <span class="stringliteral">"is necessary because release numbers are incremented when the\n"</span>
00255 <span class="stringliteral">"source does not change but the package needs to be rebuilt. So\n"</span>
00256 <span class="stringliteral">"relase numbers can not be stored in the source. The release is\n"</span>
00257 <span class="stringliteral">"assumed to be zero. \n\n"</span>
00258 <span class="stringliteral">""</span>);
00259 printf(<span class="stringliteral">"EXAMPLES (Java Keywords): \n\n"</span>
00260 <span class="stringliteral">"\t public static final String REVISION = \"$Revision: 2.6.8.4 $\";\n"</span>
00261 <span class="stringliteral">"\t public static final String EPOCH = \"4\";\n"</span>
00262 <span class="stringliteral">"\t public static final String REQUIRES = \"RPM_Requires: "</span>
00263 <span class="stringliteral">"java(gnu.regexp.RE) java(com.ibm.site.util.Options)>=1.5\";\n"</span>
00264 <span class="stringliteral">""</span>);
00265 printf(<span class="stringliteral">"\n\n"</span>);
00266 printf(<span class="stringliteral">"EXAMPLES (Arguments): \n\n"</span>
00267 <span class="stringliteral">"\tjavadeps --requires -- filename.class\n\n"</span>
00268 <span class="stringliteral">"\tjavadeps --provides -- filename.class\n\n"</span>
00269 <span class="stringliteral">"\tjavadeps --help\n\n"</span>
00270 <span class="stringliteral">"\n"</span>
00271 <span class="stringliteral">"\tjavadeps --requires --rpmformat --keywords -- filename.class\n\n"</span>
00272 <span class="stringliteral">"\tjavadeps --requires --depsformat -- filename.class\n\n"</span>
00273 <span class="stringliteral">"\tjavadeps --requires -- filename1.class filename2.class\n\n"</span>
00274 <span class="stringliteral">"\tcat filename2.class | javadeps --requires -- filename1.class -\n\n"</span>
00275 <span class="stringliteral">"\tunzip -p filename.jar | javadeps --requires -- - \n\n"</span>
00276 <span class="stringliteral">""</span>);
00277 printf(<span class="stringliteral">"This program is distributed with RPM the Redhat Package \n"</span>
00278 <span class="stringliteral">"Managment system. Further information about RPM can be found at \n"</span>
00279 <span class="stringliteral">"\thttp://www.rpm.org/\n\n"</span>);
00280 printf(<span class="stringliteral">"\n\n"</span>);
00281 exit(-1);
00282 }
00283
00284
<a name="l00285"></a><a class="code" href="javadeps_8c.html#a18">00285</a> <span class="keywordtype">void</span> <a class="code" href="javadeps_8c.html#a18">outofmemory</a>(<span class="keywordtype">void</span>) {
00286
00287 <span class="comment">/* Its doubtful we could do a printf if there is really a memory</span>
00288 <span class="comment"> issue but at least halt the program */</span>
00289
00290 fprintf(stderr, <span class="stringliteral">"Could not allocate memory\n"</span>);
00291 exit(-1);
00292 }
00293
00294
<a name="l00295"></a><a class="code" href="javadeps_8c.html#a19">00295</a> <span class="keywordtype">void</span> <a class="code" href="javadeps_8c.html#a19">die</a>(<span class="keywordtype">char</span> *format, ...) {
00296 <span class="comment">/* Most errors are fatal.</span>
00297 <span class="comment"> This function throws a fatal error and </span>
00298 <span class="comment"> accepts arguments like printf does*/</span>
00299
00300 <span class="keywordtype">char</span> *newformat = NULL, *newmsg = NULL;
00301 va_list ap;
00302
00303 <span class="keywordflow">if</span> (
00304 !(newformat = (<span class="keywordtype">char</span>*) malloc(1024)) ||
00305 !(newmsg = (<span class="keywordtype">char</span>*) malloc(1024))
00306 )
00307 <a class="code" href="javadeps_8c.html#a18">outofmemory</a>();
00308
00309 <span class="comment">/* Rewrite format line, to include additional information. The</span>
00310 <span class="comment"> format line we chose depends on how much information is availible</span>
00311 <span class="comment"> at the time of the error. Display the maximum ammount of</span>
00312 <span class="comment"> information. */</span>
00313
00314 <span class="comment">/* notice the FILE_NAME is useless for jar files. We would want to</span>
00315 <span class="comment"> print the name of the classfile which caused the error. That</span>
00316 <span class="comment"> is hard since we only know that name when we are done parsing</span>
00317 <span class="comment"> the file, and most errors will occur before that.*/</span>
00318
00319 va_start(ap, format);
00320
00321 <span class="keywordflow">if</span> ( (!<a class="code" href="javadeps_8c.html#a3">FILE_NAME</a>) ) {
00322
00323 sprintf (newformat, <span class="stringliteral">"\n%s: %s"</span>,
00324 <a class="code" href="javadeps_8c.html#a2">PROGRAM_NAME</a>, format);
00325
00326 } <span class="keywordflow">else</span> <span class="keywordflow">if</span> ( (FILE_NAME) && (!<a class="code" href="javadeps_8c.html#a4">CLASS_NAME</a>) ) {
00327
00328 sprintf (newformat, <span class="stringliteral">"\n%s: Java classfile: %s, %s"</span>,
00329 <a class="code" href="javadeps_8c.html#a2">PROGRAM_NAME</a>, <a class="code" href="javadeps_8c.html#a3">FILE_NAME</a>, format);
00330
00331 } <span class="keywordflow">else</span> <span class="keywordflow">if</span> (CLASS_NAME) {
00332 sprintf (newformat, <span class="stringliteral">"\n%s: Java classfile: %s, classname: %s, %s"</span>,
00333 <a class="code" href="javadeps_8c.html#a2">PROGRAM_NAME</a>, <a class="code" href="javadeps_8c.html#a3">FILE_NAME</a>, <a class="code" href="javadeps_8c.html#a4">CLASS_NAME</a>, format);
00334 }
00335
00336 vsprintf (newmsg, newformat, ap);
00337
00338 <span class="comment">/* print error to where it needs to go:</span>
00339 <span class="comment"> stdout, stderr, or syslog</span>
00340 <span class="comment"> */</span>
00341
00342 fprintf(stderr, newmsg);
00343
00344 free(newformat);
00345 free(newmsg);
00346
00347 exit(-1);
00348 }
00349
00350
00351 <span class="comment">/* wrap fread for safety. It is a fatal error to get an unexpected</span>
00352 <span class="comment"> EOF inside a class file. */</span>
00353
<a name="l00354"></a><a class="code" href="javadeps_8c.html#a20">00354</a> size_t <a class="code" href="javadeps_8c.html#a20">my_fread</a>(<span class="keywordtype">void</span> *ptr, size_t size, size_t nitems, FILE *stream) {
00355 size_t rc=0;
00356 <span class="comment">/*these variables are helpful in the debugger*/</span>
00357 <span class="keywordtype">int</span> eof=0;
00358 <span class="keywordtype">int</span> error=0;
00359
00360
00361 rc = fread(ptr, size, nitems, stream);
00362 <span class="keywordflow">if</span> ( (size!=0) && (rc == 0) ) {
00363 eof = feof(stream);
00364 error = ferror(stream);
00365 <a class="code" href="javadeps_8c.html#a19">die</a>(<span class="stringliteral">"Error reading from file, or unexpected EOF\n"</span>);
00366 }
00367 <span class="keywordflow">return</span> rc;
00368 }
00369
00370
<a name="l00371"></a><a class="code" href="javadeps_8c.html#a21">00371</a> <span class="keywordtype">void</span> <a class="code" href="javadeps_8c.html#a21">check_range</a>(<span class="keywordtype">short</span> entryNum, <span class="keywordtype">short</span> value, <span class="keywordtype">short</span> poolSize) {
00372
00373 <span class="keywordflow">if</span> (value > poolSize) {
00374 <a class="code" href="javadeps_8c.html#a19">die</a>(<span class="stringliteral">"Symbol Table Entry Number: %d, Value: %d, "</span>
00375 <span class="stringliteral">"is out of range of the constant pool. Pool Size: %d\n"</span>,
00376 entryNum, value, poolSize);
00377 }
00378 <span class="keywordflow">return</span> ;
00379 }
00380
00381
00382
00383 <span class="comment">/* If lower case conversion of string is equal to pattern return a</span>
00384 <span class="comment"> pointer into string, just after the match. If the string does not</span>
00385 <span class="comment"> patch the pattern the null pointer is returned. This does not</span>
00386 <span class="comment"> change string. </span>
00387 <span class="comment"></span>
00388 <span class="comment"> This is similar to strcasecmp, but I expect my patterns to be a</span>
00389 <span class="comment"> prefix of my strings. */</span>
00390
00391 <span class="keywordtype">char</span>
<a name="l00392"></a><a class="code" href="javadeps_8c.html#a22">00392</a> *<a class="code" href="javadeps_8c.html#a22">is_lower_equal</a> (<span class="keywordtype">char</span> *string, <span class="keywordtype">char</span> *pattern)
00393 {
00394
00395 <span class="keywordflow">while</span> ( (tolower(*string) == *pattern) &&
00396 *string && *pattern ) {
00397 string++;
00398 pattern++;
00399 }
00400
00401 <span class="keywordflow">if</span> ( *pattern == 0 ) {
00402 <span class="keywordflow">return</span> string;
00403 }
00404
00405 <span class="keywordflow">return</span> NULL;
00406 }
00407
00408
00409 <span class="comment">/* </span>
00410 <span class="comment"> Read fileHandle until we find the next instance of the Java</span>
00411 <span class="comment"> Classfile magic number indicating a java file or find EOF or</span>
00412 <span class="comment"> fileread error. Since we are reading from stdin which may contain</span>
00413 <span class="comment"> the concatination of many class files we can not be sure that the</span>
00414 <span class="comment"> magic number will be the first few bytes.</span>
00415 <span class="comment"></span>
00416 <span class="comment"> Return 1 on success 0 on failure. */</span>
00417
<a name="l00418"></a><a class="code" href="javadeps_8c.html#a1">00418</a> <span class="preprocessor">#define mod4(num) ( (num) & 3 )</span>
00419 <span class="preprocessor"></span>
00420
<a name="l00421"></a><a class="code" href="javadeps_8c.html#a23">00421</a> <span class="keywordtype">int</span> <a class="code" href="javadeps_8c.html#a23">findJavaMagic</a> (FILE *fileHandle)
00422 {
00423 <span class="keywordtype">int</span> offset=0;
00424 <span class="keywordtype">int</span> foundMagic = 0;
00425 size_t rc;
00426
00427 <span class="comment">/* what were looking for */</span>
00428 <span class="keywordtype">unsigned</span> <span class="keywordtype">char</span> magicInt[4] = {0xCA, 0xFE, 0xBA, 0xBE};
00429 <span class="comment">/*the hex reads in decimal: 202 254 186 190 */</span>
00430
00431 <span class="comment">/* a circular buffer indicating the last few bytes we read */</span>
00432 <span class="keywordtype">unsigned</span> <span class="keywordtype">char</span> buffer[4] = {0};
00433
00434 foundMagic = 0;
00435 <span class="keywordflow">while</span>( !foundMagic ) {
00436
00437 rc = fread(&buffer[offset], 1, 1, fileHandle);
00438 <span class="keywordflow">if</span> ( !rc ) {
00439
00440 <span class="comment">/* Either this was not a java file or we were given a jar file</span>
00441 <span class="comment"> and have already found the last java file in it.*/</span>
00442
00443 <span class="keywordflow">if</span> ( feof(fileHandle) ) {
00444 <span class="keywordflow">return</span> 0;
00445 }
00446
00447 <span class="keywordflow">if</span> ( ferror(fileHandle) ) {
00448 <a class="code" href="javadeps_8c.html#a19">die</a> (<span class="stringliteral">"Error reading character from file.\n"</span>);
00449 };
00450
00451 }
00452
00453 <span class="comment">/* offset points to the most recent char we read so offest+1</span>
00454 <span class="comment"> points to the oldest char we saved. */</span>
00455
00456 foundMagic = (
00457 (magicInt[0] == buffer[<a class="code" href="javadeps_8c.html#a1">mod4</a>(offset+1)]) &&
00458 (magicInt[1] == buffer[<a class="code" href="javadeps_8c.html#a1">mod4</a>(offset+2)]) &&
00459 (magicInt[2] == buffer[<a class="code" href="javadeps_8c.html#a1">mod4</a>(offset+3)]) &&
00460 (magicInt[3] == buffer[<a class="code" href="javadeps_8c.html#a1">mod4</a>(offset+0)]) &&
00461 1
00462 );
00463
00464 offset = <a class="code" href="javadeps_8c.html#a1">mod4</a>(offset+1);
00465
00466 } <span class="comment">/*end while*/</span>
00467
00468 <span class="keywordflow">return</span> foundMagic;
00469 }
00470
00471 <span class="preprocessor">#undef mod4</span>
00472 <span class="preprocessor"></span>
00473
00474 <span class="keywordtype">int</span>
<a name="l00475"></a><a class="code" href="javadeps_8c.html#a24">00475</a> <a class="code" href="javadeps_8c.html#a24">my_strcmp</a> (<span class="keyword">const</span> <span class="keywordtype">void</span> *a, <span class="keyword">const</span> <span class="keywordtype">void</span> *b) {
00476 <span class="keywordtype">char</span> **a1; <span class="keywordtype">char</span> **b1;
00477 <span class="keywordtype">int</span> ret;
00478
00479 a1 = (<span class="keywordtype">char</span> **)a;
00480 b1 = (<span class="keywordtype">char</span> **)b;
00481 ret = strcmp(*a1,*b1);
00482 <span class="keywordflow">return</span> ret;
00483 }
00484
00485 <span class="comment">/* print the unique strings found in PRINT_TABLE and clear it out */</span>
00486
00487 <span class="keywordtype">void</span>
<a name="l00488"></a><a class="code" href="javadeps_8c.html#a25">00488</a> <a class="code" href="javadeps_8c.html#a25">print_table_flush</a>(<span class="keywordtype">void</span>) {
00489 <span class="keywordtype">int</span> i;
00490 <span class="keywordtype">char</span> *last_string;
00491
00492 <span class="keywordflow">if</span> (!<a class="code" href="javadeps_8c.html#a16">SIZE_PRINT_TABLE</a>) {
00493 <span class="keywordflow">return</span> ;
00494 }
00495
00496 <span class="comment">/* The qsort line gives a warning on some unicies who insist that</span>
00497 <span class="comment"> strcmp takes arguments of type pointers to void not the</span>
00498 <span class="comment"> traditional pointers to char. */</span>
00499
00500 qsort( (<span class="keywordtype">void</span> *) <a class="code" href="javadeps_8c.html#a15">PRINT_TABLE</a>, (size_t) <a class="code" href="javadeps_8c.html#a16">SIZE_PRINT_TABLE</a>,
00501 <span class="keyword">sizeof</span>(<span class="keywordtype">char</span> *), &<a class="code" href="javadeps_8c.html#a24">my_strcmp</a>);
00502
00503 printf(<span class="stringliteral">"%s\n"</span>,<a class="code" href="javadeps_8c.html#a15">PRINT_TABLE</a>[0]);
00504 last_string = <a class="code" href="javadeps_8c.html#a15">PRINT_TABLE</a>[0];
00505 <a class="code" href="javadeps_8c.html#a15">PRINT_TABLE</a>[0] = NULL;
00506
00507 <span class="keywordflow">for</span> (i = 1; i < <a class="code" href="javadeps_8c.html#a16">SIZE_PRINT_TABLE</a>; i++) {
00508 <span class="keywordflow">if</span> ( strcmp(last_string, <a class="code" href="javadeps_8c.html#a15">PRINT_TABLE</a>[i]) ){
00509 printf(<span class="stringliteral">"%s\n"</span>,<a class="code" href="javadeps_8c.html#a15">PRINT_TABLE</a>[i]);
00510 free(last_string);
00511 last_string = <a class="code" href="javadeps_8c.html#a15">PRINT_TABLE</a>[i];
00512 } <span class="keywordflow">else</span> {
00513 free(<a class="code" href="javadeps_8c.html#a15">PRINT_TABLE</a>[i]);
00514 }
00515 <a class="code" href="javadeps_8c.html#a15">PRINT_TABLE</a>[i] = NULL;
00516 }
00517
00518 free(last_string);
00519 <a class="code" href="javadeps_8c.html#a16">SIZE_PRINT_TABLE</a> = 0;
00520 <span class="keywordflow">return</span> ;
00521 }
00522
00523
00524 <span class="comment">/* add an element to PRINT_TABLE for later printing to stdout. We do</span>
00525 <span class="comment"> not make a copy of the string so each string must be unique,</span>
00526 <span class="comment"> (different calls must pass pointers to different areas of memory)</span>
00527 <span class="comment"> and the string must not be freed anywhere else in the code and the</span>
00528 <span class="comment"> string must be from memory which can be freed.*/</span>
00529
00530 <span class="keywordtype">void</span>
<a name="l00531"></a><a class="code" href="javadeps_8c.html#a26">00531</a> <a class="code" href="javadeps_8c.html#a26">print_table_add</a>(<span class="keywordtype">char</span> *str) {
00532
00533 <span class="keywordflow">if</span> (<a class="code" href="javadeps_8c.html#a16">SIZE_PRINT_TABLE</a> == <a class="code" href="javadeps_8c.html#a0">MAX_PRINT_TABLE</a>) {
00534 <a class="code" href="javadeps_8c.html#a25">print_table_flush</a>();
00535 }
00536
00537 <span class="keywordflow">if</span> (OUTPUT_PREFIX) {
00538 <span class="keywordtype">char</span> *new_str;
00539
00540 new_str= (<span class="keywordtype">char</span>*) malloc(strlen(<a class="code" href="javadeps_8c.html#a5">OUTPUT_PREFIX</a>)+strlen(str)+1);
00541 <span class="keywordflow">if</span> (!new_str){
00542 <a class="code" href="javadeps_8c.html#a18">outofmemory</a>();
00543 }
00544
00545 new_str[0]=<span class="charliteral">'\0'</span>;
00546 strcat(new_str,<a class="code" href="javadeps_8c.html#a5">OUTPUT_PREFIX</a>);
00547 strcat(new_str,str);
00548 free(str);
00549 str=new_str;
00550 }
00551
00552 <a class="code" href="javadeps_8c.html#a15">PRINT_TABLE</a>[<a class="code" href="javadeps_8c.html#a16">SIZE_PRINT_TABLE</a>] = str;
00553 <a class="code" href="javadeps_8c.html#a16">SIZE_PRINT_TABLE</a>++;
00554 <span class="keywordflow">return</span> ;
00555 }
00556
00557
00558 <span class="keyword">static</span> <span class="keywordtype">void</span>
<a name="l00559"></a><a class="code" href="javadeps_8c.html#a35">00559</a> <a class="code" href="javadeps_8c.html#a35">print_list</a>(<span class="keywordtype">char</span> *in_string) {
00560
00561 <span class="comment">/* This function is no longer needed due to fixes in RPM's</span>
00562 <span class="comment"> processing of dependencies. Keep the code until I get a chance</span>
00563 <span class="comment"> to use RPM3.0 personally */</span>
00564
00565 <span class="keywordflow">if</span> (in_string) {
00566 printf(<span class="stringliteral">"%s\n"</span>, in_string);
00567 }
00568
00569 <span class="comment">/* </span>
00570 <span class="comment"> Old function did:</span>
00571 <span class="comment"></span>
00572 <span class="comment"> Given a list separated by whitespace, put each element in the print</span>
00573 <span class="comment"> table with an added "\n" */</span>
00574
00575 <span class="comment">/*</span>
00576 <span class="comment"> char *WhiteSpace_Set = "\t\v\n\r\f ";</span>
00577 <span class="comment"> char *newEnd, *out_string;</span>
00578 <span class="comment"> int copy_len;</span>
00579 <span class="comment"></span>
00580 <span class="comment"> in_string += strspn(in_string, WhiteSpace_Set); </span>
00581 <span class="comment"></span>
00582 <span class="comment"> while (*in_string) {</span>
00583 <span class="comment"> newEnd = strpbrk(in_string, WhiteSpace_Set);</span>
00584 <span class="comment"> </span>
00585 <span class="comment"> if (newEnd) {</span>
00586 <span class="comment"> copy_len = newEnd-in_string;</span>
00587 <span class="comment"> } else {</span>
00588 <span class="comment"> if (*in_string) {</span>
00589 <span class="comment"> copy_len = strlen(in_string);</span>
00590 <span class="comment"> } else {</span>
00591 <span class="comment"> copy_len = 0;</span>
00592 <span class="comment"> }</span>
00593 <span class="comment"> }</span>
00594 <span class="comment"> </span>
00595 <span class="comment"> out_string = malloc(copy_len+10);</span>
00596 <span class="comment"> if ( !out_string ) {</span>
00597 <span class="comment"> outofmemory();</span>
00598 <span class="comment"> }</span>
00599 <span class="comment"> out_string[0]= '\0';</span>
00600 <span class="comment"></span>
00601 <span class="comment"> if (copy_len) {</span>
00602 <span class="comment"> strncat(out_string, in_string, copy_len);</span>
00603 <span class="comment"> in_string+=copy_len;</span>
00604 <span class="comment"> strcat(out_string, "\n");</span>
00605 <span class="comment"> print_table_add(out_string);</span>
00606 <span class="comment"> }</span>
00607 <span class="comment"></span>
00608 <span class="comment"> in_string += strspn(in_string+copy_len, WhiteSpace_Set);</span>
00609 <span class="comment"> }</span>
00610 <span class="comment"></span>
00611 <span class="comment"> */</span>
00612 <span class="keywordflow">return</span> ;
00613 }
00614
00615
00616 <span class="comment">/* Print a properly formatted java class name, and returns the length</span>
00617 <span class="comment"> of the class string . Do not print \n here as we may wish to</span>
00618 <span class="comment"> append the version number IFF we are printing the name of this classfile</span>
00619 <span class="comment"> </span>
00620 <span class="comment"> We also provide the class with the leaf node replaced with '*'.</span>
00621 <span class="comment"> This would not be necessary if we only had to worry about java</span>
00622 <span class="comment"> Class files. However our parsing of jhtml files depends on this</span>
00623 <span class="comment"> information. This is deprecated since jhtml is deprecated and</span>
00624 <span class="comment"> this method allows for very inaccurate dependencies.</span>
00625 <span class="comment"> </span>
00626 <span class="comment"> Also users may wish to refer to dependencies using star notation</span>
00627 <span class="comment"> (though this would be less accurate then explicit dependencies</span>
00628 <span class="comment"> since any leaf class will satify a star dependency). */</span>
00629
00630 <span class="keywordtype">char</span>
<a name="l00631"></a><a class="code" href="javadeps_8c.html#a27">00631</a> *<a class="code" href="javadeps_8c.html#a27">formatClassName</a>(<span class="keywordtype">char</span> *in_string, <span class="keywordtype">char</span> terminator,
00632 <span class="keywordtype">char</span> print_star)
00633 {
00634 <span class="keywordtype">char</span> *leaf_class=0, *out_string=0;
00635 <span class="keywordtype">char</span> *ClassName_Break_Set=0;
00636
00637
00638 out_string = (<span class="keywordtype">char</span>*) malloc(strlen(in_string) + 10);
00639 <span class="keywordflow">if</span> ( !out_string ) {
00640 <a class="code" href="javadeps_8c.html#a18">outofmemory</a>();
00641 }
00642 out_string[0]= <span class="charliteral">'\0'</span>;
00643
00644 <span class="comment">/*these characters end the current parse of the string in function</span>
00645 <span class="comment"> formatClassName.*/</span>
00646
00647 ClassName_Break_Set = (<span class="keywordtype">char</span>*) malloc(3);
00648 <span class="keywordflow">if</span> ( !ClassName_Break_Set ) {
00649 <a class="code" href="javadeps_8c.html#a18">outofmemory</a>();
00650 }
00651 ClassName_Break_Set[0] = <span class="charliteral">'/'</span>;
00652 <span class="comment">/*terminator can be '\0' this must go after '/'*/</span>
00653 ClassName_Break_Set[1] = terminator;
00654 ClassName_Break_Set[2] = <span class="charliteral">'\0'</span>;
00655
00656 <span class="keywordflow">if</span>(ARG_RPMFORMAT) {
00657 strcat(out_string, <span class="stringliteral">"java("</span>);
00658 }
00659 <span class="keywordflow">if</span> (print_star) {
00660 <span class="comment">/* print the path to the leaf class but do not print the leaf</span>
00661 <span class="comment"> class, stop at the last '/' we fix this back below*/</span>
00662 leaf_class = strrchr(in_string, <span class="charliteral">'/'</span>);
00663 <span class="keywordflow">if</span> (leaf_class) {
00664 leaf_class[0] = terminator;
00665 }
00666 }
00667
00668 <span class="keywordflow">while</span> (*in_string != terminator) {
00669 <span class="keywordtype">char</span> *newEnd=0;
00670 <span class="keywordtype">int</span> copy_len;
00671
00672 <span class="comment">/* handle the break_set */</span>
00673
00674 <span class="keywordflow">if</span> (in_string[0] == <span class="charliteral">'\0'</span> ) {
00675 <a class="code" href="javadeps_8c.html#a19">die</a>(<span class="stringliteral">"Classname does not terminate with: '%c', '%s'\n"</span>,
00676 terminator, in_string);
00677 } <span class="keywordflow">else</span> {
00678 <span class="keywordflow">if</span> (in_string[0] == <span class="charliteral">'/'</span> ) {
00679 <span class="comment">/* convert '/' to '.' */</span>
00680 strcat(out_string, <span class="stringliteral">"."</span>);
00681 in_string++;
00682 }
00683 }
00684
00685 newEnd = strpbrk(in_string, ClassName_Break_Set);
00686
00687 <span class="keywordflow">if</span> (newEnd) {
00688 copy_len = newEnd-in_string;
00689 } <span class="keywordflow">else</span> {
00690 <span class="keywordflow">if</span> (terminator == <span class="charliteral">'\0'</span>) {
00691 copy_len = strlen(in_string);
00692 } <span class="keywordflow">else</span> {
00693 copy_len = 0;
00694 }
00695 }
00696
00697 <span class="comment">/* handle upto but not including the break_set*/</span>
00698 <span class="keywordflow">if</span> (copy_len) {
00699 strncat(out_string, in_string, copy_len);
00700 in_string+=copy_len;
00701 }
00702
00703 } <span class="comment">/*end while*/</span>
00704
00705 <span class="keywordflow">if</span> (leaf_class) {
00706 <span class="comment">/* print the star and fix the leaf class*/</span>
00707 strcat(out_string, <span class="stringliteral">".*"</span>);
00708 leaf_class[0] = <span class="charliteral">'/'</span>;
00709 }
00710 <span class="keywordflow">if</span>(ARG_RPMFORMAT) {
00711 strcat(out_string, <span class="stringliteral">")"</span>);
00712 }
00713
00714 free(ClassName_Break_Set);
00715 <span class="keywordflow">return</span> out_string;
00716 }
00717
00718
00719 <span class="comment">/* Parse out just the class names from a java type and moves the string</span>
00720 <span class="comment"> pointer to the end of the string. */</span>
00721
00722 <span class="keywordtype">void</span>
<a name="l00723"></a><a class="code" href="javadeps_8c.html#a28">00723</a> <a class="code" href="javadeps_8c.html#a28">dumpRefType</a>(<span class="keywordtype">char</span> *string)
00724 {
00725 <span class="comment">/* All class types start with a 'L' and and end with a ';'. We want</span>
00726 <span class="comment"> everyting in between. There might be more then one per string</span>
00727 <span class="comment"> like (params for a method call) */</span>
00728
00729 string = strchr(string, <span class="charliteral">'L'</span>);
00730 <span class="keywordflow">while</span> (string) {
00731 string++;
00732 <a class="code" href="javadeps_8c.html#a26">print_table_add</a>(<a class="code" href="javadeps_8c.html#a27">formatClassName</a>(string, <span class="charliteral">';'</span>, 0));
00733 string = strchr(string, <span class="charliteral">';'</span>);
00734 string = strchr(string, <span class="charliteral">'L'</span>);
00735 }
00736
00737 <span class="keywordflow">return</span> ;
00738 }
00739
00740
00741 <span class="comment">/* Print out the classes referenced in the symbol table */</span>
00742
00743 <span class="keywordtype">void</span>
<a name="l00744"></a><a class="code" href="javadeps_8c.html#a33">00744</a> <a class="code" href="javadeps_8c.html#a33">dumpRequires</a>(<a class="code" href="structsymbolTable__t.html">symbolTable_t</a> *symbolTable) {
00745 <span class="keywordtype">int</span> tem;
00746 <span class="keywordtype">int</span> ref = 0;
00747
00748 <span class="keywordflow">for</span>(tem=1; tem < symbolTable-><a class="code" href="structsymbolTable__t.html#m0">poolSize</a>; tem++ ) {
00749
00750 <span class="comment">/* dump all the classes in the const table. */</span>
00751 ref = symbolTable-><a class="code" href="structsymbolTable__t.html#m2">classRef</a>[tem];
00752 <span class="keywordflow">if</span>(ref) {
00753 <span class="keywordtype">char</span> *string = symbolTable-><a class="code" href="structsymbolTable__t.html#m1">stringList</a>[ref];
00754 <span class="keywordflow">if</span>( !*string ) {
00755 <a class="code" href="javadeps_8c.html#a19">die</a>(<span class="stringliteral">"class num: %d, referenced string num: %d, "</span>
00756 <span class="stringliteral">"which is null.\n"</span>,
00757 tem, ref);
00758 }
00759 <span class="keywordflow">if</span> ( string[0] == <span class="charliteral">'['</span> ) {
00760 <span class="comment">/*</span>
00761 <span class="comment"> This is an array. We need to ingore </span>
00762 <span class="comment"> strings like:</span>
00763 <span class="comment"> '[B'</span>
00764 <span class="comment"> '[[B'</span>
00765 <span class="comment"> '[[I'</span>
00766 <span class="comment"> </span>
00767 <span class="comment"> This hack leaves blank lines in the output </span>
00768 <span class="comment"> when a string not containing a class is</span>
00769 <span class="comment"> sent to dumpRefType.</span>
00770 <span class="comment"> */</span>
00771 string = strchr(string, <span class="charliteral">'L'</span>);
00772 <span class="keywordflow">if</span> (string) {
00773 <a class="code" href="javadeps_8c.html#a28">dumpRefType</a>(string);
00774 }
00775 } <span class="keywordflow">else</span> {
00776 <a class="code" href="javadeps_8c.html#a26">print_table_add</a>(<a class="code" href="javadeps_8c.html#a27">formatClassName</a>(string, <span class="charliteral">'\0'</span>, 0));
00777 }
00778 }
00779
00780 <span class="comment">/* dump all the references */</span>
00781 ref = symbolTable-><a class="code" href="structsymbolTable__t.html#m3">typeRef</a>[tem];
00782 <span class="keywordflow">if</span> (ref) {
00783 <span class="keywordtype">char</span> *string = symbolTable-><a class="code" href="structsymbolTable__t.html#m1">stringList</a>[ref];
00784 <span class="keywordflow">if</span> ( !*string ) {
00785 <a class="code" href="javadeps_8c.html#a19">die</a>(<span class="stringliteral">"type num: %d, referenced string num: %d, "</span>
00786 <span class="stringliteral">"which is null.\n"</span>,
00787 tem, ref);
00788 }
00789 <span class="comment">/* this is a java type... parse out the class names */</span>
00790 <a class="code" href="javadeps_8c.html#a28">dumpRefType</a>(string);
00791 }
00792
00793 } <span class="comment">/*end for*/</span>
00794
00795 <span class="keywordflow">return</span> ;
00796 }
00797
00798
00799 <span class="comment">/* Read a java class files symbol table into memory. </span>
00800 <span class="comment">*/</span>
00801
00802
<a name="l00803"></a><a class="code" href="javadeps_8c.html#a29">00803</a> <span class="keywordtype">void</span> <a class="code" href="javadeps_8c.html#a29">genSymbolTable</a> (FILE *fileHandle, <a class="code" href="structsymbolTable__t.html">symbolTable_t</a> *symbolTable)
00804 {
00805 <span class="keywordtype">char</span> ignore[10];
00806 <span class="keywordtype">int</span> i=0;
00807
00808
00809 <span class="comment">/* We are called just after fileHandle saw the magic number, seek a</span>
00810 <span class="comment"> few bytes in to find the poolsize */</span>
00811
00812 <a class="code" href="javadeps_8c.html#a20">my_fread</a>(&ignore, 4, 1, fileHandle);
00813
00814 <a class="code" href="javadeps_8c.html#a20">my_fread</a>(&(symbolTable-><a class="code" href="structsymbolTable__t.html#m0">poolSize</a>), 2, 1, fileHandle);
00815 symbolTable-><a class="code" href="structsymbolTable__t.html#m0">poolSize</a>=ntohs(symbolTable-><a class="code" href="structsymbolTable__t.html#m0">poolSize</a>);
00816
00817 <span class="comment">/* new the tables */</span>
00818
00819 symbolTable-><a class="code" href="structsymbolTable__t.html#m1">stringList</a> = (<span class="keywordtype">char</span>**) calloc(symbolTable-><a class="code" href="structsymbolTable__t.html#m0">poolSize</a>,
00820 <span class="keyword">sizeof</span>(<span class="keywordtype">char</span>*));
00821 <span class="keywordflow">if</span>(!symbolTable-><a class="code" href="structsymbolTable__t.html#m1">stringList</a>){
00822 <a class="code" href="javadeps_8c.html#a18">outofmemory</a>();
00823 }
00824
00825 symbolTable-><a class="code" href="structsymbolTable__t.html#m2">classRef</a> = (<span class="keywordtype">short</span>*) calloc(symbolTable-><a class="code" href="structsymbolTable__t.html#m0">poolSize</a>,
00826 <span class="keyword">sizeof</span>(<span class="keywordtype">short</span>*));
00827 <span class="keywordflow">if</span>(!symbolTable-><a class="code" href="structsymbolTable__t.html#m2">classRef</a>){
00828 <a class="code" href="javadeps_8c.html#a18">outofmemory</a>();
00829 }
00830
00831 symbolTable-><a class="code" href="structsymbolTable__t.html#m3">typeRef</a> = (<span class="keywordtype">short</span>*) calloc(symbolTable-><a class="code" href="structsymbolTable__t.html#m0">poolSize</a>,
00832 <span class="keyword">sizeof</span>(<span class="keywordtype">short</span>*));
00833 <span class="keywordflow">if</span>(!symbolTable-><a class="code" href="structsymbolTable__t.html#m3">typeRef</a>){
00834 <a class="code" href="javadeps_8c.html#a18">outofmemory</a>();
00835 }
00836
00837 <span class="comment">/* zero 'em all out. */</span>
00838 <span class="keywordflow">for</span>(i=0; i < symbolTable-><a class="code" href="structsymbolTable__t.html#m0">poolSize</a>; i++) {
00839 symbolTable-><a class="code" href="structsymbolTable__t.html#m1">stringList</a>[i] = NULL;
00840 symbolTable-><a class="code" href="structsymbolTable__t.html#m2">classRef</a>[i] = 0;
00841 symbolTable-><a class="code" href="structsymbolTable__t.html#m3">typeRef</a>[i] = 0;
00842 }
00843
00844
00845 <span class="comment">/* for the number of entries</span>
00846 <span class="comment"> (it starts at 1) </span>
00847 <span class="comment"> */</span>
00848
00849 <span class="keywordflow">for</span>(i=1; i < symbolTable-><a class="code" href="structsymbolTable__t.html#m0">poolSize</a>; i++) {
00850 <span class="keywordtype">unsigned</span> <span class="keywordtype">short</span> type = 0;
00851 <span class="keywordtype">unsigned</span> <span class="keywordtype">short</span> value = 0;
00852 <span class="keywordtype">unsigned</span> <span class="keywordtype">char</span> tag = 0;
00853
00854 <span class="comment">/* read the type of this entry */</span>
00855
00856 <a class="code" href="javadeps_8c.html#a20">my_fread</a>(&tag, 1, 1, fileHandle);
00857 <span class="keywordflow">switch</span>(tag) {
00858 <span class="keywordflow">case</span> 1: <span class="comment">/* master string pool. */</span>
00859 {
00860 <span class="comment">/* record all these strings */</span>
00861 <span class="keywordtype">char</span> *someString;
00862 <span class="keywordtype">unsigned</span> <span class="keywordtype">short</span> length = 0;
00863
00864 <span class="comment">/* I am not sure if these strings must be null</span>
00865 <span class="comment"> terminated. I termiante them to be safe. */</span>
00866
00867 <a class="code" href="javadeps_8c.html#a20">my_fread</a>(&length, 2, 1, fileHandle);
00868 length=ntohs(length);
00869
00870 someString = (<span class="keywordtype">char</span>*) malloc(length+1);
00871 <span class="keywordflow">if</span>(!someString){
00872 <a class="code" href="javadeps_8c.html#a18">outofmemory</a>();
00873 }
00874 <a class="code" href="javadeps_8c.html#a20">my_fread</a>(someString, length, 1, fileHandle);
00875 someString[length]=0;
00876 symbolTable-><a class="code" href="structsymbolTable__t.html#m1">stringList</a>[i] = someString;
00877
00878 <span class="keywordflow">if</span> (ARG_KEYWORDS) {
00879 <span class="keywordtype">char</span> *ptr=0;
00880
00881 <span class="comment">/* Each keyword can appear multiple times. Don't</span>
00882 <span class="comment"> bother with datastructures to store these strings,</span>
00883 <span class="comment"> if we need to print it print it now. */</span>
00884
00885 <span class="comment">/* it would be better if instead of printing the</span>
00886 <span class="comment"> strings "raw" I turn the space separated list</span>
00887 <span class="comment"> into a "\n" separated list*/</span>
00888
00889 <span class="keywordflow">if</span> (ARG_REQUIRES) {
00890 ptr = <a class="code" href="javadeps_8c.html#a22">is_lower_equal</a>(someString, <span class="stringliteral">"rpm_requires: "</span>);
00891 <span class="keywordflow">if</span>(ptr){
00892 <a class="code" href="javadeps_8c.html#a35">print_list</a>(ptr);
00893 }
00894 }
00895 <span class="keywordflow">if</span> (ARG_PROVIDES) {
00896 ptr = <a class="code" href="javadeps_8c.html#a22">is_lower_equal</a>(someString, <span class="stringliteral">"rpm_provides: "</span>);
00897 <span class="keywordflow">if</span>(ptr){
00898 <a class="code" href="javadeps_8c.html#a35">print_list</a>(ptr);
00899 }
00900 }
00901 <span class="comment">/* I wish there was a good way to handle this</span>
00902 <span class="comment"> ptr = is_lower_equal(someString, "rpm_conflicts: ");</span>
00903 <span class="comment"> */</span>
00904 ptr = <a class="code" href="javadeps_8c.html#a22">is_lower_equal</a>(someString, <span class="stringliteral">"$revision: "</span>);
00905 <span class="keywordflow">if</span>(ptr){
00906 <a class="code" href="javadeps_8c.html#a13">KEYWORD_REVISION</a>=ptr;
00907 <span class="comment">/* terminate the string before " $" */</span>
00908 ptr = strchr(<a class="code" href="javadeps_8c.html#a13">KEYWORD_REVISION</a>, <span class="charliteral">' '</span>);
00909 <span class="keywordflow">if</span> (ptr) {
00910 *ptr = 0;
00911 }
00912 }
00913 ptr = <a class="code" href="javadeps_8c.html#a22">is_lower_equal</a>(someString, <span class="stringliteral">"rpm_version: "</span>);
00914 <span class="keywordflow">if</span>(ptr){
00915 <a class="code" href="javadeps_8c.html#a12">KEYWORD_VERSION</a>=ptr;
00916 <span class="comment">/* terminate the string at first whitespace */</span>
00917 ptr = strchr(<a class="code" href="javadeps_8c.html#a12">KEYWORD_VERSION</a>, <span class="charliteral">' '</span>);
00918 <span class="keywordflow">if</span> (ptr) {
00919 *ptr = 0;
00920 }
00921 }
00922 ptr = <a class="code" href="javadeps_8c.html#a22">is_lower_equal</a>(someString, <span class="stringliteral">"rpm_epoch: "</span>);
00923 <span class="keywordflow">if</span>(ptr){
00924 <a class="code" href="javadeps_8c.html#a14">KEYWORD_EPOCH</a>=ptr;
00925 <span class="comment">/* terminate the string at first whitespace */</span>
00926 ptr = strchr(<a class="code" href="javadeps_8c.html#a14">KEYWORD_EPOCH</a>, <span class="charliteral">' '</span>);
00927 <span class="keywordflow">if</span> (ptr) {
00928 *ptr = 0;
00929 }
00930 }
00931 }
00932 <span class="keywordflow">break</span>;
00933 }
00934 <span class="keywordflow">case</span> 2: <span class="comment">/* unknow type!! */</span>
00935 <a class="code" href="javadeps_8c.html#a19">die</a>(<span class="stringliteral">"Unknown type in constant table. "</span>
00936 <span class="stringliteral">"Entry: %d. \n"</span>, i);
00937 <span class="keywordflow">break</span>;
00938 <span class="keywordflow">case</span> 3: <span class="comment">/* int */</span>
00939 <a class="code" href="javadeps_8c.html#a20">my_fread</a>(&ignore, 4, 1, fileHandle);
00940 <span class="keywordflow">break</span>;
00941 <span class="keywordflow">case</span> 4: <span class="comment">/* float */</span>
00942 <a class="code" href="javadeps_8c.html#a20">my_fread</a>(&ignore, 4, 1, fileHandle);
00943 <span class="keywordflow">break</span>;
00944 <span class="keywordflow">case</span> 5: <span class="comment">/* long (counts as 2) */</span>
00945 <a class="code" href="javadeps_8c.html#a20">my_fread</a>(&ignore, 8, 1, fileHandle);
00946 i++;
00947 <span class="keywordflow">break</span>;
00948 <span class="keywordflow">case</span> 6: <span class="comment">/* double (counts as 2) */</span>
00949 <a class="code" href="javadeps_8c.html#a20">my_fread</a>(&ignore, 8, 1, fileHandle);
00950 i++;
00951 <span class="keywordflow">break</span>;
00952 <span class="keywordflow">case</span> 7: <span class="comment">/* Class */</span>
00953 <a class="code" href="javadeps_8c.html#a20">my_fread</a>(&value, 2, 1, fileHandle);
00954 symbolTable-><a class="code" href="structsymbolTable__t.html#m2">classRef</a>[i]=ntohs(value);
00955 <span class="comment">/* record which const it's referencing */</span>
00956 <a class="code" href="javadeps_8c.html#a21">check_range</a>(i, symbolTable-><a class="code" href="structsymbolTable__t.html#m2">classRef</a>[i], symbolTable-><a class="code" href="structsymbolTable__t.html#m0">poolSize</a>);
00957 <span class="keywordflow">break</span>;
00958 <span class="keywordflow">case</span> 8: <span class="comment">/* String */</span>
00959 <a class="code" href="javadeps_8c.html#a20">my_fread</a>(&ignore, 2, 1, fileHandle);
00960 <span class="keywordflow">break</span>;
00961 <span class="keywordflow">case</span> 9: <span class="comment">/* field reference */</span>
00962 <a class="code" href="javadeps_8c.html#a20">my_fread</a>(&ignore, 4, 1, fileHandle);
00963 <span class="keywordflow">break</span>;
00964 <span class="keywordflow">case</span> 10: <span class="comment">/* method reference */</span>
00965 <a class="code" href="javadeps_8c.html#a20">my_fread</a>(&ignore, 4, 1, fileHandle);
00966 <span class="keywordflow">break</span>;
00967 <span class="keywordflow">case</span> 11: <span class="comment">/* interface method reference */</span>
00968 <a class="code" href="javadeps_8c.html#a20">my_fread</a>(&ignore, 4, 1, fileHandle);
00969 <span class="keywordflow">break</span>;
00970 <span class="keywordflow">case</span> 12: <span class="comment">/* constant name/type */</span>
00971 <a class="code" href="javadeps_8c.html#a20">my_fread</a>(&ignore, 2, 1, fileHandle);
00972 <a class="code" href="javadeps_8c.html#a20">my_fread</a>(&type, 2, 1, fileHandle);
00973 symbolTable-><a class="code" href="structsymbolTable__t.html#m3">typeRef</a>[i]=ntohs(type);
00974 <span class="comment">/* record the name, and the type it's referencing. */</span>
00975 <a class="code" href="javadeps_8c.html#a21">check_range</a>(i, symbolTable-><a class="code" href="structsymbolTable__t.html#m3">typeRef</a>[i], symbolTable-><a class="code" href="structsymbolTable__t.html#m0">poolSize</a>);
00976 <span class="keywordflow">break</span>;
00977 <span class="keywordflow">default</span>:
00978 <a class="code" href="javadeps_8c.html#a19">die</a>(<span class="stringliteral">"Unknown tag type: %d.\n"</span>,
00979 <span class="stringliteral">"Entry: %d. \n"</span>, tag, i);
00980 <span class="keywordflow">break</span>;
00981 }
00982 }
00983
00984 <span class="keywordflow">return</span> ;
00985 }
00986
00987
00988 <span class="comment">/* Find the proper name of the current Java Class file and return a</span>
00989 <span class="comment"> formatted of the name. </span>
00990 <span class="comment">*/</span>
00991
00992 <span class="keywordtype">char</span>*
<a name="l00993"></a><a class="code" href="javadeps_8c.html#a31">00993</a> <a class="code" href="javadeps_8c.html#a31">findClassName</a> (FILE *fileHandle, <a class="code" href="structsymbolTable__t.html">symbolTable_t</a> *symbolTable) {
00994 <span class="keywordtype">char</span> ignore[10];
00995 <span class="keywordtype">unsigned</span> <span class="keywordtype">short</span> type = 0;
00996 <span class="keywordtype">unsigned</span> <span class="keywordtype">short</span> <span class="keyword">class </span>= 0;
00997 <span class="keywordtype">char</span> *className;
00998
00999 <span class="comment">/* seek a little past the end of the table */</span>
01000
01001 <a class="code" href="javadeps_8c.html#a20">my_fread</a>(&ignore, 2, 1, fileHandle);
01002
01003 <span class="comment">/* read the name of this classfile */</span>
01004
01005 <a class="code" href="javadeps_8c.html#a20">my_fread</a>(&type, 2, 1, fileHandle);
01006 type=ntohs(type);
01007 <span class="keyword">class </span>= symbolTable->classRef[type];
01008 <span class="keywordflow">if</span>( !<span class="keyword">class </span>||
01009 !symbolTable->stringList[class] ) {
01010 <a class="code" href="javadeps_8c.html#a19">die</a>(<span class="stringliteral">"Couln't find class: %d, provided by file.\n"</span>, <span class="keyword">class</span>);
01011 }
01012
01013 className=symbolTable-><a class="code" href="structsymbolTable__t.html#m1">stringList</a>[<span class="keyword">class</span>];
01014
01015 <span class="keywordflow">return</span> className;
01016
01017 }
01018
01019
01020 <span class="comment">/* Print the name of the class that we have found and whos symbol</span>
01021 <span class="comment"> table is loaded into memory.</span>
01022 <span class="comment"></span>
01023 <span class="comment"> The name may need to have the version number printed after it, if</span>
01024 <span class="comment"> there are keywords in the symbol table. </span>
01025 <span class="comment"></span>
01026 <span class="comment"> Additionally the class name may need to be printed twice, once with</span>
01027 <span class="comment"> the regular name of the class and once with the leaf class replaced</span>
01028 <span class="comment"> with a star.</span>
01029 <span class="comment"></span>
01030 <span class="comment">*/</span>
01031
01032 <span class="keywordtype">void</span>
<a name="l01033"></a><a class="code" href="javadeps_8c.html#a32">01033</a> <a class="code" href="javadeps_8c.html#a32">dumpProvides</a>(<span class="keywordtype">char</span> *className) {
01034 <span class="keywordtype">char</span> *out_string;
01035 <span class="preprocessor">#ifdef UNUSED</span>
01036 <span class="preprocessor"></span> <span class="keywordtype">char</span> *formattedClassName;
01037 <span class="keywordtype">char</span> *newline;
01038 <span class="preprocessor">#endif</span>
01039 <span class="preprocessor"></span>
01040 <span class="comment">/* Provide the star version of this class for jhtml</span>
01041 <span class="comment"> dependencies. This option is deprecated since jhtml is</span>
01042 <span class="comment"> deprecated. */</span>
01043
01044 <span class="keywordflow">if</span> (ARG_STARPROV) {
01045 <a class="code" href="javadeps_8c.html#a26">print_table_add</a>(<a class="code" href="javadeps_8c.html#a27">formatClassName</a>(className, <span class="charliteral">'\0'</span>, 1));
01046 }
01047
01048 <span class="comment">/* If we have information about the version number of this class</span>
01049 <span class="comment"> then add it to the formatted name and print this as well. */</span>
01050
01051 out_string = <a class="code" href="javadeps_8c.html#a27">formatClassName</a>(className, <span class="charliteral">'\0'</span>, 0);
01052
01053 {
01054 <span class="keywordtype">int</span> len = 10;
01055
01056 <span class="keywordflow">if</span> (out_string) {
01057 len += strlen(out_string);
01058 }
01059 <span class="keywordflow">if</span> (KEYWORD_EPOCH) {
01060 len += strlen(<a class="code" href="javadeps_8c.html#a14">KEYWORD_EPOCH</a>);
01061 }
01062 <span class="keywordflow">if</span> (KEYWORD_VERSION) {
01063 len += strlen(<a class="code" href="javadeps_8c.html#a12">KEYWORD_VERSION</a>);
01064 }
01065 <span class="keywordflow">if</span> (KEYWORD_REVISION) {
01066 len += strlen(<a class="code" href="javadeps_8c.html#a13">KEYWORD_REVISION</a>);
01067 }
01068
01069 out_string = realloc(out_string, len );
01070 <span class="keywordflow">if</span> (!out_string){
01071 <a class="code" href="javadeps_8c.html#a18">outofmemory</a>();
01072 }
01073
01074 }
01075
01076 <span class="keywordflow">if</span>( <a class="code" href="javadeps_8c.html#a12">KEYWORD_VERSION</a> || <a class="code" href="javadeps_8c.html#a13">KEYWORD_REVISION</a> ){
01077 <span class="comment">/* It is easier to remove the extra new line here in one place</span>
01078 <span class="comment"> then to try and add a newline every where that formatClassName</span>
01079 <span class="comment"> is called */</span>
01080 <span class="keywordtype">char</span> *newline;
01081
01082 <span class="comment">/* I am not using rpm 3.0 yet so I need both the dependencies with</span>
01083 <span class="comment"> and without the version numbers, when I upgrade I will remove</span>
01084 <span class="comment"> this block (with copy_string) and change the "=" to " = " ten</span>
01085 <span class="comment"> lines down.*/</span>
01086 {
01087 <span class="keywordtype">char</span> *copy_string;
01088 copy_string = (<span class="keywordtype">char</span>*) malloc(strlen(out_string)+1);
01089 <span class="keywordflow">if</span> (!copy_string){
01090 <a class="code" href="javadeps_8c.html#a18">outofmemory</a>();
01091 }
01092 copy_string = strcpy(copy_string, out_string);
01093 <a class="code" href="javadeps_8c.html#a26">print_table_add</a>(copy_string);
01094 }
01095
01096 newline = strrchr(out_string, <span class="charliteral">'\n'</span>);
01097 <span class="keywordflow">if</span> (newline) {
01098 newline[0] = <span class="charliteral">'\0'</span>;
01099 }
01100 strcat(out_string, <span class="stringliteral">" = "</span>);
01101 <span class="keywordflow">if</span>(KEYWORD_EPOCH){
01102 strcat(out_string, <a class="code" href="javadeps_8c.html#a14">KEYWORD_EPOCH</a>);
01103 strcat(out_string, <span class="stringliteral">":"</span>);
01104 }
01105 <span class="keywordflow">if</span>(KEYWORD_VERSION){
01106 strcat(out_string, <a class="code" href="javadeps_8c.html#a12">KEYWORD_VERSION</a>);
01107 } <span class="keywordflow">else</span> {
01108 strcat(out_string, <a class="code" href="javadeps_8c.html#a13">KEYWORD_REVISION</a>);
01109 }
01110 strcat(out_string, <span class="stringliteral">"\n"</span>);
01111 }
01112
01113 <a class="code" href="javadeps_8c.html#a26">print_table_add</a>(out_string);
01114 out_string=NULL;
01115
01116 <span class="keywordflow">return</span> ;
01117 }
01118
01119
01120
01121
01122
<a name="l01123"></a><a class="code" href="javadeps_8c.html#a30">01123</a> <span class="keywordtype">void</span> <a class="code" href="javadeps_8c.html#a30">freeSymbolTable</a> (<a class="code" href="structsymbolTable__t.html">symbolTable_t</a> *symbolTable)
01124 {
01125 <span class="keywordtype">int</span> i=0;
01126
01127 <span class="keywordflow">for</span>(i=1; i < symbolTable-><a class="code" href="structsymbolTable__t.html#m0">poolSize</a>; i++) {
01128 <span class="keywordflow">if</span>( symbolTable-><a class="code" href="structsymbolTable__t.html#m1">stringList</a>[i] ) {
01129 free(symbolTable-><a class="code" href="structsymbolTable__t.html#m1">stringList</a>[i]);
01130 symbolTable-><a class="code" href="structsymbolTable__t.html#m1">stringList</a>[i] = 0;
01131 }
01132 }
01133
01134 free(symbolTable-><a class="code" href="structsymbolTable__t.html#m1">stringList</a>);
01135 symbolTable-><a class="code" href="structsymbolTable__t.html#m1">stringList</a>=0;
01136
01137 free(symbolTable-><a class="code" href="structsymbolTable__t.html#m2">classRef</a>);
01138 symbolTable-><a class="code" href="structsymbolTable__t.html#m2">classRef</a>=0;
01139
01140 free(symbolTable-><a class="code" href="structsymbolTable__t.html#m3">typeRef</a>);
01141 symbolTable-><a class="code" href="structsymbolTable__t.html#m3">typeRef</a>=0;
01142
01143 <span class="keywordflow">return</span> ;
01144 }
01145
01146
01147 <span class="comment">/* Process each file.</span>
01148 <span class="comment"> This procedure must be called directly after finding </span>
01149 <span class="comment"> the magic number.</span>
01150 <span class="comment">*/</span>
01151
<a name="l01152"></a><a class="code" href="javadeps_8c.html#a34">01152</a> <span class="keywordtype">void</span> <a class="code" href="javadeps_8c.html#a34">processJavaFile</a> (FILE *fileHandle) {
01153 <a class="code" href="structsymbolTable__t.html">symbolTable_t</a> symbolTable= {0};
01154 <span class="keywordtype">char</span> *format_class_name;
01155
01156 <a class="code" href="javadeps_8c.html#a29">genSymbolTable</a>(fileHandle, &symbolTable);
01157 <a class="code" href="javadeps_8c.html#a4">CLASS_NAME</a>=<a class="code" href="javadeps_8c.html#a31">findClassName</a>(fileHandle, &symbolTable);
01158
01159 <span class="keywordflow">if</span>(ARG_DEPSFORMAT) {
01160 <span class="keywordtype">char</span> *prefix_seperator = <span class="stringliteral">": "</span>;
01161
01162 format_class_name = <a class="code" href="javadeps_8c.html#a27">formatClassName</a>(<a class="code" href="javadeps_8c.html#a4">CLASS_NAME</a>, <span class="charliteral">'\0'</span>, 0);
01163
01164 <a class="code" href="javadeps_8c.html#a5">OUTPUT_PREFIX</a> = (<span class="keywordtype">char</span>*) malloc(strlen(format_class_name)+
01165 strlen(prefix_seperator)+1);
01166 <span class="keywordflow">if</span> (!<a class="code" href="javadeps_8c.html#a5">OUTPUT_PREFIX</a>){
01167 <a class="code" href="javadeps_8c.html#a18">outofmemory</a>();
01168 }
01169 <a class="code" href="javadeps_8c.html#a5">OUTPUT_PREFIX</a> = strcpy(<a class="code" href="javadeps_8c.html#a5">OUTPUT_PREFIX</a>, format_class_name);
01170 strcat(<a class="code" href="javadeps_8c.html#a5">OUTPUT_PREFIX</a>, prefix_seperator);
01171 }
01172
01173 <span class="keywordflow">if</span>(ARG_PROVIDES) {
01174 <a class="code" href="javadeps_8c.html#a32">dumpProvides</a>(<a class="code" href="javadeps_8c.html#a4">CLASS_NAME</a>);
01175 }
01176 <span class="keywordflow">if</span>(ARG_REQUIRES) {
01177 <a class="code" href="javadeps_8c.html#a33">dumpRequires</a>(&symbolTable);
01178 }
01179
01180 free(<a class="code" href="javadeps_8c.html#a5">OUTPUT_PREFIX</a>);
01181 <a class="code" href="javadeps_8c.html#a5">OUTPUT_PREFIX</a> = 0;
01182 <a class="code" href="javadeps_8c.html#a30">freeSymbolTable</a>(&symbolTable);
01183
01184 <span class="keywordflow">return</span> ;
01185
01186 }
01187
01188
01189 <span class="keywordtype">int</span>
<a name="l01190"></a><a class="code" href="javadeps_8c.html#a36">01190</a> <a class="code" href="rpmsignature_8c.html#a0">main</a>(<span class="keywordtype">int</span> argc, <span class="keywordtype">char</span> **argv)
01191 {
01192 FILE *fileHandle;
01193 <span class="keywordtype">int</span> i = 0;
01194 <span class="keywordtype">int</span> rc = 0;
01195 <span class="keywordtype">int</span> foundMagic=0;
01196
01197 <a class="code" href="javadeps_8c.html#a2">PROGRAM_NAME</a>=argv[0];
01198
01199 <span class="keywordflow">if</span>(argv[1] == NULL) {
01200 <a class="code" href="javadeps_8c.html#a17">usage</a>();
01201 }
01202
01203 <span class="comment">/* parse arguments which are not filenames*/</span>
01204
01205 <span class="keywordflow">for</span> (i = 1; argv[i] != NULL; i++) {
01206
01207 <span class="keywordflow">if</span> (0) {
01208 <span class="comment">/* </span>
01209 <span class="comment"> First entry a dummy to get the </span>
01210 <span class="comment"> other entries to align correctly</span>
01211 <span class="comment"> */</span>
01212 ;
01213 } <span class="keywordflow">else</span> <span class="keywordflow">if</span> ( !strcmp(<span class="stringliteral">"-p"</span>,argv[i]) || !strcmp(<span class="stringliteral">"--provides"</span>,argv[i]) ) {
01214 <a class="code" href="javadeps_8c.html#a6">ARG_PROVIDES</a> = 1;
01215 } <span class="keywordflow">else</span> <span class="keywordflow">if</span> ( !strcmp(<span class="stringliteral">"-r"</span>,argv[i]) || !strcmp(<span class="stringliteral">"--requires"</span>,argv[i]) ) {
01216 <a class="code" href="javadeps_8c.html#a7">ARG_REQUIRES</a> = 1;
01217 } <span class="keywordflow">else</span> <span class="keywordflow">if</span> ( !strcmp(<span class="stringliteral">"-h"</span>,argv[i]) || !strcmp(<span class="stringliteral">"--help"</span>,argv[i]) ||
01218 !strcmp(<span class="stringliteral">"-?"</span>,argv[i]) ) {
01219
01220 <a class="code" href="javadeps_8c.html#a17">usage</a>();
01221 } <span class="keywordflow">else</span> <span class="keywordflow">if</span> ( !strcmp(<span class="stringliteral">"-F"</span>,argv[i]) || !strcmp(<span class="stringliteral">"--rpmformat"</span>,argv[i]) ) {
01222 <a class="code" href="javadeps_8c.html#a8">ARG_RPMFORMAT</a>=1;
01223 } <span class="keywordflow">else</span> <span class="keywordflow">if</span> ( !strcmp(<span class="stringliteral">"-d"</span>,argv[i]) || !strcmp(<span class="stringliteral">"--depsformat"</span>,argv[i]) ) {
01224 <a class="code" href="javadeps_8c.html#a9">ARG_DEPSFORMAT</a>=1;
01225 } <span class="keywordflow">else</span> <span class="keywordflow">if</span> ( !strcmp(<span class="stringliteral">"-k"</span>,argv[i]) || !strcmp(<span class="stringliteral">"--keywords"</span>,argv[i]) ) {
01226 <a class="code" href="javadeps_8c.html#a10">ARG_KEYWORDS</a>=1;
01227 } <span class="keywordflow">else</span> <span class="keywordflow">if</span> ( !strcmp(<span class="stringliteral">"-s"</span>,argv[i]) || !strcmp(<span class="stringliteral">"--starprov"</span>,argv[i]) ) {
01228 <a class="code" href="javadeps_8c.html#a11">ARG_STARPROV</a>=1;
01229 } <span class="keywordflow">else</span> <span class="keywordflow">if</span> ( !strcmp(<span class="stringliteral">"--"</span>,argv[i]) ) {
01230 i++;
01231 <span class="keywordflow">break</span>;
01232 } <span class="keywordflow">else</span> {
01233 <span class="comment">/* we do not recognize the argument, must be a filename*/</span>
01234 <span class="keywordflow">break</span>;
01235 }
01236 } <span class="comment">/*end for arguments which are not filenames*/</span>
01237
01238 <span class="comment">/* check arguments for consistancy */</span>
01239
01240 <span class="keywordflow">if</span> ( !<a class="code" href="javadeps_8c.html#a6">ARG_PROVIDES</a> && !<a class="code" href="javadeps_8c.html#a7">ARG_REQUIRES</a> ) {
01241 <a class="code" href="javadeps_8c.html#a19">die</a> (<span class="stringliteral">"Must specify either --provides or --requires.\n"</span>);
01242 }
01243
01244 <span class="keywordflow">if</span> ( <a class="code" href="javadeps_8c.html#a6">ARG_PROVIDES</a> && <a class="code" href="javadeps_8c.html#a7">ARG_REQUIRES</a> ) {
01245 <a class="code" href="javadeps_8c.html#a19">die</a> (<span class="stringliteral">"Can not specify both --provides and --requires.\n"</span>);
01246 }
01247
01248 <span class="keywordflow">if</span> ( <a class="code" href="javadeps_8c.html#a7">ARG_REQUIRES</a> && <a class="code" href="javadeps_8c.html#a11">ARG_STARPROV</a>) {
01249 <a class="code" href="javadeps_8c.html#a19">die</a> (<span class="stringliteral">"Can not specify both --requires and --starpov.\n"</span>);
01250 }
01251
01252 <span class="keywordflow">if</span>(argv[i] == NULL) {
01253 <a class="code" href="javadeps_8c.html#a19">die</a> (<span class="stringliteral">"Must specify Java class files.\n"</span>);
01254 }
01255
01256 <span class="comment">/* parse arguments which are filenames. */</span>
01257
01258 <span class="keywordflow">for</span> ( <span class="comment">/*null initializer*/</span>; argv[i] != NULL; i++) {
01259
01260 <span class="comment">/*open the correct file and process it*/</span>
01261
01262 <span class="keywordflow">if</span> ( !strcmp(<span class="stringliteral">"-"</span>, argv[i]) ) {
01263 <span class="comment">/* use stdin, might be a jar file */</span>
01264 fileHandle = stdin;
01265 <a class="code" href="javadeps_8c.html#a3">FILE_NAME</a> = <span class="stringliteral">"<stdin>"</span>;
01266
01267 foundMagic = <a class="code" href="javadeps_8c.html#a23">findJavaMagic</a>(fileHandle);
01268 <span class="keywordflow">while</span> (foundMagic) {
01269 <a class="code" href="javadeps_8c.html#a34">processJavaFile</a>(fileHandle);
01270 foundMagic = <a class="code" href="javadeps_8c.html#a23">findJavaMagic</a>(fileHandle);
01271 }
01272 } <span class="keywordflow">else</span> {
01273 <span class="comment">/* Open a disk file*/</span>
01274 fileHandle = fopen(argv[i], <span class="stringliteral">"r"</span>);
01275 <span class="keywordflow">if</span>( fileHandle == 0 ) {
01276 <a class="code" href="javadeps_8c.html#a19">die</a> (<span class="stringliteral">"Could not open file: %s.\n"</span>, argv[i]);
01277 }
01278 fileHandle = fileHandle;
01279 <a class="code" href="javadeps_8c.html#a3">FILE_NAME</a> = argv[i];
01280
01281 foundMagic = <a class="code" href="javadeps_8c.html#a23">findJavaMagic</a>(fileHandle);
01282 <span class="keywordflow">if</span> (foundMagic) {
01283 <a class="code" href="javadeps_8c.html#a34">processJavaFile</a>(fileHandle);
01284 }
01285 }
01286
01287 rc = fclose(fileHandle);
01288 <span class="keywordflow">if</span>( rc ) {
01289 <a class="code" href="javadeps_8c.html#a19">die</a> (<span class="stringliteral">"Could not close file: %s.\n"</span>, <a class="code" href="javadeps_8c.html#a3">FILE_NAME</a>);
01290 }
01291 <a class="code" href="javadeps_8c.html#a4">CLASS_NAME</a>=0;
01292 } <span class="comment">/*end parsing arguments which are filenames*/</span>
01293
01294 <a class="code" href="javadeps_8c.html#a25">print_table_flush</a>();
01295 <span class="keywordflow">return</span> 0;
01296 }
</pre></div><hr><address style="align: right;"><small>Generated on Thu Sep 12 22:15:02 2002 for rpm by
<a href="http://www.doxygen.org/index.html">
<img src="doxygen.png" alt="doxygen" align="middle" border=0
width=110 height=53></a>1.2.17 </small></address>
</body>
</html>
