MKDoc:: Text:: Strukturiert:: Ist inline eine Perl-Baugruppe, zum des Textes in HTML zu konvertieren, ohne Blockenstand Marken zu handhaben.

SYNOPSE

mein $text = some_structured_text ();
mein $this = MKDoc:: Text:: Strukturiert:: Inline:: Prozeß ($text);
mein $that = MKDoc:: Text:: Strukturiert:: Inline:: process_entities_only ($text);

OpenOffice:: OODoc:: text ist eine Perl-Baugruppe für den Textbearbeitungabschnitt von OpenOffice:: OODoc.

Dieses manuelle Kapitel beschreibt die textbezogenen Methoden von OpenOffice:: OODoc, implementiert durch das OpenOffice:: OODoc:: Textklasse und übernommen durch das OpenOffice:: OODoc:: Dokumentenkategorie.

Diese Methoden werden nicht im Wesentlichen dem Zeichenketteaufbereiten eingesetzt; sie werden genau auf Textbehälter gerichtet. Ein Textbehälter ist ein Dokumentenelement, das (und müssen) verwendet werden kann, um einen text zu unterstützen und ihn am rechten Platz und entsprechend den rechten Darstellungsrichtlinien zu integrieren. Die OpenDocument Bedingung definiert viele solchen Behälter, und die anwesende API unterstützt viele von ihnen, wie Paragraphen, Steuerkursen, Tischen (oder Kalkulationstabellen), Listen, Abschnitten und Betragseiten. Einige dieser Behälter können andere Behälter bewirten: z.B. enthält ein Tisch Reihen, eine Reihe enthält Zellen, ein Abschnitt kann fast alles einschließlich andere Abschnitte, usw. enthalten.

Diese Merkmale sind textbezogen, aber können auf Dokumenten irgendeiner Kategorie, wie Kalkulationstabellen oder Darstellungen sowie Textdokumente verwendet werden. So bedeutet das Textwort nicht, dass die Merkmale, die im anwesenden manuellen Kapitel beschrieben werden, nur OpenOffice.org-Verfasserdokumenten eingesetzt werden. In der anderen Hand wendet Gewinsel einiger Methoden an jedem möglichem Dokument die Kategorie an (ex: das Herstellen oder das Zurückholen der Betragseiten ist sinnvoll mit nur Darstellung und zeichnenden Dokumenten).

OODoc:: text sollte nicht in einer gewöhnlichen Anwendung ausdrücklich verwendet werden, weil alle seine Merkmale durch das OpenOffice: erhältlich sind: OODoc:: Dokumentenkategorie, im Verbindung mit anderen Merkmalen. Praktisch wird das anwesende Handbuch zur Verfügung gestellt, um die textbezogenen Merkmale von OpenOffice zu beschreiben:: OODoc:: Dokument (wissend, dass diese Merkmale technisch durch das OpenOffice: unterstützt werden: OODoc:: Textteil der API).

Das OpenOffice:: OODoc:: Textklasse ist ein Fachmannderivat von OpenOffice:: OODoc:: XPath für XML Elemente, die den Textinhalt von OOo/ODF beschreiben, dokumentiert. Hier „Textinhalt“ bedeutet Behälter, die können Textbehälter (d.h. Tische, Listen…) bewirten sowie flachen Text.
Wissend, dass das „styles.xml“ Bauteil einer OpenOffice.org-Datei text enthalten kann (weil einige Artdefinitionen, wie Seitenvorsätze oder Seitenenden, text enthalten können), können die momentan beschriebenen Merkmale gegen dieses Bauteil sowie das „content.xml“ Bauteil verwendet werden.

Diese Baugruppe sollte im Verbindung mit OpenOffice verwendet werden:: OODoc:: Arten, über das OpenOffice:: OODoc:: Dokumentenkategorie, wenn die Anwendung ausführliche Darstellungsparameter der Textelemente handhaben muß. Dieses ist, weil solche Parameter in den Artelementen und nicht in den Textelementen selbst angehalten werden, entsprechend der Grundregel der Trennung des Inhalts und der Darstellung, die eine der Basen des OpenDocument Formats ist.

WebService:: GoogleHack:: text ist eine Perl-Baugruppe, die etwas grundlegende Textbearbeitung wie Satzgliederungsdaten usw. implementiert.

SYNOPSE
Gebrauch WebService:: GoogleHack:: Text;

#create eine Nachricht des Typen text

mein $text = GoogleHack:: Text->new ();

# zurückbringt Wörter eines Durcheinanders ringt

%results=$text->getWords („Dateieinbauort“);

# zurückbringt ein Durcheinander von 3 Wortprogrammsätzen ngt

%results=$text->getSentences („Dateieinbauort“, 3);

# liest diese Funktion die Konfigurationsdatei

%results=$text->readConfig („Einbauort der Konfigurationsdatei“);

#removes HTML-Marken

