Main Page   Alphabetical List   Compound List   File List   Compound Members   File Members  

sRefSet.c File Reference

#include "lclintMacros.nf"
#include "basic.h"

Go to the source code of this file.

Functions

sRefSet sRefSet_new ()
sRefSet sRefSet_single ( sRef sr)
sRefSet sRefSet_insert (sRefSet s, sRef el)
void sRefSet_clear (sRefSet s)
void sRefSet_clearStatics (sRefSet s)
bool sRefSet_delete (sRefSet s, sRef el)
sRef sRefSet_choose (sRefSet s)
sRef sRefSet_mergeIntoOne (sRefSet s)
bool sRefSet_deleteBase (sRefSet s, sRef base)
sRefSet sRefSet_unionFree ( sRefSet s1, sRefSet s2)
sRefSet sRefSet_union ( sRefSet s1, sRefSet s2)
sRefSet sRefSet_unionExcept ( sRefSet s1, sRefSet s2, sRef ex)
sRefSet sRefSet_realNewUnion (sRefSet s1, sRefSet s2)
sRefSet sRefSet_intersect (sRefSet s1, sRefSet s2)
sRefSet sRefSet_levelUnion ( sRefSet sr, sRefSet s, int lexlevel)
void sRefSet_levelPrune (sRefSet s, int lexlevel)
sRefSet sRefSet_copy ( sRefSet s1, sRefSet s2)
sRefSet sRefSet_newCopy ( sRefSet s)
sRefSet sRefSet_levelCopy ( sRefSet s, int lexlevel)
sRefSet sRefSet_newDeepCopy (sRefSet s)
bool sRefSet_hasRealElement (sRefSet s)
bool sRefSet_isSameMember (sRefSet s, sRef el)
bool sRefSet_isSameNameMember (sRefSet s, sRef el)
bool sRefSet_member (sRefSet s, sRef el)
bool sRefSet_hasStatic (sRefSet s)
bool sRefSet_hasUnconstrained (sRefSet s)
cstring sRefSet_unparseUnconstrained (sRefSet s)
cstring sRefSet_unparseUnconstrainedPlain (sRefSet s)
bool sRefSet_modifyMember (sRefSet s, sRef m)
sRef sRefSet_lookupMember (sRefSet s, sRef el)
int sRefSet_size (sRefSet s)
cstring sRefSet_unparse (sRefSet s)
cstring sRefSet_unparsePlain (sRefSet s)
cstring sRefSet_unparseDebug (sRefSet s)
void sRefSet_fixSrefs (sRefSet s)
void sRefSet_free ( sRefSet s)
sRefSet sRefSet_removeIndirection (sRefSet s)
sRefSet sRefSet_addIndirection (sRefSet s)
sRefSet sRefSet_accessField (sRefSet s, cstring f)
sRefSet sRefSet_fetchUnknown (sRefSet s)
sRefSet sRefSet_fetchKnown (sRefSet s, int i)
int sRefSet_compare (sRefSet s1, sRefSet s2)
bool sRefSet_equal (sRefSet s1, sRefSet s2)
sRefSet sRefSet_undump (char **s)
cstring sRefSet_dump (sRefSet sl)

Function Documentation

sRefSet sRefSet_accessField ( sRefSet s,
cstring f )
 

Definition at line 856 of file sRefSet.c.

00857 {
00858   /*
00859   ** returns a NEW sRefSet containing references to all sRef's in s
00860   */
00861 
00862   sRefSet t = sRefSet_new ();
00863 
00864   
00865   sRefSet_allElements (s, el)
00866     {
00867       ctype ct = ctype_realType (sRef_getType (el));
00868 
00869       if ((ctype_isStruct (ct) || ctype_isUnion (ct))
00870           && (!uentry_isUndefined (uentryList_lookupField (ctype_getFields (ct), f))))
00871         {
00872           t = sRefSet_insert (t, sRef_makeNCField (el, f));
00873         }
00874     } end_sRefSet_allElements;
00875   
00876     return t;
00877 }

sRefSet sRefSet_addIndirection ( sRefSet s )
 

Definition at line 830 of file sRefSet.c.

