/*{{{  #includes*/
#include <string.h>
#include <stdlib.h>
#include <stdio.h>

#include <local/bool.h>
#include <local/argparse.h>

#define VIEW_C

#include "../common/os.h"
#include "../common/keys.h"
#include "../common/rcformat.h"
/*}}}  */

/*{{{  variables*/
char filebase[60];
FILE *rc;
bool usage=FALSE;
bool std=FALSE;
/*{{{  fold-marks*/
char fo[tag_length]=begin_standard;
char fc[tag_length]=end_standard;
/*}}}  */
/*{{{  TOKEN->names*/
char *dec[O_CALL_STRING-O_NOP+1];
/*{{{  init_dec*/
#ifdef STD_C
void init_dec(void)
#else
init_dec()
#endif
{
  /*{{{  ugly but easy to extend, no order!!!*/
  dec[O_NOP-O_NOP]="O_NOP";
  dec[M_ADD_COUNTER-O_NOP]="M_ADD_COUNTER";
  dec[M_BEGIN_FOLD_COMMENT-O_NOP]="M_BEGIN_FOLD_COMMENT";
  dec[M_BEGIN_OF_LINE-O_NOP]="M_BEGIN_OF_LINE";
  dec[M_BEHIND_COUNTER_X_POS-O_NOP]="M_BEHIND_COUNTER_X_POS";
  dec[M_BOT_OF_FOLD-O_NOP]="M_BOT_OF_FOLD";
  dec[M_CALL-O_NOP]="M_CALL";
  dec[M_CHANGED-O_NOP]="M_CHANGED";
  dec[M_CLOSED_FOLD-O_NOP]="M_CLOSED_FOLD";
  dec[M_END_FOLD_COMMENT-O_NOP]="M_END_FOLD_COMMENT";
  dec[M_END_MACRO-O_NOP]="M_END_MACRO";
  dec[M_END_OF_LINE-O_NOP]="M_END_OF_LINE";
  dec[M_EXIT-O_NOP]="M_EXIT";
  dec[M_FILED_FOLD-O_NOP]="M_FILED_FOLD";
  dec[M_GO_COUNTER_X_POS-O_NOP]="M_GO_COUNTER_X_POS";
  dec[M_GO_LINE-O_NOP]="M_GO_LINE";
  dec[M_GO_X_POS-O_NOP]="M_GO_X_POS";
  dec[M_INT_STRING-O_NOP]="M_INT_STRING";
  dec[M_INV_COUNTER-O_NOP]="M_INV_COUNTER";
  dec[M_JMP-O_NOP]="M_JMP";
  dec[M_JMP_FALSE-O_NOP]="M_JMP_FALSE";
  dec[M_JMP_TRUE-O_NOP]="M_JMP_TRUE";
  dec[M_LANGUAGE-O_NOP]="M_LANGUAGE";
  dec[M_NOT-O_NOP]="M_NOT";
  dec[M_NULL_COUNTER-O_NOP]="M_NULL_COUNTER";
  dec[M_POSITIV_COUNTER-O_NOP]="M_POSITIV_COUNTER";
  dec[M_POS_TO_COUNTER-O_NOP]="M_POS_TO_COUNTER";
  dec[M_POP_INT-O_NOP]="M_POP_INT";
  dec[M_PROMPT-O_NOP]="M_PROMPT";
  dec[M_PUSH_INT-O_NOP]="M_PUSH_INT";
  dec[M_READ_REPEAT-O_NOP]="M_READ_REPEAT";
  dec[M_SET_COUNTER-O_NOP]="M_SET_COUNTER";
  dec[M_STORE_LINE_NO-O_NOP]="M_STORE_LINE_NO";
  dec[M_SUM_COUNTER-O_NOP]="M_SUM_COUNTER";
  dec[M_TEST_CHAR-O_NOP]="M_TEST_CHAR";
  dec[M_TEXTLINE-O_NOP]="M_TEXTLINE";
  dec[M_TOP_OF_FOLD-O_NOP]="M_TOP_OF_FOLD";
  dec[O_ATTACH_FILE-O_NOP]="O_ATTACH_FILE";
  dec[O_AUTO_FOLD-O_NOP]="O_AUTO_FOLD";
  dec[O_AUTO_SAVE-O_NOP]="O_AUTO_SAVE";
  dec[O_A_AUTO_SAVE-O_NOP]="O_A_AUTO_SAVE";
  dec[O_A_ECHO-O_NOP]="O_A_ECHO";
  dec[O_A_OVER-O_NOP]="O_A_OVER";
  dec[O_A_VIEW-O_NOP]="O_A_VIEW";
  dec[O_BOT_OF_FOLD-O_NOP]="O_BOT_OF_FOLD";
  dec[O_BREAK-O_NOP]="O_BREAK";
  dec[O_CAPITALIZE_WORD-O_NOP]="O_CAPITALIZE_WORD";
  dec[O_CLOSE_FOLD-O_NOP]="O_CLOSE_FOLD";
  dec[O_COPY-O_NOP]="O_COPY";
  dec[O_COPY_PICK-O_NOP]="O_COPY_PICK";
  dec[O_CREATE_FOLD-O_NOP]="O_CREATE_FOLD";
  dec[O_DEF_FIX-O_NOP]="O_DEF_FIX";
  dec[O_DEF_MACRO-O_NOP]="O_DEF_MACRO";
  dec[O_DELETE-O_NOP]="O_DELETE";
  dec[O_DELTO_EOL-O_NOP]="O_DELTO_EOL";
  dec[O_DEL_CHAR_R-O_NOP]="O_DEL_CHAR_R";
  dec[O_DEL_LINE-O_NOP]="O_DEL_LINE";
  dec[O_DESCRIBE_BINDINGS-O_NOP]="O_DESCRIBE_BINDINGS";
  dec[O_DOWN-O_NOP]="O_DOWN";
  dec[O_D_AUTO_SAVE-O_NOP]="O_D_AUTO_SAVE";
  dec[O_D_ECHO-O_NOP]="O_D_ECHO";
  dec[O_D_OVER-O_NOP]="O_D_OVER";
  dec[O_D_VIEW-O_NOP]="O_D_VIEW";
  dec[O_END_OF_LINE-O_NOP]="O_END_OF_LINE";
  dec[O_ENTER_FOLD-O_NOP]="O_ENTER_FOLD";
  dec[O_EXIT_FOLD-O_NOP]="O_EXIT_FOLD";
  dec[O_FILE_FOLD-O_NOP]="O_FILE_FOLD";
  dec[O_FILTER_BUFFER-O_NOP]="O_FILTER_BUFFER";
  dec[O_FIND-O_NOP]="O_FIND";
  dec[O_FIND_REVERSE-O_NOP]="O_FIND_REVERSE";
  dec[O_FINISH-O_NOP]="O_FINISH";
  dec[O_FIRST_LINE_TO_FOLD_HEADER-O_NOP]="O_FIRST_LINE_TO_FOLD_HEADER";
  dec[O_FOLD_INFO-O_NOP]="O_FOLD_INFO";
  dec[O_GOTO_LINE-O_NOP]="O_GOTO_LINE";
  dec[O_HELP-O_NOP]="O_HELP";
  dec[O_INSERT_FILE-O_NOP]="O_INSERT_FILE";
  dec[O_ITS_REVERSE-O_NOP]="O_ITS_REVERSE";
  dec[O_ITS_SEARCH-O_NOP]="O_ITS_SEARCH";
  dec[O_LANGUAGE-O_NOP]="O_LANGUAGE";
  dec[O_LEFT-O_NOP]="O_LEFT";
  dec[O_LOWERCASE_WORD-O_NOP]="O_LOWERCASE_WORD";
  dec[O_MOVE-O_NOP]="O_MOVE";
  dec[O_NEXT_FILE-O_NOP]="O_NEXT_FILE";
  dec[O_OPEN_FOLD-O_NOP]="O_OPEN_FOLD";
  dec[O_OPEN_NEW_FILE-O_NOP]="O_OPEN_NEW_FILE";
  dec[O_PAGE_DOWN-O_NOP]="O_PAGE_DOWN";
  dec[O_PAGE_UP-O_NOP]="O_PAGE_UP";
  dec[O_PICK-O_NOP]="O_PICK";
  dec[O_PIPE_FROM_COMMAND-O_NOP]="O_PIPE_FROM_COMMAND";
  dec[O_PIPE_KBD-O_NOP]="O_PIPE_KBD";
  dec[O_PIPE_TO_COMMAND-O_NOP]="O_PIPE_TO_COMMAND";
  dec[O_PREV_FILE-O_NOP]="O_PREV_FILE";
  dec[O_PROMPT-O_NOP]="O_PROMPT";
  dec[O_PUT_PICK-O_NOP]="O_PUT_PICK";
  dec[O_QUERY_REPLACE-O_NOP]="O_QUERY_REPLACE";
  dec[O_QUIT-O_NOP]="O_QUIT";
  dec[O_QUOTE-O_NOP]="O_QUOTE";
  dec[O_REFRESH-O_NOP]="O_REFRESH";
  dec[O_REMOVE_FOLD-O_NOP]="O_REMOVE_FOLD";
  dec[O_REPLACE-O_NOP]="O_REPLACE";
  dec[O_REP_0-O_NOP]="REP_0";
  dec[O_REP_1-O_NOP]="O_REP_1";
  dec[O_REP_2-O_NOP]="O_REP_2";
  dec[O_REP_3-O_NOP]="O_REP_3";
  dec[O_REP_4-O_NOP]="O_REP_4";
  dec[O_REP_5-O_NOP]="O_REP_5";
  dec[O_REP_6-O_NOP]="O_REP_6";
  dec[O_REP_7-O_NOP]="O_REP_7";
  dec[O_REP_8-O_NOP]="O_REP_8";
  dec[O_REP_9-O_NOP]="O_REP_9";
  dec[O_RESET_USER_MODE-O_NOP]="O_RESET_USER_MODE";
  dec[O_RETURN-O_NOP]="O_RETURN";
  dec[O_RIGHT-O_NOP]="O_RIGHT";
  dec[O_SAVE_FILE-O_NOP]="O_SAVE_FILE";
  dec[O_SET_USER_MODE-O_NOP]="O_SET_USER_MODE";
  dec[O_SHELL-O_NOP]="O_SHELL";
  dec[O_SHELL_COMMAND-O_NOP]="O_SHELL_COMMAND";
  dec[O_START_OF_LINE-O_NOP]="O_START_OF_LINE";
  dec[O_SUSPEND-O_NOP]="O_SUSPEND";
  dec[O_SW_KBD-O_NOP]="O_SW_KBD";
  dec[O_TOGGLE_CASE-O_NOP]="O_TOGGLE_CASE";
  dec[O_TOP_OF_FOLD-O_NOP]="O_TOP_OF_FOLD";
  dec[O_TRANSPOSE_CHARACTERS-O_NOP]="O_TRANSPOSE_CHARACTERS";
  dec[O_UNDEL_CHAR-O_NOP]="O_UNDEL_CHAR";
  dec[O_UNDEL_LINE-O_NOP]="O_UNDEL_LINE";
  dec[O_UP-O_NOP]="O_UP";
  dec[O_UPPERCASE_WORD-O_NOP]="O_UPPERCASE_WORD";
  dec[O_WORD_LEFT-O_NOP]="O_WORD_LEFT";
  dec[O_WORD_RIGHT-O_NOP]="O_WORD_RIGHT";
  dec[O_WRITE_FILE-O_NOP]="O_WRITE_FILE";
  dec[O_EXE_MACRO-O_NOP]="O_EXE_MACRO";
  dec[O_CALL_FIX_1-O_NOP]="O_CALL_FIX_1";
  dec[O_CALL_FIX_2-O_NOP]="O_CALL_FIX_2";
  dec[O_CALL_FIX_3-O_NOP]="O_CALL_FIX_3";
  dec[O_CALL_FIX_4-O_NOP]="O_CALL_FIX_4";
  dec[O_CALL_FIX_5-O_NOP]="O_CALL_FIX_5";
  dec[O_CALL_FIX_6-O_NOP]="O_CALL_FIX_6";
  dec[O_CALL_FIX_7-O_NOP]="O_CALL_FIX_7";
  dec[O_CALL_FIX_8-O_NOP]="O_CALL_FIX_8";
  dec[O_CALL_FIX_9-O_NOP]="O_CALL_FIX_9";
  dec[O_CALL_FIX_10-O_NOP]="O_CALL_FIX_10";
  dec[O_CALL_FIX_11-O_NOP]="O_CALL_FIX_11";
  dec[O_CALL_FIX_12-O_NOP]="O_CALL_FIX_12";
  dec[O_CALL_FIX_13-O_NOP]="O_CALL_FIX_13";
  dec[O_CALL_FIX_14-O_NOP]="O_CALL_FIX_14";
  dec[O_CALL_FIX_15-O_NOP]="O_CALL_FIX_15";
  dec[O_CALL_FIX_16-O_NOP]="O_CALL_FIX_16";
  dec[O_CALL_FIX_17-O_NOP]="O_CALL_FIX_17";
  dec[O_CALL_FIX_18-O_NOP]="O_CALL_FIX_18";
  dec[O_CALL_FIX_19-O_NOP]="O_CALL_FIX_19";
  dec[O_CALL_FIX_20-O_NOP]="O_CALL_FIX_20";
  dec[O_CALL_FIX_21-O_NOP]="O_CALL_FIX_21";
  dec[O_CALL_FIX_22-O_NOP]="O_CALL_FIX_22";
  dec[O_CALL_FIX_23-O_NOP]="O_CALL_FIX_23";
  dec[O_CALL_FIX_24-O_NOP]="O_CALL_FIX_24";
  dec[O_CALL_FIX_25-O_NOP]="O_CALL_FIX_25";
  dec[O_CALL_FIX_26-O_NOP]="O_CALL_FIX_26";
  dec[O_CALL_FIX_27-O_NOP]="O_CALL_FIX_27";
  dec[O_CALL_FIX_28-O_NOP]="O_CALL_FIX_28";
  dec[O_CALL_FIX_29-O_NOP]="O_CALL_FIX_29";
  dec[O_CALL_FIX_30-O_NOP]="O_CALL_FIX_30";
  dec[O_CALL_FIX_31-O_NOP]="O_CALL_FIX_31";
  dec[O_CALL_FIX_32-O_NOP]="O_CALL_FIX_32";
  dec[O_CALL_FIX_33-O_NOP]="O_CALL_FIX_33";
  dec[O_CALL_FIX_34-O_NOP]="O_CALL_FIX_34";
  dec[O_CALL_FIX_35-O_NOP]="O_CALL_FIX_35";
  dec[O_CALL_FIX_36-O_NOP]="O_CALL_FIX_36";
  dec[O_CALL_FIX_37-O_NOP]="O_CALL_FIX_37";
  dec[O_CALL_FIX_38-O_NOP]="O_CALL_FIX_38";
  dec[O_CALL_FIX_39-O_NOP]="O_CALL_FIX_39";
  dec[O_CALL_FIX_40-O_NOP]="O_CALL_FIX_40";
  dec[O_CALL_FIX_41-O_NOP]="O_CALL_FIX_41";
  dec[O_CALL_FIX_42-O_NOP]="O_CALL_FIX_42";
  dec[O_CALL_FIX_43-O_NOP]="O_CALL_FIX_43";
  dec[O_CALL_FIX_44-O_NOP]="O_CALL_FIX_44";
  dec[O_CALL_FIX_45-O_NOP]="O_CALL_FIX_45";
  dec[O_CALL_FIX_46-O_NOP]="O_CALL_FIX_46";
  dec[O_CALL_FIX_47-O_NOP]="O_CALL_FIX_47";
  dec[O_CALL_FIX_48-O_NOP]="O_CALL_FIX_48";
  dec[O_CALL_FIX_49-O_NOP]="O_CALL_FIX_49";
  dec[O_CALL_FIX_50-O_NOP]="O_CALL_FIX_50";
  dec[O_CALL_FIX_51-O_NOP]="O_CALL_FIX_51";
  dec[O_CALL_FIX_52-O_NOP]="O_CALL_FIX_52";
  dec[O_CALL_FIX_53-O_NOP]="O_CALL_FIX_53";
  dec[O_CALL_FIX_54-O_NOP]="O_CALL_FIX_54";
  dec[O_CALL_FIX_55-O_NOP]="O_CALL_FIX_55";
  dec[O_CALL_FIX_56-O_NOP]="O_CALL_FIX_56";
  dec[O_CALL_FIX_57-O_NOP]="O_CALL_FIX_57";
  dec[O_CALL_FIX_58-O_NOP]="O_CALL_FIX_58";
  dec[O_CALL_FIX_59-O_NOP]="O_CALL_FIX_59";
  dec[O_CALL_FIX_60-O_NOP]="O_CALL_FIX_60";
  dec[O_CALL_FIX_61-O_NOP]="O_CALL_FIX_61";
  dec[O_CALL_FIX_62-O_NOP]="O_CALL_FIX_62";
  dec[O_CALL_FIX_63-O_NOP]="O_CALL_FIX_63";
  dec[O_CALL_FIX_64-O_NOP]="O_CALL_FIX_64";
  dec[O_CALL_STRING-O_NOP]="O_CALL_STRING";
  /*}}}  */
}
/*}}}  */
/*}}}  */
/*}}}  */