%results=$text->removeHTML („Zeichenkette“);

Dieses ist ein einfaches Textbearbeitungpaket, das GoogleHack und Zollsatzbaugruppee unterstützt. Eine Datei von Wörtern, von ihr retreives die Wörter in der Datei und von Speichern gegeben es in einem einfachen Durcheinanderformat. Zusätzlich eine Datei des Textes gegeben, kann es N-Wortprogrammsätze auch bilden.

Text:: MetaText ist eine Perl-Extension, die Metasprache für das Aufbereiten „der Schablonen“ Textdateien implementiert.

SYNOPSE

Gebrauch Text:: MetaText;

mein $mt = Text:: MetaText->new ();

# Prozeßdateiinhalt oder Textfolge
Druck $mt->process_file ($filename, %vardefs);
Druck $mt->process_text ($textstring, %vardefs);

# vor-erklären, daß ein BLOCK für nachfolgendes UMFASSEN
$mt->declare ($textstring, $blockname);
$mt->declare (@content, $blockname);

ZUSAMMENFASSUNG DER METATEXT RICHTLINIEN

%% DEFINIEREN
variable1 = Wert # definieren Variablen
variable2 = „veranschlagener Wert“
%%

%% SUBST Variable %% # variabler Wert der Einlage
%% Variable %% # kurzes Formular von oben

Der %% BLOCK blockname %% # definieren ein Block blockname
Blocktext…
%% ENDBLOCK %%

%% SCHLIESSEN blockname %% # einschließen blockname Blocktext ein
%% SCHLIESSEN Dateinamen %% # einschließen externen Dateidateinamen ein

%% SCHLIESSEN file_or_block # ein kompletteres Beispiel… ein
Variable = Wert # zusätzliche variable Definitionen
wenn = Bedingung # bedingte Einbeziehung
es sei denn = Bedingung # bedingter Ausschluß
Format =, format_string # printf-wie Formatzeichenkette mit %s
Filter = fltname (Params) # nachbearbeiten Filter
%%

%% ZEIT # laufende Systemszeit, wie pro Zeit (2)
Format = format_string # Anzeigeformat, wie pro strftime (3C)
%%

Text:: MacroScript ist ein Makropräprozessor mit eingebetteter Perl-Fähigkeit.

SYNOPSE

Gebrauch Text:: MacroScript;

# neu () für das Makroaufbereiten

mein $Macro = Text:: MacroScript->new;
während (<>) {
Druck $Macro->expand ($ _) wenn $ _;
}

# kanonischer Gebrauch (der Dateiname verbessert Fehlermeldungen):
mein $Macro = Text:: MacroScript->new;
während (<>) {
Druck $Macro->expand ($_, $ARGV) wenn $ _;
}

# neu () für das eingebettete Makroaufbereiten

mein $Macro = Text:: MacroScript->new (- eingebettetes => 1);
# Begrenzungzahlungseinstellung zu <: und: >
# oder
mein $Macro = Text:: MacroScript->new (- opendelim => [[, - closedelim =>]]);
während (<>) {
Druck $Macro->expand_delimited ($_, $ARGV) wenn $ _;
}

# eine Makronachricht erstellen und Anfangsmakro-/Indexe von den Dateien erstellen
# gegeben:
mein $Macro = Text:: MacroScript->new (
- Datei => [local.macro, ~/.macro/global.macro]
);