00831 {
00832   /*
00833   ** returns a NEW sRefSet containing references to all sRef's in s
00834   */
00835 
00836   sRefSet t = sRefSet_new ();
00837   
00838   
00839   sRefSet_allElements (s, el)
00840     {
00841       ctype ct = ctype_realType (sRef_getType (el));
00842 
00843       
00844       if ((ctype_isArrayPtr (ct)))
00845         {
00846           
00847           sRef a = sRef_constructPointer (el);
00848 
00849           t = sRefSet_insert (t, a);   
00850         }
00851     } end_sRefSet_allElements;
00852 
00853     return t;
00854 }

sRef sRefSet_choose ( sRefSet s )
 

Definition at line 188 of file sRefSet.c.

Referenced by uentry_returnedRef().

00189 {
00190   llassert (sRefSet_isDefined (s));
00191   llassert (s->entries > 0);
00192   llassert (s->elements != NULL);
00193 
00194   return (s->elements[0]);
00195 }

void sRefSet_clear ( sRefSet s )
 

Definition at line 114 of file sRefSet.c.

Referenced by globSet_clear(), sRef_clearDerived(), and sRef_clearDerivedComplete().

00115 {
00116   if (sRefSet_isDefined (s))
00117     {
00118       s->nspace += s->entries;
00119       s->entries = 0;
00120     }
00121 }

void sRefSet_clearStatics ( sRefSet s )
 

Definition at line 128 of file sRefSet.c.

Referenced by context_exitFile().

00129 {
00130   if (sRefSet_isDefined (s))
00131     {
00132       int i;
00133 
00134       for (i = 0; i < s->entries; i++)
00135         {
00136           sRef current = s->elements[i];
00137           
00138           if (sRef_isFileStatic (sRef_getRootBase (current)))
00139             {
00140               int j;
00141               
00142               for (j = i; j < s->entries - 1; j++)
00143                 {
00144                   s->elements[j] = s->elements[j+1];
00145                 }
00146               
00147               s->entries--;
00148               s->nspace++;
00149               i--;
00150             }
00151         }
00152     }
00153 }

int sRefSet_compare ( sRefSet s1,
sRefSet s2 )
 

Definition at line 913 of file sRefSet.c.

Referenced by globSet_compare(), and uentry_compare().

00914 {
00915   sRefSet_allElements (s1, el)
00916     {
00917       if (!sRefSet_isSameMember (s2, el))
00918         {
00919           return -1;
00920         }
00921     } end_sRefSet_allElements;
00922 
00923   sRefSet_allElements (s2, el)
00924     {
00925       if (!sRefSet_isSameMember (s1, el))
00926         {
00927           return 1;
00928         }
00929     } end_sRefSet_allElements;
00930 
00931   return 0;
00932 }

sRefSet sRefSet_copy ( sRefSet s1,
sRefSet s2 )
 

Definition at line 425 of file sRefSet.c.

Referenced by exprNode_doWhile(), exprNode_for(), globSet_copy(), and sRefSet_union().

00426 {
00427   int origentries;
00428   
00429   llassert (NOALIAS (s1, s2));
00430   
00431   if (sRefSet_isUndefined (s1))
00432     {
00433       if (sRefSet_isEmpty (s2))
00434         {
00435           return s1;
00436         }
00437       else
00438         {
00439           s1 = sRefSet_newEmpty ();
00440         }
00441     } 
00442 
00443   origentries = s1->entries;
00444 
00445   s1->nspace = s1->entries + s1->nspace;
00446   s1->entries = 0;
00447 
00448   sRefSet_allElements (s2, el)
00449     {
00450       if (s1->nspace == 0)
00451         {
00452           sRefSet_grow (s1);
00453         }
00454 
00455       s1->elements[s1->entries] = el; 
00456       s1->nspace--;
00457       s1->entries++;
00458     } end_sRefSet_allElements;
00459 
00460   return s1;
00461 }

bool sRefSet_delete ( sRefSet s,
sRef el )
 

Definition at line 156 of file sRefSet.c.

Referenced by guardSet_delete().

