#! /usr/bin/env python
#
# Part of the A-A-P project: File type detection module

# Copyright (C) 2002 Stichting NLnet Labs
# Permission to copy and use this file is specified in the file COPYING.
# If this file is missing you can find it here: http://www.a-a-p.org/COPYING

# This module detects the type of a file.
# It can be run as a separate program or called from Python.
# Many types are recognized by default.  More types can be added dynamically.
# See filetype.txt for an explanation.
#
#
# EXTERNAL INTERFACE:
#
# ft_detect(fname)          Detects the type of file "fname".
#
# ft_check_dir(dir [, errmsg)]
#                           Scan directory "dir" for "*.afd" files, which are
#                           loaded with ft_read_file().
#
# ft_read_file(fname)       Read file "fname" for detection rules.
#
# ft_add_rules(str)         Add file type detection rules from "str".  See
#                           "filetype.txt" for the syntax.
#

import string
import os.path
import re

from Util import *

# Set to non-zero when run as a program.
_run_as_program = 0

#
# The default list of detected file types.
# NOTE: since "append" isn't used, the order of checking is last one first!
#
_def_detect_list = """
suffix c c
suffix h cpp
suffix hh cpp
suffix H cpp
suffix hxx cpp
suffix hpp cpp
suffix cpp cpp
suffix cc cpp
suffix C cpp
suffix c++ cpp
suffix cxx cpp
suffix moc cpp
suffix tcc cpp
suffix inl cpp

suffix py python
suffix pl perl
suffix sh sh
suffix aap aap
suffix afd afd
suffix html html
suffix htm html

suffix Z ignore
suffix gz ignore
suffix bz2 ignore
suffix bak ignore

regexp .*enlightenment/.*.cfg$ c
regexp .*vimrc$ vim
regexp .*\\bconfigure$ sh

script .*\\bpython python
script .*\\bperl perl
script .*csh\\b csh
script .*\\bbash sh
"""

# List of _Ft_py objects: Python code executed to detect file type.
# Used first.
_py_list_before = []

# Dictionary used to map file name extension to file type.
_suffix_dict = {}

# List of _Ft_re objects; a match of the RE with the file name defines the file
# type.
_regexp_list = []

# List of _Ft_re objects: a match of the RE with the script in the first line
# of the file defines the file type.
_script_list = []

# List of _Ft_py objects: Python code executed to detect file type.
# Used after everything else didn't detect the type.
_py_list_after = []

_did_init = 0       # non-zero when __init__() did its work

def __init__():
   global _suffix_dict, _regexp_list, _script_list
   global _py_list_before, _py_list_after
   global _did_init

   # this only needs to be done once
   if _did_init:
       return
   _did_init = 1

   _py_list_before = []
   _suffix_dict = {}
   _regexp_list = []
   _script_list = []
   _py_list_after = []

   # Load the built-in detection rules.
   ft_add_rules(_def_detect_list)

   # Load detection rules from system and user *.afd files.
   ft_check_dir("/usr/local/share/aap/afd")
   ft_check_dir(os.path.expanduser("~/.aap/afd"))


class DetectError(Exception):
   """Error for something gone wrong."""
   def __init__(self, args = None):
       self.args = args


def ft_check_dir(dir, errmsg = 0):
   """Check directory "dir" for *.afd files and load them.
      When "errmsg" is non-zero give an error message when the directory
      doesn't exist."""
   if os.path.exists(dir) and os.path.isdir(dir):
       for f in glob(os.path.join(dir, "*.afd")):
           try:
               ft_read_file(f)
           except DetectError, e:
               if _run_as_program:
                   print str(e)
               else:
                   from Message import msg_error
                   msg_error(str(e))
   elif errmsg:
       e = _('Directory does not exist: "%s"') % dir
       if _run_as_program:
           print e
       else:
           from Message import msg_error
           msg_error(e)


def ft_read_file(fname):
   """Read file "fname" for file type detection rules."""
   try:
       file = open(fname)
   except IOError, e:
       raise DetectError, (_('Cannot open "%s": ') % fname) + str(e)
   try:
       str = file.read()
   except IOError, e:
       raise DetectError, (_('Cannot read "%s": ') % fname) + str(e)
   file.close()

   ft_add_rules(str)


