summaryrefslogtreecommitdiff
path: root/support/nlatexdb/nlatexdb/Processer.cs
diff options
context:
space:
mode:
Diffstat (limited to 'support/nlatexdb/nlatexdb/Processer.cs')
-rw-r--r--support/nlatexdb/nlatexdb/Processer.cs516
1 files changed, 516 insertions, 0 deletions
diff --git a/support/nlatexdb/nlatexdb/Processer.cs b/support/nlatexdb/nlatexdb/Processer.cs
new file mode 100644
index 0000000000..0935cb2c1e
--- /dev/null
+++ b/support/nlatexdb/nlatexdb/Processer.cs
@@ -0,0 +1,516 @@
+// nlatexdb Version 0.03
+// Database Access in LaTeX
+// Copyright (C) 2011 Robin Höns, Integranova GmbH
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+// For more information see the web page http://hoens.net/robin
+
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.IO;
+
+
+
+namespace nlatexdb
+{
+ class Processer
+ {
+ public Processer()
+ {
+ m_verbosity = 0;
+ m_encoding = Encoding.GetEncoding(1252);
+ m_commandlineargs = new List<string>();
+
+ m_activecommand = null;
+ m_cmds = new List<CommandParser>();
+ m_cmds.Add(new CommandParser("texdbconnectionnet", 2, false, texdbconnection));
+ m_cmds.Add(new CommandParser("texdbdef", 3, false, texdbdef));
+ m_cmds.Add(new CommandParser("texdbfor", 2, true, texdbfor));
+ m_cmds.Add(new CommandParser("texdbforfile", 3, true, texdbforfile));
+ m_cmds.Add(new CommandParser("texdbif", 2, true, texdbif));
+ m_cmds.Add(new CommandParser("texdbcommand", 1, false, texdbcommand));
+
+ m_qrys = new Dictionary<string, SqlQuery>();
+ m_varvalues = new Dictionary<string, SqlQueryVar>();
+ m_latexpostprocess_wholefile = true;
+
+ m_cmdlineargvarprefix = "##";
+
+ SqlQueryVar.ClearLatexReplace();
+ SqlQueryVar.AddLatexReplace('\\', @"\ensuremath{\backslash}");
+ SqlQueryVar.AddLatexReplace('_', @"\_");
+ SqlQueryVar.AddLatexReplace('$', @"\$");
+ SqlQueryVar.AddLatexReplace('&', @"\&");
+ SqlQueryVar.AddLatexReplace('#', @"\#");
+ SqlQueryVar.AddLatexReplace('{', @"\{");
+ SqlQueryVar.AddLatexReplace('}', @"\}");
+ SqlQueryVar.AddLatexReplace('~', @"\~{}");
+ SqlQueryVar.AddLatexReplace('%', @"\%");
+
+
+ ReadAppConfig();
+ }
+
+ private void ReadAppConfig()
+ {
+ NlatexdbSettings settings = System.Configuration.ConfigurationManager.GetSection("NlatexdbSettings")
+ as NlatexdbSettings;
+ if (settings != null)
+ {
+ string cmdl2 = settings.CmdLineArgumentVarPrefix;
+ if (!String.IsNullOrEmpty(cmdl2))
+ {
+ m_cmdlineargvarprefix = cmdl2;
+ Debug("prefix: {0}", cmdl2);
+ }
+
+ string regexsplitter = settings.RegexSplitter;
+ if (!String.IsNullOrEmpty(regexsplitter))
+ {
+ SqlQueryVar.SetRegexSplitter(regexsplitter);
+ }
+
+ string varsplitter = settings.VariableSplitter;
+ if (!String.IsNullOrEmpty(varsplitter))
+ {
+ SqlQuery.SetVariableSplitter(varsplitter);
+ }
+
+ LatexCharReplaceCollection lrcoll = settings.LatexCharReplaceItems;
+ foreach (LatexCharReplaceElement lrelem in lrcoll)
+ {
+ Debug("replace: {0} by: {1}", lrelem.Char[0], lrelem.Replace);
+ SqlQueryVar.AddLatexReplace(lrelem.Char[0], lrelem.Replace);
+ }
+ }
+ }
+
+ public void setInpath(string path)
+ {
+ m_inpath = path;
+ }
+ public void setOutpath(string path)
+ {
+ m_outpath = path;
+ }
+ public void setLatexbefehl(string befehl)
+ {
+ m_latexbefehl = befehl;
+ }
+ public void setEncoding(string enc)
+ {
+ if (enc.Equals("utf-8", StringComparison.InvariantCultureIgnoreCase))
+ {
+ m_encoding = new UTF8EncodingWithoutPreamble();
+ }
+ else
+ {
+ try
+ {
+ m_encoding = Encoding.GetEncoding(enc);
+ }
+ catch (Exception ex)
+ {
+ Console.WriteLine(ex.Message);
+ Debug(ex.ToString());
+ }
+ }
+ }
+
+ public void incVerbosity()
+ {
+ m_verbosity++;
+ }
+
+ public void addCmdlineArg(string arg)
+ {
+ m_commandlineargs.Add(arg);
+ string key = m_cmdlineargvarprefix + m_commandlineargs.Count.ToString();
+ m_varvalues[key] = new SqlQueryVar(key, arg);
+;
+ }
+
+ public int Go()
+ {
+ int ergebnis = 0;
+ try
+ {
+ if (String.IsNullOrEmpty(m_inpath))
+ {
+ throw new Exception("No input file given!");
+ }
+
+ string outpath = m_outpath;
+ if (String.IsNullOrEmpty(outpath))
+ {
+ outpath = m_inpath.Replace(".tex", "1.tex");
+ if (String.IsNullOrEmpty(outpath))
+ {
+ outpath = String.Concat(m_inpath, "1");
+ }
+ }
+
+ using (StreamReader sr = new StreamReader(m_inpath, m_encoding))
+ {
+ try
+ {
+ OpenOutstream(outpath);
+
+ string line;
+ while ((line = sr.ReadLine()) != null)
+ {
+ HandleLine(line);
+ }
+ }
+ finally
+ {
+ CloseOutstream();
+ }
+ }
+
+ LatexPostprocess(outpath, true);
+
+
+ }
+ catch (Exception ex)
+ {
+ Console.WriteLine(ex.Message);
+ Debug(ex.ToString());
+ ergebnis = 1;
+ }
+ finally
+ {
+ if (m_conn != null)
+ {
+ try
+ {
+ m_conn.Close();
+ }
+ catch
+ {
+ }
+ }
+
+ if (m_outstream != null)
+ {
+ try
+ {
+ m_outstream.Close();
+ }
+ catch
+ {
+ }
+ }
+ }
+ return ergebnis;
+ }
+
+ public void OpenOutstream(string outpath)
+ {
+ CloseOutstream(); // just in case
+ System.IO.FileStream outstream =
+ new System.IO.FileStream(outpath, System.IO.FileMode.Create, System.IO.FileAccess.Write);
+ m_outstream = new System.IO.StreamWriter(outstream, m_encoding);
+ }
+
+ public void CloseOutstream()
+ {
+ if (m_outstream != null)
+ {
+ m_outstream.Close();
+ m_outstream=null;
+ }
+ }
+
+ public void LatexPostprocess(string texinputpath, bool renametoinpath)
+ {
+ if (renametoinpath && !m_latexpostprocess_wholefile)
+ {
+ // If there was a \texdbforfile command, don't postprocess the
+ // top file: It is expected to be empty.
+ return;
+ }
+
+ if (!String.IsNullOrEmpty(m_latexbefehl))
+ {
+ System.Diagnostics.Process p = new System.Diagnostics.Process();
+ p.StartInfo.FileName = m_latexbefehl;
+ p.StartInfo.CreateNoWindow = true;
+ p.StartInfo.Arguments = texinputpath;
+ p.Start();
+ p.WaitForExit();
+
+
+ string extension = null;
+ if (m_latexbefehl.Equals("latex"))
+ {
+ extension = "dvi";
+ }
+ else if (m_latexbefehl.Equals("pdflatex"))
+ {
+ extension = "pdf";
+ }
+
+ if (renametoinpath && !String.IsNullOrEmpty(extension))
+ {
+ string filefromlatex = System.IO.Path.ChangeExtension(texinputpath, extension);
+ string filetorename = System.IO.Path.ChangeExtension(m_inpath, extension);
+ System.IO.File.Delete(filetorename);
+ System.IO.File.Move(filefromlatex, filetorename);
+ }
+
+
+ }
+
+ }
+
+ public void ListProviders()
+ {
+ System.Data.DataTable providers = System.Data.Common.DbProviderFactories.GetFactoryClasses();
+ foreach (System.Data.DataRow provider in providers.Rows)
+ {
+ foreach (System.Data.DataColumn c in providers.Columns)
+ Console.WriteLine(c.ColumnName + ":" + provider[c]);
+ Console.WriteLine("---");
+ }
+ }
+
+
+// private void HandleLineUnlessEmpty(string line)
+// {
+// if (!String.IsNullOrEmpty(line))
+// {
+// HandleLine(line);
+// }
+// }
+
+ private void HandleRestOfLine(string line, int hintercmd)
+ {
+ if (hintercmd >= 0 && hintercmd < line.Length)
+ {
+ HandleLine(line.Substring(hintercmd));
+ }
+ }
+
+ public void HandleLine(string line)
+ {
+ if (m_activecommand != null)
+ {
+ // Aha, ein Kommando ist aktiv. Sammele die Zeilen.
+ int hintercmd = m_activecommand.ProcessLine(line);
+ HandleRestOfLine(line, hintercmd);
+ return;
+ }
+
+ // Erstmal schauen nach Kommentar
+ int prozentsuche = 0;
+ int prozentindex = -1;
+ while (prozentsuche >= 0)
+ {
+ prozentindex = line.IndexOf('%', prozentsuche);
+ if (prozentindex > 0 && line[prozentindex - 1] == '\\')
+ {
+ // Dieses % ist auskommentiert. Dahinter weitersuchen.
+ prozentsuche = prozentindex + 1;
+ prozentindex = -1;
+ }
+ else
+ {
+ break;
+ }
+ }
+
+ int firstcommandindex = line.Length + 1;
+ foreach (CommandParser c in m_cmds)
+ {
+ int cmdindex = c.FirstIndexIn(line, prozentindex);
+ if (cmdindex >= 0 && cmdindex < firstcommandindex)
+ {
+ m_activecommand = c;
+ firstcommandindex = cmdindex;
+ }
+ }
+
+ if (m_activecommand != null)
+ {
+ // Aha, Kommando gefunden.
+ if (firstcommandindex > 0)
+ {
+ // Da ist noch Text davor.
+ HandleLine(line.Substring(0, firstcommandindex));
+ }
+
+ // Rufe Kommando auf. Bzw. erstmal die Klammern suchen.
+ int hintercmd = m_activecommand.StartProcess(line, firstcommandindex);
+ HandleRestOfLine(line, hintercmd);
+ }
+ else
+ {
+ // Kein Kommando in dieser Zeile. Einfach ausgeben. Erst aber Variablen einfügen.
+ line = VariablenEinfuegen(line);
+ m_outstream.WriteLine(line);
+ }
+ }
+
+ public string VariablenEinfuegen(string inputline)
+ {
+ string line = inputline;
+ foreach (KeyValuePair<string, SqlQueryVar> var in m_varvalues)
+ {
+ line = line.Replace(var.Key, var.Value.getValueLatex());
+ }
+ return line;
+ }
+
+ private string listtostr(List<string> lines)
+ {
+ StringBuilder sb = new StringBuilder();
+ foreach (string s in lines)
+ {
+ if (sb.Length > 0)
+ {
+ sb.Append(" ");
+ }
+ sb.Append(s);
+ }
+ return sb.ToString();
+ }
+
+ private void texdbconnection(List<List<string>> pars)
+ {
+ m_activecommand = null;
+ string provider = listtostr(pars[0]);
+ string connstring = listtostr(pars[1]);
+ Debug("texdbconnection provider: {0} connstring: {1}", provider, connstring);
+ System.Data.Common.DbProviderFactory dbfac = System.Data.Common.DbProviderFactories.GetFactory(provider);
+ m_conn = dbfac.CreateConnection();
+ m_conn.ConnectionString = connstring;
+ m_conn.Open();
+ }
+
+ private void texdbdef(List<List<string>> pars)
+ {
+ m_activecommand = null;
+ string queryname = listtostr(pars[0]);
+ string querytext = listtostr(pars[1]);
+ string queryvars = listtostr(pars[2]);
+ Debug("texdbdef name: {0} sql: {1} vars: {2}", queryname, querytext, queryvars);
+ m_qrys.Add(queryname, new SqlQuery(querytext, queryvars));
+ }
+
+ private void texdbfor(List<List<string>> pars)
+ {
+ m_activecommand = null;
+ string queryname = listtostr(pars[0]);
+ List<string> texstuff = pars[1];
+ Debug("texdbfor query: {0} tex lines: {1}", queryname, texstuff.Count);
+ SqlQuery qry = m_qrys[queryname];
+ if (qry == null)
+ {
+ throw new Exception("Query " + queryname + " not found");
+ }
+ qry.Execute(texstuff, m_conn, m_varvalues, this, null);
+ }
+
+ private void texdbforfile(List<List<string>> pars)
+ {
+ m_activecommand = null;
+ m_latexpostprocess_wholefile = false;
+ string queryname = listtostr(pars[0]);
+ string filepattern = listtostr(pars[1]);
+ List<string> texstuff = pars[2];
+ Debug("texdbforfile query: {0} filepattern: {1} tex lines: {2}", queryname, filepattern, texstuff.Count);
+ SqlQuery qry = m_qrys[queryname];
+ if (qry == null)
+ {
+ throw new Exception("Query " + queryname + " not found");
+ }
+ qry.Execute(texstuff, m_conn, m_varvalues, this, filepattern);
+ }
+
+ private void texdbif(List<List<string>> pars)
+ {
+ m_activecommand = null;
+ string queryname = listtostr(pars[0]);
+ List<string> texstuff = pars[1];
+ Debug("texdbif query: {0} tex lines: {1}", queryname, texstuff.Count);
+ SqlQuery qry = m_qrys[queryname];
+ if (qry == null)
+ {
+ throw new Exception("Query " + queryname + " not found");
+ }
+ qry.ExecuteIf(texstuff, m_conn, m_varvalues, this);
+ }
+
+ private void texdbcommand(List<List<string>> pars)
+ {
+ m_activecommand = null;
+ string cmd = listtostr(pars[0]);
+ Debug("texdbcommand sql: {0}", cmd);
+ using (System.Data.Common.DbCommand comm = m_conn.CreateCommand())
+ {
+ comm.CommandText = cmd;
+ comm.ExecuteNonQuery();
+ }
+ }
+
+ public static void Debug(string format, params object[] pars)
+ {
+ if (m_verbosity >= 1)
+ {
+ Console.WriteLine(format, pars);
+ }
+ }
+
+ private string m_cmdlineargvarprefix;
+
+ private static int m_verbosity = 0;
+ private string m_outpath;
+ private string m_latexbefehl;
+ private bool m_latexpostprocess_wholefile;
+ private Encoding m_encoding;
+ private string m_inpath;
+ private List<string> m_commandlineargs;
+ private System.Data.Common.DbConnection m_conn;
+
+ private List<CommandParser> m_cmds;
+ private CommandParser m_activecommand;
+ private System.IO.StreamWriter m_outstream;
+
+ private System.Collections.Generic.Dictionary<string, SqlQuery> m_qrys;
+ private System.Collections.Generic.Dictionary<string, SqlQueryVar> m_varvalues;
+
+ }
+}
+
+
+// Latex can't handle the BOM (EF BB BF) that is prepended to UTF-8 by default.
+// So here's a UTF-8 encoding without BOM.
+
+public class UTF8EncodingWithoutPreamble : System.Text.UTF8Encoding
+{
+ public static UTF8EncodingWithoutPreamble Instance = new
+ UTF8EncodingWithoutPreamble();
+
+ private static byte[] _preamble = new byte[0];
+
+ public override byte[] GetPreamble()
+ {
+ return _preamble;
+ }
+}