00157 {
00158   int i;
00159 
00160   if (sRefSet_isUndefined (s)) return FALSE;
00161 
00162   if (s->elements != NULL)
00163     {
00164       for (i = 0; i < s->entries; i++)
00165         {
00166           sRef current = s->elements[i];
00167           
00168           if (sRef_realSame (el, current))
00169             {
00170               int j;
00171 
00172               for (j = i; j < s->entries - 1; j++)
00173                 {
00174                   s->elements[j] = s->elements[j+1];
00175                 }
00176               
00177               s->entries--;
00178               s->nspace++;
00179               return TRUE;
00180             }
00181         }
00182     }
00183 
00184   return FALSE;
00185 }

bool sRefSet_deleteBase ( sRefSet s,
sRef base )
 

Definition at line 226 of file sRefSet.c.

00227 {
00228   int i = 0;
00229   int offset = 0;
00230 
00231   if (sRefSet_isUndefined (s) || (s->elements == NULL))
00232     {
00233       return FALSE;
00234     } ;
00235 
00236   while (i + offset < s->entries)
00237     {
00238       sRef current = s->elements[i + offset];
00239 
00240       while (sRef_includedBy (current, base))
00241         {
00242                   offset++;
00243           if (i + offset >= s->entries) goto doneLoop;
00244           current = s->elements [i + offset];
00245         }
00246       
00247       if (offset > 0)
00248         {
00249                   s->elements [i] = current;
00250         }
00251       
00252       i++;
00253     }
00254 
00255  doneLoop:
00256   s->entries -= offset;
00257   s->nspace += offset;
00258 
00259   return (offset > 0);
00260 }

cstring sRefSet_dump ( sRefSet sl )
 

Definition at line 976 of file sRefSet.c.

00977 {
00978   cstring st = cstring_undefined;
00979   bool first = TRUE;
00980 
00981   
00982   sRefSet_allElements (sl, el)
00983     {
00984       if (!first)
00985         {
00986           st = cstring_appendChar (st, ',');
00987         }
00988       else
00989         {
00990           first = FALSE;
00991         }
00992 
00993       st = cstring_concatFree (st, sRef_dump (el));
00994     } end_sRefSet_allElements;
00995 
00996   return st;
00997 }

bool sRefSet_equal ( sRefSet s1,
sRefSet s2 )
 

Definition at line 934 of file sRefSet.c.

Referenced by specialClauses_checkEqual().

00935 {
00936   sRefSet_allElements (s1, el)
00937     {
00938       if (!sRefSet_isSameMember (s2, el))
00939         {
00940           return FALSE;
00941         }
00942     } end_sRefSet_allElements;
00943 
00944   sRefSet_allElements (s2, el)
00945     {
00946       if (!sRefSet_isSameMember (s1, el))
00947         {
00948           return FALSE;
00949         }
00950     } end_sRefSet_allElements;
00951 
00952   return TRUE;
00953 }

sRefSet sRefSet_fetchKnown ( sRefSet s,
int i )
 

Definition at line 896 of file sRefSet.c.

00897 {
00898   sRefSet t = sRefSet_new ();
00899   
00900   sRefSet_allElements (s, el)
00901     {
00902       ctype ct = ctype_realType (sRef_getType (el));
00903       
00904       if (ctype_isArrayPtr (ct))
00905         {
00906           t = sRefSet_insert (t, sRef_makeArrayFetchKnown (el, i));
00907         }
00908     } end_sRefSet_allElements;
00909 
00910   return t;
00911 }

sRefSet sRefSet_fetchUnknown ( sRefSet s )
 

Definition at line 879 of file sRefSet.c.

00880 {
00881   sRefSet t = sRefSet_new ();
00882   
00883   sRefSet_allElements (s, el)
00884     {
00885       ctype ct = ctype_realType (sRef_getType (el));
00886       
00887       if (ctype_isArrayPtr (ct))
00888         {
00889           t = sRefSet_insert (t, sRef_makeArrayFetch (el));
00890         }
00891     } end_sRefSet_allElements;
00892 
00893   return t;
00894 }

void sRefSet_fixSrefs ( sRefSet s )
 

Definition at line 780 of file sRefSet.c.

Referenced by aliasTable_fixSrefs().