/*{{{  argument parser table*/
#define argnum 4

ARG argtab[] =
{
  'k', STRING_ARG, filebase,
  'h', BOOL_ARG, &usage,
  '?', BOOL_ARG, &usage,
  's', BOOL_ARG, &std
};
/*}}}  */

/*{{{  completebase*/
#ifdef STD_C
char *completebase(char *s, char *t)
#else
char *completebase(s,t) char *s, *t;
#endif
{
  char *h=getenv("HOME");

  if (h==NULL)
    *s='\0';
  else {
    strcpy(s,h);
    strcat(s,PATH_SEP);
  }
  strcat(s,filebase);
  strcat(s,t);
  return(s);
}
/*}}}  */
/*{{{  decode_mac*/
#ifdef STD_C
bool decode_mac(FILE *f,int lg)
#else
bool decode_mac(f,lg) FILE *f;int lg;
#endif
{
  int pc=0;
  TOKEN x;
  bool dopc=TRUE;

  while (lg) {
    /*{{{  show each statement*/
    x=getw(f);
    lg--;
    if (x==EOF)
      return(TRUE);
    else if (x<O_NOP) {
      /*{{{  normal chars*/
      if (dopc) {
        /*{{{  with pc*/
        if (x>=' ')
          printf("%05d: ->%c",pc,(char) x);
        else
          printf("%05d: -><%d>",pc,x);
        dopc=FALSE;
        /*}}}  */
      } else {
        /*{{{  without pc*/
        if (x>=' ')
          printf("%c",(char) x);
        else
          printf("<%d>",x);
        /*}}}  */
      }
      pc++;
      /*}}}  */
    } else {
      /*{{{  opcodes*/
      /*{{{  maybe end string in last line*/
      if (!dopc) {
        printf("<-\n");
        dopc=TRUE;
      }
      /*}}}  */
      switch (x) {
        /*{{{  two int args*/
        case M_ADD_COUNTER:
        case M_SET_COUNTER:
        case M_SUM_COUNTER: {
          int x1=getw(rc);
          int x2=getw(rc);
        
          lg-=2;
          printf("%05d: %-20s %6d %3d\n",pc,dec[x-O_NOP],x1,x2);
          pc+=3;
          break;
        }
        /*}}}  */
        /*{{{  one int arg*/
        case M_GO_LINE:
        case M_GO_X_POS:
        case M_BEHIND_COUNTER_X_POS:
        case M_GO_COUNTER_X_POS:
        case M_INV_COUNTER:
        case M_LANGUAGE:
        case M_NULL_COUNTER:
        case M_POSITIV_COUNTER:
        case M_POS_TO_COUNTER:
        case M_POP_INT:
        case M_PUSH_INT:
        case M_INT_STRING:
        case M_READ_REPEAT:
        case O_SW_KBD:
        case M_STORE_LINE_NO: {
          lg--;
          printf("%05d: %-20s %6d\n",pc,dec[x-O_NOP],getw(rc));
          pc+=2;
          break;
        }
        /*}}}  */
        /*{{{  one char-argument*/
        case M_TEST_CHAR: {
          int x1=getw(rc);
        
          lg--;
          if (x1>=' ')
            printf("%05d: %s '%c'\n",pc,dec[x-O_NOP],x1);
          else
            printf("%05d: %s 'C-%c'\n",pc,dec[x-O_NOP],x1+'@');
          pc+=2;
          break;
        }
        /*}}}  */
        /*{{{  prompt/exit*/
        case M_PROMPT:
        case M_EXIT: {
          /*{{{  show command-name*/
          if (x==M_PROMPT) {
            printf("%05d: %-20s %6d\n         <",
                   pc,dec[x-O_NOP],getw(rc));
            lg--;
            pc++;
          } else
            printf("%05d: %s\n         <",
                   pc,dec[x-O_NOP]);
          /*}}}  */
          /*{{{  correct lg and pc*/
          pc+=2;
          lg--;
          /*}}}  */
          while (((x=getw(rc))!=M_END_MACRO) && (x!=EOF)) {
            /*{{{  prompt-chars*/
            lg--;
            if (x<O_NOP)
              printf("%c",x);
            else {
              /*{{{  hope, it was counter ??*/
              printf("<counter %d>",getw(rc));
              lg--;
              pc++;
              /*}}}  */
            }
            pc++;
            /*}}}  */
          }
          if (x!=EOF)
            printf(">\n       %s\n",dec[M_END_MACRO-O_NOP]);
          break;
        }
        /*}}}  */
        /*{{{  adress*/
        case M_CALL:
        case M_JMP:
        case M_JMP_FALSE:
        case M_JMP_TRUE: {
          int ad=getw(rc);
        
          printf("%05d: %-20s  %05d (%6d)\n",pc,dec[x-O_NOP],pc+2+ad,ad);
          lg--;
          pc+=2;
          break;
        }
        /*}}}  */
        /*{{{  else only command*/
        default: {
          printf("%05d: %s\n",pc,dec[x-O_NOP]);
          pc++;
          break;
        }
        /*}}}  */
      }
      /*}}}  */
    }
    /*}}}  */
  }
  /*{{{  maybe end string in previous line*/
  if (!dopc) printf("<-\n");
  /*}}}  */
  /*{{{  automatic M_END_MACRO (generated in origami when reading rc)*/
  printf("%05d: %s\n",pc,dec[M_END_MACRO-O_NOP]);
  /*}}}  */
  return(FALSE);
}
/*}}}  */