def ft_add_rules(str):
   """Add file type detection rules from string "str"."""
   # Always load the default rules first (skipped when done already).
   __init__()

   # Split the string into individual lines.
   lines = string.split(str, '\n')

   # Loop over all the lines (may use more than one for python items).
   line_idx = 0
   line_count = len(lines)
   while line_idx < line_count:
       line = lines[line_idx]
       line_len = len(line)

       # isolate first word: type of detection.
       ds = skip_white(line, 0)        # detection start

       # ignore empty and comment lines
       if ds == line_len or line[ds] == '#':
           line_idx = line_idx + 1
           continue

       de = skip_to_white(line, ds)    # detection end
       item = line[ds:de]
       as = skip_white(line, de)       # argument start

       # isolate first argument, which may be in quotes
       if as < line_len:
           if line[as] == '"' or line[as] == "'":
               quote = line[as]
               as = as + 1
               ae = as
               while ae < line_len and line[ae] != quote:
                   ae = ae + 1
               if ae == line_len:
                   raise DetectError, _('Missing quote in "%s"') % line
               n = ae + 1
           else:
               ae = as
               while ae < line_len and line[ae] != ' ' and line[ae] != '\t':
                   ae = ae + 1
               n = ae
           arg1 = line[as:ae]
           n = skip_white(line, n)
       else:
           arg1 = ''
           n = line_len

       # Isolate further arguments (no quotes!).
       # A superfluous argument is silently ignore (could be a comment).
       args = string.split(line[n:])
       if len(args) >= 1:
           arg2 = args[0]
       else:
           arg2 = ''
       if len(args) >= 2:
           arg3 = args[1]
       else:
           arg3 = ''

       if item == "suffix":
           if not arg2:
               raise DetectError, _('Missing argument in "%s"') % line
           _add_suffix(arg1, arg2)

       elif item == "regexp":
           if not arg2:
               raise DetectError, _('Missing argument in "%s"') % line
           _add_regexp(arg1, arg2, arg3 and arg3 == "append")

       elif item == "script":
           if not arg2:
               raise DetectError, _('Missing argument in "%s"') % line
           _add_script(arg1, arg2, arg3 and arg3 == "append")

       elif item == "python":
           append = 0
           after = 0
           for arg in [arg1, arg2]:
               if arg:
                   if arg == "append":
                       append = 1
                   elif arg == "after":
                       after = 1
                   else:
                       raise DetectError, _('Illegal argument in "%s"') % line

           start_indent = get_indent(line)
           line_idx = line_idx + 1
           start_line_idx = line_idx
           cmds = ""
           while line_idx < line_len:
               line = lines[line_idx]
               if get_indent(line) <= start_indent:
                   line_idx = line_idx - 1     # this line has next item
                   break
               cmds = cmds + line + '\n'
               line_idx = line_idx + 1
           if not cmds:
                   raise DetectError, _('Python commands missing')
           _add_python(cmds, _("filetype detection line %d") % start_line_idx,
                                                                after, append)

       else:
           raise (DetectError,
                    _("Illegal item %s in argument to ft_add_rules()") % item)

       line_idx = line_idx + 1


class _Ft_re:
   """Class used to store pairs of RE and file type."""
   def __init__(self, re, type):
       self.re = re
       self.type = type


class _Ft_py:
   """Class used to store Python code for detecting a file type."""
   def __init__(self, code, error_msg):
       self.code = code                # the Python code
       self.error_msg = error_msg      # ar message used for errors


def _add_suffix(suf, type):
   """Add detection of "type" by file name extension "suf".
      When "type" is "ignore" it means the suffix is removed and further
      detection done on the rest.
      When "type" is "remove" an existing detection for "suf" is removed."""
   if type == 'remove':
       if _suffix_dict.has_key(suf):
           del _suffix_dict[suf]
   else:
       _suffix_dict[suf] = type


def _add_regexp(re, type, append):
   """Add detection of "type" by matching the file name with Python regular
      expression "re".
      When append is non-zero, add to the end of the regexp rules.
      When "type" is "remove" an existing detection for "re" is removed."""
   if type == 'remove':
       for r in _regexp_list:
           if r.re == re:
               _regexp_list.remove(r)
   else:
       f = _Ft_re(re, type)
       if append:
           _regexp_list.append(f)
       else:
           _regexp_list.insert(0, f)


def _add_script(re, type, append):
   """Add detection of "type" by matching the script name in the first line of
      the file with Python regular expression "re".
      When append is non-zero, add to the end of the script rules.
      When "type" is "remove" an existing detection for "re" is removed."""
   if type == 'remove':
       for r in _script_list:
           if r.re == re:
               _script_list.remove(r)
   else:
       f = _Ft_re(re, type)
       if append:
           _script_list.append(f)
       else:
           _script_list.insert(0, f)