00781 {
00782   if (sRefSet_isDefined (s))
00783     {
00784       int i;
00785       
00786       for (i = 0; i < sRefSet_size (s); i++)
00787         {
00788           sRef current = s->elements[i];
00789 
00790           if (sRef_isLocalVar (current))
00791             {
00792               s->elements[i] = uentry_getSref (sRef_getUentry (current));
00793                     }
00794         }
00795     }
00796 }

void sRefSet_free ( sRefSet s )
 

Definition at line 799 of file sRefSet.c.

Referenced by aliasTable_addMustAlias(), aliasTable_free(), aliasTable_levelUnion(), aliasTable_levelUnionSeq(), canLoseReference(), doneParams(), exprNode_free(), exprNode_freeShallow(), globSet_free(), guardSet_and(), guardSet_free(), guardSet_levelUnion(), guardSet_levelUnionFree(), guardSet_or(), sRefSet_unionFree(), sRef_aliasCheckPred(), sRef_aliasCheckSimplePred(), sRef_aliasCompleteSimplePred(), sRef_free(), setFunctionModifies(), setFunctionSpecialClause(), setFunctionStateSpecialClause(), uentry_returnedRef(), uentry_setModifies(), and usymtab_checkFinalScope().

00800 {
00801   if (!sRefSet_isUndefined (s))
00802     {
00803       llassertprint (s->entries < 1000, ("sRefSet free size: %d", s->entries));
00804 
00805       sfree (s->elements); 
00806       sfree (s);
00807     }
00808 }

bool sRefSet_hasRealElement ( sRefSet s )
 

Definition at line 572 of file sRefSet.c.

Referenced by exprNode_checkStatement().

00573 {
00574   sRefSet_allElements (s, e)
00575     {
00576       if (sRef_isMeaningful (e) && !sRef_isUnconstrained (e))
00577         {
00578           return TRUE;
00579         }
00580     } end_sRefSet_allElements;
00581 
00582   return FALSE;
00583 }

bool sRefSet_hasStatic ( sRefSet s )
 

Definition at line 604 of file sRefSet.c.

Referenced by exprNode_checkAllMods(), and uentry_setModifies().

00605 {
00606   return (sRefSet_isElementTest (sRef_isFileStatic, s));
00607 }

bool sRefSet_hasUnconstrained ( sRefSet s )
 

Definition at line 610 of file sRefSet.c.

Referenced by exprNode_checkStatement().

00611 {
00612   return (sRefSet_isElementTest (sRef_isUnconstrained, s));
00613 }

sRefSet sRefSet_insert ( sRefSet s,
sRef el )
 

Definition at line 85 of file sRefSet.c.

Referenced by aliasTable_addMustAlias(), exprNode_checkMSet(), exprNode_checkSet(), globSet_insert(), globSet_undump(), guardSet_addFalseGuard(), guardSet_addTrueGuard(), sRefSet_accessField(), sRefSet_addIndirection(), sRefSet_fetchKnown(), sRefSet_fetchUnknown(), sRefSet_intersect(), sRefSet_levelUnion(), sRefSet_realNewUnion(), sRefSet_removeIndirection(), sRefSet_undump(), sRefSet_union(), sRefSet_unionExcept(), uentry_returnedRef(), and usymtab_checkFinalScope().

00086 {
00087   if (sRefSet_isUndefined (s))
00088     {
00089       s = sRefSet_newEmpty ();
00090     }
00091 
00092   
00093   if (!sRefSet_isSameMember (s, el))
00094     {
00095       
00096       if (s->nspace <= 0)
00097         sRefSet_grow (s);
00098 
00099       s->nspace--;
00100 
00101       llassert (s->elements != NULL);
00102       s->elements[s->entries] = el;
00103 
00104             s->entries++;
00105     }
00106   else
00107     {
00108           }
00109 
00110   return s;
00111 }

sRefSet sRefSet_intersect ( sRefSet s1,
sRefSet s2 )
 

Definition at line 346 of file sRefSet.c.

Referenced by guardSet_and(), and guardSet_or().

00347 {
00348   sRefSet s = sRefSet_new ();
00349 
00350   llassert (NOALIAS (s1, s2));
00351 
00352   sRefSet_allElements (s1, el)
00353     {
00354       if (sRefSet_member (s2, el))
00355         {
00356           s = sRefSet_insert (s, el);
00357         }
00358     } end_sRefSet_allElements;
00359   
00360     return s;
00361 }

