nedit.c-Dateireferenz

#include <properties.h>
#include <wizlevels.h>
#include <defines.h>
Include-Abhängigkeitsdiagramm für nedit.c:

gehe zum Quellcode dieser Datei

Makrodefinitionen

#define TP   this_player()
#define F_OVR   1
#define F_BLK   2
#define MAX_LINES   1000
#define UMLAUT

Funktionen

static string get_edit_line (string str)
static int ShowWritten (int f, int l, int num)
static string killctrl (string str)
static int ShowHelp ()
static int delLine (int l)
static void delBlock ()
static int input_func ()
static varargs void moveBlock (int start, int end, int real)
void init_rescue ()
static private void nedit_prompt ()
static varargs int nedit (string exitfunc, string pretext)
mixed RescueText ()

Variablen

static mixed nedittext
static mixed nexitfunc
static mixed editor_used
static int bstart
static int bend
static int cur
static int len
static int flags

Makro-Dokumentation

#define F_BLK   2

Definiert in Zeile 35 der Datei nedit.c.

Wird benutzt von get_edit_line().

#define F_OVR   1

Definiert in Zeile 34 der Datei nedit.c.

Wird benutzt von get_edit_line().

#define MAX_LINES   1000

Definiert in Zeile 37 der Datei nedit.c.

Wird benutzt von nedit_prompt().

#define TP   this_player()

Definiert in Zeile 32 der Datei nedit.c.

Wird benutzt von _normalfunction(), _query_long(), _set_autoloadobj(), abmelden(), AddDomain(), AddMember(), addproj_fun(), Allowed(), bestaetigen(), board_fun(), board_list(), board_long(), Catchup(), ChangeAutoInfo(), ChangeColors(), ChangeLeader(), ChangeName(), ChangeRow(), ChangeWimpyRow(), CheckSecond(), create(), delete_player(), doku_fun(), empty(), end_query(), FleeToRow(), fragen(), fuelle(), full_path_array(), get_edit_line(), handle_runtime_error(), HelpPage(), hilfe_fun(), Hist(), init(), leere(), lesbuch(), lesseite(), lies(), long(), Mail(), MailMessage(), make_path_absolute(), modproj_fun(), nedit(), next_question(), oeffne(), PostNote(), PresentRows(), ReadNextUnread(), rein(), RemoveMember(), remproj_fun(), RescueText(), SaveMessage(), schliesse(), SetNNADWMSG(), Shout(), ShowHelp(), ShowTeamHP(), ShowTeamInfo(), StartAttack(), StartFollow(), Subscribe(), team_aufnahmewunsch(), teamcmd(), TeamCmd(), Uncatchup(), Unsubscribe(), verbrennen(), watch_fun() und zeige_seite().

#define UMLAUT
Wert:
([ \
    'ä': "ae", \
    'ö': "oe", \
    'ü': "ue", \
    'Ä': "Ae", \
    'Ö': "Oe", \
    'Ü': "Ue", \
    'ß': "ss"  ])

Definiert in Zeile 411 der Datei nedit.c.

Wird benutzt von killctrl().

Dokumentation der Funktionen

static void delBlock (  )  [static]

Definiert in Zeile 371 der Datei nedit.c.

Benutzt bend, bstart, cur, len und nedittext.

Wird benutzt von get_edit_line() und moveBlock().

00372 {
00373   if (cur > bstart) {
00374     if (cur <= bend)
00375       cur = bstart;
00376     else
00377       cur -= (bend - bstart + 1);
00378   }
00379   if (bend == len)
00380     nedittext = nedittext[0..bstart-1];
00381   else
00382     nedittext = nedittext[0..bstart-1] + nedittext[bend+1..];
00383 
00384   bend = len = sizeof(nedittext)-1;
00385   bstart = 0;
00386   if (cur > len)
00387     cur = len;
00388 }

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

static int delLine ( int  l  )  [static]

Definiert in Zeile 351 der Datei nedit.c.

Benutzt bend, bstart, cur, input_to(), len, nedit_prompt() und nedittext.

Wird benutzt von get_edit_line().

