#!/usr/bin/env python3

'''

Copyright (C) 2013 Povilas Kanapickas <povilas@radix.lt>

This file is part of cppreference-doc

This program is free software: you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation, either version 3 of the License, or

(at your option) any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program. If not, see http://www.gnu.org/licenses/.

'''

import sys, json, os, sys, re, fnmatch

import lxml.etree as e

import lxml.html as html

from index_transform import IndexTransform, xml_escape

from build_link_map import build_link_map

from ddg_parse_html import get_declarations, get_short_description, DdgException

if len(sys.argv) != 3 and not (len(sys.argv) > 2 and sys.argv[2] == 'debug'):

print('''Please provide the file name of the index as the first argument

and the file name of the output as the second ''')

sys.exit(1)

MAX_CODE_LINES = 6

# If a the second argument is 'debug', the program switches to debug mode and

# prints everything to stdout. If the third argument is provided, the program

# processes only the identifiers that match the provided string

debug = False

debug_ident = None

if len(sys.argv) > 2 and sys.argv[2] == 'debug':

debug = True

if len(sys.argv) > 3:

debug_ident = sys.argv[3]

# track the statistics of number of lines used by the entries

debug_num_lines = [0 for i in range(40)]

index_file = sys.argv[1]

output_file = sys.argv[2]

items = {}

# Entry types

# a class or struct

ITEM_TYPE_CLASS = 1

# a member function or free function

ITEM_TYPE_FUNCTION = 2

# a constructor

ITEM_TYPE_CONSTRUCTOR = 3

# a constructor that is described in the same page as the class

ITEM_TYPE_CONSTRUCTOR_INLINEMEM = 4

# a destructor

ITEM_TYPE_DESTRUCTOR = 5

# a destructor that is described in the same page as the class

ITEM_TYPE_DESTRUCTOR_INLINEMEM = 6

# a member function that is described in the same page as the class

ITEM_TYPE_FUNCTION_INLINEMEM = 7

# an enum

ITEM_TYPE_ENUM = 8

# a value of an enum

ITEM_TYPE_ENUM_CONST = 9

def get_item_type(el):

return None # not recognized

class Index2DuckDuckGoList(IndexTransform):

IndexTransform.process_item_hook(self, el, full_name, full_link)

# get a list of pages to analyze

tr = Index2DuckDuckGoList()

tr.transform(index_file)

# get a list of existing pages

html_files = []

for root, dirnames, filenames in os.walk('reference'):

for filename in fnmatch.filter(filenames, '*.html'):

html_files.append(os.path.join(root, filename))

# get a mapping between titles and pages

# linkmap = dict { title -> filename }

link_map = build_link_map('reference')

# create a list of processing instructions for each page

proc_ins = {}

for link in items:

if link in link_map:

fn = link_map[link]

if fn not in proc_ins:

proc_ins[fn] = { 'fn': fn, 'link': link, 'idents': {}}

for ident in items[link]:

proc_ins[fn]['idents'][ident] = { 'ident' : ident,

'type' : items[link][ident] }

# sort proc_ins to produce ordered output.txt

proc_ins = [ v for v in proc_ins.values() ]

proc_ins = sorted(proc_ins, key=lambda x: x['link'])

for page in proc_ins:

idents = page['idents']

idents = [ v for v in idents.values() ]

idents = sorted(idents, key=lambda x: x['ident'])

page['idents'] = idents

# process the files

# returns the unqualified name of an identifier

def get_name(ident):

return ident

# returns the version number common to all declarations. Returns none if two

# declarations have different version numbers or if no version number is

# provided

def get_version(decls):

return rv

def build_abstract(decls, desc):

return all_code + desc