bool sRefSet_isSameMember ( sRefSet s,
sRef el )
 

Definition at line 586 of file sRefSet.c.

Referenced by sRefSet_compare(), sRefSet_equal(), and sRefSet_insert().

00587 {
00588   return (sRefSet_isElementCompare (sRef_realSame, s, el));
00589 }

bool sRefSet_isSameNameMember ( sRefSet s,
sRef el )
 

Definition at line 592 of file sRefSet.c.

00593 {
00594   return (sRefSet_isElementCompare (sRef_sameName, s, el));
00595 }

sRefSet sRefSet_levelCopy ( sRefSet s,
int lexlevel )
 

Definition at line 489 of file sRefSet.c.

Referenced by guardSet_levelUnion(), and guardSet_levelUnionFree().

00490 {
00491   if (sRefSet_isEmpty (s))
00492     {
00493       return sRefSet_undefined;
00494     }
00495   else
00496     {
00497       sRefSet r = (sRefSet) dmalloc (sizeof (*r));
00498       int i;
00499       
00500       r->nspace = s->entries;
00501       r->entries = 0;
00502       r->elements = (sRef *) dmalloc (sizeof (*r->elements) * (s->entries)); 
00503 
00504       for (i = 0; i < s->entries; i++)
00505         {
00506           if (sRef_lexLevel (s->elements[i]) <= lexlevel)
00507             {
00508               r->elements[r->entries] = s->elements[i];
00509               r->entries++;
00510               r->nspace--;
00511             }
00512         }  
00513       
00514       return r;
00515     }
00516 }

void sRefSet_levelPrune ( sRefSet s,
int lexlevel )
 

Definition at line 380 of file sRefSet.c.

Referenced by aliasTable_levelUnion(), and aliasTable_levelUnionSeq().

00381 {
00382   if (sRefSet_isDefined (s))
00383     {
00384       int i;
00385       int backcount = sRefSet_size (s) - 1;
00386       
00387       for (i = 0; i <= backcount; i++)
00388         {
00389           sRef el = s->elements[i]; 
00390           
00391           if (sRef_lexLevel (el) > lexlevel)
00392             {
00393               int j;
00394               
00395               
00396               for (j = backcount; j > i; j--)
00397                 {
00398                   backcount--;
00399                   s->entries--;
00400                   s->nspace++;
00401                   
00402                   if (sRef_lexLevel (s->elements[j]) <= lexlevel)
00403                     {
00404                       s->elements[i] = s->elements[j];
00405                       
00406                       if (backcount == i) s->entries++;
00407                       /*@innerbreak@*/ break;
00408                     }
00409                 }
00410 
00411               if (backcount == i)
00412                 {
00413                   s->entries--;
00414                 }
00415             }
00416         }
00417     }
00418 }

sRefSet sRefSet_levelUnion ( sRefSet sr,
sRefSet s,
int lexlevel )
 

Definition at line 364 of file sRefSet.c.

Referenced by guardSet_levelUnion(), and guardSet_levelUnionFree().

00365 {
00366   llassert (NOALIAS (sr, s));
00367 
00368   sRefSet_allElements (s, el)
00369     {
00370       if (sRef_lexLevel (el) <= lexlevel)
00371         {
00372           sr = sRefSet_insert (sr, el);
00373         }
00374     } end_sRefSet_allElements;
00375 
00376   return sr;
00377 }

sRef sRefSet_lookupMember ( sRefSet s,
sRef el )
 

Definition at line 695 of file sRefSet.c.

00696 {
00697   sRefSet_allElements (s, e)
00698     {
00699       if (sRef_similar (el, e))
00700         {
00701           return e;
00702         }
00703     } end_sRefSet_allElements;
00704   
00705   return sRef_undefined;
00706 }

bool sRefSet_member ( sRefSet s,
sRef el )
 

Definition at line 598 of file sRefSet.c.

Referenced by globSet_member(), guardSet_isGuarded(), guardSet_isProbableNull(), sRefSet_intersect(), and usymtab_checkFinalScope().