/*{{{  main*/
#ifdef STD_C
void main(int argc,char **argv)
#else
main(argc,argv) int argc; char **argv;
#endif
{
  char *home=getenv("HOME"),
       rcfile[128];

  /*{{{  init*/
  *filebase='\0';
  init_dec();
  /*}}}  */
  argc=argparse(argc,argv,argtab,argnum);
  /*{{{  usage?*/
  if (usage) {
    printf("viewrc [-hs?] [-k<namebase>]\n");
    exit(0);
  }
  /*}}}  */
  /*{{{  handle missing output argument*/
  if (*filebase=='\0') strcpy(filebase,STD_BASENAME);
  /*}}}  */
  /*{{{  open .origamirc*/
  if (std)
    rc=stdin;
  else {
    homecheck(home);
    if ((rc=fopen(completebase(rcfile,"rc"),READ_BIN))==NULL) {
      fprintf(stderr,"no rc-file %s.\n",home,filebase);
      exit(1);
    }
  }
  /*}}}  */
  /*{{{  scan rc-file*/
  {
    int  input;
  
    while ((input=getc(rc))!=RC_ENDE) {
      switch (input) {
        /*{{{  keydef*/
        case RC_DEFKEY: {
          int nodes;
          int no=0;
          int kb=getc(rc);
        
          printf("%s  keyboard %2d\n",fo,kb);
          nodes=getw(rc);
          /*{{{  decode the tablenodes*/
          while (nodes--) {
            int co=getw(rc);
            char ke=getc(rc);
            int of1=getw(rc);
            int of2=getw(rc);
          
            /*{{{  print values of the keytabnode*/
            printf("%4d: key %3d=%s%c | ne %4d | nl %4d",
                   no,
                   ke,
                   (ke==127 ? "DE" : ke>' ' ? "  " : "C-"),
                   (ke==127 ? 'L'  : ke>' ' ? ke : ke+'@'),
                   (of1 ? of1+no : -1),
                   (of2 ? of2+no : -1),
                   co);
            no++;
            /*}}}  */
            /*{{{  maybe print coded command*/
            if (!co)
              printf("\n");
            else if (co==127)
              printf(" => co %4d = ( DEL )\n",co);
            else if (co>=O_NOP)
              printf(" => co %4d = ( %s )\n",co,dec[co-O_NOP]);
            else if (co>' ')
              printf(" => co %4d = ( %c )\n",co,co);
            else
              printf(" => co %4d = ( C-%c )\n",co,co+'@');
            /*}}}  */
          }
          /*}}}  */
          printf("%s\n",fc);
          break;
        }
        /*}}}  */
        /*{{{  macrodef/init*/
        case RC_INITMACRO:
        case RC_DEFMACRO: {
          int macro=getw(rc);
          int lg=getw(rc);
        
          printf("%s  macro %3d (lg=%4d) %s\n",
                 fo,
                 macro,
                 lg,
                 (input==RC_INITMACRO ? "init" : "def"));
          if (!decode_mac(rc,lg)) printf("%s\n",fc);
          break;
        }
        /*}}}  */
        /*{{{  keyname*/
        case RC_KEYNAME: {
          int i=keyn_lg;
          char name[keyn_lg];
          char *n=name;
        
          while (i--) *n++=getc(rc);
          *n='\0';
          printf("name of this keybind is %s.\n",name);
          break;
        }
        /*}}}  */
        /*{{{  ints*/
        case RC_INTS:
          printf("keybind needs %d variables.\n",getw(rc));
          break;
        /*}}}  */
        /*{{{  auto_macro*/
        case RC_AUTOM:
          printf("keybind uses macro %d as automacro.\n",getc(rc));
          break;
        /*}}}  */
        /*{{{  break*/
        case RC_BREAK: {
          int k=getc(rc);
        
          printf("keybind uses %d=%s%c as general-abort-key.\n",
                 k,
                 (k>' ' ? "" : "C-"),
                 (k>' ' ? k : k+'@'));
          break;
        }
        /*}}}  */
        /*{{{  marks*/
        case RC_MARKS: {
          char name[mark_name_lg];
          char mark_mode[tag_length+1];
          int i;
        
          /*{{{  read stored name*/
          for (i=0;i<(mark_name_lg-1);i++)
            name[i]=getc(rc);
          name[mark_name_lg-1]='\0';
          /*}}}  */
          printf("keybind has additional mark-typ %s :",name);
          mark_mode[0]=' ';
          /*{{{  mark 1*/
          for (i=1;i<tag_length;i++) mark_mode[i]=getc(rc);
          mark_mode[i]='\0';
          printf(mark_mode);
          /*}}}  */
          /*{{{  mark 2*/
          for (i=1;i<tag_length;i++) mark_mode[i]=getc(rc);
          mark_mode[i]='\0';
          printf(mark_mode);
          /*}}}  */
          /*{{{  mark 3*/
          for (i=1;i<tag_length;i++) mark_mode[i]=getc(rc);
          mark_mode[i]='\0';
          printf(mark_mode);
          /*}}}  */
          /*{{{  mark 4*/
          for (i=1;i<tag_length;i++) mark_mode[i]=getc(rc);
          mark_mode[i]='\0';
          printf(mark_mode);
          /*}}}  */
          printf("\n");
          break;
        }
        /*}}}  */
        /*{{{  error!*/
        default: {
          printf("\n%s\n%s%d\n%s\n",
                 "-----------------------------------------",
                 "'token'",input,"no dissassemble possible.");
          fprintf(stderr,"incorrect data in rc!\n");
          exit (1);
        }
        /*}}}  */
      }
    }
  }
  /*}}}  */
  if (!std) fclose(rc);
  exit(0);
}
/*}}}  */