''' Outputs additional redirects for an identifier.

Firstly, we replace '::' with spaces. Then we add two redirects: one with

unchanged text and another with '_' replaced with spaces. We strip one

level of namespace/class qualification and repeat the process with the

remaining text.

For constructors and destructors, we strip the function name and apply the

abovementioned algorithm, the only difference being that we append

(or prepend) 'constructor' or 'destructor' to the title of the redirect

respectively.

Each redirect has a 'priority', which is defined by the number of stripped

namespace/class qualifications from the entry that produced the redirect.

This is used to remove duplicate redirects. For each group of duplicate

redirects, we find the redirect with the highest priority (i.e. lowest

number of qualifications stripped) and remove all other redirects. If the

number of highest-priority redirects is more than one, then we remove all

redirects from the group altogether.

We don't add any redirects to specializations, overloads or operators.

'''

''' array of dict { 'title' -> redirect title,

'target' -> redirect target,

'priority' -> redirect priority as int

}

'''

redirects = []

def build_redirects(item_ident, item_type):

pass # should not be here

def output_redirects():

out.write(line)

if debug:

out = sys.stdout

else:

out = open(output_file, 'w')

#i=1

for page in proc_ins:

idents = page['idents']

link = page['link']

fn = page['fn']

if debug_ident:

ignore = True

for ident in idents:

if ident['ident'].find(debug_ident) != -1:

ignore = False

break

if ignore:

continue

#print(str(i) + '/' + str(len(proc_ins)) + ': ' + link)

#i+=1

root = e.parse('reference/'+fn, parser=html.HTMLParser())

for ident in idents:

item_ident = ident['ident']

item_type = ident['type']

# get the name by extracting the unqualified identifier

name = get_name(item_ident)

try:

debug_verbose = True if debug and debug_ident != None else False

if item_type == ITEM_TYPE_CLASS:

decls = get_declarations(root, name)

desc = get_short_description(root, get_version(decls), debug=debug_verbose)

abstract = build_abstract(decls, desc)

elif item_type in [ ITEM_TYPE_FUNCTION,

ITEM_TYPE_CONSTRUCTOR,

ITEM_TYPE_DESTRUCTOR ]:

decls = get_declarations(root, name)

desc = get_short_description(root, get_version(decls), debug=debug_verbose)

abstract = build_abstract(decls, desc)

elif item_type in [ ITEM_TYPE_FUNCTION_INLINEMEM,

ITEM_TYPE_CONSTRUCTOR_INLINEMEM,

ITEM_TYPE_DESTRUCTOR_INLINEMEM ]:

raise DdgException("INLINEMEM") # not implemented

''' Implementation notes:

* the declarations are possibly versioned

* declaration is selected from the member table

* the member table is found according to the identifier

(last part after :: is enough, hopefully)

'''

elif item_type == ITEM_TYPE_ENUM:

raise DdgException("ENUM") # not implemented

''' Implementation notes:

* the declarations are possibly versioned

'''

elif item_type == ITEM_TYPE_ENUM_CONST:

raise DdgException("ENUM_CONST") # not implemented

''' Implementation notes:

* the abstract will come from the const -> definition table,

which is always put before the first heading.

* the declaration will come from the dcl template. We need

to split the content at ';' and ',', then search for the

name of the enum. If we find duplicates, signal an error.

'''

# title

line = item_ident + '\t'

# type

line += 'A\t'

# redirect, otheruses, categories, references, see_also,

# further_reading, external links, disambiguation, images

line += '\t\t\t\t\t\t\t\t\t'

# abstract

abstract = abstract.replace('\n','\\n')

line += abstract + '\t'

# source url

line += 'http://en.cppreference.com/w/' + link + '\n'

out.write(line)

build_redirects(item_ident, item_type)

except DdgException as err:

if debug:

line = '# error (' + str(err) + "): " + link + ": " + item_ident + "\n"

out.write(line)

output_redirects()

if debug:

print('=============================')

print('Numbers of lines used:')

for i,l in enumerate(debug_num_lines):

print(str(i) + ': ' + str(l) + ' result(s)')