00599 {
00600   return (sRefSet_isElementCompare (sRef_similar, s, el));
00601 }

sRef sRefSet_mergeIntoOne ( sRefSet s )
 

Definition at line 198 of file sRefSet.c.

Referenced by uentry_returnedRef().

00199 {
00200   sRef res;
00201   int i;
00202 
00203   if (sRefSet_isUndefined (s)) return sRef_undefined;
00204   if (s->entries == 0) return sRef_undefined;
00205 
00206   llassert (s->elements != NULL);
00207 
00208   res = s->elements[0];
00209 
00210   for (i = 1; i < s->entries; i++)
00211     {
00212       sRef tmp;
00213 
00214             tmp = sRef_makeConj (res, s->elements[i]);
00215             res = tmp;
00216     }
00217 
00218   return res;
00219 }

bool sRefSet_modifyMember ( sRefSet s,
sRef m )
 

Definition at line 677 of file sRefSet.c.

00678 {
00679   bool ret = FALSE;
00680 
00681   sRefSet_allElements (s, e)
00682     {
00683       if (sRef_similar (m, e))
00684         {
00685           sRef_setModified (e);
00686           ret = TRUE;
00687         }
00688     } end_sRefSet_allElements;
00689 
00690   
00691   return ret;
00692 }

sRefSet sRefSet_new ( )
 

Definition at line 36 of file sRefSet.c.

Referenced by context_exitFunction(), context_initMod(), context_quietExitFunction(), exprNode_createId(), exprNode_iterNewId(), globSet_undump(), guardSet_and(), guardSet_or(), sRefSet_accessField(), sRefSet_addIndirection(), sRefSet_fetchKnown(), sRefSet_fetchUnknown(), sRefSet_intersect(), sRefSet_removeIndirection(), sRefSet_undump(), uentry_makeTypeListFunction(), uentry_makeUnspecFunction(), uentry_returnedRef(), and usymtab_checkFinalScope().

00037 {
00038   return sRefSet_undefined;
00039 }

sRefSet sRefSet_newCopy ( sRefSet s )
 

Definition at line 464 of file sRefSet.c.

Referenced by aliasTable_copy(), aliasTable_levelUnion(), globSet_newCopy(), guardSet_copy(), guardSet_invert(), guardSet_union(), and sRefSet_realNewUnion().

00465 {
00466   if (sRefSet_isEmpty (s))
00467     {
00468       return sRefSet_undefined;
00469     }
00470   else
00471     {
00472       sRefSet r = (sRefSet) dmalloc (sizeof (*r));
00473       int i;
00474       
00475       r->entries = s->entries;
00476       r->nspace = s->nspace;
00477       r->elements = (sRef *) dmalloc (sizeof (*r->elements) * (s->entries + s->nspace));
00478       
00479       for (i = 0; i < s->entries; i++)
00480         {
00481           r->elements[i] = s->elements[i]; 
00482         }  
00483       
00484       return r;
00485     }
00486 }

sRefSet sRefSet_newDeepCopy ( sRefSet s )
 

Definition at line 519 of file sRefSet.c.

Referenced by sRef_copy().

00520 {
00521   if (sRefSet_isUndefined (s))
00522     {
00523       return sRefSet_newEmpty ();
00524     }
00525   else
00526     {
00527       sRefSet r = (sRefSet) dmalloc (sizeof (*r));
00528       int i;
00529       
00530       r->entries = s->entries;
00531       r->nspace = s->nspace;
00532       r->elements = (sRef *) dmalloc (sizeof (*r->elements) * (s->entries + s->nspace));
00533       
00534       for (i = 0; i < s->entries; i++)
00535         {
00536           r->elements[i] = sRef_copy (s->elements[i]);
00537         }  
00538       
00539       return r;
00540     }
00541 }

sRefSet sRefSet_realNewUnion ( sRefSet s1,
sRefSet s2 )
 

Definition at line 322 of file sRefSet.c.

Referenced by exprNode_arrayFetch().

