home *** CD-ROM | disk | FTP | other *** search
/ System Booster / System Booster.iso / Texteditors / Origami / Sources / src / origami / init.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-09-27  |  20.6 KB  |  774 lines
  1. /*{{{}}}*/
  2. /*{{{  #includes*/
  3. #ifdef CONFIG_H
  4. #   include "config.h"
  5. #endif
  6.  
  7. #include <sys/types.h>
  8. #include <signal.h>
  9. #include <fcntl.h>
  10. #include <limits.h>
  11. #include <string.h>
  12. #include <stdlib.h>
  13. #include <unistd.h>
  14. #include <stdio.h>
  15.  
  16. #define INIT_C
  17. #define I_DISPLAY_C
  18. #define I_FOLDING_C
  19. #define I_GETMSG_C
  20. #define I_GETTK_C
  21. #define I_KEYBOARD_C
  22. #define I_KEYTAB_C
  23. #define I_LOOP_C
  24. #define I_MAIN_C
  25. #define I_MISC_C
  26. #define I_MESSAGES_C
  27. #define I_ORIEDT_C
  28. #define I_PROMPT_C
  29. #define I_SCREEN_C
  30. #define I_SET_C
  31. #define I_SIGNALS_C
  32. #define I_VIRTUAL_C
  33.  
  34. #define I_RC_CHECK
  35.  
  36. #include "origami.h"
  37. #include <h/rcformat.h>
  38. #include <h/envvar_str.h>
  39. #include <lib/ori_rc_lib.h>
  40. #include <lib/ori_add_lib.h>
  41. /*}}}  */
  42.  
  43. /*{{{  variables*/
  44. public char *ori_name=0;
  45. public char const * ori_path=M_RC_PATH;
  46. public off_t helpofs=0;
  47. public off_t compofs=0;
  48. public FILE *rcfile=0;
  49. #ifdef NOMEMDUMP
  50.   public char *mem_dump_malloc;
  51. #endif
  52. /*}}}  */
  53.  
  54. /*{{{  rcclose*/
  55. public void rcclose(void)
  56. {
  57.   if (rcfile)
  58.    { fclose(rcfile);
  59.      rcfile=0;
  60.    }
  61. }
  62. /*}}}  */
  63. /*{{{  open_sysfile*/
  64. public char *open_sysfile(char const * const ending,char * const name_default)
  65. {
  66.   return
  67.    ( get_system_filename
  68.       ( ori_path,
  69.         ( rc_name
  70.            ? rc_name
  71.            : (char*)get_msg(M_BASE_FORMAT,(unsigned char*)ori_name)
  72.         ),
  73.         ending,
  74.         name_default
  75.       )
  76.    );
  77. }
  78. /*}}}  */
  79. /*{{{  parse rcfile*/
  80. public boolean rcfileparser
  81.  ( char ocl_opt[NO_OCL_CMD_OPTS*(2*BIND_NAME_LEN+2)],
  82.    char *mark_mode
  83.  )
  84. {
  85.   /*{{{  local vars*/
  86.   int input;
  87.   char *ori_term;
  88.   unsigned char u_m_buff[MODE_COUNT*2*(BIND_NAME_LEN+1)];
  89.   unsigned char *u_m_p;
  90.   boolean demand_found=False;
  91.   boolean kbd_read=False;
  92.   char *x;
  93.   /*{{{  RC_BUFFER_SIZE=max(RC_BUFFER_SIZE BUFSIZE)*/
  94. #  ifndef RC_BUFFER_SIZE
  95. #    define RC_BUFFER_SIZE BUFSIZE
  96. #  else
  97. #    if BUFSIZE>RC_BUFFER_SIZE
  98. #       define RC_BUFFER_SIZE BUFSIZE
  99. #    endif
  100. #  endif
  101.   /*}}}  */
  102.   static char rc_io_buff[RC_BUFFER_SIZE];
  103.   /*}}}  */
  104.  
  105.   /*{{{  open file*/
  106.   { char name[_POSIX_PATH_MAX+1];
  107.  
  108.     rcclose();
  109.     x=open_sysfile(M_RCSTR,name);
  110.     if (!*x)
  111.      { if (!ocl_opt)
  112.         { eputs(get_msg(M_RF,name));
  113.           eputs(" "STR_MISSING"\n");
  114.         }
  115.        return(True);
  116.      }
  117.     if ((rcfile=fopen(x,(char*)"rb")))
  118.        setvbuf(rcfile,rc_io_buff,_IOFBF,(size_t)RC_BUFFER_SIZE);
  119.   }
  120.   /*}}}  */
  121.   if (!ocl_opt)
  122.    /*{{{  do some initialization*/
  123.    {
  124.      /*{{{  ori_term=ORITERM | TERM | DEFAULT*/
  125.      if
  126.       (    !((ori_term=getenv(ORITERM)) && !ori_term[0])
  127.         && !((ori_term=getenv(TERM)) && !ori_term[0])
  128.       )
  129. #       ifdef DEFAULT_TERM
  130.            ori_term=(char*)DEFAULT_TERM;
  131. #       else
  132.            ori_term=(char*)empty_text;
  133. #       endif
  134.      /*}}}  */
  135.      /*{{{  clear buffer for user mode strings*/
  136.      u_m_p=u_m_buff;
  137.      /*}}}  */
  138.    }
  139.    /*}}}  */
  140.   /*{{{  little rc-file test*/
  141.   if (rc_get_w(rcfile)!=RC_CHECK)
  142.      goto rc_p_error;
  143.   ocl_msg("check %d",RC_CHECK);
  144.   /*}}}  */
  145.   /*{{{  constants*/
  146.   { int i;
  147.     boolean al;
  148.  
  149.     if (rc_get_c(rcfile)!=RC_CONST)
  150.        goto rc_p_error;
  151.     al=arg_list;
  152.     /*{{{  get constants*/
  153.     rc_nget_w(rcfile,RCC_SIZE,bind_const);
  154.     /*}}}  */
  155.     /*{{{  keyname*/
  156.     rc_nget_c(rcfile,BIND_NAME_LEN,(char*)origami_name);
  157.     origami_name[BIND_NAME_LEN]='\0';
  158.     ocl_msg("keyname",0);
  159.     /*}}}  */
  160.     /*{{{  get options, maybe return, if only options should be read*/
  161.     if (ocl_opt)
  162.      { rc_nget_c(rcfile,NO_OCL_CMD_OPTS*(2*BIND_NAME_LEN+2),ocl_opt);
  163.        ocl_opt[NO_OCL_CMD_OPTS*(2*BIND_NAME_LEN+2)]='\0';
  164.        ocl_opt[NO_OCL_CMD_OPTS*(2*BIND_NAME_LEN+2)+1]='\0';
  165.        rcclose();
  166.        return(False);
  167.      }
  168.     else
  169.        rc_skip_cw(rcfile,NO_OCL_CMD_OPTS*(2*BIND_NAME_LEN+2),0);
  170.     /*}}}  */
  171.     /*{{{  handle vars, hooks and var/mac memory mallocing*/
  172.     {
  173.       /*{{{  handle macs*/
  174.       if
  175.        ( !(fix_macros=paket_malloc(  MAX_MACRO_LENGTH*sizeof(TOKEN)
  176.                                     + (1+mac_count)*sizeof(macro_entry)))
  177.        )
  178.          goto rc_mem_full;
  179.       /*{{{  clear all buffers*/
  180.       { macro_entry *x;
  181.  
  182.         x=(macro_entry*)fix_macros;
  183.         x->mode=init;
  184.         x->mac.txt=(TOKEN*)&(fix_macros[mac_count+1]);
  185.         for
  186.          ( i=RCC_SIZE-1;
  187.            i--;
  188.            x++,x->mode=init,x->mac.txt=empty_macro
  189.          );
  190.       }
  191.       /*}}}  */
  192.       ocl_msg("macs %d",mac_count);
  193.       /*}}}  */
  194.       /*{{{  handle vars*/
  195.       ocl_msg("vars %d",var_count);
  196.       if (!(ocl_var=calloc(var_count,sizeof(stackent)))) goto rc_mem_full;
  197.       ocl_msg("cy_var %d",var_cur_lev);
  198.       ocl_msg("sy_var %d",var_scr_h);
  199.       ocl_msg("syo_var %d",var_off_h);
  200.       ocl_msg("sx_var %d",var_scr_w);
  201.       ocl_msg("sxo_var %d",var_off_w);
  202.       ocl_msg("ocl_arg %d",var_ocl_arg);
  203.       ocl_msg("uw_var %d",var_us_buff);
  204.       ocl_msg("cw_var %d",var_cu_buff);
  205.       ocl_msg("me_var %d",var_m_edit);
  206.       ocl_msg("mb_var %d",var_mod_beh);
  207.       ocl_msg("kc_var %d",var_key_count);
  208.       ocl_msg("mouse_x %d",var_m_x);
  209.       ocl_msg("mouse_y %d",var_m_y);
  210.       ocl_msg("mouse_b %d",var_m_but);
  211.       ocl_msg("mouse_go_y %d",var_m_gy);
  212.       ocl_msg("mouse_outside %d",var_m_out);
  213.       ocl_msg("mouse_buf %d",var_m_buff);
  214.       ocl_msg("abort key %d",general_abort_key);
  215.       /*}}}  */
  216.       /*{{{  specials*/
  217.       /*{{{  mode limiter*/
  218.       if (comma)
  219.        { ocl_msg("mode limit >%c<",comma); }
  220.       else if (!(comma=get_msg(D_COMMA)[0]))
  221.          comma=MSG_D_COMMA;
  222.       /*}}}  */
  223.       /*{{{  line limiter*/
  224.       if (eoln_str)
  225.        { ocl_msg("lineend mark >%c<",eoln_str); }
  226.       else if (!(eoln_str=get_msg(D_EOLN)[0]))
  227.          eoln_str=MSG_D_EOLN;
  228.       /*}}}  */
  229.       /*{{{  shift mark*/
  230.       if (soln_str)
  231.        { ocl_msg("linestart mark >%c<",soln_str); }
  232.       else if (!(soln_str=get_msg(D_SOLN)[0]))
  233.          soln_str=MSG_D_SOLN;
  234.       if (soln_str==' ')
  235.          soln_str='\0';
  236.       /*}}}  */
  237.       /*}}}  */
  238.       /*{{{  hooks*/
  239.       ocl_msg("auto macro %d",auto_macro);
  240.       ocl_msg("ab_mac %d",abort_macro);
  241.       ocl_msg("knb_mac %d",knb_macro);
  242.       ocl_msg("pin %d",pin_macro);
  243.       ocl_msg("pout %d",pout_macro);
  244.       ocl_msg("v_mac %d",view_macro);
  245.       ocl_msg("bchg_mac %d",buff_macro);
  246.       /*}}}  */
  247.       /*{{{  switches*/
  248.       if (var_notitle) { ocl_msg("no title\n",0); }
  249.       if (arg_list) { ocl_msg("arg_list",0); }
  250.       if (al) arg_list=True;
  251.       /*}}}  */
  252.     }
  253.     /*}}}  */
  254.   }
  255.   /*}}}  */
  256.   /*{{{  read all rc entries*/
  257.   { char t_buff[NAME_LG+1];
  258.  
  259.     for (;;)
  260.      { switch ((input=rc_get_c(rcfile)))
  261.         {
  262.           /*{{{  ende/reference ->break;*/
  263.           case RC_ENDE:
  264.           case RC_BIND:
  265.              break;
  266.           /*}}}  */
  267.           /*{{{  strings*/
  268.           case RC_STRINGS:
  269.            { int n;
  270.              unsigned char *s;
  271.  
  272.              if (rc_msg)
  273.                 goto rc_p_error;
  274.              rc_msg_count=rc_get_w(rcfile);
  275.              n=rc_get_w(rcfile);
  276.              if (!(rc_msg=paket_malloc(rc_msg_count*sizeof(unsigned char*)+n)))
  277.                 goto rc_mem_full;
  278.              s=(unsigned char*)((unsigned char**)rc_msg+rc_msg_count);
  279.              rc_nget_c(rcfile,n,(char*)s);
  280.              for (n=rc_msg_count;n--;)
  281.               { rc_msg[n]=s;
  282.                 while (*s++);
  283.               }
  284.              continue;
  285.            }
  286.           /*}}}  */
  287.           /*{{{  termalias*/
  288.           case RC_TERMALIAS:
  289.            { char tname[NAME_LG+1];
  290.              int ch;
  291.              boolean found;
  292.            
  293.              found=False;
  294.              while ((ch=rc_get_c(rcfile)) && ch!=EOF)
  295.               /*{{{  look for a alias*/
  296.               { int l;
  297.  
  298.                 rc_get_s(rcfile,tname,NAME_LG+1);
  299.                 if (tname[l=(strlen(tname)-1)]=='*')
  300.                  { if (!strncmp(ori_term,tname,l-1)) found=True; }
  301.                 else
  302.                  { if (!strcmp(ori_term,tname)) found=True; }
  303.               }
  304.               /*}}}  */
  305.              /*{{{  get the replace term*/
  306.              rc_get_s(rcfile,tname,NAME_LG+1);
  307.              /*}}}  */
  308.              if (found) strcpy(ori_term=t_buff,tname);
  309.              ocl_msg("termalias replaced %d",found);
  310.              continue;
  311.            }
  312.           /*}}}  */
  313.           /*{{{  keydef*/
  314.           case RC_DEFKEY:
  315.            { char kname[NAME_LG+1];
  316.              int nodes;
  317.  
  318.              if (ktb_count<=0)
  319.                 goto rc_p_error;
  320.              rc_get_s(rcfile,kname,NAME_LG+1);
  321.              nodes=rc_get_w(rcfile);
  322.              if
  323.               /*{{{  kbd not read and (term matches or default)*/
  324.               (!kbd_read && (kname[0]=='\0' || !strcmp(kname,ori_term)))
  325.               /*}}}  */
  326.               /*{{{  read the table*/
  327.               { KEY *tp;
  328.                 KEY const *top;
  329.                 int *m;
  330.  
  331.                 kbd_read=True;
  332.                 /*{{{  get space for table and bind_marks*/
  333.                 if
  334.                  (    !(top=tp=paket_malloc(nodes*sizeof(KEY)))
  335.                    || !(m=paket_malloc(ktb_count*sizeof(int)))
  336.                  )
  337.                    goto rc_mem_full;
  338.                 /*}}}  */
  339.                 /*{{{  read all help marks*/
  340.                 rc_nget_w(rcfile,ktb_count,(int*)m);
  341.                 /*}}}  */
  342.                 /*{{{  read all nodes*/
  343.                 while (nodes--)
  344.                  { set_key_data(tp,rcfile);
  345.                    tp++;
  346.                  }
  347.                 /*}}}  */
  348.                 set_key_top(top,m);
  349.               }
  350.               /*}}}  */
  351.              else
  352.               /*{{{  don't read*/
  353.               { rc_skip_cw(rcfile,nodes*2,nodes+ktb_count);
  354.                 ocl_msg("keydef %d skip",nodes);
  355.               }
  356.               /*}}}  */
  357.              continue;
  358.            }
  359.           /*}}}  */
  360.           /*{{{  usermodestrings*/
  361.           case RC_MODE:
  362.            { int no;
  363.              int off;
  364.  
  365.              no=rc_get_c(rcfile);
  366.              /*{{{  get long and short form*/
  367.              for (off=MODE_COUNT;off>=0;off-=MODE_COUNT)
  368.               { int m_lg;
  369.  
  370.                 m_lg=rc_get_w(rcfile);
  371.                 if (m_lg)
  372.                  { u_modes[no+off]=u_m_p;
  373.                    rc_nget_c(rcfile,m_lg,(char*)u_m_p);
  374.                    u_m_p+=m_lg;
  375.                    *u_m_p++='\0';
  376.                  }
  377.               }
  378.              /*}}}  */
  379.              if (!u_modes[no])
  380.                 u_modes[no]=u_modes[no+MODE_COUNT];
  381.              ocl_msg("user mode %d",no);
  382.              continue;
  383.            }
  384.           /*}}}  */
  385.           /*{{{  macset*/
  386.           case RC_MAC_SET:
  387.            { int lg;
  388.              TOKEN *t;
  389.  
  390.              lg=rc_get_w(rcfile);
  391.              t=paket_malloc(lg*sizeof(TOKEN));
  392.              if (!t) goto rc_mem_full;
  393.              ocl_msg("mac paket %d\n",lg);
  394.              do
  395.               /*{{{  get one mac*/
  396.               { int ml;
  397.                 int no;
  398.  
  399.                 no=rc_get_w(rcfile);
  400.                 ml=rc_get_w(rcfile);
  401.                 ocl_msg("  mac %d\n",no);
  402.                 if (no>mac_count || no<=0)
  403.                    goto rc_p_error;
  404.                 ((macro_entry*)fix_macros)[no].mode=def;
  405.                 ((macro_entry*)fix_macros)[no].mac.txt=t;
  406.                 rc_nget_w(rcfile,ml,t);
  407.                 t+=ml;
  408.                 *t++=M_END_MACRO;
  409.                 lg-=ml+1;
  410.               }
  411.               /*}}}  */
  412.              while (lg>0);
  413.              continue;
  414.            }
  415.           /*}}}  */
  416.           /*{{{  macroinit/load*/
  417.           case RC_LOADMACRO:
  418.           case RC_INITMACRO:
  419.            { int macro;
  420.              int lg;
  421.              off_t o;
  422.  
  423.              if (!fix_macros)
  424.                 goto rc_p_error;
  425.              if (input==RC_LOADMACRO)
  426.                 o=ftell(rcfile);
  427.              macro=rc_get_w(rcfile);
  428.              if (macro>mac_count || macro<=0)
  429.                 goto rc_p_error;
  430.              lg=rc_get_w(rcfile);
  431.              if (input==RC_LOADMACRO)
  432.               /*{{{  store demand info and skip code*/
  433.               { demand_found=True;
  434.                 ((macro_entry*)fix_macros)[macro].mode=load;
  435.                 ((macro_entry*)fix_macros)[macro].mac.off=o;
  436.                 rc_skip_cw(rcfile,0,lg);
  437.                 ocl_msg("skip demand load %d",macro);
  438.               }
  439.               /*}}}  */
  440.              else
  441.               /*{{{  store function info and load*/
  442.               { ((macro_entry*)fix_macros)[macro].mode=init;
  443.                 ((macro_entry*)fix_macros)[macro].mac.txt=paket_malloc((lg+1)*sizeof(TOKEN));
  444.                 if (!fix_macros[macro].mac.txt)
  445.                    goto rc_mem_full;
  446.                 rc_nget_w(rcfile,lg,(int*)fix_macros[macro].mac.txt);
  447.                 ((TOKEN*)fix_macros[macro].mac.txt)[lg]=M_END_MACRO;
  448.                 ocl_msg("read macro %d",macro);
  449.               }
  450.               /*}}}  */
  451.              continue;
  452.            }
  453.           /*}}}  */
  454.           /*{{{  comment/os-extension*/
  455.           case RC_OS_EXTENSION:
  456. #            ifdef RC_OS_EXT_HANDLE
  457.               /*{{{  special treatment*/
  458.               { input=rc_get_c(rcfile);
  459.                 RC_OS_EXT_HANDLE(rcfile,input);
  460.                 continue;
  461.               }
  462.               /*}}}  */
  463. #            endif
  464.           case RC_COMMENT:
  465.              rc_get_s(rcfile,(char*)0,INT_MAX);
  466.              continue;
  467.           /*}}}  */
  468.           /*{{{  sets*/
  469.           case RC_CHARSET:
  470.              if (init_set())
  471.                 goto rc_p_error;
  472.              ocl_msg("sets",0);
  473.              continue;
  474.           /*}}}  */
  475.           /*{{{  marks*/
  476.           case RC_MARKS:
  477.            { char name[FOLD_PATTERN_LEN];
  478.  
  479.              /*{{{  read stored name*/
  480.              rc_nget_c(rcfile,FOLD_PATTERN_LEN-1,name);
  481.              name[FOLD_PATTERN_LEN-1]='\0';
  482.              /*}}}  */
  483.              if (mark_mode && !strcmp(mark_mode,name))
  484.               /*{{{  reset mark strings*/
  485.               { int i;
  486.  
  487.                 mark_mode=0;
  488.                 for (i=4;i--;)
  489.                    rc_nget_c(rcfile,FOLD_TAG_LENGTH,(char*)init_buffer.f.str.txt[i]);
  490.                 ocl_msg("read marks",0);
  491.               }
  492.               /*}}}  */
  493.              else
  494.               /*{{{  overread the data*/
  495.               { rc_skip_cw(rcfile,4*FOLD_TAG_LENGTH,0);
  496.                 ocl_msg("skip marks",0);
  497.               }
  498.               /*}}}  */
  499.              continue;
  500.            }
  501.           /*}}}  */
  502.           /*{{{  mouse-tab*/
  503.           case RC_M_TAB:
  504.              mouse_number=rc_get_w(rcfile);
  505. #            ifdef MOUSY
  506.                 if ((mouse_mapping=paket_malloc(mouse_number*sizeof(TOKEN)))==(TOKEN*)0)
  507.                    goto rc_mem_full;
  508.                 rc_nget_w(rcfile,mouse_number,(int*)mouse_mapping);
  509. #            else
  510.                 rc_skip_cw(rcfile,0,mouse_number);
  511. #            endif
  512.              ocl_msg("read mouse tab",0);
  513.              continue;
  514.           /*}}}  */
  515.           /*{{{  reference compress words*/
  516.           case RC_REF_COMP_STR:
  517.              compofs=ftell(rcfile);
  518.              ref_skip_comp_data(rcfile);
  519.              continue;
  520.           /*}}}  */
  521.           /*{{{  error!*/
  522.           default:
  523.              goto rc_p_error;
  524.           /*}}}  */
  525.         }
  526.        break;
  527.      }
  528.   }
  529.   /*}}}  */
  530.   /*{{{  store position for help!*/
  531.   helpofs=ftell(rcfile);
  532.   /*}}}  */
  533.   /*{{{  malloc memory and copy user mode string*/
  534.   { unsigned char *x;
  535.     unsigned char **d;
  536.     int i;
  537.  
  538.     if (u_m_p!=u_m_buff)
  539.      /*{{{  copy buffer to malloced memory*/
  540.      { if (!(x=paket_malloc(u_m_p-u_m_buff)))
  541.         { rc_mem_full:
  542.           eputs((unsigned char*)M_NO_MEMORY);
  543.           eputc('\n');
  544.           return(True);
  545.         }
  546.        memcpy(x,u_m_buff,u_m_p-u_m_buff);
  547.      }
  548.      /*}}}  */
  549.     /*{{{  set char pointers and change comma*/
  550.     for (i=2*MODE_COUNT-1,d=u_modes;i>=0;i--,d++)
  551.        if (*d)
  552.           *d=x+(*d-u_m_buff);
  553.        else
  554.           *d=(unsigned char*)empty_text;
  555.     /*}}}  */
  556.   }
  557.   /*}}}  */
  558.   /*{{{  mark mode missing*/
  559.   if (mark_mode)
  560.    { eputs((unsigned char*)M_FM);
  561.      eputc('\n');
  562.      return(True);
  563.    }
  564.   /*}}}  */
  565.   /*{{{  if no macro-info or ktb given -> error*/
  566.   if (!fix_macros || !kbd_read)
  567.    { rc_p_error:
  568.  
  569.      if (!ocl_opt)
  570.         eputs(get_msg(M_NO_KTAB,x));
  571.      return(True);
  572.    }
  573.   /*}}}  */
  574.   /*{{{  set standard-vars*/
  575.   cy_ind= var_cur_lev;
  576.   ocl_var[var_path].v=PATH_C;
  577.   /*}}}  */
  578.   if (!demand_found)
  579.      rcclose();
  580.   return(False);
  581. }
  582. /*}}}  */
  583. /*{{{  load_demand*/
  584. public TOKEN const *load_demand(int const n)
  585. {
  586.   ocl_msg("loading %d",n);
  587.   if (n>=0 && n<=mac_count+1)
  588.      switch (fix_macros[n].mode)
  589.       { macro_entry m;
  590.         int lg;
  591.  
  592.         case load:
  593.            m=fix_macros[n];
  594.            if
  595.             /*{{{  use rcfile and seek to position*/
  596.             (    (    rcfile
  597.                    || (rcfile=fopen(open_sysfile(M_RCSTR,(char*)0),(char*)"rb"))
  598.                  )
  599.               && !fseek(rcfile,(off_t)m.mac.off,SEEK_SET)
  600.               && rc_get_w(rcfile)==n
  601.               && (lg=rc_get_w(rcfile))>=0
  602.               && lg<OCL_CODE_LEN
  603.             )
  604.             /*}}}  */
  605.             /*{{{  read and copy macro*/
  606.             { char *s;
  607.  
  608.               if ((s=ori_malloc(sizeof(off_t)+(lg+1)*sizeof(TOKEN))))
  609.                { m.mode=loaded;
  610.                  *((off_t*)s)=m.mac.off;
  611.                  m.mac.txt=(TOKEN*)(s+sizeof(off_t));
  612.                  rc_nget_w(rcfile,lg,(int*)m.mac.txt);
  613.                  ((TOKEN*)m.mac.txt)[lg]=M_END_MACRO;
  614.                  lg=rc_get_c(rcfile);
  615.                  if (lg<0 || lg>=RC_COUNT_TAGS)
  616.                     paket_free(s);
  617.                  else
  618.                     ((macro_entry*)fix_macros)[n]=m;
  619.                }
  620.             }
  621.             /*}}}  */
  622.            if (m.mode==load)
  623.               break;
  624.         default:
  625.            return(fix_macros[n].mac.txt);
  626.       }
  627.  
  628.   warn_message(get_msg(F_DEMAND,n));
  629.  
  630.   return(0);
  631. }
  632. /*}}}  */
  633. /*{{{  demand_unload*/
  634. public void unload_demand(int const n)
  635. {
  636.   ocl_msg("unloading %d",n);
  637.   if (n>=0 && n<=mac_count+1 && fix_macros[n].mode==loaded)
  638.    { off_t *s;
  639.  
  640.      s=(off_t*)fix_macros[n].mac.txt;
  641.      s-=1;
  642.      ((macro_entry*)fix_macros)[n].mac.off= *s;
  643.      ((macro_entry*)fix_macros)[n].mode=load;
  644.      paket_free(s);
  645.    }
  646.   rcclose();
  647. }
  648. /*}}}  */
  649. /*{{{  HostBegin*/
  650. public void HostBegin(char *mark_mode)
  651. {
  652.   /*{{{  maybe get storage for memdump*/
  653. #  ifdef NOMEMDUMP
  654.      if (!(mem_dump_malloc=paket_malloc(NOMEMDUMP)))
  655.       { eputs(M_NO_MEMORY);
  656.         eputc('\n');
  657.         goto init_failed;
  658.       }
  659. #  endif
  660.   /*}}}  */
  661.   /*{{{  get ori_path*/
  662.   { char const *k;
  663.  
  664.     /*{{{  maybe overwrite path by environement*/
  665.     if (ori_path==M_RC_PATH)
  666.        if
  667.         (    ((k=getenv(ORIPATH)) && k[0])
  668.           || ((k=getenv(ORIPATH_1)) && k[0])
  669.         )
  670.           ori_path=k;
  671.     if (!*ori_path)
  672.      { ori_path_err:
  673.  
  674.        eputs((unsigned char*)M_INVALID_PATH);
  675.        exit(r_arg_err);
  676.      }
  677.     /*}}}  */
  678.     /*{{{  check, if correct defined path list, no double : or : at end of path!*/
  679.     for (k=(char*)ori_path;;)
  680.      { switch (*k++)
  681.         { case '\0':
  682.              break;
  683.           case LIST_C:
  684.           case LIST_C_1:
  685.              switch (*k++)
  686.               { case '\0':
  687.                 case LIST_C:
  688.                 case LIST_C_1:
  689.                    goto ori_path_err;
  690.                 default:
  691.                    continue;
  692.               }
  693.           default:
  694.              continue;
  695.         }
  696.        break;
  697.      }
  698.     /*}}}  */
  699.   }
  700.   /*}}}  */
  701.   /*{{{  open and check msg-file*/
  702.   { char const *x;
  703.     char name[_POSIX_PATH_MAX];
  704.  
  705.     x=open_sysfile(M_MSGSTR,name);
  706.     if (!*x || (msg_file=open(x,O_RDONLY))<0)
  707.      /*{{{  not there*/
  708.      { eputs(get_msg(MSG_ARG_FORMAT,"%s %s\n",M_MIS_MES,name));
  709.        goto init_failed;
  710.      }
  711.      /*}}}  */
  712.     if (MSG_TEST_CHAR!=(char)*get_msg(T_TEST))
  713.      /*{{{  bad data*/
  714.      { char msg_found[MSG_LENGTH+1];
  715.  
  716.        strcpy(msg_found,(char*)get_msg(T_TEST));
  717.        eputs
  718.         ( get_msg
  719.            ( MSG_ARG_FORMAT,
  720.              M_IN_MES,
  721.              T_TEST,
  722.              MSG_TEST_CHAR,
  723.              MSG_LENGTH,
  724.              x,
  725.              msg_found
  726.            )
  727.         );
  728.        goto init_failed;
  729.      }
  730.      /*}}}  */
  731.   }
  732.   /*}}}  */
  733.   /*{{{  get prompts.. from msg-file*/
  734.   NO=get_msg(I_NO)[0];
  735.   YES=get_msg(I_YES)[0];
  736.   AB=get_msg(I_AB)[0];
  737.   DO_AB=get_msg(I_DO_AB)[0];
  738.   DO_REST=get_msg(I_DO_REST)[0];
  739.   /*}}}  */
  740.   /*{{{  parse rc-file*/
  741.   if (rcfileparser((char*)0,mark_mode))
  742.      goto init_failed;
  743.   /*}}}  */
  744.   /*{{{  init keyboard and screen*/
  745.   if (get_terminal_capability())
  746.      goto init_failed;
  747.   init_keyboard();
  748.   init_signals();
  749.   init_terminal();
  750.   allow_text_so=(so && !sg);
  751.   chg_dsp_type('c');
  752.   /*}}}  */
  753.   return;
  754.  
  755. init_failed:
  756.   exit(r_init_err);
  757. }
  758. /*}}}  */
  759. /*{{{  initialise links in editor*/
  760. public void initialise(void)
  761. {
  762.   new_data(&null_element);
  763.   set_linetyp(null_element,NOT_FOLD);
  764.   null_element.indent = 0;
  765.   null_element.x.fold.UU.U1.indent = 0;
  766.   null_element.x.fold.data = 0;
  767.   null_element.x.fold.UU.U1.type = DEFAULT_TYPE;
  768.   null_element.x.fold.UU.U1.contents = TEXT_CONTENTS;
  769.   null_element.x.fold.close_line = DEF_CURSOR_LINE;
  770.   pick_head=proc_new_element();
  771.   pick_tail = pick_head;
  772. }
  773. /*}}}  */
  774.