gb_reserved_temp.h

Gambas is a graphical development environment based on a Basic interpreter, like Visual Basic. It us

  { "Shl",       35,  5,  2     },
  { "Shr",       35,  6,  2     },
  { "Rol",       35,  7,  2     },
  { "Ror",       35,  8,  2     },

  { "IsBoolean", 42,  1,  1     },
  { "IsByte",    42,  2,  1     },
  { "IsShort",   42,  3,  1     },
  { "IsInteger", 42,  4,  1     },
  { "IsLong",    42,  5,  1     },
  { "IsFloat",   42,  6,  1     },
  { "IsDate",    42,  7,  1     },
  { "IsString",  42,  8,  1     },
  { "IsNull",    42,  15, 1     },
  { "IsObject",  42,  16, 1     },
  { "IsNumber",  42,  17, 1     },

  { "Boolean?",  42,  1,  1     },
  { "Byte?",     42,  2,  1     },
  { "Short?",    42,  3,  1     },
  { "Integer?",  42,  4,  1     },
  { "Long?",     42,  5,  1     },
  { "Float?",    42,  6,  1     },
  { "Date?",     42,  7,  1     },
  { "String?",   42,  8,  1     },
  { "Null?",     42,  15, 1     },
  { "Object?",   42,  16, 1     },
  { "Number?",   42,  17, 1     },

  { "TypeOf",    43,  0,  1     },

  { "CBool",     44,  1,  1     },
  { "CByte",     44,  2,  1     },
  { "CShort",    44,  3,  1     },
  { "CInt",      44,  4,  1     },
  { "CInteger",  44,  4,  1     },
  { "CLng",      44,  5,  1     },
  { "CLong",     44,  5,  1     },
  { "CFloat",    44,  6,  1     },
  { "CDate",     44,  7,  1     },
  { "CStr",      44,  8,  1     },
  { "CString",   44,  8,  1     },

  { "Bin$",      45,  0,  1,  2 },
  { "Bin",       45,  0,  1,  2 },

  { "Hex$",      46,  0,  1,  2 },
  { "Hex",       46,  0,  1,  2 },

  { "Val",       47,  0,  1     },

  { "Str$",      48,  0,  1     },
  { "Str",       48,  0,  1     },

  { "Format$",   49,  0,  1,  2 },
  { "Format",    49,  0,  1,  2 },

  { "Timer",     50,  0,  0     },

  { "Now",       51,  0,  0     },

  { "Year",      52,  1,  1     },
  { "Month",     52,  2,  1     },
  { "Day",       52,  3,  1     },
  { "Hour",      52,  4,  1     },
  { "Minute",    52,  5,  1     },
  { "Second",    52,  6,  1     },
  { "WeekDay",   52,  7,  1     },

  { "Date",      53,  0,  0,  6 },

  { "Time",      54,  0,  0,  3 },

#ifndef __EVAL_RESERVED_C

  { "Error",     55,  0,  0,  2 },

  { "Eval",      56,  0,  1,  2 },

  { "Use",       57,  0,  1     },
  { "Beep",      58,  0,  0     },

  { "Wait",      59,  0,  0,  1 },

  { "Open",      60,  0,  2     },
  { "Close",     61,  0,  1     },
  { "Input",     62,  0,  0,  1 },
  { "Print",     63,  0,  1, 63 },
  { "Read",      64,  0,  1,  2 },
  { "Write",     65,  0,  1,  2 },
  { "Eof",       66,  0,  1     },
  { "Lof",       67,  0,  1     },
  { "Seek",      68,  0,  1,  3 },
  { "Kill",      69,  0,  1     },
  { "Mkdir",     70,  0,  1     },
  { "Rmdir",     71,  0,  1     },
  { "Exist",     72,  0,  1     },
  { "Rename",    73,  0,  2     },
  { "Stat",      74,  0,  1     },
  { "LineInput", 75,  0,  1     },

  { "Temp",      76,  0,  0,    },
  { "Temp$",     76,  0,  0,    },

  { "IsDir",     77,  0,  1     },
  { "Dir?",      77,  0,  1     },

  { "Dir",       78,  0,  1,  2 },
  { "Flush",     79,  0,  1     },

  { "Exec",      80,  0,  3     },
  { "Shell",     80,  1,  3     },
  { "Copy",      81,  0,  2     },
  { "Access",    82,  0,  1,  2 },
  { "Link",      83,  0,  2     },
  { "Lock",      84,  0,  1     },
  { "Unlock",    84,  1,  1     },
    /*
  { "_EventOff", 94,  0,  0     },
  { "_EventOn",  95,  0,  0     },
  */