00323 {
00324   llassert (NOALIAS (s1, s2));
00325 
00326   if (sRefSet_isUndefined (s1))
00327     {
00328       return (sRefSet_newCopy (s2));
00329     }
00330   else
00331     {
00332       sRefSet ret = sRefSet_newCopy (s1);
00333       
00334       sRefSet_allElements (s2, el)
00335         {
00336           ret = sRefSet_insert (ret, el);
00337         } end_sRefSet_allElements;
00338       
00339       return ret;
00340     }
00341 }

sRefSet sRefSet_removeIndirection ( sRefSet s )
 

Definition at line 810 of file sRefSet.c.

00811 {
00812   /*
00813   ** returns a NEW sRefSet containing references to all sRef's in s
00814   */
00815 
00816   sRefSet t = sRefSet_new ();
00817   
00818   
00819   sRefSet_allElements (s, el)
00820     {
00821       if (!sRef_isAddress (el))
00822         {
00823           t = sRefSet_insert (t, sRef_makeAddress (el));
00824         }
00825     } end_sRefSet_allElements;
00826 
00827   return t;
00828 }

sRefSet sRefSet_single ( sRef sr )
 

Definition at line 54 of file sRefSet.c.

Referenced by aliasTable_addMustAlias().

00055 {
00056   sRefSet s = (sRefSet) dmalloc (sizeof (*s));
00057   
00058   s->entries = 1;
00059   s->nspace = sRefSetBASESIZE - 1;
00060   s->elements = (sRef *) dmalloc (sizeof (*s->elements) * sRefSetBASESIZE);
00061   s->elements[0] = sr;
00062 
00063     return (s);
00064 }

int sRefSet_size ( sRefSet s )
 

Definition at line 708 of file sRefSet.c.

Referenced by aliasTable_levelUnion(), sRefSet_fixSrefs(), sRefSet_levelPrune(), sRefSet_unparse(), sRefSet_unparseDebug(), sRefSet_unparsePlain(), and uentry_returnedRef().

00709 {
00710   if (sRefSet_isUndefined (s)) return 0;
00711   return s->entries;
00712 }

sRefSet sRefSet_undump ( char ** s )
 

Definition at line 956 of file sRefSet.c.

Referenced by uentry_undump().

00957 {
00958   char c;
00959   sRefSet sl = sRefSet_new ();
00960 
00961   while ((c = **s) != '#' && c != '@' && c != '$' && c != '&')
00962     {
00963       sl = sRefSet_insert (sl, sRef_undump (s));
00964 
00965       
00966       if (**s == ',')
00967         {
00968           (*s)++;
00969         }
00970     }
00971 
00972     return sl;
00973 }

sRefSet sRefSet_union ( sRefSet s1,
sRefSet s2 )
 

Definition at line 276 of file sRefSet.c.

Referenced by aliasTable_levelUnion(), exprNode_arrayFetch(), exprNode_assign(), exprNode_if(), guardSet_and(), guardSet_or(), guardSet_union(), sRefSet_unionFree(), and specialClauses_add().

00277 {
00278   if (s1 == s2) 
00279     {
00280       return s1;
00281     }
00282 
00283   if (sRefSet_isEmpty (s1))
00284     {
00285       s1 = sRefSet_copy (s1, s2);
00286     }
00287   else
00288     {
00289       sRefSet_allElements (s2, el)
00290         {
00291           s1 = sRefSet_insert (s1, el);
00292         } end_sRefSet_allElements;
00293     }
00294 
00295   return s1;
00296 }

sRefSet sRefSet_unionExcept ( sRefSet s1,
sRefSet s2,
sRef ex )
 

Definition at line 303 of file sRefSet.c.

Referenced by aliasTable_addMustAlias().

00304 {
00305   if (s1 == s2) return s1;
00306 
00307   sRefSet_allElements (s2, el)
00308     {
00309       if (sRef_same (el, ex))
00310         {
00311                 }
00312       else
00313         {
00314           s1 = sRefSet_insert (s1, el);
00315         }
00316     } end_sRefSet_allElements;
00317   
00318   return s1;
00319 }

sRefSet sRefSet_unionFree ( sRefSet s1,
sRefSet s2 )
 

Definition at line 267 of file sRefSet.c.

Referenced by aliasTable_aliasedBy(), aliasTable_canAlias(), and usymtab_allAliases().

00268 {
00269   sRefSet res = sRefSet_union (s1, s2);
00270 
00271   sRefSet_free (s2);
00272   return res;
00273 }

