gambas-source-code/main/gbc/gbc_dump.c
Benoît Minisini 96550473f7 [CONFIGURATION]
* NEW: Put custom autoconf macros in the "m4" directory.
* NEW: Drop libltdl.

[GB.IMAGE]
* NEW: Image.Resize() and Image.Mirror() has been put in common there.
* NEW: Image.Flip() has been removed.
* NEW: Image.Copy() and Image.Resize() now supports 24-bits images.

[GB.OPENGL]
* NEW: Depends on gb.image now.
* NEW: Texture images can have any format now.


git-svn-id: svn://localhost/gambas/trunk@2236 867c0c6c-44f3-4631-809d-bfa615b0a4ec
2009-08-16 22:07:48 +00:00

645 lines
12 KiB
C

/***************************************************************************
dump.c
Class dumping
(c) 2000-2007 Benoit Minisini <gambas@users.sourceforge.net>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 1, or (at your option)
any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
***************************************************************************/
#define __GBC_DUMP_C
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <ctype.h>
#include "gb_common.h"
#include "gb_common_buffer.h"
#include "gb_error.h"
#include "gb_table.h"
#include "gbc_compile.h"
#include "gb_code.h"
#include "gb_file.h"
#include "gbc_chown.h"
static FILE *_finfo;
static const char *get_name(int index)
{
return TABLE_get_symbol_name(JOB->class->table, index);
}
static const char *get_string(int index)
{
return TABLE_get_symbol_name(JOB->class->string, index);
}
static void dump_name(int index)
{
printf("%s", get_name(index));
}
static void dump_type(TYPE type, bool as)
{
int value;
TYPE_ID id;
CLASS_ARRAY *array;
int i;
id = TYPE_get_id(type);
value = TYPE_get_value(type);
if (id == T_ARRAY)
{
array = &JOB->class->array[value];
printf("[");
for (i = 0; i < array->ndim; i++)
{
if (i > 0)
printf(",");
printf("%d", array->dim[i]);
}
printf("] As ");
dump_type(array->type, FALSE);
}
else if (id == T_OBJECT && value >= 0)
{
if (as)
printf(" As ");
dump_name(JOB->class->class[value].index);
}
else
{
if (as)
printf(" As ");
printf("%s", TYPE_get_desc(type));
}
}
static void dump_function(FUNCTION *func)
{
int i;
printf("<%lld> ", func->byref);
printf("(");
for (i = 0; i < func->nparam; i++)
{
if (i > 0) printf(", ");
if (i >= func->npmin)
printf("Optional ");
if (func->byref & (1LL << i))
printf("ByRef ");
dump_name(func->param[i].index);
dump_type(func->param[i].type, TRUE);
}
if (func->vararg)
{
if (func->nparam > 0)
printf(", ");
printf("...");
}
printf(")");
}
void CLASS_dump(void)
{
int i;
TYPE type;
CLASS_SYMBOL *sym;
CLASS *class = JOB->class;
if (JOB->is_module)
printf("MODULE ");
else if (JOB->is_form)
printf("FORM ");
else
printf("CLASS ");
printf("%s\n", class->name);
if (class->parent != NO_SYMBOL)
{
printf("CLASS INHERITS ");
dump_name(class->class[class->parent].index);
putchar('\n');
}
if (class->exported)
printf("EXPORT\n");
if (class->autocreate)
printf("CREATE\n");
if (class->optional)
printf("OPTIONAL\n");
putchar('\n');
printf("Static size : %d octets\n", class->size_stat);
printf("Dynamic size : %d octets\n\n", class->size_dyn);
for (i = 0; i < TABLE_count(class->table); i++)
{
sym = CLASS_get_symbol(class, i);
type = sym->global.type;
if (TYPE_is_null(type))
continue;
if (TYPE_is_static(type)) printf("Static ");
if (TYPE_is_public(type)) printf("Public "); else printf("Private ");
switch(TYPE_get_kind(type))
{
case TK_VARIABLE:
dump_name(i);
dump_type(type, TRUE);
break;
case TK_FUNCTION:
if (TYPE_get_id(type) == T_VOID)
printf("Procedure ");
else
printf("Function ");
dump_name(i);
dump_function(&class->function[sym->global.value]);
break;
case TK_CONST:
printf("Const ");
dump_name(i);
dump_type(type, TRUE);
printf(" = ");
dump_name(class->constant[sym->global.value].index);
break;
case TK_PROPERTY:
printf("Property ");
if (class->prop[sym->global.value].write == NO_SYMBOL)
printf("Read ");
dump_name(i);
dump_type(type, TRUE);
break;
case TK_EVENT:
printf("Event ");
dump_name(i);
break;
case TK_UNKNOWN: printf("Unknown "); break;
case TK_EXTERN: printf("Extern "); break;
case TK_LABEL: printf("Label "); break;
}
putchar('\n');
/*
if (TYPE_get_kind(type) == TK_FUNCTION)
{
func = &class->function[value];
printf(" L:%ld", func->line);
}
else if (TYPE_get_kind(type) == TK_EVENT)
func = (FUNCTION *)&class->event[value];
else if (TYPE_get_kind(type) == TK_EXTERN)
{
func = (FUNCTION *)&class->ext_func[value];
printf(" in %s", TABLE_get_symbol_name(class->table, class->ext_func[value].library));
}
*/
}
putchar('\n');
}
static void export_newline(void)
{
fputc('\n', _finfo);
}
static void export_type(TYPE type, bool scomma)
{
int value;
TYPE_ID id;
id = TYPE_get_id(type);
value = TYPE_get_value(type);
if (id == T_OBJECT && value >= 0)
{
fprintf(_finfo, "%s", get_name(JOB->class->class[value].index));
if (scomma)
fputc(';', _finfo);
}
else
fprintf(_finfo, "%s", TYPE_get_short_desc(type));
}
static void export_signature(int nparam, int npmin, PARAM *param, bool vararg)
{
int i;
for (i = 0; i < nparam; i++)
{
if (i == npmin)
fprintf(_finfo, "[");
fprintf(_finfo, "(%s)", get_name(param[i].index));
export_type(param[i].type, TRUE);
}
if (npmin < nparam)
fprintf(_finfo, "]");
if (vararg)
fprintf(_finfo, ".");
export_newline();
}
static void create_file(FILE **fw, const char *file)
{
if (!*fw)
{
*fw = fopen(file, "w");
if (!*fw)
THROW("Cannot create file: &1", FILE_cat(FILE_get_dir(COMP_project), file, NULL));
}
}
static char *read_line(FILE *f, int *plen)
{
int len;
char *line;
if (!f)
return NULL;
line = fgets(COMMON_buffer, COMMON_BUF_MAX, f);
if (!line)
return NULL;
len = strlen(line);
if (line[len - 1] == '\n')
{
line[len - 1] = 0;
len--;
}
if (plen)
*plen = len;
return line;
}
static void close_file_and_rename(FILE *f, const char *file, const char *dest)
{
if (f)
{
fclose(f);
unlink(dest);
rename(file, dest);
FILE_set_owner(dest, COMP_project);
}
else
{
unlink(file);
unlink(dest);
}
}
static void class_update_exported(CLASS *class)
{
FILE *fw = NULL;
FILE *fr;
char *name;
int len;
bool inserted = FALSE;
int cmp;
fr = fopen(".list", "r");
if (!fr && !class->exported)
return;
for(;;)
{
name = read_line(fr, &len);
if (!name)
{
cmp = 1;
}
else
{
if (name[len - 1] == '?')
{
char cname[strlen(class->name) + 2];
strcpy(cname, class->name);
strcat(cname, "?");
cmp = strcmp(name, cname);
}
else
cmp = strcmp(name, class->name);
}
if (cmp == 0)
{
if (JOB->verbose)
printf("Remove '%s' from .list file\n", name);
continue;
}
else if ((cmp > 0) && class->exported && !inserted)
{
create_file(&fw, ".list#");
if (JOB->verbose)
printf("Insert '%s%s' into .list file\n", class->name, class->optional ? "?" : "");
fputs(class->name, fw);
if (class->optional)
fputc('?', fw);
fputc('\n', fw);
inserted = TRUE;
}
if (!name)
break;
if (JOB->verbose)
printf("Copy '%s' in .list file\n", name);
create_file(&fw, ".list#");
fputs(name, fw);
fputc('\n', fw);
}
if (fr)
fclose(fr);
close_file_and_rename(fw, ".list#", ".list");
}
static void insert_class_info(CLASS *class, FILE *fw)
{
int i;
TYPE type;
CLASS_SYMBOL *sym;
char kind;
int val;
FUNCTION *func;
EVENT *event;
EXTFUNC *extfunc;
CONSTANT *cst;
if (JOB->verbose)
printf("Insert '%s' information into .info file\n", class->name);
_finfo = fw;
fprintf(_finfo, "#%s\n", class->name);
if (class->parent != NO_SYMBOL)
fprintf(_finfo, "%s", get_name(JOB->class->class[class->parent].index));
export_newline();
if (!class->nocreate)
fprintf(_finfo, "C");
if (class->autocreate)
fprintf(_finfo, "A");
if (class->optional)
fprintf(_finfo, "O");
export_newline();
for (i = 0; i < TABLE_count(class->table); i++)
{
sym = CLASS_get_symbol(class, i);
type = sym->global.type;
if (TYPE_is_null(type))
continue;
if (!TYPE_is_public(type))
continue;
switch(TYPE_get_kind(type))
{
case TK_CONST:
kind = 'C';
break;
case TK_FUNCTION:
kind = 'm';
break;
case TK_PROPERTY:
if (class->prop[sym->global.value].write == NO_SYMBOL)
kind = 'r';
else
kind = 'p';
break;
case TK_EVENT:
kind = ':';
break;
case TK_EXTERN:
kind = 'X';
break;
default:
continue;
}
fprintf(_finfo, "%s\n", get_name(i));
fprintf(_finfo, "%c\n", TYPE_is_static(type) ? toupper(kind) : kind);
export_type(type, FALSE);
if (kind == 'r' || kind == 'p')
{
val = class->prop[sym->global.value].comment;
if (val != NO_SYMBOL)
fprintf(_finfo, "%s", get_string(val));
}
export_newline();
switch(kind)
{
case 'C':
cst = &class->constant[sym->global.value];
switch(TYPE_get_id(type))
{
case T_BOOLEAN:
case T_BYTE:
case T_SHORT:
case T_INTEGER:
fprintf(_finfo, "%d\n", cst->value);
break;
case T_LONG:
fprintf(_finfo, "%" PRId64 "\n", cst->lvalue);
break;
case T_SINGLE:
case T_FLOAT:
fprintf(_finfo, "%s\n", get_name(cst->value));
break;
case T_STRING:
fprintf(_finfo, "%s\n", get_string(cst->value));
break;
default:
export_newline();
break;
}
break;
case 'm':
func = &class->function[sym->global.value];
export_signature(func->nparam, func->npmin, func->param, func->vararg);
break;
case ':':
event = &class->event[sym->global.value];
export_signature(event->nparam, event->nparam, event->param, FALSE);
break;
case 'X':
extfunc = &class->ext_func[sym->global.value];
export_signature(extfunc->nparam, extfunc->nparam, extfunc->param, FALSE);
break;
default:
export_newline();
}
}
}
void CLASS_export(void)
{
FILE *fw = NULL;
FILE *fr;
char *line;
int len;
bool inserted = FALSE;
CLASS *class = JOB->class;
int cmp;
const char *msg;
if (chdir(FILE_get_dir(COMP_project)))
{
msg = "Cannot change directory";
goto __ERROR;
}
class_update_exported(class);
fr = fopen(".info", "r");
line = read_line(fr, &len);
for(;;)
{
if (!line)
cmp = 1;
else
cmp = strcmp(&line[1], class->name);
if (cmp == 0)
{
if (JOB->verbose)
printf("Remove '%s' information from .info file\n", class->name);
for(;;)
{
line = read_line(fr, &len);
if (!line || *line == '#')
break;
}
continue;
}
if (cmp > 0 && class->exported && !inserted)
{
create_file(&fw, ".info#");
insert_class_info(class, fw);
inserted = TRUE;
}
if (!line)
break;
// copying class information
if (JOB->verbose)
printf("Copy '%s' information in .info file\n", &line[1]);
for(;;)
{
create_file(&fw, ".info#");
fputs(line, fw);
fputc('\n', fw);
line = read_line(fr, NULL);
if (!line || *line == '#')
break;
}
}
if (fr)
fclose(fr);
close_file_and_rename(fw, ".info#", ".info");
return;
__ERROR:
THROW("Cannot create class information: &1: &2", msg, strerror(errno));
}