#endif

  { NULL }
};

/*
PUBLIC CONST_INFO COMP_const_info[] =
{
  {  1, "gbCompBinary" },
  {  2, "gbCompCase" },
  {  3, "gbCompLang" },
  {  4, "gbSearchBackward" },
  {  5, "gbSearchWord" },

  {  6, "gbRead" },
  {  7, "gbWrite" },
  {  8, "gbAppend" },
  {  9, "gbCreate" },
  { 10, "gbDirect" },
  { 11, "gbBinary" },

  { 12, "gbNull" },
  { 13, "gbBoolean" },
  { 14, "gbByte" },
  { 15, "gbShort" },
  { 16, "gbInteger" },
  { 17, "gbLong" },
  { 18, "gbFloat" },
  { 19, "gbDate" },
  { 20, "gbString" },
  { 21, "gbVariant" },
  { 22, "gbObject" },

  { 23, "gbFile" },
  { 24, "gbDirectory" },
  { 25, "gbDevice" },
  { 26, "gbPipe" },
  { 27, "gbSocket" },
  { 28, "gbLink" },
  { 29, "gbHidden" },

  { 30, "gbVoid" },

  { -1, NULL }
};
*/

PUBLIC TABLE *COMP_res_table;
PUBLIC TABLE *COMP_subr_table;
/*PUBLIC TABLE *COMP_const_table;*/


PUBLIC void RESERVED_init(void)
{
  COMP_INFO *info;
  SUBR_INFO *subr;
  /*CONST_INFO *cst;*/

  /* Table des mots r閟erv閟 */

  TABLE_create(&COMP_res_table, 0, TF_IGNORE_CASE);
  for (info = &COMP_res_info[0]; info->name; info++)
    TABLE_add_symbol(COMP_res_table, info->name, strlen(info->name), NULL, NULL);

  #ifdef DEBUG
  printf("Table des mots r閟erv閟:\n");
  TABLE_print(COMP_res_table, TRUE);
  #endif

  /* Table des routines int間r閑s */

  TABLE_create(&COMP_subr_table, 0, TF_IGNORE_CASE);
  for (subr = &COMP_subr_info[0]; subr->name; subr++)
  {
    if (subr->max_param == 0)
      subr->max_param = subr->min_param;

    TABLE_add_symbol(COMP_subr_table, subr->name, strlen(subr->name), NULL, NULL);
  }

  #ifdef DEBUG
  printf("Table des routines int間r閑s:\n");
  TABLE_print(COMP_subr_table, TRUE);
  #endif

  /* Table des constantes */

  /*
  TABLE_create(&COMP_const_table, 0, TF_IGNORE_CASE);
  for (cst = &COMP_const_info[0]; cst->name; cst++)
    TABLE_add_symbol(COMP_const_table, cst->name, strlen(cst->name), NULL, NULL);
  */
}


PUBLIC void RESERVED_exit(void)
{
  TABLE_delete(&COMP_res_table);
  TABLE_delete(&COMP_subr_table);
}


PUBLIC SUBR_INFO *SUBR_get(const char *subr_name)
{
  long index;

  if (!TABLE_find_symbol(COMP_subr_table, subr_name, strlen(subr_name), NULL, &index))
    return NULL;
  else
    return &COMP_subr_info[index];
}


PUBLIC SUBR_INFO *SUBR_get_from_opcode(ushort opcode, ushort optype)
{
  SUBR_INFO *si;

  for (si = COMP_subr_info; si->name; si++)
  {
    if (si->opcode == opcode)
    {
      if (si->min_param != si->max_param)
        return si;
      else if (si->optype == optype || si->optype == 0)
        return si;
    }
  }

  /*ERROR_panic("SUBR_get_from_opcode: SUBR not found !");*/
  return NULL;
}


/*
PUBLIC CONST_INFO *CONST_get(char *cst_name)
{
  long index;

  if (!TABLE_find_symbol(COMP_const_table, cst_name, strlen(cst_name), NULL, &index))
    return NULL;
  else
    return &COMP_const_info[index];
}


PUBLIC CONST_INFO *CONST_get_from_index(short index)
{
  CONST_INFO *ci;

  for (ci = COMP_const_info; ci->name; ci++)
  {
    if (ci->index == index)
      return ci;
  }

  return NULL;
}
*/