This file is indexed.

/usr/share/gluegen2/src/java/com/jogamp/gluegen/cgram/CSymbolTable.java is in libgluegen2-build-java 2.0-rc3-6.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
package com.jogamp.gluegen.cgram;

import java.util.Vector;
import java.util.Hashtable;
import java.util.Enumeration;



public class CSymbolTable {

  /** holds list of scopes */
  private Vector scopeStack;

  /** table where all defined names are mapped to TNode tree nodes */
  private Hashtable symTable;

  public CSymbolTable()  {
    scopeStack = new Vector(10);
    symTable = new Hashtable(533);
  }


  /** push a new scope onto the scope stack.
    */
  public void pushScope(String s) {
      //System.out.println("push scope:" + s);
    scopeStack.addElement(s);
  }

  /** pop the last scope off the scope stack.
    */
  public void popScope() {
      //System.out.println("pop scope");
    int size = scopeStack.size();
    if(size > 0)
      scopeStack.removeElementAt(size - 1);
  }

  /** return the current scope as a string 
   */
  public String currentScopeAsString() {
      StringBuffer buf = new StringBuffer(100);
      boolean first = true;
      Enumeration e = scopeStack.elements();
      while(e.hasMoreElements()) {
        if(first) 
          first = false;
        else
          buf.append("::");
        buf.append(e.nextElement().toString());
      }
      return buf.toString();
  }

  /** given a name for a type, append it with the 
    current scope.
    */
  public String addCurrentScopeToName(String name) {
    String currScope = currentScopeAsString();
    return addScopeToName(currScope, name);
  }

  /** given a name for a type, append it with the 
    given scope.  MBZ
    */
  public String addScopeToName(String scope, String name) {
    if(scope == null || scope.length() > 0)
      return scope + "::" + name;
    else
      return name;
  }

  /** remove one level of scope from name MBZ*/
  public String removeOneLevelScope(String scopeName) {
    int index = scopeName.lastIndexOf("::");
    if (index > 0) {
      return scopeName.substring(0,index);
    }
    if (scopeName.length() > 0) {
        return "";
    }
    return null;
  }
  
  /** add a node to the table with it's key as
    the current scope and the name */
  public TNode add(String name, TNode node) {
    return (TNode)symTable.put(addCurrentScopeToName(name),node);
  }


  /** lookup a fully scoped name in the symbol table */
  public TNode lookupScopedName(String scopedName) {
    return (TNode)symTable.get(scopedName);
  }

  /** lookup an unscoped name in the table by prepending
    the current scope.
    MBZ -- if not found, pop scopes and look again
    */
  public TNode lookupNameInCurrentScope(String name) {
    String scope = currentScopeAsString();
    String scopedName;
    TNode tnode = null;

    //System.out.println( "\n"+ this.toString() );

    while (tnode == null && scope != null) {
      scopedName = addScopeToName(scope, name);
      //System.out.println("lookup trying " + scopedName);
      tnode = (TNode)symTable.get(scopedName);
      scope = removeOneLevelScope(scope);
    }
    return tnode;
  }

  /** convert this table to a string */
  public String toString() {
    StringBuffer buff = new StringBuffer(300);
    buff.append("CSymbolTable { \nCurrentScope: " + currentScopeAsString() + 
                "\nDefinedSymbols:\n");
    Enumeration ke = symTable.keys();
    Enumeration ve = symTable.elements();
    while(ke.hasMoreElements()) {
      buff.append(ke.nextElement().toString() + " (" + 
                  TNode.getNameForType(((TNode)ve.nextElement()).getType()) + ")\n");
    }
    buff.append("}\n");
    return buff.toString();
  }

};