From 6411beae7c57ddfaa6bfe44c046d5a338c6a4856 Mon Sep 17 00:00:00 2001 From: Filip Gralinski Date: Mon, 2 Dec 2019 18:02:20 +0100 Subject: [PATCH] Init --- .gitignore | 1 + CHANGELOG.md | 5 + Jenkinsfile | 11 + README.md | 61 + cookiecutter.json | 6 + hooks/post_gen_project.sh | 10 + hooks/pre_gen_project.sh | 6 + .../.cookiecutter.yml | 6 + .../.gitignore | 150 +++ .../Makefile | 42 + .../README.md | 1 + .../appendix.tex | 17 + .../autozoil-via-docker.sh | 3 + .../bibliography.bib | 1153 +++++++++++++++++ .../build.sh | 3 + .../check.sh | 3 + .../extract-score-files.pl | 20 + .../helpers/pdf-to-plain-text.sh | 3 + .../helpers/stats.sh | 18 + .../helpers/synchro.sh | 24 + .../helpers/vars | 2 + .../install-hooks.sh | 4 + .../main.tex | 59 + .../metadata.tex | 27 + .../preamble.tex | 5 + .../uam-wmi-msc/.gitignore | 26 + .../uam-wmi-msc/build.sh | 28 + .../uam-wmi-msc/check.sh | 29 + .../uam-wmi-msc/ext/plmindex/Makefile | 40 + .../uam-wmi-msc/ext/plmindex/decode_n.c | 197 +++ .../uam-wmi-msc/ext/plmindex/decode_n.c.orig | 196 +++ .../uam-wmi-msc/ext/plmindex/genind.c | 516 ++++++++ .../uam-wmi-msc/ext/plmindex/language.c | 507 ++++++++ .../uam-wmi-msc/ext/plmindex/language.h | 52 + .../uam-wmi-msc/ext/plmindex/makefile.djg | 36 + .../uam-wmi-msc/ext/plmindex/makefile.emx | 40 + .../uam-wmi-msc/ext/plmindex/makefile.gcc | 37 + .../uam-wmi-msc/ext/plmindex/makefile.msc | 36 + .../uam-wmi-msc/ext/plmindex/mkind.c | 743 +++++++++++ .../uam-wmi-msc/ext/plmindex/mkind.h | 632 +++++++++ .../uam-wmi-msc/ext/plmindex/myctype.h | 58 + .../uam-wmi-msc/ext/plmindex/pl_1250.h | 585 +++++++++ .../uam-wmi-msc/ext/plmindex/pl_852.h | 589 +++++++++ .../uam-wmi-msc/ext/plmindex/pl_iso2.h | 593 +++++++++ .../uam-wmi-msc/ext/plmindex/pl_maz.h | 546 ++++++++ .../uam-wmi-msc/ext/plmindex/qsort.c | 228 ++++ .../uam-wmi-msc/ext/plmindex/scanid.c | 877 +++++++++++++ .../uam-wmi-msc/ext/plmindex/scanid.h | 93 ++ .../uam-wmi-msc/ext/plmindex/scanst.c | 755 +++++++++++ .../uam-wmi-msc/ext/plmindex/scanst.h | 173 +++ .../uam-wmi-msc/ext/plmindex/sortid.c | 278 ++++ .../uam-wmi-msc/ext/plmindex/us_eng.h | 548 ++++++++ .../uam-wmi-msc/fixidx.sed | 48 + .../uam-wmi-msc/gitignore-template | 13 + .../uam-wmi-msc/init.sh | 28 + .../uam-wmi-msc/msc.mk | 38 + .../uam-wmi-msc/papalike.bst | 1106 ++++++++++++++++ .../uam-wmi-msc/plain-pl.bst | 1099 ++++++++++++++++ .../uam-wmi-msc/uam.png | Bin 0 -> 11995 bytes .../uam-wmi-msc/wmimgr.cls | 416 ++++++ .../{{cookiecutter.thesis_surname}}.tex | 78 ++ 61 files changed, 12904 insertions(+) create mode 100644 .gitignore create mode 100644 CHANGELOG.md create mode 100644 Jenkinsfile create mode 100644 README.md create mode 100644 cookiecutter.json create mode 100755 hooks/post_gen_project.sh create mode 100755 hooks/pre_gen_project.sh create mode 100644 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/.cookiecutter.yml create mode 100644 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/.gitignore create mode 100644 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/Makefile create mode 100644 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/README.md create mode 100644 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/appendix.tex create mode 100755 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/autozoil-via-docker.sh create mode 100644 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/bibliography.bib create mode 100755 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/build.sh create mode 100755 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/check.sh create mode 100755 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/extract-score-files.pl create mode 100755 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/helpers/pdf-to-plain-text.sh create mode 100755 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/helpers/stats.sh create mode 100755 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/helpers/synchro.sh create mode 100644 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/helpers/vars create mode 100755 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/install-hooks.sh create mode 100644 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/main.tex create mode 100644 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/metadata.tex create mode 100644 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/preamble.tex create mode 100644 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/.gitignore create mode 100755 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/build.sh create mode 100755 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/check.sh create mode 100644 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/Makefile create mode 100644 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/decode_n.c create mode 100644 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/decode_n.c.orig create mode 100644 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/genind.c create mode 100644 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/language.c create mode 100644 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/language.h create mode 100644 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/makefile.djg create mode 100644 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/makefile.emx create mode 100644 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/makefile.gcc create mode 100644 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/makefile.msc create mode 100644 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/mkind.c create mode 100644 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/mkind.h create mode 100644 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/myctype.h create mode 100644 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/pl_1250.h create mode 100644 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/pl_852.h create mode 100644 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/pl_iso2.h create mode 100644 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/pl_maz.h create mode 100644 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/qsort.c create mode 100644 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/scanid.c create mode 100644 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/scanid.h create mode 100644 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/scanst.c create mode 100644 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/scanst.h create mode 100644 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/sortid.c create mode 100644 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/us_eng.h create mode 100644 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/fixidx.sed create mode 100644 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/gitignore-template create mode 100755 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/init.sh create mode 100644 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/msc.mk create mode 100644 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/papalike.bst create mode 100644 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/plain-pl.bst create mode 100644 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/uam.png create mode 100644 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/wmimgr.cls create mode 100644 {{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/{{cookiecutter.thesis_surname}}.tex diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..b25c15b --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +*~ diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000..4bd1730 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,5 @@ + + +## 0.9.0 + +First official release diff --git a/Jenkinsfile b/Jenkinsfile new file mode 100644 index 0000000..1406c25 --- /dev/null +++ b/Jenkinsfile @@ -0,0 +1,11 @@ +pipeline { + + node ('tau2013z') { + + stage ('build-pdf') { + sh """ +bash build.sh +""" + } + } +} diff --git a/README.md b/README.md new file mode 100644 index 0000000..1e94ec5 --- /dev/null +++ b/README.md @@ -0,0 +1,61 @@ +Template for AMU thesis +======================= + +The template itself is in the `{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}`. + +In order to generate a project from the template: + +* install cookiecutter +* find a cookiecutter-applica-pypackage release applicable (usually the latest release/tag listed at ), say VERSION +* run: `cookiecutter https://git.wmi.amu.edu.pl/filipg/cookiecutter-amu-thesis.git --checkout VERSION` + +Interoperation with Overleaf +---------------------------- + +Overleaf handles git but it's very cr*ppy. It's better to upload a +package to Overleaf first: + +1. Create a project locally. +2. Run `make` +3. Run `make source-pack` +4. Upload the zip file to Overleaf. +5. Copy project to some other place. +5. Clone the repo from Overleaf: `git clone https://git.overleaf.com/FUNNY-OVERLEAF-CODE PAPERID-paper` +6. Set remotes: + +``` +git remote add overleaf https://git.overleaf.com/FUNNY-OVERLEAF-CODE +git remote set-url origin git@git.wmi.amu.edu.pl:YOURID/YOUR-GITLAB-REPO +``` + +7. Set credential helper so that stupid Overleaf won't ask about + password: `git config credential.helper "cache --timeout=10000000"` +8. Unfortunately, Overleaf will discard hidden files (`.*`) when a zip + is uploaded, also file permissions will be somewhat broken (did I + tell you how much I hate Overleaf?) +9. … so you need to copy `.cookiecutter.yml` file and re-apply the template (`cookiecutter https://git.wmi.amu.edu.pl/filipg/cookiecutter-amu-thesis.git --checkout VERSION --output-dir .. --config-file .cookiecutter.yml --no-input --overwrite-if-exists`) +10. Re-commit the files (including recovered `.*` files). +11. Push the repo to Overleaf (fortunately, the `.*` will be treated + correctly when this is done by git): `git push overleaf master` +12. Push the repo to GitLab. `git push origin master` +13. Set the Overleaf git remote in `helpers/vars` +14. Now you can synchronize between GitLab repo and Overleaf manually or using `helpers/synchro.sh` script + +Updating package with updated template +-------------------------------------- + +To keep your codebase in sync with template you need to occasionally reapply the template. +Here's how: + +* find a cookiecutter-amu-thesis release/tag applicable, say VERSION +* (do *not* refer to master in your projects!) +* go to project root +* run: `cookiecutter https://git.wmi.amu.edu.pl/filipg/cookiecutter-amu-thesis.git --checkout VERSION --output-dir .. --config-file .cookiecutter.yml --no-input --overwrite-if-exists` +* check changes with git + +### Releasing a new version of the template + +* add an item to `CHANGELOG.md` +* in case of breaking changes (_M_ is incremented) describe clearly + what actions are to be taken in `CHANGELOG.md` +* tag master with the version diff --git a/cookiecutter.json b/cookiecutter.json new file mode 100644 index 0000000..50a1dfb --- /dev/null +++ b/cookiecutter.json @@ -0,0 +1,6 @@ +{ + "thesis_type": "msc", + "thesis_surname": "iksinski", + "thesis_author": "Jan Iksiński", + "thesis_title": "Przykładowa praca" +} diff --git a/hooks/post_gen_project.sh b/hooks/post_gen_project.sh new file mode 100755 index 0000000..6d175b2 --- /dev/null +++ b/hooks/post_gen_project.sh @@ -0,0 +1,10 @@ +#!/bin/bash -xe + +if [ -e .git ]; then + git checkout README.md main.tex abstract.tex preamble.tex appendix.tex metadata.tex bibliography.bib helpers/vars +else + git init + git add --all + git commit -m 'init' + git remote add origin git@git.wmi.amu.edu.pl:{{cookiecutter.amu_id}}/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}.git +fi diff --git a/hooks/pre_gen_project.sh b/hooks/pre_gen_project.sh new file mode 100755 index 0000000..3c85b48 --- /dev/null +++ b/hooks/pre_gen_project.sh @@ -0,0 +1,6 @@ +#!/bin/bash -xe + +if [[ -e .git && ! -z "$(git status --untracked-files=no --porcelain)" ]]; then + >&2 echo "Uncommited changes, commit your changes first" + exit 1 +fi diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/.cookiecutter.yml b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/.cookiecutter.yml new file mode 100644 index 0000000..70d6f54 --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/.cookiecutter.yml @@ -0,0 +1,6 @@ +default_context: + thesis_type: '{{ cookiecutter.thesis_type }}' + thesis_surname: '{{ cookiecutter.thesis_surname }}' + thesis_author: '{{ cookiecutter.thesis_author }}' + thesis_title: '{{ cookiecutter.thesis_title }}' + amu_id: '{{ cookiecutter.amu_id }}' diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/.gitignore b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/.gitignore new file mode 100644 index 0000000..c5c3297 --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/.gitignore @@ -0,0 +1,150 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# pycharm configs +.idea + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +.hypothesis/ +.pytest_cache/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# pyenv +.python-version + +# celery beat schedule file +celerybeat-schedule + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ + +#Intellij +vcs.xml + +# data generated by parser +/data + +# autogenerated +/docs/source/reference/ + +# docs output +/docs/build/ + +# Caches +/.cache + +# Emacs +\#*\# +.\#* + +# JetBrains +.idea + +# Temporary +*~ + +*.aux +*.nav +*.toc +*.log +*.out +*.blg +*.bbl +*.synctex.gz +*.fdb_latexmk +*.fls +*.prv +/auto +{{cookiecutter.thesis_surname}}.pdf +{{cookiecutter.thesis_surname}}.zip +autozoil-log.txt +stats.txt +abstract.txt diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/Makefile b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/Makefile new file mode 100644 index 0000000..443b429 --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/Makefile @@ -0,0 +1,42 @@ +SHELL=/bin/bash + +THESIS_ID={{cookiecutter.thesis_surname}} + +all: $(THESIS_ID).pdf stats.txt + +source-pack: $(THESIS_ID).zip + +CONTENT_TEX_SOURCES=$(filter-out $(THESIS_ID).tex metadata.tex preamble.tex, $(wildcard *.tex)) + +CURRENT_DIR=$(shell pwd) +AUTOZOIL_DIR?=/opt/autozoil + +CONTENT_TEX_SOURCES_WITH_DIR := $(addprefix $(CURRENT_DIR)/, $(CONTENT_TEX_SOURCES)) +SCOREFILES=$(shell perl extract-score-files.pl $(CONTENT_TEX_SOURCES)) + +clean_latex_stuff=rm -rf *.aux *.nav *.toc *.log *.out *.blg *.bbl autozoil-log.txt $(THESIS_ID).pdf $(THESIS_ID).zip + +stats.txt: $(THESIS_ID).pdf helpers/stats.sh + bash helpers/stats.sh $< > $@ + cat $@ + +$(THESIS_ID).pdf: $(THESIS_ID).tex preamble.tex metadata.tex $(CONTENT_TEX_SOURCES) bibliography.bib $(SCOREFILES) + pdflatex $< + bibtex $(THESIS_ID) + pdflatex $< + pdflatex $< + +scores/%.txt: + mkdir -p scores + curl "https://gonito.net/api/txt/score/"$* -o $@ + +autozoil-log.txt: $(CONTENT_TEX_SOURCES) + cd $(AUTOZOIL_DIR) && set -o pipefail && ./autozoil --locale en_US $(CONTENT_TEX_SOURCES_WITH_DIR) --alt-log-file $(CURRENT_DIR)/$(THESIS_ID).log | tee $(CURRENT_DIR)/$@ + +$(THESIS_ID).zip: + $(clean_latex_stuff) + rm -rf *~ + zip -r $@ . -x '*.git*' '*.zip' + +clean: + $(clean_latex_stuff) diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/README.md b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/README.md new file mode 100644 index 0000000..ad9b1b9 --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/README.md @@ -0,0 +1 @@ +Master's thesis diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/appendix.tex b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/appendix.tex new file mode 100644 index 0000000..c5f53c4 --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/appendix.tex @@ -0,0 +1,17 @@ +{% raw %} +% +% Załączniki (opcjonalnie): +\appendix +\chapter{Tytuł załącznika jeden} + +Treść załącznika jeden. Treść załącznika jeden. Treść załącznika jeden +Treść załącznika jeden. Treść załącznika jeden. +Treść załącznika +jeden\index{żółw}\index{źdźbło}\index{zebra}. + +\chapter{Tytuł załącznika dwa} + +Treść załącznika dwa. Treść załącznika dwa. Treść załącznika dwa +Treść załącznika dwa. Treść załącznika dwa. +Treść załącznika dwa\index{system XML}. +{% endraw %} diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/autozoil-via-docker.sh b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/autozoil-via-docker.sh new file mode 100755 index 0000000..33fd8f3 --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/autozoil-via-docker.sh @@ -0,0 +1,3 @@ +#!/bin/bash + +docker run -v $(pwd):/link -it loxygen/autozoil /opt/autozoil/autozoil --locale en_US /link/main.tex --alt-log-file /link/{{cookiecutter.thesis_surname}}.log diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/bibliography.bib b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/bibliography.bib new file mode 100644 index 0000000..690c9ea --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/bibliography.bib @@ -0,0 +1,1153 @@ +{% raw %} + +@incollection { gonito2016, + title = {Gonito.net -- Open Platform for Research Competition, Cooperation and Reproducibility}, + author = "Grali{\'n}ski, Filip and Jaworski, Rafa{\l} and Borchmann, {\L}ukasz and Wierzcho{\'n}, Piotr", + editor = "Branco, António and Calzolari , Nicoletta and Choukri, Khalid", + booktitle = {Proceedings of the 4REAL Workshop: Workshop on Research Results Reproducibility and Resources Citation in Science and Technology of Language}, + year = "2016", + pages = "13-20" +} + +@inproceedings{stanislawek-etal-2019-named, + title = "Named Entity Recognition - Is There a Glass Ceiling?", + author = "Stanislawek, Tomasz and + Wr{\'o}blewska, Anna and + W{\'o}jcicka, Alicja and + Ziembicki, Daniel and + Biecek, Przemyslaw", + booktitle = "Proceedings of the 23rd Conference on Computational Natural Language Learning (CoNLL)", + month = nov, + year = "2019", + address = "Hong Kong, China", + publisher = "Association for Computational Linguistics", + url = "https://www.aclweb.org/anthology/K19-1058", + doi = "10.18653/v1/K19-1058", + pages = "624--633", + abstract = "Recent developments in Named Entity Recognition (NER) have resulted in better and better models. However, is there a glass ceiling? Do we know which types of errors are still hard or even impossible to correct? In this paper, we present a detailed analysis of the types of errors in state-of-the-art machine learning (ML) methods. Our study illustrates weak and strong points of the Stanford, CMU, FLAIR, ELMO and BERT models, as well as their shared limitations. We also introduce new techniques for improving annotation, training process, and for checking model quality and stability.", +} + +@misc{borchmann2019searching, + title={Searching for Legal Clauses by Analogy. Few-shot Semantic Retrieval Shared Task}, + author={Łukasz Borchmann and Dawid Wiśniewski and Andrzej Gretkowski and Izabela Kosmala and Dawid Jurkiewicz and Łukasz Szałkiewicz and Gabriela Pałka and Karol Kaczmarek and Agnieszka Kaliska and Filip Graliński}, + year={2019}, + eprint={1911.03911}, + archivePrefix={arXiv}, + primaryClass={cs.CL} +} + +@inproceedings{gralinski-etal-2019-geval, + title = "{GE}val: Tool for Debugging {NLP} Datasets and Models", + author = "Grali{\'n}ski, Filip and + Wr{\'o}blewska, Anna and + Stanis{\l}awek, Tomasz and + Grabowski, Kamil and + G{\'o}recki, Tomasz", + booktitle = "Proceedings of the 2019 ACL Workshop BlackboxNLP: Analyzing and Interpreting Neural Networks for NLP", + month = aug, + year = "2019", + address = "Florence, Italy", + publisher = "Association for Computational Linguistics", + url = "https://www.aclweb.org/anthology/W19-4826", + pages = "254--262", + abstract = "This paper presents a simple but general and effective method to debug the output of machine learning (ML) supervised models, including neural networks. The algorithm looks for features that lower the evaluation metric in such a way that it cannot be ascribed to chance (as measured by their p-values). Using this method {--} implemented as MLEval tool {--} you can find: (1) anomalies in test sets, (2) issues in preprocessing, (3) problems in the ML model itself. It can give you an insight into what can be improved in the datasets and/or the model. The same method can be used to compare ML models or different versions of the same model. We present the tool, the theory behind it and use cases for text-based models of various types.", +} + +@inproceedings{Borchmann2018, +title = {Approaching nested named entity recognition with parallel LSTM-CRFs}, +author = {Łukasz Borchmann and Andrzej Gretkowski and Filip Graliński}, +editor = {Maciej Ogrodniczuk and Łukasz Kobyliński}, +url = {http://www.borchmann.pl/wp-content/uploads/2018/10/borchmann-lukasz.pdf}, +year = {2018}, +date = {2018-10-19}, +booktitle = {Proceedings of the PolEval 2018 Workshop}, +pages = {63-73}, +publisher = {Institute of Computer Science, Polish Academy of Science}, +address = {Warszawa}, +keywords = {}, +pubstate = {published}, +tppubtype = {inproceedings} +} + + +@article{DBLP:journals/corr/HewlettLJPFHKB16, + author = {Daniel Hewlett and + Alexandre Lacoste and + Llion Jones and + Illia Polosukhin and + Andrew Fandrianto and + Jay Han and + Matthew Kelcey and + David Berthelot}, + title = "{WikiReading: {A} Novel Large-scale Language Understanding Task over + Wikipedia}", + journal = {CoRR}, + volume = {abs/1608.03542}, + year = {2016}, + url = {http://arxiv.org/abs/1608.03542}, + archivePrefix = {arXiv}, + eprint = {1608.03542}, + timestamp = {Mon, 13 Aug 2018 16:46:41 +0200}, + biburl = {https://dblp.org/rec/bib/journals/corr/HewlettLJPFHKB16}, + bibsource = {dblp computer science bibliography, https://dblp.org} +} + +@inproceedings{byte-level2018kenter, + title={Byte-level Machine Reading across Morphologically Varied Languages}, + author={Tom Kenter and Llion Jones and Daniel Hewlett}, + booktitle={Proceedings of the The Thirty-Second AAAI Conference on Artificial Intelligence (AAAI-18)}, + year={2018} +} + +@article{DBLP:journals/corr/SutskeverVL14, + author = {Ilya Sutskever and + Oriol Vinyals and + Quoc V. Le}, + title = "{Sequence to Sequence Learning with Neural Networks}", + journal = {CoRR}, + volume = {abs/1409.3215}, + year = {2014}, + url = {http://arxiv.org/abs/1409.3215}, + archivePrefix = {arXiv}, + eprint = {1409.3215}, + timestamp = {Mon, 13 Aug 2018 16:48:06 +0200}, + biburl = {https://dblp.org/rec/bib/journals/corr/SutskeverVL14}, + bibsource = {dblp computer science bibliography, https://dblp.org} +} + +@article{DBLP:journals/corr/abs-1811-04284, + author = {Hainan Xu and + Shuoyang Ding and + Shinji Watanabe}, + title = "{Improving End-to-end Speech Recognition with Pronunciation-assisted + Sub-word Modeling}", + journal = {CoRR}, + volume = {abs/1811.04284}, + year = {2018}, + url = {http://arxiv.org/abs/1811.04284}, + archivePrefix = {arXiv}, + eprint = {1811.04284}, + timestamp = {Fri, 23 Nov 2018 12:43:51 +0100}, + biburl = {https://dblp.org/rec/bib/journals/corr/abs-1811-04284}, + bibsource = {dblp computer science bibliography, https://dblp.org} +} + +@inproceedings{holt-chisholm-2018-extracting, + title = "Extracting structured data from invoices", + author = "Holt, Xavier and + Chisholm, Andrew", + booktitle = "Proceedings of the Australasian Language Technology Association Workshop 2018", + month = dec, + year = "2018", + address = "Dunedin, New Zealand", + url = "https://www.aclweb.org/anthology/U18-1006", + pages = "53--59", + abstract = "Business documents encode a wealth of information in a format tailored to human consumption {--} i.e. aesthetically disbursed natural language text, graphics and tables. We address the task of extracting key fields (e.g. the amount due on an invoice) from a wide-variety of potentially unseen document formats. In contrast to traditional template driven extraction systems, we introduce a content-driven machine-learning approach which is both robust to noise and generalises to unseen document formats. In a comparison of our approach with alternative invoice extraction systems, we observe an absolute accuracy gain of 20{\textbackslash}{\%} across compared fields, and a 25{\textbackslash}{\%}{--}94{\textbackslash}{\%} reduction in extraction latency.", +} + +@article{DBLP:journals/corr/abs-1907-11692, + author = {Yinhan Liu and + Myle Ott and + Naman Goyal and + Jingfei Du and + Mandar Joshi and + Danqi Chen and + Omer Levy and + Mike Lewis and + Luke Zettlemoyer and + Veselin Stoyanov}, + title = "{RoBERTa: {A} Robustly Optimized {BERT} Pretraining Approach}", + journal = {CoRR}, + volume = {abs/1907.11692}, + year = {2019}, + url = {http://arxiv.org/abs/1907.11692}, + archivePrefix = {arXiv}, + eprint = {1907.11692}, + timestamp = {Thu, 01 Aug 2019 08:59:33 +0200}, + biburl = {https://dblp.org/rec/bib/journals/corr/abs-1907-11692}, + bibsource = {dblp computer science bibliography, https://dblp.org} +} + + +@article{ke2018focused, + title={Focused hierarchical rnns for conditional sequence processing}, + author={Ke, Nan Rosemary and Zolna, Konrad and Sordoni, Alessandro and Lin, Zhouhan and Trischler, Adam and Bengio, Yoshua and Pineau, Joelle and Charlin, Laurent and Pal, Chris}, + journal={arXiv preprint arXiv:1806.04342}, + year={2018} +} + + +@article{DBLP:journals/corr/abs-1901-02860, + author = {Zihang Dai and + Zhilin Yang and + Yiming Yang and + Jaime G. Carbonell and + Quoc V. Le and + Ruslan Salakhutdinov}, + title = "{Transformer-XL: Attentive Language Models Beyond a Fixed-Length Context}", + journal = {CoRR}, + volume = {abs/1901.02860}, + year = {2019}, + url = {http://arxiv.org/abs/1901.02860}, + archivePrefix = {arXiv}, + eprint = {1901.02860}, + timestamp = {Fri, 01 Feb 2019 13:39:59 +0100}, + biburl = {https://dblp.org/rec/bib/journals/corr/abs-1901-02860}, + bibsource = {dblp computer science bibliography, https://dblp.org} +} + +@article{DBLP:journals/corr/abs-1906-08237, + author = {Zhilin Yang and + Zihang Dai and + Yiming Yang and + Jaime G. Carbonell and + Ruslan Salakhutdinov and + Quoc V. Le}, + title = "{XLNet: Generalized Autoregressive Pretraining for Language Understanding}", + journal = {CoRR}, + volume = {abs/1906.08237}, + year = {2019}, + url = {http://arxiv.org/abs/1906.08237}, + archivePrefix = {arXiv}, + eprint = {1906.08237}, + timestamp = {Mon, 24 Jun 2019 17:28:45 +0200}, + biburl = {https://dblp.org/rec/bib/journals/corr/abs-1906-08237}, + bibsource = {dblp computer science bibliography, https://dblp.org} +} + +@article{DBLP:journals/corr/abs-1907-06170, + author = {Marcin Junczys{-}Dowmunt}, + title = "{Microsoft Translator at {WMT} 2019: Towards Large-Scale Document-Level + Neural Machine Translation}", + journal = {CoRR}, + volume = {abs/1907.06170}, + year = {2019}, + url = {http://arxiv.org/abs/1907.06170}, + archivePrefix = {arXiv}, + eprint = {1907.06170}, + timestamp = {Wed, 17 Jul 2019 10:27:36 +0200}, + biburl = {https://dblp.org/rec/bib/journals/corr/abs-1907-06170}, + bibsource = {dblp computer science bibliography, https://dblp.org} +} + +@inproceedings{akbik2018coling, + title={Contextual String Embeddings for Sequence Labeling}, + author={Akbik, Alan and Blythe, Duncan and Vollgraf, Roland}, + booktitle = {{COLING} 2018, 27th International Conference on Computational Linguistics}, + pages = {1638--1649}, + year = {2018} +} + + +@article{luo2019named, + title={Named Entity Recognition Only from Word Embeddings}, + author={Luo, Ying and Zhao, Hai and Zhan, Junlang}, + journal={arXiv preprint arXiv:1909.00164}, + year={2019} +} + +@article{tu2018learning, + title={Learning to remember translation history with a continuous cache}, + author={Tu, Zhaopeng and Liu, Yang and Shi, Shuming and Zhang, Tong}, + journal={Transactions of the Association for Computational Linguistics}, + volume={6}, + pages={407--420}, + year={2018}, + publisher={MIT Press} +} + +@article{miculicich2018document, + title={Document-level neural machine translation with hierarchical attention networks}, + author={Miculicich, Lesly and Ram, Dhananjay and Pappas, Nikolaos and Henderson, James}, + journal={arXiv preprint arXiv:1809.01576}, + year={2018} +} + +@article{DBLP:journals/corr/abs-1907-05242, + author = {Guillaume Lample and + Alexandre Sablayrolles and + Marc'Aurelio Ranzato and + Ludovic Denoyer and + Herv{\'{e}} J{\'{e}}gou}, + title = "{Large Memory Layers with Product Keys}", + journal = {CoRR}, + volume = {abs/1907.05242}, + year = {2019}, + url = {http://arxiv.org/abs/1907.05242}, + archivePrefix = {arXiv}, + eprint = {1907.05242}, + timestamp = {Wed, 17 Jul 2019 10:27:36 +0200}, + biburl = {https://dblp.org/rec/bib/journals/corr/abs-1907-05242}, + bibsource = {dblp computer science bibliography, https://dblp.org} +} + + +@article{DBLP:journals/corr/abs-1907-01686, + author = {Xin Zhang and + An Yang and + Sujian Li and + Yizhong Wang}, + title = {Machine Reading Comprehension: a Literature Review}, + journal = {CoRR}, + volume = {abs/1907.01686}, + year = {2019}, + url = {http://arxiv.org/abs/1907.01686}, + archivePrefix = {arXiv}, + eprint = {1907.01686}, + timestamp = {Mon, 08 Jul 2019 14:12:33 +0200}, + biburl = {https://dblp.org/rec/bib/journals/corr/abs-1907-01686}, + bibsource = {dblp computer science bibliography, https://dblp.org} +} + +@article{DBLP:journals/corr/abs-1810-04805, + author = {Jacob Devlin and + Ming{-}Wei Chang and + Kenton Lee and + Kristina Toutanova}, + title = "{{BERT:} Pre-training of Deep Bidirectional Transformers for Language + Understanding}", + journal = {CoRR}, + volume = {abs/1810.04805}, + year = {2018}, + url = {http://arxiv.org/abs/1810.04805}, + archivePrefix = {arXiv}, + eprint = {1810.04805}, + timestamp = {Tue, 30 Oct 2018 20:39:56 +0100}, + biburl = {https://dblp.org/rec/bib/journals/corr/abs-1810-04805}, + bibsource = {dblp computer science bibliography, https://dblp.org} +} + + +@article{DBLP:journals/corr/abs-1809-08799, + author = {Anoop R. Katti and + Christian Reisswig and + Cordula Guder and + Sebastian Brarda and + Steffen Bickel and + Johannes H{\"{o}}hne and + Jean Baptiste Faddoul}, + title = {Chargrid: Towards Understanding 2D Documents}, + journal = {CoRR}, + volume = {abs/1809.08799}, + year = {2018}, + url = {http://arxiv.org/abs/1809.08799}, + archivePrefix = {arXiv}, + eprint = {1809.08799}, + timestamp = {Fri, 05 Oct 2018 11:34:52 +0200}, + biburl = {https://dblp.org/rec/bib/journals/corr/abs-1809-08799}, + bibsource = {dblp computer science bibliography, https://dblp.org} +} + +@article{DBLP:journals/corr/HamiltonYL17, + author = {William L. Hamilton and + Rex Ying and + Jure Leskovec}, + title = {Inductive Representation Learning on Large Graphs}, + journal = {CoRR}, + volume = {abs/1706.02216}, + year = {2017}, + url = {http://arxiv.org/abs/1706.02216}, + archivePrefix = {arXiv}, + eprint = {1706.02216}, + timestamp = {Mon, 13 Aug 2018 16:46:12 +0200}, + biburl = {https://dblp.org/rec/bib/journals/corr/HamiltonYL17}, + bibsource = {dblp computer science bibliography, https://dblp.org} +} + +@article{DBLP:journals/corr/abs-1810-00826, + author = {Keyulu Xu and + Weihua Hu and + Jure Leskovec and + Stefanie Jegelka}, + title = {How Powerful are Graph Neural Networks?}, + journal = {CoRR}, + volume = {abs/1810.00826}, + year = {2018}, + url = {http://arxiv.org/abs/1810.00826}, + archivePrefix = {arXiv}, + eprint = {1810.00826}, + timestamp = {Tue, 30 Oct 2018 10:49:09 +0100}, + biburl = {https://dblp.org/rec/bib/journals/corr/abs-1810-00826}, + bibsource = {dblp computer science bibliography, https://dblp.org} +} + +@inproceedings{matuschek2008measuring, + title={Measuring text similarity with dynamic time warping}, + author={Matuschek, Michael and Schl{\"u}ter, Tim and Conrad, Stefan}, + booktitle={Proceedings of the 2008 international symposium on Database engineering \& applications}, + pages={263--267}, + year={2008}, + organization={ACM} +} + +@article{simonyan2014very, + title={Very deep convolutional networks for large-scale image recognition}, + author={Simonyan, Karen and Zisserman, Andrew}, + journal={arXiv preprint arXiv:1409.1556}, + year={2014} +} + +@article{lecun2015lenet, + title={LeNet-5, convolutional neural networks}, + author={LeCun, Yann and others}, + journal={URL: http://yann. lecun. com/exdb/lenet}, + volume={20}, + pages={5}, + year={2015} +} + +@article{bergstra2012random, + title={Random Search for Hyper-Parameter Optimization}, + author={Bergstra, James and Bengio, Yoshua}, + journal={Journal of Machine Learning Research}, + volume={13}, + pages={281--305}, + year={2012} +} + +@incollection{hinton2012practical, + title={A practical guide to training restricted Boltzmann machines}, + author={Hinton, Geoffrey E}, + booktitle={Neural networks: Tricks of the trade}, + pages={599--619}, + year={2012}, + publisher={Springer} +} + +@book{hedges2014statistical, + title={Statistical methods for meta-analysis}, + author={Hedges, Larry V and Olkin, Ingram}, + year={2014}, + publisher={Academic press} +} + +@inproceedings{koehn2004statistical, + title={Statistical significance tests for machine translation evaluation}, + author={Koehn, Philipp}, + booktitle={Proceedings of the 2004 conference on empirical methods in natural language processing}, + pages={388--395}, + year={2004} +} + +@article{DBLP:journals/corr/abs-1904-01685, + author = {Jeremy Nixon and + Mike Dusenberry and + Linchuan Zhang and + Ghassen Jerfel and + Dustin Tran}, + title = {Measuring Calibration in Deep Learning}, + journal = {CoRR}, + volume = {abs/1904.01685}, + year = {2019}, + url = {http://arxiv.org/abs/1904.01685}, + archivePrefix = {arXiv}, + eprint = {1904.01685}, + timestamp = {Wed, 24 Apr 2019 12:21:25 +0200}, + biburl = {https://dblp.org/rec/bib/journals/corr/abs-1904-01685}, + bibsource = {dblp computer science bibliography, https://dblp.org} +} + +@article{settles2012active, + title={Active learning}, + author={Settles, Burr}, + journal={Synthesis Lectures on Artificial Intelligence and Machine Learning}, + volume={6}, + number={1}, + pages={1--114}, + year={2012}, + publisher={Morgan \& Claypool Publishers} +} + +@incollection{NIPS2017_7062, +title = {A Unified Approach to Interpreting Model Predictions}, +author = {Lundberg, Scott M and Lee, Su-In}, +booktitle = {Advances in Neural Information Processing Systems 30}, +editor = {I. Guyon and U. V. Luxburg and S. Bengio and H. Wallach and R. Fergus and S. Vishwanathan and R. Garnett}, +pages = {4765--4774}, +year = {2017}, +publisher = {Curran Associates, Inc.}, +url = {http://papers.nips.cc/paper/7062-a-unified-approach-to-interpreting-model-predictions.pdf} +} + +@article{austin2014graphical, + title={Graphical assessment of internal and external calibration of logistic regression models by using loess smoothers}, + author={Austin, Peter C and Steyerberg, Ewout W}, + journal={Statistics in medicine}, + volume={33}, + number={3}, + pages={517--535}, + year={2014}, + publisher={Wiley Online Library} +} + +@article{lan2019albert, + title={ALBERT: A Lite BERT for Self-supervised Learning of Language Representations}, + author={Lan, Zhenzhong and Chen, Mingda and Goodman, Sebastian and Gimpel, Kevin and Sharma, Piyush and Soricut, Radu}, + journal={arXiv preprint arXiv:1909.11942}, + year={2019} +} + +@article{jiao2019tinybert, + title={TinyBERT: Distilling BERT for Natural Language Understanding}, + author={Jiao, Xiaoqi and Yin, Yichun and Shang, Lifeng and Jiang, Xin and Chen, Xiao and Li, Linlin and Wang, Fang and Liu, Qun}, + journal={arXiv preprint arXiv:1909.10351}, + year={2019} +} + +@article{wiewel2019localizing, + title={Localizing Catastrophic Forgetting in Neural Networks}, + author={Wiewel, Felix and Yang, Bin}, + journal={arXiv preprint arXiv:1906.02568}, + year={2019} +} + +@article{hinton2015distilling, + title={Distilling the knowledge in a neural network}, + author={Hinton, Geoffrey and Vinyals, Oriol and Dean, Jeff}, + journal={arXiv preprint arXiv:1503.02531}, + year={2015} +} + +@article{hubara2017quantized, + title={Quantized neural networks: Training neural networks with low precision weights and activations}, + author={Hubara, Itay and Courbariaux, Matthieu and Soudry, Daniel and El-Yaniv, Ran and Bengio, Yoshua}, + journal={The Journal of Machine Learning Research}, + volume={18}, + number={1}, + pages={6869--6898}, + year={2017}, + publisher={JMLR. org} +} + +@article{bao2019few, + title={Few-shot Text Classification with Distributional Signatures}, + author={Bao, Yujia and Wu, Menghua and Chang, Shiyu and Barzilay, Regina}, + journal={arXiv preprint arXiv:1908.06039}, + year={2019} +} + +@article{DBLP:journals/corr/NarayanGCS17, + author = {Shashi Narayan and + Claire Gardent and + Shay B. Cohen and + Anastasia Shimorina}, + title = {Split and Rephrase}, + journal = {CoRR}, + volume = {abs/1707.06971}, + year = {2017}, + url = {http://arxiv.org/abs/1707.06971}, + archivePrefix = {arXiv}, + eprint = {1707.06971}, + timestamp = {Mon, 13 Aug 2018 16:48:49 +0200}, + biburl = {https://dblp.org/rec/bib/journals/corr/NarayanGCS17}, + bibsource = {dblp computer science bibliography, https://dblp.org} +} + +@article{DBLP:journals/corr/abs-1906-01038, + author = {Christina Niklaus and + Matthias Cetto and + Andr{\'{e}} Freitas and + Siegfried Handschuh}, + title = {Transforming Complex Sentences into a Semantic Hierarchy}, + journal = {CoRR}, + volume = {abs/1906.01038}, + year = {2019}, + url = {http://arxiv.org/abs/1906.01038}, + archivePrefix = {arXiv}, + eprint = {1906.01038}, + timestamp = {Thu, 13 Jun 2019 13:36:00 +0200}, + biburl = {https://dblp.org/rec/bib/journals/corr/abs-1906-01038}, + bibsource = {dblp computer science bibliography, https://dblp.org} +} + +@inproceedings{goldberger2005neighbourhood, + title={Neighbourhood components analysis}, + author={Goldberger, Jacob and Hinton, Geoffrey E and Roweis, Sam T and Salakhutdinov, Ruslan R}, + booktitle={Advances in neural information processing systems}, + pages={513--520}, + year={2005} +} + +@article{hyvarinen2000independent, + title={Independent component analysis: algorithms and applications}, + author={Hyv{\"a}rinen, Aapo and Oja, Erkki}, + journal={Neural networks}, + volume={13}, + number={4-5}, + pages={411--430}, + year={2000}, + publisher={Elsevier} +} + +@article{DBLP:journals/corr/abs-1804-00079, + author = {Sandeep Subramanian and + Adam Trischler and + Yoshua Bengio and + Christopher J. Pal}, + title = {Learning General Purpose Distributed Sentence Representations via + Large Scale Multi-task Learning}, + journal = {CoRR}, + volume = {abs/1804.00079}, + year = {2018}, + url = {http://arxiv.org/abs/1804.00079}, + archivePrefix = {arXiv}, + eprint = {1804.00079}, + timestamp = {Mon, 13 Aug 2018 16:47:55 +0200}, + biburl = {https://dblp.org/rec/bib/journals/corr/abs-1804-00079}, + bibsource = {dblp computer science bibliography, https://dblp.org} +} + +@article{DBLP:journals/corr/ConneauKSBB17, + author = {Alexis Conneau and + Douwe Kiela and + Holger Schwenk and + Lo{\"{\i}}c Barrault and + Antoine Bordes}, + title = {Supervised Learning of Universal Sentence Representations from Natural + Language Inference Data}, + journal = {CoRR}, + volume = {abs/1705.02364}, + year = {2017}, + url = {http://arxiv.org/abs/1705.02364}, + archivePrefix = {arXiv}, + eprint = {1705.02364}, + timestamp = {Mon, 13 Aug 2018 16:48:46 +0200}, + biburl = {https://dblp.org/rec/bib/journals/corr/ConneauKSBB17}, + bibsource = {dblp computer science bibliography, https://dblp.org} +} + + + +@proceedings{2019:3322640, + title = {ICAIL '19: Proceedings of the Seventeenth International Conference on Artificial Intelligence and Law}, + year = {2019}, + isbn = {978-1-4503-6754-7}, + location = {Montreal, QC, Canada}, + publisher = {ACM}, + address = {New York, NY, USA}, +key = {{$\!\!$}} , +} + + +@article{GOODMAN2001403, +title = "A bit of progress in language modeling", +journal = "Computer Speech \& Language", +volume = "15", +number = "4", +pages = "403-434", +year = "2001", +issn = "0885-2308", +doi = "10.1006/csla.2001.0174", +OPTurl = "http://www.sciencedirect.com/science/article/pii/S0885230801901743", +author = "Joshua T. Goodman" +} + +@article{DBLP:journals/corr/cs-CL-9905001, + author = {Rebecca Hwa}, + title = {Supervised Grammar Induction Using Training Data with Limited Constituent Information}, + journal = {CoRR}, + volume = {cs.CL/9905001}, + note = {Version 1}, + year = {1999}, + url = {http://arxiv.org/abs/cs.CL/9905001}, + timestamp = {Wed, 07 Jun 2017 14:41:01 +0200}, + biburl = {https://dblp.org/rec/bib/journals/corr/cs-CL-9905001}, + bibsource = {dblp computer science bibliography, https://dblp.org} +} + +@book{Jurafsky+Martin:2009a, + author = {Jurafsky, Daniel and Martin, James H.}, + title = {Speech and Language Processing: An Introduction to Natural Language Processing, Computational Linguistics, and Speech Recognition}, + publisher = {Pearson Prentice Hall}, + year = 2009, + edition = {Second} +} + +@inproceedings{Maxwell2008ConceptAC, + title={Concept and Context in Legal Information Retrieval}, + author={K. Tamsin Maxwell and Burkhard Schafer}, + booktitle={JURIX}, + year={2008} +} + +@misc{41224, +title = {Efficient Estimation of Word Representations in Vector Space}, +author = {Tomas Mikolov and Kai Chen and Greg S. Corrado and Jeffrey Dean}, +year = {2013}, +URL = {http://arxiv.org/abs/1301.3781} +} + +@misc{wieting2019training, + title={No Training Required: Exploring Random Encoders for Sentence Classification}, + author={John Wieting and Douwe Kiela}, + year={2019}, + eprint={1901.10444}, + archivePrefix={arXiv}, + primaryClass={cs.CL} +} + +@inproceedings{jiao-etal-2018-convolutional, + title = "Convolutional Neural Network for Universal Sentence Embeddings", + author = "Jiao, Xiaoqi and + Wang, Fang and + Feng, Dan", + booktitle = "Proceedings of the 27th International Conference on Computational Linguistics", + month = aug, + year = "2018", + address = "Santa Fe, New Mexico, USA", + publisher = "Association for Computational Linguistics", + url = "https://www.aclweb.org/anthology/C18-1209", + pages = "2470--2481", + abstract = "This paper proposes a simple CNN model for creating general-purpose sentence embeddings that can transfer easily across domains and can also act as effective initialization for downstream tasks. Recently, averaging the embeddings of words in a sentence has proven to be a surprisingly successful and efficient way of obtaining sentence embeddings. However, these models represent a sentence, only in terms of features of words or uni-grams in it. In contrast, our model (CSE) utilizes both features of words and n-grams to encode sentences, which is actually a generalization of these bag-of-words models. The extensive experiments demonstrate that CSE performs better than average models in transfer learning setting and exceeds the state of the art in supervised learning setting by initializing the parameters with the pre-trained sentence embeddings.", +} + +@misc{zhang2018learning, + title={Learning Universal Sentence Representations with Mean-Max Attention Autoencoder}, + author={Minghua Zhang and Yunfang Wu and Weikang Li and Wei Li}, + year={2018}, + eprint={1809.06590}, + archivePrefix={arXiv}, + primaryClass={cs.CL} +} + +@misc{conneau2017supervised, + title={Supervised Learning of Universal Sentence Representations from Natural Language Inference Data}, + author={Alexis Conneau and Douwe Kiela and Holger Schwenk and Loic Barrault and Antoine Bordes}, + year={2017}, + eprint={1705.02364}, + archivePrefix={arXiv}, + primaryClass={cs.CL} +} + +@article{DBLP:journals/corr/abs-1804-00079, + author = {Sandeep Subramanian and + Adam Trischler and + Yoshua Bengio and + Christopher J. Pal}, + title = {Learning General Purpose Distributed Sentence Representations via + Large Scale Multi-task Learning}, + journal = {CoRR}, + volume = {abs/1804.00079}, + year = {2018}, + url = {http://arxiv.org/abs/1804.00079}, + archivePrefix = {arXiv}, + eprint = {1804.00079}, + timestamp = {Mon, 13 Aug 2018 16:47:55 +0200}, + biburl = {https://dblp.org/rec/bib/journals/corr/abs-1804-00079}, + bibsource = {dblp computer science bibliography, https://dblp.org} +} + +@incollection{NIPS2015_5950, +title = {Skip-Thought Vectors}, +author = {Kiros, Ryan and Zhu, Yukun and Salakhutdinov, Ruslan R and Zemel, Richard and Urtasun, Raquel and Torralba, Antonio and Fidler, Sanja}, +booktitle = {Advances in Neural Information Processing Systems 28}, +editor = {C. Cortes and N. D. Lawrence and D. D. Lee and M. Sugiyama and R. Garnett}, +pages = {3294--3302}, +year = {2015}, +publisher = {Curran Associates, Inc.}, +url = {http://papers.nips.cc/paper/5950-skip-thought-vectors.pdf} +} + +@misc{ionescu2019vector, + title="{Vector of Locally-Aggregated Word Embeddings (VLAWE): A Novel Document-level Representation}", + author={Radu Tudor Ionescu and Andrei M. Butnaru}, + year={2019}, + eprint={1902.08850}, + archivePrefix={arXiv}, + primaryClass={cs.CL} +} + +@article{Yang2018ZerotrainingSE, + title={Zero-training Sentence Embedding via Orthogonal Basis}, + author={Ziyi Yang and Chenguang Zhu and Weizhu Chen}, + journal={ArXiv}, + year={2018}, + volume={abs/1810.00438} +} + +@misc{shen2018baseline, + title={Baseline Needs More Love: On Simple Word-Embedding-Based Models and Associated Pooling Mechanisms}, + author={Dinghan Shen and Guoyin Wang and Wenlin Wang and Martin Renqiang Min and Qinliang Su and Yizhe Zhang and Chunyuan Li and Ricardo Henao and Lawrence Carin}, + year={2018}, + eprint={1805.09843}, + archivePrefix={arXiv}, + primaryClass={cs.CL} +} + +@article{DBLP:journals/corr/abs-1902-06423, + author = {Florian Mai and + Lukas Galke and + Ansgar Scherp}, + title = {{CBOW} Is Not All You Need: Combining {CBOW} with the Compositional + Matrix Space Model}, + journal = {CoRR}, + volume = {abs/1902.06423}, + year = {2019}, + url = {http://arxiv.org/abs/1902.06423}, + archivePrefix = {arXiv}, + eprint = {1902.06423}, + timestamp = {Tue, 21 May 2019 18:03:37 +0200}, + biburl = {https://dblp.org/rec/bib/journals/corr/abs-1902-06423}, + bibsource = {dblp computer science bibliography, https://dblp.org} +} + +@article{DBLP:journals/corr/abs-1809-04262, + author = {Rashmi Nagpal and + Chetna Wadhwa and + Mallika Gupta and + Samiulla Shaikh and + Sameep Mehta and + Vikram Goyal}, + title = {Extracting Fairness Policies from Legal Documents}, + journal = {CoRR}, + volume = {abs/1809.04262}, + year = {2018}, + url = {http://arxiv.org/abs/1809.04262}, + archivePrefix = {arXiv}, + eprint = {1809.04262}, + timestamp = {Fri, 05 Oct 2018 11:34:52 +0200}, + biburl = {https://dblp.org/rec/bib/journals/corr/abs-1809-04262}, + bibsource = {dblp computer science bibliography, https://dblp.org} +} + +@ARTICLE {doi:10.1080/00437956.1954.11659520, + author = "Zellig S. Harris", + title = "Distributional Structure", + journal = "WORD", + year = "1954", + volume = "10", + number = "2-3", + pages = "146-162", + publisher = "Routledge", + doi = "10.1080/00437956.1954.11659520", +} + + +@article{Halko:2011:FSR:2078879.2078881, + author = {Halko, N. and Martinsson, P. G. and Tropp, J. A.}, + title = {Finding Structure with Randomness: Probabilistic Algorithms for Constructing Approximate Matrix Decompositions}, + journal = {SIAM Rev.}, + issue_date = {May 2011}, + volume = {53}, + number = {2}, + month = may, + year = {2011}, + issn = {0036-1445}, + pages = {217--288}, + numpages = {72}, + url = {http://dx.doi.org/10.1137/090771806}, + doi = {10.1137/090771806}, + acmid = {2078881}, + publisher = {Society for Industrial and Applied Mathematics}, + address = {Philadelphia, PA, USA}, + keywords = {Johnson-Lindenstrauss lemma, dimension reduction, eigenvalue decomposition, interpolative decomposition, matrix approximation, parallel algorithm, pass-efficient algorithm, principal component analysis, random matrix, randomized algorithm, rank-revealing QR factorization, singular value decomposition, streaming algorithm}, +} + +@book{books/daglib/0031897, + added-at = {2013-10-06T00:00:00.000+0200}, + author = {Büttcher, Stefan and Clarke, Charles L. A. and Cormack, Gordon V.}, + biburl = {https://www.bibsonomy.org/bibtex/2e679957b4a1bdf252c3a33296397f434/dblp}, + ee = {http://mitpress.mit.edu/books/information-retrieval}, + interhash = {8aba6a7cd5e81a4c68dc1d6c9102fe7b}, + intrahash = {e679957b4a1bdf252c3a33296397f434}, + isbn = {978-0-262-02651-2}, + keywords = {dblp}, + pages = {I-XXIV, 1-606}, + publisher = {MIT Press}, + timestamp = {2013-10-08T11:35:46.000+0200}, + title = {Information Retrieval - Implementing and Evaluating Search Engines.}, + year = 2010 +} + +@article{Wolf2019HuggingFacesTS, + title="{HuggingFace's Transformers: State-of-the-art Natural Language Processing}", + author={Thomas Wolf and Lysandre Debut and Victor Sanh and Julien Chaumond and Clement Delangue and Anthony Moi and Pierric Cistac and Tim Rault and R'emi Louf and Morgan Funtowicz and Jamie Brew}, + journal={ArXiv}, + year={2019}, + volume={abs/1910.03771} +} + +@misc{gillick2018endtoend, + title={End-to-End Retrieval in Continuous Space}, + author={Daniel Gillick and Alessandro Presta and Gaurav Singh Tomar}, + year={2018}, + eprint={1811.08008}, + archivePrefix={arXiv}, + primaryClass={cs.IR} +} + +@misc{almarwani2019efficient, + title={Efficient Sentence Embedding using Discrete Cosine Transform}, + author={Nada Almarwani and Hanan Aldarmaki and Mona Diab}, + year={2019}, + eprint={1909.03104}, + archivePrefix={arXiv}, + primaryClass={cs.CL} +} + +@misc{wu2018word, + title="{Word Mover's Embedding: From Word2Vec to Document Embedding}", + author={Lingfei Wu and Ian E. H. Yen and Kun Xu and Fangli Xu and Avinash Balakrishnan and Pin-Yu Chen and Pradeep Ravikumar and Michael J. Witbrock}, + year={2018}, + eprint={1811.01713}, + archivePrefix={arXiv}, + primaryClass={cs.CL} +} + +@misc{yang2019xlnet, + abstract = {With the capability of modeling bidirectional contexts, denoising +autoencoding based pretraining like BERT achieves better performance than +pretraining approaches based on autoregressive language modeling. However, +relying on corrupting the input with masks, BERT neglects dependency between +the masked positions and suffers from a pretrain-finetune discrepancy. In light +of these pros and cons, we propose XLNet, a generalized autoregressive +pretraining method that (1) enables learning bidirectional contexts by +maximizing the expected likelihood over all permutations of the factorization +order and (2) overcomes the limitations of BERT thanks to its autoregressive +formulation. Furthermore, XLNet integrates ideas from Transformer-XL, the +state-of-the-art autoregressive model, into pretraining. Empirically, XLNet +outperforms BERT on 20 tasks, often by a large margin, and achieves +state-of-the-art results on 18 tasks including question answering, natural +language inference, sentiment analysis, and document ranking.}, + added-at = {2019-07-03T19:07:32.000+0200}, + author = {Yang, Zhilin and Dai, Zihang and Yang, Yiming and Carbonell, Jaime and Salakhutdinov, Ruslan and Le, Quoc V.}, + biburl = {https://www.bibsonomy.org/bibtex/2b758258da935db4bc1a57b5f6c9d94c6/deepforce}, + description = {[1906.08237] XLNet: Generalized Autoregressive Pretraining for Language Understanding}, + interhash = {cd85caa3241071a53ea5c86eadae8de8}, + intrahash = {b758258da935db4bc1a57b5f6c9d94c6}, + keywords = {language_modeling nlp tpu transfer_learning}, + note = {cite arxiv:1906.08237Comment: Pretrained models and code are available at https://github.com/zihangdai/xlnet}, + timestamp = {2019-07-03T19:07:32.000+0200}, + title = "{XLNet: Generalized Autoregressive Pretraining for Language Understanding}", + url = {http://arxiv.org/abs/1906.08237}, + year = 2019 +} + + +@InProceedings{conneau2018xnli, + author = "Conneau, Alexis + and Rinott, Ruty + and Lample, Guillaume + and Williams, Adina + and Bowman, Samuel R. + and Schwenk, Holger + and Stoyanov, Veselin", + title = "{XNLI: Evaluating Cross-lingual Sentence Representations}", + booktitle = "Proceedings of the 2018 Conference on Empirical Methods + in Natural Language Processing", + year = "2018", + publisher = "Association for Computational Linguistics", + location = "Brussels, Belgium", +} + +@inproceedings{Radford2018ImprovingLU, + title={Improving Language Understanding by Generative Pre-Training}, + author={Alec Radford}, + year={2018} +} + +@inproceedings{reimers-2019-sentence-bert, + title = "{Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks}", + author = "Reimers, Nils and Gurevych, Iryna", + booktitle = "Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing", + month = "11", + year = "2019", + publisher = "Association for Computational Linguistics", + url = "http://arxiv.org/abs/1908.10084", +} + +@INPROCEEDINGS{Pennington14glove:global, + author = {Jeffrey Pennington and Richard Socher and Christopher D. Manning}, + title = "{Glove: Global vectors for word representation}", + booktitle = {In EMNLP}, + year = {2014} +} + +@inproceedings{Kano2017OverviewOC, + title="{Overview of COLIEE 2017}", + author={Yoshinobu Kano and Mi Young Kim and Randy Goebel and Ken Satoh}, + booktitle={COLIEE@ICAIL}, + year={2017} +} + +@inproceedings{snli:emnlp2015, + Author = {Bowman, Samuel R. and Angeli, Gabor and Potts, Christopher and Manning, Christopher D.}, + Booktitle = {Proceedings of the 2015 Conference on Empirical Methods in Natural Language Processing (EMNLP)}, + Publisher = {Association for Computational Linguistics}, + Title = {A large annotated corpus for learning natural language inference}, + Year = {2015} +} + +@inproceedings{Williams2017ABC, + title={A Broad-Coverage Challenge Corpus for Sentence Understanding through Inference}, + author={Adina Williams and Nikita Nangia and Samuel R. Bowman}, + booktitle={NAACL-HLT}, + year={2017} +} + +@inproceedings{Peters:2018, + author={Peters, Matthew E. and Neumann, Mark and Iyyer, Mohit and Gardner, Matt and Clark, Christopher and Lee, Kenton and Zettlemoyer, Luke}, + title={Deep contextualized word representations}, + booktitle={Proc. of NAACL}, + year={2018} +} + +@inproceedings{Wang2019GeneralizingFA, + title={Generalizing from a Few Examples: A Survey on Few-Shot Learning}, + author={Yaqing Wang and Quanming Yao and James Kwok and Lionel M. Ni}, + year={2019} +} + +@article{DBLP:journals/corr/VaswaniSPUJGKP17, + author = {Ashish Vaswani and + Noam Shazeer and + Niki Parmar and + Jakob Uszkoreit and + Llion Jones and + Aidan N. Gomez and + Lukasz Kaiser and + Illia Polosukhin}, + title = {Attention Is All You Need}, + journal = {CoRR}, + volume = {abs/1706.03762}, + year = {2017}, + url = {http://arxiv.org/abs/1706.03762}, + archivePrefix = {arXiv}, + eprint = {1706.03762}, + timestamp = {Mon, 13 Aug 2018 16:48:37 +0200}, + biburl = {https://dblp.org/rec/bib/journals/corr/VaswaniSPUJGKP17}, + bibsource = {dblp computer science bibliography, https://dblp.org} +} + +@article{arora2017asimple, + author = {Sanjeev Arora and Yingyu Liang and Tengyu Ma}, + title = {A Simple but Tough-to-Beat Baseline for Sentence Embeddings}, + booktitle = {International Conference on Learning Representations}, + year = {2017} +} + + +@inproceedings{zhao2019moverscore, + title = "{MoverScore: Text Generation Evaluating with Contextualized Embeddings and Earth Mover Distance}", + month = {August}, + year = {2019}, + author = {Zhao, Wei and Peyrard, Maxime and Liu, Fei and Gao, Yang and Meyer, Christian M. and Eger, Steffen}, + address = {Hong Kong, China}, + publisher = {Association for Computational Linguistics}, + booktitle = {Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing}, +} + + +@article{gpt2, + added-at = {2019-02-27T03:35:25.000+0100}, + author = {Radford, Alec and Wu, Jeffrey and Child, Rewon and Luan, David and Amodei, Dario and Sutskever, Ilya}, + biburl = {https://www.bibsonomy.org/bibtex/2b30710316a8cfbae687672ea1f85c193/kirk86}, + description = {Language Models are Unsupervised Multitask Learners}, + interhash = {ce8168300081d74707849ed488e2a458}, + intrahash = {b30710316a8cfbae687672ea1f85c193}, + keywords = {learning multitask}, + timestamp = {2019-02-27T03:35:25.000+0100}, + title = {Language Models are Unsupervised Multitask Learners}, + url = {https://d4mucfpksywv.cloudfront.net/better-language-models/language-models.pdf}, + year = 2018 +} + +@article{lample2019cross, + title={Cross-lingual Language Model Pretraining}, + author={Lample, Guillaume and Conneau, Alexis}, + journal={arXiv preprint arXiv:1901.07291}, + year={2019} +} + +@InProceedings{pmlr-v37-kusnerb15, + title = {From Word Embeddings To Document Distances}, + author = {Matt Kusner and Yu Sun and Nicholas Kolkin and Kilian Weinberger}, + booktitle = {Proceedings of the 32nd International Conference on Machine Learning}, + pages = {957--966}, + year = {2015}, + editor = {Francis Bach and David Blei}, + volume = {37}, + series = {Proceedings of Machine Learning Research}, + address = {Lille, France}, + month = {07--09 Jul}, + publisher = {PMLR}, + pdf = {http://proceedings.mlr.press/v37/kusnerb15.pdf}, + url = {http://proceedings.mlr.press/v37/kusnerb15.html}, + abstract = {We present the Word Mover’s Distance (WMD), a novel distance function between text documents. Our work is based on recent results in word embeddings that learn semantically meaningful representations for words from local co-occurrences in sentences. The WMD distance measures the dissimilarity between two text documents as the minimum amount of distance that the embedded words of one document need to "travel" to reach the embedded words of another document. We show that this distance metric can be cast as an instance of the Earth Mover’s Distance, a well studied transportation problem for which several highly efficient solvers have been developed. Our metric has no hyperparameters and is straight-forward to implement. Further, we demonstrate on eight real world document classification data sets, in comparison with seven state-of-the-art baselines, that the WMD metric leads to unprecedented low k-nearest neighbor document classification error rates.} +} + +@inproceedings{Rabelo:2019:CST:3322640.3326741, + author = {Rabelo, Juliano and Kim, Mi-Young and Goebel, Randy}, + title = {Combining Similarity and Transformer Methods for Case Law Entailment}, + booktitle = {Proceedings of the Seventeenth International Conference on Artificial Intelligence and Law}, + series = {ICAIL '19}, + year = {2019}, + isbn = {978-1-4503-6754-7}, + location = {Montreal, QC, Canada}, + pages = {290--296}, + numpages = {7}, + url = {http://doi.acm.org/10.1145/3322640.3326741}, + doi = {10.1145/3322640.3326741}, + acmid = {3326741}, + publisher = {ACM}, + address = {New York, NY, USA}, + keywords = {binary classification, document similarity, imbalanced datasets, legal textual entailment}, +} + +@article{DBLP:journals/corr/abs-1803-11175, + author = {Daniel Cer and + Yinfei Yang and + Sheng{-}yi Kong and + Nan Hua and + Nicole Limtiaco and + Rhomni St. John and + Noah Constant and + Mario Guajardo{-}Cespedes and + Steve Yuan and + Chris Tar and + Yun{-}Hsuan Sung and + Brian Strope and + Ray Kurzweil}, + title = {Universal Sentence Encoder}, + journal = {CoRR}, + volume = {abs/1803.11175}, + year = {2018}, + url = {http://arxiv.org/abs/1803.11175}, + archivePrefix = {arXiv}, + eprint = {1803.11175}, + timestamp = {Mon, 13 Aug 2018 16:46:40 +0200}, + biburl = {https://dblp.org/rec/bib/journals/corr/abs-1803-11175}, + bibsource = {dblp computer science bibliography, https://dblp.org} +} + +@article{senin2008dynamic, + title={Dynamic time warping algorithm review}, + author={Senin, Pavel}, + year={2008}, + publisher={Citeseer} +} + +@incollection{Sakoe:1990:DPA:108235.108244, + author = {Sakoe, Hiroaki and Chiba, Seibi}, + chapter = {Dynamic Programming Algorithm Optimization for Spoken Word Recognition}, + title = {Readings in Speech Recognition}, + editor = {Waibel, Alex and Lee, Kai-Fu}, + year = {1990}, + isbn = {1-55860-124-4}, + pages = {159--165}, + numpages = {7}, + url = {http://dl.acm.org/citation.cfm?id=108235.108244}, + acmid = {108244}, + publisher = {Morgan Kaufmann Publishers Inc.}, + address = {San Francisco, CA, USA}, +} + +@article{muller2007dynamic, + title={Dynamic time warping}, + author={M{\"u}ller, Meinard}, + journal={Information retrieval for music and motion}, + pages={69--84}, + year={2007}, + publisher={Springer} +} +{% endraw %} diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/build.sh b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/build.sh new file mode 100755 index 0000000..e759040 --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/build.sh @@ -0,0 +1,3 @@ +#!/bin/bash -xe + +make diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/check.sh b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/check.sh new file mode 100755 index 0000000..3b53ab7 --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/check.sh @@ -0,0 +1,3 @@ +#!/bin/bash -xe + +make autozoil-log.txt diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/extract-score-files.pl b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/extract-score-files.pl new file mode 100755 index 0000000..0e76344 --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/extract-score-files.pl @@ -0,0 +1,20 @@ +#!/usr/bin/perl + +use strict; + +my %found = (); + +for my $filepath (@ARGV) { + open(my $ih, '<', $filepath); + binmode($ih, ':utf8'); + + while (my $line=<$ih>) { + while ($line =~ m<\\gonito(?:barescore|score|entry)\{([^\}]+)\}>g) { + $found{$1} = 1; + } + } + + close($ih); +} + +print join(" ", map { "scores/${_}.txt" } sort keys %found); diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/helpers/pdf-to-plain-text.sh b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/helpers/pdf-to-plain-text.sh new file mode 100755 index 0000000..ec797ad --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/helpers/pdf-to-plain-text.sh @@ -0,0 +1,3 @@ +#!/bin/bash + +pdftotext "$1" - | grep '[^[:space:]]' | egrep '[a-zA-Z]{2}' | perl -pne 's/\f//g;' diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/helpers/stats.sh b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/helpers/stats.sh new file mode 100755 index 0000000..4aab6a6 --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/helpers/stats.sh @@ -0,0 +1,18 @@ +#!/bin/bash + +here_dir=$(dirname "$0") +echo $here_dir + +pdf_file="$1" + +if [[ "$pdf_file" == "" ]] +then + >&2 echo "no file given" + exit 1 +fi + +perl -e 'print "PHYSICAL PAGES\tCHARACTERS WITH SPACES\tSTANDARD PAGES\n"' +pages=$(pdfinfo "$1" | perl -ne 'print "$1\n" if /Pages:\s+(\d+)/') +chars=$(bash $here_dir/pdf-to-plain-text.sh "$1" | wc -m) +spages=$(echo "scale=1; $chars / 1800.0" | bc) +echo "$pages $chars $spages" diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/helpers/synchro.sh b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/helpers/synchro.sh new file mode 100755 index 0000000..b245bc8 --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/helpers/synchro.sh @@ -0,0 +1,24 @@ +#!/bin/bash -xe + +. helpers/vars + +if [[ "$OVERLEAF_GIT_URL" == "" ]] +then + >&2 echo "Please set OVERLEAF_GIT_URL in `helpers/vars`" + exit 1 +fi + +if [[ -e .git && ! -z "$(git status --untracked-files=no --porcelain)" ]]; then + >&2 echo "Uncommited changes, commit your changes first" + exit 1 +fi + +git remote add overleaf "$OVERLEAF_GIT_URL" || git remote set-url overleaf "$OVERLEAF_GIT_URL" + +git config credential.helper "cache --timeout=10000000" + +git pull origin master +git pull overleaf master + +git push overleaf master +git push origin master diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/helpers/vars b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/helpers/vars new file mode 100644 index 0000000..1982ef5 --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/helpers/vars @@ -0,0 +1,2 @@ +# to be included with . +OVERLEAF_GIT_URL= diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/install-hooks.sh b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/install-hooks.sh new file mode 100755 index 0000000..aee894e --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/install-hooks.sh @@ -0,0 +1,4 @@ +#!/bin/bash -xe + +cp hooks/pre-push .git/hooks/pre-push +chmod 700 .git/hooks/pre-push diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/main.tex b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/main.tex new file mode 100644 index 0000000..87cbf93 --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/main.tex @@ -0,0 +1,59 @@ +{% raw %} +% +% Wstęp +\introduction + +Aczkolwiek w~ciągu ostatnich lat skład tekstu wspomagany +komputerowo całkowicie wyeliminował stosowanie tradycyjnych technik +drukarskich, to podobny \code{Gimmel\dbr ::Parser\dbr::ElementSpecification}, proces w~przypadku publikacji elektronicznych +czyli publikacji, które w~ogóle nie wykorzystują papieru, a~nośnikem +informacji staje się ekran komputera nie jest obserwowany. + +Formatowanie wizualne, powstało z~myślą o~przygotowaniu publikacji do +druku i~dlatego nie może sprostać nowym potrzebom, które stwarza +postęp techniki. Coraz większą rolę odgrywają dziś elektroniczne +repozytoria, bazy danych, publikacje na CD-Romach oraz WWW. Wypływa +też stąd ważny wniosek, że tworzenie dokumentów według paradygmatu +WYSIWYG nie jest efektywne i~stopniowo należy oczekiwać powstawania, +wdrażania i~rozpowszechniania się systemów opartych na paradygmacie +\emph{formatowania strukturalnego}. + +W~dokumencie formatowanym strukturalnie oznaczana jest struktura +dokumentu a~nie określany jego wygląd. Zwróćmy uwagę, że układ +graficzny jest pochodną struktury, tj. nadajemy jednolity wygląd +tytułom rozdziałów, śródtytułów, przypisów, jednakowo wyróżniamy +wyliczenia itp. Układ graficzny jak już wspominano może ulegać zmianie +(np. wraz z~rozpowszechnianiem się nowych technologii wydawniczych) +ale treść i~struktura raczej nie, np. Biblia Gutenberga widziana z~tej +perspektywy nie zmieniła się wcale. + +% Na końcu tytułów, śródtytułów, tytułów rysunków i tabel +% _nie_ umieszcza się kropki +\chapter{Wprowadzenie do standardów SGML/XML} + +\code{} +\\\\ +\code{//BBB[normalize-space(text()) = "czwarty"]} + +SGML~\cite{Goldfarb} jest to \emph{metajęzyk} służący do opisywania +struktury i~zawartości dokumentów (standard ISO 8879). Do +podstawowych zalet takiego podejścia należy: +\begin{itemize} +\item +jest to międzynarodowy +standard dostępny na wielu platformach sprzętowo{\dywiz}systemowych; +\item +jest to +język opisu \emph{każdego\/} dokumentu, o~praktycznie nieograniczonych +możliwościach (\emph{rozszerzalność\/}) +\item +umożliwia powtórne +wykorzystywanie dokumentów, także w sposób inny od poprzedniego +(np. tradycyjna książka i~dokument multimedialny utworzony z~tego +samego dokumentu SGML-owego). +\end{itemize} +\lstset{emph={square},emphstyle=\color{red}} +\begin{lstlisting} +square +\end{lstlisting} +{% endraw %} diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/metadata.tex b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/metadata.tex new file mode 100644 index 0000000..5956bfd --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/metadata.tex @@ -0,0 +1,27 @@ +{% raw %} +% Opcjonalnie identyfikator dokumentu (drukowany tylko z włączoną opcją `brudnopis'): +\nrwersji {0.1} + +% Dane autora(ów): +\author {Walenty Szczęsny} +\nralbumu {rr000000001} +\email {walenty@szczesny.com.pl} + +\author {Monika A.~Szczęsna-Woś} +\nralbumu {rr000000002} + +% Tytuł pracy: +\title {Dokumenty strukturalne: teoria i~zastosowania} + +% Kierunek, tj. katedra/instytut promotora: +\kierunek {Informatyka Ekonomiczna} + +% Rok obrony: +\date {2001} + +% Jeżeli nie podano miejsca zostanie wpisany `Sopot' +\miejsce {Wejherowo} + +% Tytuł naukowy, imię i nazwisko promotora: +\opiekun {dra hab. Jan Kowalski} +{% endraw %} diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/preamble.tex b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/preamble.tex new file mode 100644 index 0000000..ef64b39 --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/preamble.tex @@ -0,0 +1,5 @@ +{% raw %} +% +% Miejsce na deklaracje własnych poleceń: +\newcommand{\filename}[1]{\texttt{#1}} +{% endraw %} diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/.gitignore b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/.gitignore new file mode 100644 index 0000000..88fe099 --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/.gitignore @@ -0,0 +1,26 @@ +ext/plmindex/plmindex +sample/sample.aux +sample/sample.bbl +sample/sample.blg +sample/sample.brf +sample/sample.idx +sample/sample.ind +sample/sample.lof +sample/sample.log +sample/sample.lot +sample/sample.out +sample/sample.pdf +sample/sample.toc +*~ +*.aux +*.bbl +*.blg +*.brf +*.idx +*.ind +*.lof +*.log +*.lot +*.out +*.toc +{{cookiecutter.thesis_surname}}.pdf diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/build.sh b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/build.sh new file mode 100755 index 0000000..f25e867 --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/build.sh @@ -0,0 +1,28 @@ +#!/bin/bash + +check() +{ + if [[ "$CHECK" == "1" ]] + then + bash ./check.sh $MGRDIR + fi +} + +# pomocniczy skrypt generujący daną pracę magisterską z czystej kopii z repozytorium + +if [[ "$1" == "--check" ]] +then +shift +echo "will be checking" +CHECK=1 +fi + +MGRDIR=$1 + +if [[ ! -d "$MGRDIR" ]] +then + echo "unknown name: $MGRDIR" + exit 1 +fi + +(cd ext/plmindex ; make) && (cd $MGRDIR ; make) && check diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/check.sh b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/check.sh new file mode 100755 index 0000000..07e846b --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/check.sh @@ -0,0 +1,29 @@ +#!/bin/bash + +MGRDIR="$1" +HEREDIR=`pwd` +FULLMGRDIR="$HEREDIR/$MGRDIR" +AUTOZOIL=${AUTOZOIL:-../autozoil} + +if [[ "$MGRDIR" == "" ]] +then + echo "no directory given!!!" + exit 1 +fi + +echo "AUTOZOIL IN '$AUTOZOIL'" +cd $AUTOZOIL + +if [[ ! -d "$FULLMGRDIR" ]] +then + echo "no directory for '$FULLMGRDIR'" + exit 1 +fi + +SOURCE_FILE_PREFIX=`basename $MGRDIR` + +FILES_TO_CHECK=`ls $FULLMGRDIR/*.tex | grep -v '.*-form.tex'` + +echo "CHECKING: $FILES_TO_CHECK" + +PERL5LIB=. perl autozoil.pl --locale ${AUTOZOIL_LOCALE:-pl_PL} $FILES_TO_CHECK --format xml --source-file-prefix "${SOURCE_FILE_PREFIX}/" > $FULLMGRDIR/autozoil.xml || exit 0 diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/Makefile b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/Makefile new file mode 100644 index 0000000..e884085 --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/Makefile @@ -0,0 +1,40 @@ +CC = gcc +O = .o +X = + +XCFLAGS= -unsigned-char -O2 -g -pedantic -DDEFAULT_LANGUAGE=PL_latin2 +LIBS = + +CFLAGS= $(XCFLAGS) +LDFLAGS = -g + +HDRS = mkind.h scanid.h scanst.h + +MAKEFILE = makefile.gcc + +OBJS = genind$(O) qsort$(O) mkind$(O) scanid$(O) scanst$(O) \ + sortid$(O) decode_n$(O) language$(O) + +SRCS = genind.c mkind.c scanid.c scanst.c qsort.c sortid.c decode_n.c\ + language.c + +PROGRAM = plmindex + +.c.o: + $(CC) -c $(CFLAGS) $*.c + +$(PROGRAM): $(OBJS) $(MAKEFILE) + $(CC) $(LDFLAGS) -o $@ $(OBJS) $(LIBS) + rm *.o + +genind$(O): genind.c mkind.h +mkind$(O): mkind.c mkind.h +qsort$(O): qsort.c mkind.h +scanid$(O): scanid.c mkind.h scanid.h +scanst$(O): scanst.c mkind.h scanst.h +sortid$(O): sortid.c mkind.h +language$(O): pl_maz.h pl_iso2.h us_eng.h pl_1250.h pl_852.h mkind.h +mkind.h: myctype.h +clean: + rm plmindex + diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/decode_n.c b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/decode_n.c new file mode 100644 index 0000000..a1a8134 --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/decode_n.c @@ -0,0 +1,197 @@ +#include "mkind.h" +#include +#include + +Local char_u *myconcat(char_u *, const char_u *); +Local void get_jed(int *lll, long licz); +Local char_u *dec_text(Logical flag, int *zzz, char_u *text); + +#define EOS '\0' + +Local int tab_jed[5], + tab_tys[5], + tab_mil[5]; + + +Public char_u * +Decode_Number(const long liczba) + +{ + + long licz; + char_u *text; + + if(liczba >= 1000000000L) + { + fprintf(stderr, "Number to big"); + exit(1); + } + if((text = (char_u *)malloc(strlen("") + 1)) == NULL) + { + fprintf(stderr, "Can`t allocate memory"); + exit(1); + } + *text = EOS; + get_jed(tab_jed, liczba); + if(tab_jed[3] > 0) + get_jed(tab_tys, tab_jed[3]); + if(tab_jed[4] > 0) + get_jed(tab_mil, tab_jed[4]); + + if(tab_jed[4] > 0) + { + text = dec_text(False, tab_mil, text); + if(tab_mil[0] < 5 && + (tab_mil[0] > 1 || (tab_mil[1] == 0 && tab_mil[2] == 0))) + { + text = myconcat(text, + (*multilanguage[Language].decode->mil)[tab_mil[0]]); + text = myconcat(text, (char_u *)" "); + } + else + { + text = myconcat(text, (*multilanguage[Language].decode->mil)[5]); + text = myconcat(text, (char_u *)" "); + } + } + if(tab_jed[3] > 0) + { + text = dec_text(False, tab_tys, text); + if(tab_tys[0] < 5 && + (tab_tys[0] > 1 || (tab_tys[1] == 0 && tab_tys[2] == 0))) + { + text = myconcat(text, + (*multilanguage[Language].decode->tys)[tab_tys[0]]); + text = myconcat(text, (char_u *)" "); + } + else + { + text = myconcat(text, (*multilanguage[Language].decode->tys)[5]); + text = myconcat(text, (char_u *)" "); + } + } + text = dec_text(True, tab_jed, text); + return(text); +} + +Local void +get_jed(int *lll, long licz) + +{ + char *buffer; + int ii, + kk; + + if((buffer = (char *)malloc(10)) == NULL) + { + fprintf(stderr, "Can`t allocate memory"); + exit(1); + } + sprintf(buffer, "%ld", licz); + + ii = strlen(buffer); + free(buffer); + + for(kk = 0; kk < ii;) + { + if(licz < 10L) + { + lll[0] = licz; + kk++; + } + else if(licz < 100L) + { + if(licz < 20L) + { + lll[0] = licz; + kk++; + } + else + { + lll[1] = licz / 10; + licz = licz - lll[1] * 10; + kk++; + } + } + else if(licz < 1000L) + { + lll[2] = licz / 100L; + licz = licz - lll[2] * 100L; + kk++; + } + else if(licz < 1000000L) + { + lll[3] = licz / 1000L; + licz = licz - lll[3] * 1000L; + kk++; + } + else if(licz < 1000000000L) + { + lll[4] = licz / 1000000L; + licz = licz - lll[4] * 1000000L; + kk += 3; + } + } +} + +Local char_u * +dec_text(Logical flag, int *zzz, char_u *text) + +{ + if(zzz[2] > 0) + { + text = myconcat(text, + (*multilanguage[Language].decode->setki)[zzz[2]]); + text = myconcat(text, (char_u *)" "); + } + if(zzz[1] > 0) + { + text = myconcat(text, + (*multilanguage[Language].decode->dies)[zzz[1] - 1]); + text = myconcat(text, (char_u *)" "); + } + if(zzz[0] > 0 && (flag || (zzz[0] != 1 || (zzz[1] > 0 || zzz[2] > 0)))) + { + text = myconcat(text, + (*multilanguage[Language].decode->jedn)[zzz[0]]); + text = myconcat(text, (char_u *)" "); + } + return(text); +} + +Local char_u * +myconcat(char_u *str, const char_u *addstr) + +{ + char *tmp_str; + + if((tmp_str = (char *)malloc(strlen((char *)str) + + strlen((char *)addstr) + 1)) == NULL) + { + fprintf(stderr, "Can`t allocate memory"); + exit(1); + } + strcpy(tmp_str, (char *)str); + strcat(tmp_str, (char *)addstr); + free(str); + return((char_u *)tmp_str); +} + +#ifdef D_DEBUG + +void +main(int argc, char *argv[]) + +{ + long num; + + if(argc < 2) + { + fprintf(stderr, "liczba \n"); + exit(1); + } + num = atol(argv[1]); + printf("%s\n", Decode_Number(num)); +} + +#endif diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/decode_n.c.orig b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/decode_n.c.orig new file mode 100644 index 0000000..f1fd973 --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/decode_n.c.orig @@ -0,0 +1,196 @@ + #include "mkind.h" +#include + +Local char_u *myconcat(char_u *, const char_u *); +Local void get_jed(int *lll, long licz); +Local char_u *dec_text(Logical flag, int *zzz, char_u *text); + +#define EOS '\0' + +Local int tab_jed[5], + tab_tys[5], + tab_mil[5]; + + +Public char_u * +Decode_Number(const long liczba) + +{ + + long licz; + char_u *text; + + if(liczba >= 1000000000L) + { + fprintf(stderr, "Number to big"); + exit(1); + } + if((text = (char_u *)malloc(strlen("") + 1)) == NULL) + { + fprintf(stderr, "Can`t allocate memory"); + exit(1); + } + *text = EOS; + get_jed(tab_jed, liczba); + if(tab_jed[3] > 0) + get_jed(tab_tys, tab_jed[3]); + if(tab_jed[4] > 0) + get_jed(tab_mil, tab_jed[4]); + + if(tab_jed[4] > 0) + { + text = dec_text(False, tab_mil, text); + if(tab_mil[0] < 5 && + (tab_mil[0] > 1 || (tab_mil[1] == 0 && tab_mil[2] == 0))) + { + text = myconcat(text, + (*multilanguage[Language].decode->mil)[tab_mil[0]]); + text = myconcat(text, (char_u *)" "); + } + else + { + text = myconcat(text, (*multilanguage[Language].decode->mil)[5]); + text = myconcat(text, (char_u *)" "); + } + } + if(tab_jed[3] > 0) + { + text = dec_text(False, tab_tys, text); + if(tab_tys[0] < 5 && + (tab_tys[0] > 1 || (tab_tys[1] == 0 && tab_tys[2] == 0))) + { + text = myconcat(text, + (*multilanguage[Language].decode->tys)[tab_tys[0]]); + text = myconcat(text, (char_u *)" "); + } + else + { + text = myconcat(text, (*multilanguage[Language].decode->tys)[5]); + text = myconcat(text, (char_u *)" "); + } + } + text = dec_text(True, tab_jed, text); + return(text); +} + +Local void +get_jed(int *lll, long licz) + +{ + char *buffer; + int ii, + kk; + + if((buffer = (char *)malloc(10)) == NULL) + { + fprintf(stderr, "Can`t allocate memory"); + exit(1); + } + sprintf(buffer, "%ld", licz); + + ii = strlen(buffer); + free(buffer); + + for(kk = 0; kk < ii;) + { + if(licz < 10L) + { + lll[0] = licz; + kk++; + } + else if(licz < 100L) + { + if(licz < 20L) + { + lll[0] = licz; + kk++; + } + else + { + lll[1] = licz / 10; + licz = licz - lll[1] * 10; + kk++; + } + } + else if(licz < 1000L) + { + lll[2] = licz / 100L; + licz = licz - lll[2] * 100L; + kk++; + } + else if(licz < 1000000L) + { + lll[3] = licz / 1000L; + licz = licz - lll[3] * 1000L; + kk++; + } + else if(licz < 1000000000L) + { + lll[4] = licz / 1000000L; + licz = licz - lll[4] * 1000000L; + kk += 3; + } + } +} + +Local char_u * +dec_text(Logical flag, int *zzz, char_u *text) + +{ + if(zzz[2] > 0) + { + text = myconcat(text, + (*multilanguage[Language].decode->setki)[zzz[2]]); + text = myconcat(text, (char_u *)" "); + } + if(zzz[1] > 0) + { + text = myconcat(text, + (*multilanguage[Language].decode->dies)[zzz[1] - 1]); + text = myconcat(text, (char_u *)" "); + } + if(zzz[0] > 0 && (flag || (zzz[0] != 1 || (zzz[1] > 0 || zzz[2] > 0)))) + { + text = myconcat(text, + (*multilanguage[Language].decode->jedn)[zzz[0]]); + text = myconcat(text, (char_u *)" "); + } + return(text); +} + +Local char_u * +myconcat(char_u *str, const char_u *addstr) + +{ + char *tmp_str; + + if((tmp_str = (char *)malloc(strlen((char *)str) + + strlen((char *)addstr) + 1)) == NULL) + { + fprintf(stderr, "Can`t allocate memory"); + exit(1); + } + strcpy(tmp_str, (char *)str); + strcat(tmp_str, (char *)addstr); + free(str); + return((char_u *)tmp_str); +} + +#ifdef D_DEBUG + +void +main(int argc, char *argv[]) + +{ + long num; + + if(argc < 2) + { + fprintf(stderr, "liczba \n"); + exit(1); + } + num = atol(argv[1]); + printf("%s\n", Decode_Number(num)); +} + +#endif diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/genind.c b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/genind.c new file mode 100644 index 0000000..910340f --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/genind.c @@ -0,0 +1,516 @@ +/* + * + * This file is part of + * MakeIndex - A formatter and format independent index processor + * + * Copyright (C) 1989 by Chen & Harrison International Systems, Inc. + * Copyright (C) 1988 by Olivetti Research Center + * Copyright (C) 1987 by Regents of the University of California + * + * Author: + * Pehong Chen + * Chen & Harrison International Systems, Inc. + * Palo Alto, California + * USA + * (phc@renoir.berkeley.edu or chen@orc.olivetti.com) + * + * Contributors: + * Please refer to the CONTRIB file that comes with this release + * for a list of people who have contributed to this and/or previous + * release(s) of MakeIndex. + * + * All rights reserved by the copyright holders. See the copyright + * notice distributed with this software for a complete description of + * the conditions under which it is made available. + * + */ + +#include "mkind.h" +#include + +#if sun /* avoid conflict with symbol in */ + /* /usr/lang/SC1.0/include/CC/stdlib.h */ +#define end the_end +#endif + +Local FIELD_PTR curr = NULL; +Local FIELD_PTR prev = NULL; +Local FIELD_PTR begin = NULL; +Local FIELD_PTR end = NULL; +Local FIELD_PTR range_ptr; +Local int level = 0; +Local int prev_level = 0; +Local unsigned char *encap = NULL; +Local unsigned char *prev_encap = NULL; +Local Logical in_range = False; +Local Logical encap_range = False; +Local char buff[2 * ARGUMENT_MAX]; +Local char line[2 * ARGUMENT_MAX]; /* output buffer */ +Local int ind_lc = 0; /* overall line count */ +Local int ind_ec = 0; /* erroneous line count */ +Local int ind_indent; + +Local void Ind_Error (const char *F, ...); +Local void flush_line (int print); +Local void insert_page (void); +Local int make_entry (int n); +Local void make_item (unsigned char* term); +Local void new_entry (void); +Local void old_entry (void); +Local int page_diff (struct KFIELD *a, struct KFIELD *b); +Local void put_header (unsigned char let); +Local void wrap_line (int print); + +Public void +gen_ind(VOID_ARG) + +{ + int n; + int tmp_lc; + + Message("Generating output file %s...", ind_fn); + fputs(preamble, ind_fp); + ind_lc += prelen; + if(init_page) + insert_page(); + + /* reset counters for putting out dots */ + idx_dc = 0; + for(n = 0; n < idx_gt; n++) + { + if(idx_key[n]->type != DUPLICATE) + if(make_entry(n)) + { + idx_dot = True; + if(idx_dc++ == 0) + Message(DOT); + if(idx_dc == DOT_MAX) + idx_dc = 0; + } + } + tmp_lc = ind_lc; + if(in_range) + { + curr = range_ptr; + Ind_Error("Unmatched range opening operator %c.\n", idx_ropen); + } + prev = curr; + flush_line(True); + fputs(delim_t, ind_fp); + fputs(postamble, ind_fp); + tmp_lc = ind_lc + postlen; + if(ind_ec == 1) + Message("done (%d %s, %d %s).\n", tmp_lc, "lines written", ind_ec, + "warning"); + else + Message("done (%d %s, %d %s).\n", tmp_lc, "lines written", ind_ec, + "warnings"); + } + + +Local int +make_entry(int n) + +{ + unsigned char let; + + /* determine current and previous pointer */ + prev = curr; + curr = idx_key[n]; + /* check if current entry is in range */ + + if((*curr->encap == idx_ropen) || (*curr->encap == idx_rclose)) + encap = &(curr->encap[1]); + else + encap = curr->encap; + + /* determine the current nesting level */ + if(n == 0) + { + prev_level = level = 0; + let = *curr->sf[0]; + put_header(let); + make_item(EMPTY_STRING); + } + else + { + prev_level = level; + for(level = 0; level < FIELD_MAX; level++) + if(STRNEQ(curr->sf[level], prev->sf[level]) || + STRNEQ(curr->af[level], prev->af[level])) + break; + if(level < FIELD_MAX) + new_entry(); + else + old_entry(); + } + + if(*curr->encap == idx_ropen) + if(in_range) + Ind_Error("Extra range opening operator %c.\n", idx_ropen); + else + { + in_range = True; + range_ptr = curr; + } + else if(*curr->encap == idx_rclose) + if(in_range) + { + in_range = False; + if(STRNEQ(&(curr->encap[1]), EMPTY_STRING) && + STRNEQ(prev_encap, &(curr->encap[1]))) + Ind_Error("Range closing operator has an " \ + "inconsistent encapsulator %s.\n", &(curr->encap[1])); + } + else + Ind_Error("Unmatched range closing operator %c.\n", idx_rclose); + else if((*curr->encap != EOS) && + STRNEQ(curr->encap, prev_encap) && in_range) + Ind_Error("Inconsistent page encapsulator %s within range.\n", + curr->encap); + return(1); +} + +Local void +make_item(unsigned char *term) + +{ + int i; + + if(level > prev_level) + { + /* ascending level */ + if(*curr->af[level] == EOS) + sprintf(line, "%s%s%s", term, item_u[level], curr->sf[level]); + else + sprintf(line, "%s%s%s", term, item_u[level], curr->af[level]); + ind_lc += ilen_u[level]; + } + else + { + /* same or descending level */ + if(*curr->af[level] == EOS) + sprintf(line, "%s%s%s", term, item_r[level], curr->sf[level]); + else + sprintf(line, "%s%s%s", term, item_r[level], curr->af[level]); + ind_lc += ilen_r[level]; + } + + i = level + 1; + while(i < FIELD_MAX && *curr->sf[i] != EOS) + { + fputs(line, ind_fp); + if(*curr->af[i] == EOS) + sprintf(line, "%s%s", item_x[i], curr->sf[i]); + else + sprintf(line, "%s%s", item_x[i], curr->af[i]); + ind_lc += ilen_x[i]; + level = i; /* Added at 2.11 */ + i++; + } + + ind_indent = 0; + strcat(line, delim_p[level]); + begin = end = curr; + prev_encap = encap; +} + +Local void +new_entry(VOID_ARG) + +{ + unsigned char let; + FIELD_PTR ptr; + + if(in_range) + { + ptr = curr; + curr = range_ptr; + Ind_Error("Unmatched range opening operator %c.\n", idx_ropen); + in_range = False; + curr = ptr; + } + flush_line(True); + + /* beginning of a new group? */ + + if(((curr->group != ALPHA) && (curr->group != prev->group) && + (prev->group == SYMBOL)) || ((curr->group == ALPHA) && + ((let = TOLOWER(curr->sf[0][0])) != + (TOLOWER(prev->sf[0][0]))))) + { + fputs(delim_t, ind_fp); + fputs(group_skip, ind_fp); + ind_lc += skiplen; + /* beginning of a new letter? */ + put_header(let); + make_item(EMPTY_STRING); + } + else + make_item((unsigned char *)delim_t); +} + +Local void +old_entry(VOID_ARG) + +{ + int diff; + + /* current entry identical to previous one: append pages */ + + diff = page_diff(end, curr); + + if((prev->type == curr->type) && (diff != -1) && + (((diff == 0) && (prev_encap != NULL) && STREQ(encap, prev_encap)) || + (merge_page && (diff == 1) && + (prev_encap != NULL) && STREQ(encap, prev_encap)) || in_range)) + { + end = curr; + /* extract in-range encaps out */ + + if(in_range && (*curr->encap != EOS) && + (*curr->encap != idx_rclose) && STRNEQ(curr->encap, prev_encap)) + { + sprintf(buff, "%s%s%s%s%s", encap_p, curr->encap, + encap_i, curr->lpg, encap_s); + wrap_line(False); + } + if(in_range) + encap_range = True; + } + else + { + flush_line(False); + if((diff == 0) && (prev->type == curr->type)) + Ind_Error("Conflicting entries: multiple encaps for the same " \ + "page under same key.\n"); + else if(in_range && (prev->type != curr->type)) + Ind_Error("Illegal range formation: starting & ending pages are " \ + "of different types.\n"); + else if(in_range && (diff == -1)) + Ind_Error("Illegal range formation: starting & ending pages " \ + "cross chap/sec breaks.\n"); + begin = end = curr; + prev_encap = encap; + } +} + +Local int +#if STDC +page_diff(FIELD_PTR a, FIELD_PTR b) +# else +page_diff(a, b) +FIELD_PTR a; +FIELD_PTR b; +#endif + +{ + short i; + + if(a->count != b->count) + return(-1); + for(i = 0; i < a->count - 1; i++) + if(a->npg[i] != b->npg[i]) + return(-1); + return(b->npg[b->count - 1] - a->npg[a->count - 1]); +} + +Local void +put_header(unsigned char let) + +{ + if(headings_flag != 0) + { + fputs(heading_pre, ind_fp); + ind_lc += headprelen; + switch(curr->group) + { + case SYMBOL: + if(headings_flag > 0) + fputs(symhead_pos, ind_fp); + else + fputs(symhead_neg, ind_fp); + break; + case ALPHA: + if(headings_flag > 0) + fputc(TOUPPER(let), ind_fp); + else + fputc(TOLOWER(let), ind_fp); + break; + default: + if(headings_flag > 0) + fputs(numhead_pos, ind_fp); + else + fputs(numhead_neg, ind_fp); + break; + } + fputs(heading_suf, ind_fp); + ind_lc += headsuflen; + } +} + +/* changes for 2.12 (May 20, 1993) by Julian Reschke (jr@ms.maus.de): + Use keywords suffix_2p, suffix_3p or suffix_mp for one, two or + multiple page ranges (when defined) */ + +Local void +#if STDC +flush_line(int print) +# else +flush_line(print) +int print; +#endif + +{ + char *tmp; + + if((tmp = (char *) calloc(1, sizeof(buff))) == NULL) + Fatal("Not enough core...abort.\n"); + if(page_diff(begin, end) != 0) + if(encap_range || (page_diff(begin, prev) > (*suffix_2p ? 0 : 1))) + { + int diff = page_diff(begin, end); + + if((diff == 1) && *suffix_2p) + sprintf(buff, "%s%s", begin->lpg, suffix_2p); + else if((diff == 2) && *suffix_3p) + sprintf(buff, "%s%s", begin->lpg, suffix_3p); + else if((diff >= 2) && *suffix_mp) + sprintf(buff, "%s%s", begin->lpg, suffix_mp); + else + sprintf(buff, "%s%s%s", begin->lpg, delim_r, end->lpg); + + encap_range = False; + } + else + sprintf(buff, "%s%s%s", begin->lpg, delim_n, end->lpg); + else + { + encap_range = False; /* might be true from page range on same page */ + strcpy(buff, begin->lpg); + } + + if(*prev_encap != EOS) + { + strcpy(tmp, buff); + sprintf(buff, "%s%s%s%s%s", encap_p, prev_encap, encap_i, tmp, encap_s); + } + wrap_line(print); + free(tmp); +} + +Local void +#if STDC +wrap_line(int print) +# else +wrap_line(print) +int print; +#endif + +{ + int len; + + len = strlen(line) + strlen(buff) + ind_indent; + if(print) + { + if(len > linemax) + { + fputs(line, ind_fp); + fputc('\n', ind_fp); + ind_lc++; + fputs(indent_space, ind_fp); + ind_indent = indent_length; + } + else + fputs(line, ind_fp); + fputs(buff, ind_fp); + } + else + { + if(len > linemax) + { + fputs(line, ind_fp); + fputc('\n', ind_fp); + ind_lc++; + sprintf(line, "%s%s%s", indent_space, buff, delim_n); + ind_indent = indent_length; + } + else + { + strcat(buff, delim_n); + strcat(line, buff); + } + } +} + +Local void +insert_page(VOID_ARG) + +{ + int i = 0; + int j = 0; + int page = 0; + + if(even_odd >= 0) + { + /* find the rightmost digit */ + while(pageno[i++] != EOS) + ; + j = --i; + /* find the leftmost digit */ + while(isdigit(pageno[--i]) && i > 0) + ; + if(!isdigit(pageno[i])) + i++; + /* convert page from literal to numeric */ + page = strtoint(&pageno[i]) + 1; + + /* check even-odd numbering */ + + if(((even_odd == 1) && (page % 2 == 0)) || + ((even_odd == 2) && (page % 2 == 1))) + page++; + pageno[j + 1] = EOS; + /* convert page back to literal */ + while(page >= 10) + { + pageno[j--] = DIGTOASCII(page % 10); + page = page / 10; + } + pageno[j] = DIGTOASCII(page); + if(i < j) + { + while(pageno[j] != EOS) + pageno[i++] = pageno[j++]; + pageno[i] = EOS; + } + } + fputs(setpage_open, ind_fp); + fputs(pageno, ind_fp); + fputs(setpage_close, ind_fp); + ind_lc += setpagelen; +} + +Local void +Ind_Error(const char *fmt, ...) + +{ + va_list arg_ptr; + + va_start(arg_ptr, fmt); + if(idx_dot) + { + fprintf(ilg_fp, "\n"); + idx_dot = False; + } + fprintf(ilg_fp, +#if KCC_20 +"## Warning (input = %s, line = %d; output = %s, line = %d):\n\040\040 -- ", +#else + "## Warning (input = %s, line = %d; output = %s, line = %d):\n -- ", +#endif + curr->fn, curr->lc, ind_fn, ind_lc + 1); + vfprintf(ilg_fp, fmt, arg_ptr); + va_end(arg_ptr); + ind_ec++; +} diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/language.c b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/language.c new file mode 100644 index 0000000..d82b759 --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/language.c @@ -0,0 +1,507 @@ +{% raw %} +#include "mkind.h" + +#ifdef DEBUG +language Language = DEFAULT_LANGUAGE; +#endif + +#define CCCC 8 + +#define LF 10 +#define CR 13 + +#define IS_UPPER 0x01 +#define IS_LOWER 0x02 +#define IS_BLANK 0x04 +#define IS_DIG 0x08 +#define IS_XDIG 0x10 +#define IS_CTR 0x20 +#define IS_ALPH 0x40 +#define IS_ALPHA (IS_LOWER | IS_UPPER) +#define IS_ALNUM (IS_DIG | IS_ALPHA) + +#include "pl_maz.h" +#include "pl_iso2.h" +#include "pl_1250.h" +#include "pl_852.h" +#include "us_eng.h" + +Public struct _multilanguage multilanguage[] = + { + { + &us_day_name_ptr, + &us_day_name_ptr_a, + &us_mon_name_ptr, + &us_mon_name_ptr_a, + &us_toascii_table, + &us_lower_table, + &us_upper_table, + &us_char_type, + &us_order_tbl, + 0, + NULL, + "english", + "US english", + NULL + }, + { + &pl_maz_day_name_ptr, + &pl_maz_day_name_ptr_a, + &pl_maz_mon_name_ptr, + &pl_maz_mon_name_ptr_a, + &pl_maz_toascii_table, + &pl_maz_lower_table, + &pl_maz_upper_table, + &pl_maz_char_type, + &pl_maz_order_tbl, + 0, + Decode_Number, + (char *)"PL-mazowia", + (char *)"Polish mazowia", + NULL + }, + { + &pl_iso2_day_name_ptr, + &pl_iso2_day_name_ptr_a, + &pl_iso2_mon_name_ptr, + &pl_iso2_mon_name_ptr_a, + &pl_iso2_toascii_table, + &pl_iso2_lower_table, + &pl_iso2_upper_table, + &pl_iso2_char_type, + &pl_iso2_order_tbl, + 0, + Decode_Number, + "PL-latin2", + "Polish ISO-8859-2 (Latin2)", + NULL + }, + { + &pl_cp1250_day_name_ptr, + &pl_cp1250_day_name_ptr_a, + &pl_cp1250_mon_name_ptr, + &pl_cp1250_mon_name_ptr_a, + &pl_cp1250_toascii_table, + &pl_cp1250_lower_table, + &pl_cp1250_upper_table, + &pl_cp1250_char_type, + &pl_cp1250_order_tbl, + 0, + Decode_Number, + "PL-cp1250", + "Polish cp1250 (MS Windows)", + NULL + }, + { + &pl_cp852_day_name_ptr, + &pl_cp852_day_name_ptr_a, + &pl_cp852_mon_name_ptr, + &pl_cp852_mon_name_ptr_a, + &pl_cp852_toascii_table, + &pl_cp852_lower_table, + &pl_cp852_upper_table, + &pl_cp852_char_type, + &pl_cp852_order_tbl, + 0, + Decode_Number, + "PL-cp852", + "Polish cp852 (IBM Latin2)", + NULL + }, + { + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + 0, + NULL, + NULL, + NULL, + NULL + } + }; + +Public int +isalnum(unsigned char ch) + +{ + return((*(multilanguage[Language].char_type))[ch] & IS_ALNUM); +} + +Public int +isalpha(unsigned char ch) + +{ + return((*(multilanguage[Language].char_type))[ch] & IS_ALPHA); +} + +Public int +isascii(unsigned char ch) + +{ + return((*(multilanguage[Language].char_type))[ch] & IS_ALNUM); +} + +Public int +iscntrl(unsigned char ch) + +{ + return((*(multilanguage[Language].char_type))[ch] & IS_CTR); +} + +Public int +isdigit(unsigned char ch) + +{ + return((*(multilanguage[Language].char_type))[ch] & IS_DIG); +} + +Public int +isgraph(unsigned char ch) + +{ + return(((*(multilanguage[Language].char_type))[ch] & IS_ALNUM) || + (ch >= '!' && ch <= 0x7e)); +} + +Public int +islower(unsigned char ch) + +{ + return((*(multilanguage[Language].char_type))[ch] & IS_LOWER); +} + +Public int +isupper(unsigned char ch) + +{ + return((*(multilanguage[Language].char_type))[ch] & IS_UPPER); +} + +Public int +isxdigit(unsigned char ch) + +{ + return((*(multilanguage[Language].char_type))[ch] & IS_XDIG); +} + +Public int +isprint(unsigned char ch) + +{ + return(((*(multilanguage[Language].char_type))[ch] & IS_ALNUM) || + ((ch >= ' ') && (ch <= 0x7e))); +} + +Public int +ispunct(unsigned char ch) + +{ + return(!((*(multilanguage[Language].char_type))[ch] & + (IS_BLANK | IS_ALNUM | IS_CTR))); +} + +Public int +isspace(unsigned char ch) + +{ + return((*(multilanguage[Language].char_type))[ch] & IS_BLANK); +} + +Public int +isblank(unsigned char ch) + +{ + return((*(multilanguage[Language].char_type))[ch] & IS_BLANK); +} + +Public unsigned char +mytoupper(unsigned char ch) + +{ + if((*(multilanguage[Language].char_type))[ch] & IS_LOWER) + return((*(multilanguage[Language].upper_table))[ch - 'a']); + else + return(ch); +} + +Public unsigned char +mytolower(unsigned char ch) + +{ + if((*(multilanguage[Language].char_type))[ch] & IS_UPPER) + return((*(multilanguage[Language].lower_table))[ch - 'A']); + else + return(ch); +} + +Public unsigned char * +strupr(unsigned char *s) + +{ + register unsigned char *ss; + + ss = s; + + while(*ss) + { + if((*(multilanguage[Language].char_type))[*ss] & IS_LOWER) + *ss = (*(multilanguage[Language].upper_table))[*ss - 'a']; + ss++; + } + return(s); +} + +Public unsigned char * +strlwr(unsigned char *s) + +{ + register unsigned char *ss; + + ss = s; + while(*ss) + { + if((*(multilanguage[Language].char_type))[*ss] & IS_UPPER) + *ss = (*(multilanguage[Language].lower_table))[*ss - 'A']; + ss++; + } + return(s); +} + +Public int +mystrncmp(const unsigned char *s, const unsigned char *d, size_t n) + +{ + + while(*s && *d && *s == *d && (n > 0)) + s++, d++, n--; + if(n == 0) + return(0); + else + return((*(multilanguage[Language].order_tbl))[(unsigned char)*s] - + (*(multilanguage[Language].order_tbl))[(unsigned char)*d]); +} + + +Public int +mystrcmp(const unsigned char *s, const unsigned char *d) + +{ + + while(*s && *d && *s == *d) + s++, d++; + return((*(multilanguage[Language].order_tbl))[(unsigned char)*s] - + (*(multilanguage[Language].order_tbl))[(unsigned char)*d]); +} + +Public int +charcmp(unsigned char s, unsigned char d) + +{ + return((*(multilanguage[Language].order_tbl))[s] - + (*(multilanguage[Language].order_tbl))[d]); +} + +Public const char_u * +day_name(int day) + +{ + return((*multilanguage[Language].day_name_ptr)[day]); +} + +Public const char_u * +day_name_a(int day) + +{ + return((*multilanguage[Language].day_name_ptr_a)[day]); +} + +Public const char_u * +month_name(int month) + +{ + return((*multilanguage[Language].mon_name_ptr)[month]); +} + +Public const char_u * +month_name_a(int month) + +{ + return((*multilanguage[Language].mon_name_ptr_a)[month]); +} + +Public int +strnicmp(const unsigned char *s, const unsigned char *d, size_t n) + +{ + while(*s && *d && mytolower(*s) == mytolower(*d) && (n > 0)) + s++, d++, n--; + if(n == 0) + return(0); + else + return((*(multilanguage[Language].order_tbl))[*s] - + (*(multilanguage[Language].order_tbl))[*d]); +} + +Public int +strncasecmp(const unsigned char *s, const unsigned char *d, size_t n) + +{ + while(*s && *d && mytolower(*s) == mytolower(*d) && (n > 0)) + s++, d++, n--; + if(n == 0) + return(0); + else + return((*(multilanguage[Language].order_tbl))[*s] - + (*(multilanguage[Language].order_tbl))[*d]); +} + + +Public int +stricmp(const unsigned char *s, const unsigned char *d) + +{ + while(*s && *d && mytolower(*s) == mytolower(*d)) + s++, d++; + return((*(multilanguage[Language].order_tbl))[*s] - + (*(multilanguage[Language].order_tbl))[*d]); +} + +Public int +strcasecmp(const unsigned char *s, const unsigned char *d) + +{ + while(*s && *d && mytolower(*s) == mytolower(*d)) + s++, d++; + return((*(multilanguage[Language].order_tbl))[*s] - + (*(multilanguage[Language].order_tbl))[*d]); +} + +Public unsigned char * +mystrchr(unsigned char *s, unsigned char c) +{ + + if(c == 0) + return(s + strlen((char *)s)); + while(*s) + { + if (*s == c) + return(s); + s++; + } + return(NULL); +} + +Public unsigned char * +mystrrchr(unsigned char *s, unsigned char c) + +{ + unsigned char *ss = s + strlen((char *)s); + + while (ss >= s) + { + if (*ss == c) + return(ss); + ss--; + } + return(NULL); +} + +Public int +toascii(unsigned char c) + +{ + + if(c > 127) + return((*(multilanguage[Language].toascii_table))[c - 128]); + else + return(c); +} + +Public int +set_lang(char *lang_name) + +{ + int i; + + for(i = 0; multilanguage[i].id != NULL;) + { + if(mystrcmp((unsigned char *)multilanguage[i].id, + (unsigned char *)lang_name) == 0) + break; + i++; + } + if(multilanguage[i].id == NULL) + return(1); + Language = (language)i; + return(0); +} + +Public char * +get_lang_id() + +{ + return(multilanguage[Language].name); +} + +#ifdef DEBUG + +void +test(unsigned char c1, unsigned char c2) + +{ + if(charcmp(c1, c2) < 0) + printf("%c < %c (%d)\n", c1, c2, charcmp(c1, c2)); + else if(charcmp(c1, c2) == 0) + printf("%c == %c (%d)\n", c1, c2, charcmp(c1, c2)); + else + printf("%c > %c (%d)\n", c1, c2, charcmp(c1, c2)); + +} + +#include + + +void +main(int argc, char *argv[]) + +{ + + int i; + + Language = PL_latin2; + + printf("%d\n", Language); + for(i = 1; i < 256; i++) + printf("%d %c - %d %d\n", i, i, islower(i), isupper(i)); + printf("%c %c\n", '\0xB1', mytoupper('\0xB1')); + printf("%c %c\n", '\0xE6', mytoupper('\0xE6')); + printf("%c %c\n", '\0xEA', mytoupper('\0xEA')); + printf("%c %c\n", '\0xB3', mytoupper('\0xB3')); + printf("%c %c\n", '\0xF1', mytoupper('\0xF1')); + printf("%c %c\n", '\0xF3', mytoupper('\0xF3')); + printf("%c %c\n", '\0xB6', mytoupper('\0xB6')); + printf("%c %c\n", '\0xBC', mytoupper('\0xBC')); + printf("%c %c\n", '\0xBF', mytoupper('\0xBF')); + + printf("%c %c\n", '\0xA1', mytolower('\0xA1')); + printf("%c %c\n", '\0xC6', mytolower('\0xC6')); + printf("%c %c\n", '\0xCA', mytolower('\0xCA')); + printf("%c %c\n", '\0xA3', mytolower('\0xA3')); + printf("%c %c\n", '\0xD1', mytolower('\0xD1')); + printf("%c %c\n", '\0xD3', mytolower('\0xD3')); + printf("%c %c\n", '\0xA6', mytolower('\0xA6')); + printf("%c %c\n", '\0xAC', mytolower('\0xAC')); + printf("%c %c\n", '\0xAF', mytolower('\0xAF')); +printf("%x %x\n", (*(multilanguage[Language].order_tbl))[(unsigned char)'\0xF3'], + (*(multilanguage[Language].order_tbl))[(unsigned char)'\0xD3']); +printf("%x %x\n", (*(multilanguage[Language].order_tbl))[(unsigned char)'\0xB6'], + (*(multilanguage[Language].order_tbl))[(unsigned char)'\0xA6']); +} +#endif +{% endraw %} diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/language.h b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/language.h new file mode 100644 index 0000000..0fd0187 --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/language.h @@ -0,0 +1,52 @@ + +enum _language {English, PL_mazowia, PL_latin2, PL_cp1250, PL_cp852}; +typedef enum _language language; +Global language Language; + +#define EOS '\0' +#define EMPTY_STRING (unsigned char *)"" + +#define TAB '\t' +#define LFD '\n' +#define SPC ' ' +#define LSQ '[' +#define RSQ ']' +#define BSH '\\' + + +struct decode + { + p_char_u *jedn; + p_char_u *dies; + p_char_u *setki; + p_char_u *tys; + p_char_u *mil; + }; + +struct _multilanguage + { + p_char_u *day_name_ptr; + p_char_u *day_name_ptr_a; + p_char_u *mon_name_ptr; + p_char_u *mon_name_ptr_a; + int_u *toascii_table; + a_char_u *lower_table; + a_char_u *upper_table; + a_char_u *char_type; + int_u *order_tbl; + word flags; + char_u *(*_special)(const long); + char *id; + char *name; + struct decode *decode; +}; +Global struct _multilanguage multilanguage[]; + +Global char_u *Decode_Number(const long liczba); + +#define SPECIAL_FLAG 0001 + +Global const char_u *month_name(int month); +Global const char_u *month_name_a(int month); +Global const char_u *day_name_a(int day); +Global const char_u *day_name(int day); diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/makefile.djg b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/makefile.djg new file mode 100644 index 0000000..df8c7f3 --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/makefile.djg @@ -0,0 +1,36 @@ +CC = gcc +O = .o +X = .exe + +XCFLAGS= -O2 -g -m486 -pedantic -DDEFAULT_LANGUAGE=PL_mazowia +LIBS = + +CFLAGS= -DOS_PCDOS $(XCFLAGS) +LDFLAGS = -g + +HDRS = mkind.h scanid.h scanst.h + +OBJS = genind$(O) qsort$(O) mkind$(O) scanid$(O) scanst$(O) \ + sortid$(O) decode_n$(O) language$(O) + +SRCS = genind.c mkind.c scanid.c scanst.c qsort.c sortid.c decode_n.c\ + language.c + +PROGRAM = plmindex.exe + +.c.obj: + $(CC) $(CFLAGS) $*.c + +$(PROGRAM): $(OBJS) $(MAKEFILE) + echo >mk.rf $(LDFLAGS) -o $@ $(OBJS) $(LIBS) + $(CC) @mk.rf + del mk.rf + +genind$(O): genind.c mkind.h +mkind$(O): mkind.c mkind.h +qsort$(O): qsort.c mkind.h +scanid$(O): scanid.c mkind.h scanid.h +scanst$(O): scanst.c mkind.h scanst.h +sortid$(O): sortid.c mkind.h +language$(O): pl_maz.h pl_iso2.h us_eng.h pl_1250.h pl_852.h mkind.h +mkind.h: myctype.h diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/makefile.emx b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/makefile.emx new file mode 100644 index 0000000..342d004 --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/makefile.emx @@ -0,0 +1,40 @@ +CC = gcc +O = .o +X = .exe + +XCFLAGS= -O2 -g -m486 -pedantic -DDEFAULT_LANGUAGE=PL_mazowia +LIBS = + +CFLAGS= -DOS_PCDOS $(XCFLAGS) +LDFLAGS = -g + +HDRS = mkind.h scanid.h scanst.h + +MAKEFILE = Makefile + +OBJS = genind$(O) qsort$(O) mkind$(O) scanid$(O) scanst$(O) \ + sortid$(O) decode_n$(O) language$(O) + +SRCS = genind.c mkind.c scanid.c scanst.c qsort.c sortid.c decode_n.c\ + language.c + +PROGRAM = plmindex + +.c.obj: + $(CC) $(CFLAGS) $*.c + +plmindex.exe : plmindex + emxbind plmindex + +$(PROGRAM): $(OBJS) $(MAKEFILE) + $(CC) $(LDFLAGS) -o $@ $(OBJS) $(LIBS) + +genind$(O): genind.c mkind.h +mkind$(O): mkind.c mkind.h +qsort$(O): qsort.c mkind.h +scanid$(O): scanid.c mkind.h scanid.h +scanst$(O): scanst.c mkind.h scanst.h +sortid$(O): sortid.c mkind.h +language$(O): pl_maz.h pl_iso2.h us_eng.h pl_1250.h pl_852.h mkind.h +mkind.h: myctype.h + diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/makefile.gcc b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/makefile.gcc new file mode 100644 index 0000000..4e24414 --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/makefile.gcc @@ -0,0 +1,37 @@ +CC = gcc +O = .o +X = + +XCFLAGS= -unsigned-char -O2 -g -pedantic -DDEFAULT_LANGUAGE=PL_latin2 +LIBS = + +CFLAGS= $(XCFLAGS) +LDFLAGS = -g + +HDRS = mkind.h scanid.h scanst.h + +MAKEFILE = makefile.gcc + +OBJS = genind$(O) qsort$(O) mkind$(O) scanid$(O) scanst$(O) \ + sortid$(O) decode_n$(O) language$(O) + +SRCS = genind.c mkind.c scanid.c scanst.c qsort.c sortid.c decode_n.c\ + language.c + +PROGRAM = plmindex + +.c.o: + $(CC) -c $(CFLAGS) $*.c + +$(PROGRAM): $(OBJS) $(MAKEFILE) + $(CC) $(LDFLAGS) -o $@ $(OBJS) $(LIBS) + +genind$(O): genind.c mkind.h +mkind$(O): mkind.c mkind.h +qsort$(O): qsort.c mkind.h +scanid$(O): scanid.c mkind.h scanid.h +scanst$(O): scanst.c mkind.h scanst.h +sortid$(O): sortid.c mkind.h +language$(O): pl_maz.h pl_iso2.h us_eng.h pl_1250.h pl_852.h mkind.h +mkind.h: myctype.h + diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/makefile.msc b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/makefile.msc new file mode 100644 index 0000000..f6211e7 --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/makefile.msc @@ -0,0 +1,36 @@ +CC = cl +O = .obj +X = .exe + +XCFLAGS= -DDEFAULT_LANGUAGE=PL_cp1250 -c +LIBS = + +CFLAGS= -DOS_PCDOS $(XCFLAGS) +LDFLAGS = + +HDRS = mkind.h scanid.h scanst.h + +OBJS = genind$(O) qsort$(O) mkind$(O) scanid$(O) scanst$(O) \ + sortid$(O) decode_n$(O) language$(O) + +SRCS = genind.c mkind.c scanid.c scanst.c qsort.c sortid.c decode_n.c\ + language.c + +PROGRAM = plmindex.exe + +.c.obj: + $(CC) $(CFLAGS) $*.c + +$(PROGRAM): $(OBJS) $(MAKEFILE) + echo >mk.rf $(LDFLAGS) -o $@ $(OBJS) $(LIBS) + $(CC) @mk.rf + del mk.rf + +genind$(O): genind.c mkind.h +mkind$(O): mkind.c mkind.h +qsort$(O): qsort.c mkind.h +scanid$(O): scanid.c mkind.h scanid.h +scanst$(O): scanst.c mkind.h scanst.h +sortid$(O): sortid.c mkind.h +language$(O): pl_maz.h pl_iso2.h us_eng.h pl_1250.h pl_852.h mkind.h +mkind.h: myctype.h diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/mkind.c b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/mkind.c new file mode 100644 index 0000000..ab4b90e --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/mkind.c @@ -0,0 +1,743 @@ +/* + * + * This file is part of + * MakeIndex - A formatter and format independent index processor + * + * Copyright (C) 1989 by Chen & Harrison International Systems, Inc. + * Copyright (C) 1988 by Olivetti Research Center + * Copyright (C) 1987 by Regents of the University of California + * + * Author: + * Pehong Chen + * Chen & Harrison International Systems, Inc. + * Palo Alto, California + * USA + * (phc@renoir.berkeley.edu or chen@orc.olivetti.com) + * + * Contributors: + * Please refer to the CONTRIB file that comes with this release + * for a list of people who have contributed to this and/or previous + * release(s) of MakeIndex. + * + * All rights reserved by the copyright holders. See the copyright + * notice distributed with this software for a complete description of + * the conditions under which it is made available. + * + */ + +#define MKIND_C 1 +#include "mkind.h" +#undef MKIND_C +#include + +Public language Language = DEFAULT_LANGUAGE; +Public Logical blank_ignore = False; +Public Logical special_flag = False; +Public Logical compress_blanks = False; +Public Logical merge_page = True; +Public Logical init_page = False; +Public int even_odd = -1; +Public Logical verbose = True; +Public int fn_no = -1; /* total number of files */ +Public Logical idx_dot = True; /* flag which shows dot in ilg being + * active */ +Public int idx_tt = 0; /* total entry count (all files) */ +Public int idx_et = 0; /* erroneous entry count (all files) */ +Public int idx_gt = 0; /* good entry count (all files) */ + +Public FIELD_PTR *idx_key; +Public FILE *log_fp; +Public FILE *sty_fp; +Public FILE *idx_fp; +Public FILE *ind_fp; +Public FILE *ilg_fp; + +Public char *pgm_fn; +Public char sty_fn[LINE_MAX]; +Public char *idx_fn; +Public char ind[STRING_MAX]; +Public char *ind_fn; +Public char ilg[STRING_MAX]; +Public char *ilg_fn; +Public char pageno[NUMBER_MAX]; + +Local char log_fn[STRING_MAX]; +Local char base[STRING_MAX]; +Local Logical need_version = True; + +Local void check_all (char *fn, Logical ind_given, Logical ilg_given, + Logical log_given); +Local void check_idx (char *fn,int open_fn); +Local void find_pageno (void); +Local void open_sty (char *fn); +Local void prepare_idx (void); +Local void process_idx (char * *fn, Logical use_stdin, + Logical sty_given, Logical ind_given, Logical ilg_given, + Logical log_given); + +#if OS_ATARI +Public long _stksize = 20000L; /* make the stack larger than 2KB */ + /* size must be given */ +#endif /* OS_ATARI */ + +#ifdef DEBUG +Public long totmem = 0L; /* for debugging memory usage */ +#endif /* DEBUG */ + +Public int +main(int argc, char *argv[]) + +{ + char **fns; + char *ap; + Logical use_stdin = False; + Logical sty_given = False; + Logical ind_given = False; + Logical ilg_given = False; + Logical log_given = False; + + /* determine program name */ + + if((fns = (char **) calloc(sizeof(*fns), ARRAY_MAX)) == NULL) + Fatal("Not enough core...abort.\n"); +#if(OS_ATARI | OS_VAXVMS | OS_MVSXA | OS_VMCMS) + pgm_fn = "MakeIndex"; /* Use symbolic name on some systems */ +#else + +#if OS_PCDOS + { + char *last = NULL, + *beg; + + pgm_fn = argv[0]; + for(beg = pgm_fn; *beg != EOS; beg++) + { + if(*beg == ':' || *beg == '/' || *beg == '\\') + last = beg; + } + if(last++ != NULL) + { + char *beg = pgm_fn; + + while(*beg++ = *last++) + ; + } + last = (char *)mystrrchr((unsigned char *)pgm_fn, (unsigned char)('.')); + if(last != NULL) + *last = EOS; + } + (void)strlwr((unsigned char *)pgm_fn); +#else + pgm_fn = (char *)mystrrchr((unsigned char *)*argv, (unsigned char)DIR_DELIM); + if(pgm_fn == NULL) + pgm_fn = *argv; + else + pgm_fn++; +#endif /* OS_PCDOS */ + +#endif /* OS_VAXVMS | OS_MVSXA */ + + /* process command line options */ + while(--argc > 0) + { + if(**++argv == SW_PREFIX) + { + if(*(*argv + 1) == EOS) + break; + for(ap = ++*argv; *ap != EOS; ap++) + switch(*ap) + { + case '!': + special_flag = True; + break; + case 'l': + blank_ignore = True; + break; + /* use standard input */ + case 'i': + case 'I': + use_stdin = True; + break; + + /* disable range merge */ + case 'r': + case 'R': + merge_page = False; + break; + + /* supress progress message -- quiet mode */ + case 'q': + case 'Q': + verbose = False; + break; + + /* compress blanks */ + case 'c': + case 'C': + compress_blanks = True; + break; + + /* style file */ + case 's': + case 'S': + argc--; + if(argc <= 0) + Fatal("Expected -s \n"); + open_sty(*++argv); + sty_given = True; + break; + + /* output index file name */ + case 'o': + case 'O': + argc--; + if(argc <= 0) + Fatal("Expected -o \n"); + ind_fn = *++argv; + ind_given = True; + break; + + /* transcript file name */ + case 't': + case 'T': + argc--; + if(argc <= 0) + Fatal("Expected -t \n"); + ilg_fn = *++argv; + ilg_given = True; + break; + + case 'L': + { + int i; + char *lang_name; + + argc--; + if(argc <= 0) + Fatal("Expected -L \n"); + lang_name = *++argv; + for(i = 0; multilanguage[i].id != NULL;) + { + if(mystrcmp((unsigned char *)(multilanguage[i].id), + (unsigned char *)lang_name) == 0) + break; + i++; + } + if(multilanguage[i].id == NULL) + Fatal("Illegal language\n"); + Language = (language)i; + } + break; + + /* initial page */ + case 'p': + case 'P': + argc--; + if(argc <= 0) + Fatal("Expected -p \n"); + strcpy(pageno, *++argv); + init_page = True; + if(STREQ(pageno, EVEN)) + { + log_given = True; + even_odd = 2; + } + else if(STREQ(pageno, ODD)) + { + log_given = True; + even_odd = 1; + } + else if(STREQ(pageno, ANY)) + { + log_given = True; + even_odd = 0; + } + break; + + case 'h': + case 'H': + case '?': + usage(pgm_fn); + return(1); + /* bad option */ + default: + Fatal("Unknown option -%c.\n", *ap); + break; + } + } + else + { + if(fn_no < ARRAY_MAX) + { + check_idx(*argv, False); + fns[++fn_no] = *argv; + } + else + Fatal("Too many input files (max %d).\n", ARRAY_MAX); + } + } + + if(special_flag) + multilanguage[Language].flags |= SPECIAL_FLAG; + + +/* changes for 2.12 (May 20, 1993) by Julian Reschke (jr@ms.maus.de): + if only one input file and no explicit style file was given */ + + if(fn_no == 0 && !sty_given) + { + char tmp[STRING_MAX + 5]; + + /* base set by last call to check_idx */ + sprintf(tmp, "%s%s", base, INDEX_STY); + if(0 == access(tmp, R_OK)) + { + open_sty (tmp); + sty_given = True; + } + } + + process_idx(fns, use_stdin, sty_given, ind_given, ilg_given, log_given); + + idx_gt = idx_tt - idx_et; + if(fn_no > 0) + Message("Overall %d files read (%d entries accepted, %d rejected).\n", \ + fn_no + 1, idx_gt, idx_et); + if(idx_gt > 0) + { + prepare_idx(); + sort_idx(); + gen_ind(); +/*{ + NODE_PTR aqq; + int i = 0; + int j = 0; + + aqq = head; + + do + { + + printf("type=%d\n", aqq->data.type); + for(i = 0; i < FIELD_MAX; i++) + if(aqq->data.sf[i][0] != EOS) + printf("%s\n", aqq->data.sf[i]); + aqq = aqq->next; + }while(aqq != NULL); + for(j = 0; j < idx_gt; j++) + { + printf("type=%d\n", idx_key[j]->type); + for(i = 0; i < FIELD_MAX; i++) + if(idx_key[j]->sf[i][0] != EOS) + printf("%s\n", idx_key[j]->sf[i]); + } + }*/ + Message("Output written in %s.\n", ind_fn); + } + else + Message("Nothing written in %s.\n", ind_fn); + + Message("Transcript written in %s.\n", ilg_fn); + CLOSE(ind_fp); + CLOSE(ilg_fp); + free(fns); + + return(0); +} + +Local void +prepare_idx(VOID_ARG) + +{ + NODE_PTR ptr = head; + int i = 0; + +#ifdef DEBUG + totmem += idx_gt * sizeof(FIELD_PTR); + (void)fprintf(stderr,"prepare_idx(): calloc(%d,%d)\ttotmem = %ld\n", + idx_gt,sizeof(FIELD_PTR),totmem); +#endif /* DEBUG */ + + if(head == (NODE_PTR)NULL) + Fatal("No valid index entries collected.\n"); + + if((idx_key = (FIELD_PTR *) calloc(idx_gt, sizeof(FIELD_PTR))) == NULL) + Fatal("Not enough core...abort.\n"); + for(i = 0; i < idx_gt; i++) + { + idx_key[i] = &(ptr->data); + ptr = ptr->next; + } +} + +Local void +process_idx(char *fn[], Logical use_stdin, Logical sty_given, Logical ind_given, + Logical ilg_given, Logical log_given) + +{ + int i; + + if(fn_no == -1) + /* use stdin if no input files specified */ + use_stdin = True; + else + { + check_all(fn[0], ind_given, ilg_given, log_given); + PUT_VERSION; + if(sty_given) + scan_sty(); + scan_idx(); + ind_given = True; + ilg_given = True; + for(i = 1; i <= fn_no; i++) + { + check_idx(fn[i], True); + scan_idx(); + } + } + + + if(use_stdin) + { + idx_fn = "stdin"; + idx_fp = stdin; + + if(ind_given) + { + if(!ind_fp && ((ind_fp = OPEN_OUT(ind_fn)) == NULL)) + Fatal("Can't create output index file %s.\n", ind_fn); + } + else + { + ind_fn = "stdout"; + ind_fp = stdout; + } + + if(ilg_given) + { + if(!ilg_fp && ((ilg_fp = OPEN_OUT(ilg_fn)) == NULL)) + Fatal("Can't create transcript file %s.\n", ilg_fn); + } + else + { + ilg_fn = "stderr"; + ilg_fp = stderr; + } + + if((fn_no == -1) && (sty_given)) + scan_sty(); + if(need_version) + { + PUT_VERSION; + } + + scan_idx(); + fn_no++; + } +} + +Local void +check_idx(char *fn, int open_fn) + +{ + char *ptr = fn; + char *ext; + int with_ext = False; + int i = 0; + + ext = (char *)mystrrchr((unsigned char *)fn, (unsigned char)EXT_DELIM); + if((ext != NULL) && (ext != fn) && (*(ext + 1) != DIR_DELIM)) + { + with_ext = True; + while((ptr != ext) && (i < STRING_MAX)) + base[i++] = *ptr++; + } + else + while((*ptr != EOS) && (i < STRING_MAX)) + base[i++] = *ptr++; + + if(i < STRING_MAX) + base[i] = EOS; + else + Fatal("Index file name %s too long (max %d).\n", base, STRING_MAX); + + idx_fn = fn; + + if((open_fn && ((idx_fp = OPEN_IN(idx_fn)) == NULL)) || + ((!open_fn) && (access(idx_fn, R_OK) != 0))) + if(with_ext) + Fatal("Input index file %s not found.\n", idx_fn); + else + { + +#ifdef DEBUG + totmem += STRING_MAX; + (void)fprintf(stderr,"check_idx()-2: malloc(%d)\ttotmem = %ld\n", + STRING_MAX,totmem); +#endif /* DEBUG */ + + if((idx_fn = (char *) malloc(STRING_MAX)) == NULL) + Fatal("Not enough core...abort.\n"); + sprintf(idx_fn, "%s%s", base, INDEX_IDX); + if((open_fn && ((idx_fp = OPEN_IN(idx_fn)) == NULL)) || + ((!open_fn) && (access(idx_fn, R_OK) != 0))) + Fatal("Couldn't find input index file %s or %s.\n", base, + idx_fn); + } +} + +Local void +check_all(char *fn, Logical ind_given, Logical ilg_given, Logical log_given) + +{ + check_idx(fn, True); + + /* index output file */ + if(!ind_given) + { + sprintf(ind, "%s%s", base, INDEX_IND); + ind_fn = ind; + } + if((ind_fp = OPEN_OUT(ind_fn)) == NULL) + Fatal("Can't create output index file %s.\n", ind_fn); + + /* index transcript file */ + if(!ilg_given) + { + sprintf(ilg, "%s%s", base, INDEX_ILG); + ilg_fn = ilg; + } + if((ilg_fp = OPEN_OUT(ilg_fn)) == NULL) + Fatal("Can't create transcript file %s.\n", ilg_fn); + + if(log_given) + { + sprintf(log_fn, "%s%s", base, INDEX_LOG); +#if OS_PCDOS /* open in binary mode (CR-LF) */ + if((log_fp = OPEN_IN_B(log_fn)) == NULL) +#else + if((log_fp = OPEN_IN(log_fn)) == NULL) +#endif /* OS_PCDOS */ + Fatal("Source log file %s not found.\n", log_fn); + else + { + find_pageno(); + CLOSE(log_fp); + } + } +} + +Local void +find_pageno(VOID_ARG) + +{ + int i = 0; + unsigned char p, + c; + +#if(OS_VAXVMS | OS_MVSXA) + /* + * Scan forward through the file for VMS, because fseek doesn't work on + * variable record files + */ + c = GET_CHAR(log_fp); + while(c != EOF) + { + p = c; + c = GET_CHAR(log_fp); + if(p == LSQ && isdigit(c)) + { + i = 0; + do + { + pageno[i++] = c; + c = GET_CHAR(log_fp); + } while(isdigit(c)); + pageno[i] = EOS; + } + } + if(i == 0) + { + fprintf(ilg_fp, "Couldn't find any page number in %s...ignored\n", + log_fn); + init_page = False; + } +#else /* NOT (OS_VAXVMS | ...) */ + fseek(log_fp, -1L, 2); + p = GET_CHAR(log_fp); + fseek(log_fp, -2L, 1); + do + { + c = p; + p = GET_CHAR(log_fp); + }while(!(((p == LSQ) && isdigit(c)) || (fseek(log_fp, -2L, 1) != 0))); + if(p == LSQ) + { + while((c = GET_CHAR(log_fp)) == SPC); + do + { + pageno[i++] = (char) c; + c = GET_CHAR(log_fp); + } while(isdigit(c)); + pageno[i] = EOS; + } + else + { + fprintf(ilg_fp, "Couldn't find any page number in %s...ignored\n", + log_fn); + init_page = False; + } +#endif /* (OS_VAXVMS | ...) */ +} + +Local void +open_sty(char *fn) + +{ + char *path; + char *local_fn; + char *ptr; + int i; + int len; + + if((local_fn = (char *)malloc(LINE_MAX)) == NULL) + Fatal("Not enough core...abort.\n"); + strcpy(local_fn, fn); + if((mystrrchr((unsigned char *)local_fn, (unsigned char)'.') == NULL) && + (strlen(local_fn) + 4) < LINE_MAX) + strcat(local_fn, INDEX_STY); + if((path = getenv(STYLE_PATH)) == NULL) + { + /* style input path not defined */ + strcpy(sty_fn, local_fn); + sty_fp = OPEN_IN(sty_fn); + } + else + { +#if OS_VAXVMS + if((strlen(STYLE_PATH) + strlen(local_fn) + 1) > LINE_MAX) + Fatal("Path %s too long (max %d).\n", STYLE_PATH, LINE_MAX); + else + { + sprintf(sty_fn, "%s:%s", STYLE_PATH, local_fn); + sty_fp = OPEN_IN(sty_fn); + } +#else /* NOT OS_VAXVMS */ + len = LINE_MAX - strlen(local_fn) - 1; + while(*path != EOS) + { + ptr = (char *)mystrchr((unsigned char *)path, + (unsigned char)ENV_SEPAR); + i = 0; + if(ptr == (char*)NULL) + { + int j = strlen(path); + + while(i < j) + sty_fn[i++] = *path++; + } + else + { + while((path != ptr) && (i < len)) + sty_fn[i++] = *path++; + } + if(i == len) + Fatal("Path %s too long (max %d).\n", sty_fn, LINE_MAX); + else + { +#ifdef OS_VAXVMS + if(sty_fn[i - 1] != ']') + sty_fn[i++] = DIR_DELIM; +#else + sty_fn[i++] = DIR_DELIM; +#endif + sty_fn[i] = EOS; + strcat(sty_fn, local_fn); + if((sty_fp = OPEN_IN(sty_fn)) == NULL) + path++; + else + break; + } + } +#endif /* OS_VAXVMS */ + } + + if(sty_fp == NULL) + Fatal("Index style file %s not found.\n", local_fn); + free(local_fn); +} + +Public int +strtoint(char *str) + +{ + int val = 0; + + while(*str != EOS) + { +#if (OS_MVSXA) + val = 10 * val + *str - '0'; +#else + val = 10 * val + *str - 48; +#endif /* (OS_MVSXA) */ + str++; + } + return(val); +} + +Public void +usage(char *program_name) + +{ + int i; + + fprintf(stderr, +"Usage: \n %s [] [-s ] [-o ] [-t ] [-p ] "\ + "[ ...]\n"\ + "\t = -l - ignore interword space\n"\ + "\t -i - use standard input (stdin) as input file\n"\ + "\t -q - quiet mode\n"\ + "\t -r - disable range merge\n"\ + "\t -c - compress blanks\n"\ + "\t -L - language\n", + program_name); + fprintf(stderr, "\t\t\t\t - %s\n", multilanguage[0].id); + for(i = 1; multilanguage[i].id != NULL; i++) + fprintf(stderr, "\t\t\t\t - %s\n", multilanguage[i].id); + fprintf(stderr, + "\t\t-s - style file (default extension .mst)\n"\ + "\t\t-o - output file (default extension .ind)\n"\ + "\t\t-t - log file (default extension .ilg)\n"\ + "\t\t-p - starting page count \n"\ + "\t\t\t\t - \n"\ + "\t\t\t\t - odd\n"\ + "\t\t\t\t - even\n"\ + "\t\t\t\t - any\n"\ + "\t\t - source file (index; default extension .idx)\n"); +} + +Public void +Fatal(const char *fmt, ...) + +{ + va_list arg_ptr; + + va_start(arg_ptr, fmt); + vfprintf(stderr, fmt, arg_ptr); + va_end(arg_ptr); + EXIT(1); +} + +Public void +Message(const char *fmt, ...) + +{ + va_list arg_ptr; + + va_start(arg_ptr, fmt); + if(verbose) + vfprintf(stderr, fmt, arg_ptr); + if((ilg_fp != stderr) || !verbose) + vfprintf(ilg_fp, fmt, arg_ptr); + va_end(arg_ptr); +} diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/mkind.h b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/mkind.h new file mode 100644 index 0000000..4b00ef1 --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/mkind.h @@ -0,0 +1,632 @@ +/* + * + * This file is part of + * MakeIndex - A formatter and format independent index processor + * + * Copyright (C) 1989 by Chen & Harrison International Systems, Inc. + * Copyright (C) 1988 by Olivetti Research Center + * Copyright (C) 1987 by Regents of the University of California + * + * Author: + * Pehong Chen + * Chen & Harrison International Systems, Inc. + * Palo Alto, California + * USA + * (phc@renoir.berkeley.edu or chen@orc.olivetti.com) + * + * Contributors: + * Please refer to the CONTRIB file that comes with this release + * for a list of people who have contributed to this and/or previous + * release(s) of MakeIndex. + * + * All rights reserved by the copyright holders. See the copyright + * notice distributed with this software for a complete description of + * the conditions under which it is made available. + * + */ + +/*********************************************************************** + + INSTALLATION NOTES + <11-Nov-1989> + + At compile-time (or here, if compile-time definition is not + available), set non-zero ONE OS_xxxx operating system flag, and if + more than one compiler is available, ONE compiler flag: + + Operating Systems Compiler(s) + ================= =========== + OS_ATARI + OS_UNIX + OS_MVSXA IBM_C370 + OS_VMCMS IBM_C370 + OS_TOPS20 KCC_20 or PCC_20 + OS_VAXVMS + ================= =========== + + If Standard C prototypes are supported, define the symbol + STDC_PROTOTYPES in the appropriate OS_xxxx section below, and insert + #include's for the standard system files which define library + prototypes. STDC_PROTOTYPES will be defined automatically if + __STDC__ is; the latter must be defined by all Standard C conformant + implementations. + + All function declarations in MakeIndex are contained at the end of + this file. If 185STDC_PROTOTYPES is not selected, then all the standard + library functions must be declared explicitly. + + If the host system restricts Globalal names to 6 characters, set + SHORTNAMES non-zero in the appropriate OS_xxxx section below. + + Installing MakeIndex under BS2000 requires at least Version 8.5 + supporting Multiple Public Volume Sets (MPVS). Define WORK in this + file to your CATID (default :w:) for temporary files (.ilg, .ind), + in case of no MPVS support define WORK to NIL. + +*/ + +/**********************************************************************/ + +#define STDC (__STDC__ || __cplusplus) + +/* + * Establish needed operating symbols (defaulting to OS_UNIX if none + * specified at compile time). If you add one, add it to the check + * list at the end of this section, too. + */ + +#ifndef OS_ATARI +#define OS_ATARI 0 +#endif + +#ifndef OS_PCDOS +#define OS_PCDOS 0 +#endif + +#ifndef OS_TOPS20 +#define OS_TOPS20 0 +#endif + +#ifndef KCC_20 +#define KCC_20 0 +#endif + +#ifndef PCC_20 +#define PCC_20 0 +#endif + +#ifndef OS_UNIX +#define OS_UNIX 0 +#endif + +#ifndef OS_VAXVMS +#define OS_VAXVMS 0 +#endif + +#ifndef IBM_C370 +#define IBM_C370 0 +#endif + +#if OS_TOPS20 +#if (KCC_20 || PCC_20) +#else +#undef PCC_20 +#define PCC_20 1 /* PCC-20 is default for Tops-20 */ +#endif /* KCC_20 || PCC_20) */ +#endif /* OS_TOPS20 */ + +#ifndef OS_MVSXA +#define OS_MVSXA 0 +#endif + +#ifndef OS_VMCMS +#define OS_VMCMS 0 +#endif + +#if (OS_ATARI || OS_UNIX || OS_MVSXA || OS_PCDOS || OS_VMCMS) +#else +#if (OS_TOPS20 || OS_VAXVMS) +#else +#undef OS_UNIX +#define OS_UNIX 1 /* Unix is default operating system */ +#endif +#endif + +#if (OS_MVSXA || OS_VMCMS) +#undef IBM_C370 +#define IBM_C370 1 /* IBM_C370 is default for OS_MVSXA and OS_VMCMS */ +#endif + + +#if (OS_MVSXA || OS_TOPS20 || OS_VMCMS) +#define SHORTNAMES 1 +#else +#define SHORTNAMES 0 +#endif + +#define STDC_PROTOTYPES STDC + +/**********************************************************************/ + +#include + +#if OS_PCDOS + +# include /* for function declarations */ + +# include /* for function declarations */ +# include /* for function declarations */ +# undef STDC_PROTOTYPES +# define STDC_PROTOTYPES 1 /* so we get full argument + type checking */ +#endif /* OS_PCDOS */ +#include "myctype.h" + +#if (OS_VMCMS || OS_MVSXA) +# include /* for function declarations */ +# undef STDC_PROTOTYPES +# define STDC_PROTOTYPES 1 /* so we get full argument + type checking */ +# if 0 +# undef __STDC__ +# define __STDC__ 1 +# endif +#endif /* OS_MVSXA || OS_VMCMS */ + +#if OS_ATARI + +# if ATARI_ST_TURBO +# define access(fn, mode) 0 /* function not available */ +# endif + +# if __GNUC__ +# include +# include +# endif + +# undef STDC_PROTOTYPES +# define STDC_PROTOTYPES 1 /* so we get full argument checking */ + +#endif /* OS_ATARI */ + +#if IBM_C370 +# define access(fn, mode) 0 /* function not available */ +#endif + +#if SHORTNAMES +/* + * Provide alternate Globalal names which are unique in the first SIX + * characters as required for portability (and Standard C) + */ +#define check_all chk_all +#define check_idx chk_idx +#define check_mixsym chk_mix +#define compare_one cmp_one +#define compare_page cmp_page +#define compare_string cmp_string +#define delim_n dlm_n +#define delim_p dlm_p +#define delim_r dlm_r +#define delim_t dlm_t +#define encap_i ecp_i +#define encap_p ecp_p +#define encap_range ecp_range +#define encap_s ecp_s +#define group_skip grp_skip +#define group_type grp_type +#define idx_aclose idxaclose +#define idx_actual idxactual +#define idx_keyword idx_kwd +#define indent_length ind_length +#define indent_space ind_space +#define headings_flag hd_flag +#define heading_pre hd_pre +#define heading_suf hd_suf +#define symhead_pos sym_pos +#define symhead_neg sym_neg +#define numhead_pos num_pos +#define numhead_neg num_neg +#define process_idx prc_idx +#define process_precedence prc_pre +#define range_ptr rng_ptr +#define scan_alpha_lower scnalw +#define scan_alpha_upper scnaup +#define scan_arabic scnarabic +#define scan_arg1 scna1 +#define scan_arg2 scna2 +#define scan_char scnchr +#define scan_field scnfld +#define scan_idx scnidx +#define scan_key scnkey +#define scan_no scnno +#define scan_roman_lower scnrlw +#define scan_roman_upper scnrup +#define scan_spec scnspc +#define scan_string scnstr +#define scan_style scnsty +#define setpagelen spg_len +#define setpage_close spg_close +#define setpage_open spg_open +#define suffix_2p suf_2p +#define suffix_3p suf_3p +#define suffix_mp suf_mp +#endif /* SHORTNAMES */ + +#if OS_VAXVMS +#define EXIT(code) exit( ((code) == 0) ? 1 : (1 << 28) + 2 ) +#else /* NOT OS_VAXVMS */ +#define EXIT exit +#endif /* OS_VAXVMS */ + +#define Local static +#define Global extern +#define Public + +enum _logical {False,True}; +typedef enum _logical Logical; + +#define EOS '\0' +#define EMPTY_STRING (unsigned char *)"" + +#define TAB '\t' +#define LFD '\n' +#define SPC ' ' +#define LSQ '[' +#define RSQ ']' +#define BSH '\\' + +#if OS_ATARI +#define ENV_SEPAR ';' +#define DIR_DELIM '\\' +#endif /* OS_ATARI */ + +#if (OS_UNIX) +#define ENV_SEPAR ':' +#define DIR_DELIM '/' +#endif /* (OS_UNIX)*/ + + +#if (OS_MVSXA || OS_VMCMS) +#define ENV_SEPAR '.' +#define DIR_DELIM '.' +#endif /* OS_MVSXA || OS_VMCMS */ + +#if OS_PCDOS +#define ENV_SEPAR ';' +#define DIR_DELIM '\\' +#endif /* OS_PCDOS */ + +#if OS_TOPS20 +#define ENV_SEPAR ',' +#define DIR_DELIM ':' +#endif /* OS_TOPS20 */ + +#if OS_VAXVMS +#define ENV_SEPAR ',' /* In fact these aren't used */ +#define DIR_DELIM ':' +#endif /* OS_VAXVMS */ + +#ifndef SW_PREFIX /* can override at compile time */ +#define SW_PREFIX '-' +#endif + +#define EXT_DELIM '.' +#define ROMAN_SIGN '*' +#define EVEN "even" +#define ODD "odd" +#define ANY "any" + +#define GET_CHAR getc + + +#define TOLOWER(C) mytolower((unsigned char)C) +#define TOUPPER(C) mytoupper((unsigned char)C) +#define TOASCII(i) toascii((unsigned char)i) +#define STRNEQ(A, B) ((((A) == NULL) && ((B) == NULL)) ? False : \ + ((((A) == NULL) || ((B) == NULL)) ? True : \ + (mystrcmp((unsigned char *)(A), (unsigned char *)(B)) != 0))) + +#define STREQ(A, B) ((((A) == NULL) && ((B) == NULL)) ? True : \ + ((((A) == NULL) || ((B) == NULL)) ? False : \ + (mystrcmp((unsigned char *)(A), (unsigned char *)(B)) == 0))) + +#if (OS_MVSXA) +#define DIGTOASCII(i) (char)((i) + '0') +#else +#define DIGTOASCII(i) (char)((i) + 48) +#endif /* (OS_MVSXA) */ + +#if OS_PCDOS /* open file in binary mode */ +#define OPEN_IN_B(FP) fopen(FP, "rb") +#endif + +#define OPEN_IN(FP) fopen(FP, "r") +#define OPEN_OUT(FP) fopen(FP, "w") +#define CLOSE(FP) fclose(FP) + +#define ISDIGIT(C) isdigit(C) +#define ISSYMBOL(C) (!(isdigit(C) || isalpha(C) || iscntrl(C) || C == SPC)) + +/*==================================================================== +Many arrays in MakeIndex are dimensioned [xxx_MAX], where the xxx_MAX +values are defined below. The use of each of these is described in +comments. However, no run-time check is made to ensure that these are +consistent, or reasonable! Therefore, change them only with great +care. + +The array sizes should be made generously large: there are a great +many uses of strings in MakeIndex with the strxxx() and sprintf() +functions where no checking is done for adequate target storage sizes. +Although some input checking is done to avoid this possibility, it is +highly likely that there are still several places where storage +violations are possible, with core dumps, or worse, incorrect output, +ensuing. +======================================================================*/ + +#define ARABIC_MAX 5 /* maximum digits in an Arabic page */ + /* number field */ + +#define ARGUMENT_MAX 1024 /* maximum length of sort or actual key */ + /* in index entry */ + +#define ARRAY_MAX 1024 /* maximum length of constant values in */ + /* style file */ + +#define FIELD_MAX 4 /* maximum levels of index entries (item, */ + /* subitem, subsubitem); cannot be */ + /* increased beyond 3 without */ + /* significant design changes (no field */ + /* names are known beyond 3 levels) */ + +#ifdef LINE_MAX /* IBM RS/6000 AIX has this in */ +#undef LINE_MAX +#endif +#define LINE_MAX 72 /* maximum output line length (longer */ + /* ones wrap if possible) */ + +#define NUMBER_MAX 16 /* maximum digits in a Roman or Arabic */ + /* page number */ + /* (MAX(ARABIC_MAX,ROMAN_MAX)) */ + +#define PAGEFIELD_MAX 10 /* maximum fields in a composite page */ + /* number */ + +#define PAGETYPE_MAX 5 /* fixed at 5; see use in scanst.c */ + +#define ROMAN_MAX 16 /* maximum length of Roman page number */ + /* field */ + +#define STRING_MAX 256 /* maximum length of host filename */ + +/*====================================================================*/ + +#define VERSION "Version 2.12wm [28-Feb-1999]" + +#if 0 +#define VERSION "Version 2.12wm [28-Feb-1999]" +#define VERSION "Version 2.12a [25-May-1995]" +#define VERSION "portable version 2.11 [19-Oct-1991]" +#define VERSION "portable version 2.10 [05-Jul-1991]" +#define VERSION "portable version 2.9.1 [21-Jun-1990]" +#define VERSION "portable version 2.9 [13-Dec-1989]" +#define VERSION "portable version 2.8 [11-Nov-1989]" +#define VERSION "portable version 2.7 [01-Oct-1988]" +#define VERSION "portable version 2.6 [14-Jul-1988]" +#define VERSION "portable version 2.5 [14-Apr-1988]" +#define VERSION "portable version 2.4 [20-Mar-1988]" +#define VERSION "portable version 2.3 [20-Jan-1988]" +#define VERSION "version 2.2 [29-May-1987]" +#endif + +#define PUT_VERSION \ + { \ + Message("This is %s, ", pgm_fn); \ + Message("%s (%s).\n", VERSION, multilanguage[Language].name); \ + need_version = False; \ + } + + +#define STYLE_PATH "INDEXSTYLE" /* environment variable defining search */ + /* path for style files */ +#define INDEX_IDX ".idx" +#define INDEX_ILG ".ilg" +#define INDEX_IND ".ind" +#define INDEX_STY ".mst" + +#if OS_VAXVMS +#define INDEX_LOG ".lis" +#else +#define INDEX_LOG ".log" +#endif + +#define EMPTY -9999 +#define ROML 0 +#define ROMU 1 +#define ARAB 2 +#define ALPL 3 +#define ALPU 4 +#define DUPLICATE 9999 + +#define SYMBOL -1 +#define ALPHA -2 + +#define GERMAN 0 + +typedef struct KFIELD + { + unsigned char *sf[FIELD_MAX]; /* sort key */ + unsigned char *af[FIELD_MAX]; /* actual key */ + int group; /* key group */ + char lpg[NUMBER_MAX]; /* literal page */ + short npg[PAGEFIELD_MAX]; /* page field array */ + short count; /* page field count */ + short type; /* page number type */ + unsigned char *encap; /* encapsulator */ + char *fn; /* input filename */ + int lc; /* line number */ + }FIELD, *FIELD_PTR; + +typedef struct KNODE + { + FIELD data; + struct KNODE *next; + }NODE, *NODE_PTR; + +Global void Fatal(const char *fmt, ...); +Global void Message(const char *f, ...); +Global void usage(char *); + +Global Logical blank_ignore; +Global Logical compress_blanks; +Global Logical special_flag; +Global Logical init_page; +Global Logical merge_page; +Global int even_odd; +Global Logical verbose; + +Global unsigned char idx_keyword[ARRAY_MAX]; +Global char idx_aopen; +Global char idx_aclose; +Global char idx_level; +Global char idx_ropen; +Global char idx_rclose; +Global char idx_quote; +Global char idx_actual; +Global char idx_encap; +Global char idx_escape; + +Global char page_comp[ARRAY_MAX]; +Global int page_offset[PAGETYPE_MAX]; + +Global char preamble[ARRAY_MAX]; +Global char postamble[ARRAY_MAX]; +Global char setpage_open[ARRAY_MAX]; +Global char setpage_close[ARRAY_MAX]; +Global char group_skip[ARRAY_MAX]; +Global int headings_flag; +Global char heading_pre[ARRAY_MAX]; +Global char heading_suf[ARRAY_MAX]; +Global char symhead_pos[ARRAY_MAX]; +Global char symhead_neg[ARRAY_MAX]; +Global char numhead_pos[ARRAY_MAX]; +Global char numhead_neg[ARRAY_MAX]; +Global int prelen; +Global int postlen; +Global int skiplen; +Global int headprelen; +Global int headsuflen; +Global int setpagelen; + +Global char item_r[FIELD_MAX][ARRAY_MAX]; +Global char item_u[FIELD_MAX][ARRAY_MAX]; +Global char item_x[FIELD_MAX][ARRAY_MAX]; +Global int ilen_r[FIELD_MAX]; +Global int ilen_u[FIELD_MAX]; +Global int ilen_x[FIELD_MAX]; + +Global char delim_p[FIELD_MAX][ARRAY_MAX]; +Global char delim_n[ARRAY_MAX]; +Global char delim_r[ARRAY_MAX]; +Global char delim_t[ARRAY_MAX]; + +Global char suffix_2p[ARRAY_MAX]; +Global char suffix_3p[ARRAY_MAX]; +Global char suffix_mp[ARRAY_MAX]; + +Global char encap_p[ARRAY_MAX]; +Global char encap_i[ARRAY_MAX]; +Global char encap_s[ARRAY_MAX]; + +Global int linemax; +Global char indent_space[ARRAY_MAX]; +Global int indent_length; + +Global FILE *idx_fp; +Global FILE *sty_fp; +Global FILE *ind_fp; +Global FILE *ilg_fp; + +Global char *idx_fn; +Global char *pgm_fn; +Global char *ind_fn; +Global char *ilg_fn; + +#ifndef MKIND_C +Global char sty_fn[]; +Global char ind[]; +Global char ilg[]; +Global char pageno[]; + +#ifdef DEBUG +Global long totmem; +#endif /* DEBUG */ + +#endif + +Global FIELD_PTR *idx_key; +Global NODE_PTR head; +Global NODE_PTR tail; + +Global Logical idx_dot; +Global int idx_tt; +Global int idx_gt; +Global int idx_et; +Global int idx_dc; + +#define DOT "." +#define DOT_MAX 1000 +#define CMP_MAX 1500 + +#define VOIDP void* +#define VOID_ARG void + +Global void gen_ind (void); +Global int group_type (unsigned char *str); +Global int main(int argc, char **argv); +Global void qqsort (char *base, int n, int size, + int (*compar)(char*,char*)); +Global void scan_idx (void); +Global void scan_sty (void); +Global void sort_idx (void); +Global int strtoint (char *str); + +#if STDC +#include +#undef strchr +#undef strrchr +#if __NeXT__ +int access (const char *, int); +#else +#if OS_PCDOS +#else +#include +#endif +#endif +#else +/* Miscellaneous standard library routines */ +int access (const char *, int); +VOIDP calloc (size_t nitems,size_t size); + +char *getenv (const char *name); + +VOIDP malloc (size_t size); +#endif /* __STDC__ */ + +#if PCC_20 +#define R_OK 0 /* PCC-20 access(file,mode) */ +#endif /* only understands mode=0 */ + +#ifndef R_OK +#define R_OK 4 /* only symbol from sys/file.h */ +#endif + +typedef unsigned char char_u; + +typedef const char_u *p_char_u[]; + +typedef const char_u a_char_u[]; +typedef const int int_u[]; +typedef unsigned int word; + + +#include "language.h" diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/myctype.h b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/myctype.h new file mode 100644 index 0000000..42b24b5 --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/myctype.h @@ -0,0 +1,58 @@ +#undef strupr +#undef strlwr +#undef strnicmp +#undef strncasecmp +#undef stricmp +#undef strcasecmp +#undef isalnum +#undef isalpha +#undef isascii +#undef iscntrl +#undef isdigit +#undef isgraph +#undef islower +#undef isprint +#undef ispunct +#undef isspace +#undef isupper +#undef isxdigit +#undef tolower +#undef toupper +#undef toascii +#undef charcmp +#undef strchr +#undef strrchr + + +#ifdef __cplusplus +extern "C" { +#endif +unsigned char *mystrchr(unsigned char *s, unsigned char c); +unsigned char *mystrrchr(unsigned char *s, unsigned char c); +unsigned char * strupr(unsigned char *s); +unsigned char * strlwr(unsigned char *s); +int mystrncmp(const unsigned char *s, const unsigned char *d, size_t n); +int mystrcmp(const unsigned char *s, const unsigned char *d); +int strnicmp(const unsigned char *s, const unsigned char *d, size_t n); +int strncasecmp(const unsigned char *s, const unsigned char *d, size_t n); +int stricmp(const unsigned char *s, const unsigned char *d); +int strcasecmp(const unsigned char *s, const unsigned char *d); +int isalnum (unsigned char __c); +int isalpha (unsigned char __c); +int isascii (unsigned char __c); +int iscntrl (unsigned char __c); +int isdigit (unsigned char __c); +int isgraph (unsigned char __c); +int islower (unsigned char __c); +int isprint (unsigned char __c); +int ispunct (unsigned char __c); +int isspace (unsigned char __c); +int isupper (unsigned char __c); +int isxdigit(unsigned char __c); +unsigned char mytolower(unsigned char __ch); +unsigned char mytoupper(unsigned char __ch); +int toascii(unsigned char __ch); +int charcmp(unsigned char s, unsigned char d); +#ifdef __cplusplus +} +#endif diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/pl_1250.h b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/pl_1250.h new file mode 100644 index 0000000..9da65c4 --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/pl_1250.h @@ -0,0 +1,585 @@ +{% raw %} +static p_char_u pl_cp1250_day_name_ptr = + { + (char_u *)NULL, + (char_u *)"niedziela", + (char_u *)"poniedzia\0xB3ek", + (char_u *)"wtorek", + (char_u *)"\0x9Croda", + (char_u *)"czwartek", + (char_u *)"pi\0xB9tek", + (char_u *)"sobota", + }; + +static p_char_u pl_cp1250_day_name_ptr_a = + { + (char_u *)NULL, + (char_u *)"nd", + (char_u *)"pn", + (char_u *)"wt", + (char_u *)"\0x9Cr", + (char_u *)"cz", + (char_u *)"pt", + (char_u *)"sb", + }; + +static p_char_u pl_cp1250_mon_name_ptr = + { + (char_u *)NULL, + (char_u *)"stycze\0xF1", + (char_u *)"luty", + (char_u *)"marzec", + (char_u *)"kwiecie\0xF1", + (char_u *)"maj", + (char_u *)"czerwiec", + (char_u *)"lipiec", + (char_u *)"sierpie\0xF1", + (char_u *)"wrzesie\0xF1", + (char_u *)"pa\0x9Fdziernik", + (char_u *)"listopad", + (char_u *)"grudzie\0xF1" + }; + +static p_char_u pl_cp1250_mon_name_ptr_a = + { + (char_u *)NULL, + (char_u *)"stycze\0xF1", + (char_u *)"luty", + (char_u *)"marzec", + (char_u *)"kwiecie\0xF1", + (char_u *)"maj", + (char_u *)"czerwiec", + (char_u *)"lipiec", + (char_u *)"sierpie\0xF1", + (char_u *)"wrzesie\0xF1", + (char_u *)"pa\0x9Fdziernik", + (char_u *)"listopad", + (char_u *)"grudzie\0xF1" + }; + +static int_u pl_cp1250_toascii_table = + { + ' ', /* 128 0x80 */ + ' ', /* 129 0x81 */ + ' ', /* 130 0x82 */ + ' ', /* 131 0x83 */ + ' ', /* 132 0x84 */ + ' ', /* 133 0x85 */ + ' ', /* 134 0x86 */ + ' ', /* 135 0x87 */ + ' ', /* 136 0x88 */ + ' ', /* 137 0x89 */ + ' ', /* 138 0x8a */ + ' ', /* 139 0x8b */ + ' ', /* 140 0x8c */ + ' ', /* 141 0x8d */ + ' ', /* 142 0x8e */ + ' ', /* 143 0x8f */ + ' ', /* 144 0x90 */ + ' ', /* 145 0x91 */ + ' ', /* 146 0x92 */ + ' ', /* 147 0x93 */ + ' ', /* 148 0x94 */ + ' ', /* 149 0x95 */ + ' ', /* 150 0x96 */ + ' ', /* 151 0x97 */ + ' ', /* 152 0x98 */ + ' ', /* 153 0x99 */ + ' ', /* 154 0x9a */ + ' ', /* 155 0x9b */ + ' ', /* 156 0x9c */ + ' ', /* 157 0x9d */ + ' ', /* 158 0x9e */ + ' ', /* 159 0x9f */ + ' ', /* 160 0xa0 */ + ' ', /* 161 0xa1 */ + ' ', /* 162 0xa2 */ + ' ', /* 163 0xa3 */ + ' ', /* 164 0xa4 */ + ' ', /* 165 0xa5 */ + ' ', /* 166 0xa6 */ + ' ', /* 167 0xa7 */ + ' ', /* 168 0xa8 */ + ' ', /* 169 0xa9 */ + ' ', /* 170 0xaa */ + ' ', /* 171 0xab */ + ' ', /* 172 0xac */ + ' ', /* 173 0xad */ + ' ', /* 174 0xae */ + ' ', /* 175 0xaf */ + ' ', /* 176 0xb0 */ + ' ', /* 177 0xb1 */ + ' ', /* 178 0xb2 */ + ' ', /* 179 0xb3 */ + ' ', /* 180 0xb4 */ + ' ', /* 181 0xb5 */ + ' ', /* 182 0xb6 */ + ' ', /* 183 0xb7 */ + ',', /* 184 0xb8 */ + ' ', /* 185 0xb9 */ + ' ', /* 186 0xba */ + ' ', /* 187 0xbb */ + ' ', /* 188 0xbc */ + ' ', /* 189 0xbd */ + ' ', /* 190 0xbe */ + ' ', /* 191 0xbf */ + 'R', /* 192 0xc0 */ + 'A', /* 193 0xc1 */ + 'A', /* 194 0xc2 */ + 'A', /* 195 0xc3 */ + 'A', /* 196 0xc4 */ + 'L', /* 197 0xc5 */ + 'C', /* 198 0xc6 */ + 'C', /* 199 0xc7 */ + 'C', /* 200 0xc8 */ + 'E', /* 201 0xc9 */ + 'E', /* 202 0xca */ + 'E', /* 203 0xcb */ + 'E', /* 204 0xcc */ + 'I', /* 205 0xcd */ + 'I', /* 206 0xce */ + 'D', /* 207 0xcf */ + 'D', /* 208 0xd0 */ + 'N', /* 209 0xd1 */ + 'N', /* 210 0xd2 */ + 'O', /* 211 0xd3 */ + 'O', /* 212 0xd4 */ + 'O', /* 213 0xd5 */ + 'O', /* 214 0xd6 */ + 'x', /* 215 0xd7 */ + 'R', /* 216 0xd8 */ + 'U', /* 217 0xd9 */ + 'U', /* 218 0xda */ + 'U', /* 219 0xdb */ + 'U', /* 220 0xdc */ + 'Y', /* 221 0xdd */ + 'T', /* 222 0xde */ + ' ', /* 223 0xdf */ + 'r', /* 224 0xe0 */ + 'a', /* 225 0xe1 */ + 'a', /* 226 0xe2 */ + 'a', /* 227 0xe3 */ + 'a', /* 228 0xe4 */ + 'l', /* 229 0xe5 */ + 'c', /* 230 0xe6 */ + 'c', /* 231 0xe7 */ + 'c', /* 232 0xe8 */ + 'e', /* 233 0xe9 */ + 'e', /* 234 0xea */ + 'e', /* 235 0xeb */ + 'e', /* 236 0xec */ + 'i', /* 237 0xed */ + 'i', /* 238 0xee */ + 'd', /* 239 0xef */ + 'd', /* 240 0xf0 */ + 'n', /* 241 0xf1 */ + 'n', /* 242 0xf2 */ + 'o', /* 243 0xf3 */ + 'o', /* 244 0xf4 */ + 'o', /* 245 0xf5 */ + 'o', /* 246 0xf6 */ + ' ', /* 247 0xf7 */ + 'r', /* 248 0xf8 */ + 'u', /* 249 0xf9 */ + 'u', /* 250 0xfa */ + 'u', /* 251 0xfb */ + 'u', /* 252 0xfc */ + 'y', /* 253 0xfd */ + 't', /* 254 0xfe */ + ' ' /* 255 0xff */ + }; + +static a_char_u pl_cp1250_lower_table = + { + 'a', 'b', 'c', 'd', 'e', 'f', 'g', + 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', + 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', + 'x', 'y', 'z', '[', '\\', ']', '^', '_', + + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', '\0x9C', ' ', ' ', '\0x9F', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + + ' ', ' ', ' ', '\0xB3', ' ', '\0xB9', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', '\0xBF', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + + ' ', ' ', ' ', ' ', ' ', ' ', '\0xE6', ' ', + ' ', ' ', '\0xEA', ' ', ' ', ' ', ' ', ' ', + ' ', '\0xF1', ' ', '\0xF3', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' + }; + +static a_char_u pl_cp1250_upper_table = + { + 'A','B','C','D','E','F','G', + 'H','I','J','K','L','M','N','O', + + 'P','Q','R','S','T','U','V','W', + 'X','Y','Z','{','|','}','~',' ', + + ' ',' ',' ',' ',' ',' ',' ',' ', + ' ',' ',' ',' ',' ',' ',' ',' ', + ' ',' ',' ',' ',' ',' ',' ',' ', + ' ',' ',' ',' ','\0x8C',' ',' ','\0x8F', + + ' ',' ',' ',' ',' ',' ',' ',' ', + ' ',' ',' ',' ',' ',' ',' ',' ', + ' ',' ',' ','\0xA3',' ',' ',' ',' ', + ' ','\0xA5',' ',' ',' ',' ',' ','\0xAF', + + ' ',' ',' ',' ',' ',' ',' ',' ', + ' ',' ',' ',' ',' ',' ',' ',' ', + ' ',' ',' ',' ',' ',' ',' ',' ', + ' ',' ',' ',' ',' ',' ',' ',' ', + + ' ',' ',' ',' ',' ',' ','\0xC6',' ', + ' ',' ','\0xCA',' ',' ',' ',' ',' ', + ' ','\0xD1',' ','\0xD3',' ',' ',' ',' ', + }; + +static a_char_u pl_cp1250_char_type = + { +IS_CTR, IS_CTR, IS_CTR, IS_CTR, +IS_CTR, IS_CTR, IS_CTR, IS_CTR, +IS_CTR, IS_CTR | IS_BLANK, IS_CTR | IS_BLANK, IS_CTR | IS_BLANK, +IS_CTR | IS_BLANK, IS_CTR | IS_BLANK, IS_CTR, IS_CTR, +IS_CTR, IS_CTR, IS_CTR, IS_CTR, +IS_CTR, IS_CTR, IS_CTR, IS_CTR, +IS_CTR, IS_CTR, IS_CTR, IS_CTR, +IS_CTR, IS_CTR, IS_CTR, IS_CTR, +IS_BLANK, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +IS_XDIG | IS_DIG, IS_XDIG | IS_DIG, IS_XDIG | IS_DIG, IS_XDIG | IS_DIG, +IS_XDIG | IS_DIG, IS_XDIG | IS_DIG, IS_XDIG | IS_DIG, IS_XDIG | IS_DIG, +IS_XDIG | IS_DIG, IS_XDIG | IS_DIG, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, + +0x000, IS_XDIG | IS_UPPER,IS_XDIG | IS_UPPER,IS_XDIG | IS_UPPER, +IS_XDIG | IS_UPPER,IS_XDIG | IS_UPPER,IS_XDIG | IS_UPPER,IS_UPPER, +IS_UPPER, IS_UPPER, IS_UPPER, IS_UPPER, +IS_UPPER, IS_UPPER, IS_UPPER, IS_UPPER, +IS_UPPER, IS_UPPER, IS_UPPER, IS_UPPER, +IS_UPPER, IS_UPPER, IS_UPPER, IS_UPPER, +IS_UPPER, IS_UPPER, IS_UPPER, 0x000, +0x000, 0x000, 0x000, IS_ALPH, + +0x000, IS_XDIG | IS_LOWER,IS_XDIG | IS_LOWER,IS_XDIG | IS_LOWER, +IS_XDIG | IS_LOWER,IS_XDIG | IS_LOWER,IS_XDIG | IS_LOWER,IS_LOWER, +IS_LOWER, IS_LOWER, IS_LOWER, IS_LOWER, +IS_LOWER, IS_LOWER, IS_LOWER, IS_LOWER, +IS_LOWER, IS_LOWER, IS_LOWER, IS_LOWER, +IS_LOWER, IS_LOWER, IS_LOWER, IS_LOWER, +IS_LOWER, IS_LOWER, IS_LOWER, 0x000, +0x000, 0x000, 0x000, IS_CTR, +/*----------------------------*/ +/*\0xB9\0xE6\0xEA\0xB3\0xF1\0xF3\0x9C\0x9F\0xBF \0xA5\0xC6\0xCA\0xA3\0xD1\0xD3\0x8C\0x8F\0xAF */ +0x000, 0x000, 0x000, 0x000, /*128*/ +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +IS_UPPER, 0x000, 0x000, IS_UPPER, /* \0x8C..\0x8F */ + +0x000, 0x000, 0x000, 0x000, /*144 */ +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +IS_LOWER, 0x000, 0x000, IS_LOWER, /* \0x9C..\0x9F */ + +0x000, 0x000, 0x000, IS_UPPER, /*...\0xA3*/ +0x000, IS_UPPER, 0x000, 0x000, /*.\0xA5.. */ +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, IS_UPPER, /*...\0xAF*/ + +0x000, 0x000, 0x000, IS_LOWER, /*...\0xB3*/ +0x000, 0x000, 0x000, 0x000, +0x000, IS_LOWER, 0x000, 0x000, /*.\0xB9..*/ +0x000, 0x000, 0x000, IS_LOWER, /*...\0xBF*/ + +0x000, 0x000, 0x000, 0x000, /*.......\0xC6.*/ +0x000, 0x000, IS_UPPER, 0x000, +0x000, 0x000, IS_UPPER, 0x000, /*..\0xCA....*/ +0x000, 0x000, 0x000, 0x000, +0x000, IS_UPPER, 0x000, IS_UPPER, /*.\0xD1.\0xD3....*/ +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, + +0x000, 0x000, 0x000, 0x000, /*......\0xE6.*/ +0x000, 0x000, IS_LOWER, 0x000, +0x000, 0x000, IS_LOWER, 0x000, /*..\0xEA.....*/ +0x000, 0x000, 0x000, 0x000, + +0x000, IS_LOWER, 0x000, IS_LOWER, /*.\0xF1.\0xF3....*/ +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000 + }; + +static int_u pl_cp1250_order_tbl = + { +0, /* 0 */ +'', /* 1 */ +'', /* 2 */ +'', /* 3 */ +'', /* 4 */ +'', /* 5 */ +'', /* 6 */ +'', /* 7 */ +'', /* 8 */ +TAB, /* 9 */ + LF, /* 10 0a */ +' ', /* 11 0b */ +' ', /* 12 0c */ + CR, /* 13 0d */ +'', /* 14 0e */ +'', /* 15 0f */ +'', /* 16 10 */ +'', /* 17 11 */ +'', /* 18 12 */ +'', /* 19 13 */ +'', /* 20 14 */ +'', /* 21 15 */ +'', /* 22 16 */ +'', /* 23 17 */ +'', /* 24 18 */ +'', /* 25 19 */ +0x1a, /* 26 1a */ +'', /* 27 1b */ +'', /* 28 1c */ +'', /* 29 1d */ +'', /* 30 1e */ +'', /* 31 1f */ +' ', /* 32 20 */ +'!', /* 33 21 */ +0x22, /* 34 22 quote */ +'#', /* 35 23 */ +'$', /* 36 24 */ +'%', /* 37 25 */ +'&', /* 38 26 */ +0x27, /* 39 27 single quote */ +'(', /* 40 28 */ +')', /* 41 29 */ +'*', /* 42 2a */ +'+', /* 43 2b */ +',', /* 44 2c */ +'-', /* 45 2d */ +'.', /* 46 2e */ +'/', /* 47 2f */ +'0', /* 48 30 */ +'1', /* 49 31 */ +'2', /* 50 32 */ +'3', /* 51 33 */ +'4', /* 52 34 */ +'5', /* 53 35 */ +'6', /* 54 36 */ +'7', /* 55 37 */ +'8', /* 56 38 */ +'9', /* 57 39 */ +':', /* 58 3a */ +';', /* 59 3b */ +'<', /* 60 3c */ +'=', /* 61 3d */ +'>', /* 62 3e */ +'?', /* 63 3f */ +'@', /* 64 40 */ +'a' * CCCC + 4, /* 'A', 65 41 */ +'b' * CCCC + 4, /* 'B', 66 42 */ +'c' * CCCC + 4, /* 'C', 67 43 */ +'d' * CCCC + 4, /* 'D', 68 44 */ +'e' * CCCC + 4, /* 'E', 69 45 */ +'f' * CCCC + 4, /* 'F', 70 46 */ +'g' * CCCC + 4, /* 'G', 71 47 */ +'h' * CCCC + 4, /* 'H', 72 48 */ +'i' * CCCC + 4, /* 'I', 73 49 */ +'j' * CCCC + 4, /* 'J', 74 4a */ +'k' * CCCC + 4, /* 'K', 75 4b */ +'l' * CCCC + 4, /* 'L', 76 4c */ +'m' * CCCC + 4, /* 'M', 77 4d */ +'n' * CCCC + 4, /* 'N', 78 4e */ +'o' * CCCC + 4, /* 'O', 79 4f */ +'p' * CCCC + 4, /* 'P', 80 50 */ +'q' * CCCC + 4, /* 'Q', 81 51 */ +'r' * CCCC + 4, /* 'R', 82 52 */ +'s' * CCCC + 4, /* 'S', 83 53 */ +'t' * CCCC + 4, /* 'T', 84 54 */ +'u' * CCCC + 4, /* 'U', 85 55 */ +'v' * CCCC + 4, /* 'V', 86 56 */ +'w' * CCCC + 4, /* 'W', 87 57 */ +'x' * CCCC + 4, /* 'X', 88 58 */ +'y' * CCCC + 4, /* 'Y', 89 59 */ +'z' * CCCC + 4, /* 'Z', 90 5a */ +0x5b, /* 91 5b */ +0x5c, /* 92 5c */ +0x5d, /* 93 5d ] */ +0x5e, /* 94 5e */ +'_', /* 95 5f */ +0x60, /* 96 60 ` */ +'a' * CCCC, /* 97 61 */ +'b' * CCCC, /* 98 62 */ +'c' * CCCC, /* 99 63 */ +'d' * CCCC, /* 100 64 */ +'e' * CCCC, /* 101 65 */ +'f' * CCCC, /* 102 66 */ +'g' * CCCC, /* 103 67 */ +'h' * CCCC, /* 104 68 */ +'i' * CCCC, /* 105 69 */ +'j' * CCCC, /* 106 6a */ +'k' * CCCC, /* 107 6b */ +'l' * CCCC, /* 108 6c */ +'m' * CCCC, /* 109 6d */ +'n' * CCCC, /* 110 6e */ +'o' * CCCC, /* 111 6f */ +'p' * CCCC, /* 112 70 */ +'q' * CCCC, /* 113 71 */ +'r' * CCCC, /* 114 72 */ +'s' * CCCC, /* 115 73 */ +'t' * CCCC, /* 116 74 */ +'u' * CCCC, /* 117 75 */ +'v' * CCCC, /* 118 76 */ +'w' * CCCC, /* 119 77 */ +'x' * CCCC, /* 120 78 */ +'y' * CCCC, /* 121 79 */ +'z' * CCCC, /* 122 7a */ +'{', /* 123 7b */ +'|', /* 124 7c */ +'}', /* 125 7d */ +'~', /* 126 7e */ + 127, /* 127 7f */ + 128, /* 128 80 */ + 129, /* 129 81 */ + 130, /* 130 82 */ + 131, /* 131 83 */ + 132, /* 132 84 */ + 133, /* 133 85 */ + 134, /* 134 86 */ + 135, /* 135 87 */ + 136, /* 136 88 */ + 137, /* 137 89 */ + 138, /* 138 8a */ + 139, /* 139 8b */ + 's' * CCCC + 1, /* 140 8c */ + 141, /* 141 8d */ + 142, /* 142 8e */ + 'z' * CCCC + 1, /* 143 8f */ + 144, /* 144 90 */ + 145, /* 145 91 */ + 146, /* 146 92 */ + 147, /* 147 93 */ + 148, /* 148 94 */ + 149, /* 149 95 */ + 150, /* 150 96 */ + 151, /* 151 97 */ + 152, /* 152 98 */ + 153, /* 153 99 */ + 154, /* 154 9a */ + 155, /* 155 9b */ + 's' * CCCC + 5, /* 156 9c */ + 157, /* 157 9d */ + 158, /* 158 9e */ + 'z' * CCCC + 5, /* 159 9f */ + 160, /* 160 a0 */ + 161, /* 161 a1 */ + 162, /* 162 a2 */ + 'l' * CCCC + 1, /* 163 a3 */ + 164, /* 164 a4 */ + 'a' * CCCC + 1, /* 165 a5 */ + 166, /* 166 a6 */ + 167, /* 167 a7 */ + 168, /* 168 a8 */ + 169, /* 169 a9 */ + 170, /* 170 aa */ + 171, /* 171 ab */ + 172, /* 172 ac */ + 173, /* 173 ad */ + 174, /* 174 ae */ + 'z' * CCCC + 2, /* 175 af */ + 176, /* 176 b0 */ + 177, /* 177 b1 */ + 178, /* 178 b2 */ + 'l' * CCCC + 5, /* 179 b3 */ + 180, /* 180 b4 */ + 181, /* 181 b5 */ + 182, /* 182 b6 */ + 183, /* 183 b7 */ + 184, /* 184 b8 */ + 'a' * CCCC + 5, /* 185 b9 */ + 186, /* 186 ba */ + 187, /* 187 bb */ + 188, /* 188 bc */ + 189, /* 189 bd */ + 190, /* 190 be */ + 'z' * CCCC + 6, /* 191 bf */ + 192, /* 192 c0 */ + 193, /* 193 c1 */ + 194, /* 194 c2 */ + 195, /* 195 c3 */ + 196, /* 196 c4 */ + 197, /* 197 c5 */ + 'c' * CCCC + 1, /* 198 c6 */ + 199, /* 199 c7 */ + 200, /* 200 c8 */ + 201, /* 201 c9 */ + 'e' * CCCC + 1, /* 202 ca */ + 203, /* 203 cb */ + 204, /* 204 cc */ + 205, /* 205 cd */ + 206, /* 206 ce */ + 207, /* 207 cf */ + 208, /* 208 d0 */ + 'n' * CCCC + 1, /* 209 d1 */ + 210, /* 210 d2 */ + 'o' * CCCC + 1, /* 211 d3 */ + 212, /* 212 d4 */ + 213, /* 213 d5 */ + 214, /* 214 d6 */ + 215, /* 215 d7 */ + 216, /* 216 d8 */ + 217, /* 217 d9 */ + 218, /* 218 da */ + 219, /* 219 db */ + 220, /* 220 dc */ + 221, /* 221 dd */ + 222, /* 222 de */ + 223, /* 223 df */ + 224, /* 224 e0 */ + 225, /* 225 e1 */ + 226, /* 226 e2 */ + 227, /* 227 e3 */ + 228, /* 228 e4 */ + 229, /* 229 e5 */ + 'c' * CCCC + 5, /* 230 e6 */ + 231, /* 231 e7 */ + 232, /* 232 e8 */ + 233, /* 233 e9 */ + 'e' * CCCC + 5, /* 234 ea */ + 235, /* 235 eb */ + 236, /* 236 ec */ + 237, /* 237 ed */ + 238, /* 238 ee */ + 239, /* 239 ef */ + 240, /* 240 f0 */ + 'n' * CCCC + 5, /* 241 f1 */ + 242, /* 242 f2 */ + 'o' * CCCC + 5, /* 243 f3 */ + 244, /* 244 f4 */ + 245, /* 245 f5 */ + 246, /* 246 f6 */ + 247, /* 247 f7 */ + 248, /* 248 f8 */ + 249, /* 249 f9 */ + 250, /* 250 fa */ + 251, /* 251 fb */ + 252, /* 252 fc */ + 253, /* 253 fd */ + 254, /* 254 fe */ + 255 /* 255 ff */ + }; +{% endraw %} diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/pl_852.h b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/pl_852.h new file mode 100644 index 0000000..7e858e8 --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/pl_852.h @@ -0,0 +1,589 @@ +{% raw %} +static p_char_u pl_cp852_day_name_ptr = + { + (char_u *)NULL, + (char_u *)"niedziela", + (char_u *)"poniedzia\0x88ek", + (char_u *)"wtorek", + (char_u *)"\0x98roda", + (char_u *)"czwartek", + (char_u *)"pi\0xA5tek", + (char_u *)"sobota", + }; + +static p_char_u pl_cp852_day_name_ptr_a = + { + (char_u *)NULL, + (char_u *)"nd", + (char_u *)"pn", + (char_u *)"wt", + (char_u *)"\0x98r", + (char_u *)"cz", + (char_u *)"pt", + (char_u *)"sb", + }; + +static p_char_u pl_cp852_mon_name_ptr = + { + (char_u *)NULL, + (char_u *)"stycze\0xE4", + (char_u *)"luty", + (char_u *)"marzec", + (char_u *)"kwiecie\0xE4", + (char_u *)"maj", + (char_u *)"czerwiec", + (char_u *)"lipiec", + (char_u *)"sierpie\0xE4", + (char_u *)"wrzesie\0xE4", + (char_u *)"pa\0xABdziernik", + (char_u *)"listopad", + (char_u *)"grudzie\0xE4" + }; + +static p_char_u pl_cp852_mon_name_ptr_a = + { + (char_u *)NULL, + (char_u *)"stycze\0xE4", + (char_u *)"luty", + (char_u *)"marzec", + (char_u *)"kwiecie\0xE4", + (char_u *)"maj", + (char_u *)"czerwiec", + (char_u *)"lipiec", + (char_u *)"sierpie\0xE4", + (char_u *)"wrzesie\0xE4", + (char_u *)"pa\0xABdziernik", + (char_u *)"listopad", + (char_u *)"grudzie\0xE4" + }; + +static int_u pl_cp852_toascii_table = + { + ' ', /* 128 0x80 */ + ' ', /* 129 0x81 */ + ' ', /* 130 0x82 */ + ' ', /* 131 0x83 */ + ' ', /* 132 0x84 */ + ' ', /* 133 0x85 */ + 'c', /* 134 0x86 */ + ' ', /* 135 0x87 */ + 'l', /* 136 0x88 */ + ' ', /* 137 0x89 */ + ' ', /* 138 0x8a */ + ' ', /* 139 0x8b */ + ' ', /* 140 0x8c */ + 'Z', /* 141 0x8d */ + ' ', /* 142 0x8e */ + 'C', /* 143 0x8f */ + ' ', /* 144 0x90 */ + ' ', /* 145 0x91 */ + ' ', /* 146 0x92 */ + ' ', /* 147 0x93 */ + ' ', /* 148 0x94 */ + ' ', /* 149 0x95 */ + ' ', /* 150 0x96 */ + 'S', /* 151 0x97 */ + 's', /* 152 0x98 */ + ' ', /* 153 0x99 */ + ' ', /* 154 0x9a */ + ' ', /* 155 0x9b */ + ' ', /* 156 0x9c */ + 'L', /* 157 0x9d */ + ' ', /* 158 0x9e */ + ' ', /* 159 0x9f */ + ' ', /* 160 0xa0 */ + ' ', /* 161 0xa1 */ + 'o', /* 162 0xa2 */ + ' ', /* 163 0xa3 */ + 'A', /* 164 0xa4 */ + 'a', /* 165 0xa5 */ + ' ', /* 166 0xa6 */ + ' ', /* 167 0xa7 */ + 'E', /* 168 0xa8 */ + 'e', /* 169 0xa9 */ + ' ', /* 170 0xaa */ + 'z', /* 171 0xab */ + ' ', /* 172 0xac */ + ' ', /* 173 0xad */ + ' ', /* 174 0xae */ + ' ', /* 175 0xaf */ + ' ', /* 176 0xb0 */ + ' ', /* 177 0xb1 */ + ' ', /* 178 0xb2 */ + ' ', /* 179 0xb3 */ + ' ', /* 180 0xb4 */ + ' ', /* 181 0xb5 */ + ' ', /* 182 0xb6 */ + ' ', /* 183 0xb7 */ + ',', /* 184 0xb8 */ + ' ', /* 185 0xb9 */ + ' ', /* 186 0xba */ + ' ', /* 187 0xbb */ + ' ', /* 188 0xbc */ + 'Z', /* 189 0xbd */ + 'z', /* 190 0xbe */ + ' ', /* 191 0xbf */ + 'R', /* 192 0xc0 */ + 'A', /* 193 0xc1 */ + 'A', /* 194 0xc2 */ + 'A', /* 195 0xc3 */ + 'A', /* 196 0xc4 */ + 'L', /* 197 0xc5 */ + 'C', /* 198 0xc6 */ + 'C', /* 199 0xc7 */ + 'C', /* 200 0xc8 */ + 'E', /* 201 0xc9 */ + 'E', /* 202 0xca */ + 'E', /* 203 0xcb */ + 'E', /* 204 0xcc */ + 'I', /* 205 0xcd */ + 'I', /* 206 0xce */ + 'D', /* 207 0xcf */ + 'D', /* 208 0xd0 */ + 'N', /* 209 0xd1 */ + 'N', /* 210 0xd2 */ + 'O', /* 211 0xd3 */ + 'O', /* 212 0xd4 */ + 'O', /* 213 0xd5 */ + 'O', /* 214 0xd6 */ + 'x', /* 215 0xd7 */ + 'R', /* 216 0xd8 */ + 'U', /* 217 0xd9 */ + 'U', /* 218 0xda */ + 'U', /* 219 0xdb */ + 'U', /* 220 0xdc */ + 'Y', /* 221 0xdd */ + 'T', /* 222 0xde */ + ' ', /* 223 0xdf */ + 'O', /* 224 0xe0 */ + 'a', /* 225 0xe1 */ + 'a', /* 226 0xe2 */ + 'N', /* 227 0xe3 */ + 'n', /* 228 0xe4 */ + 'l', /* 229 0xe5 */ + 'c', /* 230 0xe6 */ + 'c', /* 231 0xe7 */ + 'c', /* 232 0xe8 */ + 'e', /* 233 0xe9 */ + 'e', /* 234 0xea */ + 'e', /* 235 0xeb */ + 'e', /* 236 0xec */ + 'i', /* 237 0xed */ + 'i', /* 238 0xee */ + 'd', /* 239 0xef */ + 'd', /* 240 0xf0 */ + 'n', /* 241 0xf1 */ + 'n', /* 242 0xf2 */ + 'o', /* 243 0xf3 */ + 'o', /* 244 0xf4 */ + 'o', /* 245 0xf5 */ + 'o', /* 246 0xf6 */ + ' ', /* 247 0xf7 */ + 'r', /* 248 0xf8 */ + 'u', /* 249 0xf9 */ + 'u', /* 250 0xfa */ + 'u', /* 251 0xfb */ + 'u', /* 252 0xfc */ + 'y', /* 253 0xfd */ + 't', /* 254 0xfe */ + ' ' /* 255 0xff */ + }; + +static a_char_u pl_cp852_lower_table = + { + 'a', 'b', 'c', 'd', 'e', 'f', 'g', /*40*/ + 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', + 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', /*50*/ + 'x', 'y', 'z', '[', '\\', ']', '^', '_', + + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', /*60 */ + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', /*70*/ + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', /*80*/ + ' ', ' ', ' ', ' ', ' ', '\0xAB', ' ', '\0x86', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', '\0x98', /*90*/ + ' ', ' ', ' ', ' ', ' ', '\0x88', ' ', ' ', + + ' ', ' ', ' ', ' ', '\0xA5', ' ', ' ', ' ', /*a0*/ + '\0xA9', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', /*b0*/ + ' ', ' ', ' ', ' ', ' ', '\0xBE', ' ', ' ', + + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', /*c0*/ + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', /*d0*/ + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' , + + '\0xA2', ' ', ' ', '\0xE4', ' ', ' ', ' ', ' ' /*e0*/ + }; + +static a_char_u pl_cp852_upper_table = + { + 'A','B','C','D','E','F','G', /*60*/ + 'H','I','J','K','L','M','N','O', + + 'P','Q','R','S','T','U','V','W', /*70*/ + 'X','Y','Z','{','|','}','~',' ', + + ' ',' ',' ',' ',' ',' ','\0x8F',' ', /*80*/ + '\0x9D',' ',' ',' ',' ',' ',' ',' ', + + ' ',' ',' ',' ',' ',' ',' ',' ', /*90*/ + '\0x97',' ',' ',' ',' ',' ',' ',' ', + + ' ',' ','\0xE0',' ',' ','\0xA4',' ',' ',/*a0*/ + ' ','\0xA8',' ','\0x8D',' ',' ',' ',' ', + + ' ',' ',' ',' ',' ',' ',' ',' ',/*b0*/ + ' ',' ',' ',' ',' ',' ','\0xBD',' ', + + ' ',' ',' ',' ',' ',' ',' ',' ',/*c0*/ + ' ',' ',' ',' ',' ',' ',' ',' ', + + ' ',' ',' ',' ',' ',' ',' ',' ',/*d0*/ + ' ',' ',' ',' ',' ',' ',' ',' ', + + ' ',' ',' ',' ','\0xE3',' ',' ',' '/*e0*/ + }; + +static a_char_u pl_cp852_char_type = + { +IS_CTR, IS_CTR, IS_CTR, IS_CTR, +IS_CTR, IS_CTR, IS_CTR, IS_CTR, +IS_CTR, IS_CTR | IS_BLANK, IS_CTR | IS_BLANK, IS_CTR | IS_BLANK, +IS_CTR | IS_BLANK, IS_CTR | IS_BLANK, IS_CTR, IS_CTR, +IS_CTR, IS_CTR, IS_CTR, IS_CTR, +IS_CTR, IS_CTR, IS_CTR, IS_CTR, +IS_CTR, IS_CTR, IS_CTR, IS_CTR, +IS_CTR, IS_CTR, IS_CTR, IS_CTR, +IS_BLANK, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +IS_XDIG | IS_DIG, IS_XDIG | IS_DIG, IS_XDIG | IS_DIG, IS_XDIG | IS_DIG, +IS_XDIG | IS_DIG, IS_XDIG | IS_DIG, IS_XDIG | IS_DIG, IS_XDIG | IS_DIG, +IS_XDIG | IS_DIG, IS_XDIG | IS_DIG, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, + +0x000, IS_XDIG | IS_UPPER,IS_XDIG | IS_UPPER,IS_XDIG | IS_UPPER, +IS_XDIG | IS_UPPER,IS_XDIG | IS_UPPER,IS_XDIG | IS_UPPER,IS_UPPER, +IS_UPPER, IS_UPPER, IS_UPPER, IS_UPPER, +IS_UPPER, IS_UPPER, IS_UPPER, IS_UPPER, +IS_UPPER, IS_UPPER, IS_UPPER, IS_UPPER, +IS_UPPER, IS_UPPER, IS_UPPER, IS_UPPER, +IS_UPPER, IS_UPPER, IS_UPPER, 0x000, +0x000, 0x000, 0x000, IS_ALPH, + +0x000, IS_XDIG | IS_LOWER,IS_XDIG | IS_LOWER,IS_XDIG | IS_LOWER, +IS_XDIG | IS_LOWER,IS_XDIG | IS_LOWER,IS_XDIG | IS_LOWER,IS_LOWER, +IS_LOWER, IS_LOWER, IS_LOWER, IS_LOWER, +IS_LOWER, IS_LOWER, IS_LOWER, IS_LOWER, +IS_LOWER, IS_LOWER, IS_LOWER, IS_LOWER, +IS_LOWER, IS_LOWER, IS_LOWER, IS_LOWER, +IS_LOWER, IS_LOWER, IS_LOWER, 0x000, +0x000, 0x000, 0x000, IS_CTR, +/*----------------------------*/ +/*\0xA5\0x86\0xA9\0x88\0xE4\0xA2\0x98\0xAB\0xBE \0xA4\0x8F\0xA8\0x9D\0xE3\0xE0\0x97\0x8D\0xBD */ +0x000, 0x000, 0x000, 0x000, /*128 80*/ +0x000, 0x000, IS_LOWER, 0x000, +IS_LOWER, 0x000, 0x000, 0x000, +0x000, IS_UPPER, 0x000, IS_UPPER, + +0x000, 0x000, 0x000, 0x000, /*144 90*/ +0x000, 0x000, 0x000, IS_UPPER, +IS_LOWER, 0x000, 0x000, 0x000, +0x000, IS_UPPER, 0x000, 0x000, + +0x000, 0x000, IS_LOWER, 0x000, /*160 a0*/ +IS_UPPER, IS_LOWER, 0x000, 0x000, +IS_UPPER, IS_LOWER, 0x000, IS_LOWER, +0x000, 0x000, 0x000, 0x000, + +0x000, 0x000, 0x000, 0x000, /*176 b0*/ +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, IS_UPPER, IS_LOWER, 0x000, + +0x000, 0x000, 0x000, 0x000,/*192 c0*/ +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, + +0x000, 0x000, 0x000, 0x000,/*208 d0*/ +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, + +IS_UPPER, 0x000, 0x000, IS_UPPER, /*224 e0*/ +IS_LOWER, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, + +0x000, 0x000, 0x000, 0x000, /*240 f0*/ +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000 + }; + +static int_u pl_cp852_order_tbl = + { +0, /* 0 */ +'', /* 1 */ +'', /* 2 */ +'', /* 3 */ +'', /* 4 */ +'', /* 5 */ +'', /* 6 */ +'', /* 7 */ +'', /* 8 */ +TAB, /* 9 */ + LF, /* 10 0a */ +' ', /* 11 0b */ +' ', /* 12 0c */ + CR, /* 13 0d */ +'', /* 14 0e */ +'', /* 15 0f */ +'', /* 16 10 */ +'', /* 17 11 */ +'', /* 18 12 */ +'', /* 19 13 */ +'', /* 20 14 */ +'', /* 21 15 */ +'', /* 22 16 */ +'', /* 23 17 */ +'', /* 24 18 */ +'', /* 25 19 */ +0x1a, /* 26 1a */ +'', /* 27 1b */ +'', /* 28 1c */ +'', /* 29 1d */ +'', /* 30 1e */ +'', /* 31 1f */ +' ', /* 32 20 */ +'!', /* 33 21 */ +0x22, /* 34 22 quote */ +'#', /* 35 23 */ +'$', /* 36 24 */ +'%', /* 37 25 */ +'&', /* 38 26 */ +0x27, /* 39 27 single quote */ +'(', /* 40 28 */ +')', /* 41 29 */ +'*', /* 42 2a */ +'+', /* 43 2b */ +',', /* 44 2c */ +'-', /* 45 2d */ +'.', /* 46 2e */ +'/', /* 47 2f */ +'0', /* 48 30 */ +'1', /* 49 31 */ +'2', /* 50 32 */ +'3', /* 51 33 */ +'4', /* 52 34 */ +'5', /* 53 35 */ +'6', /* 54 36 */ +'7', /* 55 37 */ +'8', /* 56 38 */ +'9', /* 57 39 */ +':', /* 58 3a */ +';', /* 59 3b */ +'<', /* 60 3c */ +'=', /* 61 3d */ +'>', /* 62 3e */ +'?', /* 63 3f */ +'@', /* 64 40 */ +'a' * CCCC + 4, /* 'A', 65 41 */ +'b' * CCCC + 4, /* 'B', 66 42 */ +'c' * CCCC + 4, /* 'C', 67 43 */ +'d' * CCCC + 4, /* 'D', 68 44 */ +'e' * CCCC + 4, /* 'E', 69 45 */ +'f' * CCCC + 4, /* 'F', 70 46 */ +'g' * CCCC + 4, /* 'G', 71 47 */ +'h' * CCCC + 4, /* 'H', 72 48 */ +'i' * CCCC + 4, /* 'I', 73 49 */ +'j' * CCCC + 4, /* 'J', 74 4a */ +'k' * CCCC + 4, /* 'K', 75 4b */ +'l' * CCCC + 4, /* 'L', 76 4c */ +'m' * CCCC + 4, /* 'M', 77 4d */ +'n' * CCCC + 4, /* 'N', 78 4e */ +'o' * CCCC + 4, /* 'O', 79 4f */ +'p' * CCCC + 4, /* 'P', 80 50 */ +'q' * CCCC + 4, /* 'Q', 81 51 */ +'r' * CCCC + 4, /* 'R', 82 52 */ +'s' * CCCC + 4, /* 'S', 83 53 */ +'t' * CCCC + 4, /* 'T', 84 54 */ +'u' * CCCC + 4, /* 'U', 85 55 */ +'v' * CCCC + 4, /* 'V', 86 56 */ +'w' * CCCC + 4, /* 'W', 87 57 */ +'x' * CCCC + 4, /* 'X', 88 58 */ +'y' * CCCC + 4, /* 'Y', 89 59 */ +'z' * CCCC + 4, /* 'Z', 90 5a */ +0x5b, /* 91 5b */ +0x5c, /* 92 5c */ +0x5d, /* 93 5d ] */ +0x5e, /* 94 5e */ +'_', /* 95 5f */ +0x60, /* 96 60 ` */ +'a' * CCCC, /* 97 61 */ +'b' * CCCC, /* 98 62 */ +'c' * CCCC, /* 99 63 */ +'d' * CCCC, /* 100 64 */ +'e' * CCCC, /* 101 65 */ +'f' * CCCC, /* 102 66 */ +'g' * CCCC, /* 103 67 */ +'h' * CCCC, /* 104 68 */ +'i' * CCCC, /* 105 69 */ +'j' * CCCC, /* 106 6a */ +'k' * CCCC, /* 107 6b */ +'l' * CCCC, /* 108 6c */ +'m' * CCCC, /* 109 6d */ +'n' * CCCC, /* 110 6e */ +'o' * CCCC, /* 111 6f */ +'p' * CCCC, /* 112 70 */ +'q' * CCCC, /* 113 71 */ +'r' * CCCC, /* 114 72 */ +'s' * CCCC, /* 115 73 */ +'t' * CCCC, /* 116 74 */ +'u' * CCCC, /* 117 75 */ +'v' * CCCC, /* 118 76 */ +'w' * CCCC, /* 119 77 */ +'x' * CCCC, /* 120 78 */ +'y' * CCCC, /* 121 79 */ +'z' * CCCC, /* 122 7a */ +'{', /* 123 7b */ +'|', /* 124 7c */ +'}', /* 125 7d */ +'~', /* 126 7e */ + 127, /* 127 7f */ + 128, /* 128 80 */ + 129, /* 129 81 */ + 130, /* 130 82 */ + 131, /* 131 83 */ + 132, /* 132 84 */ + 133, /* 133 85 */ + 'c' * CCCC + 5, /* 134 86 */ + 135, /* 135 87 */ + 'l' * CCCC + 5, /* 136 88 */ + 137, /* 137 89 */ + 138, /* 138 8a */ + 139, /* 139 8b */ + 140, /* 140 8c */ + 'z' * CCCC + 1, /* 141 8d */ + 142, /* 142 8e */ + 'c' * CCCC + 1, /* 143 8f */ + 144, /* 144 90 */ + 145, /* 145 91 */ + 146, /* 146 92 */ + 147, /* 147 93 */ + 148, /* 148 94 */ + 149, /* 149 95 */ + 150, /* 150 96 */ + 's' * CCCC + 1, /* 151 97 */ + 's' * CCCC + 5, /* 152 98 */ + 153, /* 153 99 */ + 154, /* 154 9a */ + 155, /* 155 9b */ + 156, /* 156 9c */ + 'l' * CCCC + 1, /* 157 9d */ + 158, /* 158 9e */ + 159, /* 159 9f */ + 160, /* 160 a0 */ + 161, /* 161 a1 */ + 'o' * CCCC + 5, /* 162 a2 */ + 163, /* 163 a3 */ + 'a' * CCCC + 1, /* 164 a4 */ + 'a' * CCCC + 5, /* 165 a5 */ + 166, /* 166 a6 */ + 167, /* 167 a7 */ + 'e' * CCCC + 1, /* 168 a8 */ + 'e' * CCCC + 5, /* 169 a9 */ + 170, /* 170 aa */ + 'z' * CCCC + 5, /* 171 ab */ + 172, /* 172 ac */ + 173, /* 173 ad */ + 174, /* 174 ae */ + 175, /* 175 af */ + 176, /* 176 b0 */ + 177, /* 177 b1 */ + 178, /* 178 b2 */ + 179, /* 179 b3 */ + 180, /* 180 b4 */ + 181, /* 181 b5 */ + 182, /* 182 b6 */ + 183, /* 183 b7 */ + 184, /* 184 b8 */ + 185, /* 185 b9 */ + 186, /* 186 ba */ + 187, /* 187 bb */ + 188, /* 188 bc */ + 'z' * CCCC + 2, /* 189 bd */ + 'z' * CCCC + 6, /* 190 be */ + 191, /* 191 bf */ + 192, /* 192 c0 */ + 193, /* 193 c1 */ + 194, /* 194 c2 */ + 195, /* 195 c3 */ + 196, /* 196 c4 */ + 197, /* 197 c5 */ + 198, /* 198 c6 */ + 199, /* 199 c7 */ + 200, /* 200 c8 */ + 201, /* 201 c9 */ + 202, /* 202 ca */ + 203, /* 203 cb */ + 204, /* 204 cc */ + 205, /* 205 cd */ + 206, /* 206 ce */ + 207, /* 207 cf */ + 208, /* 208 d0 */ + 209, /* 209 d1 */ + 210, /* 210 d2 */ + 211, /* 211 d3 */ + 212, /* 212 d4 */ + 213, /* 213 d5 */ + 214, /* 214 d6 */ + 215, /* 215 d7 */ + 216, /* 216 d8 */ + 217, /* 217 d9 */ + 218, /* 218 da */ + 219, /* 219 db */ + 220, /* 220 dc */ + 221, /* 221 dd */ + 222, /* 222 de */ + 223, /* 223 df */ + 'o' * CCCC + 1, /* 224 e0 */ + 225, /* 225 e1 */ + 226, /* 226 e2 */ + 'n' * CCCC + 1, /* 227 e3 */ + 'n' * CCCC + 5, /* 228 e4 */ + 229, /* 229 e5 */ + 230, /* 230 e6 */ + 231, /* 231 e7 */ + 232, /* 232 e8 */ + 233, /* 233 e9 */ + 234, /* 234 ea */ + 235, /* 235 eb */ + 236, /* 236 ec */ + 237, /* 237 ed */ + 238, /* 238 ee */ + 239, /* 239 ef */ + 240, /* 240 f0 */ + 241, /* 241 f1 */ + 242, /* 242 f2 */ + 243, /* 243 f3 */ + 244, /* 244 f4 */ + 245, /* 245 f5 */ + 246, /* 246 f6 */ + 247, /* 247 f7 */ + 248, /* 248 f8 */ + 249, /* 249 f9 */ + 250, /* 250 fa */ + 251, /* 251 fb */ + 252, /* 252 fc */ + 253, /* 253 fd */ + 254, /* 254 fe */ + 255 /* 255 ff */ + }; +{% endraw %} diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/pl_iso2.h b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/pl_iso2.h new file mode 100644 index 0000000..24492fe --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/pl_iso2.h @@ -0,0 +1,593 @@ +{% raw %} +static p_char_u pl_iso2_day_name_ptr = + { + (char_u *)NULL, + (char_u *)"niedziela", + (char_u *)"poniedzia\0xB3ek", + (char_u *)"wtorek", + (char_u *)"\0xB6roda", + (char_u *)"czwartek", + (char_u *)"pi\0xB1tek", + (char_u *)"sobota", + }; + +static p_char_u pl_iso2_day_name_ptr_a = + { + (char_u *)NULL, + (char_u *)"nd", + (char_u *)"pn", + (char_u *)"wt", + (char_u *)"\0xB6r", + (char_u *)"cz", + (char_u *)"pt", + (char_u *)"sb", + }; + +static p_char_u pl_iso2_mon_name_ptr = + { + (char_u *)NULL, + (char_u *)"stycze\0xF1", + (char_u *)"luty", + (char_u *)"marzec", + (char_u *)"kwiecie\0xF1", + (char_u *)"maj", + (char_u *)"czerwiec", + (char_u *)"lipiec", + (char_u *)"sierpie\0xF1", + (char_u *)"wrzesie\0xF1", + (char_u *)"pa\0xBCdziernik", + (char_u *)"listopad", + (char_u *)"grudzie\0xF1" + }; + +static p_char_u pl_iso2_mon_name_ptr_a = + { + (char_u *)NULL, + (char_u *)"stycze\0xF1", + (char_u *)"luty", + (char_u *)"marzec", + (char_u *)"kwiecie\0xF1", + (char_u *)"maj", + (char_u *)"czerwiec", + (char_u *)"lipiec", + (char_u *)"sierpie\0xF1", + (char_u *)"wrzesie\0xF1", + (char_u *)"pa\0xBCdziernik", + (char_u *)"listopad", + (char_u *)"grudzie\0xF1" + }; + +static int_u pl_iso2_toascii_table = + { + ' ', /* 128 0x80 */ + ' ', /* 129 0x81 */ + ' ', /* 130 0x82 */ + ' ', /* 131 0x83 */ + ' ', /* 132 0x84 */ + ' ', /* 133 0x85 */ + ' ', /* 134 0x86 */ + ' ', /* 135 0x87 */ + ' ', /* 136 0x88 */ + ' ', /* 137 0x89 */ + ' ', /* 138 0x8a */ + ' ', /* 139 0x8b */ + ' ', /* 140 0x8c */ + ' ', /* 141 0x8d */ + ' ', /* 142 0x8e */ + ' ', /* 143 0x8f */ + ' ', /* 144 0x90 */ + ' ', /* 145 0x91 */ + ' ', /* 146 0x92 */ + ' ', /* 147 0x93 */ + ' ', /* 148 0x94 */ + ' ', /* 149 0x95 */ + ' ', /* 150 0x96 */ + ' ', /* 151 0x97 */ + ' ', /* 152 0x98 */ + ' ', /* 153 0x99 */ + ' ', /* 154 0x9a */ + ' ', /* 155 0x9b */ + ' ', /* 156 0x9c */ + ' ', /* 157 0x9d */ + ' ', /* 158 0x9e */ + ' ', /* 159 0x9f */ + ' ', /* 160 0xa0 */ + 'A', /* 161 0xa1 */ + ' ', /* 162 0xa2 */ + 'L', /* 163 0xa3 */ + 'o', /* 164 0xa4 */ + 'L', /* 165 0xa5 */ + 'S', /* 166 0xa6 */ + 'S', /* 167 0xa7 */ + '"', /* 168 0xa8 */ + 'S', /* 169 0xa9 */ + 'S', /* 170 0xaa */ + 'T', /* 171 0xab */ + 'Z', /* 172 0xac */ + '-', /* 173 0xad */ + 'Z', /* 174 0xae */ + 'Z', /* 175 0xaf */ + 'o', /* 176 0xb0 */ + 'a', /* 177 0xb1 */ + ',', /* 178 0xb2 */ + 'l', /* 179 0xb3 */ + 180, /* 180 0xb4 */ + 'l', /* 181 0xb5 */ + 's', /* 182 0xb6 */ + ' ', /* 183 0xb7 */ + ',', /* 184 0xb8 */ + 's', /* 185 0xb9 */ + 's', /* 186 0xba */ + 't', /* 187 0xbb */ + 'z', /* 188 0xbc */ + ' ', /* 189 0xbd */ + 'z', /* 190 0xbe */ + 'z', /* 191 0xbf */ + 'R', /* 192 0xc0 */ + 'A', /* 193 0xc1 */ + 'A', /* 194 0xc2 */ + 'A', /* 195 0xc3 */ + 'A', /* 196 0xc4 */ + 'L', /* 197 0xc5 */ + 'C', /* 198 0xc6 */ + 'C', /* 199 0xc7 */ + 'C', /* 200 0xc8 */ + 'E', /* 201 0xc9 */ + 'E', /* 202 0xca */ + 'E', /* 203 0xcb */ + 'E', /* 204 0xcc */ + 'I', /* 205 0xcd */ + 'I', /* 206 0xce */ + 'D', /* 207 0xcf */ + 'D', /* 208 0xd0 */ + 'N', /* 209 0xd1 */ + 'N', /* 210 0xd2 */ + 'O', /* 211 0xd3 */ + 'O', /* 212 0xd4 */ + 'O', /* 213 0xd5 */ + 'O', /* 214 0xd6 */ + 'x', /* 215 0xd7 */ + 'R', /* 216 0xd8 */ + 'U', /* 217 0xd9 */ + 'U', /* 218 0xda */ + 'U', /* 219 0xdb */ + 'U', /* 220 0xdc */ + 'Y', /* 221 0xdd */ + 'J', /* 222 0xde */ + 'B', /* 223 0xdf */ + 'r', /* 224 0xe0 */ + 'a', /* 225 0xe1 */ + 'a', /* 226 0xe2 */ + 'a', /* 227 0xe3 */ + 'a', /* 228 0xe4 */ + 'l', /* 229 0xe5 */ + 'c', /* 230 0xe6 */ + 'c', /* 231 0xe7 */ + 'c', /* 232 0xe8 */ + 'e', /* 233 0xe9 */ + 'e', /* 234 0xea */ + 'e', /* 235 0xeb */ + 'e', /* 236 0xec */ + 'i', /* 237 0xed */ + 'i', /* 238 0xee */ + 'd', /* 239 0xef */ + 'd', /* 240 0xf0 */ + 'n', /* 241 0xf1 */ + 'n', /* 242 0xf2 */ + 'o', /* 243 0xf3 */ + 'o', /* 244 0xf4 */ + 'o', /* 245 0xf5 */ + 'o', /* 246 0xf6 */ + ':', /* 247 0xf7 */ + 'r', /* 248 0xf8 */ + 'u', /* 249 0xf9 */ + 'u', /* 250 0xfa */ + 'u', /* 251 0xfb */ + 'u', /* 252 0xfc */ + 'y', /* 253 0xfd */ + 't', /* 254 0xfe */ + '.', /* 255 0xff */ + }; + +static a_char_u pl_iso2_lower_table = + { + 'a', 'b', 'c', 'd', 'e', 'f', 'g', + 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', + 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', + 'x', 'y', 'z', '[', '\\', ']', '^', '_', + + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + + ' ', '\0xB1', ' ', '\0xB3', ' ', ' ', '\0xB6', ' ', + ' ', ' ', ' ', ' ', '\0xBC', ' ', ' ', '\0xBF', + + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + + ' ', ' ', ' ', ' ', ' ', ' ', '\0xE6', ' ', + ' ', ' ', '\0xEA', ' ', ' ', ' ', ' ', ' ', + + ' ', '\0xF1', ' ', '\0xF3', ' ', ' ', ' ', ' ', + }; + +static a_char_u pl_iso2_upper_table = + { + 'A','B','C','D','E','F','G', + 'H','I','J','K','L','M','N','O', + + 'P','Q','R','S','T','U','V','W', + 'X','Y','Z','{','|','}','~',' ', + + ' ',' ',' ',' ',' ',' ',' ',' ', + ' ',' ',' ',' ',' ',' ',' ',' ', + + ' ',' ',' ',' ',' ',' ',' ',' ', + ' ',' ',' ',' ',' ',' ',' ',' ', + + ' ',' ',' ',' ',' ',' ',' ',' ', + ' ',' ',' ',' ',' ',' ',' ',' ', + + ' ','\0xA1',' ','\0xA3',' ',' ','\0xA6',' ', + ' ',' ',' ',' ','\0xAC',' ',' ','\0xAF', + + ' ',' ',' ',' ',' ',' ',' ',' ', + ' ',' ',' ',' ',' ',' ',' ',' ', + + ' ',' ',' ',' ',' ',' ',' ',' ', + ' ',' ',' ',' ',' ',' ',' ',' ', + + ' ',' ',' ',' ',' ',' ','\0xC6',' ', + ' ',' ','\0xCA',' ',' ',' ',' ',' ', + + ' ','\0xD1',' ','\0xD3',' ',' ',' ',' ', + }; + + +static a_char_u pl_iso2_char_type = + { +IS_CTR, IS_CTR, IS_CTR, IS_CTR, +IS_CTR, IS_CTR, IS_CTR, IS_CTR, +IS_CTR, IS_CTR | IS_BLANK, IS_CTR | IS_BLANK, IS_CTR | IS_BLANK, +IS_CTR | IS_BLANK, IS_CTR | IS_BLANK, IS_CTR, IS_CTR, +IS_CTR, IS_CTR, IS_CTR, IS_CTR, +IS_CTR, IS_CTR, IS_CTR, IS_CTR, +IS_CTR, IS_CTR, IS_CTR, IS_CTR, +IS_CTR, IS_CTR, IS_CTR, IS_CTR, +IS_BLANK, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +IS_XDIG | IS_DIG, IS_XDIG | IS_DIG, IS_XDIG | IS_DIG, IS_XDIG | IS_DIG, +IS_XDIG | IS_DIG, IS_XDIG | IS_DIG, IS_XDIG | IS_DIG, IS_XDIG | IS_DIG, +IS_XDIG | IS_DIG, IS_XDIG | IS_DIG, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, + +0x000, IS_XDIG | IS_UPPER,IS_XDIG | IS_UPPER,IS_XDIG | IS_UPPER, +IS_XDIG | IS_UPPER,IS_XDIG | IS_UPPER,IS_XDIG | IS_UPPER,IS_UPPER, +IS_UPPER, IS_UPPER, IS_UPPER, IS_UPPER, +IS_UPPER, IS_UPPER, IS_UPPER, IS_UPPER, +IS_UPPER, IS_UPPER, IS_UPPER, IS_UPPER, +IS_UPPER, IS_UPPER, IS_UPPER, IS_UPPER, +IS_UPPER, IS_UPPER, IS_UPPER, 0x000, +0x000, 0x000, 0x000, IS_ALPH, + +0x000, IS_XDIG | IS_LOWER,IS_XDIG | IS_LOWER,IS_XDIG | IS_LOWER, +IS_XDIG | IS_LOWER,IS_XDIG | IS_LOWER,IS_XDIG | IS_LOWER,IS_LOWER, +IS_LOWER, IS_LOWER, IS_LOWER, IS_LOWER, +IS_LOWER, IS_LOWER, IS_LOWER, IS_LOWER, +IS_LOWER, IS_LOWER, IS_LOWER, IS_LOWER, +IS_LOWER, IS_LOWER, IS_LOWER, IS_LOWER, +IS_LOWER, IS_LOWER, IS_LOWER, 0x000, +0x000, 0x000, 0x000, IS_CTR, +/*--------------*/ +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, + +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, + +0x000, IS_UPPER, 0x000, IS_UPPER, /*.\0xA1.\0xA3..\0xA6.*/ +0x000, 0x000, IS_UPPER, 0x000, +0x000, 0x000, 0x000, 0x000, /*....\0xAC..\0xAF*/ +IS_UPPER, 0x000, 0x000, IS_UPPER, + +0x000, IS_LOWER, 0x000, IS_LOWER, /*.\0xB1.\0xB3..\0xB6.*/ +0x000, 0x000, IS_LOWER, 0x000, +0x000, 0x000, 0x000, 0x000, /*....\0xBC..\0xBF*/ +IS_LOWER, 0x000, 0x000, IS_LOWER, + +0x000, 0x000, 0x000, 0x000, /*.......\0xC6.*/ +0x000, 0x000, IS_UPPER, 0x000, +0x000, 0x000, IS_UPPER, 0x000, /*..\0xCA.....*/ +0x000, 0x000, 0x000, 0x000, + +0x000, IS_UPPER, 0x000, IS_UPPER, /*.\0xD1.\0xD3....*/ +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, + +0x000, 0x000, 0x000, 0x000, /*......\0xE6.*/ +0x000, 0x000, IS_LOWER, 0x000, +0x000, 0x000, IS_LOWER, 0x000, /*..\0xEA.....*/ +0x000, 0x000, 0x000, 0x000, + +0x000, IS_LOWER, 0x000, IS_LOWER, /*.\0xF1.\0xF3....*/ +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000 + }; + +static int_u pl_iso2_order_tbl = + { +0, /* 0 */ +'', /* 1 */ +'', /* 2 */ +'', /* 3 */ +'', /* 4 */ +'', /* 5 */ +'', /* 6 */ +'', /* 7 */ +'', /* 8 */ +TAB, /* 9 */ + LF, /* 10 0a */ +' ', /* 11 0b */ +' ', /* 12 0c */ + CR, /* 13 0d */ +'', /* 14 0e */ +'', /* 15 0f */ +'', /* 16 10 */ +'', /* 17 11 */ +'', /* 18 12 */ +'', /* 19 13 */ +'', /* 20 14 */ +'', /* 21 15 */ +'', /* 22 16 */ +'', /* 23 17 */ +'', /* 24 18 */ +'', /* 25 19 */ +0x1a, /* 26 1a */ +'', /* 27 1b */ +'', /* 28 1c */ +'', /* 29 1d */ +'', /* 30 1e */ +'', /* 31 1f */ +' ', /* 32 20 */ +'!', /* 33 21 */ +0x22, /* 34 22 quote */ +'#', /* 35 23 */ +'$', /* 36 24 */ +'%', /* 37 25 */ +'&', /* 38 26 */ +0x27, /* 39 27 single quote */ +'(', /* 40 28 */ +')', /* 41 29 */ +'*', /* 42 2a */ +'+', /* 43 2b */ +',', /* 44 2c */ +'-', /* 45 2d */ +'.', /* 46 2e */ +'/', /* 47 2f */ +'0', /* 48 30 */ +'1', /* 49 31 */ +'2', /* 50 32 */ +'3', /* 51 33 */ +'4', /* 52 34 */ +'5', /* 53 35 */ +'6', /* 54 36 */ +'7', /* 55 37 */ +'8', /* 56 38 */ +'9', /* 57 39 */ +':', /* 58 3a */ +';', /* 59 3b */ +'<', /* 60 3c */ +'=', /* 61 3d */ +'>', /* 62 3e */ +'?', /* 63 3f */ +'@', /* 64 40 */ +'a' * CCCC + 4, /* 'A', 65 41 */ +'b' * CCCC + 4, /* 'B', 66 42 */ +'c' * CCCC + 4, /* 'C', 67 43 */ +'d' * CCCC + 4, /* 'D', 68 44 */ +'e' * CCCC + 4, /* 'E', 69 45 */ +'f' * CCCC + 4, /* 'F', 70 46 */ +'g' * CCCC + 4, /* 'G', 71 47 */ +'h' * CCCC + 4, /* 'H', 72 48 */ +'i' * CCCC + 4, /* 'I', 73 49 */ +'j' * CCCC + 4, /* 'J', 74 4a */ +'k' * CCCC + 4, /* 'K', 75 4b */ +'l' * CCCC + 4, /* 'L', 76 4c */ +'m' * CCCC + 4, /* 'M', 77 4d */ +'n' * CCCC + 4, /* 'N', 78 4e */ +'o' * CCCC + 4, /* 'O', 79 4f */ +'p' * CCCC + 4, /* 'P', 80 50 */ +'q' * CCCC + 4, /* 'Q', 81 51 */ +'r' * CCCC + 4, /* 'R', 82 52 */ +'s' * CCCC + 4, /* 'S', 83 53 */ +'t' * CCCC + 4, /* 'T', 84 54 */ +'u' * CCCC + 4, /* 'U', 85 55 */ +'v' * CCCC + 4, /* 'V', 86 56 */ +'w' * CCCC + 4, /* 'W', 87 57 */ +'x' * CCCC + 4, /* 'X', 88 58 */ +'y' * CCCC + 4, /* 'Y', 89 59 */ +'z' * CCCC + 4, /* 'Z', 90 5a */ +0x5b, /* 91 5b */ +0x5c, /* 92 5c */ +0x5d, /* 93 5d ] */ +0x5e, /* 94 5e */ +'_', /* 95 5f */ +0x60, /* 96 60 ` */ +'a' * CCCC, /* 97 61 */ +'b' * CCCC, /* 98 62 */ +'c' * CCCC, /* 99 63 */ +'d' * CCCC, /* 100 64 */ +'e' * CCCC, /* 101 65 */ +'f' * CCCC, /* 102 66 */ +'g' * CCCC, /* 103 67 */ +'h' * CCCC, /* 104 68 */ +'i' * CCCC, /* 105 69 */ +'j' * CCCC, /* 106 6a */ +'k' * CCCC, /* 107 6b */ +'l' * CCCC, /* 108 6c */ +'m' * CCCC, /* 109 6d */ +'n' * CCCC, /* 110 6e */ +'o' * CCCC, /* 111 6f */ +'p' * CCCC, /* 112 70 */ +'q' * CCCC, /* 113 71 */ +'r' * CCCC, /* 114 72 */ +'s' * CCCC, /* 115 73 */ +'t' * CCCC, /* 116 74 */ +'u' * CCCC, /* 117 75 */ +'v' * CCCC, /* 118 76 */ +'w' * CCCC, /* 119 77 */ +'x' * CCCC, /* 120 78 */ +'y' * CCCC, /* 121 79 */ +'z' * CCCC, /* 122 7a */ +'{', /* 123 7b */ +'|', /* 124 7c */ +'}', /* 125 7d */ +'~', /* 126 7e */ +'', /* 127 7f */ +'\0x80', /* 128 80 */ +'\0x81', /* 129 81 */ +'\0x82', /* 130 82 */ +'\0x83', /* 131 83 */ +'\0x84', /* 132 84 */ +'\0x85', /* 133 85 */ +'\0x86', /* 134 86 */ +'\0x87', /* 135 87 */ +'\0x88', /* 136 88 */ +'\0x89', /* 137 89 */ +'\0x8A', /* 138 8a */ +'\0x8B', /* 139 8b */ +'\0x8C', /* 140 8c */ +'\0x8D', /* 141 8d */ +'\0x8E', /* 142 8e */ +'\0x8F', /* 143 8f */ +'\0x90', /* 144 90 */ +'\0x91', /* 145 91 */ +'\0x92', /* 146 92 */ +'\0x93', /* 147 93 */ +'\0x94', /* 148 94 */ +'\0x95', /* 149 95 */ +'\0x96', /* 150 96 */ +'\0x97', /* 151 97 */ +'\0x98', /* 152 98 */ +'\0x99', /* 153 99 */ +'\0x9A', /* 154 9a */ +'\0x9B', /* 155 9b */ +'\0x9C', /* 156 9c */ +'\0x9D', /* 157 9d */ +'\0x9E', /* 158 9e */ +'\0x9F', /* 159 9f */ + 160, /* a0 */ +'a' * CCCC + 5, /* 161 a1 */ + 162, /* a2 */ +'l' * CCCC + 5, /* 163 a3 */ + 164, /* a4 */ + 165, /* a5 */ +'s' * CCCC + 5, /* 166 a6 */ + 167, /* a7 */ + 168, /* a8 */ + 169, /* a9 */ + 170, /* aa */ + 171, /* ab */ +'z' * CCCC + 5, /* 172 ac */ + 173, /* ad */ + 174, /* ae */ +'z' * CCCC + 6, /* 175 af */ + 176, /* b0 */ +'a' * CCCC + 1, /* 177 b1 */ + 178, /* b2 */ +'l' * CCCC + 1, /* 179 b3 */ + 180, /* b4 */ + 181, /* b5 */ +'s' * CCCC + 1, /* 182 b6 */ + 183, /* b7 */ + 184, /* b8 */ + 185, /* b9 */ + 186, /* ba */ + 187, /* bb */ +'z' * CCCC + 1, /* 188 bc */ + 189, /* bd */ + 190, /* be */ +'z' * CCCC + 2, /* 191 bf */ + 192, /* c0 */ + 193, /* c1 */ + 194, /* c2 */ + 195, /* c3 */ + 196, /* c4 */ + 197, /* c5 */ +'c' * CCCC + 5, /* 198 c6 */ + 199, /* c7 */ + 200, /* c8 */ + 201, /* c9 */ +'e' * CCCC + 5, /* 202 ca */ + 203, /* cb */ + 204, /* cc */ + 205, /* cd */ + 206, /* ce */ + 207, /* cf */ + 208, /* d0 */ +'n' * CCCC + 5, /* 209 d1 */ + 210, /* d2 */ +'o' * CCCC + 5, /* 211 d3 */ + 212, /* d4 */ + 213, /* d5 */ + 214, /* d6 */ + 215, /* d7 */ + 216, /* d8 */ + 217, /* d9 */ + 218, /* da */ + 219, /* db */ + 220, /* dc */ + 221, /* dd */ + 222, /* de */ + 223, /* df */ + 224, /* e0 */ + 225, /*e1 */ + 226, /* e2 */ + 227, /* e3 */ + 228, /* e4 */ + 229, /* e5 */ +'c' * CCCC + 1, /* 230 e6 \0xE6*/ + 231, /* e7 */ + 232, /* e8 */ + 233, /* e9 */ +'e' * CCCC + 1, /* 234 ea */ + 235, /* eb */ + 236, /* ec */ + 237, /* ed */ + 238, /* ee */ + 239, /* ef */ + 240, /* f0 */ +'n' * CCCC + 1, /* 241 f1 */ + 242, /* f2 */ +'o' * CCCC + 1, /* 243 f3 */ + 244, /* f4 */ + 245, /* f5 */ + 246, /* f6 */ + 247, /* f7 */ + 248, /* f8 */ + 249, /* f9 */ + 250, /* fa */ + 251, /* fb */ + 252, /* fc */ + 253, /* fd */ + 254, /* fe */ + 255 /* 255 ff */ + }; +{% endraw %} diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/pl_maz.h b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/pl_maz.h new file mode 100644 index 0000000..a700c85 --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/pl_maz.h @@ -0,0 +1,546 @@ +{% raw %} +static p_char_u pl_maz_day_name_ptr = + { + (char_u *)NULL, + (char_u *)"niedziela", + (char_u *)"poniedzia\0x92ek", + (char_u *)"wtorek", + (char_u *)"\0x9Eroda", + (char_u *)"czwartek", + (char_u *)"pi\0x86tek", + (char_u *)"sobota", + }; + +static p_char_u pl_maz_day_name_ptr_a = + { + (char_u *)NULL, + (char_u *)"nd", + (char_u *)"pn", + (char_u *)"wt", + (char_u *)"\0x9Er", + (char_u *)"cz", + (char_u *)"pt", + (char_u *)"sb", + }; + +static p_char_u pl_maz_mon_name_ptr = + { + (char_u *)NULL, + (char_u *)"stycze\0xA4", + (char_u *)"luty", + (char_u *)"marzec", + (char_u *)"kwiecie\0xA4", + (char_u *)"maj", + (char_u *)"czerwiec", + (char_u *)"lipiec", + (char_u *)"sierpie\0xA4", + (char_u *)"wrzesie\0xA4", + (char_u *)"pa\0xA6dziernik", + (char_u *)"listopad", + (char_u *)"grudzie\0xA4" + }; + +static p_char_u pl_maz_mon_name_ptr_a = + { + (char_u *)NULL, + (char_u *)"stycze\0xA4", + (char_u *)"luty", + (char_u *)"marzec", + (char_u *)"kwiecie\0xA4", + (char_u *)"maj", + (char_u *)"czerwiec", + (char_u *)"lipiec", + (char_u *)"sierpie\0xA4", + (char_u *)"wrzesie\0xA4", + (char_u *)"pa\0xA6dziernik", + (char_u *)"listopad", + (char_u *)"grudzie\0xA4" + }; + +static int_u pl_maz_toascii_table = + { + 'C', /* 128 0x80 */ + 'u', /* 129 0x81 */ + 'e', /* 130 0x82 */ + 'a', /* 131 0x83 */ + 'a', /* 132 0x84 */ + 'a', /* 133 0x85 */ + 'a', /* 134 0x86 */ + 'c', /* 135 0x87 */ + 'e', /* 136 0x88 */ + 'e', /* 137 0x89 */ + 'e', /* 138 0x8a */ + 'i', /* 139 0x8b */ + 'i', /* 140 0x8c */ + 'c', /* 141 0x8d */ + 'A', /* 142 0x8e */ + 'A', /* 143 0x8f */ + 'E', /* 144 0x90 */ + 'e', /* 145 0x91 */ + 'l', /* 146 0x92 */ + 'o', /* 147 0x93 */ + 'o', /* 148 0x94 */ + 'C', /* 149 0x95 */ + 'u', /* 150 0x96 */ + 'u', /* 151 0x97 */ + 'S', /* 152 0x98 */ + 'O', /* 153 0x99 */ + 'U', /* 154 0x9a */ + 'c', /* 155 0x9b */ + 'L', /* 156 0x9c */ + 'Y', /* 157 0x9d */ + 's', /* 158 0x9e */ + 'f', /* 159 0x9f */ + 'Z', /* 160 0xa0 */ + 'Z', /* 161 0xa1 */ + 'o', /* 162 0xa2 */ + 'O', /* 163 0xa3 */ + 'n', /* 164 0xa4 */ + 'N', /* 165 0xa5 */ + 'z', /* 166 0xa6 */ + 'z', /* 167 0xa7 */ + '?', /* 168 0xa8 */ + '!', /* 169 0xa9 */ + '!', /* 170 0xaa */ + ' ', /* 171 0xab */ + ' ', /* 172 0xac */ + '!', /* 173 0xad */ + '<', /* 174 0xae */ + '>', /* 175 0xaf */ + '|', /* 176 0xb0 */ + '|', /* 177 0xb1 */ + '|', /* 178 0xb2 */ + '|', /* 179 0xb3 */ + '|', /* 180 0xb4 */ + '|', /* 181 0xb5 */ + '|', /* 182 0xb6 */ + '|', /* 183 0xb7 */ + '|', /* 184 0xb8 */ + '|', /* 185 0xb9 */ + '|', /* 186 0xba */ + '|', /* 187 0xbb */ + '+', /* 188 0xbc */ + '+', /* 189 0xbd */ + '+', /* 190 0xbe */ + '+', /* 191 0xbf */ + '+', /* 192 0xc0 */ + '+', /* 193 0xc1 */ + '+', /* 194 0xc2 */ + '|', /* 195 0xc3 */ + '-', /* 196 0xc4 */ + '|', /* 197 0xc5 */ + '|', /* 198 0xc6 */ + '|', /* 199 0xc7 */ + '|', /* 200 0xc8 */ + '|', /* 201 0xc9 */ + '-', /* 202 0xca */ + '-', /* 203 0xcb */ + '|', /* 204 0xcc */ + '-', /* 205 0xcd */ + '|', /* 206 0xce */ + '-', /* 207 0xcf */ + '-', /* 208 0xd0 */ + '-', /* 209 0xd1 */ + '-', /* 210 0xd2 */ + '|', /* 211 0xd3 */ + '|', /* 212 0xd4 */ + '|', /* 213 0xd5 */ + '|', /* 214 0xd6 */ + '|', /* 215 0xd7 */ + '|', /* 216 0xd8 */ + '-', /* 217 0xd9 */ + '-', /* 218 0xda */ + '|', /* 219 0xdb */ + '-', /* 220 0xdc */ + '|', /* 221 0xdd */ + '|', /* 222 0xde */ + '-', /* 223 0xdf */ + 'a', /* 224 0xe0 */ + 's', /* 225 0xe1 */ + 'G', /* 226 0xe2 */ + 'p', /* 227 0xe3 */ + 'S', /* 228 0xe4 */ + 's', /* 229 0xe5 */ + 'm', /* 230 0xe6 */ + 't', /* 231 0xe7 */ + 'p', /* 232 0xe8 */ + 'H', /* 233 0xe9 */ + 'O', /* 234 0xea */ + 'd', /* 235 0xeb */ + 'o', /* 236 0xec */ + 'o', /* 237 0xed */ + 'e', /* 238 0xee */ + 'n', /* 239 0xef */ + '=', /* 240 0xf0 */ + '+', /* 241 0xf1 */ + '>', /* 242 0xf2 */ + '<', /* 243 0xf3 */ + 'f', /* 244 0xf4 */ + 'f', /* 245 0xf5 */ + '/', /* 246 0xf6 */ + '=', /* 247 0xf7 */ + 'o', /* 248 0xf8 */ + '.', /* 249 0xf9 */ + '.', /* 250 0xfa */ + ' ', /* 251 0xfb */ + ' ', /* 252 0xfc */ + '2', /* 253 0xfd */ + '.', /* 254 0xfe */ + ' ', /* 255 0xff */ + }; + +static a_char_u pl_maz_lower_table = + { + 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', + 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', + 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', + 'y', 'z', '[', '\\', ']', '^', '_', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', + ' ', ' ', ' ', ' ', ' ', ' ', ' ', '\0x86', + '\0x91', ' ', ' ', ' ', ' ', '\0x8D', ' ', ' ', + '\0x9E', ' ', ' ', ' ', '\0x92', ' ', ' ', ' ', + '\0xA6', '\0xA7', ' ', '\0xA2', ' ', '\0xA4' + }; + +static a_char_u pl_maz_upper_table = + { + 'A','B','C','D','E','F','G','H', + 'I','J','K','L','M','N','O','P', + 'Q','R','S','T','U','V','W','X', + 'Y','Z','{','|','}','~',' ', + ' ',' ',' ',' ',' ',' ','\0x8F',' ', + ' ',' ',' ',' ',' ','\0x95',' ',' ', + ' ','\0x90','\0x9C',' ',' ',' ',' ',' ', + ' ',' ',' ',' ',' ',' ','\0x98',' ', + '\0xA0',' ','\0xA3',' ','\0xA5',' ','\0xA0','\0xA1' + }; + + +static a_char_u pl_maz_char_type = + { +IS_CTR, IS_CTR, IS_CTR, IS_CTR, +IS_CTR, IS_CTR, IS_CTR, IS_CTR, +IS_CTR, IS_CTR | IS_BLANK, IS_CTR | IS_BLANK, IS_CTR | IS_BLANK, +IS_CTR | IS_BLANK, IS_CTR | IS_BLANK, IS_CTR, IS_CTR, +IS_CTR, IS_CTR, IS_CTR, IS_CTR, +IS_CTR, IS_CTR, IS_CTR, IS_CTR, +IS_CTR, IS_CTR, IS_CTR, IS_CTR, +IS_CTR, IS_CTR, IS_CTR, IS_CTR, +IS_BLANK, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +IS_XDIG | IS_DIG, IS_XDIG | IS_DIG, IS_XDIG | IS_DIG, IS_XDIG | IS_DIG, +IS_XDIG | IS_DIG, IS_XDIG | IS_DIG, IS_XDIG | IS_DIG, IS_XDIG | IS_DIG, +IS_XDIG | IS_DIG, IS_XDIG | IS_DIG, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, + +0x000, IS_XDIG | IS_UPPER,IS_XDIG | IS_UPPER,IS_XDIG | IS_UPPER, +IS_XDIG | IS_UPPER,IS_XDIG | IS_UPPER,IS_XDIG | IS_UPPER,IS_UPPER, +IS_UPPER, IS_UPPER, IS_UPPER, IS_UPPER, +IS_UPPER, IS_UPPER, IS_UPPER, IS_UPPER, +IS_UPPER, IS_UPPER, IS_UPPER, IS_UPPER, +IS_UPPER, IS_UPPER, IS_UPPER, IS_UPPER, +IS_UPPER, IS_UPPER, IS_UPPER, 0x000, +0x000, 0x000, 0x000, IS_ALPH, + +0x000, IS_XDIG | IS_LOWER,IS_XDIG | IS_LOWER,IS_XDIG | IS_LOWER, +IS_XDIG | IS_LOWER,IS_XDIG | IS_LOWER,IS_XDIG | IS_LOWER,IS_LOWER, +IS_LOWER, IS_LOWER, IS_LOWER, IS_LOWER, +IS_LOWER, IS_LOWER, IS_LOWER, IS_LOWER, +IS_LOWER, IS_LOWER, IS_LOWER, IS_LOWER, +IS_LOWER, IS_LOWER, IS_LOWER, IS_LOWER, +IS_LOWER, IS_LOWER, IS_LOWER, 0x000, +0x000, 0x000, 0x000, IS_CTR, + +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, IS_LOWER, 0x000, /* 84 */ + /* a ogonek */ +0x000, 0x000, 0x000, 0x000, /* 88 */ +0x000, IS_LOWER, 0x000, IS_UPPER, /* 8c */ + /* c acute*/ /* A ogonek*/ +IS_UPPER, IS_LOWER, IS_LOWER, 0x000, /* 90 */ +/*E ogonek */ /*e ogonek */ /* polish l */ +0x000, IS_UPPER, 0x000, 0x000, /* 94 */ + /* C acute */ +IS_UPPER, 0x000, 0x000, 0x000, /* 98 */ +/* S acute */ +IS_UPPER, 0x000, IS_LOWER, 0x000, /* 9c */ +/* Polish L */ /* s acute */ +IS_UPPER, IS_UPPER, IS_LOWER, IS_UPPER, /* a0 */ +/* Z acute */ /* Z dot */ /* o acute */ /* O acute*/ +IS_LOWER, IS_UPPER, IS_LOWER, IS_LOWER, /* a4 */ +/*n acute */ /* N acute */ /* z acute */ /* z dot */ +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, + +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000 + }; + +static int_u pl_maz_order_tbl = + { +0, 1, 2, 3, 4, 5, 6, 7, +8, +TAB, /* 9 */ +LF, /* 10 0a */ +11, +12, +CR, /* 13 0d */ +14, +15, +16, 17, 18, 19, 20, 21, 22, 23, +24, 25, 26, 27, 28, 29, 30, 31, +' ', /* 32 20 */ +'!', /* 33 21 */ +0x22, /* 34 22 quote */ +'#', /* 35 23 */ +'$', /* 36 24 */ +'%', /* 37 25 */ +'&', /* 38 26 */ +0x27, /* 39 27 single quote */ +'(', /* 40 28 */ +')', /* 41 29 */ +'*', /* 42 2a */ +'+', /* 43 2b */ +',', /* 44 2c */ +'-', /* 45 2d */ +'.', /* 46 2e */ +'/', /* 47 2f */ +'0', /* 48 30 */ +'1', /* 49 31 */ +'2', /* 50 32 */ +'3', /* 51 33 */ +'4', /* 52 34 */ +'5', /* 53 35 */ +'6', /* 54 36 */ +'7', /* 55 37 */ +'8', /* 56 38 */ +'9', /* 57 39 */ +':', /* 58 3a */ +';', /* 59 3b */ +'<', /* 60 3c */ +'=', /* 61 3d */ +'>', /* 62 3e */ +'?', /* 63 3f */ +'@', /* 64 40 */ +'a' * CCCC + 4, /* 'A', 65 41 */ +'b' * CCCC + 4, /* 'B', 66 42 */ +'c' * CCCC + 4, /* 'C', 67 43 */ +'d' * CCCC + 4, /* 'D', 68 44 */ +'e' * CCCC + 4, /* 'E', 69 45 */ +'f' * CCCC + 4, /* 'F', 70 46 */ +'g' * CCCC + 4, /* 'G', 71 47 */ +'h' * CCCC + 4, /* 'H', 72 48 */ +'i' * CCCC + 4, /* 'I', 73 49 */ +'j' * CCCC + 4, /* 'J', 74 4a */ +'k' * CCCC + 4, /* 'K', 75 4b */ +'l' * CCCC + 4, /* 'L', 76 4c */ +'m' * CCCC + 4, /* 'M', 77 4d */ +'n' * CCCC + 4, /* 'N', 78 4e */ +'o' * CCCC + 4, /* 'O', 79 4f */ +'p' * CCCC + 4, /* 'P', 80 50 */ +'q' * CCCC + 4, /* 'Q', 81 51 */ +'r' * CCCC + 4, /* 'R', 82 52 */ +'s' * CCCC + 4, /* 'S', 83 53 */ +'t' * CCCC + 4, /* 'T', 84 54 */ +'u' * CCCC + 4, /* 'U', 85 55 */ +'v' * CCCC + 4, /* 'V', 86 56 */ +'w' * CCCC + 4, /* 'W', 87 57 */ +'x' * CCCC + 4, /* 'X', 88 58 */ +'y' * CCCC + 4, /* 'Y', 89 59 */ +'z' * CCCC + 4, /* 'Z', 90 5a */ +0x5b, /* 91 5b */ +0x5c, /* 92 5c */ +0x5d, /* 93 5d ] */ +0x5e, /* 94 5e */ +'_', /* 95 5f */ +0x60, /* 96 60 ` */ +'a' * CCCC, /* 97 61 */ +'b' * CCCC, /* 98 62 */ +'c' * CCCC, /* 99 63 */ +'d' * CCCC, /* 100 64 */ +'e' * CCCC, /* 101 65 */ +'f' * CCCC, /* 102 66 */ +'g' * CCCC, /* 103 67 */ +'h' * CCCC, /* 104 68 */ +'i' * CCCC, /* 105 69 */ +'j' * CCCC, /* 106 6a */ +'k' * CCCC, /* 107 6b */ +'l' * CCCC, /* 108 6c */ +'m' * CCCC, /* 109 6d */ +'n' * CCCC, /* 110 6e */ +'o' * CCCC, /* 111 6f */ +'p' * CCCC, /* 112 70 */ +'q' * CCCC, /* 113 71 */ +'r' * CCCC, /* 114 72 */ +'s' * CCCC, /* 115 73 */ +'t' * CCCC, /* 116 74 */ +'u' * CCCC, /* 117 75 */ +'v' * CCCC, /* 118 76 */ +'w' * CCCC, /* 119 77 */ +'x' * CCCC, /* 120 78 */ +'y' * CCCC, /* 121 79 */ +'z' * CCCC, /* 122 7a */ +'{', /* 123 7b */ +'|', /* 124 7c */ +'}', /* 125 7d */ +'~', /* 126 7e */ + 127, + 128, + 129, + 130, + 131, + 132, + 133, +'a' * CCCC + 1, /* aogonek 134 86 */ + 135, + 136, + 137, + 138, + 139, + 140, +'c' * CCCC + 1, /* c acute 141 8d */ + 142, +'a' * CCCC + 5, /* Aogonek 143 8f */ +'e' * CCCC + 5, /* Eogonek 144 90 */ +'e' * CCCC + 1, /* eogonek 145 91 */ +'l' * CCCC + 1, /* polish l 146 92 */ + 147, + 148, +'c' * CCCC + 5, /* O acute 149 95 */ + 150, + 151, +'s' * CCCC + 5, /* S acute 152 98 */ + 153, + 154, + 155, +'l' * CCCC + 5, /* polish L 156 9c */ + 157, +'s' * CCCC + 1, /* s acute 158 9e */ + 159, +'z' * CCCC + 5, /* Z dot 160 a0 */ +'z' * CCCC + 6, /* Z acute 161 a1 */ +'o' * CCCC + 1, /* o acute 162 a2 */ +'o' * CCCC + 5, /* O acute 163 a3 */ +'n' * CCCC + 1, /* n acute 164 a4 */ +'n' * CCCC + 5, /* N acute 165 a5 */ +'z' * CCCC + 1, /* z dot 166 a6 */ +'z' * CCCC + 2, /* z acute 167 a7 */ + 168, 169, 170, 171, 172, 173, 174, 175, + 176, 177, 178, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 198, 199, + 200, 201, 202, 203, 204, 205, 206, 207, + 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, 218, 219, 220, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 230, 231, + 232, 233, 234, 235, 236, 237, 238, 239, + 240, 241, 242, 243, 244, 245, 246, 247, + 248, 249, 250, 251, 252, 253, 254, 255 + }; + +/* +static p_char_u maz_jedn = + { + (char_u *)"???", + (char_u *)"jeden", + (char_u *)"dwa", + (char_u *)"trzy", + (char_u *)"cztery", + (char_u *)"pie\0x8D", + (char_u *)"sze\0x9E\0x8D", + (char_u *)"siedem", + (char_u *)"osiem", + (char_u *)"dziewi\0x91\0x8D", + (char_u *)"dziesi\0x91\0x8D", + (char_u *)"jedena\0x9Ecie", + (char_u *)"dwana\0x9Ecie", + (char_u *)"trzyna\0x9Ecie", + (char_u *)"czterna\0x9Ecie", + (char_u *)"pi\0x91tna\0x9Ecie", + (char_u *)"szesna\0x9Ecie", + (char_u *)"siedemna\0x9Ecie", + (char_u *)"osiemna\0x9Ecie", + (char_u *)"dziewi\0x91tna\0x9Ecie" + }; + +static p_char_u maz_dies = + { + (char_u *)"???", + (char_u *)"dwadzie\0x9Ecia", + (char_u *)"trzydzie\0x9Eci", + (char_u *)"czterdzie\0x9Eci", + (char_u *)"pie\0x8Ddziesi\0x86t", + (char_u *)"sze\0x9Ecdziesi\0x86t", + (char_u *)"siedemdziesi\0x86t", + (char_u *)"osiemdziesi\0x86t", + (char_u *)"dziewi\0x91\0x8Ddziesi\0x86t" + }; + +static p_char_u maz_setki = + { + (char_u *)"???", + (char_u *)"sto", + (char_u *)"dwie\0x9Ecie", + (char_u *)"trzysta", + (char_u *)"czterysta", + (char_u *)"pie\0x8Dset", + (char_u *)"sze\0x9E\0x8Dset", + (char_u *)"siedemset", + (char_u *)"osiemset", + (char_u *)"dziewi\0x91\0x8Dset" + }; + +static p_char_u maz_tys = + { + (char_u *)"???", + (char_u *)"tysi\0x86c", + (char_u *)"tysi\0x86ce", + (char_u *)"tysi\0x86ce", + (char_u *)"tysi\0x86ce", + (char_u *)"tysi\0x91cy" + }; + +static p_char_u maz_mil = + { + (char_u *)"???", + (char_u *)"milion", + (char_u *)"miliony", + (char_u *)"miliony", + (char_u *)"miliony", + (char_u *)"milion\0xA2w" + }; + +static struct decode maz_decode = + { + &maz_jedn, + &maz_dies, + &maz_setki, + &maz_tys, + &maz_mil + }; */ +/* ******************************************************************* */ +{% endraw %} diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/qsort.c b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/qsort.c new file mode 100644 index 0000000..0d18cc6 --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/qsort.c @@ -0,0 +1,228 @@ +/* + * + * This file is part of + * MakeIndex - A formatter and format independent index processor + * + * This file is public domain software donated by + * Nelson Beebe (beebe@science.utah.edu). + * + */ + +/* + * qsort.c: Our own version of the system qsort routine which is faster by an + * average of 25%, with lows and highs of 10% and 50%. The THRESHold below is + * the insertion sort threshold, and has been adjusted for records of size 48 + * bytes. The MTHREShold is where we stop finding a better median. + */ + +/* #include -- mkind.h includes this */ +#include "mkind.h" /* only for type declarations */ + +#define THRESH 4 /* threshold for insertion */ +#define MTHRESH 6 /* threshold for median */ + +Local int qsz; /* size of each record */ +Local int thresh; /* THRESHold in chars */ +Local int mthresh; /* MTHRESHold in chars */ + +Local int (*qcmp) (char*,char*); /* the comparison routine */ +Local void qst (char *base, char *max); +/* + * qqsort: First, set up some global parameters for qst to share. Then, + * quicksort with qst(), and then a cleanup insertion sort ourselves. Sound + * simple? It's not... + */ + +Public void +qqsort(char *base, int n, int size, int (*compar) (char*, char*)) + +{ + register char *i; + register char *j; + register char *lo; + register char *hi; + register char *min; + register char c; + char *max; + + if(n <= 1) + return; + + qsz = size; + qcmp = compar; + thresh = qsz * THRESH; + mthresh = qsz * MTHRESH; + max = base + n * qsz; + if(n >= THRESH) + { + qst(base, max); + hi = base + thresh; + } + else + hi = max; + /* + * First put smallest element, which must be in the first THRESH, in the + * first position as a sentinel. This is done just by searching the + * first THRESH elements (or the first n if n < THRESH), finding the min, + * and swapping it into the first position. + */ + for(j = lo = base; (lo += qsz) < hi; ) + if((*qcmp) (j, lo) > 0) + j = lo; + if(j != base) + { /* swap j into place */ + for(i = base, hi = base + qsz; i < hi; ) + { + c = *j; + *j++ = *i; + *i++ = c; + } + } + /* + * With our sentinel in place, we now run the following hyper-fast + * insertion sort. For each remaining element, min, from [1] to [n-1], + * set hi to the index of the element AFTER which this one goes. Then, do + * the standard insertion sort shift on a character at a time basis for + * each element in the frob. + */ + for(min = base; (hi = min += qsz) < max; ) + { + while((*qcmp) (hi -= qsz, min) > 0) + ; + if((hi += qsz) != min) + for(lo = min + qsz; --lo >= min; ) + { + c = *lo; + for(i = j = lo; (j -= qsz) >= hi; i = j) + *i = *j; + *i = c; + } + } +} + +/* + * qst: Do a quicksort. First, find the median element, and put that one in + * the first place as the discriminator. (This "median" is just the median + * of the first, last and middle elements). (Using this median instead of + * the first element is a big win). Then, the usual partitioning/swapping, + * followed by moving the discriminator into the right place. Then, figure + * out the sizes of the two partions, do the smaller one recursively and the + * larger one via a repeat of this code. Stopping when there are less than + * THRESH elements in a partition and cleaning up with an insertion sort (in + * our caller) is a huge win. All data swaps are done in-line, which is + * space-losing but time-saving. (And there are only three places where this + * is done). + */ + +Local void +qst(char *base, char *max) + +{ + register char *i; + register char *j; + register char *jj; + register char *mid; + register int ii; + register char c; + char *tmp; + int lo; + int hi; + + lo = (int)(max - base); /* number of elements as chars */ + do + { + /* + * At the top here, lo is the number of characters of elements in the + * current partition. (Which should be max - base). Find the median + * of the first, last, and middle element and make that the middle + * element. Set j to largest of first and middle. If max is larger + * than that guy, then it's that guy, else compare max with loser of + * first and take larger. Things are set up to prefer the middle, + * then the first in case of ties. + */ + mid = i = base + qsz * ((unsigned) (lo / qsz) >> 1); + if(lo >= mthresh) + { + j = ((*qcmp) ((jj = base), i) > 0 ? jj : i); + if((*qcmp) (j, (tmp = max - qsz)) > 0) + { + /* switch to first loser */ + j = (j == jj ? i : jj); + if((*qcmp) (j, tmp) < 0) + j = tmp; + } + if(j != i) + { + ii = qsz; + do + { + c = *i; + *i++ = *j; + *j++ = c; + }while(--ii); + } + } + /* Semi-standard quicksort partitioning/swapping */ + for(i = base, j = max - qsz;;) + { + while(i < mid && (*qcmp) (i, mid) <= 0) + i += qsz; + while(j > mid) + { + if((*qcmp) (mid, j) <= 0) + { + j -= qsz; + continue; + } + tmp = i + qsz; /* value of i after swap */ + if(i == mid) + /* j <-> mid, new mid is j */ + mid = jj = j; + else + { /* i <-> j */ + jj = j; + j -= qsz; + } + goto swap; + } + if(i == mid) + break; + else + { /* i <-> mid, new mid is i */ + jj = mid; + tmp = mid = i; /* value of i after swap */ + j -= qsz; + } +swap: + ii = qsz; + do + { + c = *i; + *i++ = *jj; + *jj++ = c; + }while(--ii); + i = tmp; + } + /* + * Look at sizes of the two partitions, do the smaller one first by + * recursion, then do the larger one by making sure lo is its size, + * base and max are update correctly, and branching back. But only + * repeat (recursively or by branching) if the partition is of at + * least size THRESH. + */ + i = (j = mid) + qsz; + if((lo = (int)(j - base)) <= (hi = (int)(max - i))) + { + if(lo >= thresh) + qst(base, j); + base = i; + lo = hi; + } + else + { + if(hi >= thresh) + qst(i, max); + max = j; + } + }while(lo >= thresh); +} diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/scanid.c b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/scanid.c new file mode 100644 index 0000000..b04fe2c --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/scanid.c @@ -0,0 +1,877 @@ +#include "mkind.h" +#include "scanid.h" +#include + +#define CHECK_LENGTH() \ + if(i > len_field)\ + goto OVERFLOW + +Local int idx_lc; /* line count */ +Local int idx_tc; /* total entry count */ +Local int idx_ec; /* erroneous entry count */ + +Public int idx_dc; /* number of dots printed so far */ + +Local Logical first_entry = True; +Local int comp_len; +Local unsigned char key[ARGUMENT_MAX]; +Local char no[NUMBER_MAX]; + +NODE_PTR head; +NODE_PTR tail; + +Local void Idx_Error (const char *fmt, ...); +Local int Idx_Skipline (VOID_ARG); +Local void flush_to_eol (void); +Local Logical make_key (void); +Local void make_string (unsigned char **ppstr, int n); +Local Logical scan_alpha_lower (unsigned char *no, short *npg, \ + short *count); +Local Logical scan_alpha_upper (unsigned char *no, short *npg, \ + short *count); +Local Logical scan_arabic (unsigned char *no,short *npg, short *count); +Local Logical scan_arg1 (void); +Local Logical scan_arg2 (void); +Local Logical scan_field (int *n, unsigned char field[], int len_field, + Logical ck_level, Logical ck_encap, Logical ck_actual); +Local Logical scan_key (struct KFIELD *data); +Local Logical scan_no (unsigned char *no, short *npg, short *count, \ + short *type); +Local Logical scan_roman_lower (unsigned char *no, short *npg, \ + short *count); +Local Logical scan_roman_upper (unsigned char *no, short *npg, \ + short *count); + +Public void +scan_idx(VOID_ARG) + +{ + unsigned char *keyword; + int c; + int i = 0; + Logical not_eof = True; + int arg_count = -1; + + if((keyword = (unsigned char *) calloc(1, ARRAY_MAX)) == NULL) + Fatal("Not enough core...abort.\n"); + Message("Scanning input file %s...", idx_fn); + idx_lc = idx_tc = idx_ec = idx_dc = 0; + comp_len = strlen(page_comp); + while(not_eof) + { + switch(c = GET_CHAR(idx_fp)) + { + case EOF: + if(arg_count == 2) + { + idx_lc++; + if(make_key()) + { + idx_dot = True; + if(idx_dc++ == 0) + Message(DOT); + if(idx_dc == DOT_MAX) + idx_dc = 0; + } + arg_count = -1; + } + else + not_eof = False; + break; + + case LFD: + idx_lc++; + if(arg_count == 2) + { + if(make_key()) + { + idx_dot = True; + if(idx_dc++ == 0) + Message(DOT); + if(idx_dc == DOT_MAX) + idx_dc = 0; + } + arg_count = -1; + } + else if(arg_count > -1) + { + Idx_Error("Missing arguments -- need two " \ + "(premature LFD).\n"); + arg_count = -1; + } + case TAB: + case SPC: + break; + + default: + switch(arg_count) + { + case -1: + i = 0; + keyword[i++] = (unsigned char) c; + arg_count++; + idx_tc++; + break; + case 0: + if(c == idx_aopen) + { + arg_count++; + keyword[i] = EOS; + if(STREQ(keyword, idx_keyword)) + { + if(!scan_arg1()) + arg_count = -1; + } + else + { + arg_count = Idx_Skipline(); + Idx_Error("Unknown index keyword %s.\n", + keyword); + } + } + else + { + if(i < ARRAY_MAX) + keyword[i++] = (char) c; + else + { + arg_count = Idx_Skipline(); + Idx_Error("Index keyword %s too long " \ + "(max %d).\n", keyword, ARRAY_MAX); + } + } + break; + case 1: + if(c == idx_aopen) + { + arg_count++; + if(!scan_arg2()) + arg_count = -1; + } + else + { + arg_count = Idx_Skipline(); + Idx_Error("No opening delimiter for second " \ + "argument (illegal character `%c').\n", c); + } + break; + case 2: + arg_count = Idx_Skipline(); + Idx_Error("No closing delimiter for second argument " \ + "(illegal character `%c').\n", c); + break; + } + break; + } + } +/* { + NODE_PTR aqq; + + aqq = head; + + while(aqq->next != NULL) + { + int i = 0; + + for(i = 0; i < FIELD_MAX; i++) + printf("%s\n", aqq->data.sf[i]); + aqq = aqq->next; + } + }*/ + + /* fixup the total counts */ + idx_tt += idx_tc; + idx_et += idx_ec; + + free(keyword); + CLOSE(idx_fp); + Message("done (%d %s, %d %s).\n", idx_tc - idx_ec, "entries accepted", + idx_ec, "rejected"); +} + +Local void +flush_to_eol(VOID_ARG) + +{ /* flush to end-of-line, or end-of-file, whichever is first */ + int a; + + while(((a = GET_CHAR(idx_fp)) != LFD) && (a != EOF)) + ;/* NO-OP */ +} + +Local Logical +make_key(VOID_ARG) + +{ + NODE_PTR ptr; + int i; + + /* allocate and initialize a node */ + +#ifdef DEBUG + totmem += sizeof(NODE); + (void)fprintf(stderr,"make_key(): malloc(%d)\ttotmem = %ld\n", + sizeof(NODE), totmem); +#endif /* DEBUG */ + + if((ptr = (NODE_PTR) malloc(sizeof(NODE))) == NULL) + Fatal("Not enough core...abort.\n"); + + for(i = 0; i < FIELD_MAX; i++) + { + ptr->data.sf[i] = EMPTY_STRING; /* initialize fields to pointers */; + ptr->data.af[i] = EMPTY_STRING; /* to constant empty strings */ + } + ptr->data.encap = EMPTY_STRING; + ptr->data.lpg[0] = EOS; + ptr->data.count = 0; + ptr->data.type = EMPTY; + + /* process index key */ + if(!scan_key(&(ptr->data))) + return(False); /* WM OK*/ + + /* determine group type */ + ptr->data.group = group_type(ptr->data.sf[0]); + + /* process page number */ + strcpy(ptr->data.lpg, no); + if(!scan_no((unsigned char *)no, ptr->data.npg, &(ptr->data.count), + &(ptr->data.type))) + return(False); + + if(first_entry) + { + head = tail = ptr; + first_entry = False; + } + else + { + tail->next = ptr; + tail = ptr; + } + ptr->data.lc = idx_lc; + ptr->data.fn = idx_fn; + tail->next = NULL; + + return(True); +} + +Local void +make_string(unsigned char **ppstr, int n) + +{ + if((*ppstr)[0] == EOS) /* then we have an empty string */ + { + (*ppstr) = (unsigned char*)malloc(n); + if((*ppstr) == (unsigned char*)NULL) + Fatal("Not enough core...abort.\n"); + (*ppstr)[0] = EOS; + } +} + +Local Logical +scan_key(FIELD_PTR data) + +{ + int i = 0; /* current level */ + int n = 0; /* index to the key[] array */ + int second_round = False; + int last = FIELD_MAX - 1; + + while(True) + { + if(key[n] == EOS) + break; + if(key[n] == idx_encap) + { + n++; + make_string(&(data->encap), strlen((char *)key) + 1); + if(scan_field(&n, data->encap, strlen((char *)key), False, False, + False)) + break; + else + return(False); + } + if(key[n] == idx_actual) + { + n++; + make_string(&(data->af[i]), strlen((char *)key) + 1); + if(i == last) + { + if(!scan_field(&n, data->af[i], strlen((char *)key), + False, True, False)) + return(False); + } + else + { + if(!scan_field(&n, data->af[i], strlen((char *)key), True, + True, False)) + return(False); + } + } + else + { + /* Next nesting level */ + if(second_round) + { + i++; + n++; + } + make_string(&(data->sf[i]), strlen((char *)key) + 1); + if(i == last) + { + if(!scan_field(&n, data->sf[i], strlen((char *)key), False, + True, True)) + return(False); + } + else + { + if(!scan_field(&n, data->sf[i], strlen((char *)key), True, + True, True)) + return(False); + } + second_round = True; + } + if((multilanguage[Language].flags & SPECIAL_FLAG) && + multilanguage[Language]._special != NULL && + (isdigit(data->sf[i][0]) && data->af[i][0] == EOS)) + { + data->af[i] = data->sf[i]; + data->sf[i] = (unsigned char *) + (*(multilanguage[Language]._special))(atol((char *)data->af[i])); + } + } + + /* check for empty fields which shouldn't be empty */ + if(*data->sf[0] == EOS) + { + Idx_Error("Illegal null field.\n"); + return(False); + } + for(i = 1; i < FIELD_MAX - 1; i++) + if((*data->sf[i] == EOS) && + ((*data->af[i] != EOS) || (*data->sf[i + 1] != EOS))) + { + Idx_Error("Illegal null field.\n"); + return(False); + } + /* i == FIELD_MAX-1 */ + if((*data->sf[i] == EOS) && (*data->af[i] != EOS)) + { + Idx_Error("Illegal null field.\n"); + return(False); + } + return(True); +} + +Local Logical +scan_field(int *n, unsigned char field[], int len_field, Logical ck_level, + Logical ck_encap, Logical ck_actual) + +{ + int i = 0; + int nbsh; /* backslash count */ + + if(compress_blanks && ((key[*n] == SPC) || (key[*n] == TAB))) + ++* n; + + while(True) + { + nbsh = 0; + while(key[*n] == idx_escape) + { + nbsh++; + field[i++] = key[*n]; + CHECK_LENGTH(); + ++*n; + } + + if(key[*n] == idx_quote) + { + if(nbsh % 2 == 0) + field[i++] = key[++*n]; + else + field[i++] = key[*n]; + CHECK_LENGTH(); + } + else if((ck_level && (key[*n] == idx_level)) || + (ck_encap && (key[*n] == idx_encap)) || + (ck_actual && (key[*n] == idx_actual)) || + (key[*n] == EOS)) + { + if((i > 0) && compress_blanks && (field[i - 1] == SPC)) + field[i - 1] = EOS; + else + field[i] = EOS; + return(True); + } + else + { + field[i++] = key[*n]; + CHECK_LENGTH(); + if((!ck_level) && (key[*n] == idx_level)) + { + Idx_Error("Extra `%c' at position %d of first argument.\n", + idx_level, *n + 1); + return(False); + } + else if((!ck_encap) && (key[*n] == idx_encap)) + { + Idx_Error("Extra `%c' at position %d of first argument.\n", + idx_encap, *n + 1); + return(False); + } + else if((!ck_actual) && (key[*n] == idx_actual)) + { + Idx_Error("Extra `%c' at position %d of first argument.\n", + idx_actual, *n + 1); + return(False); + } + } + /* check if max field length is reached */ + if(i > len_field) + { +OVERFLOW: + if(!ck_encap) + Idx_Error("Encapsulator of page number too long (max. %d).\n", + len_field); + else if(ck_actual) + Idx_Error("Index sort key too long (max. %d).\n", len_field); + else + Idx_Error("Text of key entry too long (max. %d).\n", len_field); + return(False); + } + ++*n; + } +} + +Public int +group_type(unsigned char *str) + +{ + int i = 0; + + while((str[i] != EOS) && ISDIGIT(str[i])) + i++; + + if(str[i] == EOS) + { + sscanf((char *)str, "%d", &i); + return(i); + } + else if(ISSYMBOL(str[0])) + return(SYMBOL); + else + return(ALPHA); +} + +Local Logical +scan_no(unsigned char no[], short npg[], short *count, short *type) + +{ + int i = 1; + + if(isdigit(no[0])) + { + *type = ARAB; + if(!scan_arabic(no, npg, count)) + return(False); + /* simple heuristic to determine if a letter is Roman or Alpha */ + } + else if(IS_ROMAN_LOWER(no[0]) && (!IS_COMPOSITOR)) + { + *type = ROML; + if(!scan_roman_lower(no, npg, count)) + return(False); + /* simple heuristic to determine if a letter is Roman or Alpha */ + } + else if(IS_ROMAN_UPPER(no[0]) && + ((no[0] == ROMAN_I) || (!IS_COMPOSITOR))) + { + *type = ROMU; + if(!scan_roman_upper(no, npg, count)) + return(False); + } + else if(IS_ALPHA_LOWER(no[0])) + { + *type = ALPL; + if(!scan_alpha_lower(no, npg, count)) + return(False); + } + else if(IS_ALPHA_UPPER(no[0])) + { + *type = ALPU; + if(!scan_alpha_upper(no, npg, count)) + return(False); + } + else + { + Idx_Error("Illegal page number %s.\n", no); + return(False); + } + return(True); +} + + +Local Logical +scan_arabic(unsigned char no[], short npg[], short *count) + +{ + short i = 0; + char str[ARABIC_MAX + 1]; /* space for trailing EOS */ + + while((no[i] != EOS) && (i <= ARABIC_MAX) && (!IS_COMPOSITOR)) + { + if(isdigit(no[i])) + { + str[i] = no[i]; + i++; + } + else + { + Idx_Error("Illegal Arabic digit: position %d in %s.\n", i + 1, no); + return(False); + } + } + if(i > ARABIC_MAX) + { + Idx_Error("Arabic page number %s too big (max %d digits).\n", + no, ARABIC_MAX); + return(False); + } + str[i] = EOS; + + if(*count >= PAGEFIELD_MAX) + { + Idx_Error("Page number %s has too many fields (max. %d).", + no, PAGEFIELD_MAX); + return(False); + } + npg[*count] = (strtoint(str) + page_offset[ARAB]); + ++*count; + + if(IS_COMPOSITOR) + return(scan_no(&no[i + comp_len], npg, count, &i)); + else + return(True); +} + +Local Logical +scan_roman_lower(unsigned char no[], short npg[], short *count) + +{ + short i = 0; + int inp = 0; + int prev = 0; + int the_new; + + while((no[i] != EOS) && (i < ROMAN_MAX) && (!IS_COMPOSITOR)) + { + if((IS_ROMAN_LOWER(no[i])) && + ((the_new = ROMAN_LOWER_VAL(no[i])) != 0)) + { + if(prev == 0) + prev = the_new; + else + { + if(prev < the_new) + { + prev = the_new - prev; + the_new = 0; + } + inp += prev; + prev = the_new; + } + } + else + { + Idx_Error("Illegal Roman number: position %d in %s.\n", i + 1, no); + return(False); + } + i++; + } + if(i == ROMAN_MAX) + { + Idx_Error("Roman page number %s too big (max %d digits).\n", + no, ROMAN_MAX); + return(False); + } + inp += prev; + + if(*count >= PAGEFIELD_MAX) + { + Idx_Error("Page number %s has too many fields (max. %d).", + no, PAGEFIELD_MAX); + return(False); + } + npg[*count] = (inp + page_offset[ROML]); + ++*count; + + if(IS_COMPOSITOR) + return(scan_no(&no[i + comp_len], npg, count, &i)); + else + return(True); +} + +Local Logical +scan_roman_upper(unsigned char no[], short npg[], short *count) + +{ + short i = 0; + int inp = 0; + int prev = 0; + int the_new; + + while((no[i] != EOS) && (i < ROMAN_MAX) && (!IS_COMPOSITOR)) + { + if((IS_ROMAN_UPPER(no[i])) && + ((the_new = ROMAN_UPPER_VAL(no[i])) != 0)) + { + if(prev == 0) + prev = the_new; + else + { + if(prev < the_new) + { + prev = the_new - prev; + the_new = 0; + } + inp += prev; + prev = the_new; + } + } + else + { + Idx_Error("Illegal Roman number: position %d in %s.\n", i + 1, no); + return(False); + } + i++; + } + if(i == ROMAN_MAX) + { + Idx_Error("Roman page number %s too big (max %d digits).\n", + no, ROMAN_MAX); + return(False); + } + inp += prev; + + if(*count >= PAGEFIELD_MAX) + { + Idx_Error("Page number %s has too many fields (max. %d).", + no, PAGEFIELD_MAX); + return(False); + } + npg[*count] = (inp + page_offset[ROMU]); + ++*count; + + if(IS_COMPOSITOR) + return(scan_no(&no[i + comp_len], npg, count, &i)); + else + return(True); +} + +Local Logical +scan_alpha_lower(unsigned char no[], short npg[], short *count) + +{ + short i; + + if(*count >= PAGEFIELD_MAX) + { + Idx_Error("Page number %s has too many fields (max. %d).", + no, PAGEFIELD_MAX); + return(False); + } + npg[*count] = (ALPHA_VAL(no[0]) + page_offset[ALPL]); + ++*count; + + i = 1; + if(IS_COMPOSITOR) + return(scan_no(&no[comp_len + 1], npg, count, &i)); + else + return(True); +} + +Local Logical +scan_alpha_upper(unsigned char no[], short npg[], short *count) + +{ + short i; + + if(*count >= PAGEFIELD_MAX) + { + Idx_Error("Page number %s has too many fields (max. %d).", + no, PAGEFIELD_MAX); + return(False); + } + npg[*count] = (ALPHA_VAL(no[0]) + page_offset[ALPU]); + ++*count; + + i = 1; + if(IS_COMPOSITOR) + return(scan_no(&no[comp_len + 1], npg, count, &i)); + else + return(True); +} + +Local Logical +scan_arg1(VOID_ARG) + +{ + int i = 0; + int n = 0; /* delimiter count */ + int a; + + if(compress_blanks) + while(((a = GET_CHAR(idx_fp)) == SPC) || (a == TAB)) + ; + else + a = GET_CHAR(idx_fp); + + while((i < ARGUMENT_MAX) && (a != EOF)) + { + if((a == idx_quote) || (a == idx_escape)) + { /* take next character literally */ + key[i++] = (char) a; /* but preserve quote or escape */ + a = GET_CHAR(idx_fp); + key[i++] = (unsigned char)a; /* save literal character */ + } + else if(a == idx_aopen) + { /* opening delimiters within the argument list */ + key[i++] = (unsigned char)a; + n++; + } + else if(a == idx_aclose) + { + if(n == 0) /* end of argument */ + { + if(compress_blanks && key[i - 1] == SPC) + key[i - 1] = EOS; + else + key[i] = EOS; + return(True); + } + else /* nested delimiters */ + { + key[i++] = (unsigned char) a; + n--; + } + } + else + { + switch(a) + { + case LFD: + idx_lc++; + Idx_Error("Incomplete first argument (premature LFD).\n"); + return(False); + case TAB: + case SPC: + /* compress successive SPC's to one SPC */ + if(compress_blanks) + { + if((i > 0) && (key[i - 1] != SPC) && + (key[i - 1] != TAB)) + key[i++] = SPC; + break; + } + default: + key[i++] = (unsigned char) a; + break; + } + } + a = GET_CHAR(idx_fp); + } + + flush_to_eol(); /* Skip to end of line */ + idx_lc++; + Idx_Error("First argument too long (max %d).\n", ARGUMENT_MAX); + return(False); +} + +Local Logical +scan_arg2(VOID_ARG) + +{ + int i = 0; + int a; + int hit_blank = False; + + while(((a = GET_CHAR(idx_fp)) == SPC) || (a == TAB)) + ; + + while(i < NUMBER_MAX) + { + if(a == idx_aclose) + { + no[i] = EOS; + return(True); + } + else + switch(a) + { + case LFD: + idx_lc++; + Idx_Error("Incomplete second argument (premature LFD).\n"); + return(False); + case TAB: + case SPC: + hit_blank = True; + break; + default: + if(hit_blank) + { + flush_to_eol(); /* Skip to end of line */ + idx_lc++; + Idx_Error("Illegal space within numerals in second " \ + "argument.\n"); + return(False); + } + no[i++] = (char)a; + break; + } + a = GET_CHAR(idx_fp); + } + flush_to_eol(); /* Skip to end of line */ + idx_lc++; + Idx_Error("Second argument too long (max %d).\n", NUMBER_MAX); + return(False); +} + +Local void +Idx_Error(const char *fmt, ...) + +{ + va_list arg_ptr; + + va_start(arg_ptr, fmt); + if(idx_dot) + { + fprintf(ilg_fp, "\n"); + idx_dot = False; + } + fprintf(ilg_fp, +#if KCC_20 + "!! Input index error (file = %s, line = %d):\n\040\040 -- ", +#else + "!! Input index error (file = %s, line = %d):\n -- ", +#endif + idx_fn, idx_lc); + vfprintf(ilg_fp, fmt, arg_ptr); + va_end(arg_ptr); + idx_ec++; +} + +Local int +Idx_Skipline(VOID_ARG) + +{ + int tmp; + + while((tmp = GET_CHAR(idx_fp)) != LFD) + if(tmp == EOF) + break; + idx_lc++; + return(-1); +} diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/scanid.h b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/scanid.h new file mode 100644 index 0000000..c95ca1a --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/scanid.h @@ -0,0 +1,93 @@ +/* + * + * This file is part of + * MakeIndex - A formatter and format independent index processor + * + * Copyright (C) 1989 by Chen & Harrison International Systems, Inc. + * Copyright (C) 1988 by Olivetti Research Center + * Copyright (C) 1987 by Regents of the University of California + * + * Author: + * Pehong Chen + * Chen & Harrison International Systems, Inc. + * Palo Alto, California + * USA + * (phc@renoir.berkeley.edu or chen@orc.olivetti.com) + * + * Contributors: + * Please refer to the CONTRIB file that comes with this release + * for a list of people who have contributed to this and/or previous + * release(s) of MakeIndex. + * + * All rights reserved by the copyright holders. See the copyright + * notice distributed with this software for a complete description of + * the conditions under which it is made available. + * + */ + +#define IS_COMPOSITOR (mystrncmp((unsigned char *)&no[i], (unsigned char *)page_comp, comp_len) == 0) + +#define ROMAN_I 'I' +#define ROMAN_V 'V' +#define ROMAN_X 'X' +#define ROMAN_L 'L' +#define ROMAN_C 'C' +#define ROMAN_D 'D' +#define ROMAN_M 'M' + +#define ROMAN_i 'i' +#define ROMAN_v 'v' +#define ROMAN_x 'x' +#define ROMAN_l 'l' +#define ROMAN_c 'c' +#define ROMAN_d 'd' +#define ROMAN_m 'm' + +#define VAL_I 1 +#define VAL_V 5 +#define VAL_X 10 +#define VAL_L 50 +#define VAL_C 100 +#define VAL_D 500 +#define VAL_M 1000 + +#define ROMAN_LOWER_VAL(C) \ + ((C == ROMAN_i) ? VAL_I : \ + (C == ROMAN_v) ? VAL_V : \ + (C == ROMAN_x) ? VAL_X : \ + (C == ROMAN_l) ? VAL_L : \ + (C == ROMAN_c) ? VAL_C : \ + (C == ROMAN_d) ? VAL_D : \ + (C == ROMAN_m) ? VAL_M : 0) + +#define ROMAN_UPPER_VAL(C) \ + ((C == ROMAN_I) ? VAL_I : \ + (C == ROMAN_V) ? VAL_V : \ + (C == ROMAN_X) ? VAL_X : \ + (C == ROMAN_L) ? VAL_L : \ + (C == ROMAN_C) ? VAL_C : \ + (C == ROMAN_D) ? VAL_D : \ + (C == ROMAN_M) ? VAL_M : 0) + +#define IS_ROMAN_LOWER(C) \ + ((C == ROMAN_i) || (C == ROMAN_v) || (C == ROMAN_x) || \ + (C == ROMAN_l) || (C == ROMAN_c) || (C == ROMAN_d) || (C == ROMAN_m)) + +#define IS_ROMAN_UPPER(C) \ + ((C == ROMAN_I) || (C == ROMAN_V) || (C == ROMAN_X) || \ + (C == ROMAN_L) || (C == ROMAN_C) || (C == ROMAN_D) || (C == ROMAN_M)) + +#if (OS_MVSXA) +#define ALPHA_VAL(C) ((isalpha(C)) ? (mystrchr(UPCC,mytoupper(C))-UPCC) : 0) + +#define IS_ALPHA_LOWER(C) (isalpha(C) && islower(C)) + +#define IS_ALPHA_UPPER(C) (isalpha(C) && isupper(C)) +#else +#define IS_ALPHA_LOWER(C) islower(C) +#define IS_ALPHA_UPPER(C) isupper(C) +#define ALPHA_VAL(C) \ + ((('A' <= C) && (C <= 'Z')) ? C - 'A' : \ + (('a' <= C) && (C <= 'z')) ? C - 'a' : 0) +#endif /* OS_MVSXA */ + diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/scanst.c b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/scanst.c new file mode 100644 index 0000000..5f3b436 --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/scanst.c @@ -0,0 +1,755 @@ +/* + * + * This file is part of + * MakeIndex - A formatter and format independent index processor + * + * Copyright (C) 1989 by Chen & Harrison International Systems, Inc. + * Copyright (C) 1988 by Olivetti Research Center + * Copyright (C) 1987 by Regents of the University of California + * + * Author: + * Pehong Chen + * Chen & Harrison International Systems, Inc. + * Palo Alto, California + * USA + * (phc@renoir.berkeley.edu or chen@orc.olivetti.com) + * + * Contributors: + * Please refer to the CONTRIB file that comes with this release + * for a list of people who have contributed to this and/or previous + * release(s) of MakeIndex. + * + * All rights reserved by the copyright holders. See the copyright + * notice distributed with this software for a complete description of + * the conditions under which it is made available. + * + */ + +#include "mkind.h" +#include +#include "scanst.h" + +Local int sty_lc = 0; /* line count */ +Local int sty_tc = 0; /* total count */ +Local int sty_ec = 0; /* error count */ + +Public unsigned char idx_keyword[ARRAY_MAX] = IDX_KEYWORD; +Public char idx_aopen = IDX_AOPEN; +Public char idx_aclose = IDX_ACLOSE; +Public char idx_level = IDX_LEVEL; +Public char idx_ropen = IDX_ROPEN; +Public char idx_rclose = IDX_RCLOSE; +Public char idx_quote = IDX_QUOTE; +Public char idx_actual = IDX_ACTUAL; +Public char idx_encap = IDX_ENCAP; +Public char idx_escape = IDX_ESCAPE; + +Public char preamble[ARRAY_MAX] = PREAMBLE_DEF; +Public char postamble[ARRAY_MAX] = POSTAMBLE_DEF; +Public int prelen = PREAMBLE_LEN; +Public int postlen = POSTAMBLE_LEN; + +Public char setpage_open[ARRAY_MAX] = SETPAGEOPEN_DEF; +Public char setpage_close[ARRAY_MAX] = SETPAGECLOSE_DEF; +Public int setpagelen = SETPAGE_LEN; + +Public char group_skip[ARRAY_MAX] = GROUPSKIP_DEF; +Public int skiplen = GROUPSKIP_LEN; + +Public int headings_flag = HEADINGSFLAG_DEF; +Public char heading_pre[ARRAY_MAX] = HEADINGPRE_DEF; +Public char heading_suf[ARRAY_MAX] = HEADINGSUF_DEF; +Public int headprelen = HEADINGPRE_LEN; +Public int headsuflen = HEADINGSUF_LEN; + +Public char symhead_pos[ARRAY_MAX] = SYMHEADPOS_DEF; +Public char symhead_neg[ARRAY_MAX] = SYMHEADNEG_DEF; + +Public char numhead_pos[ARRAY_MAX] = NUMHEADPOS_DEF; +Public char numhead_neg[ARRAY_MAX] = NUMHEADNEG_DEF; + +Public char item_r[FIELD_MAX][ARRAY_MAX] = {ITEM0_DEF, ITEM1_DEF, ITEM2_DEF, + ITEM3_DEF}; +Public char item_u[FIELD_MAX][ARRAY_MAX] = {"", ITEM1_DEF, ITEM2_DEF, + ITEM3_DEF}; +Public char item_x[FIELD_MAX][ARRAY_MAX] = {"", ITEM1_DEF, ITEM2_DEF, + ITEM3_DEF}; + +Public int ilen_r[FIELD_MAX] = {ITEM_LEN, ITEM_LEN, ITEM_LEN, ITEM_LEN}; +Public int ilen_u[FIELD_MAX] = {0, ITEM_LEN, ITEM_LEN, ITEM_LEN}; +Public int ilen_x[FIELD_MAX] = {0, ITEM_LEN, ITEM_LEN, ITEM_LEN}; + +Public char delim_p[FIELD_MAX][ARRAY_MAX] = {DELIM_DEF, DELIM_DEF, DELIM_DEF, + DELIM_DEF}; +Public char delim_n[ARRAY_MAX] = DELIM_DEF; + /* page number separator */ +Public char delim_r[ARRAY_MAX] = DELIMR_DEF; + /* page range designator */ +Public char delim_t[ARRAY_MAX] = DELIMT_DEF; + /* page list terminating delimiter */ + +Public char suffix_2p[ARRAY_MAX] = ""; /* suffix for two page ranges */ +Public char suffix_3p[ARRAY_MAX] = ""; /* suffix for three page ranges*/ +Public char suffix_mp[ARRAY_MAX] = ""; + /* suffix for multiple page ranges */ + +Public char encap_p[ARRAY_MAX] = ENCAP0_DEF; /* encapsulator prefix */ +Public char encap_i[ARRAY_MAX] = ENCAP1_DEF; /* encapsulator infix */ +Public char encap_s[ARRAY_MAX] = ENCAP2_DEF; /* encapsulator postfix */ + +Public int linemax = LINE_MAX; + +Public int indent_length = INDENTLEN_DEF; +Public char indent_space[ARRAY_MAX] = INDENTSPC_DEF; + +Public char page_comp[ARRAY_MAX] = COMPOSITOR_DEF; +Public int page_offset[PAGETYPE_MAX] = + { + 0, + ROMAN_LOWER_OFFSET, + ROMAN_LOWER_OFFSET + ARABIC_OFFSET, + ROMAN_LOWER_OFFSET + ARABIC_OFFSET + ALPHA_LOWER_OFFSET, + ROMAN_LOWER_OFFSET + ARABIC_OFFSET + ALPHA_LOWER_OFFSET + ROMAN_UPPER_OFFSET + }; + +Local char page_prec[ARRAY_MAX] = PRECEDENCE_DEF; + +Local int put_dot; + +Local void Sty_Error_prec(const char ch, const char *str); +Local void Sty_Error(const char *F, ...); +Local void Sty_Skipline (void); +Local int count_lfd (char *str); +Local int next_nonblank (void); +Local Logical process_precedence (void); +Local Logical scan_char (unsigned char *c); +Local Logical scan_spec (unsigned char *spec); +Local Logical scan_string (unsigned char *str); + +Public void +scan_sty(VOID_ARG) + +{ + unsigned char *spec; + int tmp; + + if((spec = (unsigned char *)calloc(1, STRING_MAX)) == NULL) + Fatal("Not enough core...abort.\n"); + Message("Scanning style file %s...", sty_fn); + while(scan_spec(spec)) + { + sty_tc++; + put_dot = True; + + /* output pre- and post-ambles */ + if(STREQ(spec, PREAMBLE)) + { + (void) scan_string((unsigned char *)preamble); + prelen = count_lfd(preamble); + } + else if(STREQ(spec, POSTAMBLE)) + { + (void) scan_string((unsigned char *)postamble); + postlen = count_lfd(postamble); + } + else if(STREQ(spec, GROUP_SKIP)) + { + (void) scan_string((unsigned char *)group_skip); + skiplen = count_lfd(group_skip); + } + + else if(STREQ(spec, HEADINGS_FLAG)) + fscanf(sty_fp, "%d", &headings_flag); + else if(STREQ(spec, HEADING_PRE)) + { + (void) scan_string((unsigned char *)heading_pre); + headprelen = count_lfd(heading_pre); + } + else if(STREQ(spec, HEADING_SUF)) + { + (void) scan_string((unsigned char *)heading_suf); + headsuflen = count_lfd(heading_suf); + } + else if(STREQ(spec, SYMHEAD_POS)) + { + (void) scan_string((unsigned char *)symhead_pos); + } + else if(STREQ(spec, SYMHEAD_NEG)) + { + (void) scan_string((unsigned char *)symhead_neg); + } + else if(STREQ(spec, NUMHEAD_POS)) + { + (void) scan_string((unsigned char *)numhead_pos); + } + else if(STREQ(spec, NUMHEAD_NEG)) + { + (void) scan_string((unsigned char *)numhead_neg); + } + else if(STREQ(spec, SETPAGEOPEN)) + { + (void) scan_string((unsigned char *)setpage_open); + setpagelen = count_lfd(setpage_open); + } + else if(STREQ(spec, SETPAGECLOSE)) + { + (void) scan_string((unsigned char *)setpage_close); + setpagelen = count_lfd(setpage_close); + /* output index item commands */ + } + else if(STREQ(spec, ITEM_0)) + { + (void) scan_string((unsigned char *)item_r[0]); + ilen_r[0] = count_lfd(item_r[0]); + } + else if(STREQ(spec, ITEM_1)) + { + (void) scan_string((unsigned char *)item_r[1]); + ilen_r[1] = count_lfd(item_r[1]); + } + else if(STREQ(spec, ITEM_2)) + { + (void) scan_string((unsigned char *)item_r[2]); + ilen_r[2] = count_lfd(item_r[2]); + } + else if(STREQ(spec, ITEM_01)) + { + (void) scan_string((unsigned char *)item_u[1]); + ilen_u[1] = count_lfd(item_u[1]); + } + else if(STREQ(spec, ITEM_12)) + { + (void) scan_string((unsigned char *)item_u[2]); + ilen_u[2] = count_lfd(item_u[2]); + } + else if(STREQ(spec, ITEM_x1)) + { + (void) scan_string((unsigned char *)item_x[1]); + ilen_x[1] = count_lfd(item_x[1]); + } + else if(STREQ(spec, ITEM_x2)) + { + (void) scan_string((unsigned char *)item_x[2]); + ilen_x[2] = count_lfd(item_x[2]); + /* output encapsulators */ + } + else if(STREQ(spec, ENCAP_0)) + (void) scan_string((unsigned char *)encap_p); + else if(STREQ(spec, ENCAP_1)) + (void) scan_string((unsigned char *)encap_i); + else if(STREQ(spec, ENCAP_2)) + (void) scan_string((unsigned char *)encap_s); + /* output delimiters */ + else if(STREQ(spec, DELIM_0)) + (void) scan_string((unsigned char *)delim_p[0]); + else if(STREQ(spec, DELIM_1)) + (void) scan_string((unsigned char *)delim_p[1]); + else if(STREQ(spec, DELIM_2)) + (void) scan_string((unsigned char *)delim_p[2]); + else if(STREQ(spec, DELIM_N)) + (void) scan_string((unsigned char *)delim_n); + else if(STREQ(spec, DELIM_R)) + (void) scan_string((unsigned char *)delim_r); + else if(STREQ(spec, DELIM_T)) + (void) scan_string((unsigned char *)delim_t); + else if(STREQ(spec, SUFFIX_2P)) + (void) scan_string((unsigned char *)suffix_2p); + else if(STREQ(spec, SUFFIX_3P)) + (void) scan_string((unsigned char *)suffix_3p); + else if(STREQ(spec, SUFFIX_MP)) + (void) scan_string((unsigned char *)suffix_mp); + /* output line width */ + else if(STREQ(spec, LINEMAX)) + { + fscanf(sty_fp, "%d", &tmp); + if(tmp > 0) + linemax = tmp; + else + Sty_Error("%s must be positive (got %d)", LINEMAX, tmp); + /* output line indentation length */ + } + else if(STREQ(spec, INDENT_LENGTH)) + { + fscanf(sty_fp, "%d", &tmp); + if(tmp >= 0) + indent_length = tmp; + else + Sty_Error("%s must be nonnegative (got %d)", INDENT_LENGTH, + tmp); + /* output line indentation */ + } + else if(STREQ(spec, INDENT_SPACE)) + { + (void) scan_string((unsigned char *)indent_space); + /* composite page delimiter */ + } + else if(STREQ(spec, COMPOSITOR)) + { + (void) scan_string((unsigned char *)page_comp); + /* page precedence */ + } + else if(STREQ(spec, PRECEDENCE)) + { + (void) scan_string((unsigned char *)page_prec); + (void) process_precedence(); + /* index input format */ + } + else if(STREQ(spec, KEYWORD)) + (void) scan_string(idx_keyword); + else if(STREQ(spec, AOPEN)) + (void) scan_char((unsigned char *)&idx_aopen); + else if(STREQ(spec, ACLOSE)) + (void) scan_char((unsigned char *)&idx_aclose); + else if(STREQ(spec, LEVEL)) + (void) scan_char((unsigned char *)&idx_level); + else if(STREQ(spec, ROPEN)) + (void) scan_char((unsigned char *)&idx_ropen); + else if(STREQ(spec, RCLOSE)) + (void) scan_char((unsigned char *)&idx_rclose); + else if(STREQ(spec, QUOTE)) + (void) scan_char((unsigned char *)&idx_quote); + else if(STREQ(spec, ACTUAL)) + (void) scan_char((unsigned char *)&idx_actual); + else if(STREQ(spec, ENCAP)) + (void) scan_char((unsigned char *)&idx_encap); + else if(STREQ(spec, ESCAPE)) + (void) scan_char((unsigned char *)&idx_escape); + else + { + (void) next_nonblank(); + Sty_Skipline(); + Sty_Error("Unknown specifier %s.\n", spec); + put_dot = False; + } + if(put_dot) + { + idx_dot = True; + Message(DOT); + } + } + + /* check if quote and escape are distinct */ + if(idx_quote == idx_escape) + { + Sty_Error( + "Quote and escape symbols must be distinct (both `%c' now).\n", + idx_quote); + idx_quote = IDX_QUOTE; + idx_escape = IDX_ESCAPE; + } + CLOSE(sty_fp); + free(spec); + Message("done (%d %s, %d %s).\n", sty_tc - sty_ec, "attributes redefined", + sty_ec, "ignored"); +} + +Local Logical +scan_spec(unsigned char spec[]) + +{ + int i = 0; + int c; + + while(True) + if((c = next_nonblank()) == -1) + return(False); + else if(c == COMMENT) + Sty_Skipline(); + else + break; + + spec[0] = TOLOWER(c); + while((i++ < STRING_MAX) && ((c = GET_CHAR(sty_fp)) != SPC) && + (c != TAB) && (c != LFD) && (c != EOF)) + spec[i] = TOLOWER(c); + if(i < STRING_MAX) + { + spec[i] = EOS; + if(c == EOF) + { + Sty_Error("No attribute for specifier %s (premature EOF)\n", spec); + return(False); + } + if(c == LFD) + sty_lc++; + return(True); + } + else + { + Sty_Error("Specifier %s too long (max %d).\n", spec, STRING_MAX); + return(False); + } +} + +Local int +next_nonblank(VOID_ARG) + +{ + int c; + + while(True) + { + switch(c = GET_CHAR(sty_fp)) + { + case EOF: + return(-1); + case LFD: + sty_lc++; + case SPC: + case TAB: + break; + default: + return(c); + } + } +} + +Local Logical +scan_string(unsigned char str[]) + +{ + char *clone; + int i = 0; + int c; + + if((clone = (char *) calloc(1, ARRAY_MAX)) == NULL) + Fatal("Not enough core...abort.\n"); + switch(c = next_nonblank()) + { + case STR_DELIM: + while(True) + switch(c = GET_CHAR(sty_fp)) + { + case EOF: + Sty_Error("No closing delimiter in %s.\n", clone); + free(clone); + return(False); + case STR_DELIM: + clone[i] = EOS; + strcpy((char *)str, clone); + free(clone); + return(True); + case BSH: + switch(c = GET_CHAR(sty_fp)) + { + case 't': + clone[i++] = TAB; + break; + case 'n': + clone[i++] = LFD; + break; + + default: + clone[i++] = (char) c; + } + break; + default: + if(c == LFD) + sty_lc++; + if(i < ARRAY_MAX) + clone[i++] = (char) c; + else + { + Sty_Skipline(); + Sty_Error( + "Attribute string %s too long (max %d).\n", + clone, ARRAY_MAX); + free(clone); + return(False); + } + } + case COMMENT: + Sty_Skipline(); + break; + default: + Sty_Skipline(); + Sty_Error("No opening delimiter.\n"); + free(clone); + return(False); + } + free(clone); + return(True); /* function value no longer used */ +} + +Local Logical +scan_char(unsigned char *c) + +{ + int clone; + + switch(clone = next_nonblank()) + { + case CHR_DELIM: + switch(clone = GET_CHAR(sty_fp)) + { + case CHR_DELIM: + Sty_Skipline(); + Sty_Error("Premature closing delimiter.\n"); + return(False); + case LFD: + sty_lc++; + case EOF: + Sty_Error("No character (premature EOF).\n"); + return(False); + case BSH: + clone = GET_CHAR(sty_fp); + default: + if(GET_CHAR(sty_fp) == CHR_DELIM) + { + *c = (char) clone; + return(True); + } + else + { + Sty_Error("No closing delimiter or too many letters.\n"); + return(False); + } + } + /* break; */ /* NOT REACHED */ + case COMMENT: + Sty_Skipline(); + break; + default: + Sty_Skipline(); + Sty_Error("No opening delimiter.\n"); + return(False); + } + return(True); /* function value no longer used */ +} + + +Local int +count_lfd(char *str) + +{ + register int i = 0; + register int n = 0; + + while(str[i] != EOS) + { + if(str[i] == LFD) + n++; + i++; + } + return(n); +} + +Local Logical +process_precedence(VOID_ARG) + +{ + int order[PAGETYPE_MAX]; + int type[PAGETYPE_MAX]; + int i = 0; + int last; + Logical roml = False; + Logical romu = False; + Logical arab = False; + Logical alpl = False; + Logical alpu = False; + + /* check for llegal specifiers first */ + + while((i < PAGETYPE_MAX) && (page_prec[i] != EOS)) + { + switch(page_prec[i]) + { + case ROMAN_LOWER: + if(roml) + { + Sty_Error_prec(ROMAN_LOWER, page_prec); + return(False); + } + else + roml = True; + break; + case ROMAN_UPPER: + if(romu) + { + Sty_Error_prec(ROMAN_UPPER, page_prec); + return(False); + } + else + romu = True; + break; + case ARABIC: + if(arab) + { + Sty_Error_prec(ARABIC, page_prec); + return(False); + } + else + arab = True; + break; + case ALPHA_LOWER: + if(alpl) + { + Sty_Error_prec(ALPHA_LOWER, page_prec); + return(False); + } + else + alpl = True; + break; + case ALPHA_UPPER: + if(alpu) + { + Sty_Error_prec(ALPHA_UPPER, page_prec); + return(False); + } + else + alpu = True; + break; + default: + Sty_Skipline(); + Sty_Error("Unknow type `%c' in page precedence " \ + "specification.\n", page_prec[i]); + return(False); + } + i++; + } + if(page_prec[i] != EOS) + { + Sty_Skipline(); + Sty_Error("Page precedence specification string too long.\n"); + return(False); + } + last = i; + switch(page_prec[0]) + { + case ROMAN_LOWER: + order[0] = ROMAN_LOWER_OFFSET; + type[0] = ROML; + break; + case ROMAN_UPPER: + order[0] = ROMAN_UPPER_OFFSET; + type[0] = ROMU; + break; + case ARABIC: + order[0] = ARABIC_OFFSET; + type[0] = ARAB; + break; + case ALPHA_LOWER: + order[0] = ALPHA_LOWER_OFFSET; + type[0] = ALPL; + break; + case ALPHA_UPPER: + order[0] = ALPHA_LOWER_OFFSET; + type[0] = ALPU; + break; + } + + i = 1; + while(i < last) + { + switch(page_prec[i]) + { + case ROMAN_LOWER: + order[i] = order[i - 1] + ROMAN_LOWER_OFFSET; + type[i] = ROML; + break; + case ROMAN_UPPER: + order[i] = order[i - 1] + ROMAN_UPPER_OFFSET; + type[i] = ROMU; + break; + case ARABIC: + order[i] = order[i - 1] + ARABIC_OFFSET; + type[i] = ARAB; + break; + case ALPHA_LOWER: + order[i] = order[i - 1] + ALPHA_LOWER_OFFSET; + type[i] = ALPL; + break; + case ALPHA_UPPER: + order[i] = order[i - 1] + ALPHA_LOWER_OFFSET; + type[i] = ALPU; + break; + } + i++; + } + + for(i = 0; i < PAGETYPE_MAX; i++) + page_offset[i] = -1; + + page_offset[type[0]] = 0; + for(i = 1; i < last; i++) + { + page_offset[type[i]] = order[i - 1]; + } + for(i = 0; i < PAGETYPE_MAX; i++) + { + if(page_offset[i] == -1) + { + switch(type[last - 1]) + { + case ROML: + order[last] = order[last - 1] + ROMAN_LOWER_OFFSET; + break; + case ROMU: + order[last] = order[last - 1] + ROMAN_UPPER_OFFSET; + break; + case ARAB: + order[last] = order[last - 1] + ARABIC_OFFSET; + break; + case ALPL: + order[last] = order[last - 1] + ALPHA_LOWER_OFFSET; + break; + case ALPU: + order[last] = order[last - 1] + ALPHA_UPPER_OFFSET; + break; + } + type[last] = i; + page_offset[i] = order[last]; + last++; + } + } + return(True); /* function value no longer used */ +} + +Local void +Sty_Skipline(VOID_ARG) + +{ + register int a; + + while(((a = GET_CHAR(sty_fp)) != LFD) && (a != EOF)) + ; + sty_lc++; +} + +Local void +Sty_Error(const char *fmt, ...) + +{ + va_list arg_ptr; + + va_start(arg_ptr, fmt); + + if(idx_dot) + { + fprintf(ilg_fp, "\n"); + idx_dot = False; + } + fprintf(ilg_fp, +#if KCC_20 + "** Input style error (file = %s, line = %d):\n\040\040 -- ", +#else + "** Input style error (file = %s, line = %d):\n -- ", +#endif /* KCC_20 */ + sty_fn, sty_lc); + vfprintf(ilg_fp, fmt, arg_ptr); + + va_end(arg_ptr); + + sty_ec++; + put_dot = False; +} + +Local void +Sty_Error_prec(const char ch, const char *str) + +{ + + Sty_Skipline(); + Sty_Error("Multiple instances of type `%c' " \ + "in page precedence specification `%s'.\n", ch, str); +} diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/scanst.h b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/scanst.h new file mode 100644 index 0000000..fe50ab1 --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/scanst.h @@ -0,0 +1,173 @@ +/* + * + * This file is part of + * MakeIndex - A formatter and format independent index processor + * + * Copyright (C) 1989 by Chen & Harrison International Systems, Inc. + * Copyright (C) 1988 by Olivetti Research Center + * Copyright (C) 1987 by Regents of the University of California + * + * Author: + * Pehong Chen + * Chen & Harrison International Systems, Inc. + * Palo Alto, California + * USA + * (phc@renoir.berkeley.edu or chen@orc.olivetti.com) + * + * Contributors: + * Please refer to the CONTRIB file that comes with this release + * for a list of people who have contributed to this and/or previous + * release(s) of MakeIndex. + * + * All rights reserved by the copyright holders. See the copyright + * notice distributed with this software for a complete description of + * the conditions under which it is made available. + * + */ + +#define COMMENT '%' +#define STR_DELIM '"' +#define CHR_DELIM '\'' + +#define KEYWORD "keyword" +#define AOPEN "arg_open" +#define ACLOSE "arg_close" +#define ROPEN "range_open" +#define RCLOSE "range_close" +#define LEVEL "level" +#define QUOTE "quote" +#define ACTUAL "actual" +#define ENCAP "encap" +#define ESCAPE "escape" + +#define IDX_KEYWORD "\\indexentry" +#define IDX_AOPEN '{' +#define IDX_ACLOSE '}' +#define IDX_ROPEN '(' +#define IDX_RCLOSE ')' +#define IDX_LEVEL '!' +#define IDX_QUOTE '"' +#define IDX_ACTUAL '@' +#define IDX_ENCAP '|' +#define IDX_ESCAPE '\\' + +#define COMPOSITOR "page_compositor" +#define COMPOSITOR_DEF "--" +#define PRECEDENCE "page_precedence" +#define PRECEDENCE_DEF "rnaRA" +#define ROMAN_LOWER 'r' +#define ROMAN_UPPER 'R' +#define ARABIC 'n' +#define ALPHA_LOWER 'a' +#define ALPHA_UPPER 'A' +#define ROMAN_LOWER_OFFSET 10000 +#define ROMAN_UPPER_OFFSET 10000 +#define ARABIC_OFFSET 10000 +#define ALPHA_LOWER_OFFSET 26 +#define ALPHA_UPPER_OFFSET 26 + +#define PREAMBLE "preamble" +#define PREAMBLE_DEF "\\begin{theindex}\n" +#define PREAMBLE_LEN 1 +#define POSTAMBLE "postamble" +#define POSTAMBLE_DEF "\n\n\\end{theindex}\n" +#define POSTAMBLE_LEN 3 + +#define SETPAGEOPEN "setpage_prefix" +#define SETPAGECLOSE "setpage_suffix" + +#if KCC_20 +/* KCC preprocessor bug collapses multiple blanks to single blank */ +#define SETPAGEOPEN_DEF "\n\040\040\\setcounter{page}{" +#else +#define SETPAGEOPEN_DEF "\n \\setcounter{page}{" +#endif /* KCC_20 */ + +#define SETPAGECLOSE_DEF "}\n" +#define SETPAGE_LEN 2 + +#define GROUP_SKIP "group_skip" +#if KCC_20 +/* KCC preprocessor bug collapses multiple blanks to single blank */ +#define GROUPSKIP_DEF "\n\n\040\040\\indexspace\n" +#else +#define GROUPSKIP_DEF "\n\n \\indexspace\n" +#endif /* KCC_20 */ +#define GROUPSKIP_LEN 3 + +#define HEADINGS_FLAG "headings_flag" +#define HEADINGSFLAG_DEF 0 +#define HEADING_PRE "heading_prefix" +#define HEADINGPRE_DEF "" +#define HEADINGPRE_LEN 0 +#define HEADING_SUF "heading_suffix" +#define HEADINGSUF_DEF "" +#define HEADINGSUF_LEN 0 +#define SYMHEAD_POS "symhead_positive" +#define SYMHEADPOS_DEF "Symbols" +#define SYMHEAD_NEG "symhead_negative" +#define SYMHEADNEG_DEF "symbols" +#define NUMHEAD_POS "numhead_positive" +#define NUMHEADPOS_DEF "Numbers" +#define NUMHEAD_NEG "numhead_negative" +#define NUMHEADNEG_DEF "numbers" + +#define ITEM_0 "item_0" +#define ITEM_1 "item_1" +#define ITEM_2 "item_2" +#define ITEM_3 "item_3" +#define ITEM_01 "item_01" +#define ITEM_x1 "item_x1" +#define ITEM_12 "item_12" +#define ITEM_x2 "item_x2" +#define ITEM_23 "item_23" +#define ITEM_x3 "item_x3" + +#if KCC_20 +/* KCC preprocessor bug collapses multiple blanks to single blank */ +#define ITEM0_DEF "\n\040\040\\item\040" +#define ITEM1_DEF "\n\040\040\040\040\\subitem\040" +#define ITEM2_DEF "\n\040\040\040\040\040\040\\subsubitem\040" +#define ITEM3_DEF "\n\040\040\040\040\040\040\\subsubsubitem\040" +#else +#define ITEM0_DEF "\n \\item " +#define ITEM1_DEF "\n \\subitem " +#define ITEM2_DEF "\n \\subsubitem " +#define ITEM3_DEF "\n \\subsubsubitem " +#endif /* KCC_20 */ + +#define ITEM_LEN 1 + +#define DELIM_0 "delim_0" +#define DELIM_1 "delim_1" +#define DELIM_2 "delim_2" +#define DELIM_3 "delim_3" +#define DELIM_N "delim_n" +#define DELIM_R "delim_r" +#define DELIM_T "delim_t" +#define DELIM_DEF ", " +#define DELIMR_DEF "--" +#define DELIMT_DEF "" + +#define SUFFIX_2P "suffix_2p" +#define SUFFIX_3P "suffix_3p" +#define SUFFIX_MP "suffix_mp" + +#define ENCAP_0 "encap_prefix" +#define ENCAP_1 "encap_infix" +#define ENCAP_2 "encap_suffix" +#define ENCAP0_DEF "\\" +#define ENCAP1_DEF "{" +#define ENCAP2_DEF "}" + +#define LINEMAX "line_max" +#define INDENT_SPACE "indent_space" +#define INDENT_LENGTH "indent_length" + +#if (OS_MVSXA) +#define INDENTSPC_DEF " " +#else +#define INDENTSPC_DEF "\t\t" +#endif /* OS_MVSXA */ + +#define INDENTLEN_DEF 16 diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/sortid.c b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/sortid.c new file mode 100644 index 0000000..94516df --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/sortid.c @@ -0,0 +1,278 @@ +/* + * + * This file is part of + * MakeIndex - A formatter and format independent index processor + * + * Copyright (C) 1989 by Chen & Harrison International Systems, Inc. + * Copyright (C) 1988 by Olivetti Research Center + * Copyright (C) 1987 by Regents of the University of California + * + * Author: + * Pehong Chen + * Chen & Harrison International Systems, Inc. + * Palo Alto, California + * USA + * (phc@renoir.berkeley.edu or chen@orc.olivetti.com) + * + * Contributors: + * Please refer to the CONTRIB file that comes with this release + * for a list of people who have contributed to this and/or previous + * release(s) of MakeIndex. + * + * All rights reserved by the copyright holders. See the copyright + * notice distributed with this software for a complete description of + * the conditions under which it is made available. + * + */ + +#include "mkind.h" + +Local long idx_gc; + +Local int check_mixsym (unsigned char *x, unsigned char *y); +Local int compare (struct KFIELD * *a,struct KFIELD * *b); +Local int compare_one (unsigned char *x, unsigned char *y); +Local int compare_page (struct KFIELD * *a,struct KFIELD * *b); +Local int compare_string (unsigned char *a,unsigned char *b); + +Public void +sort_idx(VOID_ARG) + +{ + Message("Sorting entries..."); + idx_dc = 0; + idx_gc = 0L; + qqsort((char *) idx_key, (int) idx_gt, (int) sizeof(FIELD_PTR), + (int (*) (char*, char*))compare); + Message("done (%ld comparisons).\n", idx_gc); +} + +Local int +compare(FIELD_PTR *a, FIELD_PTR *b) + +{ + int i; + int dif; + + idx_gc++; + idx_dot = True; + if(idx_dc++ == 0) + Message(DOT); + if(idx_dc == CMP_MAX) + idx_dc = 0; + + for(i = 0; i < FIELD_MAX; i++) + { + /* compare the sort fields */ + if((dif = compare_one((*a)->sf[i], (*b)->sf[i])) != 0) + break; + + if((dif = compare_one((*a)->af[i], (*b)->af[i])) != 0) + break; + } + + /* both key aggregates are identical, compare page numbers */ + if(i == FIELD_MAX) + dif = compare_page(a, b); + return(dif); +} + +Local int +compare_one(unsigned char *x, unsigned char *y) + +{ + int m; + int n; + + if((x[0] == EOS) && (y[0] == EOS)) + return(0); + + if(x[0] == EOS) + return(-1); + + if(y[0] == EOS) + return(1); + + m = group_type(x); + n = group_type(y); + + /* both pure digits */ + if((m >= 0) && (n >= 0)) + return(m - n); + + /* x digit, y non-digit */ + if(m >= 0) + return((n == -1) ? 1 : -1); + /* x non-digit, y digit */ + if(n >= 0) + return((m == -1) ? -1 : 1); + /* strings started with a symbol (including digit) */ + if((m == SYMBOL) && (n == SYMBOL)) + return(check_mixsym(x, y)); + + /* x symbol, y non-symbol */ + if(m == SYMBOL) + return(-1); + + /* x non-symbol, y symbol */ + if(n == SYMBOL) + return(1); + + /* strings with a leading letter, the ALPHA type */ + + return(compare_string((unsigned char*)x, (unsigned char*)y)); +} + +Local int +check_mixsym(unsigned char *x, unsigned char *y) + +{ + int m; + int n; + + m = ISDIGIT(x[0]); + n = ISDIGIT(y[0]); + + if(m && !n) + return(1); + + if(!m && n) + return(-1); + + return(mystrcmp(x, y)); +} + + +Local int +compare_string(unsigned char *a, unsigned char *b) + +{ + int i = 0; + int j = 0; + unsigned char al; + unsigned char bl; + + while((a[i] != EOS) || (b[j] != EOS)) + { + if(a[i] == EOS) + return(-1); + if(b[j] == EOS) + return(1); + + if(blank_ignore) + { + if(a[i] == SPC) + i++; + if(b[j] == SPC) + j++; + } + al = TOLOWER(a[i]); + bl = TOLOWER(b[j]); + + if(al != bl) + return(charcmp(al, bl)); + i++; + j++; + } + return(mystrcmp(a, b)); +} + +Local int +compare_page(FIELD_PTR *a, FIELD_PTR *b) + +{ + int m = 0; + short i = 0; + + while((i < (*a)->count) && (i < (*b)->count) && + ((m = (*a)->npg[i] - (*b)->npg[i]) == 0)) + { + i++; + } + if(m == 0) + { /* common leading page numbers match */ + if((i == (*a)->count) && (i == (*b)->count)) + { /* all page numbers match */ + + /*********************************************************** + We have identical entries, except possibly in encap fields. + The ordering is tricky here. Consider the following input + sequence of index names, encaps, and page numbers: + + foo|( 2 + foo|) 6 + foo|( 6 + foo|) 10 + + This might legimately occur when a page range ends, and + subsequently, a new range starts, on the same page. If we + just order by range_open and range_close (here, parens), + then we will produce + + foo|( 2 + foo|( 6 + foo|) 6 + foo|) 10 + + This will later generate the index entry + + foo, 2--6, \({6}, 10 + + which is not only wrong, but has also introduced an illegal + LaTeX macro, \({6}, because the merging step treated this + like a \see{6} entry. + + The solution is to preserve the original input order, which + we can do by treating range_open and range_close as equal, + and then ordering by input line number. This will then + generate the correct index entry + + foo, 2--10 + + Ordering inconsistencies from missing range open or close + entries, or mixing roman and arabic page numbers, will be + detected later. + ***********************************************************/ + +#define isrange(c) ( ((c) == idx_ropen) || ((c) == idx_rclose) ) + + /* Order two range values by input line number */ + + if(isrange(*(*a)->encap) && isrange(*(*b)->encap)) + m = (*a)->lc - (*b)->lc; + + /* Handle identical encap fields; neither is a range delimiter */ + + else if(STREQ((*a)->encap, (*b)->encap)) + { + /* If neither are yet marked duplicate, mark the second + of them to be ignored. */ + + if(((*a)->type != DUPLICATE) && ((*b)->type != DUPLICATE)) + (*b)->type = DUPLICATE; + + /* leave m == 0 to show equality */ + } + + /* Encap fields differ: only one may be a range delimiter, */ + /* or else neither of them is. If either of them is a range */ + /* delimiter, order by input line number; otherwise, order */ + /* by name. */ + + else + { + if(isrange(*(*a)->encap) || isrange(*(*b)->encap)) + m = (*a)->lc - (*b)->lc; /* order by input line number */ + else /* order non-range items by */ + /* their encap strings */ + m = compare_string((unsigned char*)((*a)->encap), + (unsigned char*)((*b)->encap)); + } + } + else if((i == (*a)->count) && (i < (*b)->count)) + m = -1; + else if((i < (*a)->count) && (i == (*b)->count)) + m = 1; + } + return(m); +} diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/us_eng.h b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/us_eng.h new file mode 100644 index 0000000..76082ad --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/ext/plmindex/us_eng.h @@ -0,0 +1,548 @@ +{% raw %} +static p_char_u us_day_name_ptr = + { + (char_u *)NULL, + (char_u *)"Sunday", + (char_u *)"Monday", + (char_u *)"Tuesday", + (char_u *)"Wednesday", + (char_u *)"Thursday", + (char_u *)"Friday", + (char_u *)"Saturday", + }; + +static p_char_u us_day_name_ptr_a = + { + (char_u *)NULL, + (char_u *)"Sun", + (char_u *)"Mon", + (char_u *)"Tue", + (char_u *)"Wed", + (char_u *)"Thu", + (char_u *)"Fri", + (char_u *)"Sat", + }; + +static p_char_u us_mon_name_ptr = + { + (char_u *)NULL, + (char_u *)"Januar", + (char_u *)"Februar", + (char_u *)"March", + (char_u *)"April", + (char_u *)"May", + (char_u *)"June", + (char_u *)"July", + (char_u *)"August", + (char_u *)"September", + (char_u *)"October", + (char_u *)"November", + (char_u *)"December" + }; + +static p_char_u us_mon_name_ptr_a = + { + (char_u *)NULL, + (char_u *)"Jan", + (char_u *)"Feb", + (char_u *)"Mar", + (char_u *)"Apr", + (char_u *)"May", + (char_u *)"Jun", + (char_u *)"Jul", + (char_u *)"Aug", + (char_u *)"Sep", + (char_u *)"Oct", + (char_u *)"Nov", + (char_u *)"Dec" + }; + +static int_u us_toascii_table = + { + ' ', /* 128 0x80 */ + ' ', /* 129 0x81 */ + ' ', /* 130 0x82 */ + ' ', /* 131 0x83 */ + ' ', /* 132 0x84 */ + ' ', /* 133 0x85 */ + ' ', /* 134 0x86 */ + ' ', /* 135 0x87 */ + ' ', /* 136 0x88 */ + ' ', /* 137 0x89 */ + ' ', /* 138 0x8a */ + ' ', /* 139 0x8b */ + ' ', /* 140 0x8c */ + ' ', /* 141 0x8d */ + ' ', /* 142 0x8e */ + ' ', /* 143 0x8f */ + ' ', /* 144 0x90 */ + ' ', /* 145 0x91 */ + ' ', /* 146 0x92 */ + ' ', /* 147 0x93 */ + ' ', /* 148 0x94 */ + ' ', /* 149 0x95 */ + ' ', /* 150 0x96 */ + ' ', /* 151 0x97 */ + ' ', /* 152 0x98 */ + ' ', /* 153 0x99 */ + ' ', /* 154 0x9a */ + ' ', /* 155 0x9b */ + ' ', /* 156 0x9c */ + ' ', /* 157 0x9d */ + ' ', /* 158 0x9e */ + ' ', /* 159 0x9f */ + ' ', /* 160 0xa0 */ + '!', /* 161 0xa1 */ + 'c', /* 162 0xa2 */ + 'L', /* 163 0xa3 */ + 'o', /* 164 0xa4 */ + 'Y', /* 165 0xa5 */ + '|', /* 166 0xa6 */ + 'S', /* 167 0xa7 */ + '"', /* 168 0xa8 */ + 'c', /* 169 0xa9 */ + 'a', /* 170 0xaa */ + '<', /* 171 0xab */ + ' ', /* 172 0xac */ + '-', /* 173 0xad */ + 'R', /* 174 0xae */ + '-', /* 175 0xaf */ + 'o', /* 176 0xb0 */ + '+', /* 177 0xb1 */ + '2', /* 178 0xb2 */ + '3', /* 179 0xb3 */ + '\'', /* 180 0xb4 */ + 'u', /* 181 0xb5 */ + 'P', /* 182 0xb6 */ + '.', /* 183 0xb7 */ + ',', /* 184 0xb8 */ + '1', /* 185 0xb9 */ + 'o', /* 186 0xba */ + '>', /* 187 0xbb */ + ' ', /* 188 0xbc */ + ' ', /* 189 0xbd */ + ' ', /* 190 0xbe */ + '?', /* 191 0xbf */ + 'A', /* 192 0xc0 */ + 'A', /* 193 0xc1 */ + 'A', /* 194 0xc2 */ + 'A', /* 195 0xc3 */ + 'A', /* 196 0xc4 */ + 'A', /* 197 0xc5 */ + 'A', /* 198 0xc6 */ + 'C', /* 199 0xc7 */ + 'E', /* 200 0xc8 */ + 'E', /* 201 0xc9 */ + 'E', /* 202 0xca */ + 'E', /* 203 0xcb */ + 'I', /* 204 0xcc */ + 'I', /* 205 0xcd */ + 'I', /* 206 0xce */ + 'I', /* 207 0xcf */ + 'D', /* 208 0xd0 */ + 'N', /* 209 0xd1 */ + 'O', /* 210 0xd2 */ + 'O', /* 211 0xd3 */ + 'O', /* 212 0xd4 */ + 'O', /* 213 0xd5 */ + 'O', /* 214 0xd6 */ + 'x', /* 215 0xd7 */ + '0', /* 216 0xd8 */ + 'U', /* 217 0xd9 */ + 'U', /* 218 0xda */ + 'U', /* 219 0xdb */ + 'U', /* 220 0xdc */ + 'Y', /* 221 0xdd */ + 'P', /* 222 0xde */ + 'B', /* 223 0xdf */ + 'a', /* 224 0xe0 */ + 'a', /* 225 0xe1 */ + 'a', /* 226 0xe2 */ + 'a', /* 227 0xe3 */ + 'a', /* 228 0xe4 */ + 'a', /* 229 0xe5 */ + 'a', /* 230 0xe6 */ + 'c', /* 231 0xe7 */ + 'e', /* 232 0xe8 */ + 'e', /* 233 0xe9 */ + 'e', /* 234 0xea */ + 'e', /* 235 0xeb */ + 'i', /* 236 0xec */ + 'i', /* 237 0xed */ + 'i', /* 238 0xee */ + 'i', /* 239 0xef */ + 'd', /* 240 0xf0 */ + 'n', /* 241 0xf1 */ + 'o', /* 242 0xf2 */ + 'o', /* 243 0xf3 */ + 'o', /* 244 0xf4 */ + 'o', /* 245 0xf5 */ + 'o', /* 246 0xf6 */ + ':', /* 247 0xf7 */ + 'o', /* 248 0xf8 */ + 'u', /* 249 0xf9 */ + 'u', /* 250 0xfa */ + 'u', /* 251 0xfb */ + 'u', /* 252 0xfc */ + 'y', /* 253 0xfd */ + 'p', /* 254 0xfe */ + 'Y', /* 255 0xff */ + }; + +static a_char_u us_lower_table = + { + 'a', 'b', 'c', 'd', 'e', 'f', 'g', + 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', + 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', + 'x', 'y', 'z' + }; + +static a_char_u us_upper_table = + { + 'A','B','C','D','E','F','G', + 'H','I','J','K','L','M','N','O', + + 'P','Q','R','S','T','U','V','W', + 'X','Y','Z' + }; + +static a_char_u us_char_type = + { +IS_CTR, IS_CTR, IS_CTR, IS_CTR, +IS_CTR, IS_CTR, IS_CTR, IS_CTR, +IS_CTR, IS_CTR | IS_BLANK, IS_CTR | IS_BLANK, IS_CTR | IS_BLANK, +IS_CTR | IS_BLANK, IS_CTR | IS_BLANK, IS_CTR, IS_CTR, +IS_CTR, IS_CTR, IS_CTR, IS_CTR, +IS_CTR, IS_CTR, IS_CTR, IS_CTR, +IS_CTR, IS_CTR, IS_CTR, IS_CTR, +IS_CTR, IS_CTR, IS_CTR, IS_CTR, +IS_BLANK, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +IS_XDIG | IS_DIG, IS_XDIG | IS_DIG, IS_XDIG | IS_DIG, IS_XDIG | IS_DIG, +IS_XDIG | IS_DIG, IS_XDIG | IS_DIG, IS_XDIG | IS_DIG, IS_XDIG | IS_DIG, +IS_XDIG | IS_DIG, IS_XDIG | IS_DIG, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, + +0x000, IS_XDIG | IS_UPPER,IS_XDIG | IS_UPPER,IS_XDIG | IS_UPPER, +IS_XDIG | IS_UPPER,IS_XDIG | IS_UPPER,IS_XDIG | IS_UPPER,IS_UPPER, +IS_UPPER, IS_UPPER, IS_UPPER, IS_UPPER, +IS_UPPER, IS_UPPER, IS_UPPER, IS_UPPER, +IS_UPPER, IS_UPPER, IS_UPPER, IS_UPPER, +IS_UPPER, IS_UPPER, IS_UPPER, IS_UPPER, +IS_UPPER, IS_UPPER, IS_UPPER, 0x000, +0x000, 0x000, 0x000, IS_ALPH, + +0x000, IS_XDIG | IS_LOWER,IS_XDIG | IS_LOWER,IS_XDIG | IS_LOWER, +IS_XDIG | IS_LOWER,IS_XDIG | IS_LOWER,IS_XDIG | IS_LOWER,IS_LOWER, +IS_LOWER, IS_LOWER, IS_LOWER, IS_LOWER, +IS_LOWER, IS_LOWER, IS_LOWER, IS_LOWER, +IS_LOWER, IS_LOWER, IS_LOWER, IS_LOWER, +IS_LOWER, IS_LOWER, IS_LOWER, IS_LOWER, +IS_LOWER, IS_LOWER, IS_LOWER, 0x000, +0x000, 0x000, 0x000, IS_CTR, + +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, + +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, + +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, + +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, + +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, + +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, + +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, + +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000, +0x000, 0x000, 0x000, 0x000 + }; + +static int_u us_order_tbl = + { +0, /* 0 */ +'', /* 1 */ +'', /* 2 */ +'', /* 3 */ +'', /* 4 */ +'', /* 5 */ +'', /* 6 */ +'', /* 7 */ +'', /* 8 */ +TAB, /* 9 */ + LF, /* 10 0a */ +' ', /* 11 0b */ +' ', /* 12 0c */ + CR, /* 13 0d */ +'', /* 14 0e */ +'', /* 15 0f */ +'', /* 16 10 */ +'', /* 17 11 */ +'', /* 18 12 */ +'', /* 19 13 */ +'', /* 20 14 */ +'', /* 21 15 */ +'', /* 22 16 */ +'', /* 23 17 */ +'', /* 24 18 */ +'', /* 25 19 */ +0x1a, /* 26 1a */ +'', /* 27 1b */ +'', /* 28 1c */ +'', /* 29 1d */ +'', /* 30 1e */ +'', /* 31 1f */ +' ', /* 32 20 */ +'!', /* 33 21 */ +0x22, /* 34 22 quote */ +'#', /* 35 23 */ +'$', /* 36 24 */ +'%', /* 37 25 */ +'&', /* 38 26 */ +0x27, /* 39 27 single quote */ +'(', /* 40 28 */ +')', /* 41 29 */ +'*', /* 42 2a */ +'+', /* 43 2b */ +',', /* 44 2c */ +'-', /* 45 2d */ +'.', /* 46 2e */ +'/', /* 47 2f */ +'0', /* 48 30 */ +'1', /* 49 31 */ +'2', /* 50 32 */ +'3', /* 51 33 */ +'4', /* 52 34 */ +'5', /* 53 35 */ +'6', /* 54 36 */ +'7', /* 55 37 */ +'8', /* 56 38 */ +'9', /* 57 39 */ +':', /* 58 3a */ +';', /* 59 3b */ +'<', /* 60 3c */ +'=', /* 61 3d */ +'>', /* 62 3e */ +'?', /* 63 3f */ +'@', /* 64 40 */ +'A', /* 'A', 65 41 */ +'B', /* 'B', 66 42 */ +'C', /* 'C', 67 43 */ +'D', /* 'D', 68 44 */ +'E', /* 'E', 69 45 */ +'F', /* 'F', 70 46 */ +'G', /* 'G', 71 47 */ +'H', /* 'H', 72 48 */ +'I', /* 'I', 73 49 */ +'J', /* 'J', 74 4a */ +'K', /* 'K', 75 4b */ +'L', /* 'L', 76 4c */ +'M', /* 'M', 77 4d */ +'N', /* 'N', 78 4e */ +'O', /* 'O', 79 4f */ +'P', /* 'P', 80 50 */ +'Q', /* 'Q', 81 51 */ +'R', /* 'R', 82 52 */ +'S', /* 'S', 83 53 */ +'T', /* 'T', 84 54 */ +'U', /* 'U', 85 55 */ +'V', /* 'V', 86 56 */ +'W', /* 'W', 87 57 */ +'x', /* 'X', 88 58 */ +'y', /* 'Y', 89 59 */ +'z', /* 'Z', 90 5a */ +0x5b, /* 91 5b */ +0x5c, /* 92 5c */ +0x5d, /* 93 5d ] */ +0x5e, /* 94 5e */ +'_', /* 95 5f */ +0x60, /* 96 60 ` */ +'a', /* 97 61 */ +'b', /* 98 62 */ +'c', /* 99 63 */ +'d', /* 100 64 */ +'e', /* 101 65 */ +'f', /* 102 66 */ +'g', /* 103 67 */ +'h', /* 104 68 */ +'i', /* 105 69 */ +'j', /* 106 6a */ +'k', /* 107 6b */ +'l', /* 108 6c */ +'m', /* 109 6d */ +'n', /* 110 6e */ +'o', /* 111 6f */ +'p', /* 112 70 */ +'q', /* 113 71 */ +'r', /* 114 72 */ +'s', /* 115 73 */ +'t', /* 116 74 */ +'u', /* 117 75 */ +'v', /* 118 76 */ +'w', /* 119 77 */ +'x', /* 120 78 */ +'y', /* 121 79 */ +'z', /* 122 7a */ +'{', /* 123 7b */ +'|', /* 124 7c */ +'}', /* 125 7d */ +'~', /* 126 7e */ +'', /* 127 7f */ +'\0x80', /* 128 80 */ +'\0x81', /* 129 81 */ +'\0x82', /* 130 82 */ +'\0x83', /* 131 83 */ +'\0x84', /* 132 84 */ +'\0x85', /* 133 85 */ +'\0x86', /* 134 86 */ +'\0x87', /* 135 87 */ +'\0x88', /* 136 88 */ +'\0x89', /* 137 89 */ +'\0x8A', /* 138 8a */ +'\0x8B', /* 139 8b */ +'\0x8C', /* 140 8c */ +'\0x8D', /* 141 8d */ +'\0x8E', /* 142 8e */ +'\0x8F', /* 143 8f */ +'\0x90', /* 144 90 */ +'\0x91', /* 145 91 */ +'\0x92', /* 146 92 */ +'\0x93', /* 147 93 */ +'\0x94', /* 148 94 */ +'\0x95', /* 149 95 */ +'\0x96', /* 150 96 */ +'\0x97', /* 151 97 */ +'\0x98', /* 152 98 */ +'\0x99', /* 153 99 */ +'\0x9A', /* 154 9a */ +'\0x9B', /* 155 9b */ +'\0x9C', /* 156 9c */ +'\0x9D', /* 157 9d */ +'\0x9E', /* 158 9e */ +'\0x9F', /* 159 9f */ +'\0xA0', /* 160 a0 */ +'\0xA1' , /* 161 a1 */ +'\0xA2', /* 162 a2 */ +'\0xA3' , /* 163 a3 */ +'\0xA4', /* 164 a4 */ +'\0xA5', /* 165 a5 */ +'\0xA6' , /* 166 a6 */ +'\0xA7', /* 167 a7 */ +'\0xA8', /* 168 a8 */ +'\0xA9', /* 169 a9 */ +'\0xAA', /* 170 aa */ +'\0xAB', /* 171 ab */ +'\0xAC' , /* 172 ac */ +'\0xAD', /* 173 ad */ +'\0xAE', /* 174 ae */ +'\0xAF' , /* 175 af */ +'\0xB0', /* 176 b0 */ +'\0xB1' , /* 177 b1 */ +'\0xB2', /* 178 b2 */ +'\0xB3' , /* 179 b3 */ +'\0xB4', /* 180 b4 */ +'\0xB5', /* 181 b5 */ +'\0xB6' , /* 182 b6 */ +'\0xB7', /* 183 b7 */ +'\0xB8', /* 184 b8 */ +'\0xB9', /* 185 b9 */ +'\0xBA', /* 186 ba */ +'\0xBB', /* 187 bb */ +'\0xBC' , /* 188 bc */ +'\0xBD', /* 189 bd */ +'\0xBE', /* 190 be */ +'\0xBF' , /* 191 bf */ +'\0xC0', /* 192 c0 */ +'\0xC1', /* 193 c1 */ +'\0xC2', /* 194 c2 */ +'\0xC3', /* 195 c3 */ +'\0xC4', /* 196 c4 */ +'\0xC5', /* 197 c5 */ +'\0xC6' , /* 198 c6 */ +'\0xC7', /* 199 c7 */ +'\0xC8', /* 200 c8 */ +'\0xC9', /* 201 c9 */ +'\0xCA' , /* 202 ca */ +'\0xCB', /* 203 cb */ +'\0xCC', /* 204 cc */ +'\0xCD', /* 205 cd */ +'\0xCE', /* 206 ce */ +'\0xCF', /* 207 cf */ +'\0xD0', /* 208 d0 */ +'\0xD1' , /* 209 d1 */ +'\0xD2', /* 210 d2 */ +'\0xD3' , /* 211 d3 */ +'\0xD4', /* 212 d4 */ +'\0xD5', /* 213 d5 */ +'\0xD6', /* 214 d6 */ +'\0xD7', /* 215 d7 */ +'\0xD8', /* 216 d8 */ +'\0xD9', /* 217 d9 */ +'\0xDA', /* 218 da */ +'\0xDB', /* 219 db */ +'\0xDC', /* 220 dc */ +'\0xDD', /* 221 dd */ +'\0xDE', /* 222 de */ +'\0xDF', /* 223 df */ +'\0xE0', /* 224 e0 */ +'\0xE1', /* 225 e1 */ +'\0xE2', /* 226 e2 */ +'\0xE3', /* 227 e3 */ +'\0xE4', /* 228 e4 */ +'\0xE5', /* 229 e5 */ +'\0xE6' , /* 230 e6 */ +'\0xE7', /* 231 e7 */ +'\0xE8', /* 232 e8 */ +'\0xE9', /* 233 e9 */ +'\0xEA' , /* 234 ea */ +'\0xEB', /* 235 eb */ +'\0xEC', /* 236 ec */ +'\0xED', /* 237 ed */ +'\0xEE', /* 238 ee */ +'\0xEF', /* 239 ef */ +'\0xF0', /* 240 f0 */ +'\0xF1' , /* 241 f1 */ +'\0xF2', /* 242 f2 */ +'\0xF3' , /* 243 f3 */ +'\0xF4', /* 244 f4 */ +'\0xF5', /* 245 f5 */ +'\0xF6', /* 246 f6 */ +'\0xF7', /* 247 f7 */ +'\0xF8', /* 248 f8 */ +'\0xF9', /* 249 f9 */ +'\0xFA', /* 250 fa */ +'\0xFB', /* 251 fb */ +'\0xFC', /* 252 fc */ +'\0xFD', /* 253 fd */ +'\0xFE', /* 254 fe */ +255 /* 255 ff */ + }; + +/* ******************************************************************* */ +{% endraw %} diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/fixidx.sed b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/fixidx.sed new file mode 100644 index 0000000..767a8d5 --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/fixidx.sed @@ -0,0 +1,48 @@ +# +# Autor: Rafał Nowak (www.rafalnowak.pl) +# Data : 22.03.2009 +# +# Poniższy plik zawiera skrypt dla programu sed. +# Służy on do zamiany pewnych instrukcji wygenerowanych +# przez program LaTeX'a na polskie znaki krytyczne +# kodowane zgodnie ze standarderm ISO-8859-2, tzw. Latin2. +# +# Skrypt ten ma zastosowanie przy tworzeniu polskiego +# skorowidza dla dokumentów składanych przez LaTeX'a, +# gdzie pliki źródłowe (*.tex) są kodowane w standardzie +# unicode UTF-8. +# +# Przykładowe użycie: +# > latex dokument.tex +# > sed -f skrypt.sed dokument.idx | ./plmindex -L PL-latin2 | iconv --from-code=ISO-8859-2 --to-code=UTF-8 > dokument.ind +# > latex dokument.tex +# +# W powyższym przykładzie: +# skrypt.sed - jest nazwą tego pliku (skryptu dla sed'a) +# plmindex - to program przygotowany przez Włodzimierza +# Macewicza to prawidłowego sortowania +# słów w celu utworzenia skorowidza +# iconv - to program który konwertuje otrzymany +# indeks z powrotem do kodowania UTF-8 +# W wyniku otrzymujemy plik dokument.ind zgodny z UTF-8 +# i prawidłowo posortowanymi słowami. +# +s/\\IeC\ {\\k\ a}/ą/g +s/\\IeC\ {\\k\ A}/Ą/g +s/\\IeC\ {\\k\ e}/ę/g +s/\\IeC\ {\\k\ E}/Ę/g +s/\\IeC\ {\\'c}/ć/g +s/\\IeC\ {\\'C}/Ć/g +s/\\IeC\ {\\l\ }/ł/g +s/\\IeC\ {\\L\ }/Ł/g +s/\\IeC\ {\\'n}/ń/g +s/\\IeC\ {\\'N}/Ń/g +s/\\IeC\ {\\'o}/ó/g +s/\\IeC\ {\\'O}/Ó/g +s/\\IeC\ {\\'s}/ś/g +s/\\IeC\ {\\'S}/Ś/g +s/\\IeC\ {\\'z}/ź/g +s/\\IeC\ {\\'Z}/Ź/g +s/\\IeC\ {\\\.z}/ż/g +s/\\IeC\ {\\\.Z}/Ż/g +s/\\nobreakspace\ \ {}/~/g diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/gitignore-template b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/gitignore-template new file mode 100644 index 0000000..c5be264 --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/gitignore-template @@ -0,0 +1,13 @@ +*~ +*.aux +*.bbl +*.blg +*.brf +*.idx +*.ind +*.lof +*.log +*.lot +*.out +*.toc +janus.pdf diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/init.sh b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/init.sh new file mode 100755 index 0000000..da3a9db --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/init.sh @@ -0,0 +1,28 @@ +#!/bin/bash + +NAME="$1" + +if [[ "$NAME" == "" ]] +then + echo 'no name given' + exit 1 +fi + +mkdir ../msc-$NAME +cp sample/sample.tex ../msc-$NAME/$NAME.tex +cp sample/sample.bib ../msc-$NAME/$NAME.bib + +perl -pne "s/janus/$NAME/g" < gitignore-template > ../msc-$NAME/.gitignore + + +echo "ROOTFILE=$NAME.tex" > ../msc-$NAME/Makefile +echo 'COMMONDIR=../uam-wmi-msc' >> ../msc-$NAME/Makefile +echo >> ../msc-$NAME/Makefile +echo 'include $(COMMONDIR)/msc.mk' >> ../msc-$NAME/Makefile + +cd ../msc-$NAME +git init +git add --all +git commit -m 'init' +git remote add origin ssh://gitolite@gonito.net/msc-$NAME +#git push origin master diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/msc.mk b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/msc.mk new file mode 100644 index 0000000..1a12d20 --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/msc.mk @@ -0,0 +1,38 @@ +{% raw %} +# Plik, który powinien być załączany (include'owany) przez pliki +# Makefile poszczególnych prac. +# W pliku Makefile załączającym niniejszy plik powinny być +# zdefiniowane następujące zmienne: +# ROOTFILE - główny plik .tex pracy +# PICTURES - ewentualne pliki graficzne + +PDFTARGET=$(ROOTFILE:.tex=.pdf) +BASENAME=$(ROOTFILE:.tex=) +WITHGLOSSARIES ?= no + +# Choć jesteśmy w katalogu common, niniejszy plik będzie załączany +# w katalogach poszczególnych prac, dlatego też musimy wpisać względną +# ścieżkę "..". +INPUTSDIR=".:$(COMMONDIR):" +RELDIR=$(COMMONDIR) + +.DELETE_ON_ERROR: + +all: $(PDFTARGET) + +$(PDFTARGET) : $(ROOTFILE) $(PICTURES) $(RELDIR)/plain-pl.bst $(RELDIR)/uam.png $(RELDIR)/wmimgr.cls + TEXINPUTS=$(INPUTSDIR) pdflatex -halt-on-error $(ROOTFILE) + sed -f ../../common/fixidx.sed $(BASENAME).idx | iconv -f utf-8 -t iso-8859-2 | ../../ext/plmindex/plmindex | iconv -f iso-8859-2 -t utf-8 > $(BASENAME).ind + BSTINPUTS=$(INPUTSDIR) bibtex $(BASENAME) + # pdflatecha należy uruchomić 3 razy, ze względu na możliwe referencje + TEXINPUTS=$(INPUTSDIR) pdflatex -halt-on-error $(ROOTFILE) + TEXINPUTS=$(INPUTSDIR) pdflatex -halt-on-error $(ROOTFILE) +ifeq ($(WITHGLOSSARIES), yes) + makeglossaries $(BASENAME) + TEXINPUTS=$(INPUTSDIR) pdflatex -halt-on-error $(ROOTFILE) +endif + +# czyszczenie z latechowych śmieci +clean: + rm -f $(PDFTARGET) *.bbl *.aux *.blg *.brf *.log *.lof *.idx *.out *.toc *.lot *.idx *.ind *.loa *.ist *.glo *.glg *.gls *.not *.ntn *.xdy +{% endraw %} diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/papalike.bst b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/papalike.bst new file mode 100644 index 0000000..2a63d8e --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/papalike.bst @@ -0,0 +1,1106 @@ +{% raw %} +% Spolonizowane `na szybko' +% ------------------------- +% +% BibTeX `apalike' bibliography style (24-Jan-88 version) +% Adapted from the `alpha' style, version 0.99a; for BibTeX version 0.99a. +% Copyright (C) 1988, all rights reserved. +% Copying of this file is allowed, provided that if you make any changes at all +% you name it something other than `apalike.bst'. +% This restriction helps ensure that all copies are identical. +% Differences between this style and `alpha' are generally heralded by a `%'. +% The file btxbst.doc has the documentation for alpha.bst. +% +% This style should be used with the `apalike' LaTeX style (apalike.sty). +% \cite's come out like "(Jones, 1986)" in the text but there are no labels +% in the bibliography, and something like "(1986)" comes out immediately +% after the author. Author (and editor) names appear as last name, comma, +% initials. A `year' field is required for every entry, and so is either +% an author (or in some cases, an editor) field or a key field. +% +% Editorial note: +% Many journals require a style like `apalike', but I strongly, strongly, +% strongly recommend that you not use it if you have a choice---use something +% like `plain' instead. Mary-Claire van Leunen (A Handbook for Scholars, +% Knopf, 1979) argues convincingly that a style like `plain' encourages better +% writing than one like `apalike'. Furthermore the strongest arguments for +% using an author-date style like `apalike'---that it's "the most practical" +% (The Chicago Manual of Style, University of Chicago Press, thirteenth +% edition, 1982, pages 400--401)---fall flat on their face with the new +% computer-typesetting technology. For instance page 401 anachronistically +% states "The chief disadvantage of [a style like `plain'] is that additions +% or deletions cannot be made after the manuscript is typed without changing +% numbers in both text references and list." LaTeX sidesteps the disadvantage. +% +% History: +% 15-sep-86 (SK,OP) Original version, by Susan King and Oren Patashnik. +% 10-nov-86 (OP) Truncated the sort.key$ string to the correct length +% in bib.sort.order to eliminate error message. +% 24-jan-88 (OP) Updated for BibTeX version 0.99a, from alpha.bst 0.99a; +% apalike now sorts by author, then year, then title; +% THIS `apalike' VERSION DOES NOT WORK WITH BIBTEX 0.98i. + +ENTRY + { address + author + booktitle + chapter + edition + editor + howpublished + institution + journal + key +% month not used in apalike + note + number + organization + pages + publisher + school + series + title + type + volume + year + } + {} + { label extra.label sort.label } + +INTEGERS { output.state before.all mid.sentence after.sentence after.block } + +FUNCTION {init.state.consts} +{ #0 'before.all := + #1 'mid.sentence := + #2 'after.sentence := + #3 'after.block := +} + +STRINGS { s t } + +FUNCTION {output.nonnull} +{ 's := + output.state mid.sentence = + { ", " * write$ } + { output.state after.block = + { add.period$ write$ + newline$ + "\newblock " write$ + } + { output.state before.all = + 'write$ + { add.period$ " " * write$ } + if$ + } + if$ + mid.sentence 'output.state := + } + if$ + s +} + +FUNCTION {output} +{ duplicate$ empty$ + 'pop$ + 'output.nonnull + if$ +} + +FUNCTION {output.check} +{ 't := + duplicate$ empty$ + { pop$ "empty " t * " in " * cite$ * warning$ } + 'output.nonnull + if$ +} + +% apalike needs this function because +% the year has special punctuation; +% apalike ignores the month +FUNCTION {output.year.check} +{ year empty$ + { "empty year in " cite$ * warning$ } + { write$ + " (" year * extra.label * ")" * + mid.sentence 'output.state := + } + if$ +} + +FUNCTION {output.bibitem} +{ newline$ + "\bibitem[" write$ + label write$ + "]{" write$ + cite$ write$ + "}" write$ + newline$ + "" + before.all 'output.state := +} + +FUNCTION {fin.entry} +{ add.period$ + write$ + newline$ +} + +FUNCTION {new.block} +{ output.state before.all = + 'skip$ + { after.block 'output.state := } + if$ +} + +FUNCTION {new.sentence} +{ output.state after.block = + 'skip$ + { output.state before.all = + 'skip$ + { after.sentence 'output.state := } + if$ + } + if$ +} + +FUNCTION {not} +{ { #0 } + { #1 } + if$ +} + +FUNCTION {and} +{ 'skip$ + { pop$ #0 } + if$ +} + +FUNCTION {or} +{ { pop$ #1 } + 'skip$ + if$ +} + +FUNCTION {new.block.checkb} +{ empty$ + swap$ empty$ + and + 'skip$ + 'new.block + if$ +} + +FUNCTION {field.or.null} +{ duplicate$ empty$ + { pop$ "" } + 'skip$ + if$ +} + +FUNCTION {emphasize} +{ duplicate$ empty$ + { pop$ "" } + { "{\em " swap$ * "}" * } + if$ +} + +INTEGERS { nameptr namesleft numnames } + +FUNCTION {format.names} +{ 's := + #1 'nameptr := + s num.names$ 'numnames := + numnames 'namesleft := + { namesleft #0 > } + { s nameptr "{vv~}{ll}{, jj}{, f.}" format.name$ 't := % last name first + nameptr #1 > + { namesleft #1 > + { ", " * t * } + { numnames #2 > + { "," * } + 'skip$ + if$ + t "others" = + { " i~inni" * } + { " i " * t * } + if$ + } + if$ + } + 't + if$ + nameptr #1 + 'nameptr := + namesleft #1 - 'namesleft := + } + while$ +} + +FUNCTION {format.authors} +{ author empty$ + { "" } + { author format.names } + if$ +} + +FUNCTION {format.key} % this function is just for apalike +{ empty$ + { key field.or.null } + { "" } + if$ +} + +FUNCTION {format.editors} +{ editor empty$ + { "" } + { editor format.names + editor num.names$ #1 > + { ", editors" * } + { ", editor" * } + if$ + } + if$ +} + +FUNCTION {format.title} +{ title empty$ + { "" } + { title "t" change.case$ } + if$ +} + +FUNCTION {n.dashify} +{ 't := + "" + { t empty$ not } + { t #1 #1 substring$ "-" = + { t #1 #2 substring$ "--" = not + { "--" * + t #2 global.max$ substring$ 't := + } + { { t #1 #1 substring$ "-" = } + { "-" * + t #2 global.max$ substring$ 't := + } + while$ + } + if$ + } + { t #1 #1 substring$ * + t #2 global.max$ substring$ 't := + } + if$ + } + while$ +} + +FUNCTION {format.btitle} +{ title emphasize +} + +FUNCTION {tie.or.space.connect} +{ duplicate$ text.length$ #3 < + { "~" } + { " " } + if$ + swap$ * * +} + +FUNCTION {either.or.check} +{ empty$ + 'pop$ + { "can't use both " swap$ * " fields in " * cite$ * warning$ } + if$ +} + +FUNCTION {format.bvolume} +{ volume empty$ + { "" } + { "volume" volume tie.or.space.connect + series empty$ + 'skip$ + { " of " * series emphasize * } + if$ + "volume and number" number either.or.check + } + if$ +} + +FUNCTION {format.number.series} +{ volume empty$ + { number empty$ + { series field.or.null } + { output.state mid.sentence = + { "number" } + { "Number" } + if$ + number tie.or.space.connect + series empty$ + { "there's a number but no series in " cite$ * warning$ } + { " in " * series * } + if$ + } + if$ + } + { "" } + if$ +} + +FUNCTION {format.edition} +{ edition empty$ + { "" } + { output.state mid.sentence = + { edition "l" change.case$ " edition" * } + { edition "t" change.case$ " edition" * } + if$ + } + if$ +} + +INTEGERS { multiresult } + +FUNCTION {multi.page.check} +{ 't := + #0 'multiresult := + { multiresult not + t empty$ not + and + } + { t #1 #1 substring$ + duplicate$ "-" = + swap$ duplicate$ "," = + swap$ "+" = + or or + { #1 'multiresult := } + { t #2 global.max$ substring$ 't := } + if$ + } + while$ + multiresult +} + +FUNCTION {format.pages} +{ pages empty$ + { "" } + { pages multi.page.check + { "pages" pages n.dashify tie.or.space.connect } + { "page" pages tie.or.space.connect } + if$ + } + if$ +} + +FUNCTION {format.vol.num.pages} +{ volume field.or.null + number empty$ + 'skip$ + { "(" number * ")" * * + volume empty$ + { "there's a number but no volume in " cite$ * warning$ } + 'skip$ + if$ + } + if$ + pages empty$ + 'skip$ + { duplicate$ empty$ + { pop$ format.pages } + { ":" * pages n.dashify * } + if$ + } + if$ +} + +FUNCTION {format.chapter.pages} +{ chapter empty$ + 'format.pages + { type empty$ + { "chapter" } + { type "l" change.case$ } + if$ + chapter tie.or.space.connect + pages empty$ + 'skip$ + { ", " * format.pages * } + if$ + } + if$ +} + +FUNCTION {format.in.ed.booktitle} +{ booktitle empty$ + { "" } + { editor empty$ + { "In " booktitle emphasize * } + { "In " format.editors * ", " * booktitle emphasize * } + if$ + } + if$ +} + +FUNCTION {format.thesis.type} +{ type empty$ + 'skip$ + { pop$ + type "t" change.case$ + } + if$ +} + +FUNCTION {format.tr.number} +{ type empty$ + { "Technical Report" } + 'type + if$ + number empty$ + { "t" change.case$ } + { number tie.or.space.connect } + if$ +} + +FUNCTION {format.article.crossref} +{ "In" % this is for apalike + " \cite{" * crossref * "}" * +} + +FUNCTION {format.book.crossref} +{ volume empty$ + { "empty volume in " cite$ * "'s crossref of " * crossref * warning$ + "In " + } + { "Volume" volume tie.or.space.connect + " of " * + } + if$ + "\cite{" * crossref * "}" * % this is for apalike +} + +FUNCTION {format.incoll.inproc.crossref} +{ "In" % this is for apalike + " \cite{" * crossref * "}" * +} + +FUNCTION {article} +{ output.bibitem + format.authors "author" output.check + author format.key output % special for + output.year.check % apalike + new.block + format.title "title" output.check + new.block + crossref missing$ + { journal emphasize "journal" output.check + format.vol.num.pages output + } + { format.article.crossref output.nonnull + format.pages output + } + if$ + new.block + note output + fin.entry +} + +FUNCTION {book} +{ output.bibitem + author empty$ + { format.editors "author and editor" output.check + editor format.key output + } + { format.authors output.nonnull + crossref missing$ + { "author and editor" editor either.or.check } + 'skip$ + if$ + } + if$ + output.year.check % special for apalike + new.block + format.btitle "title" output.check + crossref missing$ + { format.bvolume output + new.block + format.number.series output + new.sentence + publisher "publisher" output.check + address output + } + { new.block + format.book.crossref output.nonnull + } + if$ + format.edition output + new.block + note output + fin.entry +} + +FUNCTION {booklet} +{ output.bibitem + format.authors output + author format.key output % special for + output.year.check % apalike + new.block + format.title "title" output.check + new.block + howpublished output + address output + new.block + note output + fin.entry +} + +FUNCTION {inbook} +{ output.bibitem + author empty$ + { format.editors "author and editor" output.check + editor format.key output + } + { format.authors output.nonnull + crossref missing$ + { "author and editor" editor either.or.check } + 'skip$ + if$ + } + if$ + output.year.check % special for apalike + new.block + format.btitle "title" output.check + crossref missing$ + { format.bvolume output + format.chapter.pages "chapter and pages" output.check + new.block + format.number.series output + new.sentence + publisher "publisher" output.check + address output + } + { format.chapter.pages "chapter and pages" output.check + new.block + format.book.crossref output.nonnull + } + if$ + format.edition output + new.block + note output + fin.entry +} + +FUNCTION {incollection} +{ output.bibitem + format.authors "author" output.check + author format.key output % special for + output.year.check % apalike + new.block + format.title "title" output.check + new.block + crossref missing$ + { format.in.ed.booktitle "booktitle" output.check + format.bvolume output + format.number.series output + format.chapter.pages output + new.sentence + publisher "publisher" output.check + address output + format.edition output + } + { format.incoll.inproc.crossref output.nonnull + format.chapter.pages output + } + if$ + new.block + note output + fin.entry +} + +FUNCTION {inproceedings} +{ output.bibitem + format.authors "author" output.check + author format.key output % special for + output.year.check % apalike + new.block + format.title "title" output.check + new.block + crossref missing$ + { format.in.ed.booktitle "booktitle" output.check + format.bvolume output + format.number.series output + format.pages output + address output % for apalike + new.sentence % there's no year + organization output % here so things + publisher output % are simpler + } + { format.incoll.inproc.crossref output.nonnull + format.pages output + } + if$ + new.block + note output + fin.entry +} + +FUNCTION {conference} { inproceedings } + +FUNCTION {manual} +{ output.bibitem + format.authors output + author format.key output % special for + output.year.check % apalike + new.block + format.btitle "title" output.check + organization address new.block.checkb + organization output + address output + format.edition output + new.block + note output + fin.entry +} + +FUNCTION {mastersthesis} +{ output.bibitem + format.authors "author" output.check + author format.key output % special for + output.year.check % apalike + new.block + format.title "title" output.check + new.block + "praca magisterska" format.thesis.type output.nonnull + school "school" output.check + address output + new.block + note output + fin.entry +} + +FUNCTION {misc} +{ output.bibitem + format.authors output + author format.key output % special for + output.year.check % apalike + new.block + format.title output + new.block + howpublished output + new.block + note output + fin.entry +} + +FUNCTION {phdthesis} +{ output.bibitem + format.authors "author" output.check + author format.key output % special for + output.year.check % apalike + new.block + format.btitle "title" output.check + new.block + "rozprawa doktorska" format.thesis.type output.nonnull + school "school" output.check + address output + new.block + note output + fin.entry +} + +FUNCTION {proceedings} +{ output.bibitem + format.editors output + editor format.key output % special for + output.year.check % apalike + new.block + format.btitle "title" output.check + format.bvolume output + format.number.series output + address output % for apalike + new.sentence % we always output + organization output % a nonempty organization + publisher output % here + new.block + note output + fin.entry +} + +FUNCTION {techreport} +{ output.bibitem + format.authors "author" output.check + author format.key output % special for + output.year.check % apalike + new.block + format.title "title" output.check + new.block + format.tr.number output.nonnull + institution "institution" output.check + address output + new.block + note output + fin.entry +} + +FUNCTION {unpublished} +{ output.bibitem + format.authors "author" output.check + author format.key output % special for + output.year.check % apalike + new.block + format.title "title" output.check + new.block + note "note" output.check + fin.entry +} + +FUNCTION {default.type} { misc } + +MACRO {jan} {"January"} + +MACRO {feb} {"February"} + +MACRO {mar} {"March"} + +MACRO {apr} {"April"} + +MACRO {may} {"May"} + +MACRO {jun} {"June"} + +MACRO {jul} {"July"} + +MACRO {aug} {"August"} + +MACRO {sep} {"September"} + +MACRO {oct} {"October"} + +MACRO {nov} {"November"} + +MACRO {dec} {"December"} + +MACRO {acmcs} {"ACM Computing Surveys"} + +MACRO {acta} {"Acta Informatica"} + +MACRO {cacm} {"Communications of the ACM"} + +MACRO {ibmjrd} {"IBM Journal of Research and Development"} + +MACRO {ibmsj} {"IBM Systems Journal"} + +MACRO {ieeese} {"IEEE Transactions on Software Engineering"} + +MACRO {ieeetc} {"IEEE Transactions on Computers"} + +MACRO {ieeetcad} + {"IEEE Transactions on Computer-Aided Design of Integrated Circuits"} + +MACRO {ipl} {"Information Processing Letters"} + +MACRO {jacm} {"Journal of the ACM"} + +MACRO {jcss} {"Journal of Computer and System Sciences"} + +MACRO {scp} {"Science of Computer Programming"} + +MACRO {sicomp} {"SIAM Journal on Computing"} + +MACRO {tocs} {"ACM Transactions on Computer Systems"} + +MACRO {tods} {"ACM Transactions on Database Systems"} + +MACRO {tog} {"ACM Transactions on Graphics"} + +MACRO {toms} {"ACM Transactions on Mathematical Software"} + +MACRO {toois} {"ACM Transactions on Office Information Systems"} + +MACRO {toplas} {"ACM Transactions on Programming Languages and Systems"} + +MACRO {tcs} {"Theoretical Computer Science"} + +READ + +FUNCTION {sortify} +{ purify$ + "l" change.case$ +} + +INTEGERS { len } + +FUNCTION {chop.word} +{ 's := + 'len := + s #1 len substring$ = + { s len #1 + global.max$ substring$ } + 's + if$ +} + +% There are three apalike cases: one person (Jones), +% two (Jones and de~Bruijn), and more (Jones et~al.). +% This function is much like format.crossref.editors. +% +FUNCTION {format.lab.names} +{ 's := + s #1 "{vv~}{ll}" format.name$ + s num.names$ duplicate$ + #2 > + { pop$ " i~inni" * } + { #2 < + 'skip$ + { s #2 "{ff }{vv }{ll}{ jj}" format.name$ "others" = + { " i~inni" * } + { " i " * s #2 "{vv~}{ll}" format.name$ * } + if$ + } + if$ + } + if$ +} + +FUNCTION {author.key.label} +{ author empty$ + { key empty$ + { cite$ #1 #3 substring$ } + 'key % apalike uses the whole key + if$ + } + { author format.lab.names } + if$ +} + +FUNCTION {author.editor.key.label} +{ author empty$ + { editor empty$ + { key empty$ + { cite$ #1 #3 substring$ } + 'key % apalike uses the whole key + if$ + } + { editor format.lab.names } + if$ + } + { author format.lab.names } + if$ +} + +FUNCTION {editor.key.label} +{ editor empty$ + { key empty$ + { cite$ #1 #3 substring$ } + 'key % apalike uses the whole key, no organization + if$ + } + { editor format.lab.names } + if$ +} + +FUNCTION {calc.label} +{ type$ "book" = + type$ "inbook" = + or + 'author.editor.key.label + { type$ "proceedings" = + 'editor.key.label % apalike ignores organization + 'author.key.label % for labeling and sorting + if$ + } + if$ + ", " % these three lines are + * % for apalike, which + year field.or.null purify$ #-1 #4 substring$ % uses all four digits + * + 'label := +} + +FUNCTION {sort.format.names} +{ 's := + #1 'nameptr := + "" + s num.names$ 'numnames := + numnames 'namesleft := + { namesleft #0 > } + { nameptr #1 > + { " " * } + 'skip$ + if$ % apalike uses initials + s nameptr "{vv{ } }{ll{ }}{ f{ }}{ jj{ }}" format.name$ 't := % <= here + nameptr numnames = t "others" = and + { "i~inni" * } + { t sortify * } + if$ + nameptr #1 + 'nameptr := + namesleft #1 - 'namesleft := + } + while$ +} + +FUNCTION {sort.format.title} +{ 't := + "A " #2 + "An " #3 + "The " #4 t chop.word + chop.word + chop.word + sortify + #1 global.max$ substring$ +} + +FUNCTION {author.sort} +{ author empty$ + { key empty$ + { "to sort, need author or key in " cite$ * warning$ + "" + } + { key sortify } + if$ + } + { author sort.format.names } + if$ +} + +FUNCTION {author.editor.sort} +{ author empty$ + { editor empty$ + { key empty$ + { "to sort, need author, editor, or key in " cite$ * warning$ + "" + } + { key sortify } + if$ + } + { editor sort.format.names } + if$ + } + { author sort.format.names } + if$ +} + +FUNCTION {editor.sort} +{ editor empty$ + { key empty$ + { "to sort, need editor or key in " cite$ * warning$ + "" + } + { key sortify } + if$ + } + { editor sort.format.names } + if$ +} + +% apalike uses two sorting passes; the first one sets the +% labels so that the `a's, `b's, etc. can be computed; +% the second pass puts the references in "correct" order. +% The presort function is for the first pass. It computes +% label, sort.label, and title, and then concatenates. +FUNCTION {presort} +{ calc.label + label sortify + " " + * + type$ "book" = + type$ "inbook" = + or + 'author.editor.sort + { type$ "proceedings" = + 'editor.sort + 'author.sort + if$ + } + if$ + #1 entry.max$ substring$ % for + 'sort.label := % apalike + sort.label % style + * + " " + * + title field.or.null + sort.format.title + * + #1 entry.max$ substring$ + 'sort.key$ := +} + +ITERATE {presort} + +SORT % by label, sort.label, title---for final label calculation + +STRINGS { last.label next.extra } % apalike labels are only for the text; + +INTEGERS { last.extra.num } % there are none in the bibliography + +FUNCTION {initialize.extra.label.stuff} % and hence there is no `longest.label' +{ #0 int.to.chr$ 'last.label := + "" 'next.extra := + #0 'last.extra.num := +} + +FUNCTION {forward.pass} +{ last.label label = + { last.extra.num #1 + 'last.extra.num := + last.extra.num int.to.chr$ 'extra.label := + } + { "a" chr.to.int$ 'last.extra.num := + "" 'extra.label := + label 'last.label := + } + if$ +} + +FUNCTION {reverse.pass} +{ next.extra "b" = + { "a" 'extra.label := } + 'skip$ + if$ + label extra.label * 'label := + extra.label 'next.extra := +} + +EXECUTE {initialize.extra.label.stuff} + +ITERATE {forward.pass} + +REVERSE {reverse.pass} + +% Now that the label is right we sort for real, +% on sort.label then year then title. This is +% for the second sorting pass. +FUNCTION {bib.sort.order} +{ sort.label + " " + * + year field.or.null sortify + * + " " + * + title field.or.null + sort.format.title + * + #1 entry.max$ substring$ + 'sort.key$ := +} + +ITERATE {bib.sort.order} + +SORT % by sort.label, year, title---giving final bibliography order + +FUNCTION {begin.bib} +{ preamble$ empty$ % no \etalchar in apalike + 'skip$ + { preamble$ write$ newline$ } + if$ + "\begin{thebibliography}{}" write$ newline$ % no labels in apalike +} + +EXECUTE {begin.bib} + +EXECUTE {init.state.consts} + +ITERATE {call.type$} + +FUNCTION {end.bib} +{ newline$ + "\end{thebibliography}" write$ newline$ +} + +EXECUTE {end.bib} +{% endraw %} diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/plain-pl.bst b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/plain-pl.bst new file mode 100644 index 0000000..bfe0abc --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/plain-pl.bst @@ -0,0 +1,1099 @@ +{% raw %} +% BibTeX standard bibliography style `plain' + % version 0.99a for BibTeX versions 0.99a or later, LaTeX version 2.09. + % Copyright (C) 1985, all rights reserved. + % Copying of this file is authorized only if either + % (1) you make absolutely no changes to your copy, including name, or + % (2) if you do make changes, you name it something other than + % btxbst.doc, plain.bst, unsrt.bst, alpha.bst, and abbrv.bst. + % This restriction helps ensure that all standard styles are identical. + % The file btxbst.doc has the documentation for this style. + +ENTRY + { address + author + booktitle + chapter + edition + editor + howpublished + institution + journal + key + month + note + number + organization + pages + publisher + school + series + title + type + volume + year + } + {} + { label } + +INTEGERS { output.state before.all mid.sentence after.sentence after.block } + +FUNCTION {init.state.consts} +{ #0 'before.all := + #1 'mid.sentence := + #2 'after.sentence := + #3 'after.block := +} + +STRINGS { s t } + +FUNCTION {output.nonnull} +{ 's := + output.state mid.sentence = + { ", " * write$ } + { output.state after.block = + { add.period$ write$ + newline$ + "\newblock " write$ + } + { output.state before.all = + 'write$ + { add.period$ " " * write$ } + if$ + } + if$ + mid.sentence 'output.state := + } + if$ + s +} + +FUNCTION {output} +{ duplicate$ empty$ + 'pop$ + 'output.nonnull + if$ +} + +FUNCTION {output.check} +{ 't := + duplicate$ empty$ + { pop$ "empty " t * " in " * cite$ * warning$ } + 'output.nonnull + if$ +} + +FUNCTION {output.bibitem} +{ newline$ + "\bibitem{" write$ + cite$ write$ + "}" write$ + newline$ + "" + before.all 'output.state := +} + +FUNCTION {fin.entry} +{ add.period$ + write$ + newline$ +} + +FUNCTION {new.block} +{ output.state before.all = + 'skip$ + { after.block 'output.state := } + if$ +} + +FUNCTION {new.sentence} +{ output.state after.block = + 'skip$ + { output.state before.all = + 'skip$ + { after.sentence 'output.state := } + if$ + } + if$ +} + +FUNCTION {not} +{ { #0 } + { #1 } + if$ +} + +FUNCTION {and} +{ 'skip$ + { pop$ #0 } + if$ +} + +FUNCTION {or} +{ { pop$ #1 } + 'skip$ + if$ +} + +FUNCTION {new.block.checka} +{ empty$ + 'skip$ + 'new.block + if$ +} + +FUNCTION {new.block.checkb} +{ empty$ + swap$ empty$ + and + 'skip$ + 'new.block + if$ +} + +FUNCTION {new.sentence.checka} +{ empty$ + 'skip$ + 'new.sentence + if$ +} + +FUNCTION {new.sentence.checkb} +{ empty$ + swap$ empty$ + and + 'skip$ + 'new.sentence + if$ +} + +FUNCTION {field.or.null} +{ duplicate$ empty$ + { pop$ "" } + 'skip$ + if$ +} + +FUNCTION {emphasize} +{ duplicate$ empty$ + { pop$ "" } + { "{\em " swap$ * "}" * } + if$ +} + +INTEGERS { nameptr namesleft numnames } + +FUNCTION {format.names} +{ 's := + #1 'nameptr := + s num.names$ 'numnames := + numnames 'namesleft := + { namesleft #0 > } + { s nameptr "{ff~}{vv~}{ll}{, jj}" format.name$ 't := + nameptr #1 > + { namesleft #1 > + { ", " * t * } + { numnames #2 > + { " " * } + 'skip$ + if$ + t "others" = + { " i~inni" * } + { " i " * t * } + if$ + } + if$ + } + 't + if$ + nameptr #1 + 'nameptr := + namesleft #1 - 'namesleft := + } + while$ +} + +FUNCTION {format.authors} +{ author empty$ + { "" } + { author format.names } + if$ +} + +FUNCTION {format.editors} +{ editor empty$ + { "" } + { editor format.names + editor num.names$ #1 > + { ", editors" * } + { ", editor" * } + if$ + } + if$ +} + +FUNCTION {format.title} +{ title empty$ + { "" } + { title "t" change.case$ } + if$ +} + +FUNCTION {n.dashify} +{ 't := + "" + { t empty$ not } + { t #1 #1 substring$ "-" = + { t #1 #2 substring$ "--" = not + { "--" * + t #2 global.max$ substring$ 't := + } + { { t #1 #1 substring$ "-" = } + { "-" * + t #2 global.max$ substring$ 't := + } + while$ + } + if$ + } + { t #1 #1 substring$ * + t #2 global.max$ substring$ 't := + } + if$ + } + while$ +} + +FUNCTION {format.date} +{ year empty$ + { month empty$ + { "" } + { "there's a month but no year in " cite$ * warning$ + month + } + if$ + } + { month empty$ + 'year + { month " " * year * } + if$ + } + if$ +} + +FUNCTION {format.btitle} +{ title emphasize +} + +FUNCTION {tie.or.space.connect} +{ duplicate$ text.length$ #3 < + { "~" } + { " " } + if$ + swap$ * * +} + +FUNCTION {either.or.check} +{ empty$ + 'pop$ + { "can't use both " swap$ * " fields in " * cite$ * warning$ } + if$ +} + +FUNCTION {format.bvolume} +{ volume empty$ + { "" } + { "tom" volume tie.or.space.connect + series empty$ + 'skip$ + { " of " * series emphasize * } + if$ + "volume and number" number either.or.check + } + if$ +} + +FUNCTION {format.number.series} +{ volume empty$ + { number empty$ + { series field.or.null } + { output.state mid.sentence = + { "number" } + { "Number" } + if$ + number tie.or.space.connect + series empty$ + { "there's a number but no series in " cite$ * warning$ } + { " in " * series * } + if$ + } + if$ + } + { "" } + if$ +} + +FUNCTION {format.edition} +{ edition empty$ + { "" } + { output.state mid.sentence = + { edition "l" change.case$ ". edycja" * } + { edition "t" change.case$ ". edycja" * } + if$ + } + if$ +} + +INTEGERS { multiresult } + +FUNCTION {multi.page.check} +{ 't := + #0 'multiresult := + { multiresult not + t empty$ not + and + } + { t #1 #1 substring$ + duplicate$ "-" = + swap$ duplicate$ "," = + swap$ "+" = + or or + { #1 'multiresult := } + { t #2 global.max$ substring$ 't := } + if$ + } + while$ + multiresult +} + +FUNCTION {format.pages} +{ pages empty$ + { "" } + { pages multi.page.check + { "s.~" pages n.dashify tie.or.space.connect } + { "stron" pages tie.or.space.connect } + if$ + } + if$ +} + +FUNCTION {format.vol.num.pages} +{ volume field.or.null + number empty$ + 'skip$ + { "(" number * ")" * * + volume empty$ + { "there's a number but no volume in " cite$ * warning$ } + 'skip$ + if$ + } + if$ + pages empty$ + 'skip$ + { duplicate$ empty$ + { pop$ format.pages } + { ":" * pages n.dashify * } + if$ + } + if$ +} + +FUNCTION {format.chapter.pages} +{ chapter empty$ + 'format.pages + { type empty$ + { "chapter" } + { type "l" change.case$ } + if$ + chapter tie.or.space.connect + pages empty$ + 'skip$ + { ", " * format.pages * } + if$ + } + if$ +} + +FUNCTION {format.in.ed.booktitle} +{ booktitle empty$ + { "" } + { editor empty$ + { "W: " booktitle emphasize * } + { "W: " format.editors * ", " * booktitle emphasize * } + if$ + } + if$ +} + +FUNCTION {empty.misc.check} +{ author empty$ title empty$ howpublished empty$ + month empty$ year empty$ note empty$ + and and and and and + key empty$ not and + { "all relevant fields are empty in " cite$ * warning$ } + 'skip$ + if$ +} + +FUNCTION {format.thesis.type} +{ type empty$ + 'skip$ + { pop$ + type "t" change.case$ + } + if$ +} + +FUNCTION {format.tr.number} +{ type empty$ + { "Raport techniczny" } + 'type + if$ + number empty$ + { "t" change.case$ } + { number tie.or.space.connect } + if$ +} + +FUNCTION {format.article.crossref} +{ key empty$ + { journal empty$ + { "need key or journal for " cite$ * " to crossref " * crossref * + warning$ + "" + } + { "W: {\em " journal * "\/}" * } + if$ + } + { "W: " key * } + if$ + " \cite{" * crossref * "}" * +} + +FUNCTION {format.crossref.editor} +{ editor #1 "{vv~}{ll}" format.name$ + editor num.names$ duplicate$ + #2 > + { pop$ " et~al." * } + { #2 < + 'skip$ + { editor #2 "{ff }{vv }{ll}{ jj}" format.name$ "others" = + { " et~al." * } + { " and " * editor #2 "{vv~}{ll}" format.name$ * } + if$ + } + if$ + } + if$ +} + +FUNCTION {format.book.crossref} +{ volume empty$ + { "empty volume in " cite$ * "'s crossref of " * crossref * warning$ + "W: " + } + { "Tom" volume tie.or.space.connect + " of " * + } + if$ + editor empty$ + editor field.or.null author field.or.null = + or + { key empty$ + { series empty$ + { "need editor, key, or series for " cite$ * " to crossref " * + crossref * warning$ + "" * + } + { "{\em " * series * "\/}" * } + if$ + } + { key * } + if$ + } + { format.crossref.editor * } + if$ + " \cite{" * crossref * "}" * +} + +FUNCTION {format.incoll.inproc.crossref} +{ editor empty$ + editor field.or.null author field.or.null = + or + { key empty$ + { booktitle empty$ + { "need editor, key, or booktitle for " cite$ * " to crossref " * + crossref * warning$ + "" + } + { "W: {\em " booktitle * "\/}" * } + if$ + } + { "W: " key * } + if$ + } + { "W: " format.crossref.editor * } + if$ + " \cite{" * crossref * "}" * +} + +FUNCTION {article} +{ output.bibitem + format.authors "author" output.check + new.block + format.title "title" output.check + new.block + crossref missing$ + { journal emphasize "journal" output.check + format.vol.num.pages output + format.date "year" output.check + } + { format.article.crossref output.nonnull + format.pages output + } + if$ + new.block + note output + fin.entry +} + +FUNCTION {book} +{ output.bibitem + author empty$ + { format.editors "author and editor" output.check } + { format.authors output.nonnull + crossref missing$ + { "author and editor" editor either.or.check } + 'skip$ + if$ + } + if$ + new.block + format.btitle "title" output.check + crossref missing$ + { format.bvolume output + new.block + format.number.series output + new.sentence + publisher "publisher" output.check + address output + } + { new.block + format.book.crossref output.nonnull + } + if$ + format.edition output + format.date "year" output.check + new.block + note output + fin.entry +} + +FUNCTION {booklet} +{ output.bibitem + format.authors output + new.block + format.title "title" output.check + howpublished address new.block.checkb + howpublished output + address output + format.date output + new.block + note output + fin.entry +} + +FUNCTION {inbook} +{ output.bibitem + author empty$ + { format.editors "author and editor" output.check } + { format.authors output.nonnull + crossref missing$ + { "author and editor" editor either.or.check } + 'skip$ + if$ + } + if$ + new.block + format.btitle "title" output.check + crossref missing$ + { format.bvolume output + format.chapter.pages "chapter and pages" output.check + new.block + format.number.series output + new.sentence + publisher "publisher" output.check + address output + } + { format.chapter.pages "chapter and pages" output.check + new.block + format.book.crossref output.nonnull + } + if$ + format.edition output + format.date "year" output.check + new.block + note output + fin.entry +} + +FUNCTION {incollection} +{ output.bibitem + format.authors "author" output.check + new.block + format.title "title" output.check + new.block + crossref missing$ + { format.in.ed.booktitle "booktitle" output.check + format.bvolume output + format.number.series output + format.chapter.pages output + new.sentence + publisher "publisher" output.check + address output + format.edition output + format.date "year" output.check + } + { format.incoll.inproc.crossref output.nonnull + format.chapter.pages output + } + if$ + new.block + note output + fin.entry +} + +FUNCTION {inproceedings} +{ output.bibitem + format.authors "author" output.check + new.block + format.title "title" output.check + new.block + crossref missing$ + { format.in.ed.booktitle "booktitle" output.check + format.bvolume output + format.number.series output + format.pages output + address empty$ + { organization publisher new.sentence.checkb + organization output + publisher output + format.date "year" output.check + } + { address output.nonnull + format.date "year" output.check + new.sentence + organization output + publisher output + } + if$ + } + { format.incoll.inproc.crossref output.nonnull + format.pages output + } + if$ + new.block + note output + fin.entry +} + +FUNCTION {conference} { inproceedings } + +FUNCTION {manual} +{ output.bibitem + author empty$ + { organization empty$ + 'skip$ + { organization output.nonnull + address output + } + if$ + } + { format.authors output.nonnull } + if$ + new.block + format.btitle "title" output.check + author empty$ + { organization empty$ + { address new.block.checka + address output + } + 'skip$ + if$ + } + { organization address new.block.checkb + organization output + address output + } + if$ + format.edition output + format.date output + new.block + note output + fin.entry +} + +FUNCTION {mastersthesis} +{ output.bibitem + format.authors "author" output.check + new.block + format.title "title" output.check + new.block + "Praca magisterska" format.thesis.type output.nonnull + school "school" output.check + address output + format.date "year" output.check + new.block + note output + fin.entry +} + +FUNCTION {misc} +{ output.bibitem + format.authors output + title howpublished new.block.checkb + format.title output + howpublished new.block.checka + howpublished output + format.date output + new.block + note output + fin.entry + empty.misc.check +} + +FUNCTION {phdthesis} +{ output.bibitem + format.authors "author" output.check + new.block + format.btitle "title" output.check + new.block + "Rozprawa doktorska" format.thesis.type output.nonnull + school "school" output.check + address output + format.date "year" output.check + new.block + note output + fin.entry +} + +FUNCTION {proceedings} +{ output.bibitem + editor empty$ + { organization output } + { format.editors output.nonnull } + if$ + new.block + format.btitle "title" output.check + format.bvolume output + format.number.series output + address empty$ + { editor empty$ + { publisher new.sentence.checka } + { organization publisher new.sentence.checkb + organization output + } + if$ + publisher output + format.date "year" output.check + } + { address output.nonnull + format.date "year" output.check + new.sentence + editor empty$ + 'skip$ + { organization output } + if$ + publisher output + } + if$ + new.block + note output + fin.entry +} + +FUNCTION {techreport} +{ output.bibitem + format.authors "author" output.check + new.block + format.title "title" output.check + new.block + format.tr.number output.nonnull + institution "institution" output.check + address output + format.date "year" output.check + new.block + note output + fin.entry +} + +FUNCTION {unpublished} +{ output.bibitem + format.authors "author" output.check + new.block + format.title "title" output.check + new.block + note "note" output.check + format.date output + fin.entry +} + +FUNCTION {default.type} { misc } + +MACRO {jan} {"Styczeń"} + +MACRO {feb} {"Luty"} + +MACRO {mar} {"Marzec"} + +MACRO {apr} {"Kwiecień"} + +MACRO {may} {"Maj"} + +MACRO {jun} {"Czerwiec"} + +MACRO {jul} {"Lipiec"} + +MACRO {aug} {"Sierpień"} + +MACRO {sep} {"Wrzesień"} + +MACRO {oct} {"Październik"} + +MACRO {nov} {"Listopad"} + +MACRO {dec} {"Grudzień"} + +MACRO {acmcs} {"ACM Computing Surveys"} + +MACRO {acta} {"Acta Informatica"} + +MACRO {cacm} {"Communications of the ACM"} + +MACRO {ibmjrd} {"IBM Journal of Research and Development"} + +MACRO {ibmsj} {"IBM Systems Journal"} + +MACRO {ieeese} {"IEEE Transactions on Software Engineering"} + +MACRO {ieeetc} {"IEEE Transactions on Computers"} + +MACRO {ieeetcad} + {"IEEE Transactions on Computer-Aided Design of Integrated Circuits"} + +MACRO {ipl} {"Information Processing Letters"} + +MACRO {jacm} {"Journal of the ACM"} + +MACRO {jcss} {"Journal of Computer and System Sciences"} + +MACRO {scp} {"Science of Computer Programming"} + +MACRO {sicomp} {"SIAM Journal on Computing"} + +MACRO {tocs} {"ACM Transactions on Computer Systems"} + +MACRO {tods} {"ACM Transactions on Database Systems"} + +MACRO {tog} {"ACM Transactions on Graphics"} + +MACRO {toms} {"ACM Transactions on Mathematical Software"} + +MACRO {toois} {"ACM Transactions on Office Information Systems"} + +MACRO {toplas} {"ACM Transactions on Programming Languages and Systems"} + +MACRO {tcs} {"Theoretical Computer Science"} + +READ + +FUNCTION {sortify} +{ purify$ + "l" change.case$ +} + +INTEGERS { len } + +FUNCTION {chop.word} +{ 's := + 'len := + s #1 len substring$ = + { s len #1 + global.max$ substring$ } + 's + if$ +} + +FUNCTION {sort.format.names} +{ 's := + #1 'nameptr := + "" + s num.names$ 'numnames := + numnames 'namesleft := + { namesleft #0 > } + { nameptr #1 > + { " " * } + 'skip$ + if$ + s nameptr "{vv{ } }{ll{ }}{ ff{ }}{ jj{ }}" format.name$ 't := + nameptr numnames = t "others" = and + { "et al" * } + { t sortify * } + if$ + nameptr #1 + 'nameptr := + namesleft #1 - 'namesleft := + } + while$ +} + +FUNCTION {sort.format.title} +{ 't := + "A " #2 + "An " #3 + "The " #4 t chop.word + chop.word + chop.word + sortify + #1 global.max$ substring$ +} + +FUNCTION {author.sort} +{ author empty$ + { key empty$ + { "to sort, need author or key in " cite$ * warning$ + "" + } + { key sortify } + if$ + } + { author sort.format.names } + if$ +} + +FUNCTION {author.editor.sort} +{ author empty$ + { editor empty$ + { key empty$ + { "to sort, need author, editor, or key in " cite$ * warning$ + "" + } + { key sortify } + if$ + } + { editor sort.format.names } + if$ + } + { author sort.format.names } + if$ +} + +FUNCTION {author.organization.sort} +{ author empty$ + { organization empty$ + { key empty$ + { "to sort, need author, organization, or key in " cite$ * warning$ + "" + } + { key sortify } + if$ + } + { "The " #4 organization chop.word sortify } + if$ + } + { author sort.format.names } + if$ +} + +FUNCTION {editor.organization.sort} +{ editor empty$ + { organization empty$ + { key empty$ + { "to sort, need editor, organization, or key in " cite$ * warning$ + "" + } + { key sortify } + if$ + } + { "The " #4 organization chop.word sortify } + if$ + } + { editor sort.format.names } + if$ +} + +FUNCTION {presort} +{ type$ "book" = + type$ "inbook" = + or + 'author.editor.sort + { type$ "proceedings" = + 'editor.organization.sort + { type$ "manual" = + 'author.organization.sort + 'author.sort + if$ + } + if$ + } + if$ + " " + * + year field.or.null sortify + * + " " + * + title field.or.null + sort.format.title + * + #1 entry.max$ substring$ + 'sort.key$ := +} + +ITERATE {presort} + +SORT + +STRINGS { longest.label } + +INTEGERS { number.label longest.label.width } + +FUNCTION {initialize.longest.label} +{ "" 'longest.label := + #1 'number.label := + #0 'longest.label.width := +} + +FUNCTION {longest.label.pass} +{ number.label int.to.str$ 'label := + number.label #1 + 'number.label := + label width$ longest.label.width > + { label 'longest.label := + label width$ 'longest.label.width := + } + 'skip$ + if$ +} + +EXECUTE {initialize.longest.label} + +ITERATE {longest.label.pass} + +FUNCTION {begin.bib} +{ preamble$ empty$ + 'skip$ + { preamble$ write$ newline$ } + if$ + "\begin{thebibliography}{" longest.label * "}" * write$ newline$ +} + +EXECUTE {begin.bib} + +EXECUTE {init.state.consts} + +ITERATE {call.type$} + +FUNCTION {end.bib} +{ newline$ + "\end{thebibliography}" write$ newline$ +} + +EXECUTE {end.bib} +{% endraw %} diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/uam.png b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/uam.png new file mode 100644 index 0000000000000000000000000000000000000000..a06d2d7287d336f8c31659359029394f1e430e1d GIT binary patch literal 11995 zcmX9^2RxSV*MF?Cd+aSFWRJ49M`rfkp|Z0gE0ILmvPbqv$j->fEGv6&GP76adw&1- z{-liD>pJIqzT*njP*WhlrN%`d5Clq!C@uKc3O?Mi(GdtV+i(s~_yWgS(a;TnAZ-2b z1FiFUfi(ibfKWoo=)6pw7PZyUQK)$F>>;HEr3*4z-h>iK!Ssz)nN&uTDT{TRhPszg zhEG$5DR`ckS8>>Fk+|&vE|C=`Q7E;h%TF1@83Ub&0%;wM<7me}qvx8FX2EEOK3+R3 z4QG5qHBK+!@O1POK?QjtqDLzd5)zzbQK+`AuCB}T6Dt)BHqx;92U321mq9_85lfQi zTLLO7DiKTN<>kJx!a~F zEXybnD5im)B!QIV|(h+T`Oy?tc=U#u{j$4SX^9uwA8#*tFXkpi95%)NF!n?p2wV|{O zjMrnySO~Zf&Za4;VqAB~^`gVHA{|3=%P zJb1}Z#f^6@`Qb?^5H_*>DMGi1IwR|Z>xR_NnW|Jr8u?6?V9=8E+EX2mbqPgonb+`w`+2%~Wr@h(m zc(tRkiwmFJpr&-dd#Z+6b9s6BAK~RM_beBzBIzXx_&m2wYE8Hkx|76&-PfXyuh0?d z>gsj};{D5_KF6F)lT%Z8@(2V41%=&j_NqiH9UW3cPl}LwmxPdz{6(_wqU1+ClmS0mbEE<>28I_!$?DVIJjdgT991r-x z6pC_P?V}6s@9I)iQnKyc{L8*IQE?Ly&uPe%&`lL%iLj|avLz~TxC3k$or zxClzz-E~GaxGV)D3rkDQ4Gau)b&oFoxzRN+-MRBg($7d=U&wy+3tR$vH0JDdZ^_oy zRy$uUSK;Q(cge}gi;If^7&n=+3^>ioEamac=;`T0#;ff0Q6}{sT!>T=x2JunB23Y1 ze|l5izJ1Fchl_X^Mj0I!_r%tAVtP6(zdmk7mStu>Uik60NWZj0@3*D;)@0R(i$nuX zZZ7IeY;V8XTa-stR#g=j72)CIqflpe z3rb2}o$fw1F)@Kxo7i}Dw#h@+05~?^@+LIv%a@+6u8=TVE)hhO01rERvcNOK7tueh zLqkIy`!uo5{VyNbS4aZjIu6uyevn?{77MB&H!RfQ-vSs!V-ONb@C|zRPGM*EduZ5- z2BJBJBCtmAS#R=#FOD`g*a*OQ|BKVI*w~?oif8ZesbouO>FB5ob#>ziQ!o$&1O(4> z$;L~w6(T)0hH;1htk$CLSlZg&`>Q~=5QZ9PFa4Bf{BHhIjTjbrO>R=S7b$9^rf!8zMM);54w|tgal*4C=;Gn zC_WPhZ@Q#hVHSpiE4pjK6K)^6{QF(&cxC z4F18^gg`l~Xv_Gx0e1oiDQ=;Tk*@AY-?xGxX(2&DS6Y2@bAMR){r?Wv=g)VbHmchL z@4iH6=j+fySmo;(!{W^u>1i>3pBG|rl0KZ4-O59z1+<(DjucA zC(2h#dmjP~1xRXHmdMT%GCn=+yT7cYT>k28J^x8}d~R+o6%|!)BHtY;sk#3Co#8_5 z9cDc*uYXaDas|Z$Hu(7X9g(-ys~x7Q9XmQY07+mpkJ;R3k7MWI>F@0gXU9Nf=oR($ z^eiqdDNWc_)#cFGyqq6F`M~ZYul68$QDx=FI2zy?Ia=#$1KC8;ucR(^TO0k(feu8_OPu|T zWreHXSA`*=to#cg(D0>`jZH{MW@e^`hlgwJMRNcKt9m*V#|6wzv+v&RPjz*5b4yEa zA^Q6I=}8fcU|?wILMvoDm@|g;+p}P@DkCH^lJ&z;=WTzDp!RPLGj(zFKF3=k zFE)l#Q)z*rWo0ojWh5?5*SdwQt*qo~u)z{>adIN}2C@}YBVeVQeE$&>)qC!!J&Q6W zsASc1cIFj8hA6gMrLR(O8c0)(6dTu!Pi15~F-!0+E*v$AAY$Nx%qc5`9^TN_=$ z7;IbVPFUX+&?wX?D=RB5n%QBEkBn3Y4yOFy@e7ckp`oGDgn-G&z(6%scwlB`=GU)Z zqobqK)2Y>Ci|rqND*v?RM<}YP=@sh0^W^2_!OJHkBrJZ0j-c(-2 z4=P=@-jc$ek%xPL=8ND1MPqgN1FXvprs>dDAOd z54$QOPIB$g*TgB2l4omNn}S(&o}tG^PkER$Zw@RKzvQ+VA5((PNzW_Tv|<5 z+9Hq?6eskSRZ^ipe*CD$rcBq}Y5noT;I86076K~4&D9k zWYp4yw#NI&?uRxRK9SGShWrUZV`JkXI~P~)#6*&+skSx=qoMUwp26}4nlz;||JSN2 ziB}iGG;(Z1FgKF)3@$M+?_#E<6k?E7j*^>-VzKrwM}aOmsn=V~dP zpdq5t(!#mu=3sQL#eKCHy9%}q$Q2X+?|lr+EQZ$UX3eO#iH7R zg`wxWZNSO+0PXEdd=|CTE;Bwus*fK(u9@(l?(^{te2y*GirKXcXt}Qca^_EZm1}uP zL$Nnk@cBAkwXm=dZt)g2HVo~5|NdQ{@b{(&J-;~J^YZcnLhz-q&);kZ@C-kqBuD?#9S6pP<4GZaBea(GEh9E znIu7P-)i#DP-kUli$rL%krIct&CN9x%iy?oTR(gD%-Wh1>N_{UV?zw%27X4zTRe)4 zkz6#4G6U7jmPo0qZ_W#{$0EP#e=TosH@dHDp>)_t;cmtIhtdkwp!sh+&?_;S&>Pt~ zTpyaMc@E>hyrw3f<6guPTyRd8rOJo^VONzr4XRE5=~EVLbQZ3R`_x2D|Nf*@TTeE4 zxyj0+b8OyO1jZ$KI{(Hq?w*K9Qu#g(35&yIrPAq)g8jT#x@nTGj!va~o>pOMYO2%p zH%$!<4L!Z%b_(;Yxu&MHm7zcUfCw;=q(DK4ik@9vo+~LSF+~@A{i^ZoS#=UNib)fc zlYKe7U{~6Nw6sT_`0j7Mko~M=)rQI2{p%Me7guX*tEs6eG_ta}{{<+XTd;D0_)YQ?*DIx?oW+tj2?M~@spy2i zU%#mD+aRAbK#jwsSXo&~;4ybnXMq}J$1E7x0LD5wIk_(`W!)9^`7=8(Sx^(OgzzJn zg>`kJetv#&%4BddT3X+&aX!GN^i{DJ8}5I4s8BkEI{GChE-zkGRacjM{tR$+cy#3G z;Ly|EEr%Ms>vylt@7!aCA4tiI?dhcLvYqK#0iR=s9~^PYa3L}dy|(stG71VQ??W~Q zhUV^Wl|r2xSXg`F{RiT4h3m$cVq#)IDdy+rHM1Xrgx1y51I&5)^r^Rx&kk_U5zK-f zg|9H-1&?w{OL<~{7I4omEy*d?1vdF#U;WOMTXFSrbSy3_ zFWbF)>wxa2rgR8lQBk18G>E=WQc_QTkpjUnG*qI%{=%U0LB-b7o@2=JFFHE9tel)z zdOr1^H#cu3{>x+^21v8Fvr~Qa2r%yC?-Xma;_>zj4H3~}N5{0}WcJvfP^)hO1J{PI z`17G~w)6-wm25$1ZLXQUQ^nld+tYD}Ze}!YAGf_v4Pp|7Pe^!taw7F&gLH(nkeG^w zM$B>YzP7eD%H*5#V?RF$CTbd*=Tp_;e3|=osw`6#&mz?V+`CccpEU;pQ}OSzhJ5qf zF^j=LFcbd-Vgck7DC!LY>cho$yvNnUFbR$By_IcIB|^X~WLyO8b98hB%_JoyrR?$O z(IfpY21MlK!66k-d$XcD!fBp4IjP-Ud;J+g$WYBYBeak+V)S8-;T$Kc*W}yx!Ho!i4O*;N?N%OTfuQHR8&vtK*%FC$`Ws zfCwQh?Cd@d*o=NLBq1fu8L$CyqxMOXj*jlpF*@Qu8sj)s4g80cf&vO)Xd?B#tri?W z=GQ9-lO0pM1BDVsL%!J#u^f3BWD2nBmc#_ES@X=ew8cl`eS`+|ak zwzf94G|_<^G>g_?0=OBwe_+>ePxA{16qY|~$BtN{m+&6WQ}w^TG~Y6Lra?AF(R3~< zewH1?B6Ba0R0b85cVF{8dSDlJ;9E4Mwh}6Q;=4q28XqYY9261RnqQgu14W56r8PsM zUNdCkg$?FP%uZeU3okr9kZ!Z?`1$U72cu$VduC;;_A+%&q;yT2x5vTaN?k>T1RGP# zbNlf4xI^J3@1S|T2S}st-@kbo7!XgrrXM{}2DQIYDXle0>CEsU(0tI{G-uub&C*7dK9w&dTsHph*6(Nup8j2Hk zFfgELq4vd~4BeLsnweO&w9q;Rfsg$9P=i!gL!){10BCZ%Wf=$qKr|@$u<&pw3-Bw@ z)2U*ZTh2#@hjR)GZEbAUmY3VC`7<$uMMNHJE!C$M#dcwKXDTuej*MWbc)xrpjGQ^y znvm1fdGX>wWGCETY;-hQ{KVc;Cp64!Hne_fDk_*Hz;>VlLs3~_Vfd6?+1c5@lhUR9 zBgB5f@zT~&m^5$k) zmEXu`UFne^3U1T7`|RxRv)IZEe6O!A^VL78iN>iUiw1mF4)=KrZjPGf$4{T;#>dBh z|JIO^L7Rp`;c{PIT(mS`g1b_R2|B{;BL&0~5fPD-lY^=E@&p_d39F7U7_AB@RKth$ zL!l(_y^yka6x>1MLBj26;t!xvPiAF%abi z4iaKw6F@3j+ML{64tDml^K)34{!|fdU0pI#(qZriXlcbCcx_$sKSIO9!;4`K@D67r z|G<}|k#z-nxF7r^-~hLXLz3^`STMx~(uR!nWR*Rp%xl(* z*4@n8G78V0u}Tt4cH~-TLL0N3Z zjM)wF7Rkvw+S*dZJR`E$BqY8IJnLg-VUfk8WRX{Oz=dUC^Jmq4y4aMOC9_cS>C^2C z--}bezMQd%!cmD6EyxyGDD#V;KXjV(+v&cFJ2tAf1s$ZuZMB`qZmY!3D>=QIOcLD zIIkObF9{5+#^2o^z`$ts;hgp$m46^4)GGLaA*8xm(4-_gdues`=Fz(3t01J{NXw50 zx>HAohs{_)Z&gudX0vUwj*fp}uzqcU)|ubW%VPlz{EeQHGD9jREscO;=Xw3yt8)VG zHB4hs5Qi*WpCo)do8N=^zjYt+-jTW0RwD&JF|H3HPuzzxN*X2SZ zV1zb{qsB;N6~UW=vcHn3_xOum&WGshjYZU00{Q+pJTmfVvgee@+dnJ8>NER;#*2VV z`~h?Y0e=31lSiWdamk5^(h{OORN0l4I);W`S*jqUfj9)Y(#G6qm6x@AU#+&35p~i9 z-7g|9@!-LOt+L#16cU^&hEM(ZQd5J2fsx!VKhD&;-F&|I<;$16Q*-|#*0Ua#08koz zeQM)t11?J)1cdMIaB&f|&|x!1odd-{%6>o^m0RPOe5lOx7E3&<=4f>@uDJOL$DpGTwW4)^~Sa=1WN7Bw@;pyJtgfeQ5kMjea!4^J{Ab z+1VI1&4+7$|9*eko7{BOiJ4?^Gr;EE&d(`A_4-63w5YhaTz`(>{QUf;rlz{OGiZ#o z)KrEG{LxRaJTS#W&r$>(e~baWaE9jO)15+FLNcO+z5{{{)w&v-bw=JE`s+XZt(A^Z zM@Og4f_IH?v*KC*L+pVhNoivg_Q0Je7F)5pn18;nP$F_xkYadUkE?Kkx%U_=7tH1_BJqpn^>Q&|5<~FbNC{ zDDx`NmzS3bZ%bZq+jS4Kv9k{j478Ntyw1#I43I_;9h@KkO}U!F#lsV!jVLK`^7a;; zbq9?3(K7h^H*z)k^k!m7o{^CegGpC=`wDbEz{H~ zI7!}0Ak<|;S}Xv-VKO}05J(Og9o6Gb*j!wcjadefAVRAKD*>vud4`n~H^7PSSs!g^ za1u*i?!7KnKJYZaz)MU{mhHd{iUM!p;`@tD@~x&8y-OKqclWkXbi}~G05+pw3c>Vi zTlB5C+S*zWTH~ka_X!Gk1qJg;OCyni?hkIiKe7K@Ru=A`%YIBgzjE#&O9Ur?2r$U&*Pl@k6OBfPH zjE%YD8vQ8X#Qr~l0l#j54j~8>90WeFrnjUnq+^yn=lnV?%RqxN4>CRq2e^FjpbAXM z(3)mkQFyjnXF0e1FQQv4+B!RHDk}lGon{-TEMtJ}=H}!C$ueRN{QUWIU~Iy6Q6ic6 zL%Z9b9vN&ha`G7FTJNKceyM8{X5zO&LE}?XtzW#>2Z89{C45IhLt|`gEY|xR1ZYrj z@QnsEIq!N)sI_)VbX(}!N$QsK}tFwIsp#`CBggO;S3xa#+Bof zCwG0#05dHu7sIFoz}Fud9JC;M-E0FSo+Vaf;BaJU2;=+)Z7|gPon7{r&wtJq{ouqEeqMb%aL+l+@Qx_4MGU(tyYnmUsk~ zoI6K=Gy@VFDi=a8#`}rgE23gz=0JS_pq@N=LJIIC4+stNi~K`wQ4t59L(TKKhyzkB z(z~R%@OVI=A)I3?J5^KBzP!8ysB?01f~)h|!-~OGS|pJNtY}Qp*m)g+f#@u;g_)TP z@a>HaQC?mPdwaZp-QW`F>5+$F#V{8Y6~XKTz6M#q#PBflojVwKsp;uvKxE}L;U}0f z(#(9P-;lDv0?d8)pwvMm0#ySKfhoERq)kgpCMbldDPvR9nYK1egDM8&XV3Ccr)*Je zfJ;E~Zeex;R71Ed`ANN|M@?V*^_MT4TkfxG8H9z$hlT{0m;%iReC3GkeF1i%N_>3I zUSWGL z>be{P97K_s822pzgU`wK+hs-gyZt(=q2c1}XcMCIx-bp4RPdZqdP_=6^YO&(M>&I# zYI@k^GDT2|ss}~uFe>y)&FCm8L;S%vC$FPXyCtJZsuc4zx4AM3kSXzVGZ#1tP-jTl zgFn3_AKF1lN&7#jKQ^loa>zqcngsBjA!iMNiHXS~Q#Zt*f1)cyh3DZ9JPt@L7q(2>K@((Y?Y8X7rD5v3S-f*ng2_1t^j6~GsS#l+ldO}r<` z=1K0cvp2rFob2l(#A786&1hl>0`HLRJxIEMQYc(%disumY&bo1mnw@J1S$}9TbCJt z*aO=NQwGF%vky6!(J+ukq?U#TbpDMR$OU@gw!#!(PX|-XSgdli-AjHO%B6 zu+Y(DkT9YF`$5wujt>nCltEq%yED`!{{=B%8yiopZ^d8d6<%EUo>CgLLpjLw^SeU= z?ELKJjT`S#S?~kygby6d%*+{kJ^h|Lv$-9SUm&1-*V6_T1uPYuGN925JS_nMflLiy zP}kNiFxTY_y1{{j)`z@qK=`=~Gx1{zb_QNvK)gg+FUz?d=>K@QutKK7>#Z2FS{0X%itX?hkHX*!>}# z7m8wnu3Qr%m9MI)A;D}}aW&+OPfw>;ih);&e?!jl;qKlZny4^?xVSG&20$5TI?$+K zh*|ucD1U;tmALk^k&%P}#RYJ@^5+kX#D@wBG*nbaCnvGY>)YGheA%JxmhgfD8P+C# z0{a2;AKvixT+_9Td!N#uLWo}!dBOU#28U8X-5soTFeL+?aob#jRAz~t`2E`%Qrw^@ zP`W`90_^O++S{?NeGmQ+eEJWG8{Ae2-?V)5I(Q130$7%jm}n+G%|I1_Tu1CQ!^Rqm ziizs#Y8VO9_3-JqrM{sd4wVP9UWfl{e@nW)t}YENtslmT2dn*ef}r92&JJyF-HHqe z3F%JYfv8cLazW5>l9ZhMM$)Gs*~jkg_hpb^9Kkq%`hn#^HfrhU+=py2kO7h_S{fR> zOs3!V^I@)FTK>;E0XlsD!2=jj2mAZr2KGTS1B7L2oWerzC#gD&fG7Bvml9GtVnSc$ zN8i1Vesy#_1zX`|jh?1viv=${Ew~fPYGJRjQBt_E zIT!5Rzegpas zl}q@p!m5){lywynHjB+>B8HRg8F<3a#l`Rh?D!HPv^GvouP)E3z!Gk1x?Wpj^V0#l zIIP72o(JMK-{Y+bOqs6+oM)U+JUN?WO#HGMrwtDf1NNDelVbFy>R2u$VUUt;Q1;~x{x+Y7Z@u&EKsPV z@<2X=gMw_}u(dTbFu=xyiK!IX$pK0m2Pfbl`{PGazxbnr128>dSiaFYJFN5s?;Nbd ztNm^s*h-UU&<(=|xC#~i4Tq)WtsJttw2>+U-tiRTyoU6oDHylg4vJ~EQDVAFx zB@B&j$P>v9yrJ-*KnZuHU{hmy4P<}RB2^N0wU03kS&-Kr&?|{6qfMb7A4*zHy>5Tk z=<7e{)+c@m_ObiGrqe$O`}3{Toz~TbOPm{T=EH@-oz2~8E#FEKc-G~3kjf_M2Q2QZ z)Z}*`p*}R2XnQZkJ?iPwL%>cF?}d8@JInwX1Xvu|DIhEy!pbj$L=TV#`U=?Nm9Czv zC74nSTZZT(VT~!nJHVb+d-MqFjm)S1v8k#0r@hq0dQ-#0ZRHL?C;k1K*xp0Ukbh{m z=5KLtEq4I>M;07T8xUH6AyHdci)+kq(HLdf4R=xgntgLaWm5U{Rp8N&Tk;I5?8wN7 z>}+jCAlHDsW@e?&;d8$;_~f0RGhitwL{=6Sh+fuRYk_fqA0*^3&MPK1H8$4CiyyZ| zz%Fv*4I?FfI*?c>^D=`iD1V?wUyX`cVr^ma&BtT(KM>CA?(WXKue-h(B%2AOL?K%< z7kkP7`Mp7F$xk~FTm(oOlmpNrmcRt{{5$yqpjDXu)%BGhY-@sGGFlOkLAHHl=TA*r zRO`Yn7@#sK3y{|0w`$1FFoV5lXlMxWazKK!AamMH(rCptyQ;u`RM7}O{+*(b1F2O{ z`KcBc@6A!JTz=f|$O48;U7Gx-PL ziNFW3-n5jIltARWFYdp$*bZb3^c)~F2v{Hp!H>a|)cGId*M@b}(AWhr1{*wpY;(dN zR@Qe*!tqZoUtPogvERSp?wdY2kolBX-QJ07k~M+vT}I!U}0ix^C&(pt|fH; zR~!c*%2%BKH}8Z}dY$8gTVUXw(!Ng;SU?m7qk*HT%S~-dE=_aSD&`6UTHls&-fZsZ#26ZG0CV{-(|IZWUjR;h zZgc-XK?)QPRF1cJIv8|sS~QG}Rg!LqS}R@igyg8~d4G>8mu9rzQ|+3y4P=nskYW)N zGggW;iAOO7m}Ve!-!Z>u>Mmzc2)#0l#<}$eOy4Ip(FQJ2S)V^Ei<%*We*IFO*vr{( zq$VW`Dj-3S(`o$YSQn_XRFSeoD*{`B2vo}V6q(utbE*7}VLVn-QR_m+1|ll8nPpjk zG3a<_?$#_LzEfW=v6l+`AI;l=Jufsd+P>)+;Q}TKraa0Xh@x@FH8C9;8-v03a9vXC zctx17?r`nMJO0USsaL9mf|U48A3xodQePO6I5xc@5zlpu5Y*`i)4H91`C+=@q z(#5xivn`ly+@jxQM{nnvYmBt zuxPS(@q;rn;Yjo<|LEU&@l~Y#2lJJ%w-bBzWl4-T3;)V1 zDd9*)eG+y-Cla{NLQ5!TM;EH2rGAk#ubMSmb5|-`+o(KhJZZsH+IG%CFjgu$Cii7} z=f=7nxY;D~nn+A+-(RBtobydA+TW9vHyUa@zO%lyb)g?0Smzu=C+5+W&L#Qk0$YaJ zwnFNQoSKm`64Sr{;+gD9WoZO%EO_aWomOR(Jqp%VvZ}n4%wrGMtXbtho1jUsjbu=^ z$J7-7$NH)P=lnADH`v+A%q-pE9J4SNq5{1vNFkDjR0@2bu@CvQ#UTgFaH5x}1`q zG1_vqFHNV9`zRek?`6$0*l`0B>uE);Nr{Md!K;?YzJrE`*_wuDqLPwM_o)l-;luJoV^ZjBAc@NcgH^aTJg$AnaiImH@+!etJ@zzRXd?Yh@BJ% QyVVg&@@l9OS&P8`1M9UKlK=n! literal 0 HcmV?d00001 diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/wmimgr.cls b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/wmimgr.cls new file mode 100644 index 0000000..4fc9f56 --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/uam-wmi-msc/wmimgr.cls @@ -0,0 +1,416 @@ +{% raw %} +% Klasa dokument\'ow do sk{\l}adu prac magisterskich/licencjackich +% na wydziale Matematyki i Informatyki UAM +% Klasę oparto na analogicznej klasie stworzonej Wydziale +% Zarz\k{a}dzania Uniwersytetu Gda\'nskiego (wersja 1.10): +% http://gnu.univ.gda.pl/~tomasz/prog/tex/wzmgr/wzmgr.html +% Ta klasa była z kolei oparta na klasie opracowanej +% przez Marcina Woli\'nskiego. + +\def\ThisClassVersionId{v1.0} +% +\NeedsTeXFormat{LaTeX2e} +\ProvidesClass{wmimgr}[2009/06/19 \ThisClassVersionId, Praca magisterska] + +\def\@baseclass{report} +\def\@rodzajpracy{magisterska} +\def\@BInterlinia{\relax} +\DeclareOption*{\PassOptionsToClass{\CurrentOption}{\@baseclass}} +\PassOptionsToClass{a4paper,openany,11pt}{\@baseclass} +% +\newif\if@wmimgrauthoryear +\DeclareOption{autorrok}{\@wmimgrauthoryeartrue} +\newif\if@wmimgrbackref \DeclareOption{backref}{\@wmimgrbackreftrue} +\newif\if@oswiadczenie \DeclareOption{oswiadczenie}{\@oswiadczenietrue} +\DeclareOption{licencjacka}{\def\@rodzajpracy{licencjacka}} +\DeclareOption{skorowidz}{\input{makeidx.sty}\makeindex} +\DeclareOption{palatino}{\input{tgpagella.sty}} +\DeclareOption{tgpagella}{\input{tgpagella.sty}} +\DeclareOption{twoside}{\PassOptionsToClass{twoside}{\@baseclass}} +% opcja `brudnopis' jest poprawiona -- teraz wykorzystuje pakiet `prelim2e' +\DeclareOption{brudnopis}{\AtEndOfClass{\input{prelim2e.sty}% + \renewcommand{\PrelimWords}{\ThisDocVersionId}\linespread{1.0}}} +\DeclareOption{xodstep}{\AtEndOfClass{\linespread{1.3}}} +\ProcessOptions +% +\LoadClass{\@baseclass} +% +\usepackage{graphicx} +\usepackage{polski} +\usepackage[utf8]{inputenc} +%% +\if@wmimgrbackref + \usepackage[breaklinks,pagebackref]{hyperref}\else + \usepackage[breaklinks]{hyperref} \fi + \if@wmimgrauthoryear + \typeout{*** Cytowanie autor-rok ***}\RequirePackage[numbers]{natbib}\fi +% +% +\textwidth\paperwidth +\advance\textwidth -55mm +\oddsidemargin-1in +\advance\oddsidemargin 30mm +\evensidemargin-1in +\advance\evensidemargin 25mm +\topmargin -1in +\advance\topmargin 25mm +\setlength\textheight{48\baselineskip} +\addtolength\textheight{\topskip} +\marginparwidth15mm +% +\widowpenalty999999 +\tolerance450 +\pretolerance250 +\hfuzz=1.5pt +\hbadness1450 +% +\def\AndNextAuthor{\ifnum\language=0\& \else i \fi} +\newcount\authornumber +\authornumber=0 +% +\def\author#1{% + \global\advance\authornumber\@ne + \expandafter\def\csname theauthor\number\authornumber\endcsname + {\ignorespaces#1\unskip}% + \expandafter\def\csname theauthorid\number\authornumber + \endcsname{???\ClassError{wmimgr}{Brak numeru albumu}\@ehc}% + \expandafter\let\csname thenetaddress\number\authornumber\endcsname\relax } +% +\def\nralbumu#1{% + \expandafter\def\csname theauthorid\number\authornumber\endcsname + {\ignorespaces#1\unskip}} +\def\email#1{% -- opcjonalny -- + \expandafter\def\csname thenetaddress\number\authornumber\endcsname + {\ignorespaces#1\unskip}} + +%%\def\authorlist#1{\def\@author{#1}} +\def\@author{\@defaultauthorlist} + +\def\@subtitle{} +\def\@logo{} + +\newcount\count@@ + +\def\@defaultauthorlist{% + \count@=\authornumber + \count@@=0 + \loop + \ifnum\count@>0 + \advance\count@@ by 1 + \begingroup \Large\bf + \ignorespaces\csname theauthor\number\count@@\endcsname\par + \normalsize \rm nr~albumu: + \ignorespaces\csname theauthorid\number\count@@\endcsname\par + % adres email nie jest drukowany -- ale si{\e} przyda + %%\ignorespaces\csname thenetaddress\number\count@@\endcsname + \par + \medskip \endgroup + \advance\count@ by -1 + \repeat + } + + % << +\def\UniversityName#1{\def\Univ@Name{#1}} +\def\Univ@Name{UNIWERSYTET IM. ADAMA MICKIEWICZA \\ WYDZIA\L{} + MATEMATYKI I INFORMATYKI}% + % << +\renewcommand\maketitle{% + \begin{titlepage}% + \let\footnotesize\small + \let\footnoterule\relax + \let \footnote \thanks + \begin{center}% + {\large \textbf{\Univ@Name}\par} + \par + \@logo + \end{center}% + \vspace{1cm plus 1fill} + \begin{flushleft}% + {\@author\par} + \end{flushleft}% + \vspace{8mm plus 1mm minus 2mm} + \begin{center}% + {\huge\textbf{\@title}\par} + \vspace{0.5cm} + {\LARGE\textit{\@subtitle}\par} + \vspace{2cm plus 1.5fill} + \begin{flushright}\large + \begin{tabular}{l} + Praca \@rodzajpracy{} na kierunku:\\[3pt] + \MakeUppercase{\@kierunek}\\[3pt] + Promotor: \\[3pt] + \bfseries \@opiekun + \end{tabular} + \end{flushright} + \vspace{15mm plus .1fill} + {\large \@miejsce\space \@date\par} + \end{center} + \@thanks + \end{titlepage}% + % + \setcounter{footnote}{0}% + \global\let\thanks\relax + \global\let\maketitle\relax + \global\let\@thanks\@empty + \global\let\@author\@empty + \global\let\@date\@empty + \global\let\@title\@empty + \global\let\title\relax + \global\let\@subtitle\@empty + \global\let\subtitle\relax + \global\let\logo\relax + \global\let\author\relax + \global\let\date\relax + \global\let\and\relax + % + % Jezeli podano slowa kluczowe wydrukuj + \clearpage + \if@oswiadczenie\oswiadczenie\fi + \thispagestyle{empty} + \ifvoid\abspagebox \@latex@warning{*** Nie podano streszczenia ***}% + \else \InsertAbstractHere \fi + \ifx\@keywords\EmptyKwsList \@latex@warning{*** Nie podano slow kluczowych ***}% + \else \section*{S{\l}owa kluczowe} + \@keywords + \fi + \cleardoublepage %% + \tableofcontents + %\listoftables + %\listoffigures +} %% --renewcommand: maketitle -- + +%%\def\nralbumu#1{\gdef\@nralbumu{#1}} +%%\def\@nralbumu{???\ClassError{wmimgr}{Brak numeru albumu}\@ehc} +\def\title#1{\gdef\@title{#1}\gdef\thetitle{#1}} +\def\subtitle#1{\gdef\@subtitle{#1}} +\def\logo#1{\gdef\@logo{#1}} +\def\kierunek#1{\gdef\@kierunek{#1}} +\def\@kierunek{???\ClassError{wmimgr}{Nie podano kierunku studiow}\@ehc} +\def\opiekun#1{\gdef\@opiekun{#1}} +\def\@opiekun{???\ClassError{wmimgr}{Brak danych opiekuna pracy}\@ehc} +\def\miejsce#1{\gdef\@miejsce{#1}} +\def\@miejsce{Sopot} +% +\def\keywords#1{\gdef\@keywords{#1}} +% slowa kluczowe sa opcjonalne: +%%\def\@keywords{???\ClassError{wmimgr}{Brak slow kluczowych}\@ehc} +\def\@keywords{????} +\def\EmptyKwsList{????} +%% +\def\klasyfikacja#1{\gdef\@klasyfikacja{#1}} +\def\@klasyfikacja{???\ClassError{wmimgr}{Brak klasyfikacji + tematycznej}\@ehc} +% +\newbox \abspagebox %% *tp ** +\def\InsertAbstractHere{\unvbox \abspagebox} +% +\renewenvironment{abstract}{\global + \setbox \abspagebox \vbox \bgroup + \section*{Streszczenie} } + {\egroup} +% +\renewcommand*\@seccntformat[1]{\csname the#1\endcsname.\enspace} +\def\numberline#1{\hb@xt@\@tempdima{#1.\hfil}} +\renewcommand*\l@chapter[2]{% + \ifnum \c@tocdepth >\m@ne + \addpenalty{-\@highpenalty}% + \vskip 1.0em \@plus\p@ + \setlength\@tempdima{1.5em}% + \begingroup + \parindent \z@ \rightskip \@pnumwidth + \parfillskip -\@pnumwidth + \leavevmode \bfseries + \advance\leftskip\@tempdima + \hskip -\leftskip + #1\nobreak\mdseries + \leaders\hbox{$\m@th + \mkern \@dotsep mu\hbox{.}\mkern \@dotsep + mu$}\hfill + \nobreak\hb@xt@\@pnumwidth{\hss #2}\par + \penalty\@highpenalty + \endgroup + \fi} +% +\def\@makechapterhead#1{% + %\vspace*{50\p@}% + {\parindent \z@ \raggedright \normalfont + \ifnum \c@secnumdepth >\m@ne + \normalsize \bfseries \MakeUppercase{\@chapapp}\space \thechapter + \par\nobreak + \vskip\baselineskip + \fi + \interlinepenalty\@M + \LARGE \bfseries #1\par\nobreak + \vskip 40\p@ + }} +% +\def\@makeschapterhead#1{% + %\vspace*{50\p@}% + {\parindent \z@ \raggedright + \normalfont + \interlinepenalty\@M + \LARGE \bfseries #1\par\nobreak + \vskip 40\p@ + }} +% +\renewcommand{\section}{\@startsection{section}{1}{\z@}% + {-3.5ex \@plus -1ex \@minus -.2ex}% + {2.3ex \@plus.2ex}% + {\reset@font\Large\bfseries\raggedright}} +\renewcommand{\subsection}{\@startsection{subsection}{2}{\z@}% + {-3.25ex\@plus -1ex \@minus -.2ex}% + {1.5ex \@plus .2ex}% + {\reset@font\large\bfseries\raggedright}} +\renewcommand{\subsubsection}{\@startsection{subsubsection}{3}{\z@}% + {-3.25ex\@plus -1ex \@minus -.2ex}% + {1.5ex \@plus .2ex}% + {\reset@font\normalsize\bfseries\raggedright}} +\renewcommand{\paragraph}{???\ClassError{wmimgr}{Zbyt duzo srodtytulow}\@ehc}% +% +% Skorowidz: dodanie kresek w pozycjach skorowidza stopnia drugiego +\renewenvironment{theindex}{% + \clearpage \refstepcounter{chapter}% potrzebne do prawid{\l}owego + % dzia{\l}ania zak{\l}adek w dokumencie PDF + \columnseprule \z@ \columnsep 35\p@ + \twocolumn[\@makeschapterhead{\indexname}]% + \@mkboth{\indexname}{\indexname}% + \addcontentsline{toc}{chapter}{\indexname}% + \thispagestyle{plain}\parindent\z@ + \parskip\z@ \@plus .3\p@\relax + \let\item\@idxitem } + {\clearpage } +\def\indexemdashes{% +\def\@idxitem{\par\hangindent 0pt} +\def\subitem{\par\hangindent 0pt --- } +\def\subsubitem{\par\hangindent 0pt --- --- } +\def\indexspace{\par \vskip 10pt plus 5pt minus 3pt\relax}} +\indexemdashes +% +% Wprowadzenie/zako\'nczenie +\newcommand{\introduction}{%\doublepage + \chapter*{\IntroName\@mkboth{\IntroName}{\IntroName}}% +\addcontentsline{toc}{chapter}{\IntroName}} +% +\newcommand{\summary}{%\doublepage + \chapter*{\SummaryName\@mkboth{\SummaryName}{\SummaryName}}% +\addcontentsline{toc}{chapter}{\SummaryName}} +% O\'swiadczenie (dodane 7.4.2005) +\def\oswiadczenieText{% +\par +Ja, ni\.zej podpisany {\csname theauthor1\endcsname}, student +Wydzia{\l}u Matematyki i~Informatyki Uniwersytetu im.~Adama Mickiewicza +w~Poznaniu, o\'swiadczam, \.ze przedk{\l}adan\k{a} prac\k{e} dyplomow\k{a}~ +pt.~{\emph{\let\\=\relax\thetitle}\/} napisa{\l}em samodzielnie. Oznacza to, +\.ze przy pisaniu pracy, poza niezb\k{e}dnymi konsultacjami, nie korzysta{\l}em +z~pomocy innych os\'ob, a~w~szczeg\'olno\'sci nie zleca{\l}em opracowania +rozprawy lub jej cz\k{e}\'sci innym osobom ani nie odpisywa{\l}em tej rozprawy +lub jej cz\k{e}\'sci od innych os\'ob.\par +O\'swiadczam r\'ownie\.z, \.ze egzemplarz pracy dyplomowej w~formie wydruku +komputerowego jest zgodny z~egzemplarzem pracy dyplomowej w~formie +elektronicznej.\par +Jednocze\'snie przyjmuj\k{e} do wiadomo\'sci, \.ze gdyby powy\.zsze +o\'swiadczenie okaza{\l}o si\k{e} nieprawdziwe, decyzja o~wydaniu mi dyplomu +zostanie cofni\k{e}ta.\endgraf } +% +\long\def\oswiadczenie{%%\newpage +\if@twocolumn \onecolumn \fi +%%\centerline{\large\textbf{O\'swiadczenie}} +%%\vspace*{50mm} +\chapter*{O\'swiadczenie}% +\addcontentsline{toc}{chapter}{O\'swiadczenie}% +%\hbox to.8\textwidth{\hbox to45mm{\dotfill}\hss +\thispagestyle{empty} +\vskip6mm +\begin{flushright}\large + Pozna\'n, dnia \hbox to40mm{\dotfill} +\end{flushright} +\par +\vskip12mm +\noindent +\oswiadczenieText +\par\vskip20mm +\centerline{\vbox{% +\hbox to.8\textwidth{\hbox to50mm{}\hss + \hbox to50mm{\dotfill}} +\hbox to.83\textwidth{\hbox to60mm{}\hss +\hbox to60mm{\hss podpis\hss}}% +}}\par +\newpage } +% +% Polecenia listoffigures/listoftables uproszczono oraz +% dodano \addcontentsline, tak aby tytu{\l} spisu pojawi{\l} +% si\k{e} w spisie tre\'sci i zak\ladkach w pliku PDF: +\renewcommand\listoffigures{% + \chapter*{\listfigurename + \@mkboth{\MakeUppercase\listfigurename}% + {\MakeUppercase\listfigurename}}% + \addcontentsline{toc}{chapter}{\listfigurename} + \@starttoc{lof}} +% +\renewcommand\listoftables{% + \chapter*{\listtablename + \@mkboth{% + \MakeUppercase\listtablename}{\MakeUppercase\listtablename}}% + \@starttoc{lot}% + \addcontentsline{toc}{chapter}{\listtablename}} +% +\renewenvironment{thebibliography}[1] + {\chapter*{\bibname}% + \@mkboth{\MakeUppercase\bibname}{\MakeUppercase\bibname}% + \addcontentsline{toc}{chapter}{\bibname}%<-- + \list{%% + \@biblabel{\@arabic\c@enumiv}}%\fi}% + {%% + \settowidth\labelwidth{\@biblabel{#1}}% + \leftmargin\labelwidth + \advance\leftmargin\labelsep + \@openbib@code + \usecounter{enumiv}% + \let\p@enumiv\@empty + \renewcommand\theenumiv{\@arabic\c@enumiv}}% + \sloppy + \clubpenalty4000 + \@clubpenalty \clubpenalty + \widowpenalty4000% + \sfcode`\.\@m} + {\def\@noitemerr + {\@latex@warning{Empty `thebibliography' environment}}% + \endlist} + +% Uproszczono polecenie \@makecaption, tak \.ze podpisy s\k{a} +% teraz sk{\l}adane od lewego marginesu. +% Dodano polecenie \source do sk{\l}adania \'xr\'od{\l}a +\long\def\@makecaption#1#2{\par + \vskip\abovecaptionskip + \begin{flushleft}\small\textbf{#1}. #2\end{flushleft} + %\vskip\belowcaptionskip % niepotrzebne bo po caption + %winno by\'c \'xr\'od{\l}o + \par +} +\def\source#1{\par \begin{flushleft}\small +\SourceName:~#1\end{flushleft}} +% +% Oznakowanie wersji dokumentu na ka\.zdej stronie w postaci +% adresu e-mail pierwszego autora (je\.zeli jest zdefiniowany) lub imienia +% i nazwiska pierwszego autora + tego co autor wpisa{\l} jako +% argument polecenia \nrwersji + bie{\.z}\k{a}ca data. +\def\nrwersji#1{\def\ThisDocVersion{#1}}\nrwersji{????}% +\def\ThisDocVersionId{% + \expandafter \ifx \csname theauthor1 \endcsname \undefined + \else \csname theauthor1\endcsname \fi + %% adres moze zawierac nie-litery (np `_' powoduje blad), pomijam + %\expandafter \ifx \csname thenetaddress1\endcsname \undefined + %\else \csname thenetaddress1\endcsname \fi + \space --\space wersja \ThisDocVersion\space z\space + \number\day/\number\month/\number\year~r. } +% +\def\IntroName{Wprowadzenie} +\def\SummaryName{Zako\'nczenie} +\def\SourceName{\'Zr\'od{\l}o} +\newcommand{\eng}[1]{(ang.~\emph{#1})} +\newcommand{\english}[1]{\textit{#1}} +\newcommand{\turkish}[1]{\textit{#1}} +\newcommand{\code}[1]{\texttt{#1}} +% +\endinput +{% endraw %} diff --git a/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/{{cookiecutter.thesis_surname}}.tex b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/{{cookiecutter.thesis_surname}}.tex new file mode 100644 index 0000000..1c6d4dd --- /dev/null +++ b/{{cookiecutter.thesis_type}}-{{cookiecutter.thesis_surname}}/{{cookiecutter.thesis_surname}}.tex @@ -0,0 +1,78 @@ +{% raw %} + +\documentclass[skorowidz,autorrok,backref,xodstep]{wmimgr} + +\usepackage{listings} +\usepackage{color} +\usepackage{alltt} +\usepackage{floatrow} +\usepackage{hyphenat} +\usepackage{url} + +\newcommand\dbr{\discretionary{}{}{}} + +\usepackage{hyperref} +\usepackage{xstring} +% Format a reference to a Gonito submission +\newcommand{\gonitoref}[1]{\{\href{https://gonito.net/q/#1}{\StrMid{#1}{1}{6}}\}} +% A bare score from Gonito +\newcommand{\gonitobarescore}[1]{\minput{scores/#1.txt}} +% A score from Gonito along with a reference +\newcommand{\gonitoscore}[1]{\gonitobarescore{#1} \gonitoref{#1}} +% A reference and a score as two cells in a table +\newcommand{\gonitoentry}[1]{\gonitoref{#1} & \minput{scores/#1.txt}} + +\newcommand{\code}[1]{\texttt{#1}} +\newcommand{\noqa}[1]{} + +\input{preamble} + +\input{metadata} + + +% Cytowanie przez numer (standard): +%\bibliographystyle{plain} +% +% Jeżeli cytowanie autor-rok to np.: +\bibliographystyle{papalike} +% +% Inne sposoby +%\bibliographystyle{abbrv} %% standard +%\bibliographystyle{acm} %% ACM transactions... +%\bibliographystyle{elsart-harv} %% dziwaczny %% + +%%% zakomentuj \iffalse ... \fi (ostatnie, zaznaczone //pdfscreen) jeżeli chcesz włączyć pakiet pdfscreen: +\def\SITI{SI/TI} %%% +\def\ISTI{SI/TI} %%% +\def\UTAUT{UTAUT} %%% + +\begin{document} + +%% +\nocite{beebe,p.perl} %% dołącza niecytowane +%%\nocite{*} %% ** dołącza wszystko ** + + +% Tytuł/spis treści +\maketitle + +\input{main} + +\input{appendix} + +%\include bib.tex +\bibliography{bibliography} + +% +% Spis tabel (jeżeli jest potrzebny): +\listoftables +% +% Spis rysunków (jeżeli jest potrzebny): +\listoffigures + +% +% Skorowidz (opcjonalnie) +\printindex + +\end{document} +{% endraw %}