# eine Makronachricht erstellen und Anfangsmakro-/Indexe von erstellen
# Definitionen gegeben:
mein $Macro = Text:: MacroScript->new (
- Makro=> [
[MAX_INT => 32767],
],
- Index => [
[DHM2S =>
[
mein $s = (#0*24*60*60) + (#1*60*60) + (#2*60);
„#0 Tage, #1 Stunden, Protokoll #2 = $s sek“
],
],
- variables => [*MARKER* => 0],
);

# können wir jede mögliche Kombination der Optionen selbstverständlich verwenden.

mein $Macro = Text:: MacroScript->new (- Kommentar => 1); # das %% [] Makro erstellen.

# definieren ()

$Macro->define (- Makro, $macroname, $macrobody);

$Macro->define (- Index, $scriptname, $scriptbody);

$Macro->define (- Variable, $variablename, $variablebody);

# undefine ()

$Macro->undefine (- Makro, $macroname);

$Macro->undefine (- script, $scriptname);

$Macro->undefine (- Variable, $variablename);

# undefine_all ()

$Macro->undefine (- Makro);

$Macro->undefine (- Index);

$Macro->undefine (- Variable);

# Liste ()

@macros = $Macro->list (- Makro);
@macros = $Macro->list (- Makro, - namesonly);

@scripts = $Macro->list (- Index);
@scripts = $Macro->list (- Index, - namesonly);

@variables = $Macro->list (- Variable);
@variables = $Macro->list (- Variable, - namesonly);

# load_file () - behandelt immer den Inhalt wie innerhalb der Begrenzungen, wenn wir sind
#, das eingebettete Aufbereiten tuend.

$Macro->load_file ($filename);

# expand_embedded expand_file () - Aufrufe () wenn wir das eingebettete Handeln sind
#, Aufrufe anders aufbereitend, erweitern ().

$Macro->expand_file ($filename);
@expanded = $Macro->expand_file ($filename);


# erweitern ()

$expanded = $Macro->expand ($unexpanded);
$expanded = $Macro->expand ($unexpanded, $filename);

# expand_embedded ()

$expanded = $Macro->expand_embedded ($unexpanded);
$expanded = $Macro->expand_embedded ($unexpanded, $filename);

Dieses Bündel schließt auch das Makro ein und macrodir Indexe, das uns erlaubt, Makro zu erweitern, ohne zu müssen zu verwenden/, verstehen Text:: MacroScript.pm, obgleich Sie die Handvoll erhältlichen der Makrobefehle erlernen müssen und die hier und im Makro dokumentiert werden. Makro stellt mehr Unterlagen auf dem eingebetteten Anflug zur Verfügung.

Die angegebene macroutil.pl Bibliothek liefert einige Funktionen, die Sie beschließen können, um in der HTML-Arbeit zum Beispiel zu verwenden.

Workorder Verarbeitungssystem erlaubt Ihnen, einen Betriebszustand/ein Kartengleichlaufsystem für die meisten Service in Verbindung gestandenen Geschäfte schnell vorzubringen.

Workorder Verarbeitungssystem ist zum Handhaben der Mehrfachverzweigungen fähig, das alle Zweigniederlassungen von einem zentralen Server laufen läßt, der an das Internet angeschlossen.

Sind hier einige Hauptmerkmale „des Betriebszustand Karten-Verarbeitungssystems“:

· Multi Zweigniederlassung fähig mit zentralem Server
· Abnehmeradressendatenbank
· Abnehmerarbeitsgeschichte
· Auffindbare Kartendatenbank
· Terminhost

SoundTouch klingen, aufbereitend Bibliothek, ist eine Öffnenquelle aufbereitende Audiobibliothek für das Ändern der Tempo-, Nicken-und Playback-Zollsätze der Audioströme oder der Dateien:

· Tempo (Zeit-ausdehnen): Ändert den Ton, um mit schnellerer oder langsamerer Drehzahl als Vorlage zu spielen, ohne das fehlerfreie Nicken zu beeinflussen.
· Nicken (Schlüssel): Ändert das fehlerfreie Nicken oder den Schlüssel, ohne das fehlerfreie Tempo oder die Drehzahl zu beeinflussen.
· Playback-Zollsatz: Ändert das fehlerfreie Tempo und Nicken, als ob eine Langspielplatte-Platte mit falschem Drehzahl-Zollsatz gespielt.

Sind hier einige Hauptmerkmale „SoundTouch der fehlerfreien aufbereitenden Bibliothek“:

· Bedienungsfreundliche Umsetzung von Zeit-ausdehnen en, neigen-schalten und prüfen umstellenprogramme des Zollsatzes.
· Leistungsstarke objektorientierte C++ Umsetzung.
· Volle Quellencodes erhältlich für die SoundTouch Bibliothek und die Beispielanwendung.
· Freier Raum und bedienungsfreundliche Programmierungschnittstelle über ein einzelnes C++ klassifizieren.
· Unterstütztes Audiodatenformat: ganze Zahl 16Bit oder Gleitkomma 32bit PCM mono/Stereolithographie
· Fähig zum Echtzeitaudiostromaufbereiten:
· Output-Latenzzeit max. ~ 100 Frau.
· Das Aufbereiten des Stereotones 44.1kHz/16bit in der Istzeit erfordert einen Prozessor 133 MHZ-Intel Pentium oder besser.
· Plattform-unabhängige Umsetzung: Die SoundTouch Bibliothek kann für jeden möglichen Prozessor und OS-Plattform kompiliert werden, die GNU c-Compiler oder (gcc) Sichtstudio, z.B. Win32, Linux, AIX unterstützen.
· Zusätzlicher Assemblerstand und die Intel-MMX Befehlsatzoptimierungen für kompatible Prozessoren Intel-x86 (Win32 u. Linuxplattformen), mehrmals anbietend erhöhen der aufbereitenden Leistung.
· Kompilierte vollziehbare Zweiheiten erhältlich für Windows.

Was in diesem Auslösen neu ist:

· Merkmale/Beschränkungen/Änderungen hier hinzufügen

Java-Parallelverarbeitungs-Rahmen ist eine Einstellung Werkzeuge und API, zum der Paralellisierung der CPU-steigernden Anwendungen zu ermöglichen und verteilt ihre Ausführung über einem Netz der heterogenen Knotenpunkte.

Java-Parallelverarbeitungs-Rahmen soll in Blöcke und Rasterfelder laufen.

Sind hier einige Hauptmerkmale „des Java-Parallelverarbeitungs-Rahmens“:

· eine API, zum des Aufbereitens der parallel gemachten Aufgaben zu den lokalen und Fernausführungdienstleistungen zu beauftragen
· eine Einstellung API und Benutzerschnittstellewerkzeuge, zum von Ausführungdienstleistungen auszuüben und zu überwachen
· anpassungsfähige ausgleichende Echtzeitfähigkeiten der Belastung
· Ersteigbarkeit bis zu einer willkürlichen Zahl des Aufbereitens von Knotenpunkten
· Träger für Failover und Wiederanlauf
· begrenzte Einmischung für das Existieren oder Legacycode
· eine dynamische Dislozierungvorrichtung, die aktiviert die Ausführung von neuem, oder geändert, Code, ohne zu müssen, auf das Rasterfeld auszufahren
· völlig dokumentierte API, Verwaltungsführung und Entwicklerführung
· Lack-Läufer auf irgendeiner Plattform, die Plattform-Standardausgabe 5.0 (J2SE 1.5) Java-unterstützt 2

Was in diesem Auslösen neu ist:

· JPPF wird jetzt im Sinne der Apache-Lizenz, Version 2.0 genehmigt. Abfahrend von JPPF 1.0 beta1, wird alles Auslösen unter diesen Ausdrücken genehmigt.
· Vorherige Versionen bleiben im Sinne des LGPL.
· Zum ersten Mal integriert JPPF nahtlos mit J2EE. Der JPPF Hilfsmittel-Adapter versieht J2EE Applikationsserver mit einem Zugriff zu den gediegenen Rasterfelddienstleistungen.
· Zahlreiche Markeverlegenheiten, besonders in bezug auf die verteilte Kategorienladenvorrichtung.

Text:: ScriptTemplate ist ein unabhängiger ASP/JSP/PHP-style Schablonenprozessor.

SYNOPSE

Gebrauch Text:: ScriptTemplate;

$text = <<EOF; # PHP/JSP/ASP-style Schablone
< % für (1..3) {% > # - jeden möglichen Perl-Ausdruck wird unterstützt
Meldung ist: < %= $TEXT % >. # - unterstützt auch variable Dynamicdehnung
< %} % >
EOF

$tmpl = neuer Text:: ScriptTemplate; # Prozessornachricht erstellen
$tmpl->setq (TEXT => „hallo, Welt“); # Exportdaten zur Schablone

# erweiterten Belastung, Fülle und Druck Resultat in den einzelnen Maßnahmen
Druck $tmpl->pack ($text) - >fill;

Dieses ist ein Nachfolger des Textes:: SimpleTemplate, eine Baugruppe für Schablone gründete Texterzeugung.

Schablone-gegründetes Texterzeugung ist eine Methode, sich Programmcode und -daten zu trennen, also kann Nicht-Programmierer Endergebnis (wie HTML) wie gewünscht steuern, ohne den Programmcode selbst zu zwicken. Indem man so tut, ist Jobs wie sitebeibehaltung viel einfacher, weil Sie Programmcode unverändert lassen können, selbst wenn Seitenneukonstruktion erforderlich war.

Die Idee dieser Baugruppes ist einfach. Wann immer ein Textabschnitt vorbei umgeben (oder irgendwelche Paare Begrenzungen, die Sie spezifizieren), gefunden wird, wird er als Perl-Ausdruck genommen und wird besonders durch die Schablone gehandhabt, die Motor aufbereitet. Mit dieser Baugruppe können Perl-Index und text eng vermischt werden.

Hauptziel dieser Bibliothek ist, Träger der leistungsfähigen PHP-Art Schablone mit kleinerem Hilfsmittel zu gewähren. Dieses ist nützlich, wenn PHP, Java/JSP oder Apache:: Asp ist Übermaß, aber ihre Schablonenart wird noch gewünscht.

Text:: Ngrams ist eine flexible Ngram Analyse (für Zeichen, Wörter und mehr).

SYNOPSE

Für Zahlungseinstellungzeichen Ngramm Analyse der Zeichenkette:

Gebrauch Text:: Ngrams;
mein $ng3 = Text:: Ngrams->new;
$ng3->process_text (abcdefg1235678hijklmnop);
Druck $ng3->to_string;
mein @ngramsarray = $ng3->get_ngrams;

Ein kann Zeichen auch manuell führen:

Gebrauch Text:: Ngrams;
mein $ng3 = Text:: Ngrams->new;
$ng3->feed_tokens (A);
$ng3->feed_tokens (B);
$ng3->feed_tokens (c);
$ng3->feed_tokens (d);
$ng3->feed_tokens (e);
$ng3->feed_tokens (f);
$ng3->feed_tokens (g);
$ng3->feed_tokens (h);

Wir können Ngramm verschiedene Größen wählen, z.B.:

mein $ng = Text:: Ngrams->new (=> 6) windowsize;

oder verschiedene Typen von Ngramm, z.B.:

mein $ng = Text:: Ngrams->new (Typ => Byte);
mein $ng = Text:: Ngrams->new (Typ => Wort);
mein $ng = Text:: Ngrams->new (Typ => utf8);

Zu eine Liste der Dateien aufbereiten:

$ng->process_files (somefile.txt, otherfile.txt);

Diese Baugruppenwerkzeugtext Ngramm Analyse, einige Typen Analyse, einschließlich Zeichen und Wort Ngramm unterstützend.

Der Baugruppe Text:: Ngrams ist sehr flexibel. Z.B. erlaubt es einem Benutzer, eine Reihenfolge aller möglicher Zeichen manuell zu führen. Es handhabt einige Typen Zeichen (Zeichen, Wort) und erlaubt auch viel Flexibilität in der automatischen Anerkennung und Zufuhr der Zeichen und der Methode, die sie in einem Ngramm kombiniert. Es zählt alle Ngramm Frequenzen bis zur maximalen spezifizierten Länge. Das Ausgangformat bedeutet, um ziemlich genau für den Menschen lesbar zu sein, wenn auch ladbar durch die Baugruppe.
Die Baugruppe kann von der Befehlszeile durch den Index ngrams.pl verwendet werden, der mit dem Paket versehen.

Beschränkungen:

· Wenn ein Benutzer einen Typen anpaßt, ist es möglich, dass ein resultierendes Ngramm vieldeutig ist. Auf diese Weise zu den verschiedenen Ngramm kann als eins gegolten werden. Mit vorbestimmten Typen von Ngramm, sollte dieses nicht geschehen. Z.B. wenn ein Benutzer wählt, dass ein Zeichen einen Platz enthalten kann, und verwendet Platz als Ngramm Trennzeichen, dann ist ein Trigram wie dieses „x x x x“ vieldeutig.
· Die process_file Methode handhabt Mehrkanalzeichen nicht durch Zahlungseinstellung. Dieses kann örtlich festgelegt sein, aber es scheint nicht, die Codekomplikation wert zu sein. Es gibt verschiedene Methoden um dieses, wenn eine wirklich solche Zeichen benötigt: One-way ist, sie zu aufbereiten. Eine andere Methode ist, so viel text wie erforderlich zu lesen auf einmal dann, um process_text zu verwenden, das Mehrkanalzeichen handhabt.

Baugruppe Perl-EP3 ist der ausdehnbare Perl-Präprozessor.

SYNOPSE

# Gebrauchoptionen und -dateien von der Befehlleitung
Gebrauch Text:: EP3;
[Gebrauch Text:: EP3:: {Extension}] # sprachspezifische Baugruppee
# die Präprozessornachricht erstellen
mein $preprocessor = neuer Text:: Datei EP3;
# die Aufbereitung, using Befehlleitung Optionen vom @ARGV tun
$preprocessor->ep3_execute;

# Optionen einstellen und Dateien vom Perl script
Gebrauch Text:: EP3;
[Gebrauch Text:: EP3:: {Extension}] # sprachspezifische Baugruppee
# die Präprozessornachricht erstellen
mein $preprocessor = neuer Text:: Datei EP3;
# die Präprozessornachricht konfigurieren (wahlweise)
$preprocessor->ep3_output_file ([$filename]);
$preprocessor->ep3_modules ([@modules]);
$preprocessor->ep3_includes ([@include_directories]);
$preprocessor->ep3_reset;
$preprocessor->ep3_start_comment ([$string]);
$preprocessor->ep3_end_comment ([$string]);
$preprocessor->ep3_line_comment ([$string]);
$preprocessor->ep3_delimiter ([$string]);
$preprocessor->ep3_gen_depend_list ([$value]);
$preprocessor->ep3_keep_comments ([$value]);
$preprocessor->ep3_protect_comments ([$value]);
$preprocessor->ep3_defines ($string1=$string2);
# tun die Aufbereitung
$preprocessor->ep3_process ([$filename, [$condition]]);

EP3 ist ein Programm Perl5, das STDIN oder irgendeine Einstellung Inputdateien aufbereitet und eine Ausgabedatei produziert. EP3 arbeitet nur an Inputdateien und produziert Ausgabedateien. Es scheint mir dass, wenn Sie Reihen oder somesuch aufbereiten möchten, Sie sollte Perl verwenden. EP3 wurde zuerst entwickelt, um einen flexiblen Präprozessor für die Verilog Befestigungsteil-Beschreibungssprache zur Verfügung zu stellen.

Verilog stellt einige Probleme dar, die nicht leicht gelöst wurden, indem man cpp oder m4 verwendete. Ich wollte in der Lage sein, einen normalen Präprozessor zu verwenden, aber dehne seine Funktionalität aus. So schrieb ich EP3 - den ausdehnbaren Perl-Präprozessor. Der Hauptunterschied zwischen EP3 und anderen Präprozessoren ist seine eingebaute Ausbaufähigkeit. Jede Richtlinie in EP3 ist wirklich eine Methode, die in EP3, einer seiner Abschnitte definiert wird oder in der Datei eingebettet ist, die aufbereitet wird. Indem sie den richtungweisenden Namen zu den verbundenen Methoden banden, konnten andere Methoden addiert werden, den Präprozessor und so ausdehnen.

Text:: LooseCSV ist eine in hohem Grade verzeihende Satz variabler Längetextsyntaxanalyse; mit Ms Excel vergleichen.

SYNOPSE

Gebrauch Text:: LooseCSV;
Gebrauch IO:: Datei;

$fh = neuer IO:: Datei $fname;
$f = neuer Text:: LooseCSV ($fh);

# einige wahlweiseeinstellungen
$f->word_delimiter („t“);
$f->line_delimiter („N“);
$f->no_quotes (1);

# eine Leitung analysieren/aufteilen
während ($rec = $f->next_record ())
{
wenn ($rec == -1)
{
warnen („verdorbener rec: “, $f->cur_line);
zunächst;
}

# Prozeß$rec als arrayref
…
}


# oder, (umgekehrt) eine Satz variabler Längedatei herstellen
$line = $f->form_record ([Debbie tut Dallas, 30.00, VHS, klassisches],);

Warum eine andere mit variabler Längetextsatzsyntaxanalyse? Ive hatte das Privileg, einige der gnarliest Daten zu analysieren, die überhaupt gesehen und alles anderes versuchte ich ein CPAN erdrosselt (zu der Zeit als ich diese Baugruppe schrieb). Diese Baugruppe gekaut auf Millionen Sätzen der schmutzigsten Daten, die an einigen Produktionssites erdenklich sind, also dachte ich, daß Identifikation beitragen.

Diese Baugruppe folgt ein wenig losen Richtlinien (mit Ms Excel vergleichen) und handhaben eingebettete neue Zeilen, usw. Sie ist zum Handhaben der großen Dateien fähig und aufbereitet Daten in den Leitungklumpen et. Wenn MAX_LINEBUF jedoch erreicht markiert es den aktuellen Satz, wie verdorben, zurückbringt -1 ngt und an der sehr folgenden Leitung vorbei wieder beginnen. Dieses wird (selbstverständlich) Prozeß Tabulator-abgegrenzte Daten, oder was Wert Sie für word_delimiter einstellen.
Methoden gerufen auf Form Perl-OO.

Das WARNEN dieser Baugruppes verwirrt mit $ line_delimiter Einstellungen $ und gerufen immer während des Aufbaus. $ nicht während des Ablaufs des Programms ändern!

GD:: text ist eine Perl-Baugruppe mit Texthilfsprogrammen für Gebrauch mit GD.

SYNOPSE

GD verwenden;
Gebrauch GD:: Text;

mein $gd_text = GD:: Text->new () oder sterben GD:: Text:: Fehler ();
$gd_text->set_font (funny.ttf, 12) oder sterben $gd_text->error;
$gd_text->set_font (gdTinyFont);
$gd_text->set_font (GD:: Schrifttyp:: Klein);
…
$gd_text->set_text ($string);
mein ($w, $h) = $gd_text->get (Breite, Höhe);

wenn ($gd_text->is_ttf)
{
…
}
Oder wechselweise
mein $gd_text = GD:: Text->new (
text => etwas Text,
Schrifttyp => funny.ttf,
=> 14 ptsize,
);

Diese Baugruppe zur Verfügung stellt eine Schrifttyp-unabhängige Methode des Beschäftigens text in GD, für Gebrauch das GD:: Text:: * Baugruppee und GD:: Diagramm.

Text:: CPP ist ein voller c-Präprozessor in XS.

SYNOPSE

Gebrauch Text:: CPP;
mein $reader = neuer Text:: CPP (
Sprachen=> CLK_GNUC99,
Optionen => {
…
},
Builtins => {
foo => dieses,
Rechtsanwaltschaft => das,
},
);
$reader->read („file.c“);
während (mein $token = $reader->token) {
Druck „Zeichen: $tokenn“;
}

$reader->data-> {MyKey} = $MyData;

Ein schneller c-Präprozessor in XS. Dieses erfordert nicht einen Präprozessor des External C und wird () oder exec () kein externer Prozeß gabeln.

VERBRAUCH

Die folgenden Methoden sind implementiert worden und den Gebrauch dieser Baugruppes als reiner c-Präprozessor oder als lexer für Wechselstrom, C++ oder Assembler-wie Sprache erlaubt.

neuer Text:: CPP (...)

Nimmt ein Durcheinander oder ein hashref mit den folgenden möglichen Schlüsseln:

Sprache

Definiert die Ausgangssprache, um zu aufbereiten und/oder tokenise. Es kann irgendein von sein:

CLK_GNUC89 - GNU C89
CLK_GNUC99 - GNU C99
CLK_STDC89 - StandardC89
CLK_STDC94 - StandardC94
CLK_STDC99 - StandardC99
CLK_GNUCXX - GNU C++
CLK_CXX98 - StandardC++ 98
CLK_ASM - Assembler

Optionen

Ein hashref der Optionen für den Präprozessor. Gültige Eingaben werden mit alternativen Formularen (vom GNU cpp) in den Haltern gegeben.

Definieren (- D): Reihe Zeichenketten oder Durcheinander

Zeichenketten sollten vom Formular NAME=VALUE sein.

Undef (- U): Reihe Zeichenketten

DiscardComments (- C): Boolesch

DiscardCommentsInMacroExp (- cm): Boolesch

PrintIncludeNames (- H): Boolesch

NoLineCommands (- P): Boolesch

WarnComments (- Wcomment - Wcomments): Boolesch

WarnDeprecated (- Wdeprecated): Boolesch

WarningsAreErrors (- Werror): Boolesch

WarnImport (- Wimport): Boolesch

WarnMultichar (- Wmultichar): Boolesch

WarnSystemHeaders (- Wsystem-Vorsätze): Boolesch

Fehler in den SystemsInclude-Dateien ignorieren.

WarnTraditional (- Wtraditional): Boolesch

WarnTrigraphs (- Wtrigraphs): Boolesch

WarnUnusedMacros (- Wunused-Makro): Boolesch

Pedantisch (- pedantisch): Boolesch

PedanticErrors (- Pedantischfehler): Boolesch

Deutet an und steuert über, pedantisch.

Remap (- remap): Boolesch

Abkommen mit etwas Brokennesses von MSDOS. Ungetestet.

Trigraphs (- trigraphs): Boolesch

Traditionell (- traditionell): Boolesch

NoWarnings (- w): Boolesch

IncludePrefix (- iprefix): Zeichenkette

SystemRoot (- isysroot): Zeichenkette

Einschließen (- einschließen): Reihe Zeichenketten

Die spezifizierten Dateien enthalten, bevor Sie die aufbereitet zu werden Hauptlesen datei.

IncludeMacros (- imacros): Reihe Zeichenketten

Die spezifizierten Dateien enthalten, bevor Sie die aufbereitet zu werden Hauptlesen datei. Vom Aufbereiten dieser Dateien ausgeben wird verworfen. Die Dateien, die von IncludeMacros spezifiziert werden, werden vor den Dateien aufbereitet, die vorbei spezifiziert werden, einschließen.

IncludePath (- I): Reihe Zeichenketten

Dieses enthalten Bahn wird gesucht zuerst.

SystemIncludePath (- isystem): Reihe Zeichenketten

Das Standardsystem spezifizieren enthalten die Bahn, an zweiter Stelle gesucht.

AfterIncludePath (- idirafter): Reihe Zeichenketten

Dieses enthalten Bahn wird gesucht, nachdem das System Bahn umfassen.

Builtins

Ein hashref der vorbestimmten Makro. Die Werte müssen Zeichenketten oder ganze Zahlen sein. Makro in diesem Durcheinander werden definiert, bevor das Aufbereiten beginnt. Diese entsprechen, um „builtin“ Makro auszurichten. Sie sollten vermutlich es vorziehen, die definierenoption zu verwenden.

$text = $reader->token

($text, $type, $flags) = $reader->token

Das folgende erhältliche vorbearbeitete Zeichen zurückbringen. Einige Zeichen sind nicht stringifiable. Diese enthalten Zeichen des Typen CPP_MACRO_ARG, CPP_PADDING und CPP_EOF. Text:: CPP bringt eine blinde Zeichenkette auf dem Textgebiet für diese Zeichen zurück. Zeichen des Typen CPP_EOF sollten nie wirklich zurückgebracht werden.

@tokens = $reader->tokens

Eine Liste der Zeichen aufbereiten und zurückbringen. Dieses ist mit ungefähr gleichwertig:

drücken (@tokens, $_) während ($ _ = $reader->token);

$reader->type ($type)

Einen für den Menschen lesbaren Namen für einen Scheintypen zurückbringen, wie durch $reader->token zurückgegangen.

$reader->data

Bringt ein hashref zurück, in dem Benutzerdaten durch Unterklassen gelagert werden können. Dieses hashref wird mit einem neuen Text: erstellt: CPP Nachricht und wird zu allen Funktionszwecken ignoriert. Der Benutzer kann mit ihr tun, wie er wünscht.

$reader->errors

Im Skalarzusammenhang Umsätze der Zählimpuls des blockierenden Fehlers. Im Zusammenhang, in den Umsätzen eine Liste von Vorsichtshinweisen und in den Fehlern der Liste angetroffen durch den Präprozessor. So Skalar (@errors) >= $errors, da @errors auch die Vorsichtshinweise enthalten.

Text-Text-Drehbewegungprojekt ist ein text gegründeter ncurses DDR-Klon.

Text-Text-Drehbewegung ist ein text gegründeter Tanz-Tanz-Drehbewegungklon.

Sie unterstützt pyDDRs .step Dateiformat (das jetzt durch das .dance Format superceeded) und Pläne, um OGG, MP3-oder WAV Dateien zu strömen.

Was in diesem Auslösen neu ist:

· Träger des Steuerknüppels (DDR-Matte) arbeitet jetzt. den - J-Schalter verwenden. Sein aktuell festverdrahtetes, zum von /dev/input/js0 zu verwenden.
· Einige Formcode aufgeräumt mt, und es ist jetzt möglich, die Schwierigkeit zu spezifizieren (--Leuchte, --Standard, --hart oder - ln, wo N 1, 2 oder 3) ist.

Text:: Gewebe ist ein menschlicher Web-Textgenerator.

SYNOPSE

Gebrauch Text:: Gewebeqw (Gewebe);
mein $text = <<EOT;
h1. Steuerkurs

Eine _simple_ Vorführung des Textilpreisaufschlags.

* Ein
* Zwei
* Drei

„Mehr Informationen“: http://www.textism.com/tools/textile ist erhältlich.
EOT

# prozeduraler Verbrauch
mein $html = Gewebe ($text);
Druck $html;

# OOP Verbrauch
mein $textile = neuer Text:: Gewebe;
$html = $textile->process ($text);
Druck $html;

Text:: VisualWidth ist eine Perl-Baugruppe, die Funktionen liefert, um die half-width und full-width Zeichen zu behandeln und korrekte Größe des Textes in einer Leitung auf Flughafengebäuden und Handys anzuzeigen. Sie können die Sichtbreite jedes möglichen Textes kennen und text durch die Sichtbreite abspalten.

Jetzt dieser Baugruppenträger EUC-JP und UTF-8 und geprüft nur mit Japaner.

Text:: Emoticon ist eine Fabrikkategorie für Yahoo! und MSN Emoticons.

SYNOPSE

Gebrauch Text:: Emoticon;

mein $emoticon = Text:: Emoticon->new (MSN, {strenges => 1, xhtml => 0});
Druck $emoticon->filter (hallo;));

Text:: Emoticon ist eine Fabrikkategorie, zum der MSN/YIM Emoticoneinstellung zu schicken. Sein bildete, um handlich zu werden, in anderen Anwendungen wie Kwiki/MT Steckverbindungen verwendet zu werden.

Text:: Kakasi ist ein Perl, das zum kakasi vorgelagert ist.

SYNOPSE

Gebrauch Text:: Kakasi;
# funktionell
$res = Text:: Kakasi:: getopt_argv (- JJ, - c, - w);
$str = Text:: Kakasi:: do_kakasi ($japanese_text);
# objektorientiert
$obj = Text:: Kakasi->new (- JJ, - c, - w);
$str = $obj->get ($japanese_text);

Diese Baugruppe zur Verfügung stellt Schnittstelle zum kakasi (Kandschi kana einfacher Umformer). kakasi ist eine Einstellung Programme und Bibliotheken, die tut, was japanische Inputmethoden in der Rückordnung tun. Sie führen Japaner und kakasi konvertiert ihn in Lautdarstellung davon. kakasi kann zu japanischen Text, tokenizing auch gewohnt. Um mehr über kakasi zu finden, http://kakasi.namazu.org/ sehen.

Text:: Kakasi kennzeichnet jetzt die Funktions- und objektorientierten API. Funktionsapi sind 100%, das mit ver kompatibel ist. 1.05. Aber, „Perl 5.8 zu nutzen kennzeichnet“, Sie sollte OOP API anstatt verwenden.

text sehen:: Kakasi:: JP für die japanische Version dieses Dokuments.

Text:: Yats ist noch eins Schablonen-System.

SYNOPSE

Gebrauch Text:: Yats;

mein $template = < < ENDHTML;
< HTML >
< Leiter >
< Name >$title - $version< /title >
< /head >
< Karosserie >
< Formular >
< " benennt " auserwähltes name= ><! --{1}-- >
< Option $selected >$list< /option >
<! --{2}-- >< /select >
< /form >
< /body >
< /html >
ENDHTML

mein $result = "";
mein $tpl = Text:: Yats- >new (
Stand = > 1,
text = > $template);

$result. = $tpl- >section- > [0] - >replace (
Name = > „Yats“,
Version = > „Entwicklung“,);

$result. = $tpl- >section- > [1] - >replace (
Liste = > [hdias, Anita, cubitos],
ausgewählt = > {Wert = > „ausgewählt“,
Reihe = > „Liste“,
Übereinstimmung = > „Anita“,});

$result. = $tpl- >section- > [2] - >text;
Druck $result;