00352 {
00353   if (l < 0)
00354     write("Da ist nix mehr zum Loeschen!\n]");
00355   else {
00356     if (bstart >= l)
00357       bstart--;
00358     if (bend >= l)
00359       bend--;
00360     if (cur >= l)
00361       cur--;
00362     len--;
00363     nedittext=(nedittext[0..l-1]+nedittext[l+1..]);
00364     write("Vorherige Zeile geloescht.\n");
00365     nedit_prompt();
00366   }
00367   input_to("get_edit_line");
00368   return 1;
00369 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

static mixed get_edit_line ( string  str  )  [static]

Definiert in Zeile 97 der Datei nedit.c.

Benutzt _get_path(), bend, break_string(), bs, BS_BLOCK, BS_NO_PARINDENT, bstart, cur, delBlock(), delLine(), editor_used, err, F_BLK, F_OVR, flags, init_rescue(), input_func(), input_to(), IS_LEARNER, killctrl(), len, moveBlock(), nedit_prompt(), nedittext, nexitfunc, p, ShowHelp(), ShowWritten(), TP und x.

Wird benutzt von nedit().

00097                                        {
00098   int err;
00099   int spaces;
00100   int fflag;
00101   int sl;
00102 
00103   if (!str) str="";
00104   str=killctrl(str); /* kleiner hack wegen CTRL-chars. */
00105   fflag = 0;
00106 
00107   sl = strlen(str);
00108 
00109   if (str=="**" || str=="~." || str==".") {
00110     editor_used=0;
00111     str = implode(nedittext, "\n");
00112     nedittext = 0;
00113     call_other(this_object(),nexitfunc,str);
00114     return 1;
00115   }
00116   if (str[0..0]== "~" && sl >= 2) {
00117     if (sl == 2) {
00118       switch(str[0..1]) {
00119     // Abbruch:
00120       case "~q":
00121                 editor_used = 0;
00122                 return call_other(this_object(), nexitfunc, 0);
00123     // Temporaer rausgehen:
00124       case "~!":
00125                 write("Mit ~r kannst Du weiterschreiben.\n");
00126                 init_rescue();
00127                 return 1;
00128     // Gesamten Text anzeigen
00129       case "~R":
00130                 fflag = 1;
00131       case "~r":
00132                 return ShowWritten(0, len, fflag);
00133     // Ausschnitt um Cursor anzeigen
00134       case "~Z":
00135                 fflag = 1;
00136       case "~z":
00137       { int f, l;
00138 
00139                 f = (cur > 5) ? cur-5 : 0;
00140                 l = (cur < len-5) ? cur + 5 : len;
00141                 return ShowWritten(f, l, fflag);
00142       }
00143     // Hilfeseite anzeigen:
00144       case "~h":
00145                 return ShowHelp();
00146     // Zeile ueber Cursor loeschen:
00147       case "~d":
00148                 return delLine(cur-1);
00149     // Block loeschen:
00150       case "~D":
00151                 delBlock();
00152                 write( "Block geloescht.\n" );
00153                 return input_func();
00154     // Overwrite-Modus toggeln:
00155       case "~v":
00156                 flags ^= F_OVR;
00157                 printf("%smodus eingeschaltet.\n",
00158                       (flags & F_OVR) ? "Ueberschreib" : "Einfuege");
00159                 return input_func();
00160     // Blocksatz toggeln:
00161       case "~b":
00162                 flags ^= F_BLK;
00163                 printf("%ssatz aktiviert.\n",
00164                       (flags & F_BLK) ? "Block" : "Flatter");
00165                 return input_func();
00166     // Statusinfo anzeigen:
00167       case "~s":
00168                 printf("Zeile: %d | Laenge: %d | BStart: %d | BEnde: %d | Modus: %s/%s.\n",
00169                                 cur,                len,         bstart,      bend,               (flags&F_OVR)?"Ueber.":"Einfg.",
00170                                                                                                                                   (flags&F_BLK)?"Blocksatz":"Flattersatz");
00171                 return input_func();
00172     // Block verschieben:
00173       case "~m":
00174                 moveBlock(bstart, bend, 1);
00175                 return input_func();
00176     // Block umformatieren:
00177       case "~F":
00178       { int bs;
00179 
00180                 bs = bstart;
00181                 str = implode(nedittext[bstart..bend], " ");
00182                 delBlock();
00183                 bstart = bend = cur = bs;
00184                 fflag = -1;
00185                 write("Block wurde umformatiert.\n");
00186                 break;
00187       }
00188     // Zeile umformatieren:
00189       case "~f":
00190                 str = nedittext[cur];
00191                 nedittext = nedittext[0..cur-1] + nedittext[cur+1..];
00192                 if (cur <= bstart)
00193                   bstart--;
00194                 if (cur <= bend)
00195                   bend--;
00196                 len --;
00197                 fflag = -1;
00198                 write("Zeile wurde umformatiert.\n");
00199                 break;
00200       } // switch
00201     } // if (sl == 2)
00202     else {
00203     // Cursorbewegungen an bestimmte Stellen:
00204       if (str[0..1] == "~c" && sl == 3) {
00205                 fflag = 1;
00206                 switch(str[2]) {
00207                   case 'u': spaces = -1;   break;
00208                   case 'd': spaces = 1;    break;
00209                   case 't': spaces = -len; break;
00210                   case 'b': spaces = len;  break;
00211                   case 's': spaces = bstart - cur; break;
00212                   case 'e': spaces = bend - cur;   break;
00213                   default:  spaces = 0;
00214                                     fflag = 0;
00215                                     break;
00216                 }
00217       }
00218     // Cursorbewegung mit Zeilennummern:
00219       if (spaces || sscanf(str, "~c%d", spaces) == 1) {
00220                 if (fflag>0 || str[2..2] == "+" || str[2..2] == "-")
00221                   cur += spaces;
00222                 else
00223                   cur = spaces-1;
00224 
00225                 if (cur < 0)
00226                   cur = 0;
00227                 else if (cur > len)
00228                   cur = len;
00229 
00230                 printf("%s\n",nedittext[cur]);
00231                 return input_func();
00232       }
00233 
00234     // Blockgrenzen setzen:
00235       if ((err = (str[0..2] == "~bs")) || (str[0..2]=="~be")) {
00236                 string out, p;
00237                 int pos, valid;
00238 
00239                 valid = -1;
00240 
00241                 if (sl == 3)
00242                   pos = valid = cur;
00243                 else if (sscanf(str[3..], "%d%s", pos, p) == 2 && p=="")
00244                   valid = pos--;
00245 
00246                 if (valid >= 0) {
00247                   if (err) {
00248                     bstart = pos;
00249                     if (pos > bend)
00250                       bend = len;
00251                     out = "Blockanfang";
00252                   }
00253                   else {
00254                     if (pos < bstart)
00255                       bstart = 0;
00256                     bend = pos;
00257                     if (len && bend == len)
00258                       bend--;
00259                     out = "Blockende";
00260                   }
00261                   printf("%s gesetzt.\n", out);
00262                   return input_func();
00263                 }
00264       }
00265 
00266     // Ersetzen:
00267       if ((strlen(str) >= 8) && str[0..1] == "~s") {
00268                 string *s1, *s2;
00269                 int m;
00270 
00271                 m = (str[2] == ' ') ? 3 : 2;
00272 
00273                 if (sizeof(s1 = explode(str[m..], str[m..m])) == 4) {
00274                   s2 = explode(nedittext[cur], s1[1]);
00275                   if (sizeof(s2) > 1) {
00276                     s2[1] = s2[0]+s1[2]+s2[1];
00277                     nedittext[cur] = implode(s2[1..], s1[1]);
00278                     if (s1[3] == "p")
00279                       printf("%s\n", nedittext[cur]);
00280                     else
00281                       write("OK.\n");
00282                     nedit_prompt();
00283                   }
00284                   else {
00285                     printf("\"%s\" nicht gefunden!\n", s1[1]);
00286                     nedit_prompt();
00287                   }
00288 
00289                   input_to("get_edit_line");
00290                   return 1;
00291                 }
00292       }
00293     } // if (sl > 2)
00294   } // if (str[0..0] == "~")
00295 
00296   spaces=(strlen(str) && (str[0]==' ' || str[0]=='\t'));
00297   if (spaces) str="$"+str;  /* Kleiner hack wegen fuehrenden Leerzeichen */
00298   str=break_string(str,78,0,(flags&F_BLK) ? BS_BLOCK|BS_NO_PARINDENT : 0);
00299   if (spaces) str=str[1..<1];
00300   if (((str[0..1]=="~r" && strlen(str)>2) || str[0..1]=="~i") && IS_LEARNER(TP)) {
00301     str=str[2..<2];
00302     if (str[0..0]==" ") str=str[1..<1];
00303     if (!str || catch(err=file_size(str=(string)"/secure/master"->_get_path(str,getuid(TP)))) || err<0) {
00304       write("File nicht gefunden.\n");
00305       nedit_prompt();
00306       input_to("get_edit_line");
00307       return 1;
00308     }
00309     str=read_file(str);
00310     if (!str){
00311       write("Zu gross!\n");
00312       nedit_prompt();
00313       input_to("get_edit_line");
00314       return 1;
00315     }
00316     write("Ok.\n");
00317   }
00318   if (str=="" || !str) str="\n";
00319   {
00320     string *x;
00321     int sx;
00322 
00323     x = explode(str, "\n")[0..<2];
00324     sx = sizeof(x);
00325 
00326     if (flags&F_OVR && !fflag) {
00327       nedittext = nedittext[0..cur-1] + x + nedittext[cur+1..];
00328       sx--;
00329     }
00330     else
00331       nedittext = nedittext[0..cur-1] + x + nedittext[cur..];
00332 
00333     if (cur < bstart)
00334       bstart += sx;
00335     if (cur <= bend)
00336       bend += (sx + fflag);
00337     cur += (sx + fflag + ((flags&F_OVR) ? 1:0));
00338     len += sx;
00339 
00340     // Kann beim Umformatieren des letzten Abschnitts vorkommen.
00341     if (nedittext[len] != "") {
00342       nedittext += ({ "" });
00343       len++;
00344     }
00345   }
00346   nedit_prompt();
00347   input_to("get_edit_line");
00348   return 1;
00349 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

void init_rescue (  ) 

Definiert in Zeile 54 der Datei nedit.c.

Wird benutzt von get_edit_line() und init().

00054                    {
00055   add_action("RescueText","~r");
00056 }

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

static int input_func (  )  [static]

Definiert in Zeile 543 der Datei nedit.c.

Benutzt input_to() und nedit_prompt().

Wird benutzt von get_edit_line().

00543                         {
00544   nedit_prompt();
00545   input_to("get_edit_line");
00546   return 1;
00547 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

static string killctrl ( string  str  )  [static]

Definiert in Zeile 420 der Datei nedit.c.

Benutzt i und UMLAUT.

Wird benutzt von get_edit_line() und schreib().

00421 {
00422     int i, j;
00423     string tmp;
00424 
00425     tmp = "";
00426     
00427     for ( j = strlen(str), i = 0; i < j; i++ )
00428         tmp += (UMLAUT[str[i]] || str[i..i]);
00429 
00430     tmp = regreplace( tmp, "[^ -~\t]", "", 1 );
00431     
00432     if (sizeof(tmp) &&  tmp[0] < 32 )
00433         return tmp[1..];
00434   
00435     return tmp;
00436 }

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

static varargs void moveBlock ( int  start,
int  end,
int  real 
) [static]

Definiert in Zeile 390 der Datei nedit.c.

Benutzt bend, bstart, cur, delBlock(), len und nedittext.

Wird benutzt von get_edit_line().

00391 {
00392   int blen;
00393   string *block;
00394 
00395   if (cur >= start && cur <= end)
00396     write("Aber der Cursor steht innerhalb des Blocks!\n");
00397   else {
00398     block = nedittext[start..end];
00399     blen = sizeof(block)-1;
00400     delBlock();
00401     nedittext = nedittext[0..cur-1] + block + nedittext[cur..];
00402     if (real) {
00403       bstart = cur;
00404       bend = cur + blen;
00405     }
00406     len += (blen+1);
00407     write("OK.\n");
00408   }
00409 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

static varargs int nedit ( string  exitfunc,
string  pretext 
) [static]

Definiert in Zeile 75 der Datei nedit.c.

Benutzt bend, bstart, cur, editor_used, flags, get_edit_line(), input_to(), len, nedit_prompt(), nedittext, nexitfunc und TP.

Wird benutzt von get_subject() und schreib().

00075                                                          {
00076   if (editor_used) {
00077     write("Offensichtlich schreibt hier schon jemand dran. Sorry.\n"+
00078                                                 "(Falls du es selbst bist, tippe ~r zur Wiederaufnahme einer verlorenen Sitzung)\n");
00079     return -1;
00080   }
00081   if (!pretext) nedittext=({""});
00082   else nedittext=explode(pretext,"\n");
00083   bstart = 0;
00084   bend = cur = len = sizeof(nedittext)-1;
00085   nexitfunc=exitfunc;
00086   flags = 0;
00087   editor_used=(string)TP->query_real_name();
00088   if (pretext)
00089     get_edit_line("~z");
00090   else {
00091     nedit_prompt();
00092     input_to("get_edit_line");
00093   }
00094   return 1;
00095 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

static private void nedit_prompt (  )  [static]

Definiert in Zeile 58 der Datei nedit.c.

Benutzt bend, bstart, cur, len, MAX_LINES und nedittext.

Wird benutzt von delLine(), get_edit_line(), input_func() und nedit().

00059 {
00060   if (sizeof(nedittext) <= MAX_LINES)
00061     write("]");
00062   else {
00063     nedittext = nedittext[0..MAX_LINES-1];
00064     len = MAX_LINES;
00065     if (cur >= MAX_LINES)
00066       cur = MAX_LINES-1;
00067     if (bstart >= MAX_LINES)
00068       bstart = MAX_LINES-1;
00069     if (bend >= MAX_LINES)
00070       bend = MAX_LINES-1;
00071     printf("*** Mehr als %d Zeilen! Text wurde abgeschnitten! ***\n]", MAX_LINES);
00072   }
00073 }

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

mixed RescueText (  ) 

Definiert in Zeile 438 der Datei nedit.c.

Benutzt editor_used, len, nedittext, notify_fail(), ShowWritten() und TP.

Wird benutzt von postneustart().

00438                    {
00439   if (!nedittext || !editor_used)
00440     return notify_fail("Du hast nix angefangen zu schreiben!\n"),0;
00441   if (TP->query_real_name()!=editor_used)
00442     return notify_fail("Hier schreibt "+capitalize(editor_used)+"!\n"),0;
00443   if (query_input_pending(TP))
00444     return notify_fail("Du schreibst gerade schon irgendwas. Sorry...\n"),0;
00445   return ShowWritten(0, len, 0);
00446 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

static int ShowHelp (  )  [static]

Definiert in Zeile 495 der Datei nedit.c.

Benutzt IS_WIZARD und TP.

Wird benutzt von get_edit_line().

00495                       {
00496   this_player()->More("\
00497 --------------------------\n\
00498 Der Editor versteht folgende Befehle:\n\
00499 --- Dateikommandos:\n\
00500 ~h                  diese Hilfsseite\n\
00501 ~r / ~R     zeigt an, was Du bisher geschrieben hast\n\
00502 ~z / ~Z     zeigt den Textausschnitt um den Cursor herum\n\
00503 "+(IS_WIZARD(TP) ? "\
00504 ~i filename fuegt eine Datei in den Text ein (auch ~r filename)\n\
00505 " : "" )+ "\
00506 ~q                  bricht ab\n\
00507 ** oder .   beendet sauber\n\
00508 !<cmd>              fuehrt <cmd> aus, wie wenn Du gerade nicht schreiben wuerdest\n\
00509 ~!                  verlaesst den Editor voruebergehend\n\
00510 ~s                  Statusinformationen anzeigen\n\
00511 ~b                  Wechselt zwischen Flatter- (default) und Blocksatz\n\
00512 --- zeilenorientierte Kommandos:\n\
00513 ~d                  loescht die letzte Zeile (Text-, nicht Eingabezeile)\n\
00514 ~v                  wechselt zwischen Einfuege- (default) und Ueberschreibmodus\n\
00515 ~s !s1!s2!  Ersetzt das erste Vorkommnis des Strings s1 durch den String s2\n\
00516                     in der aktuellen Zeile.\n\
00517                     Statt durch ! koennen die Strings auch durch beliebige andere\n\
00518                     Zeichen getrennt werden, die weder in s1 noch in s2 vorkommen.\n\
00519 ~f                  Formatiert die aktuelle Zeile neu\n\
00520 --- Cursorkommandos:\n\
00521 ~cu / ~cd   Cursor um eine Zeile nach oben/unten bewegen\n\
00522 ~ct / ~cb   Cursor an Anfang/Ende des Textes bewegen\n\
00523 ~cs / ~ce   Cursor an Blockanfang/Blockende bewegen\n\
00524 ~c<nr>              Cursor nach Zeile <nr> bewegen\n\
00525 ~c+<nr>     Cursor um <nr> Zeilen nach unten bewegen\n\
00526 ~c-<nr>     Cursor um <nr> Zeilen nach oben bewegen\n\
00527 --- blockorientierte Kommandos:\n\
00528 ~bs/~bs<nr> setzt Blockanfang auf Cursorposition bzw. auf Zeile <nr>\n\
00529 ~be/~be<nr> setzt Blockende auf Cursorposition bzw. auf Zeile <nr>\n\
00530 ~F                  formatiert den Block neu\n\
00531 ~D                  loescht den markierten Block\n\
00532 ~m                  verschiebt den markierten Block an die Cursorposition\n\
00533 ---\n\
00534 Alles andere gilt als Text. Ueberlange Zeilen werden auf eine maximale\n\
00535 Laenge von 78 Zeichen umgebrochen.\n\
00536 Nach ~!, oder wenn man waehrend des Schreibens netztot wird, kann man mit\n\
00537  ~r wieder in den Editor einsteigen.\n\
00538 --------------------------\n\
00539 ", 0, symbol_function("input_func", this_object()));
00540   return 1;
00541 }

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

static int ShowWritten ( int  f,
int  l,
int  num 
) [static]

Definiert in Zeile 448 der Datei nedit.c.

Benutzt bend, bstart, c, cur, i, len, nedittext und p.

Wird benutzt von get_edit_line() und RescueText().

00448                                               {
00449   string s, t, c, p, in;
00450   int i;
00451 
00452   if (num) {
00453     if (l >= 100) {
00454       p = "%3d%s%s";
00455       in = " ";
00456     }
00457     else {
00458       p = "%2d%s%s";
00459       in = "  ";
00460     }
00461   }
00462   else
00463     in = "";
00464 
00465   for (t="", i=l-1; i>=f; i--) {
00466     if (i == cur)
00467       c = ( ((i == bend) || (i == bstart)) ? "#" : "*");
00468     else if (i==bstart || i==bend)
00469       c = ">";
00470     else c = ":";
00471 
00472     if (num)
00473       t = (sprintf(p, i+1, c, nedittext[i])[0..75] + "\n" + t);
00474     else
00475       t = (c + nedittext[i]+"\n" + t);
00476   }
00477 
00478   if (l==len) {
00479     if (len == cur)
00480       c = ( (len == bend) ? "#" : "*");
00481     else if (len==bend)
00482       c = ">";
00483     else c = " ";
00484   }
00485   else c= " ";
00486 
00487   s="Das hast Du bisher geschrieben:\n"+in+" \
00488 --------------------------\n\
00489 "+t+in+c+"\
00490 --------------------------";
00491   this_player()->More(s,0,symbol_function("input_func",this_object()));
00492   return 1;
00493 }

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

Variablen-Dokumentation

int bend [static]

Definiert in Zeile 40 der Datei nedit.c.

Wird benutzt von delBlock(), delLine(), get_edit_line(), moveBlock(), nedit(), nedit_prompt() und ShowWritten().

int bstart [static]

Definiert in Zeile 40 der Datei nedit.c.

Wird benutzt von delBlock(), delLine(), get_edit_line(), moveBlock(), nedit(), nedit_prompt() und ShowWritten().

int cur [static]

Definiert in Zeile 41 der Datei nedit.c.

Wird benutzt von delBlock(), delLine(), get_edit_line(), moveBlock(), nedit(), nedit_prompt() und ShowWritten().

mixed editor_used [static]

Definiert in Zeile 39 der Datei nedit.c.

Wird benutzt von get_edit_line(), nedit() und RescueText().

int flags [static]

Definiert in Zeile 43 der Datei nedit.c.

Wird benutzt von _cd2(), _clone(), _destruct(), _ed(), _inventory(), _man(), _more(), _rman(), _upd(), finger_single(), get_edit_line(), may_enter_room(), nedit(), ProcessAllBuffers(), propflags() und walk_random().

int len [static]

Definiert in Zeile 42 der Datei nedit.c.

Wird benutzt von delBlock(), delLine(), filter_who_options(), get_edit_line(), get_sequence(), GetFunc(), histmin(), HTMLunescape(), match_item(), moveBlock(), nedit(), nedit_prompt(), QuoteLine(), RescueText(), ShowWritten(), stretch() und zeige_seite().

mixed nedittext [static]

Definiert in Zeile 39 der Datei nedit.c.

Wird benutzt von delBlock(), delLine(), get_edit_line(), moveBlock(), nedit(), nedit_prompt(), postneustart(), RescueText(), reset() und ShowWritten().

mixed nexitfunc [static]

Definiert in Zeile 39 der Datei nedit.c.

Wird benutzt von get_edit_line() und nedit().

Erzeugt am Thu Jun 3 14:39:28 2010 für MorgenGrauen Mudlib von  doxygen 1.6.3