code: def _lookup_abs(self, p, klass, create=1):
          
          k = _my_normcase(p)
          try:
              result = self._lookupDict[k]
          except KeyError:
              if not create:
                  msg = "No such file or directory: '%s' in '%s' (and create is False)" % (p, str(self))
                  raise SCons.Errors.UserError(msg)
              # There is no Node for this path name, and we're allowed
              # to create it.
              dir_name, file_name = p.rsplit('/',1)
              dir_node = self._lookup_abs(dir_name, Dir)
              result = klass(file_name, dir_node, self.fs)
  
              # Double-check on disk (as configured) that the Node we
              # created matches whatever is out there in the real world.
              result.diskcheck_match()
  
              self._lookupDict[k] = result
              dir_node.entries[_my_normcase(file_name)] = result
              dir_node.implicit = None
          else:
              # There is already a Node for this path name.  Allow it to
              # complain if we were looking for an inappropriate type.
              result.must_be_same(klass)
          return result
docs: Fast (?) lookup of a *normalized* absolute path.
  
          This method is intended for use by internal lookups with
          already-normalized path data.  For general-purpose lookups,
          use the FS.Entry(), FS.Dir() or FS.File() methods.
  
          The caller is responsible for making sure we're passed a
          normalized absolute path; we merely let Python's dictionary look
          up and return the One True Node.FS object for the path.
  
          If a Node for the specified "p" doesn't already exist, and
          "create" is specified, the Node may be created after recursive
          invocation to find or create the parent directory or directories.