def _add_python(code, error_msg, after, append):
   """Add detection of "type" by using Python code "code".
      Each line in "code" must end in a '\n'.
      "error_msg" is printed when executing the code results in an error.
      When "after" is non-zero use this rule after suffix, regexp and script
      rules.
      When append is non-zero, add to the end of the python rules."""
   p = _Ft_py(code, error_msg)
   if after:
       list = _py_list_after
   else:
       list = _py_list_before
   if append:
       list.append(p)
   else:
       list.insert(0, p)


def _exec_py(fname, item):
   """Execute the code defined with _add_python()."""
   # Make a completely fresh globals dictionary.
   new_globals = {"fname" : fname}

   # Prepend "if 1:" to get the indenting right.
   if item.code[0] == ' ' or item.code[0] == '\t':
       code = "if 1:\n" + item.code
   else:
       code = item.code

   try:
       exec code in new_globals, new_globals
   except StandardError, e:
       raise DetectError, _(item.error_msg) + str(e)

   if new_globals.has_key("type"):
       return new_globals["type"]
   return None


def ft_detect(fname):
   """Detect the file type for file "fname".
      Returns the type as a string or None."""
   # Initialize (will skip when done already)
   __init__()

   # On non-Posix systems we ignore case differences by making the name lower
   # case.
   if os.name != 'posix':
       fname = string.lower(fname)

   # Do the python code checks.
   for p in _py_list_before:
       type = _exec_py(fname, p)
       if type:
           return type

   # Try the extension, this is fastest.
   # When "fname" has several extensions, try with all of them first, then
   # try by removing the first ones:  "f.html.c": "html.c" then ".c".
   bn = os.path.basename(fname)
   i = string.find(bn, ".")
   while i > 0 and i + 1 < len(bn):
       # Found a dot that's not the first or last character.
       if _suffix_dict.has_key(bn[i + 1:]):
           ft = _suffix_dict[bn[i + 1:]]
           if ft != "ignore":
               return ft
           # remove an ignored extension
           fname = fname[:-(len(bn[i:]))]
           bn = bn[:i]
           i = 0
       i = string.find(bn, ".", i + 1)

   # match all defined REs with the file name.
   # TODO: handle "/" in RE and fname.
   for r in _regexp_list:
       if re.match(r.re, fname):
           return r.type

   # match all defined REs with the script name in the first line of the
   # file.
   try:
       f = open(fname)
       line = f.readline()
       f.close()
   except:
       # Errors for files that can't be read are ignored.
       pass
   else:
       if len(line) > 2 and line[:2] == "#!":
           # TODO: remove "env VAR=val" and script arguments from line
           for r in _script_list:
               if re.match(r.re, line[2:]):
                   return r.type

   # Do the python code checks.
   for p in _py_list_after:
       type = _exec_py(fname, p)
       if type:
           return type

   return None


# When executed as a program, detect the type of the specified file.
if __name__ == '__main__':
   import sys

   # Internationalisation inits: setlocale and gettext.
   i18n_init()

   items = []
   checkfile = None
   _run_as_program = 1

   # Check for any "-Idir", "-I dir", "-ffile" and "-f file" arguments.
   next_is_dir = 0
   next_is_file = 0
   for arg in sys.argv[1:]:
       if next_is_dir:
           items.extend({"dir" : arg})
           next_is_dir = 0
       elif next_is_file:
           items.extend({"file" : arg})
           next_is_file = 0
       elif len(arg) >= 2 and arg[:2] == "-I":
           if len(arg) > 2:
               items.extend({"dir" : arg[2:]})
           else:
               next_is_dir = 1
       elif len(arg) >= 2 and arg[:2] == "-f":
           if len(arg) > 2:
               items.extend({"file" : arg[2:]})
           else:
               next_is_file = 1
       else:
           if checkfile:
               print _("Can only check one file")
               sys.exit(1)
           checkfile = arg

   if next_is_dir:
       print _("-I argument must be followed by a directory name")
       sys.exit(1)
   if next_is_file:
       print _("-f argument must be followed by a file name")
       sys.exit(1)

   if not checkfile:
       print _("Usage: %s [-I ruledir] [-f rulefile] filename") % sys.argv[0]
       sys.exit(1)

   # load the built-in default rules
   __init__()

   # Check specified directories for *.afd files and read specified files.
   for item in items:
       if item.has_key("dir"):
           ft_check_dir(item["dir"])
       else:
           try:
               ft_read_file(item["file"])
           except DetectError, e:
               print e

   print ft_detect(sys.argv[1])


# vim: set sw=4 sts=4 tw=79 fo+=l:

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.