cstring sRefSet_unparse ( sRefSet s )
 

Definition at line 715 of file sRefSet.c.

Referenced by aliasTable_unparse(), context_unparse(), globSet_unparse(), specialClause_unparse(), and uentry_unparseFull().

00716 {
00717   int i;
00718   cstring st = cstring_makeLiteral ("{");
00719 
00720   if (sRefSet_isDefined (s))
00721     {
00722       for (i = 0; i < sRefSet_size (s); i++)
00723         {
00724           if (i == 0)
00725             st = message ("%q %q", st, sRef_unparse (s->elements[i]));
00726           else
00727             st = message ("%q, %q", st, sRef_unparse (s->elements[i]));
00728         }
00729     }
00730   
00731   st = message ("%q }", st);
00732   return st;
00733 }

cstring sRefSet_unparseDebug ( sRefSet s )
 

Definition at line 755 of file sRefSet.c.

Referenced by guardSet_unparse(), and sRef_unparseFull().

00756 {
00757   int i;
00758   cstring st = cstring_makeLiteral ("{");
00759 
00760   if (sRefSet_isDefined (s))
00761     {
00762       for (i = 0; i < sRefSet_size (s); i++)
00763         {
00764           if (i == 0)
00765             {
00766               st = message ("%q %q", st, sRef_unparseDebug (s->elements[i]));
00767             }
00768           else
00769             {
00770               st = message ("%q, %q", st, sRef_unparseDebug (s->elements[i]));
00771             }
00772         }
00773     }
00774   
00775   st = message ("%q }", st);
00776   return st;
00777 }

cstring sRefSet_unparsePlain ( sRefSet s )
 

Definition at line 735 of file sRefSet.c.

Referenced by specialClauses_checkEqual().

00736 {
00737   int i;
00738   cstring st = cstring_undefined;
00739 
00740   if (sRefSet_isDefined (s))
00741     {
00742       for (i = 0; i < sRefSet_size (s); i++)
00743         {
00744           if (i == 0)
00745             st = sRef_unparse (s->elements[i]);
00746           else
00747             st = message ("%q, %q", st, sRef_unparse (s->elements[i]));
00748         }
00749     }
00750   
00751   return st;
00752 }

cstring sRefSet_unparseUnconstrained ( sRefSet s )
 

Definition at line 616 of file sRefSet.c.

00617 {
00618   int num = 0;
00619   cstring res = cstring_undefined;
00620   
00621   sRefSet_allElements (s, el)
00622     {
00623       if (sRef_isUnconstrained (el))
00624         {
00625           if (cstring_isUndefined (res))
00626             {
00627               res = cstring_copy (sRef_unconstrainedName (el));
00628             }
00629           else
00630             {
00631               res = message ("%q, %s", res, sRef_unconstrainedName (el));
00632             }
00633           
00634           num++;
00635         }
00636     } end_sRefSet_allElements ;
00637   
00638   if (num == 0)
00639     {
00640       llassert (cstring_isUndefined (res));
00641       return (cstring_makeLiteral ("<ERROR: no unconstrained calls>"));
00642     }
00643   else if (num == 1)
00644     {
00645       return (message ("unconstrained function %q", res));
00646     }
00647   else
00648     {
00649       return (message ("unconstrained functions %q", res));
00650     }
00651 }

cstring sRefSet_unparseUnconstrainedPlain ( sRefSet s )
 

Definition at line 654 of file sRefSet.c.

00655 {
00656   cstring res = cstring_undefined;
00657 
00658   sRefSet_allElements (s, el)
00659     {
00660       if (sRef_isUnconstrained (el))
00661         {
00662           if (cstring_isUndefined (res))
00663             {
00664               res = cstring_copy (sRef_unconstrainedName (el));
00665             }
00666           else
00667             {
00668               res = message ("%q, %s", res, sRef_unconstrainedName (el));
00669             }
00670         }
00671     } end_sRefSet_allElements ;
00672 
00673   return res;
00674 }

Generated at Fri Nov 3 18:58:13 2000 for LCLint by doxygen1.2.3 written by Dimitri van Heesch, © 1997-2000